diff --git a/Assets/Shaders/PlayerCamo.hlsl b/Assets/Shaders/PlayerCamo.hlsl new file mode 100644 index 0000000..2bf6bc9 --- /dev/null +++ b/Assets/Shaders/PlayerCamo.hlsl @@ -0,0 +1,228 @@ +#ifndef PLAYER_CAMO_INCLUDED +#define PLAYER_CAMO_INCLUDED + +// Camouflage lighting for the player avatar. Goal: keep the player lit by the scene (so its +// brightness matches the surroundings) but de-emphasise the 3D FORM, so a correctly painted +// avatar is harder to spot. Three independent, tunable knobs - all 0 => byte-identical URP/Lit: +// +// _FormSoftness (0..1) : bends the per-pixel normal toward the view direction before shading. +// Flattens diffuse + specular + reflections together -> the silhouette +// shading that reveals curvature softens from every light angle. +// _HalfLambert (0..1) : wraps the DIRECT diffuse term, saturate(N.L) -> N.L*0.5+0.5, lifting +// the shadow side (classic half-Lambert). Specular stays clamped. +// _SpecularDampen (0..1) : scales down the DIRECT specular highlight (a strong shape cue). +// +// Implementation note: URP's LightingPhysicallyBased() hard-codes saturate(N.L) inline with no +// override hook, so a faithful half-Lambert needs the forward light loop reimplemented. This file +// is a 1:1 copy of URP 17.3 UniversalFragmentPBR that delegates ALL the fragile parts (GI / APV / +// shadow mask / AO / clustered light loop / final color) to URP's own helpers and only swaps the +// per-light shading call for the camo variant below. +// +// Declared OUTSIDE UnityPerMaterial (LitInput.hlsl owns that CBUFFER). The player is a handful of +// instances, so the resulting SRP-batcher break is irrelevant. +half _FormSoftness; +half _HalfLambert; +half _SpecularDampen; + +// Bend the shading normal toward the camera. n and viewDirWS are unit; for a visible (front-facing) +// fragment N.V > 0, so the lerp never collapses to zero - SafeNormalize guards the rare grazing case. +half3 SoftenNormalCamo(half3 normalWS, half3 viewDirWS) +{ + half3 n = lerp(normalWS, viewDirWS, _FormSoftness); + return half3(SafeNormalize(n)); +} + +// Per-light shading: copy of URP's LightingPhysicallyBased with the diffuse term wrapped +// (half-Lambert) and the specular term dampened. Diffuse and specular use SEPARATE radiance so the +// wrap lifts only the diffuse shadow side and never smears specular onto back faces. +half3 LightingPhysicallyBasedCamo(BRDFData brdfData, BRDFData brdfDataClearCoat, + half3 lightColor, half3 lightDirectionWS, float lightAttenuation, + half3 normalWS, half3 viewDirectionWS, + half clearCoatMask, bool specularHighlightsOff) +{ + half NdotL = dot(normalWS, lightDirectionWS); + half ndlSat = saturate(NdotL); + half diffuseTerm = lerp(ndlSat, NdotL * 0.5h + 0.5h, _HalfLambert); + + half3 atten = lightColor * lightAttenuation; + half3 diffuseRadiance = atten * diffuseTerm; // wrapped (half-Lambert) + half3 specularRadiance = atten * ndlSat; // clamped (no back-face specular) + + half3 color = brdfData.diffuse * diffuseRadiance; + +#ifndef _SPECULARHIGHLIGHTS_OFF + [branch] if (!specularHighlightsOff) + { + half3 spec = brdfData.specular * DirectBRDFSpecular(brdfData, normalWS, lightDirectionWS, viewDirectionWS); + +#if defined(_CLEARCOAT) || defined(_CLEARCOATMAP) + // Inert for URP/Lit (no clear-coat keywords on the forward pass); kept for fidelity. + half brdfCoat = kDielectricSpec.r * DirectBRDFSpecular(brdfDataClearCoat, normalWS, lightDirectionWS, viewDirectionWS); + half NoV = saturate(dot(normalWS, viewDirectionWS)); + half coatFresnel = kDielectricSpec.x + kDielectricSpec.a * Pow4(1.0 - NoV); + spec = spec * (1.0 - clearCoatMask * coatFresnel) + (brdfCoat * clearCoatMask).xxx; +#endif + + spec *= (1.0h - _SpecularDampen); + color += spec * specularRadiance; + } +#endif + + return color; +} + +half3 LightingPhysicallyBasedCamo(BRDFData brdfData, BRDFData brdfDataClearCoat, Light light, + half3 normalWS, half3 viewDirectionWS, half clearCoatMask, bool specularHighlightsOff) +{ + return LightingPhysicallyBasedCamo(brdfData, brdfDataClearCoat, light.color, light.direction, + light.distanceAttenuation * light.shadowAttenuation, normalWS, viewDirectionWS, + clearCoatMask, specularHighlightsOff); +} + +// Faithful copy of URP 17.3 UniversalFragmentPBR. ONLY change vs. stock: the three per-light calls +// go to LightingPhysicallyBasedCamo (above). Everything else delegates to URP unchanged. +half4 UniversalFragmentCamo(InputData inputData, SurfaceData surfaceData) +{ + #if defined(_SPECULARHIGHLIGHTS_OFF) + bool specularHighlightsOff = true; + #else + bool specularHighlightsOff = false; + #endif + BRDFData brdfData; + + // NOTE: can modify "surfaceData"... + InitializeBRDFData(surfaceData, brdfData); + + #if defined(DEBUG_DISPLAY) + half4 debugColor; + if (CanDebugOverrideOutputColor(inputData, surfaceData, brdfData, debugColor)) + { + return debugColor; + } + #endif + + BRDFData brdfDataClearCoat = CreateClearCoatBRDFData(surfaceData, brdfData); + half4 shadowMask = CalculateShadowMask(inputData); + AmbientOcclusionFactor aoFactor = CreateAmbientOcclusionFactor(inputData, surfaceData); + uint meshRenderingLayers = GetMeshRenderingLayer(); + Light mainLight = GetMainLight(inputData, shadowMask, aoFactor); + + MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI); + + LightingData lightingData = CreateLightingData(inputData, surfaceData); + + lightingData.giColor = GlobalIllumination(brdfData, brdfDataClearCoat, surfaceData.clearCoatMask, + inputData.bakedGI, aoFactor.indirectAmbientOcclusion, inputData.positionWS, + inputData.normalWS, inputData.viewDirectionWS, inputData.normalizedScreenSpaceUV); +#ifdef _LIGHT_LAYERS + if (IsMatchingLightLayer(mainLight.layerMask, meshRenderingLayers)) +#endif + { + lightingData.mainLightColor = LightingPhysicallyBasedCamo(brdfData, brdfDataClearCoat, + mainLight, + inputData.normalWS, inputData.viewDirectionWS, + surfaceData.clearCoatMask, specularHighlightsOff); + } + + #if defined(_ADDITIONAL_LIGHTS) + uint pixelLightCount = GetAdditionalLightsCount(); + + #if USE_CLUSTER_LIGHT_LOOP + [loop] for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++) + { + CLUSTER_LIGHT_LOOP_SUBTRACTIVE_LIGHT_CHECK + + Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor); + +#ifdef _LIGHT_LAYERS + if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers)) +#endif + { + lightingData.additionalLightsColor += LightingPhysicallyBasedCamo(brdfData, brdfDataClearCoat, light, + inputData.normalWS, inputData.viewDirectionWS, + surfaceData.clearCoatMask, specularHighlightsOff); + } + } + #endif + + LIGHT_LOOP_BEGIN(pixelLightCount) + Light light = GetAdditionalLight(lightIndex, inputData, shadowMask, aoFactor); + +#ifdef _LIGHT_LAYERS + if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers)) +#endif + { + lightingData.additionalLightsColor += LightingPhysicallyBasedCamo(brdfData, brdfDataClearCoat, light, + inputData.normalWS, inputData.viewDirectionWS, + surfaceData.clearCoatMask, specularHighlightsOff); + } + LIGHT_LOOP_END + #endif + + #if defined(_ADDITIONAL_LIGHTS_VERTEX) + lightingData.vertexLightingColor += inputData.vertexLighting * brdfData.diffuse; + #endif + +#if REAL_IS_HALF + return min(CalculateFinalColor(lightingData, surfaceData.alpha), HALF_MAX); +#else + return CalculateFinalColor(lightingData, surfaceData.alpha); +#endif +} + +// Replicates URP's LitPassFragment body and inserts the normal-soften step before GI + lighting, +// so GI (probe) direction, direct lighting and reflections all use the flattened normal. +void CamoForwardFragment( + Varyings input + , out half4 outColor : SV_Target0 +#ifdef _WRITE_RENDERING_LAYERS + , out uint outRenderingLayers : SV_Target1 +#endif +) +{ + UNITY_SETUP_INSTANCE_ID(input); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); + +#if defined(_PARALLAXMAP) +#if defined(REQUIRES_TANGENT_SPACE_VIEW_DIR_INTERPOLATOR) + half3 viewDirTS = input.viewDirTS; +#else + half3 viewDirWS = GetWorldSpaceNormalizeViewDir(input.positionWS); + half3 viewDirTS = GetViewDirectionTangentSpace(input.tangentWS, input.normalWS, viewDirWS); +#endif + ApplyPerPixelDisplacement(viewDirTS, input.uv); +#endif + + SurfaceData surfaceData; + InitializeStandardLitSurfaceData(input.uv, surfaceData); + +#ifdef LOD_FADE_CROSSFADE + LODFadeCrossFade(input.positionCS); +#endif + + InputData inputData; + InitializeInputData(input, surfaceData.normalTS, inputData); + + // Camo: flatten the shading normal toward the camera (no-op when _FormSoftness == 0). + inputData.normalWS = SoftenNormalCamo(inputData.normalWS, inputData.viewDirectionWS); + + SETUP_DEBUG_TEXTURE_DATA(inputData, UNDO_TRANSFORM_TEX(input.uv, _BaseMap)); + +#if defined(_DBUFFER) + ApplyDecalToSurfaceData(input.positionCS, surfaceData, inputData); +#endif + + InitializeBakedGIData(input, inputData); + + half4 color = UniversalFragmentCamo(inputData, surfaceData); + color.rgb = MixFog(color.rgb, inputData.fogCoord); + color.a = OutputAlpha(color.a, IsSurfaceTypeTransparent(_Surface)); + + outColor = color; + +#ifdef _WRITE_RENDERING_LAYERS + outRenderingLayers = EncodeMeshRenderingLayer(); +#endif +} + +#endif diff --git a/Assets/Shaders/PlayerCamo.hlsl.meta b/Assets/Shaders/PlayerCamo.hlsl.meta new file mode 100644 index 0000000..9587d27 --- /dev/null +++ b/Assets/Shaders/PlayerCamo.hlsl.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: b3db7f737eb30334c8bcfd1bd71a83ad +ShaderIncludeImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Shaders/PlayerCamoLit.shader b/Assets/Shaders/PlayerCamoLit.shader new file mode 100644 index 0000000..533fc90 --- /dev/null +++ b/Assets/Shaders/PlayerCamoLit.shader @@ -0,0 +1,544 @@ +// Drop-in clone of "Universal Render Pipeline/Lit" (URP 17) for the PLAYER avatar that adds +// camouflage lighting: the player stays lit by the scene (matching its surroundings) but its 3D +// form is de-emphasised, so a correctly painted avatar is harder to spot. See PlayerCamo.hlsl. +// +// Faithful copy of URP's Lit.shader - same properties, keywords and includes, so material values +// transfer 1:1, the Lit inspector keeps working, and the runtime MeshPainter (which only sets +// _BaseColor / PBR keywords on the material instance) is unaffected. The ONLY change is the +// ForwardLit pass: its fragment is CamoForwardFragment, which reimplements URP's forward shading +// while delegating GI / shadows / clustered lights to URP and applying the three camo knobs. All +// other passes (ShadowCaster, GBuffer, DepthOnly, DepthNormals, Meta, ...) are stock URP/Lit. +Shader "Custom/PlayerCamoLit" +{ + Properties + { + // --- Camouflage knobs (all 0 => identical to URP/Lit) --- + [Header(Camouflage)] + _FormSoftness("Form Softness (normal -> view)", Range(0.0, 1.0)) = 0.4 + _HalfLambert("Half Lambert (lift shadow side)", Range(0.0, 1.0)) = 0.5 + _SpecularDampen("Specular Dampen", Range(0.0, 1.0)) = 0.5 + + // Specular vs Metallic workflow + _WorkflowMode("WorkflowMode", Float) = 1.0 + + [MainTexture] _BaseMap("Albedo", 2D) = "white" {} + [MainColor] _BaseColor("Color", Color) = (1,1,1,1) + + _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5 + + _Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5 + _SmoothnessTextureChannel("Smoothness texture channel", Float) = 0 + + _Metallic("Metallic", Range(0.0, 1.0)) = 0.0 + _MetallicGlossMap("Metallic", 2D) = "white" {} + + _SpecColor("Specular", Color) = (0.2, 0.2, 0.2) + _SpecGlossMap("Specular", 2D) = "white" {} + + [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0 + [ToggleOff] _EnvironmentReflections("Environment Reflections", Float) = 1.0 + + _BumpScale("Scale", Float) = 1.0 + _BumpMap("Normal Map", 2D) = "bump" {} + + _Parallax("Scale", Range(0.005, 0.08)) = 0.005 + _ParallaxMap("Height Map", 2D) = "black" {} + + _OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0 + _OcclusionMap("Occlusion", 2D) = "white" {} + + [HDR] _EmissionColor("Color", Color) = (0,0,0) + _EmissionMap("Emission", 2D) = "white" {} + + _DetailMask("Detail Mask", 2D) = "white" {} + _DetailAlbedoMapScale("Scale", Range(0.0, 2.0)) = 1.0 + _DetailAlbedoMap("Detail Albedo x2", 2D) = "linearGrey" {} + _DetailNormalMapScale("Scale", Range(0.0, 2.0)) = 1.0 + [Normal] _DetailNormalMap("Normal Map", 2D) = "bump" {} + + // SRP batching compatibility for Clear Coat (Not used in Lit) + [HideInInspector] _ClearCoatMask("_ClearCoatMask", Float) = 0.0 + [HideInInspector] _ClearCoatSmoothness("_ClearCoatSmoothness", Float) = 0.0 + + // Blending state + _Surface("__surface", Float) = 0.0 + _Blend("__blend", Float) = 0.0 + _Cull("__cull", Float) = 2.0 + [ToggleUI] _AlphaClip("__clip", Float) = 0.0 + [HideInInspector] _SrcBlend("__src", Float) = 1.0 + [HideInInspector] _DstBlend("__dst", Float) = 0.0 + [HideInInspector] _SrcBlendAlpha("__srcA", Float) = 1.0 + [HideInInspector] _DstBlendAlpha("__dstA", Float) = 0.0 + [HideInInspector] _ZWrite("__zw", Float) = 1.0 + [HideInInspector] _BlendModePreserveSpecular("_BlendModePreserveSpecular", Float) = 1.0 + [HideInInspector] _AlphaToMask("__alphaToMask", Float) = 0.0 + [HideInInspector] _AddPrecomputedVelocity("_AddPrecomputedVelocity", Float) = 0.0 + [HideInInspector] _XRMotionVectorsPass("_XRMotionVectorsPass", Float) = 1.0 + + [ToggleUI] _ReceiveShadows("Receive Shadows", Float) = 1.0 + // Editmode props + _QueueOffset("Queue offset", Float) = 0.0 + + // ObsoleteProperties + [HideInInspector] _MainTex("BaseMap", 2D) = "white" {} + [HideInInspector] _Color("Base Color", Color) = (1, 1, 1, 1) + [HideInInspector] _GlossMapScale("Smoothness", Float) = 0.0 + [HideInInspector] _Glossiness("Smoothness", Float) = 0.0 + [HideInInspector] _GlossyReflections("EnvironmentReflections", Float) = 0.0 + + [HideInInspector][NoScaleOffset]unity_Lightmaps("unity_Lightmaps", 2DArray) = "" {} + [HideInInspector][NoScaleOffset]unity_LightmapsInd("unity_LightmapsInd", 2DArray) = "" {} + [HideInInspector][NoScaleOffset]unity_ShadowMasks("unity_ShadowMasks", 2DArray) = "" {} + } + + SubShader + { + Tags + { + "RenderType" = "Opaque" + "RenderPipeline" = "UniversalPipeline" + "UniversalMaterialType" = "Lit" + "IgnoreProjector" = "True" + } + LOD 300 + + // ------------------------------------------------------------------ + // Forward pass. Shades all light in a single pass. GI + emission + Fog + Pass + { + Name "ForwardLit" + Tags + { + "LightMode" = "UniversalForward" + } + + // ------------------------------------- + // Render State Commands + Blend[_SrcBlend][_DstBlend], [_SrcBlendAlpha][_DstBlendAlpha] + ZWrite[_ZWrite] + Cull[_Cull] + AlphaToMask[_AlphaToMask] + + HLSLPROGRAM + #pragma target 2.0 + + // ------------------------------------- + // Shader Stages + #pragma vertex LitPassVertex + #pragma fragment CamoForwardFragment + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local _NORMALMAP + #pragma shader_feature_local _PARALLAXMAP + #pragma shader_feature_local _RECEIVE_SHADOWS_OFF + #pragma shader_feature_local _ _DETAIL_MULX2 _DETAIL_SCALED + #pragma shader_feature_local_fragment _SURFACE_TYPE_TRANSPARENT + #pragma shader_feature_local_fragment _ALPHATEST_ON + #pragma shader_feature_local_fragment _ _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON + #pragma shader_feature_local_fragment _EMISSION + #pragma shader_feature_local_fragment _METALLICSPECGLOSSMAP + #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A + #pragma shader_feature_local_fragment _OCCLUSIONMAP + #pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF + #pragma shader_feature_local_fragment _ENVIRONMENTREFLECTIONS_OFF + #pragma shader_feature_local_fragment _SPECULAR_SETUP + + // ------------------------------------- + // Universal Pipeline keywords + #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN + #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS + #pragma multi_compile _ EVALUATE_SH_MIXED EVALUATE_SH_VERTEX + #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS + #pragma multi_compile_fragment _ _REFLECTION_PROBE_BLENDING + #pragma multi_compile_fragment _ _REFLECTION_PROBE_BOX_PROJECTION + #pragma multi_compile_fragment _ _REFLECTION_PROBE_ATLAS + #pragma multi_compile_fragment _ _SHADOWS_SOFT _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH + #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION + #pragma multi_compile_fragment _ _SCREEN_SPACE_IRRADIANCE + #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3 + #pragma multi_compile_fragment _ _LIGHT_COOKIES + #pragma multi_compile _ _LIGHT_LAYERS + #pragma multi_compile _ _CLUSTER_LIGHT_LOOP + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + + + // ------------------------------------- + // Unity defined keywords + #pragma multi_compile _ LIGHTMAP_SHADOW_MIXING + #pragma multi_compile _ SHADOWS_SHADOWMASK + #pragma multi_compile _ DIRLIGHTMAP_COMBINED + #pragma multi_compile _ LIGHTMAP_ON + #pragma multi_compile_fragment _ LIGHTMAP_BICUBIC_SAMPLING + #pragma multi_compile_fragment _ REFLECTION_PROBE_ROTATION + #pragma multi_compile _ DYNAMICLIGHTMAP_ON + #pragma multi_compile _ USE_LEGACY_LIGHTMAPS + #pragma multi_compile _ LOD_FADE_CROSSFADE + #pragma multi_compile_fragment _ DEBUG_DISPLAY + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Fog.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ProbeVolumeVariants.hlsl" + + //-------------------------------------- + // GPU Instancing + #pragma multi_compile_instancing + #pragma instancing_options renderinglayer + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitForwardPass.hlsl" + #include "PlayerCamo.hlsl" + ENDHLSL + } + + Pass + { + Name "ShadowCaster" + Tags + { + "LightMode" = "ShadowCaster" + } + + // ------------------------------------- + // Render State Commands + ZWrite On + ZTest LEqual + ColorMask 0 + Cull[_Cull] + + HLSLPROGRAM + #pragma target 2.0 + + // ------------------------------------- + // Shader Stages + #pragma vertex ShadowPassVertex + #pragma fragment ShadowPassFragment + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local _ALPHATEST_ON + #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A + + //-------------------------------------- + // GPU Instancing + #pragma multi_compile_instancing + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + + // ------------------------------------- + // Universal Pipeline keywords + + // ------------------------------------- + // Unity defined keywords + #pragma multi_compile _ LOD_FADE_CROSSFADE + + // This is used during shadow map generation to differentiate between directional and punctual light shadows, as they use different formulas to apply Normal Bias + #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW + + // ------------------------------------- + // Includes + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl" + ENDHLSL + } + + Pass + { + Name "GBuffer" + Tags + { + "LightMode" = "UniversalGBuffer" + } + + // ------------------------------------- + // Render State Commands + ZWrite[_ZWrite] + ZTest LEqual + Cull[_Cull] + + HLSLPROGRAM + #pragma target 4.5 + + // Deferred Rendering Path does not support the OpenGL-based graphics API: + // Desktop OpenGL, OpenGL ES 3.0, WebGL 2.0. + #pragma exclude_renderers gles3 glcore + + // ------------------------------------- + // Shader Stages + #pragma vertex LitGBufferPassVertex + #pragma fragment LitGBufferPassFragment + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local _NORMALMAP + #pragma shader_feature_local_fragment _ALPHATEST_ON + //#pragma shader_feature_local_fragment _ALPHAPREMULTIPLY_ON + #pragma shader_feature_local_fragment _EMISSION + #pragma shader_feature_local_fragment _METALLICSPECGLOSSMAP + #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A + #pragma shader_feature_local_fragment _OCCLUSIONMAP + #pragma shader_feature_local _PARALLAXMAP + #pragma shader_feature_local _ _DETAIL_MULX2 _DETAIL_SCALED + + #pragma shader_feature_local_fragment _SPECULARHIGHLIGHTS_OFF + #pragma shader_feature_local_fragment _ENVIRONMENTREFLECTIONS_OFF + #pragma shader_feature_local_fragment _SPECULAR_SETUP + #pragma shader_feature_local _RECEIVE_SHADOWS_OFF + + // ------------------------------------- + // Universal Pipeline keywords + #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN + //#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS + //#pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS + #pragma multi_compile_fragment _ _REFLECTION_PROBE_BLENDING + #pragma multi_compile_fragment _ _REFLECTION_PROBE_BOX_PROJECTION + #pragma multi_compile_fragment _ _SHADOWS_SOFT _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH + #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3 + #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED + #pragma multi_compile _ _CLUSTER_LIGHT_LOOP + #pragma multi_compile _ EVALUATE_SH_MIXED EVALUATE_SH_VERTEX + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + + // ------------------------------------- + // Unity defined keywords + #pragma multi_compile _ LIGHTMAP_SHADOW_MIXING + #pragma multi_compile _ SHADOWS_SHADOWMASK + #pragma multi_compile _ DIRLIGHTMAP_COMBINED + #pragma multi_compile _ LIGHTMAP_ON + #pragma multi_compile_fragment _ LIGHTMAP_BICUBIC_SAMPLING + #pragma multi_compile_fragment _ REFLECTION_PROBE_ROTATION + #pragma multi_compile _ DYNAMICLIGHTMAP_ON + #pragma multi_compile _ USE_LEGACY_LIGHTMAPS + #pragma multi_compile _ LOD_FADE_CROSSFADE + #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT + #pragma multi_compile_fragment _ _SCREEN_SPACE_IRRADIANCE + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ProbeVolumeVariants.hlsl" + + //-------------------------------------- + // GPU Instancing + #pragma multi_compile_instancing + #pragma instancing_options renderinglayer + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + + // ------------------------------------- + // Includes + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitGBufferPass.hlsl" + ENDHLSL + } + + Pass + { + Name "DepthOnly" + Tags + { + "LightMode" = "DepthOnly" + } + + // ------------------------------------- + // Render State Commands + ZWrite On + ColorMask R + Cull[_Cull] + + HLSLPROGRAM + #pragma target 2.0 + + // ------------------------------------- + // Shader Stages + #pragma vertex DepthOnlyVertex + #pragma fragment DepthOnlyFragment + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local _ALPHATEST_ON + #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A + + // ------------------------------------- + // Unity defined keywords + #pragma multi_compile _ LOD_FADE_CROSSFADE + + //-------------------------------------- + // GPU Instancing + #pragma multi_compile_instancing + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + + // ------------------------------------- + // Includes + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl" + ENDHLSL + } + + // This pass is used when drawing to a _CameraNormalsTexture texture + Pass + { + Name "DepthNormals" + Tags + { + "LightMode" = "DepthNormals" + } + + // ------------------------------------- + // Render State Commands + ZWrite On + Cull[_Cull] + + HLSLPROGRAM + #pragma target 2.0 + + // ------------------------------------- + // Shader Stages + #pragma vertex DepthNormalsVertex + #pragma fragment DepthNormalsFragment + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local _NORMALMAP + #pragma shader_feature_local _PARALLAXMAP + #pragma shader_feature_local _ _DETAIL_MULX2 _DETAIL_SCALED + #pragma shader_feature_local _ALPHATEST_ON + #pragma shader_feature_local_fragment _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A + + // ------------------------------------- + // Unity defined keywords + #pragma multi_compile _ LOD_FADE_CROSSFADE + + // ------------------------------------- + // Universal Pipeline keywords + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + + //-------------------------------------- + // GPU Instancing + #pragma multi_compile_instancing + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + + // ------------------------------------- + // Includes + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitDepthNormalsPass.hlsl" + ENDHLSL + } + + // This pass it not used during regular rendering, only for lightmap baking. + Pass + { + Name "Meta" + Tags + { + "LightMode" = "Meta" + } + + // ------------------------------------- + // Render State Commands + Cull Off + + HLSLPROGRAM + #pragma target 2.0 + + // ------------------------------------- + // Shader Stages + #pragma vertex UniversalVertexMeta + #pragma fragment UniversalFragmentMetaLit + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local_fragment _SPECULAR_SETUP + #pragma shader_feature_local_fragment _EMISSION + #pragma shader_feature_local_fragment _METALLICSPECGLOSSMAP + #pragma shader_feature_local_fragment _ALPHATEST_ON + #pragma shader_feature_local_fragment _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A + #pragma shader_feature_local _ _DETAIL_MULX2 _DETAIL_SCALED + #pragma shader_feature_local_fragment _SPECGLOSSMAP + #pragma shader_feature EDITOR_VISUALIZATION + + // ------------------------------------- + // Includes + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitMetaPass.hlsl" + + ENDHLSL + } + + Pass + { + Name "Universal2D" + Tags + { + "LightMode" = "Universal2D" + } + + // ------------------------------------- + // Render State Commands + Blend[_SrcBlend][_DstBlend] + ZWrite[_ZWrite] + Cull[_Cull] + + HLSLPROGRAM + #pragma target 2.0 + + // ------------------------------------- + // Shader Stages + #pragma vertex vert + #pragma fragment frag + + // ------------------------------------- + // Material Keywords + #pragma shader_feature_local_fragment _ALPHATEST_ON + #pragma shader_feature_local_fragment _ALPHAPREMULTIPLY_ON + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + + // ------------------------------------- + // Includes + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Shaders/Utils/Universal2D.hlsl" + ENDHLSL + } + + Pass + { + Name "MotionVectors" + Tags { "LightMode" = "MotionVectors" } + ColorMask RG + + HLSLPROGRAM + #pragma shader_feature_local _ALPHATEST_ON + #pragma multi_compile _ LOD_FADE_CROSSFADE + #pragma shader_feature_local_vertex _ADD_PRECOMPUTED_VELOCITY + + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ObjectMotionVectors.hlsl" + ENDHLSL + } + + Pass + { + Name "XRMotionVectors" + Tags { "LightMode" = "XRMotionVectors" } + ColorMask RGBA + + // Stencil write for obj motion pixels + Stencil + { + WriteMask 1 + Ref 1 + Comp Always + Pass Replace + } + + HLSLPROGRAM + #pragma shader_feature_local _ALPHATEST_ON + #pragma multi_compile _ LOD_FADE_CROSSFADE + #pragma shader_feature_local_vertex _ADD_PRECOMPUTED_VELOCITY + #define APPLICATION_SPACE_WARP_MOTION 1 + + #include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ObjectMotionVectors.hlsl" + ENDHLSL + } + } + + FallBack "Hidden/Universal Render Pipeline/FallbackError" + //CustomEditor "UnityEditor.Rendering.Universal.ShaderGUI.LitShader" +} diff --git a/Assets/Shaders/PlayerCamoLit.shader.meta b/Assets/Shaders/PlayerCamoLit.shader.meta new file mode 100644 index 0000000..2795391 --- /dev/null +++ b/Assets/Shaders/PlayerCamoLit.shader.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 7b3dd5720b6152047b45788060d64904 +ShaderImporter: + externalObjects: {} + defaultTextures: [] + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: