iwnc2020/ProjectDDD
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
dfb51d9c9f
ProjectDDD/Assets/Plugins/AllIn1SpriteShader/Shaders/LitShaders/AllIn1SpriteShaderLitTransparent_BetterShader_HDRP2022.txt

26359 lines
1.0 MiB
Plaintext
Raw Normal View History

all in 1 sprite 패키지 추가
2025-08-13 06:53:08 +00:00
////////////////////////////////////////
// Generated with Better Shaders
//
// Auto-generated shader code, don't hand edit!
//
// Unity Version: 2019.4.16f1
// Render Pipeline: HDRP2022
// Platform: WindowsEditor
////////////////////////////////////////
Shader "AllIn1SpriteShader/AllIn1SpriteShaderLitTransparent_BetterShader"
{
Properties
{
_MainTex ("Main Texture", 2D) = "white" {} //0
_Color("Main Color", Color) = (1,1,1,1) //1
_Alpha("General Alpha", Range(0,1)) = 1 //2
_GlowColor("Glow Color", Color) = (1,1,1,1) //3
_Glow("Glow Color Intensity", Range(0,100)) = 10 //4
_GlowGlobal("Global Glow Intensity", Range(1,100)) = 1 //5
[NoScaleOffset] _GlowTex("Glow Texture", 2D) = "white" {} //6
_FadeTex("Fade Texture", 2D) = "white" {} //7
_FadeAmount("Fade Amount", Range(-0.1,1)) = -0.1 //8
_FadeBurnWidth("Fade Burn Width", Range(0,1)) = 0.025 //9
_FadeBurnTransition("Burn Transition", Range(0.01,0.5)) = 0.075 //10
_FadeBurnColor("Fade Burn Color", Color) = (1,1,0,1) //11
_FadeBurnTex("Fade Burn Texture", 2D) = "white" {} //12
_FadeBurnGlow("Fade Burn Glow", Range(1,250)) = 2//13
_OutlineColor("Outline Base Color", Color) = (1,1,1,1) //14
_OutlineAlpha("Outline Base Alpha", Range(0,1)) = 1 //15
_OutlineGlow("Outline Base Glow", Range(1,100)) = 1.5 //16
_OutlineWidth("Outline Base Width", Range(0,0.2)) = 0.004 //17
_OutlinePixelWidth("Outline Base Pixel Width", Int) = 1 //18
[Space]
_OutlineTex("Outline Texture", 2D) = "white" {} //19
_OutlineTexXSpeed("Texture scroll speed X", Range(-50,50)) = 10 //20
_OutlineTexYSpeed("Texture scroll speed Y", Range(-50,50)) = 0 //21
[Space]
_OutlineDistortTex("Outline Distortion Texture", 2D) = "white" {} //22
_OutlineDistortAmount("Outline Distortion Amount", Range(0,2)) = 0.5 //23
_OutlineDistortTexXSpeed("Distortion scroll speed X", Range(-50,50)) = 5 //24
_OutlineDistortTexYSpeed("Distortion scroll speed Y", Range(-50,50)) = 5 //25
_AlphaOutlineColor("Color", Color) = (1, 1, 1, 1) //26
_AlphaOutlineGlow("Outline Glow", Range(1,100)) = 5 //27
_AlphaOutlinePower("Power", Range(0, 5)) = 1 // 28
_AlphaOutlineMinAlpha("Min Alpha", Range(0, 1)) = 0 // 29
_AlphaOutlineBlend("Blend", Range(0, 1)) = 1 // 30
_GradBlend("Gradient Blend", Range(0,1)) = 1 //31
_GradTopLeftCol("Top Color", Color) = (1,0,0,1) //32
_GradTopRightCol("Top Color 2", Color) = (1, 1, 0, 1) //33
_GradBotLeftCol("Bot Color", Color) = (0,0,1,1) //34
_GradBotRightCol("Bot Color 2", Color) = (0, 1, 0, 1) //35
[NoScaleOffset] _ColorSwapTex("Color Swap Texture", 2D) = "black" {} //36
[HDR] _ColorSwapRed("Red Channel", Color) = (1,1,1,1) //37
_ColorSwapRedLuminosity("Red luminosity", Range(-1,1)) = 0.5 //38
[HDR] _ColorSwapGreen("Green Channel", Color) = (1,1,1,1) //39
_ColorSwapGreenLuminosity("Green luminosity", Range(-1,1)) = 0.5 //40
[HDR] _ColorSwapBlue("Blue Channel", Color) = (1,1,1,1) //41
_ColorSwapBlueLuminosity("Blue luminosity", Range(-1,1)) = 0.5 //42
_HsvShift("Hue Shift", Range(0, 360)) = 180 //43
_HsvSaturation("Saturation", Range(0, 2)) = 1 //44
_HsvBright("Brightness", Range(0, 2)) = 1 //45
_HitEffectColor("Hit Effect Color", Color) = (1,1,1,1) //46
_HitEffectGlow("Glow Intensity", Range(1,100)) = 5 //47
[Space]
_HitEffectBlend("Hit Effect Blend", Range(0,1)) = 1 //48
_NegativeAmount("Negative Amount", Range(0, 1)) = 1 //49
_PixelateSize("Pixelate size", Range(4,512)) = 32 //50
[NoScaleOffset] _ColorRampTex("Color ramp Texture", 2D) = "white" {} //51
_ColorRampLuminosity("Color ramp luminosity", Range(-1,1)) = 0 //52
[Toggle()] _ColorRampOutline("Affects everything?", float) = 0 //53
_GreyscaleLuminosity("Greyscale luminosity", Range(-1,1)) = 0 //54
[Toggle()] _GreyscaleOutline("Affects everything?", float) = 0 //55
_GreyscaleTintColor("Greyscale Tint Color", Color) = (1,1,1,1) //56
_PosterizeNumColors("Number of Colors", Range(0,100)) = 8 //57
_PosterizeGamma("Posterize Amount", Range(0.1,10)) = 0.75 //58
[Toggle()] _PosterizeOutline("Affects everything?", float) = 0 //59
_BlurIntensity("Blur Intensity", Range(0,100)) = 10 //60
[Toggle()] _BlurHD("Blur is Low Res?", float) = 0 //61
_MotionBlurAngle("Motion Blur Angle", Range(-1, 1)) = 0.1 //62
_MotionBlurDist("Motion Blur Distance", Range(-3, 3)) = 1.25 //63
_GhostColorBoost("Ghost Color Boost", Range(0,5)) = 1 //64
_GhostTransparency("Ghost Transparency", Range(0,1)) = 0 //65
_InnerOutlineColor("Inner Outline Color", Color) = (1,0,0,1) //66
_InnerOutlineThickness("Outline Thickness", Range(0,3)) = 1 //67
_InnerOutlineAlpha("Inner Outline Alpha", Range(0,1)) = 1 //68
_InnerOutlineGlow("Inner Outline Glow", Range(1,250)) = 4 //69
_AlphaCutoffValue("Alpha cutoff value", Range(0, 1)) = 0.01 //70
[Toggle()] _OnlyOutline("Only render outline?", float) = 0 //71
[Toggle()] _OnlyInnerOutline("Only render inner outline?", float) = 0 //72
_HologramStripesAmount("Stripes Amount", Range(0, 1)) = 0.1 //73
_HologramUnmodAmount("Unchanged Amount", Range(0, 1)) = 0.0 //74
_HologramStripesSpeed("Stripes Speed", Range(-20, 20)) = 4.5 //75
_HologramMinAlpha("Min Alpha", Range(0, 1)) = 0.1 //76
_HologramMaxAlpha("Max Alpha", Range(0, 100)) = 0.75 //77
_ChromAberrAmount("ChromAberr Amount", Range(0, 1)) = 1 //78
_ChromAberrAlpha("ChromAberr Alpha", Range(0, 1)) = 0.4 //79
_GlitchAmount("Glitch Amount", Range(0, 20)) = 3 //80
_FlickerPercent("Flicker Percent", Range(0, 1)) = 0.05 //81
_FlickerFreq("Flicker Frequency", Range(0, 5)) = 0.2 //82
_FlickerAlpha("Flicker Alpha", Range(0, 1)) = 0 //83
_ShadowX("Shadow X Axis", Range(-0.5, 0.5)) = 0.1 //84
_ShadowY("Shadow Y Axis", Range(-0.5, 0.5)) = -0.05 //85
_ShadowAlpha("Shadow Alpha", Range(0, 1)) = 0.5 //86
_ShadowColor("Shadow Color", Color) = (0, 0, 0, 1) //87
_HandDrawnAmount("Hand Drawn Amount", Range(0, 20)) = 10 //88
_HandDrawnSpeed("Hand Drawn Speed", Range(1, 15)) = 5 //89
_GrassSpeed("Speed", Range(0,50)) = 2 //90
_GrassWind("Bend amount", Range(0,50)) = 20 //91
[Space]
[Toggle()] _GrassManualToggle("Manually animated?", float) = 0 //92
_GrassManualAnim("Manual Anim Value", Range(-1,1)) = 1 //93
_WaveAmount("Wave Amount", Range(0, 25)) = 7 //94
_WaveSpeed("Wave Speed", Range(0, 25)) = 10 //95
_WaveStrength("Wave Strength", Range(0, 25)) = 7.5 //96
_WaveX("Wave X Axis", Range(0, 1)) = 0 //97
_WaveY("Wave Y Axis", Range(0, 1)) = 0.5 //98
_RectSize("Rect Size", Range(1, 4)) = 1 //99
_OffsetUvX("X axis", Range(-1, 1)) = 0 //100
_OffsetUvY("Y axis", Range(-1, 1)) = 0 //101
_ClipUvLeft("Clipping Left", Range(0, 1)) = 0 //102
_ClipUvRight("Clipping Right", Range(0, 1)) = 0 //103
_ClipUvUp("Clipping Up", Range(0, 1)) = 0 //104
_ClipUvDown("Clipping Down", Range(0, 1)) = 0 //105
_TextureScrollXSpeed("Speed X Axis", Range(-5, 5)) = 1 //106
_TextureScrollYSpeed("Speed Y Axis", Range(-5, 5)) = 0 //107
_ZoomUvAmount("Zoom Amount", Range(0.1, 5)) = 0.5 //108
_DistortTex("Distortion Texture", 2D) = "white" {} //109
_DistortAmount("Distortion Amount", Range(0,2)) = 0.5 //110
_DistortTexXSpeed("Scroll speed X", Range(-50,50)) = 5 //111
_DistortTexYSpeed("Scroll speed Y", Range(-50,50)) = 5 //112
_TwistUvAmount("Twist Amount", Range(0, 3.1416)) = 1 //113
_TwistUvPosX("Twist Pos X Axis", Range(0, 1)) = 0.5 //114
_TwistUvPosY("Twist Pos Y Axis", Range(0, 1)) = 0.5 //115
_TwistUvRadius("Twist Radius", Range(0, 3)) = 0.75 //116
_RotateUvAmount("Rotate Angle(radians)", Range(0, 6.2831)) = 0 //117
_FishEyeUvAmount("Fish Eye Amount", Range(0, 0.5)) = 0.35 //118
_PinchUvAmount("Pinch Amount", Range(0, 0.5)) = 0.35 //119
_ShakeUvSpeed("Shake Speed", Range(0, 20)) = 2.5 //120
_ShakeUvX("X Multiplier", Range(0, 5)) = 1.5 //121
_ShakeUvY("Y Multiplier", Range(0, 5)) = 1 //122
_ColorChangeTolerance("Tolerance", Range(0, 1)) = 0.25 //123
_ColorChangeTarget("Color to change", Color) = (1, 0, 0, 1) //124
[HDR] _ColorChangeNewCol("New Color", Color) = (1, 1, 0, 1) //125
_ColorChangeLuminosity("New Color Luminosity", Range(0, 1)) = 0.0 //126
_RoundWaveStrength("Wave Strength", Range(0, 1)) = 0.7 //127
_RoundWaveSpeed("Wave Speed", Range(0, 5)) = 2 //128
[Toggle()] _BillboardY("Billboard on both axis?", float) = 0 //129
_ZWrite ("Depth Write", Float) = 1.0 // 130
_MySrcMode ("SrcMode", Float) = 5 // 131
_MyDstMode ("DstMode", Float) = 10 // 132
_ShineColor("Shine Color", Color) = (1,1,1,1) // 133
_ShineLocation("Shine Location", Range(0,1)) = 0.5 // 134
_ShineRotate("Rotate Angle(radians)", Range(0, 6.2831)) = 0 //135
_ShineWidth("Shine Width", Range(0.05,1)) = 0.1 // 136
_ShineGlow("Shine Glow", Range(0,100)) = 1 // 137
[NoScaleOffset] _ShineMask("Shine Mask", 2D) = "white" {} // 138
_GlitchSize("Glitch Size", Range(0.25, 5)) = 1 //139
_HologramStripeColor("Stripes Color", Color) = (0,1,1,1) //140
_GradBoostX("Boost X axis", Range(0.1, 5)) = 1.2 //141
_GradBoostY("Boost Y axis", Range(0.1, 5)) = 1.2 //142
[Toggle()] _GradIsRadial("Radial Gradient?", float) = 0 //143
_AlphaRoundThreshold("Round Threshold", Range(0.005, 1.0)) = 0.5 //144
_GrassRadialBend("Radial Bend", Range(0.0, 5.0)) = 0.1 //145
_ColorChangeTolerance2("Tolerance 2", Range(0, 1)) = 0.25 //146
_ColorChangeTarget2("Color to change 2", Color) = (1, 0, 0, 1) //147
[HDR] _ColorChangeNewCol2("New Color 2", Color) = (1, 1, 0, 1) //148
_ColorChangeTolerance3("Tolerance 3", Range(0, 1)) = 0.25 //149
_ColorChangeTarget3("Color to change 3", Color) = (1, 0, 0, 1) //150
[HDR] _ColorChangeNewCol3("New Color 3", Color) = (1, 1, 0, 1) //151
_Contrast ("Contrast", Range(0, 6)) = 1 // 152
_Brightness ("Brightness", Range(-1, 1)) = 0 // 153
_ColorSwapBlend ("Color Swap Blend", Range(0, 1)) = 1 // 154
_ColorRampBlend ("Color Ramp Blend", Range(0, 1)) = 1 // 155
_GreyscaleBlend ("Greyscale Blend", Range(0, 1)) = 1 // 156
_GhostBlend ("Ghost Blend", Range(0, 1)) = 1 // 157
_HologramBlend ("Hologram Blend", Range(0, 1)) = 1 // 158
[AllIn1ShaderGradient] _ColorRampTexGradient("Color ramp Gradient", 2D) = "white" {} //159
_OverlayTex("Overlay Texture", 2D) = "white" {} //160
_OverlayColor("Overlay Color", Color) = (1, 1, 1, 1) //161
_OverlayGlow("Overlay Glow", Range(0,25)) = 1 // 162
_OverlayBlend("Overlay Blend", Range(0, 1)) = 1 // 163
_RadialStartAngle("Radial Start Angle", Range(0, 360)) = 90 //164
_RadialClip("Radial Clip", Range(0, 360)) = 45 //165
_RadialClip2("Radial Clip 2", Range(0, 360)) = 0 //166
_WarpStrength("Warp Strength", Range(0, 0.1)) = 0.025 //167
_WarpSpeed("Warp Speed", Range(0, 25)) = 8 //168
_WarpScale("Warp Scale", Range(0.05, 3)) = 0.5 //169
_OverlayTextureScrollXSpeed("Speed X Axis", Range(-5, 5)) = 0.25 //170
_OverlayTextureScrollYSpeed("Speed Y Axis", Range(-5, 5)) = 0.25 //171
_ZTestMode ("Z Test Mode", Float) = 4
_CullingOption ("Culling Option", float) = 0
[HideInInspector] _MinXUV("_MinXUV", Range(0, 1)) = 0.0
[HideInInspector] _MaxXUV("_MaxXUV", Range(0, 1)) = 1.0
[HideInInspector] _MinYUV("_MinYUV", Range(0, 1)) = 0.0
[HideInInspector] _MaxYUV("_MaxYUV", Range(0, 1)) = 1.0
[HideInInspector] _RandomSeed("_MaxYUV", Range(0, 10000)) = 0.0
_EditorDrawers("Editor Drawers", Int) = 6
[Normal][NoScaleOffset] _NormalMap("Normal Map", 2D) = "bump" {}
_NormalStrength("Normal Strength", Range(0, 15)) = 1.0
[HideInInspector]_RenderQueueType("Float", Float) = 1
[HideInInspector][ToggleUI]_AddPrecomputedVelocity("Boolean", Float) = 0
[HideInInspector][ToggleUI]_DepthOffsetEnable("Boolean", Float) = 0
[HideInInspector][ToggleUI]_TransparentWritingMotionVec("Boolean", Float) = 0
[HideInInspector][ToggleUI]_AlphaCutoffEnable("Boolean", Float) = 0
[HideInInspector]_TransparentSortPriority("_TransparentSortPriority", Float) = 0
[HideInInspector][ToggleUI]_UseShadowThreshold("Boolean", Float) = 0
[HideInInspector][ToggleUI]_TransparentDepthPrepassEnable("Boolean", Float) = 0
[HideInInspector][ToggleUI]_TransparentDepthPostpassEnable("Boolean", Float) = 0
[HideInInspector]_SurfaceType("Float", Float) = 0
[HideInInspector]_BlendMode("Float", Float) = 0
[HideInInspector]_SrcBlend("Float", Float) = 1
[HideInInspector]_DstBlend("Float", Float) = 0
[HideInInspector]_AlphaSrcBlend("Float", Float) = 1
[HideInInspector]_AlphaDstBlend("Float", Float) = 0
[HideInInspector][ToggleUI]_AlphaToMask("Boolean", Float) = 0
[HideInInspector][ToggleUI]_AlphaToMaskInspectorValue("Boolean", Float) = 0
[HideInInspector][ToggleUI]_ZWrite("Boolean", Float) = 1
[HideInInspector][ToggleUI]_TransparentZWrite("Boolean", Float) = 0
[HideInInspector][ToggleUI]_EnableFogOnTransparent("Boolean", Float) = 1
[HideInInspector]_ZTestDepthEqualForOpaque("Float", Int) = 4
[HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)]_ZTestTransparent("Float", Float) = 4
[HideInInspector][ToggleUI]_TransparentBackfaceEnable("Boolean", Float) = 0
[HideInInspector][ToggleUI]_RequireSplitLighting("Boolean", Float) = 0
[HideInInspector][ToggleUI]_ReceivesSSR("Boolean", Float) = 1
[HideInInspector][ToggleUI]_ReceivesSSRTransparent("Boolean", Float) = 0
[HideInInspector][ToggleUI]_EnableBlendModePreserveSpecularLighting("Boolean", Float) = 1
[HideInInspector][ToggleUI]_SupportDecals("Boolean", Float) = 1
[HideInInspector]_StencilRef("Float", Int) = 0
[HideInInspector]_StencilWriteMask("Float", Int) = 6
[HideInInspector]_StencilRefDepth("Float", Int) = 8
[HideInInspector]_StencilWriteMaskDepth("Float", Int) = 8
[HideInInspector]_StencilRefMV("Float", Int) = 40
[HideInInspector]_StencilWriteMaskMV("Float", Int) = 40
[HideInInspector]_StencilRefDistortionVec("Float", Int) = 4
[HideInInspector]_StencilWriteMaskDistortionVec("Float", Int) = 4
[HideInInspector]_StencilWriteMaskGBuffer("Float", Int) = 14
[HideInInspector]_StencilRefGBuffer("Float", Int) = 10
[HideInInspector]_ZTestGBuffer("Float", Int) = 4
[HideInInspector][ToggleUI]_RayTracing("Boolean", Float) = 0
[HideInInspector][Enum(None, 0, Box, 1, Sphere, 2, Thin, 3)]_RefractionModel("Float", Float) = 0
[HideInInspector][NoScaleOffset]unity_Lightmaps("unity_Lightmaps", 2DArray) = "" {}
[HideInInspector][NoScaleOffset]unity_LightmapsInd("unity_LightmapsInd", 2DArray) = "" {}
[HideInInspector][NoScaleOffset]unity_ShadowMasks("unity_ShadowMasks", 2DArray) = "" {}
}
SubShader
{
Tags { "RenderPipeline" = "HDRenderPipeline" "RenderType" = "Transparent" "Queue" = "Transparent" }
Pass
{
// based on HDLitPass.template
Name "Forward"
Tags { "LightMode" = "Forward" }
Stencil
{
WriteMask [_StencilWriteMask]
Ref [_StencilRef]
CompFront Always
PassFront Replace
CompBack Always
PassBack Replace
}
ColorMask [_ColorMaskTransparentVel] 1
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma instancing_options renderinglayer
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
#pragma multi_compile_instancing
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
#pragma multi_compile _ DEBUG_DISPLAY
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
#pragma multi_compile _ LIGHTMAP_ON
#pragma multi_compile _ DIRLIGHTMAP_COMBINED
#pragma multi_compile_fragment PROBE_VOLUMES_OFF PROBE_VOLUMES_L1 PROBE_VOLUMES_L2
#pragma multi_compile_raytracing PROBE_VOLUMES_OFF PROBE_VOLUMES_L1 PROBE_VOLUMES_L2
#pragma multi_compile _ DYNAMICLIGHTMAP_ON
#pragma multi_compile_fragment _ SHADOWS_SHADOWMASK
#pragma multi_compile_raytracing _ SHADOWS_SHADOWMASK
#pragma multi_compile_fragment DECALS_OFF DECALS_3RT DECALS_4RT
#pragma multi_compile_fragment _ DECAL_SURFACE_GRADIENT
#pragma multi_compile_fragment SHADOW_LOW SHADOW_MEDIUM SHADOW_HIGH
#pragma multi_compile_fragment SCREEN_SPACE_SHADOWS_OFF SCREEN_SPACE_SHADOWS_ON
#pragma multi_compile_fragment USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
#pragma multi_compile_fragment AREA_SHADOW_MEDIUM AREA_SHADOW_HIGH
#pragma multi_compile _ LOD_FADE_CROSSFADE
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
//-------------------------------------------------------------------------------------
// Variant Definitions (active field translations to HDRP defines)
//-------------------------------------------------------------------------------------
// #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
// #define _MATERIAL_FEATURE_TRANSMISSION 1
// #define _MATERIAL_FEATURE_ANISOTROPY 1
// #define _MATERIAL_FEATURE_IRIDESCENCE 1
// #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
#define _ENABLE_FOG_ON_TRANSPARENT 1
// #define _AMBIENT_OCCLUSION 1
// #define _SPECULAR_OCCLUSION_FROM_AO 1
// #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1
// #define _SPECULAR_OCCLUSION_CUSTOM 1
// #define _ENERGY_CONSERVING_SPECULAR 1
// #define _ENABLE_GEOMETRIC_SPECULAR_AA 1
// #define _HAS_REFRACTION 1
// #define _REFRACTION_PLANE 1
// #define _REFRACTION_SPHERE 1
// #define _DISABLE_DECALS 1
// #define _DISABLE_SSR 1
// #define _ADD_PRECOMPUTED_VELOCITY
// #define _WRITE_TRANSPARENT_MOTION_VECTOR 1
// #define _DEPTHOFFSET_ON 1
// #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1
#define SHADERPASS SHADERPASS_FORWARD
#define SUPPORT_BLENDMODE_PRESERVE_SPECULAR_LIGHTING
#define HAS_LIGHTLOOP
#define RAYTRACING_SHADER_GRAPH_DEFAULT
#define _PASSFORWARD 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
#ifdef UNITY_VIRTUAL_TEXTURING
#define VT_BUFFER_TARGET SV_Target1
#define EXTRA_BUFFER_TARGET SV_Target2
#else
#define EXTRA_BUFFER_TARGET SV_Target1
#endif
void Frag(VertexToPixel v2p,
#ifdef OUTPUT_SPLIT_LIGHTING
out float4 outColor : SV_Target0, // outSpecularLighting
#ifdef UNITY_VIRTUAL_TEXTURING
out float4 outVTFeedback : VT_BUFFER_TARGET,
#endif
out float4 outDiffuseLighting : EXTRA_BUFFER_TARGET,
OUTPUT_SSSBUFFER(outSSSBuffer)
#else
out float4 outColor : SV_Target0
#ifdef UNITY_VIRTUAL_TEXTURING
,out float4 outVTFeedback : VT_BUFFER_TARGET
#endif
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
, out float4 outMotionVec : EXTRA_BUFFER_TARGET
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
#endif // OUTPUT_SPLIT_LIGHTING
#ifdef _DEPTHOFFSET_ON
, out float outputDepth : SV_Depth
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
// Init outMotionVector here to solve compiler warning (potentially unitialized variable)
// It is init to the value of forceNoMotion (with 2.0)
outMotionVec = float4(2.0, 0.0, 0.0, 0.0);
#endif
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(v2p);
FragInputs input = BuildFragInputs(v2p);
// We need to readapt the SS position as our screen space positions are for a low res buffer, but we try to access a full res buffer.
input.positionSS.xy = _OffScreenRendering > 0 ? (input.positionSS.xy * _OffScreenDownsampleFactor) : input.positionSS.xy;
uint2 tileIndex = uint2(input.positionSS.xy) / GetTileSize();
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS.xyz, tileIndex);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2p, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
BSDFData bsdfData = ConvertSurfaceDataToBSDFData(input.positionSS.xy, surfaceData);
PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
outColor = float4(0.0, 0.0, 0.0, 0.0);
// We need to skip lighting when doing debug pass because the debug pass is done before lighting so some buffers may not be properly initialized potentially causing crashes on PS4.
#ifdef DEBUG_DISPLAY
// Init in debug display mode to quiet warning
#ifdef OUTPUT_SPLIT_LIGHTING
outDiffuseLighting = 0;
ENCODE_INTO_SSSBUFFER(surfaceData, posInput.positionSS, outSSSBuffer);
#endif
// Same code in ShaderPassForwardUnlit.shader
// Reminder: _DebugViewMaterialArray[i]
// i==0 -> the size used in the buffer
// i>0 -> the index used (0 value means nothing)
// The index stored in this buffer could either be
// - a gBufferIndex (always stored in _DebugViewMaterialArray[1] as only one supported)
// - a property index which is different for each kind of material even if reflecting the same thing (see MaterialSharedProperty)
bool viewMaterial = false;
int bufferSize = _DebugViewMaterialArray[0].x;
if (bufferSize != 0)
{
bool needLinearToSRGB = false;
float3 result = float3(1.0, 0.0, 1.0);
// Loop through the whole buffer
// Works because GetSurfaceDataDebug will do nothing if the index is not a known one
for (int index = 1; index <= bufferSize; index++)
{
int indexMaterialProperty = _DebugViewMaterialArray[index].x;
// skip if not really in use
if (indexMaterialProperty != 0)
{
viewMaterial = true;
GetPropertiesDataDebug(indexMaterialProperty, result, needLinearToSRGB);
GetVaryingsDataDebug(indexMaterialProperty, input, result, needLinearToSRGB);
GetBuiltinDataDebug(indexMaterialProperty, builtinData, posInput, result, needLinearToSRGB);
GetSurfaceDataDebug(indexMaterialProperty, surfaceData, result, needLinearToSRGB);
GetBSDFDataDebug(indexMaterialProperty, bsdfData, result, needLinearToSRGB);
}
}
// TEMP!
// For now, the final blit in the backbuffer performs an sRGB write
// So in the meantime we apply the inverse transform to linear data to compensate.
if (!needLinearToSRGB)
result = SRGBToLinear(max(0, result));
outColor = float4(result, 1.0);
}
if (!viewMaterial)
{
if (_DebugFullScreenMode == FULLSCREENDEBUGMODE_VALIDATE_DIFFUSE_COLOR || _DebugFullScreenMode == FULLSCREENDEBUGMODE_VALIDATE_SPECULAR_COLOR)
{
float3 result = float3(0.0, 0.0, 0.0);
GetPBRValidatorDebug(surfaceData, result);
outColor = float4(result, 1.0f);
}
else if (_DebugFullScreenMode == FULLSCREENDEBUGMODE_TRANSPARENCY_OVERDRAW)
{
float4 result = _DebugTransparencyOverdrawWeight * float4(TRANSPARENCY_OVERDRAW_COST, TRANSPARENCY_OVERDRAW_COST, TRANSPARENCY_OVERDRAW_COST, TRANSPARENCY_OVERDRAW_A);
outColor = result;
}
else
#endif
{
#ifdef _SURFACE_TYPE_TRANSPARENT
uint featureFlags = LIGHT_FEATURE_MASK_FLAGS_TRANSPARENT;
#else
uint featureFlags = LIGHT_FEATURE_MASK_FLAGS_OPAQUE;
#endif
LightLoopOutput lightLoopOutput;
LightLoop(V, posInput, preLightData, bsdfData, builtinData, featureFlags, lightLoopOutput);
float3 diffuseLighting = lightLoopOutput.diffuseLighting;
float3 specularLighting = lightLoopOutput.specularLighting;
diffuseLighting *= GetCurrentExposureMultiplier();
specularLighting *= GetCurrentExposureMultiplier();
#ifdef OUTPUT_SPLIT_LIGHTING
if (_EnableSubsurfaceScattering != 0 && ShouldOutputSplitLighting(bsdfData))
{
outColor = float4(specularLighting, 1.0);
outDiffuseLighting = float4(TagLightingForSSS(diffuseLighting), 1.0);
}
else
{
outColor = float4(diffuseLighting + specularLighting, 1.0);
outDiffuseLighting = 0;
}
ENCODE_INTO_SSSBUFFER(surfaceData, posInput.positionSS, outSSSBuffer);
#else
outColor = ApplyBlendMode(diffuseLighting, specularLighting, builtinData.opacity);
outColor = EvaluateAtmosphericScattering(posInput, V, outColor);
#endif
ChainFinalColorForward(l, d, outColor);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
bool forceNoMotion = any(unity_MotionVectorsParams.yw == 0.0);
// outMotionVec is already initialize at the value of forceNoMotion (see above)
if (!forceNoMotion)
{
float2 motionVec = CalculateMotionVector(v2p.motionVectorCS, v2p.previousPositionCS);
EncodeMotionVector(motionVec * 0.5, outMotionVec);
outMotionVec.zw = 1.0;
}
#endif
}
#ifdef DEBUG_DISPLAY
}
#endif
#ifdef _DEPTHOFFSET_ON
outputDepth = l.outputDepth;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
outVTFeedback = builtinData.vtPackedFeedback;
#endif
}
ENDHLSL
}
Pass
{
// based on HDLitPass.template
Name "GBuffer"
Tags { "LightMode" = "GBuffer" }
//-------------------------------------------------------------------------------------
// Render Modes (Blend, Cull, ZTest, Stencil, etc)
//-------------------------------------------------------------------------------------
Cull Back
ZTest [_ZTestGBuffer]
ColorMask [_LightLayersMaskBuffer4] 4
ColorMask [_LightLayersMaskBuffer5] 5
Stencil
{
WriteMask [_StencilWriteMaskGBuffer]
Ref [_StencilRefGBuffer]
CompFront Always
PassFront Replace
CompBack Always
PassBack Replace
}
ColorMask [_LightLayersMaskBuffer4] 4
ColorMask [_LightLayersMaskBuffer5] 5
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma instancing_options renderinglayer
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
#pragma multi_compile_instancing
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma multi_compile _ LOD_FADE_CROSSFADE
#pragma multi_compile _ LIGHT_LAYERS
//#pragma multi_compile_raytracing _ LIGHT_LAYERS
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
#pragma multi_compile _ DEBUG_DISPLAY
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
#pragma multi_compile _ LIGHTMAP_ON
#pragma multi_compile _ DIRLIGHTMAP_COMBINED
#pragma multi_compile_fragment PROBE_VOLUMES_OFF PROBE_VOLUMES_L1 PROBE_VOLUMES_L2
#pragma multi_compile _ DYNAMICLIGHTMAP_ON
#pragma multi_compile_fragment _ SHADOWS_SHADOWMASK
#pragma multi_compile_fragment DECALS_OFF DECALS_3RT DECALS_4RT
#pragma multi_compile_fragment _ DECAL_SURFACE_GRADIENT
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
//-------------------------------------------------------------------------------------
// Variant Definitions (active field translations to HDRP defines)
//-------------------------------------------------------------------------------------
// #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
// #define _MATERIAL_FEATURE_TRANSMISSION 1
// #define _MATERIAL_FEATURE_ANISOTROPY 1
// #define _MATERIAL_FEATURE_IRIDESCENCE 1
// #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
#define _ENABLE_FOG_ON_TRANSPARENT 1
// #define _AMBIENT_OCCLUSION 1
// #define _SPECULAR_OCCLUSION_FROM_AO 1
// #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1
// #define _SPECULAR_OCCLUSION_CUSTOM 1
// #define _ENERGY_CONSERVING_SPECULAR 1
// #define _ENABLE_GEOMETRIC_SPECULAR_AA 1
// #define _HAS_REFRACTION 1
// #define _REFRACTION_PLANE 1
// #define _REFRACTION_SPHERE 1
// #define _DISABLE_DECALS 1
// #define _DISABLE_SSR 1
// #define _ADD_PRECOMPUTED_VELOCITY
// #define _WRITE_TRANSPARENT_MOTION_VECTOR 1
// #define _DEPTHOFFSET_ON 1
// #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1
#define SHADERPASS SHADERPASS_GBUFFER
#define RAYTRACING_SHADER_GRAPH_DEFAULT
#define _PASSGBUFFER 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
//-------------------------------------------------------------------------------------
// Defines
//-------------------------------------------------------------------------------------
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
void Frag( VertexToPixel v2f,
OUTPUT_GBUFFER(outGBuffer)
#ifdef _DEPTHOFFSET_ON
, out float outputDepth : SV_Depth
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(v2f);
FragInputs input = BuildFragInputs(v2f);
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2f, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
ENCODE_INTO_GBUFFER(surfaceData, builtinData, posInput.positionSS, outGBuffer);
#ifdef _DEPTHOFFSET_ON
outputDepth = l.outputDepth;
#endif
}
ENDHLSL
}
Pass
{
// based on HDLitPass.template
Name "ShadowCaster"
Tags { "LightMode" = "ShadowCaster" }
//-------------------------------------------------------------------------------------
// Render Modes (Blend, Cull, ZTest, Stencil, etc)
//-------------------------------------------------------------------------------------
Cull Back
ZWrite On
ColorMask 0
ZClip [_ZClip]
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
//#pragma enable_d3d11_debug_symbols
#pragma multi_compile_instancing
#pragma instancing_options renderinglayer
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma multi_compile _ LOD_FADE_CROSSFADE
//#pragma multi_compile_local _ _ALPHATEST_ON
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
#pragma multi_compile _ WRITE_DECAL_BUFFER
//-------------------------------------------------------------------------------------
// Variant Definitions (active field translations to HDRP defines)
//-------------------------------------------------------------------------------------
// #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
// #define _MATERIAL_FEATURE_TRANSMISSION 1
// #define _MATERIAL_FEATURE_ANISOTROPY 1
// #define _MATERIAL_FEATURE_IRIDESCENCE 1
// #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
#define _ENABLE_FOG_ON_TRANSPARENT 1
// #define _AMBIENT_OCCLUSION 1
// #define _SPECULAR_OCCLUSION_FROM_AO 1
// #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1
// #define _SPECULAR_OCCLUSION_CUSTOM 1
// #define _ENERGY_CONSERVING_SPECULAR 1
// #define _ENABLE_GEOMETRIC_SPECULAR_AA 1
// #define _HAS_REFRACTION 1
// #define _REFRACTION_PLANE 1
// #define _REFRACTION_SPHERE 1
// #define _DISABLE_DECALS 1
// #define _DISABLE_SSR 1
// #define _ADD_PRECOMPUTED_VELOCITY
// #define _WRITE_TRANSPARENT_MOTION_VECTOR 1
// #define _DEPTHOFFSET_ON 1
// #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1
#define SHADERPASS SHADERPASS_SHADOWS
#define _PASSSHADOW 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
//-------------------------------------------------------------------------------------
// Defines
//-------------------------------------------------------------------------------------
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
#if defined(WRITE_NORMAL_BUFFER) && defined(WRITE_MSAA_DEPTH)
#define SV_TARGET_DECAL SV_Target2
#elif defined(WRITE_NORMAL_BUFFER) || defined(WRITE_MSAA_DEPTH)
#define SV_TARGET_DECAL SV_Target1
#else
#define SV_TARGET_DECAL SV_Target0
#endif
void Frag( VertexToPixel v2f
#if defined(SCENESELECTIONPASS) || defined(SCENEPICKINGPASS)
, out float4 outColor : SV_Target0
#else
#ifdef WRITE_MSAA_DEPTH
// We need the depth color as SV_Target0 for alpha to coverage
, out float4 depthColor : SV_Target0
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target1
#endif
#else
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target0
#endif
#endif
// Decal buffer must be last as it is bind but we can optionally write into it (based on _DISABLE_DECALS)
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
, out float4 outDecalBuffer : SV_TARGET_DECAL
#endif
#endif
#if defined(_DEPTHOFFSET_ON) && !defined(SCENEPICKINGPASS)
, out float outputDepth : SV_Depth
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(v2f);
FragInputs input = BuildFragInputs(v2f);
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2f, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
#ifdef _DEPTHOFFSET_ON
outputDepth = l.outputDepth;
#endif
#ifdef SCENESELECTIONPASS
// We use depth prepass for scene selection in the editor, this code allow to output the outline correctly
outColor = float4(_ObjectId, _PassValue, 1.0, 1.0);
#elif defined(SCENEPICKINGPASS)
outColor = _SelectionID;
#else
#ifdef WRITE_MSAA_DEPTH
// In case we are rendering in MSAA, reading the an MSAA depth buffer is way too expensive. To avoid that, we export the depth to a color buffer
depthColor = v2f.pos.z;
#ifdef _ALPHATOMASK_ON
// Alpha channel is used for alpha to coverage
depthColor.a = SharpenAlpha(builtinData.opacity, builtinData.alphaClipTreshold);
#endif // alphatomask
#endif // msaa_depth
#endif
#if defined(WRITE_NORMAL_BUFFER)
EncodeIntoNormalBuffer(ConvertSurfaceDataToNormalData(surfaceData), outNormalBuffer);
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
DecalPrepassData decalPrepassData;
// We don't have the right to access SurfaceData in a shaderpass.
// However it would be painful to have to add a function like ConvertSurfaceDataToDecalPrepassData() to every Material to return geomNormalWS anyway
// Here we will put the constrain that any Material requiring to support Decal, will need to have geomNormalWS as member of surfaceData (and we already require normalWS anyway)
decalPrepassData.geomNormalWS = surfaceData.geomNormalWS;
decalPrepassData.decalLayerMask = GetMeshRenderingDecalLayer();
EncodeIntoDecalPrepassBuffer(decalPrepassData, outDecalBuffer);
#endif
}
ENDHLSL
}
Pass
{
// based on HDLitPass.template
Name "DepthOnly"
Tags { "LightMode" = "DepthOnly" }
//-------------------------------------------------------------------------------------
// Render Modes (Blend, Cull, ZTest, Stencil, etc)
//-------------------------------------------------------------------------------------
Cull Back
ZWrite On
// Stencil setup
Stencil
{
WriteMask [_StencilWriteMaskDepth]
Ref [_StencilRefDepth]
CompFront Always
PassFront Replace
CompBack Always
PassBack Replace
}
AlphaToMask [_AlphaCutoffEnable]
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
//#pragma enable_d3d11_debug_symbols
#pragma multi_compile_instancing
#pragma instancing_options renderinglayer
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma multi_compile _ LOD_FADE_CROSSFADE
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
#pragma multi_compile _ WRITE_DECAL_BUFFER
//-------------------------------------------------------------------------------------
// Variant Definitions (active field translations to HDRP defines)
//-------------------------------------------------------------------------------------
// #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
// #define _MATERIAL_FEATURE_TRANSMISSION 1
// #define _MATERIAL_FEATURE_ANISOTROPY 1
// #define _MATERIAL_FEATURE_IRIDESCENCE 1
// #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
#define _ENABLE_FOG_ON_TRANSPARENT 1
// #define _AMBIENT_OCCLUSION 1
// #define _SPECULAR_OCCLUSION_FROM_AO 1
// #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1
// #define _SPECULAR_OCCLUSION_CUSTOM 1
// #define _ENERGY_CONSERVING_SPECULAR 1
// #define _ENABLE_GEOMETRIC_SPECULAR_AA 1
// #define _HAS_REFRACTION 1
// #define _REFRACTION_PLANE 1
// #define _REFRACTION_SPHERE 1
// #define _DISABLE_DECALS 1
// #define _DISABLE_SSR 1
// #define _ADD_PRECOMPUTED_VELOCITY
// #define _WRITE_TRANSPARENT_MOTION_VECTOR 1
// #define _DEPTHOFFSET_ON 1
// #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1
#define SHADERPASS SHADERPASS_DEPTH_ONLY
#pragma multi_compile _ WRITE_NORMAL_BUFFER
#pragma multi_compile _ WRITE_MSAA_DEPTH
#define _PASSDEPTH 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
#if defined(WRITE_NORMAL_BUFFER) && defined(WRITE_MSAA_DEPTH)
#define SV_TARGET_DECAL SV_Target2
#elif defined(WRITE_NORMAL_BUFFER) || defined(WRITE_MSAA_DEPTH)
#define SV_TARGET_DECAL SV_Target1
#else
#define SV_TARGET_DECAL SV_Target0
#endif
void Frag( VertexToPixel v2p
#if defined(SCENESELECTIONPASS) || defined(SCENEPICKINGPASS)
, out float4 outColor : SV_Target0
#else
#ifdef WRITE_MSAA_DEPTH
// We need the depth color as SV_Target0 for alpha to coverage
, out float4 depthColor : SV_Target0
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target1
#endif
#else
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target0
#endif
#endif
// Decal buffer must be last as it is bind but we can optionally write into it (based on _DISABLE_DECALS)
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
, out float4 outDecalBuffer : SV_TARGET_DECAL
#endif
#endif
#if defined(_DEPTHOFFSET_ON) && !defined(SCENEPICKINGPASS)
, out float outputDepth : DEPTH_OFFSET_SEMANTIC
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(v2p);
FragInputs input = BuildFragInputs(v2p);
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2p, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
// to prevent stripping
surfaceData.normalWS *= saturate(l.Albedo.r + 9999);
#ifdef _DEPTHOFFSET_ON
outputDepth = l.outputDepth;
#endif
#ifdef SCENESELECTIONPASS
// We use depth prepass for scene selection in the editor, this code allow to output the outline correctly
outColor = float4(_ObjectId, _PassValue, 1.0, 1.0);
#elif defined(SCENEPICKINGPASS)
outColor = unity_SelectionID;
#else
#ifdef WRITE_MSAA_DEPTH
// In case we are rendering in MSAA, reading the an MSAA depth buffer is way too expensive. To avoid that, we export the depth to a color buffer
depthColor = v2p.pos.z;
#ifdef _ALPHATOMASK_ON
// Alpha channel is used for alpha to coverage
depthColor.a = SharpenAlpha(builtinData.opacity, builtinData.alphaClipTreshold);
#endif // alphatomask
#endif // msaa_depth
#if defined(WRITE_NORMAL_BUFFER)
EncodeIntoNormalBuffer(ConvertSurfaceDataToNormalData(surfaceData), outNormalBuffer);
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
DecalPrepassData decalPrepassData;
// We don't have the right to access SurfaceData in a shaderpass.
// However it would be painful to have to add a function like ConvertSurfaceDataToDecalPrepassData() to every Material to return geomNormalWS anyway
// Here we will put the constrain that any Material requiring to support Decal, will need to have geomNormalWS as member of surfaceData (and we already require normalWS anyway)
decalPrepassData.geomNormalWS = surfaceData.geomNormalWS;
decalPrepassData.decalLayerMask = GetMeshRenderingDecalLayer();
EncodeIntoDecalPrepassBuffer(decalPrepassData, outDecalBuffer);
#endif
#endif
}
ENDHLSL
}
Pass
{
// based on HDLitPass.template
Name "META"
Tags { "LightMode" = "META" }
Cull Off
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
#pragma multi_compile_instancing
//#pragma multi_compile_local _ _ALPHATEST_ON
//-------------------------------------------------------------------------------------
// Variant Definitions (active field translations to HDRP defines)
//-------------------------------------------------------------------------------------
// #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
// #define _MATERIAL_FEATURE_TRANSMISSION 1
// #define _MATERIAL_FEATURE_ANISOTROPY 1
// #define _MATERIAL_FEATURE_IRIDESCENCE 1
// #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
#define _ENABLE_FOG_ON_TRANSPARENT 1
// #define _AMBIENT_OCCLUSION 1
// #define _SPECULAR_OCCLUSION_FROM_AO 1
// #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1
// #define _SPECULAR_OCCLUSION_CUSTOM 1
// #define _ENERGY_CONSERVING_SPECULAR 1
// #define _ENABLE_GEOMETRIC_SPECULAR_AA 1
// #define _HAS_REFRACTION 1
// #define _REFRACTION_PLANE 1
// #define _REFRACTION_SPHERE 1
// #define _DISABLE_DECALS 1
// #define _DISABLE_SSR 1
// #define _ADD_PRECOMPUTED_VELOCITY
// #define _WRITE_TRANSPARENT_MOTION_VECTOR 1
// #define _DEPTHOFFSET_ON 1
// #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1
#define SHADERPASS SHADERPASS_LIGHT_TRANSPORT
#define RAYTRACING_SHADER_GRAPH_HIGH
#define REQUIRE_DEPTH_TEXTURE
#define _PASSMETA 1
#pragma multi_compile _ LOD_FADE_CROSSFADE
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
float4 Frag(VertexToPixel v2f
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
) : SV_Target
{
FragInputs input = BuildFragInputs(v2f);
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2f, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
// no debug apply during light transport pass
BSDFData bsdfData = ConvertSurfaceDataToBSDFData(input.positionSS.xy, surfaceData);
LightTransportData lightTransportData = GetLightTransportData(surfaceData, builtinData, bsdfData);
// This shader is call two times. Once for getting emissiveColor, the other time to get diffuseColor
// We use unity_MetaFragmentControl to make the distinction.
float4 res = float4(0.0, 0.0, 0.0, 1.0);
if (unity_MetaFragmentControl.x)
{
// Apply diffuseColor Boost from LightmapSettings.
// put abs here to silent a warning, no cost, no impact as color is assume to be positive.
res.rgb = clamp(pow(abs(lightTransportData.diffuseColor), saturate(unity_OneOverOutputBoost)), 0, unity_MaxOutputValue);
}
if (unity_MetaFragmentControl.y)
{
// emissive use HDR format
res.rgb = lightTransportData.emissiveColor;
}
return res;
}
ENDHLSL
}
Pass
{
// based on HDLitPass.template
Name "SceneSelectionPass"
Tags { "LightMode" = "SceneSelectionPass" }
Cull Off
ColorMask 0
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
#pragma multi_compile_instancing
#pragma editor_sync_compilation
#pragma instancing_options renderinglayer
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
//-------------------------------------------------------------------------------------
// Variant Definitions (active field translations to HDRP defines)
//-------------------------------------------------------------------------------------
// #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
// #define _MATERIAL_FEATURE_TRANSMISSION 1
// #define _MATERIAL_FEATURE_ANISOTROPY 1
// #define _MATERIAL_FEATURE_IRIDESCENCE 1
// #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
#define _ENABLE_FOG_ON_TRANSPARENT 1
// #define _AMBIENT_OCCLUSION 1
// #define _SPECULAR_OCCLUSION_FROM_AO 1
// #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1
// #define _SPECULAR_OCCLUSION_CUSTOM 1
// #define _ENERGY_CONSERVING_SPECULAR 1
// #define _ENABLE_GEOMETRIC_SPECULAR_AA 1
// #define _HAS_REFRACTION 1
// #define _REFRACTION_PLANE 1
// #define _REFRACTION_SPHERE 1
// #define _DISABLE_DECALS 1
// #define _DISABLE_SSR 1
// #define _ADD_PRECOMPUTED_VELOCITY
// #define _WRITE_TRANSPARENT_MOTION_VECTOR 1
// #define _DEPTHOFFSET_ON 1
// #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1
#define SHADERPASS SHADERPASS_DEPTH_ONLY
#define RAYTRACING_SHADER_GRAPH_DEFAULT
#define SCENESELECTIONPASS
#define _PASSSCENESELECT 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
void Frag( VertexToPixel IN
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target0
#ifdef WRITE_MSAA_DEPTH
, out float1 depthColor : SV_Target1
#endif
#elif defined(WRITE_MSAA_DEPTH) // When only WRITE_MSAA_DEPTH is define and not WRITE_NORMAL_BUFFER it mean we are Unlit and only need depth, but we still have normal buffer binded
, out float4 outNormalBuffer : SV_Target0
, out float1 depthColor : SV_Target1
#elif defined(SCENESELECTIONPASS)
, out float4 outColor : SV_Target0
#endif
#ifdef _DEPTHOFFSET_ON
, out float outputDepth : SV_Depth
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(IN);
FragInputs input = BuildFragInputs(IN);
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(IN, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
#ifdef _DEPTHOFFSET_ON
outputDepth = l.outputDepth;
#endif
#ifdef WRITE_NORMAL_BUFFER
EncodeIntoNormalBuffer(ConvertSurfaceDataToNormalData(surfaceData), posInput.positionSS, outNormalBuffer);
#ifdef WRITE_MSAA_DEPTH
// In case we are rendering in MSAA, reading the an MSAA depth buffer is way too expensive. To avoid that, we export the depth to a color buffer
depthColor = v2f.pos.z;
#endif
#elif defined(WRITE_MSAA_DEPTH) // When we are MSAA depth only without normal buffer
// Due to the binding order of these two render targets, we need to have them both declared
outNormalBuffer = float4(0.0, 0.0, 0.0, 1.0);
// In case we are rendering in MSAA, reading the an MSAA depth buffer is way too expensive. To avoid that, we export the depth to a color buffer
depthColor = v2f.pos.z;
#elif defined(SCENESELECTIONPASS)
// We use depth prepass for scene selection in the editor, this code allow to output the outline correctly
outColor = float4(_ObjectId, _PassValue, 1.0, 1.0);
#endif
}
ENDHLSL
}
Pass
{
Name "ScenePickingPass"
Tags
{
"LightMode" = "Picking"
}
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
#pragma multi_compile_instancing
#pragma editor_sync_compilation
#pragma instancing_options renderinglayer
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
#pragma multi_compile _ WRITE_DECAL_BUFFER
#pragma multi_compile _ LOD_FADE_CROSSFADE
#define SHADERPASS SHADERPASS_DEPTH_ONLY
#define SCENEPICKINGPASS
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/PickingSpaceTransforms.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
void Frag( VertexToPixel v2f
#if defined(SCENESELECTIONPASS) || defined(SCENEPICKINGPASS)
, out float4 outColor : SV_Target0
#else
#ifdef WRITE_MSAA_DEPTH
// We need the depth color as SV_Target0 for alpha to coverage
, out float4 depthColor : SV_Target0
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target1
#endif
#else
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_Target0
#endif
#endif
// Decal buffer must be last as it is bind but we can optionally write into it (based on _DISABLE_DECALS)
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
, out float4 outDecalBuffer : SV_TARGET_DECAL
#endif
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(v2f);
FragInputs input = BuildFragInputs(v2f);
// input.positionSS is SV_Position
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2f, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
#ifdef SCENESELECTIONPASS
// We use depth prepass for scene selection in the editor, this code allow to output the outline correctly
outColor = float4(_ObjectId, _PassValue, 1.0, 1.0);
#elif defined(SCENEPICKINGPASS)
outColor = _SelectionID;
#else
#ifdef WRITE_MSAA_DEPTH
// In case we are rendering in MSAA, reading the an MSAA depth buffer is way too expensive. To avoid that, we export the depth to a color buffer
depthColor = v2p.pos.z;
#ifdef _ALPHATOMASK_ON
// Alpha channel is used for alpha to coverage
depthColor.a = SharpenAlpha(builtinData.opacity, builtinData.alphaClipTreshold);
#endif // alphatomask
#endif // msaa_depth
#if defined(WRITE_NORMAL_BUFFER)
EncodeIntoNormalBuffer(ConvertSurfaceDataToNormalData(surfaceData), outNormalBuffer);
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
DecalPrepassData decalPrepassData;
// We don't have the right to access SurfaceData in a shaderpass.
// However it would be painful to have to add a function like ConvertSurfaceDataToDecalPrepassData() to every Material to return geomNormalWS anyway
// Here we will put the constrain that any Material requiring to support Decal, will need to have geomNormalWS as member of surfaceData (and we already require normalWS anyway)
decalPrepassData.geomNormalWS = surfaceData.geomNormalWS;
decalPrepassData.decalLayerMask = GetMeshRenderingDecalLayer();
EncodeIntoDecalPrepassBuffer(decalPrepassData, outDecalBuffer);
#endif
#endif
}
ENDHLSL
}
Pass
{
Name "MotionVectors"
Tags
{
"LightMode" = "MotionVectors"
}
// Render State
Cull Back
ZWrite On
Stencil
{
WriteMask [_StencilWriteMaskMV]
Ref [_StencilRefMV]
CompFront Always
PassFront Replace
CompBack Always
PassBack Replace
}
Tags { "RenderType" = "Transparent" "Queue" = "Transparent" "PreviewType" = "Plane" }
Cull [_CullingOption]
ZWrite [_ZWrite]
ZTest [_ZTestMode]
Blend SrcAlpha OneMinusSrcAlpha
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
#pragma multi_compile_instancing
#pragma multi_compile _ DOTS_INSTANCING_ON
#pragma instancing_options renderinglayer
#pragma multi_compile _ LOD_FADE_CROSSFADE
#pragma multi_compile _ WRITE_MSAA_DEPTH
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
#pragma multi_compile _ WRITE_NORMAL_BUFFER
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
#pragma multi_compile _ WRITE_DECAL_BUFFER
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
#define SHADERPASS SHADERPASS_MOTION_VECTORS
#define RAYTRACING_SHADER_GRAPH_DEFAULT
#define VARYINGS_NEED_PASS
#define _PASSMOTIONVECTOR 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
#if defined(WRITE_DECAL_BUFFER) && defined(WRITE_MSAA_DEPTH)
#define SV_TARGET_NORMAL SV_Target3
#elif defined(WRITE_DECAL_BUFFER) || defined(WRITE_MSAA_DEPTH)
#define SV_TARGET_NORMAL SV_Target2
#else
#define SV_TARGET_NORMAL SV_Target1
#endif
// Caution: Motion vector pass is different from Depth prepass, it render normal buffer last instead of decal buffer last
// and thus, we force a write of 0 if _DISABLE_DECALS so we always write in the decal buffer.
// This is required as we can't make distinction between deferred (write normal buffer) and forward (write normal buffer)
// in the context of the motion vector pass. The cost is acceptable as it is only do object with motion vector (usualy skin object)
// that most of the time use Forward Material (so are already writing motion vector data).
// So note that here unlike for depth prepass we don't check && !defined(_DISABLE_DECALS)
void Frag( VertexToPixel v2f
#ifdef WRITE_MSAA_DEPTH
// We need the depth color as SV_Target0 for alpha to coverage
, out float4 depthColor : SV_Target0
, out float4 outMotionVector : SV_Target1
#ifdef WRITE_DECAL_BUFFER
, out float4 outDecalBuffer : SV_Target2
#endif
#else
// When no MSAA, the motion vector is always the first buffer
, out float4 outMotionVector : SV_Target0
#ifdef WRITE_DECAL_BUFFER
, out float4 outDecalBuffer : SV_Target1
#endif
#endif
// Decal buffer must be last as it is bind but we can optionally write into it (based on _DISABLE_DECALS)
#ifdef WRITE_NORMAL_BUFFER
, out float4 outNormalBuffer : SV_TARGET_NORMAL
#endif
#ifdef _DEPTHOFFSET_ON
, out float outputDepth : SV_Depth
#endif
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
FragInputs input = BuildFragInputs(v2f);
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS);
float3 V = GetWorldSpaceNormalizeViewDir(input.positionRWS);
SurfaceData surfaceData;
BuiltinData builtinData;
Surface l;
ShaderData d;
GetSurfaceAndBuiltinData(v2f, input, V, posInput, surfaceData, builtinData, l, d
#if NEED_FACING
, facing
#endif
);
#ifdef _DEPTHOFFSET_ON
v2f.motionVectorCS.w += builtinData.depthOffset;
v2f.previousPositionCS.w += builtinData.depthOffset;
#endif
// TODO: How to allow overriden motion vector from GetSurfaceAndBuiltinData ?
float2 motionVector = CalculateMotionVector(v2f.motionVectorCS, v2f.previousPositionCS);
// Convert from Clip space (-1..1) to NDC 0..1 space.
// Note it doesn't mean we don't have negative value, we store negative or positive offset in NDC space.
// Note: ((positionCS * 0.5 + 0.5) - (v2f.previousPositionCS * 0.5 + 0.5)) = (motionVector * 0.5)
EncodeMotionVector(motionVector * 0.5, outMotionVector);
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
// Setting the motionVector to a value more than 2 set as a flag for "force no motion". This is valid because, given that the velocities are in NDC,
// a value of >1 can never happen naturally, unless explicitely set.
if (forceNoMotion)
outMotionVector = float4(2.0, 0.0, 0.0, 0.0);
// Depth and Alpha to coverage
#ifdef WRITE_MSAA_DEPTH
// In case we are rendering in MSAA, reading the an MSAA depth buffer is way too expensive. To avoid that, we export the depth to a color buffer
depthColor = v2f.pos.z;
#ifdef _ALPHATOMASK_ON
// Alpha channel is used for alpha to coverage
depthColor.a = SharpenAlpha(builtinData.opacity, builtinData.alphaClipTreshold);
#endif
#endif
// Normal Buffer Processing
#ifdef WRITE_NORMAL_BUFFER
EncodeIntoNormalBuffer(ConvertSurfaceDataToNormalData(surfaceData), outNormalBuffer);
#endif
#if defined(WRITE_DECAL_BUFFER)
DecalPrepassData decalPrepassData;
// Force a write in decal buffer even if decal is disab. This is a neutral value which have no impact for later pass
#ifdef _DISABLE_DECALS
ZERO_INITIALIZE(DecalPrepassData, decalPrepassData);
#else
// We don't have the right to access SurfaceData in a shaderpass.
// However it would be painful to have to add a function like ConvertSurfaceDataToDecalPrepassData() to every Material to return geomNormalWS anyway
// Here we will put the constrain that any Material requiring to support Decal, will need to have geomNormalWS as member of surfaceData (and we already require normalWS anyway)
decalPrepassData.geomNormalWS = surfaceData.geomNormalWS;
decalPrepassData.decalLayerMask = GetMeshRenderingDecalLayer();
#endif
EncodeIntoDecalPrepassBuffer(decalPrepassData, outDecalBuffer);
outDecalBuffer.w = (GetMeshRenderingLightLayer() & 0x000000FF) / 255.0;
#endif
#ifdef _DEPTHOFFSET_ON
outputDepth = posInput.deviceDepth;
#endif
}
ENDHLSL
}
Pass
{
Name "FullScreenDebug"
Tags
{
"LightMode" = "FullScreenDebug"
}
// Render State
Cull Back
ZTest LEqual
ZWrite Off
//-------------------------------------------------------------------------------------
// End Render Modes
//-------------------------------------------------------------------------------------
HLSLPROGRAM
#pragma target 4.5
#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch
//#pragma shader_feature _ _SURFACE_TYPE_TRANSPARENT
//#pragma shader_feature_local _BLENDMODE_OFF _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
//#pragma shader_feature_local _ _ADD_PRECOMPUTED_VELOCITY
//#pragma shader_feature_local _ _TRANSPARENT_WRITES_MOTION_VEC
//#pragma shader_feature_local _ _ENABLE_FOG_ON_TRANSPARENT
//#pragma shader_feature_local _ _DISABLE_DECALS
//#pragma shader_feature_local _ _DISABLE_SSR
//#pragma shader_feature_local _ _DISABLE_SSR_TRANSPARENT
//#pragma shader_feature_local _REFRACTION_OFF _REFRACTION_PLANE _REFRACTION_SPHERE _REFRACTION_THIN
#pragma multi_compile _ LOD_FADE_CROSSFADE
#define SHADERPASS SHADERPASS_FULL_SCREEN_DEBUG
#define _PASSFULLSCREENDEBUG 1
#pragma shader_feature_local GLOW_ON
#pragma shader_feature_local FADE_ON
#pragma shader_feature_local OUTBASE_ON
#pragma shader_feature_local ONLYOUTLINE_ON
#pragma shader_feature_local GRADIENT_ON
#pragma shader_feature_local GRADIENT2COL_ON
#pragma shader_feature_local RADIALGRADIENT_ON
#pragma shader_feature_local COLORSWAP_ON
#pragma shader_feature_local HSV_ON
#pragma shader_feature_local CHANGECOLOR_ON
#pragma shader_feature_local CHANGECOLOR2_ON
#pragma shader_feature_local CHANGECOLOR3_ON
#pragma shader_feature_local COLORRAMP_ON
#pragma shader_feature_local GRADIENTCOLORRAMP_ON
#pragma shader_feature_local HITEFFECT_ON
#pragma shader_feature_local NEGATIVE_ON
#pragma shader_feature_local PIXELATE_ON
#pragma shader_feature_local GREYSCALE_ON
#pragma shader_feature_local POSTERIZE_ON
#pragma shader_feature_local BLUR_ON
#pragma shader_feature_local MOTIONBLUR_ON
#pragma shader_feature_local GHOST_ON
#pragma shader_feature_local ALPHAOUTLINE_ON
#pragma shader_feature_local INNEROUTLINE_ON
#pragma shader_feature_local ONLYINNEROUTLINE_ON
#pragma shader_feature_local HOLOGRAM_ON
#pragma shader_feature_local CHROMABERR_ON
#pragma shader_feature_local GLITCH_ON
#pragma shader_feature_local FLICKER_ON
#pragma shader_feature_local SHADOW_ON
#pragma shader_feature_local SHINE_ON
#pragma shader_feature_local CONTRAST_ON
#pragma shader_feature_local OVERLAY_ON
#pragma shader_feature_local OVERLAYMULT_ON
#pragma shader_feature_local DOODLE_ON
#pragma shader_feature_local WIND_ON
#pragma shader_feature_local WAVEUV_ON
#pragma shader_feature_local ROUNDWAVEUV_ON
#pragma shader_feature_local RECTSIZE_ON
#pragma shader_feature_local OFFSETUV_ON
#pragma shader_feature_local CLIPPING_ON
#pragma shader_feature_local RADIALCLIPPING_ON
#pragma shader_feature_local TEXTURESCROLL_ON
#pragma shader_feature_local ZOOMUV_ON
#pragma shader_feature_local DISTORT_ON
#pragma shader_feature_local WARP_ON
#pragma shader_feature_local TWISTUV_ON
#pragma shader_feature_local ROTATEUV_ON
#pragma shader_feature_local POLARUV_ON
#pragma shader_feature_local FISHEYE_ON
#pragma shader_feature_local PINCH_ON
#pragma shader_feature_local SHAKEUV_ON
#pragma shader_feature_local GLOWTEX_ON
#pragma shader_feature_local OUTTEX_ON
#pragma shader_feature_local OUTDIST_ON
#pragma shader_feature_local OUTBASE8DIR_ON
#pragma shader_feature_local OUTBASEPIXELPERF_ON
#pragma shader_feature_local COLORRAMPOUTLINE_ON
#pragma shader_feature_local GREYSCALEOUTLINE_ON
#pragma shader_feature_local POSTERIZEOUTLINE_ON
#pragma shader_feature_local BLURISHD_ON
#pragma shader_feature_local MANUALWIND_ON
#pragma shader_feature_local ATLAS_ON
#pragma shader_feature_local PREMULTIPLYALPHA_ON
#pragma shader_feature BILBOARD_ON
#pragma shader_feature BILBOARDY_ON
#pragma shader_feature NORMALMAP_ON
#define _HDRP 1
#define _USINGTEXCOORD1 1
#define _USINGTEXCOORD2 1
#pragma vertex Vert
#pragma fragment Frag
// useful conversion functions to make surface shader code just work
#define UNITY_DECLARE_TEX2D(name) TEXTURE2D(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2D_NOSAMPLER(name) TEXTURE2D(name);
#define UNITY_DECLARE_TEX2DARRAY(name) TEXTURE2D_ARRAY(name); SAMPLER(sampler##name);
#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) TEXTURE2D_ARRAY(tex);
#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) SAMPLE_TEXTURE2D_ARRAY(tex, sampler##tex, coord.xy, coord.z)
#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) SAMPLE_TEXTURE2D_ARRAY_LOD(tex, sampler##tex, coord.xy, coord.z, lod)
#define UNITY_SAMPLE_TEX2D(tex, coord) SAMPLE_TEXTURE2D(tex, sampler##tex, coord)
#define UNITY_SAMPLE_TEX2D_SAMPLER(tex, samp, coord) SAMPLE_TEXTURE2D(tex, sampler##samp, coord)
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) SAMPLE_TEXTURE2D_LOD(tex, sampler_##tex, coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) SAMPLE_TEXTURE2D_LOD (tex, sampler##samplertex,coord, lod)
#if defined(UNITY_COMPILER_HLSL)
#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
#else
#define UNITY_INITIALIZE_OUTPUT(type,name)
#endif
#define sampler2D_float sampler2D
#define sampler2D_half sampler2D
#undef WorldNormalVector
#define WorldNormalVector(data, normal) mul(normal, data.TBNMatrix)
#define UnityObjectToWorldNormal(normal) mul(GetObjectToWorldMatrix(), normal)
#ifndef SHADER_STAGE_FRAGMENT
#if !defined(SHADOW_ULTRA_LOW) && !defined(SHADOW_LOW) && !defined(SHADOW_MEDIUM) && !defined(SHADOW_HIGH) // ultra low come from volumetricLighting.compute
#define SHADOW_MEDIUM
#endif
#if !defined(AREA_SHADOW_LOW) && !defined(AREA_SHADOW_MEDIUM) && !defined(AREA_SHADOW_HIGH) // low come from volumetricLighting.compute
#define AREA_SHADOW_MEDIUM
#endif
#endif
// HDRP Adapter stuff
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
#if UNITY_VERSION >= 202239
#include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl" // Need to be here for Gradient struct definition
#else
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl"
#endif
#ifdef RAYTRACING_SHADER_GRAPH_DEFAULT
#define RAYTRACING_SHADER_GRAPH_HIGH
#endif
#ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED
#define RAYTRACING_SHADER_GRAPH_LOW
#endif
// end
// If we use subsurface scattering, enable output split lighting (for forward pass)
#if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define OUTPUT_SPLIT_LIGHTING
#endif
#define HAVE_RECURSIVE_RENDERING
#if SHADERPASS == SHADERPASS_TRANSPARENT_DEPTH_PREPASS
#if !defined(_DISABLE_SSR_TRANSPARENT) && !defined(SHADER_UNLIT)
#define WRITE_NORMAL_BUFFER
#endif
#endif
#ifndef DEBUG_DISPLAY
// In case of opaque we don't want to perform the alpha test, it is done in depth prepass and we use depth equal for ztest (setup from UI)
// Don't do it with debug display mode as it is possible there is no depth prepass in this case
#if !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_ALPHATEST)
#if SHADERPASS == SHADERPASS_FORWARD
#define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST
#elif SHADERPASS == SHADERPASS_GBUFFER
#define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST
#endif
#endif
#endif
// Define _DEFERRED_CAPABLE_MATERIAL for shader capable to run in deferred pass
#if defined(SHADER_LIT) && !defined(_SURFACE_TYPE_TRANSPARENT)
#define _DEFERRED_CAPABLE_MATERIAL
#endif
// Translate transparent motion vector define
#if defined(_TRANSPARENT_WRITES_MOTION_VEC) && defined(_SURFACE_TYPE_TRANSPARENT)
#define _WRITE_TRANSPARENT_MOTION_VECTOR
#endif
CBUFFER_START(UnityPerMaterial)
float _UseShadowThreshold;
float _BlendMode;
float _EnableBlendModePreserveSpecularLighting;
float _RayTracing;
float _RefractionModel;
half4 _Color;
half4 _MainTex_ST, _MainTex_TexelSize;
half _Alpha, _AlphaCutoffValue;
#if ATLAS_ON
half _MinXUV, _MaxXUV, _MinYUV, _MaxYUV;
#endif
#if GLOW_ON
half4 _GlowColor;
half _Glow, _GlowGlobal;
#endif
#if HSV_ON
half _HsvShift, _HsvSaturation, _HsvBright;
#endif
#if DISTORT_ON
half4 _DistortTex_ST;
half _DistortTexXSpeed, _DistortTexYSpeed, _DistortAmount;
#endif
#if FADE_ON
half4 _FadeBurnColor, _FadeTex_ST, _FadeBurnTex_ST;
half _FadeAmount, _FadeBurnWidth, _FadeBurnTransition,_FadeBurnGlow;
#endif
#if OUTBASE_ON
half4 _OutlineColor;
half _OutlineAlpha, _OutlineGlow, _OutlineWidth;
int _OutlinePixelWidth;
#endif
#if OUTTEX_ON
half4 _OutlineTex_ST;
half _OutlineTexXSpeed, _OutlineTexYSpeed;
#endif
#if OUTDIST_ON
half4 _OutlineDistortTex_ST;
half _OutlineDistortTexXSpeed, _OutlineDistortTexYSpeed, _OutlineDistortAmount;
#endif
#if ALPHAOUTLINE_ON
half _AlphaOutlineGlow, _AlphaOutlinePower, _AlphaOutlineMinAlpha, _AlphaOutlineBlend;
half4 _AlphaOutlineColor;
#endif
#if INNEROUTLINE_ON
half _InnerOutlineThickness, _InnerOutlineAlpha, _InnerOutlineGlow;
half4 _InnerOutlineColor;
#endif
#if GRADIENT_ON
half _GradBlend, _GradBoostX, _GradBoostY;
half4 _GradTopRightCol, _GradTopLeftCol, _GradBotRightCol, _GradBotLeftCol;
#endif
#if COLORSWAP_ON
half4 _ColorSwapRed, _ColorSwapGreen, _ColorSwapBlue;
half _ColorSwapRedLuminosity, _ColorSwapGreenLuminosity, _ColorSwapBlueLuminosity, _ColorSwapBlend;
#endif
#if CHANGECOLOR_ON
half4 _ColorChangeNewCol, _ColorChangeTarget;
half _ColorChangeTolerance, _ColorChangeLuminosity;
#endif
#if CHANGECOLOR2_ON
half4 _ColorChangeNewCol2, _ColorChangeTarget2;
half _ColorChangeTolerance2;
#endif
#if CHANGECOLOR3_ON
half4 _ColorChangeNewCol3, _ColorChangeTarget3;
half _ColorChangeTolerance3;
#endif
#if COLORRAMP_ON
half _ColorRampLuminosity, _ColorRampBlend;
#endif
#if HITEFFECT_ON
half4 _HitEffectColor;
half _HitEffectGlow, _HitEffectBlend;
#endif
#if NEGATIVE_ON
half _NegativeAmount;
#endif
#if PIXELATE_ON
half _PixelateSize;
#endif
#if GREYSCALE_ON
half _GreyscaleLuminosity, _GreyscaleBlend;
half4 _GreyscaleTintColor;
#endif
#if POSTERIZE_ON
half _PosterizeNumColors, _PosterizeGamma;
#endif
#if BLUR_ON
half _BlurIntensity;
#endif
#if MOTIONBLUR_ON
half _MotionBlurAngle, _MotionBlurDist;
#endif
#if GHOST_ON
half _GhostColorBoost, _GhostTransparency, _GhostBlend;
#endif
#if HOLOGRAM_ON
half _HologramStripesAmount, _HologramMinAlpha, _HologramUnmodAmount, _HologramStripesSpeed, _HologramMaxAlpha, _HologramBlend;
half4 _HologramStripeColor;
#endif
#if CHROMABERR_ON
half _ChromAberrAmount, _ChromAberrAlpha;
#endif
#if GLITCH_ON
half _GlitchAmount, _GlitchSize;
#endif
#if FLICKER_ON
half _FlickerFreq, _FlickerPercent, _FlickerAlpha;
#endif
#if SHADOW_ON
half _ShadowX, _ShadowY, _ShadowAlpha;
half4 _ShadowColor;
#endif
#if SHINE_ON
half4 _ShineColor;
half _ShineLocation, _ShineRotate, _ShineWidth, _ShineGlow;
#endif
#if CONTRAST_ON
half _Contrast, _Brightness;
#endif
#if OVERLAY_ON
half4 _OverlayTex_ST, _OverlayColor;
half _OverlayGlow, _OverlayBlend, _OverlayTextureScrollXSpeed, _OverlayTextureScrollYSpeed;
#endif
#if DOODLE_ON
half _HandDrawnAmount, _HandDrawnSpeed;
#endif
#if WIND_ON
half _GrassSpeed, _GrassWind, _GrassManualAnim, _GrassRadialBend;
#endif
#if WAVEUV_ON
float _WaveAmount, _WaveSpeed, _WaveStrength, _WaveX, _WaveY;
#endif
#if ROUNDWAVEUV_ON
half _RoundWaveStrength, _RoundWaveSpeed;
#endif
#if RECTSIZE_ON
half _RectSize;
#endif
#if OFFSETUV_ON
half _OffsetUvX, _OffsetUvY;
#endif
#if CLIPPING_ON
half _ClipUvLeft, _ClipUvRight, _ClipUvUp, _ClipUvDown;
#endif
#if RADIALCLIPPING_ON
half _RadialStartAngle, _RadialClip, _RadialClip2;
#endif
#if TEXTURESCROLL_ON
half _TextureScrollXSpeed, _TextureScrollYSpeed;
#endif
#if ZOOMUV_ON
half _ZoomUvAmount;
#endif
#if WARP_ON
half _WarpStrength, _WarpSpeed, _WarpScale;
#endif
#if TWISTUV_ON
half _TwistUvAmount, _TwistUvPosX, _TwistUvPosY, _TwistUvRadius;
#endif
#if ROTATEUV_ON
half _RotateUvAmount;
#endif
#if FISHEYE_ON
half _FishEyeUvAmount;
#endif
#if PINCH_ON
half _PinchUvAmount;
#endif
#if SHAKEUV_ON
half _ShakeUvSpeed, _ShakeUvX, _ShakeUvY;
#endif
#if NORMALMAP_ON
half _NormalStrength;
#endif
float _RandomSeed;
CBUFFER_END
// -- Property used by ScenePickingPass
#ifdef SCENEPICKINGPASS
float4 _SelectionID;
#endif
// -- Properties used by SceneSelectionPass
#ifdef SCENESELECTIONPASS
int _ObjectId;
int _PassValue;
#endif
// data across stages, stripped like the above.
struct VertexToPixel
{
float4 pos : SV_POSITION;
float3 worldPos : TEXCOORD0;
float3 worldNormal : TEXCOORD1;
float4 worldTangent : TEXCOORD2;
float4 texcoord0 : TEXCOORD3;
float4 texcoord1 : TEXCOORD4;
float4 texcoord2 : TEXCOORD5;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD6;
// #endif
// #if %SCREENPOSREQUIREKEY%
// float4 screenPos : TEXCOORD7;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD8;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD9;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD10;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD11;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD12;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD13;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD14;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD15;
// #endif
#if UNITY_ANY_INSTANCING_ENABLED
UNITY_VERTEX_INPUT_INSTANCE_ID
#endif // UNITY_ANY_INSTANCING_ENABLED
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
float4 previousPositionCS : TEXCOORD16; // Contain previous transform position (in case of skinning for example)
float4 motionVectorCS : TEXCOORD17;
#endif
UNITY_VERTEX_OUTPUT_STEREO
};
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl"
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl"
// data describing the user output of a pixel
struct Surface
{
half3 Albedo;
half Height;
half3 Normal;
half Smoothness;
half3 Emission;
half Metallic;
half3 Specular;
half Occlusion;
half SpecularPower; // for simple lighting
half Alpha;
float outputDepth; // if written, SV_Depth semantic is used. ShaderData.clipPos.z is unused value
// HDRP Only
half SpecularOcclusion;
half SubsurfaceMask;
half Thickness;
half CoatMask;
half CoatSmoothness;
half Anisotropy;
half IridescenceMask;
half IridescenceThickness;
int DiffusionProfileHash;
float SpecularAAThreshold;
float SpecularAAScreenSpaceVariance;
// requires _OVERRIDE_BAKEDGI to be defined, but is mapped in all pipelines
float3 DiffuseGI;
float3 BackDiffuseGI;
float3 SpecularGI;
float ior;
float3 transmittanceColor;
float atDistance;
float transmittanceMask;
// requires _OVERRIDE_SHADOWMASK to be defines
float4 ShadowMask;
// for decals
float NormalAlpha;
float MAOSAlpha;
};
// Data the user declares in blackboard blocks
struct Blackboard
{
float blackboardDummyData;
};
// data the user might need, this will grow to be big. But easy to strip
struct ShaderData
{
float4 clipPos; // SV_POSITION
float3 localSpacePosition;
float3 localSpaceNormal;
float3 localSpaceTangent;
float3 worldSpacePosition;
float3 worldSpaceNormal;
float3 worldSpaceTangent;
float tangentSign;
float3 worldSpaceViewDir;
float3 tangentSpaceViewDir;
float4 texcoord0;
float4 texcoord1;
float4 texcoord2;
float4 texcoord3;
float2 screenUV;
float4 screenPos;
float4 vertexColor;
bool isFrontFace;
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
float3x3 TBNMatrix;
Blackboard blackboard;
};
struct VertexData
{
#if SHADER_TARGET > 30
// uint vertexID : SV_VertexID;
#endif
float4 vertex : POSITION;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
// optimize out mesh coords when not in use by user or lighting system
#if _URP && (_USINGTEXCOORD1 || _PASSMETA || _PASSFORWARD || _PASSGBUFFER)
float4 texcoord1 : TEXCOORD1;
#endif
#if _URP && (_USINGTEXCOORD2 || _PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && defined(DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _STANDARD && (_USINGTEXCOORD1 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER || _PASSFORWARDADD) && LIGHTMAP_ON)))
float4 texcoord1 : TEXCOORD1;
#endif
#if _STANDARD && (_USINGTEXCOORD2 || (_PASSMETA || ((_PASSFORWARD || _PASSGBUFFER) && DYNAMICLIGHTMAP_ON)))
float4 texcoord2 : TEXCOORD2;
#endif
#if _HDRP
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
#endif
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD4; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD5; // Add Precomputed Velocity (Alembic computes velocities on runtime side).
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
};
struct TessVertex
{
float4 vertex : INTERNALTESSPOS;
float3 normal : NORMAL;
float4 tangent : TANGENT;
float4 texcoord0 : TEXCOORD0;
float4 texcoord1 : TEXCOORD1;
float4 texcoord2 : TEXCOORD2;
// #if %TEXCOORD3REQUIREKEY%
float4 texcoord3 : TEXCOORD3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
float4 vertexColor : COLOR;
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// float4 extraV2F0 : TEXCOORD5;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// float4 extraV2F1 : TEXCOORD6;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// float4 extraV2F2 : TEXCOORD7;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// float4 extraV2F3 : TEXCOORD8;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// float4 extraV2F4 : TEXCOORD9;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// float4 extraV2F5 : TEXCOORD10;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// float4 extraV2F6 : TEXCOORD11;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// float4 extraV2F7 : TEXCOORD12;
// #endif
#if _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
float3 previousPositionOS : TEXCOORD13; // Contain previous transform position (in case of skinning for example)
#if defined (_ADD_PRECOMPUTED_VELOCITY)
float3 precomputedVelocity : TEXCOORD14;
#endif
#endif
UNITY_VERTEX_INPUT_INSTANCE_ID
UNITY_VERTEX_OUTPUT_STEREO
};
struct ExtraV2F
{
float4 extraV2F0;
float4 extraV2F1;
float4 extraV2F2;
float4 extraV2F3;
float4 extraV2F4;
float4 extraV2F5;
float4 extraV2F6;
float4 extraV2F7;
Blackboard blackboard;
float4 time;
};
float3 WorldToTangentSpace(ShaderData d, float3 normal)
{
return mul(d.TBNMatrix, normal);
}
float3 TangentToWorldSpace(ShaderData d, float3 normal)
{
return mul(normal, d.TBNMatrix);
}
// in this case, make standard more like SRPs, because we can't fix
// unity_WorldToObject in HDRP, since it already does macro-fu there
#if _STANDARD
float3 TransformWorldToObject(float3 p) { return mul(unity_WorldToObject, float4(p, 1)); };
float3 TransformObjectToWorld(float3 p) { return mul(unity_ObjectToWorld, float4(p, 1)); };
float4 TransformWorldToObject(float4 p) { return mul(unity_WorldToObject, p); };
float4 TransformObjectToWorld(float4 p) { return mul(unity_ObjectToWorld, p); };
float4x4 GetWorldToObjectMatrix() { return unity_WorldToObject; }
float4x4 GetObjectToWorldMatrix() { return unity_ObjectToWorld; }
#if (defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL) || (SHADER_TARGET_SURFACE_ANALYSIS && !SHADER_TARGET_SURFACE_ANALYSIS_MOJOSHADER))
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord, lod) tex.SampleLevel (sampler##tex,coord, lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord, lod) tex.SampleLevel (sampler##samplertex,coord, lod)
#else
#define UNITY_SAMPLE_TEX2D_LOD(tex,coord,lod) tex2D (tex,coord,0,lod)
#define UNITY_SAMPLE_TEX2D_SAMPLER_LOD(tex,samplertex,coord,lod) tex2D (tex,coord,0,lod)
#endif
#undef GetWorldToObjectMatrix()
#define GetWorldToObjectMatrix() unity_WorldToObject
#endif
float3 GetCameraWorldPosition()
{
#if _HDRP
return GetCameraRelativePositionWS(_WorldSpaceCameraPos);
#else
return _WorldSpaceCameraPos;
#endif
}
#if _GRABPASSUSED
#if _STANDARD
TEXTURE2D(%GRABTEXTURE%);
SAMPLER(sampler_%GRABTEXTURE%);
#endif
half3 GetSceneColor(float2 uv)
{
#if _STANDARD
return SAMPLE_TEXTURE2D(%GRABTEXTURE%, sampler_%GRABTEXTURE%, uv).rgb;
#else
return SHADERGRAPH_SAMPLE_SCENE_COLOR(uv);
#endif
}
#endif
#if _STANDARD
UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
float GetSceneDepth(float2 uv) { return SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv)); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv)); }
#else
float GetSceneDepth(float2 uv) { return SHADERGRAPH_SAMPLE_SCENE_DEPTH(uv); }
float GetLinear01Depth(float2 uv) { return Linear01Depth(GetSceneDepth(uv), _ZBufferParams); }
float GetLinearEyeDepth(float2 uv) { return LinearEyeDepth(GetSceneDepth(uv), _ZBufferParams); }
#endif
float3 GetWorldPositionFromDepthBuffer(float2 uv, float3 worldSpaceViewDir)
{
float eye = GetLinearEyeDepth(uv);
float3 camView = mul((float3x3)GetObjectToWorldMatrix(), transpose(mul(GetWorldToObjectMatrix(), UNITY_MATRIX_I_V)) [2].xyz);
float dt = dot(worldSpaceViewDir, camView);
float3 div = worldSpaceViewDir/dt;
float3 wpos = (eye * div) + GetCameraWorldPosition();
return wpos;
}
#if _HDRP
float3 ObjectToWorldSpacePosition(float3 pos)
{
return GetAbsolutePositionWS(TransformObjectToWorld(pos));
}
#else
float3 ObjectToWorldSpacePosition(float3 pos)
{
return TransformObjectToWorld(pos);
}
#endif
#if _STANDARD
UNITY_DECLARE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture);
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
float4 depthNorms = UNITY_SAMPLE_SCREENSPACE_TEXTURE(_CameraDepthNormalsTexture, uv);
float3 norms = DecodeViewNormalStereo(depthNorms);
norms = mul((float3x3)GetWorldToViewMatrix(), norms) * 0.5 + 0.5;
return norms;
}
#elif _HDRP && !_DECALSHADER
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
NormalData nd;
DecodeFromNormalBuffer(_ScreenSize.xy * uv, nd);
return nd.normalWS;
}
#elif _URP
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareNormalsTexture.hlsl"
#endif
float3 GetSceneNormal(float2 uv, float3 worldSpaceViewDir)
{
#if (SHADER_LIBRARY_VERSION_MAJOR >= 10)
return SampleSceneNormals(uv);
#else
float3 wpos = GetWorldPositionFromDepthBuffer(uv, worldSpaceViewDir);
return normalize(-cross(ddx(wpos), ddy(wpos))) * 0.5 + 0.5;
#endif
}
#endif
#if _HDRP
half3 UnpackNormalmapRGorAG(half4 packednormal)
{
// This do the trick
packednormal.x *= packednormal.w;
half3 normal;
normal.xy = packednormal.xy * 2 - 1;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
half3 UnpackNormal(half4 packednormal)
{
#if defined(UNITY_NO_DXT5nm)
return packednormal.xyz * 2 - 1;
#else
return UnpackNormalmapRGorAG(packednormal);
#endif
}
#endif
#if _HDRP || _URP
half3 UnpackScaleNormal(half4 packednormal, half scale)
{
#ifndef UNITY_NO_DXT5nm
// Unpack normal as DXT5nm (1, y, 1, x) or BC5 (x, y, 0, 1)
// Note neutral texture like "bump" is (0, 0, 1, 1) to work with both plain RGB normal and DXT5nm/BC5
packednormal.x *= packednormal.w;
#endif
half3 normal;
normal.xy = (packednormal.xy * 2 - 1) * scale;
normal.z = sqrt(1 - saturate(dot(normal.xy, normal.xy)));
return normal;
}
#endif
void GetSun(out float3 lightDir, out float3 color)
{
lightDir = float3(0.5, 0.5, 0);
color = 1;
#if _HDRP
if (_DirectionalLightCount > 0)
{
DirectionalLightData light = _DirectionalLightDatas[0];
lightDir = -light.forward.xyz;
color = light.color;
}
#elif _STANDARD
lightDir = normalize(_WorldSpaceLightPos0.xyz);
color = _LightColor0.rgb;
#elif _URP
Light light = GetMainLight();
lightDir = light.direction;
color = light.color;
#endif
}
TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
#if GLOW_ON
TEXTURE2D(_GlowTex);
SAMPLER(sampler_GlowTex);
#endif
#if FADE_ON
TEXTURE2D(_FadeTex);
SAMPLER(sampler_FadeTex);
TEXTURE2D(_FadeBurnTex);
SAMPLER(sampler_FadeBurnTex);
#endif
#if DISTORT_ON
TEXTURE2D(_DistortTex);
SAMPLER(sampler_DistortTex);
#endif
#if OUTTEX_ON
TEXTURE2D(_OutlineTex);
SAMPLER(sampler_OutlineTex);
#endif
#if OUTDIST_ON
TEXTURE2D(_OutlineDistortTex);
SAMPLER(sampler_OutlineDistortTex);
#endif
#if COLORSWAP_ON
TEXTURE2D(_ColorSwapTex);
SAMPLER(sampler_ColorSwapTex);
#endif
#if COLORRAMP_ON
TEXTURE2D(_ColorRampTex);
TEXTURE2D(_ColorRampTexGradient);
SAMPLER(sampler_ColorRampTex);
SAMPLER(sampler_ColorRampTexGradient);
#endif
#if SHINE_ON
TEXTURE2D(_ShineMask);
SAMPLER(sampler_ShineMask);
#endif
#if OVERLAY_ON
TEXTURE2D(_OverlayTex);
SAMPLER(sampler_OverlayTex);
#endif
#if NORMALMAP_ON
TEXTURE2D(_NormalMap);
SAMPLER(sampler_NormalMap);
#endif
half3 GetPixel(in int offsetX, in int offsetY, in half2 uv, in Texture2D _tex, in SamplerState _sampler)
{
half2 _uv = uv + half2(offsetX * _MainTex_TexelSize.x, offsetY * _MainTex_TexelSize.y);
half4 col = SAMPLE_TEXTURE2D(_tex, _sampler, _uv);
return col.rgb;
}
//BLURS-------------------------------------------------------------------------
half4 Blur(half2 uv, Texture2D source, SamplerState sampler_source, half Intensity)
{
const half2 texelSize = 1.0 / _ScreenParams.xy;
const half4 color = SAMPLE_TEXTURE2D(source, sampler_source, uv);
const half2 offset = Intensity * texelSize;
half4 accumulatedColor = color;
half accumulatedWeight = 1.0;
for (int x = -1; x <= 1; x++)
{
for (int y = -1; y <= 1; y++)
{
const half2 sampleUV = uv + half2(x, y) * offset;
const half4 sampleColor = SAMPLE_TEXTURE2D(source, sampler_source, sampleUV);
accumulatedColor += sampleColor;
accumulatedWeight += 1.0;
}
}
half4 blurredColor = accumulatedColor / accumulatedWeight;
return blurredColor;
}
half BlurHD_G(half bhqp, half x)
{
return exp(-(x * x) / (2.0 * bhqp * bhqp));
}
half4 BlurHD(half2 uv, Texture2D source, SamplerState sampler_source, half BlurAmount, half xScale, half yScale)
{
int iterations = 16;
int halfIterations = iterations / 2;
half sigmaX = 0.1 + BlurAmount * 0.5;
half sigmaY = sigmaX;
half total = 0.0;
half4 ret = half4(0, 0, 0, 0);
for (int iy = 0; iy < iterations; ++iy)
{
half fy = BlurHD_G(sigmaY, half(iy) -half(halfIterations));
half offsetY = half(iy - halfIterations) * 0.00390625 * xScale;
for (int ix = 0; ix < iterations; ++ix)
{
half fx = BlurHD_G(sigmaX, half(ix) - half(halfIterations));
half offsetX = half(ix - halfIterations) * 0.00390625 * yScale;
total += fx * fy;
ret += SAMPLE_TEXTURE2D(source, sampler_source, uv + half2(offsetX, offsetY)) * fx * fy;
}
}
return ret / total;
}
//-----------------------------------------------------------------------
//-------------------------------------------
half RemapFloat(half inValue, half inMin, half inMax, half outMin, half outMax){
return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
}
//-------------------------------------------
//-----------------------------------------------------------------------
half rand(half2 seed, half offset) {
return (frac(sin(dot(seed, half2(12.9898, 78.233))) * 43758.5453) + offset) % 1.0;
}
half rand2(half2 seed, half offset) {
return (frac(sin(dot(seed * floor(50 + (_Time.x % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
half rand2CustomTime(half2 seed, half offset, half customTime) {
return (frac(sin(dot(seed * floor(50 + (customTime % 1.0) * 12.), half2(127.1, 311.7))) * 43758.5453123) + offset) % 1.0;
}
//-----------------------------------------------------------------------
void Ext_ModifyVertex0 (inout VertexData v, inout ExtraV2F d)
{
//BILBOARD_ON
#if BILBOARD_ON
half3 camRight = mul((half3x3)unity_CameraToWorld, half3(1,0,0));
half3 camUp = half3(0,1,0);
#if BILBOARDY_ON
camUp = mul((half3x3)unity_CameraToWorld, half3(0,1,0));
#endif
half3 localPos = v.vertex.x * camRight + v.vertex.y * camUp;
v.vertex = half4(localPos, 1);
#endif
//-----------------------------------------------------------
v.texcoord0.xy = TRANSFORM_TEX(v.texcoord0.xy, _MainTex);
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
#endif
//POLARUV_ON
#if POLARUV_ON
v.texcoord0.xy = v.texcoord0.xy - center;
#endif
//----------------------------------------
//ROTATEUV_ON
#if ROTATEUV_ON
half2 uvC = v.texcoord0.xy;
half cosAngle = cos(_RotateUvAmount);
half sinAngle = sin(_RotateUvAmount);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvC -= center;
v.texcoord0.xy = mul(rot, uvC);
v.texcoord0.xy += center;
#endif
//--------------------
#if RECTSIZE_ON
v.vertex.xyz += (v.vertex.xyz * (_RectSize - 1.0));
#endif
#if OUTTEX_ON
v.texcoord1.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineTex);
#endif
#if OUTDIST_ON
v.texcoord2.xy = TRANSFORM_TEX(v.texcoord0.xy, _OutlineDistortTex);
#endif
#if DISTORT_ON
v.texcoord3.xy = TRANSFORM_TEX(v.texcoord0.xy, _DistortTex);
#endif
}
void Ext_SurfaceFunction0 (inout Surface o, ShaderData d)
{
half randomSeed = _RandomSeed;
float2 uvRect = d.texcoord0;
half2 center = half2(0.5, 0.5);
#if ATLAS_ON
center = half2((_MaxXUV + _MinXUV) / 2.0, (_MaxYUV + _MinYUV) / 2.0);
uvRect = half2((d.texcoord0.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord0.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half2 centerTiled = half2(center.x * _MainTex_ST.x, center.y * _MainTex_ST.y);
//CLIPPING_ON
#if CLIPPING_ON
half2 tiledUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv = half2((tiledUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
clip((1 - _ClipUvUp) - tiledUv.y);
clip(tiledUv.y - _ClipUvDown);
clip((1 - _ClipUvRight) - tiledUv.x);
clip(tiledUv.x - _ClipUvLeft);
#endif
//----------------------------------
//RADIALCLIPPING_ON
#if RADIALCLIPPING_ON
half2 tiledUv2 = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
tiledUv2 = half2((tiledUv2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUv2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half startAngle = _RadialStartAngle - _RadialClip;
half endAngle = _RadialStartAngle + _RadialClip2;
half offset0 = clamp(0, 360, startAngle + 360);
half offset360 = clamp(0, 360, endAngle - 360);
half2 atan2Coord = half2(lerp(-1, 1, tiledUv2.x), lerp(-1, 1, tiledUv2.y));
half atanAngle = atan2(atan2Coord.y, atan2Coord.x) * 57.3; // angle in degrees
if(atanAngle < 0) atanAngle = 360 + atanAngle;
if(atanAngle >= startAngle && atanAngle <= endAngle) discard;
if(atanAngle <= offset360) discard;
if(atanAngle >= offset0) discard;
#endif
//-----------------------------
//TEXTURESCROLL_ON && ATLAS_ON
#if TEXTURESCROLL_ON && ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs(((_Time.y + randomSeed) * _TextureScrollXSpeed) + uvRect.x) % 1)),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(((_Time.y + randomSeed) * _TextureScrollYSpeed) + uvRect.y) % 1)));
#endif
//----------------------------
//OFFSETUV_ON
#if OFFSETUV_ON
#if ATLAS_ON
d.texcoord0.xy = half2(_MinXUV + ((_MaxXUV - _MinXUV) * (abs((_OffsetUvX + uvRect.x) % 1))),
_MinYUV + ((_MaxYUV - _MinYUV) * (abs(_OffsetUvY + uvRect.y) % 1)));
#else
d.texcoord0.xy += half2(_OffsetUvX, _OffsetUvY);
#endif
#endif
//----------------------
//POLARUV_ON
#if POLARUV_ON
d.texcoord0.xy = half2(atan2(d.texcoord0.y, d.texcoord0.x) / (2.0f * 3.141592653589f), length(d.texcoord0.xy));
d.texcoord0.xy *= _MainTex_ST.xy;
#endif
//--------------------------------------
//TWISTUV_ON
#if TWISTUV_ON
#if ATLAS_ON
_TwistUvPosX = ((_MaxXUV - _MinXUV) * _TwistUvPosX) + _MinXUV;
_TwistUvPosY = ((_MaxYUV - _MinYUV) * _TwistUvPosY) + _MinYUV;
#endif
half2 tempUv = d.texcoord0.xy - half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
_TwistUvRadius *= (_MainTex_ST.x + _MainTex_ST.y) / 2;
half percent = (_TwistUvRadius - length(tempUv)) / _TwistUvRadius;
half theta = percent * percent * (2.0 * sin(_TwistUvAmount)) * 8.0;
half s = sin(theta);
half c = cos(theta);
half beta = max(sign(_TwistUvRadius - length(tempUv)), 0.0);
tempUv = half2(dot(tempUv, half2(c, -s)), dot(tempUv, half2(s, c))) * beta + tempUv * (1 - beta);
tempUv += half2(_TwistUvPosX * _MainTex_ST.x, _TwistUvPosY * _MainTex_ST.y);
d.texcoord0.xy = tempUv;
#endif
//--------------------------------------------
//FISHEYE_ON
#if FISHEYE_ON
half bind = length(centerTiled);
half2 dF = d.texcoord0.xy - centerTiled;
half dFlen = length(dF);
half fishInt = (3.14159265359 / bind) * (_FishEyeUvAmount + 0.001);
d.texcoord0.xy = centerTiled + (dF / (max(0.0001, dFlen))) * tan(dFlen * fishInt) * bind / tan(bind * fishInt);
#endif
//---------------------------------------------
//PINCH_ON
#if PINCH_ON
half2 dP = d.texcoord0.xy - centerTiled;
half pinchInt = (3.141592 / length(centerTiled)) * (-_PinchUvAmount + 0.001);
d.texcoord0.xy = centerTiled + normalize(dP) * atan(length(dP) * -pinchInt * 10.0) * 0.5 / atan(-pinchInt * 5);
#endif
//---------------------------------------------
//ZOOMUV_ON
#if ZOOMUV_ON
d.texcoord0.xy -= centerTiled;
d.texcoord0.xy = d.texcoord0.xy * _ZoomUvAmount;
d.texcoord0.xy += centerTiled;
#endif
//-----------------------------------------------
//DOODLE_ON
#if DOODLE_ON
half2 uvCopy = uvRect;
_HandDrawnSpeed = (floor((_Time.x + randomSeed) * 20 * _HandDrawnSpeed) / _HandDrawnSpeed) * _HandDrawnSpeed;
uvCopy.x = sin((uvCopy.x * _HandDrawnAmount + _HandDrawnSpeed) * 4);
uvCopy.y = cos((uvCopy.y * _HandDrawnAmount + _HandDrawnSpeed) * 4);
d.texcoord0.xy = lerp(d.texcoord0.xy, d.texcoord0.xy + uvCopy, 0.0005 * _HandDrawnAmount);
#endif
//--------------------------
//SHAKEUV_ON
#if SHAKEUV_ON
half xShake = sin((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvX;
half yShake = cos((_Time.x + randomSeed) * _ShakeUvSpeed * 50) * _ShakeUvY;
d.texcoord0.xy += half2(xShake * 0.012, yShake * 0.01);
#endif
//-------------------------------------------
//RECTSIZE_ON
#if RECTSIZE_ON
d.texcoord0.xy = d.texcoord0.xy * (_RectSize).xx + (((-_RectSize * 0.5) + 0.5)).xx;
#endif
//-------------------------------------------
//DISTORT_ON
#if DISTORT_ON
#if ATLAS_ON
d.texcoord3.x = d.texcoord3.x * (1 / (_MaxXUV - _MinXUV));
d.texcoord3.y = d.texcoord3.y * (1 / (_MaxYUV - _MinYUV));
#endif
d.texcoord3.x += ((_Time.x + _RandomSeed) * _DistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _DistortTexYSpeed) % 1;
half distortAmnt = (SAMPLE_TEXTURE2D(_DistortTex, sampler_DistortTex, d.texcoord3.xy).r - 0.5) * 0.2 * _DistortAmount;
d.texcoord0.x += distortAmnt;
d.texcoord0.y += distortAmnt;
#endif
//-------------------------------------------------------
//WARP_ON
#if WARP_ON
half2 warpUv = half2(d.texcoord0.x / _MainTex_ST.x, d.texcoord0.y / _MainTex_ST.y);
#if ATLAS_ON
warpUv = half2((warpUv.x - _MinXUV) / (_MaxXUV - _MinXUV), (warpUv.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
const float tau = 6.283185307179586;
float xWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.x * tau / _WarpScale;
float yWarp = (_Time.y + randomSeed) * _WarpSpeed + warpUv.y * tau / _WarpScale;
float2 warp = float2(sin(xWarp), sin(yWarp)) * _WarpStrength;
d.texcoord0.xy += warp;
#endif
//-------------------------------------------------------
//WAVEUV_ON
#if WAVEUV_ON
float2 uvWave = half2(_WaveX * _MainTex_ST.x, _WaveY * _MainTex_ST.y) - d.texcoord0.xy;
uvWave %= 1;
#if ATLAS_ON
uvWave = half2(_WaveX, _WaveY) - uvRect;
#endif
uvWave.x *= _ScreenParams.x / _ScreenParams.y;
float waveTime = _Time.y + randomSeed;
float angWave = (sqrt(dot(uvWave, uvWave)) * _WaveAmount) - ((waveTime * _WaveSpeed));
d.texcoord0.xy = d.texcoord0.xy + uvWave * sin(angWave) * (_WaveStrength / 1000.0);
#endif
//----------------------------------------------------
//ROUNDWAVEUV_ON
#if ROUNDWAVEUV_ON
half xWave = ((0.5 * _MainTex_ST.x) - uvRect.x);
half yWave = ((0.5 * _MainTex_ST.y) - uvRect.y) * (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
half ripple = -sqrt(xWave*xWave + yWave* yWave);
d.texcoord0.xy += (sin((ripple + (_Time.y + randomSeed) * (_RoundWaveSpeed/10.0)) / 0.015) * (_RoundWaveStrength/10.0)) % 1;
#endif
//----------------------------------------------------
//WIND_ON
#if WIND_ON
half windOffset = sin((_Time.x + randomSeed) * _GrassSpeed * 10);
half2 windCenter = half2(0.5, 0.1);
#if ATLAS_ON
windCenter.x = ((_MaxXUV - _MinXUV) * windCenter.x) + _MinXUV;
windCenter.y = ((_MaxYUV - _MinYUV) * windCenter.y) + _MinYUV;
#endif
#if !MANUALWIND_ON
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * windOffset), uvRect.y)), 1);
#else
d.texcoord0.x = fmod(abs(lerp(d.texcoord0.x, d.texcoord0.x + (_GrassWind * 0.01 * _GrassManualAnim), uvRect.y)), 1);
windOffset = _GrassManualAnim;
#endif
half2 delta = d.texcoord0.xy - windCenter;
half delta2 = dot(delta.xy, delta.xy);
half2 delta_offset = delta2 * windOffset;
d.texcoord0.xy = d.texcoord0.xy + half2(delta.y, -delta.x) * delta_offset * _GrassRadialBend;
#endif
//--------------------------------------------------------
//TEXTURESCROLL_ON && !ATLAS_ON
#if TEXTURESCROLL_ON && !ATLAS_ON
d.texcoord0.x += ((_Time.y + randomSeed) * _TextureScrollXSpeed) % 1;
d.texcoord0.y += ((_Time.y + randomSeed) * _TextureScrollYSpeed) % 1;
#endif
//------------------------------
//PIXELATE_ON
#if PIXELATE_ON
half aspectRatio = _MainTex_TexelSize.x / _MainTex_TexelSize.y;
half2 pixelSize = float2(_PixelateSize, _PixelateSize * aspectRatio);
d.texcoord0.xy = floor(d.texcoord0.xy * pixelSize) / pixelSize;
#endif
//--------------
half4 col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy);
half originalAlpha = col.a;
col *= d.vertexColor;
//NORMAL MAP
#if NORMALMAP_ON
half4 normalSample = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, d.texcoord0.xy);
half3 normalTS = UnpackNormal(normalSample);
normalTS.xy *= _NormalStrength;
o.Normal = normalTS;
#endif
float normalSign = sign(dot(d.worldSpaceViewDir, d.worldSpaceNormal));
o.Normal *= normalSign;
//GLITCH_ON
#if GLITCH_ON
half2 uvGlitch = uvRect;
uvGlitch.y -= 0.5;
half lineNoise = pow(rand2(floor(uvGlitch * half2(24., 19.) * _GlitchSize) * 4.0, randomSeed), 3.0) * _GlitchAmount
* pow(rand2(floor(uvGlitch * half2(38., 14.) * _GlitchSize) * 4.0, randomSeed), 3.0);
col = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(lineNoise * 0.02 * rand2(half2(2.0, 1), randomSeed), 0)) * d.vertexColor;
#endif
//--------------------------------------
//CHROMABERR_ON
#if CHROMABERR_ON
half4 r = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ChromAberrAmount/10, 0)) * d.vertexColor;
half4 b = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-_ChromAberrAmount/10, 0)) * d.vertexColor;
col = half4(r.r * r.a, col.g, b.b * b.a, max(max(r.a, b.a) * _ChromAberrAlpha, col.a));
#endif
//--------------------------------
//BLUR_ON
#if BLUR_ON
#if ATLAS_ON
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, (_MaxXUV - _MinXUV), (_MaxYUV - _MinYUV)) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity * (_MaxXUV - _MinXUV)) * d.vertexColor;
#endif
#else
#if !BLURISHD_ON
col = BlurHD(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity, 1, 1) * d.vertexColor;
#else
col = Blur(d.texcoord0.xy, _MainTex, sampler_MainTex, _BlurIntensity) * d.vertexColor;
#endif
#endif
#endif
//--------------------
//MOTIONBLUR_ON
#if MOTIONBLUR_ON
_MotionBlurAngle = _MotionBlurAngle * 3.1415926;
#define rot(n) mul(n, half2x2(cos(_MotionBlurAngle), -sin(_MotionBlurAngle), sin(_MotionBlurAngle), cos(_MotionBlurAngle)))
_MotionBlurDist = _MotionBlurDist * 0.005;
#if ATLAS_ON
_MotionBlurDist *= (_MaxXUV - _MinXUV);
#endif
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist, -_MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 2, -_MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 3, -_MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(-_MotionBlurDist * 4, -_MotionBlurDist * 4)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist, _MotionBlurDist)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 2, _MotionBlurDist * 2)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 3, _MotionBlurDist * 3)));
col.rgb += SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + rot(half2(_MotionBlurDist * 4, _MotionBlurDist * 4)));
col.rgb = col.rgb / 9;
#endif
//------------------------------------
//NEGATIVE_ON
#if NEGATIVE_ON
col.rgb = lerp(col.rgb, 1 - col.rgb, _NegativeAmount);
#endif
//--------------
half luminance = 0;
//GREYSCALE_ON && !GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && !GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//------------------------------------
//GHOST_ON
#if GHOST_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 ghostResult;
ghostResult.a = saturate(luminance - _GhostTransparency) * col.a;
ghostResult.rgb = col.rgb * (luminance + _GhostColorBoost);
col = lerp(col, ghostResult, _GhostBlend);
#endif
//------------------------------------
//INNEROUTLINE_ON
#if INNEROUTLINE_ON
half3 innerT = abs(GetPixel(0, _InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(0, -_InnerOutlineThickness, d.texcoord0.xy, _MainTex, sampler_MainTex));
innerT += abs(GetPixel(_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex) - GetPixel(-_InnerOutlineThickness, 0, d.texcoord0.xy, _MainTex, sampler_MainTex));
#if !ONLYINNEROUTLINE_ON
innerT = (innerT / 2.0) * col.a * _InnerOutlineAlpha;
col.rgb += length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
#else
innerT *= col.a * _InnerOutlineAlpha;
col.rgb = length(innerT) * _InnerOutlineColor.rgb * _InnerOutlineGlow;
col.a = step(0.3, col.r+col.g+col.b);
#endif
#endif
//-------------------------------------------------------
//HITEFFECT_ON
#if HITEFFECT_ON
col.rgb = lerp(col.rgb, _HitEffectColor.rgb * _HitEffectGlow, _HitEffectBlend);
#endif
//--------------------
//GRADIENT_ON
#if GRADIENT_ON
half2 tiledUvGrad = half2(uvRect.x / _MainTex_ST.x, uvRect.y / _MainTex_ST.y);
#if GRADIENT2COL_ON
_GradTopRightCol = _GradTopLeftCol;
_GradBotRightCol = _GradBotLeftCol;
#endif
#if RADIALGRADIENT_ON
half radialDist = 1 - length(tiledUvGrad - half2(0.5, 0.5));
radialDist *= (_MainTex_TexelSize.w / _MainTex_TexelSize.z);
radialDist = saturate(_GradBoostX * radialDist);
half4 gradientResult = lerp(_GradTopLeftCol, _GradBotLeftCol, radialDist);
#else
half gradXLerpFactor = saturate(pow(tiledUvGrad.x, _GradBoostX));
half4 gradientResult = lerp(lerp(_GradBotLeftCol, _GradBotRightCol, gradXLerpFactor),
lerp(_GradTopLeftCol, _GradTopRightCol, gradXLerpFactor), saturate(pow(tiledUvGrad.y, _GradBoostY)));
#endif
gradientResult = lerp(col, gradientResult, _GradBlend);
col.rgb = gradientResult.rgb * col.a;
col.a *= gradientResult.a;
#endif
//--------------------------------------------------------------------
//CONTRAST_ON
#if CONTRAST_ON
col.rgb = (col.rgb - float3(0.5, 0.5, 0.5)) * _Contrast + float3(0.5, 0.5, 0.5);
col.rgb += _Brightness;
#endif
//-------------------------------------------------------------------
//COLORSWAP_ON
#if COLORSWAP_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
half4 swapMask = SAMPLE_TEXTURE2D(_ColorSwapTex, sampler_ColorSwapTex, d.texcoord0.xy);
swapMask.rgb *= swapMask.a;
half3 redSwap = _ColorSwapRed * swapMask.r * saturate(luminance + _ColorSwapRedLuminosity);
half3 greenSwap = _ColorSwapGreen * swapMask.g * saturate(luminance + _ColorSwapGreenLuminosity);
half3 blueSwap = _ColorSwapBlue * swapMask.b * saturate(luminance + _ColorSwapBlueLuminosity);
swapMask.rgb = col.rgb * saturate(1 - swapMask.r - swapMask.g - swapMask.b);
col.rgb = lerp(col.rgb, swapMask.rgb + redSwap + greenSwap + blueSwap, _ColorSwapBlend);
#endif
//--------------------------------------------------------------------
//COLORRAMP_ON && !COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && !COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//--------------------------------------------------------------------
//CHANGECOLOR_ON
#if CHANGECOLOR_ON
float3 currChangeColor = saturate(col.rgb);
luminance = 0.3 * currChangeColor.r + 0.59 * currChangeColor.g + 0.11 * currChangeColor.b;
luminance = saturate(luminance + _ColorChangeLuminosity);
half3 dif = abs(currChangeColor - _ColorChangeTarget.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance), 0.0));
#if CHANGECOLOR2_ON
dif = abs(currChangeColor - _ColorChangeTarget2.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol2.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance2), 0.0));
#endif
#if CHANGECOLOR3_ON
dif = abs(currChangeColor - _ColorChangeTarget3.rgb);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _ColorChangeNewCol3.rgb,
max(sign(1 - saturate(dif.x + dif.y + dif.z) - _ColorChangeTolerance3), 0.0));
#endif
#endif
//-------------------------------------------------------
//POSTERIZE_ON && !POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && !POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//------------------------------------
//HSV_ON
#if HSV_ON
half3 resultHsv = half3(col.rgb);
half cosHsv = _HsvBright * _HsvSaturation * cos(_HsvShift * 3.14159265 / 180);
half sinHsv = _HsvBright * _HsvSaturation * sin(_HsvShift * 3.14159265 / 180);
resultHsv.x = (.299 * _HsvBright + .701 * cosHsv + .168 * sinHsv) * col.x
+ (.587 * _HsvBright - .587 * cosHsv + .330 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv - .497 * sinHsv) * col.z;
resultHsv.y = (.299 * _HsvBright - .299 * cosHsv - .328 * sinHsv) *col.x
+ (.587 * _HsvBright + .413 * cosHsv + .035 * sinHsv) * col.y
+ (.114 * _HsvBright - .114 * cosHsv + .292 * sinHsv) * col.z;
resultHsv.z = (.299 * _HsvBright - .3 * cosHsv + 1.25 * sinHsv) * col.x
+ (.587 * _HsvBright - .588 * cosHsv - 1.05 * sinHsv) * col.y
+ (.114 * _HsvBright + .886 * cosHsv - .203 * sinHsv) * col.z;
col.rgb = resultHsv;
#endif
//-------------------------------------------------------
//OVERLAY_ON
#if OVERLAY_ON
half2 overlayUvs = d.texcoord0.xy;
overlayUvs.x += ((_Time.y + randomSeed) * _OverlayTextureScrollXSpeed) % 1;
overlayUvs.y += ((_Time.y + randomSeed) * _OverlayTextureScrollYSpeed) % 1;
half4 overlayCol = SAMPLE_TEXTURE2D(_OverlayTex, sampler_OverlayTex, TRANSFORM_TEX(overlayUvs, _OverlayTex));
overlayCol.rgb *= _OverlayColor.rgb * _OverlayGlow;
#if !OVERLAYMULT_ON
overlayCol.rgb *= overlayCol.a * _OverlayColor.rgb * _OverlayColor.a * _OverlayBlend;
col.rgb += overlayCol.rgb;
#else
overlayCol.a *= _OverlayColor.a;
col = lerp(col, col * overlayCol, _OverlayBlend);
#endif
#endif
//---------------------------------
//OUTBASE_ON
#if OUTBASE_ON
#if OUTBASEPIXELPERF_ON
half2 destUv = half2(_OutlinePixelWidth * _MainTex_TexelSize.x, _OutlinePixelWidth * _MainTex_TexelSize.y);
#else
half2 destUv = half2(_OutlineWidth * _MainTex_TexelSize.x * 200, _OutlineWidth * _MainTex_TexelSize.y * 200);
#endif
#if OUTDIST_ON
d.texcoord3.x += ((_Time.x + _RandomSeed) * _OutlineDistortTexXSpeed) % 1;
d.texcoord3.y += ((_Time.x + _RandomSeed) * _OutlineDistortTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord3 = half2((d.texcoord3.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord3.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half outDistortAmnt = (SAMPLE_TEXTURE2D(_OutlineDistortTex, sampler_OutlineDistortTex, d.texcoord3).r - 0.5) * 0.2 * _OutlineDistortAmount;
destUv.x += outDistortAmnt;
destUv.y += outDistortAmnt;
#endif
half spriteLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, 0)).a;
half spriteRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(destUv.x, 0)).a;
half spriteBottom = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(0, destUv.y)).a;
half spriteTop = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy - half2(0, destUv.y)).a;
half result = spriteLeft + spriteRight + spriteBottom + spriteTop;
#if OUTBASE8DIR_ON
half spriteTopLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, destUv.y)).a;
half spriteTopRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, destUv.y)).a;
half spriteBotLeft = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(destUv.x, -destUv.y)).a;
half spriteBotRight = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(-destUv.x, -destUv.y)).a;
result = result + spriteTopLeft + spriteTopRight + spriteBotLeft + spriteBotRight;
#endif
result = step(0.05, saturate(result));
#if OUTTEX_ON
d.texcoord1.x += ((_Time.x + _RandomSeed) * _OutlineTexXSpeed) % 1;
d.texcoord1.y += ((_Time.x + _RandomSeed) * _OutlineTexYSpeed) % 1;
#if ATLAS_ON
d.texcoord1 = half2((d.texcoord1.x - _MinXUV) / (_MaxXUV - _MinXUV), (d.texcoord1.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half4 tempOutColor = SAMPLE_TEXTURE2D(_OutlineTex, sampler_OutlineTex, d.texcoord1);
tempOutColor *= _OutlineColor;
_OutlineColor = tempOutColor;
#endif
result *= (1 - originalAlpha) * _OutlineAlpha;
half4 outline = _OutlineColor * d.vertexColor.a;
outline.rgb *= _OutlineGlow;
outline.a = result;
#if ONLYOUTLINE_ON
col = outline;
#else
col = lerp(col, outline, result);
#endif
#endif
//-------------------------------------------------------
//FADE_ON
#if FADE_ON
half2 tiledUvFade1 = TRANSFORM_TEX(d.texcoord0, _FadeTex);
half2 tiledUvFade2 = TRANSFORM_TEX(d.texcoord0, _FadeBurnTex);
#if ATLAS_ON
tiledUvFade1 = half2((tiledUvFade1.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade1.y - _MinYUV) / (_MaxYUV - _MinYUV));
tiledUvFade2 = half2((tiledUvFade2.x - _MinXUV) / (_MaxXUV - _MinXUV), (tiledUvFade2.y - _MinYUV) / (_MaxYUV - _MinYUV));
#endif
half fadeTemp = SAMPLE_TEXTURE2D(_FadeTex, sampler_FadeTex, tiledUvFade1).r;
half fade = smoothstep(_FadeAmount, _FadeAmount + _FadeBurnTransition, fadeTemp);
half fadeBurn = saturate(smoothstep(_FadeAmount - _FadeBurnWidth, _FadeAmount - _FadeBurnWidth + 0.1, fadeTemp) * _FadeAmount);
col.a *= fade;
_FadeBurnColor.rgb *= _FadeBurnGlow;
col += fadeBurn * SAMPLE_TEXTURE2D(_FadeBurnTex, sampler_FadeBurnTex, tiledUvFade2) * _FadeBurnColor * originalAlpha * (1 - col.a);
#endif
//-------------------------------------------------------
//SHADOW_ON
#if SHADOW_ON
half shadowA = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, d.texcoord0.xy + half2(_ShadowX, _ShadowY)).a;
half preMultShadowMask = 1 - (saturate(shadowA - col.a) * (1 - col.a));
col.rgb *= 1 - ((shadowA - col.a) * (1 - col.a));
col.rgb += (_ShadowColor * shadowA) * (1 - col.a);
col.a = max(shadowA * _ShadowAlpha * d.vertexColor.a, col.a);
#endif
//-------------------------------------------------------
//GLOW_ON
#if GLOW_ON
half4 emission;
#if GLOWTEX_ON
emission = SAMPLE_TEXTURE2D(_GlowTex, sampler_GlowTex, d.texcoord0);
#else
emission = col;
#endif
col.rgb *= _GlowGlobal;
emission.rgb *= emission.a * col.a * _Glow * _GlowColor;
col.rgb += emission.rgb;
#endif
//-------------------------------------------------------
//COLORRAMP_ON && COLORRAMPOUTLINE_ON
#if COLORRAMP_ON && COLORRAMPOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _ColorRampLuminosity);
#if GRADIENTCOLORRAMP_ON
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTexGradient, sampler_ColorRampTexGradient, half2(luminance, 0)).rgb, _ColorRampBlend);
#else
col.rgb = lerp(col.rgb, SAMPLE_TEXTURE2D(_ColorRampTex, sampler_ColorRampTex, half2(luminance, 0)).rgb, _ColorRampBlend);
#endif
#endif
//---------------
//GREYSCALE_ON && GREYSCALEOUTLINE_ON
#if GREYSCALE_ON && GREYSCALEOUTLINE_ON
luminance = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
luminance = saturate(luminance + _GreyscaleLuminosity);
col.rgb = lerp(col.rgb, half3(luminance, luminance, luminance) * _GreyscaleTintColor, _GreyscaleBlend);
#endif
//-----------------------------------
//POSTERIZE_ON && POSTERIZEOUTLINE_ON
#if POSTERIZE_ON && POSTERIZEOUTLINE_ON
col.rgb = pow(col.rgb, _PosterizeGamma) * _PosterizeNumColors;
col.rgb = floor(col.rgb) / _PosterizeNumColors;
col.rgb = pow(col.rgb, 1.0 / _PosterizeGamma);
#endif
//-----------------------------------
//SHINE_ON
#if SHINE_ON
half2 uvShine = uvRect;
half cosAngle = cos(_ShineRotate);
half sinAngle = sin(_ShineRotate);
half2x2 rot = half2x2(cosAngle, -sinAngle, sinAngle, cosAngle);
uvShine -= half2(0.5, 0.5);
uvShine = mul(rot, uvShine);
uvShine += half2(0.5, 0.5);
half shineMask = SAMPLE_TEXTURE2D(_ShineMask, sampler_ShineMask, d.texcoord0.xy).a;
half currentDistanceProjection = (uvShine.x + uvShine.y) / 2;
half whitePower = 1 - (abs(currentDistanceProjection - _ShineLocation) / _ShineWidth);
col.rgb += col.a * whitePower * _ShineGlow * max(sign(currentDistanceProjection - (_ShineLocation - _ShineWidth)), 0.0)
* max(sign((_ShineLocation + _ShineWidth) - currentDistanceProjection), 0.0) * _ShineColor * shineMask;
#endif
//-----------------------------------
//HOLOGRAM_ON
#if HOLOGRAM_ON
half totalHologram = _HologramStripesAmount + _HologramUnmodAmount;
half hologramYCoord = ((uvRect.y + (((_Time.x + randomSeed) % 1) * _HologramStripesSpeed)) % totalHologram) / totalHologram;
hologramYCoord = abs(hologramYCoord);
half alpha = RemapFloat(saturate(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0, 1.0, _HologramMinAlpha, saturate(_HologramMaxAlpha));
half hologramMask = max(sign((_HologramUnmodAmount/totalHologram) - hologramYCoord), 0.0);
half4 hologramResult = col;
hologramResult.a *= lerp(alpha, 1, hologramMask);
hologramResult.rgb *= max(1, _HologramMaxAlpha * max(sign(hologramYCoord - (_HologramUnmodAmount/totalHologram)), 0.0));
hologramMask = 1 - step(0.01,hologramMask);
hologramResult.rgb += hologramMask * _HologramStripeColor * col.a;
col = lerp(col, hologramResult, _HologramBlend);
#endif
//-----------------------------------
//FLICKER_ON
#if FLICKER_ON
col.a *= saturate(col.a * step(frac(0.05 + (_Time.w + randomSeed) * _FlickerFreq), 1 - _FlickerPercent) + _FlickerAlpha);
#endif
//-----------------------------------
//ALPHACUTOFF_ON
//ALPHAROUND_ON
//ALPHAOUTLINE_ON
#if ALPHAOUTLINE_ON
half alphaOutlineRes = pow(1 - col.a, max(_AlphaOutlinePower, 0.0001)) * step(_AlphaOutlineMinAlpha, col.a) * _AlphaOutlineBlend;
col.rgb = lerp(col.rgb, _AlphaOutlineColor.rgb * _AlphaOutlineGlow, alphaOutlineRes);
col.a = lerp(col.a, 1, alphaOutlineRes > 1);
#endif
//-------------------------------------------------------
//FOG_ON
//------------------
col *= _Color;
o.Albedo = col;
col.a *= _Alpha;
clip(col.a - _AlphaCutoffValue - 0.01);
o.Alpha = col.a;
}
void ChainSurfaceFunction(inout Surface l, inout ShaderData d)
{
Ext_SurfaceFunction0(l, d);
// Ext_SurfaceFunction1(l, d);
// Ext_SurfaceFunction2(l, d);
// Ext_SurfaceFunction3(l, d);
// Ext_SurfaceFunction4(l, d);
// Ext_SurfaceFunction5(l, d);
// Ext_SurfaceFunction6(l, d);
// Ext_SurfaceFunction7(l, d);
// Ext_SurfaceFunction8(l, d);
// Ext_SurfaceFunction9(l, d);
// Ext_SurfaceFunction10(l, d);
// Ext_SurfaceFunction11(l, d);
// Ext_SurfaceFunction12(l, d);
// Ext_SurfaceFunction13(l, d);
// Ext_SurfaceFunction14(l, d);
// Ext_SurfaceFunction15(l, d);
// Ext_SurfaceFunction16(l, d);
// Ext_SurfaceFunction17(l, d);
// Ext_SurfaceFunction18(l, d);
// Ext_SurfaceFunction19(l, d);
// Ext_SurfaceFunction20(l, d);
// Ext_SurfaceFunction21(l, d);
// Ext_SurfaceFunction22(l, d);
// Ext_SurfaceFunction23(l, d);
// Ext_SurfaceFunction24(l, d);
// Ext_SurfaceFunction25(l, d);
// Ext_SurfaceFunction26(l, d);
// Ext_SurfaceFunction27(l, d);
// Ext_SurfaceFunction28(l, d);
// Ext_SurfaceFunction29(l, d);
}
#if !_DECALSHADER
void ChainModifyVertex(inout VertexData v, inout VertexToPixel v2p, float4 time)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// due to motion vectors in HDRP, we need to use the last
// time in certain spots. So if you are going to use _Time to adjust vertices,
// you need to use this time or motion vectors will break.
d.time = time;
Ext_ModifyVertex0(v, d);
// Ext_ModifyVertex1(v, d);
// Ext_ModifyVertex2(v, d);
// Ext_ModifyVertex3(v, d);
// Ext_ModifyVertex4(v, d);
// Ext_ModifyVertex5(v, d);
// Ext_ModifyVertex6(v, d);
// Ext_ModifyVertex7(v, d);
// Ext_ModifyVertex8(v, d);
// Ext_ModifyVertex9(v, d);
// Ext_ModifyVertex10(v, d);
// Ext_ModifyVertex11(v, d);
// Ext_ModifyVertex12(v, d);
// Ext_ModifyVertex13(v, d);
// Ext_ModifyVertex14(v, d);
// Ext_ModifyVertex15(v, d);
// Ext_ModifyVertex16(v, d);
// Ext_ModifyVertex17(v, d);
// Ext_ModifyVertex18(v, d);
// Ext_ModifyVertex19(v, d);
// Ext_ModifyVertex20(v, d);
// Ext_ModifyVertex21(v, d);
// Ext_ModifyVertex22(v, d);
// Ext_ModifyVertex23(v, d);
// Ext_ModifyVertex24(v, d);
// Ext_ModifyVertex25(v, d);
// Ext_ModifyVertex26(v, d);
// Ext_ModifyVertex27(v, d);
// Ext_ModifyVertex28(v, d);
// Ext_ModifyVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainModifyTessellatedVertex(inout VertexData v, inout VertexToPixel v2p)
{
ExtraV2F d;
ZERO_INITIALIZE(ExtraV2F, d);
ZERO_INITIALIZE(Blackboard, d.blackboard);
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = v2p.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = v2p.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = v2p.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = v2p.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = v2p.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = v2p.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = v2p.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = v2p.extraV2F7;
// #endif
// Ext_ModifyTessellatedVertex0(v, d);
// Ext_ModifyTessellatedVertex1(v, d);
// Ext_ModifyTessellatedVertex2(v, d);
// Ext_ModifyTessellatedVertex3(v, d);
// Ext_ModifyTessellatedVertex4(v, d);
// Ext_ModifyTessellatedVertex5(v, d);
// Ext_ModifyTessellatedVertex6(v, d);
// Ext_ModifyTessellatedVertex7(v, d);
// Ext_ModifyTessellatedVertex8(v, d);
// Ext_ModifyTessellatedVertex9(v, d);
// Ext_ModifyTessellatedVertex10(v, d);
// Ext_ModifyTessellatedVertex11(v, d);
// Ext_ModifyTessellatedVertex12(v, d);
// Ext_ModifyTessellatedVertex13(v, d);
// Ext_ModifyTessellatedVertex14(v, d);
// Ext_ModifyTessellatedVertex15(v, d);
// Ext_ModifyTessellatedVertex16(v, d);
// Ext_ModifyTessellatedVertex17(v, d);
// Ext_ModifyTessellatedVertex18(v, d);
// Ext_ModifyTessellatedVertex19(v, d);
// Ext_ModifyTessellatedVertex20(v, d);
// Ext_ModifyTessellatedVertex21(v, d);
// Ext_ModifyTessellatedVertex22(v, d);
// Ext_ModifyTessellatedVertex23(v, d);
// Ext_ModifyTessellatedVertex24(v, d);
// Ext_ModifyTessellatedVertex25(v, d);
// Ext_ModifyTessellatedVertex26(v, d);
// Ext_ModifyTessellatedVertex27(v, d);
// Ext_ModifyTessellatedVertex28(v, d);
// Ext_ModifyTessellatedVertex29(v, d);
// #if %EXTRAV2F0REQUIREKEY%
// v2p.extraV2F0 = d.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// v2p.extraV2F1 = d.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// v2p.extraV2F2 = d.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// v2p.extraV2F3 = d.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// v2p.extraV2F4 = d.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// v2p.extraV2F5 = d.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// v2p.extraV2F6 = d.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// v2p.extraV2F7 = d.extraV2F7;
// #endif
}
void ChainFinalColorForward(inout Surface l, inout ShaderData d, inout half4 color)
{
// Ext_FinalColorForward0(l, d, color);
// Ext_FinalColorForward1(l, d, color);
// Ext_FinalColorForward2(l, d, color);
// Ext_FinalColorForward3(l, d, color);
// Ext_FinalColorForward4(l, d, color);
// Ext_FinalColorForward5(l, d, color);
// Ext_FinalColorForward6(l, d, color);
// Ext_FinalColorForward7(l, d, color);
// Ext_FinalColorForward8(l, d, color);
// Ext_FinalColorForward9(l, d, color);
// Ext_FinalColorForward10(l, d, color);
// Ext_FinalColorForward11(l, d, color);
// Ext_FinalColorForward12(l, d, color);
// Ext_FinalColorForward13(l, d, color);
// Ext_FinalColorForward14(l, d, color);
// Ext_FinalColorForward15(l, d, color);
// Ext_FinalColorForward16(l, d, color);
// Ext_FinalColorForward17(l, d, color);
// Ext_FinalColorForward18(l, d, color);
// Ext_FinalColorForward19(l, d, color);
// Ext_FinalColorForward20(l, d, color);
// Ext_FinalColorForward21(l, d, color);
// Ext_FinalColorForward22(l, d, color);
// Ext_FinalColorForward23(l, d, color);
// Ext_FinalColorForward24(l, d, color);
// Ext_FinalColorForward25(l, d, color);
// Ext_FinalColorForward26(l, d, color);
// Ext_FinalColorForward27(l, d, color);
// Ext_FinalColorForward28(l, d, color);
// Ext_FinalColorForward29(l, d, color);
}
void ChainFinalGBufferStandard(inout Surface s, inout ShaderData d, inout half4 GBuffer0, inout half4 GBuffer1, inout half4 GBuffer2, inout half4 outEmission, inout half4 outShadowMask)
{
// Ext_FinalGBufferStandard0(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard1(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard2(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard3(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard4(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard5(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard6(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard7(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard8(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard9(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard10(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard11(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard12(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard13(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard14(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard15(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard16(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard17(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard18(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard19(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard20(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard21(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard22(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard23(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard24(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard25(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard26(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard27(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard28(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
// Ext_FinalGBufferStandard29(s, d, GBuffer0, GBuffer1, GBuffer2, outEmission, outShadowMask);
}
#endif
#if _DECALSHADER
ShaderData CreateShaderData(SurfaceDescriptionInputs IN)
{
ShaderData d = (ShaderData)0;
d.TBNMatrix = float3x3(IN.WorldSpaceTangent, IN.WorldSpaceBiTangent, IN.WorldSpaceNormal);
d.worldSpaceNormal = IN.WorldSpaceNormal;
d.worldSpaceTangent = IN.WorldSpaceTangent;
d.worldSpacePosition = IN.WorldSpacePosition;
d.texcoord0 = IN.uv0.xyxy;
d.screenPos = IN.ScreenPosition;
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - d.worldSpacePosition);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(d.worldSpacePosition), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(d.worldSpacePosition, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), d.worldSpaceTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenUV = (IN.ScreenPosition.xy / max(0.01, IN.ScreenPosition.w));
// #endif
return d;
}
#else
ShaderData CreateShaderData(VertexToPixel i
#if NEED_FACING
, bool facing
#endif
)
{
ShaderData d = (ShaderData)0;
d.clipPos = i.pos;
d.worldSpacePosition = i.worldPos;
d.worldSpaceNormal = normalize(i.worldNormal);
d.worldSpaceTangent.xyz = normalize(i.worldTangent.xyz);
d.tangentSign = i.worldTangent.w * unity_WorldTransformParams.w;
float3 bitangent = cross(d.worldSpaceTangent.xyz, d.worldSpaceNormal) * d.tangentSign;
d.TBNMatrix = float3x3(d.worldSpaceTangent, -bitangent, d.worldSpaceNormal);
d.worldSpaceViewDir = normalize(_WorldSpaceCameraPos - i.worldPos);
d.tangentSpaceViewDir = mul(d.TBNMatrix, d.worldSpaceViewDir);
d.texcoord0 = i.texcoord0;
d.texcoord1 = i.texcoord1;
d.texcoord2 = i.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
d.texcoord3 = i.texcoord3;
// #endif
// d.isFrontFace = facing;
// #if %VERTEXCOLORREQUIREKEY%
d.vertexColor = i.vertexColor;
// #endif
// these rarely get used, so we back transform them. Usually will be stripped.
#if _HDRP
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(GetCameraRelativePositionWS(i.worldPos), 1)).xyz;
#else
// d.localSpacePosition = mul(GetWorldToObjectMatrix(), float4(i.worldPos, 1)).xyz;
#endif
// d.localSpaceNormal = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldNormal));
// d.localSpaceTangent = normalize(mul((float3x3)GetWorldToObjectMatrix(), i.worldTangent.xyz));
// #if %SCREENPOSREQUIREKEY%
// d.screenPos = i.screenPos;
// d.screenUV = (i.screenPos.xy / i.screenPos.w);
// #endif
// #if %EXTRAV2F0REQUIREKEY%
// d.extraV2F0 = i.extraV2F0;
// #endif
// #if %EXTRAV2F1REQUIREKEY%
// d.extraV2F1 = i.extraV2F1;
// #endif
// #if %EXTRAV2F2REQUIREKEY%
// d.extraV2F2 = i.extraV2F2;
// #endif
// #if %EXTRAV2F3REQUIREKEY%
// d.extraV2F3 = i.extraV2F3;
// #endif
// #if %EXTRAV2F4REQUIREKEY%
// d.extraV2F4 = i.extraV2F4;
// #endif
// #if %EXTRAV2F5REQUIREKEY%
// d.extraV2F5 = i.extraV2F5;
// #endif
// #if %EXTRAV2F6REQUIREKEY%
// d.extraV2F6 = i.extraV2F6;
// #endif
// #if %EXTRAV2F7REQUIREKEY%
// d.extraV2F7 = i.extraV2F7;
// #endif
return d;
}
#endif
#if (SHADERPASS == SHADERPASS_LIGHT_TRANSPORT)
// This was not in constant buffer in original unity, so keep outiside. But should be in as ShaderRenderPass frequency
float unity_OneOverOutputBoost;
float unity_MaxOutputValue;
CBUFFER_START(UnityMetaPass)
// x = use uv1 as raster position
// y = use uv2 as raster position
bool4 unity_MetaVertexControl;
// x = return albedo
// y = return normal
bool4 unity_MetaFragmentControl;
CBUFFER_END
VertexToPixel Vert(VertexData inputMesh)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(inputMesh);
UNITY_TRANSFER_INSTANCE_ID(inputMesh, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
// Output UV coordinate in vertex shader
float2 uv = float2(0.0, 0.0);
if (unity_MetaVertexControl.x)
{
uv = inputMesh.texcoord1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
}
else if (unity_MetaVertexControl.y)
{
uv = inputMesh.texcoord2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
}
// OpenGL right now needs to actually use the incoming vertex position
// so we create a fake dependency on it here that haven't any impact.
output.pos = float4(uv * 2.0 - 1.0, inputMesh.vertex.z > 0 ? 1.0e-4 : 0.0, 1.0);
output.worldPos = TransformObjectToWorld(inputMesh.vertex.xyz).xyz;
// Normal is required for triplanar mapping
output.worldNormal = TransformObjectToWorldNormal(inputMesh.normal);
// Not required but assign to silent compiler warning
output.worldTangent = float4(1.0, 0.0, 0.0, 0.0);
output.texcoord0 = inputMesh.texcoord0;
output.texcoord1 = inputMesh.texcoord1;
output.texcoord2 = inputMesh.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = inputMesh.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = inputMesh.vertexColor;
// #endif
return output;
}
#else
#if (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesMatrixDefsHDCamera.hlsl"
void MotionVectorPositionZBias(VertexToPixel input)
{
#if UNITY_REVERSED_Z
input.pos.z -= unity_MotionVectorsParams.z * input.pos.w;
#else
input.pos.z += unity_MotionVectorsParams.z * input.pos.w;
#endif
}
#endif
VertexToPixel Vert(VertexData input)
{
VertexToPixel output;
ZERO_INITIALIZE(VertexToPixel, output);
UNITY_SETUP_INSTANCE_ID(input);
UNITY_TRANSFER_INSTANCE_ID(input, output);
UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
VertexData previousMesh = input;
#endif
ChainModifyVertex(input, output, _Time);
// This return the camera relative position (if enable)
float3 positionRWS = TransformObjectToWorld(input.vertex.xyz);
float3 normalWS = TransformObjectToWorldNormal(input.normal);
float4 tangentWS = float4(TransformObjectToWorldDir(input.tangent.xyz), input.tangent.w);
output.worldPos = GetAbsolutePositionWS(positionRWS);
output.pos = TransformWorldToHClip(positionRWS);
output.worldNormal = normalWS;
output.worldTangent = tangentWS;
output.texcoord0 = input.texcoord0;
output.texcoord1 = input.texcoord1;
output.texcoord2 = input.texcoord2;
// #if %TEXCOORD3REQUIREKEY%
output.texcoord3 = input.texcoord3;
// #endif
// #if %VERTEXCOLORREQUIREKEY%
output.vertexColor = input.vertexColor;
// #endif
// #if %SCREENPOSREQUIREKEY%
// output.screenPos = ComputeScreenPos(output.pos, _ProjectionParams.x);
// #endif
#if _HDRP && (_PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR)))
#if !defined(TESSELLATION_ON)
MotionVectorPositionZBias(output);
#endif
output.motionVectorCS = mul(UNITY_MATRIX_UNJITTERED_VP, float4(positionRWS.xyz, 1.0));
// Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
if (forceNoMotion)
{
output.previousPositionCS = float4(0.0, 0.0, 0.0, 1.0);
}
else
{
bool hasDeformation = unity_MotionVectorsParams.x > 0.0; // Skin or morph target
float3 effectivePositionOS = (hasDeformation ? previousMesh.previousPositionOS : previousMesh.vertex.xyz);
#if defined(_ADD_PRECOMPUTED_VELOCITY)
effectivePositionOS -= input.precomputedVelocity;
#endif
previousMesh.vertex = float4(effectivePositionOS, 1);
VertexToPixel dummy = (VertexToPixel)0;
ChainModifyVertex(previousMesh, dummy, _LastTimeParameters);
// we might need this for skinned objects?
//float3 normalWS = TransformPreviousObjectToWorldNormal(input.normal).xyz;
float3 previousPositionRWS = TransformPreviousObjectToWorld(previousMesh.vertex.xyz);
#ifdef _WRITE_TRANSPARENT_MOTION_VECTOR
if (_TransparentCameraOnlyMotionVectors > 0)
{
previousPositionRWS = positionRWS.xyz;
}
#endif // _WRITE_TRANSPARENT_MOTION_VECTOR
output.previousPositionCS = mul(UNITY_MATRIX_PREV_VP, float4(previousPositionRWS, 1.0));
}
#endif // _HDRP && _PASSMOTIONVECTOR || ((_PASSFORWARD || _PASSUNLIT) && defined(_WRITE_TRANSPARENT_MOTION_VECTOR))
return output;
}
#endif
#if defined(WRITE_DECAL_BUFFER) && !defined(_DISABLE_DECALS)
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalPrepassBuffer.hlsl"
#endif
FragInputs BuildFragInputs(VertexToPixel input)
{
UNITY_SETUP_INSTANCE_ID(input);
FragInputs output;
ZERO_INITIALIZE(FragInputs, output);
// Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used).
// TODO: this is a really poor workaround, but the variable is used in a bunch of places
// to compute normals which are then passed on elsewhere to compute other values...
output.tangentToWorld = k_identity3x3;
output.positionSS = input.pos; // input.positionCS is SV_Position
// BETTER SHADERS: because we transform world position into actual world space for things like
// triplanar, etc, we have to back transform it here for lighting
output.positionRWS = GetCameraRelativePositionWS(input.worldPos);
output.tangentToWorld = BuildTangentToWorld(input.worldTangent, input.worldNormal);
output.texCoord0 = input.texcoord0;
output.texCoord1 = input.texcoord1;
output.texCoord2 = input.texcoord2;
return output;
}
#if UNITY_VERSION > UNITY_2022_3_12
void ApplyDecalAndGetNormal(FragInputs fragInputs, PositionInputs posInput, Surface surfaceDescription, float3 normalTS,
inout SurfaceData surfaceData)
{
float3 doubleSidedConstants = GetDoubleSidedConstants();
#ifdef DECAL_NORMAL_BLENDING
// SG nodes don't ouptut surface gradients, so if decals require surf grad blending, we have to convert
// the normal to gradient before applying the decal. We then have to resolve the gradient back to world space
normalTS = SurfaceGradientFromTangentSpaceNormalAndFromTBN(normalTS,
fragInputs.tangentToWorld[0], fragInputs.tangentToWorld[1]);
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, fragInputs.tangentToWorld[2], normalTS);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
GetNormalWS_SG(fragInputs, normalTS, surfaceData.normalWS, doubleSidedConstants);
#else
// normal delivered to master node
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceNormal(decalSurfaceData, surfaceData.normalWS.xyz);
ApplyDecalToSurfaceDataNoNormal(decalSurfaceData, surfaceData);
}
#endif
#endif
}
#endif
void BuildSurfaceData(FragInputs fragInputs, inout Surface surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS)
{
// setup defaults -- these are used if the graph doesn't output a value
ZERO_INITIALIZE(SurfaceData, surfaceData);
// specularOcclusion need to be init ahead of decal to quiet the compiler that modify the SurfaceData struct
// however specularOcclusion can come from the graph, so need to be init here so it can be override.
surfaceData.specularOcclusion = 1.0;
// copy across graph values, if defined
surfaceData.baseColor = surfaceDescription.Albedo;
surfaceData.perceptualSmoothness = surfaceDescription.Smoothness;
surfaceData.ambientOcclusion = surfaceDescription.Occlusion;
surfaceData.specularOcclusion = surfaceDescription.SpecularOcclusion;
surfaceData.metallic = surfaceDescription.Metallic;
surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask;
surfaceData.thickness = surfaceDescription.Thickness;
surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash);
#if _USESPECULAR
surfaceData.specularColor = surfaceDescription.Specular;
#endif
surfaceData.coatMask = surfaceDescription.CoatMask;
surfaceData.anisotropy = surfaceDescription.Anisotropy;
surfaceData.iridescenceMask = surfaceDescription.IridescenceMask;
surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness;
#if defined(_REFRACTION_PLANE) || defined(_REFRACTION_SPHERE) || defined(_REFRACTION_THIN)
if (_EnableSSRefraction)
{
surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha);
surfaceDescription.Alpha = 1.0;
}
else
{
surfaceData.ior = surfaceDescription.ior;
surfaceData.transmittanceColor = surfaceDescription.transmittanceColor;
surfaceData.atDistance = surfaceDescription.atDistance;
surfaceData.transmittanceMask = surfaceDescription.transmittanceMask;
surfaceDescription.Alpha = 1.0;
}
#else
surfaceData.ior = 1.0;
surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
surfaceData.atDistance = 1.0;
surfaceData.transmittanceMask = 0.0;
#endif
// These static material feature allow compile time optimization
surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD;
#ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING;
#endif
#ifdef _MATERIAL_FEATURE_TRANSMISSION
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION;
#endif
#ifdef _MATERIAL_FEATURE_ANISOTROPY
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY;
surfaceData.normalWS = float3(0, 1, 0);
#endif
#ifdef _MATERIAL_FEATURE_IRIDESCENCE
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE;
#endif
#ifdef _MATERIAL_FEATURE_SPECULAR_COLOR
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR;
#endif
#if defined(_MATERIAL_FEATURE_CLEAR_COAT) || _CLEARCOAT
surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT;
#endif
#if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && defined (_ENERGY_CONSERVING_SPECULAR)
// Require to have setup baseColor
// Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it
surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b));
#endif
float3 normalTS = surfaceDescription.Normal;
#if !_WORLDSPACENORMAL
surfaceData.normalWS = mul(surfaceDescription.Normal, fragInputs.tangentToWorld);
#else
normalTS = mul(fragInputs.tangentToWorld, surfaceDescription.Normal);
surfaceData.normalWS = surfaceDescription.Normal;
#endif
#if UNITY_VERSION > UNITY_2022_3_12
ApplyDecalAndGetNormal(fragInputs, posInput, surfaceDescription, normalTS, surfaceData);
#else
#ifdef DECAL_NORMAL_BLENDING
#if HAVE_DECALS
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
if (_EnableDecals)
{
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData, normalTS);
}
#endif
#else
#if HAVE_DECALS
if (_EnableDecals)
{
float alpha = 1.0;
alpha = surfaceDescription.Alpha;
// Both uses and modifies 'surfaceData.normalWS'.
DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, fragInputs, alpha);
ApplyDecalToSurfaceData(decalSurfaceData, fragInputs.tangentToWorld[2], surfaceData);
}
#endif
#endif
#endif
surfaceData.geomNormalWS = fragInputs.tangentToWorld[2];
surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT
bentNormalWS = surfaceData.normalWS;
surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
#ifdef DEBUG_DISPLAY
if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
{
// TODO: need to update mip info
surfaceData.metallic = 0;
}
// We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData
// as it can modify attribute use for static lighting
ApplyDebugToSurfaceData(fragInputs.tangentToWorld, surfaceData);
#endif
// By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion.
// If user provide bent normal then we process a better term
#if defined(_SPECULAR_OCCLUSION_CUSTOM)
// Just use the value passed through via the slot (not active otherwise)
#elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL)
// If we have bent normal and ambient occlusion, process a specular occlusion
surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness));
#elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO)
surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness));
#endif
#if defined(_ENABLE_GEOMETRIC_SPECULAR_AA) && !defined(SHADER_STAGE_RAY_TRACING)
surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold);
#endif
}
void GetSurfaceAndBuiltinData(VertexToPixel m2ps, FragInputs fragInputs, float3 V, inout PositionInputs posInput,
out SurfaceData surfaceData, out BuiltinData builtinData, inout Surface l, inout ShaderData d
#if NEED_FACING
, bool facing
#endif
)
{
// Removed since crossfade does not work, probably needs extra material setup.
//#if !defined(SHADER_STAGE_RAY_TRACING) && !defined(_TESSELLATION_DISPLACEMENT)
// #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
// LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x);
// #endif
//#endif
d = CreateShaderData(m2ps
#if NEED_FACING
, facing
#endif
);
l = (Surface)0;
l.Albedo = half3(0.5, 0.5, 0.5);
l.Normal = float3(0,0,1);
l.Occlusion = 1;
l.Alpha = 1;
l.SpecularOcclusion = 1;
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
l.outputDepth = d.clipPos.z;
#endif
ChainSurfaceFunction(l, d);
#if !defined(SHADER_STAGE_RAY_TRACING) && defined(_DEPTHOFFSET_ON)
posInput.deviceDepth = l.outputDepth;
#endif
#if _UNLIT
//l.Emission = l.Albedo;
//l.Albedo = 0;
l.Normal = half3(0,0,1);
l.Occlusion = 1;
l.Metallic = 0;
l.Specular = 0;
#endif
surfaceData.geomNormalWS = d.worldSpaceNormal;
surfaceData.tangentWS = d.worldSpaceTangent;
fragInputs.tangentToWorld = d.TBNMatrix;
float3 bentNormalWS;
BuildSurfaceData(fragInputs, l, V, posInput, surfaceData, bentNormalWS);
float4 lightmapTexCoord1 = fragInputs.texCoord1;
float4 lightmapTexCoord2 = fragInputs.texCoord2;
//#ifdef FRAG_INPUTS_USE_TEXCOORD1
// float4 lightmapTexCoord1 = fragInputs.texCoord1;
// #else
// float4 lightmapTexCoord1 = float4(0,0,0,0);
// #endif
// #ifdef FRAG_INPUTS_USE_TEXCOORD2
// float4 lightmapTexCoord2 = fragInputs.texCoord2;
// #else
// float4 lightmapTexCoord2 = float4(0,0,0,0);
// #endif
InitBuiltinData(posInput, l.Alpha, bentNormalWS, -d.worldSpaceNormal, lightmapTexCoord1, lightmapTexCoord2, builtinData);
builtinData.emissiveColor = l.Emission;
#if defined(_OVERRIDE_BAKEDGI)
builtinData.bakeDiffuseLighting = l.DiffuseGI;
builtinData.backBakeDiffuseLighting = l.BackDiffuseGI;
builtinData.emissiveColor += l.SpecularGI;
#endif
#if defined(_OVERRIDE_SHADOWMASK)
builtinData.shadowMask0 = l.ShadowMask.x;
builtinData.shadowMask1 = l.ShadowMask.y;
builtinData.shadowMask2 = l.ShadowMask.z;
builtinData.shadowMask3 = l.ShadowMask.w;
#endif
#ifdef UNITY_VIRTUAL_TEXTURING
//builtinData.vtPackedFeedback = surfaceData.VTPackedFeedback;
#endif
#if (SHADERPASS == SHADERPASS_DISTORTION)
builtinData.distortion = surfaceData.Distortion;
builtinData.distortionBlur = surfaceData.DistortionBlur;
#endif
#ifndef SHADER_UNLIT
// PostInitBuiltinData call ApplyDebugToBuiltinData
PostInitBuiltinData(V, posInput, surfaceData, builtinData);
#else
ApplyDebugToBuiltinData(builtinData);
#endif
RAY_TRACING_OPTIONAL_ALPHA_TEST_PASS
}
#define DEBUG_DISPLAY
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl"
#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/FullScreenDebug.hlsl"
#if !defined(_DEPTHOFFSET_ON)
[earlydepthstencil] // quad overshading debug mode writes to UAV
#endif
void Frag(VertexToPixel v2f
#if NEED_FACING
, bool facing : SV_IsFrontFace
#endif
)
{
UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(v2f);
FragInputs input = BuildFragInputs(v2f);
PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, input.positionSS.z, input.positionSS.w, input.positionRWS.xyz);
#ifdef PLATFORM_SUPPORTS_PRIMITIVE_ID_IN_PIXEL_SHADER
if (_DebugFullScreenMode == FULLSCREENDEBUGMODE_QUAD_OVERDRAW)
{
IncrementQuadOverdrawCounter(posInput.positionSS.xy, input.primitiveID);
}
#endif
}
ENDHLSL
}
}
CustomEditor "AllIn1SpriteShaderLitMaterialInspector"
}
Reference in New Issue Copy Permalink