You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
925a8fe75c
This logic took primitives with a material using static lighting and moved velocity writing to a second pass. Seems like that is some old behavior and after asking around it isn't well known why we had it. Anyway it's not good to pay the cost of that second pass, so removing that. #preflight 628fd8f574630984fd4d4464 #ROBOMERGE-AUTHOR: jeremy.moore #ROBOMERGE-SOURCE: CL 20392160 via CL 20392172 via CL 20392182 #ROBOMERGE-BOT: UE5 (Release-Engine-Staging -> Main) (v949-20362246) [CL 20398501 by jeremy moore in ue5-main branch]
142 lines
8.6 KiB
Plaintext
142 lines
8.6 KiB
Plaintext
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
BasePassCommon.ush: Base pass definitions used by both vertex and pixel shader
|
|
=============================================================================*/
|
|
|
|
#if MATERIALBLENDING_ANY_TRANSLUCENT
|
|
#define ForwardLightData TranslucentBasePass.Shared.Forward
|
|
#define ReflectionStruct TranslucentBasePass.Shared.Reflection
|
|
#define PlanarReflectionStruct TranslucentBasePass.Shared.PlanarReflection
|
|
#define FogStruct TranslucentBasePass.Shared.Fog
|
|
#else
|
|
#define ForwardLightData OpaqueBasePass.Shared.Forward
|
|
#define ReflectionStruct OpaqueBasePass.Shared.Reflection
|
|
#define PlanarReflectionStruct OpaqueBasePass.Shared.PlanarReflection
|
|
#define FogStruct OpaqueBasePass.Shared.Fog
|
|
#endif
|
|
|
|
#undef NEEDS_LIGHTMAP_COORDINATE
|
|
|
|
#define NEEDS_LIGHTMAP_COORDINATE (HQ_TEXTURE_LIGHTMAP || LQ_TEXTURE_LIGHTMAP)
|
|
// Translucent materials need to compute fogging in the forward shading pass
|
|
// Materials that read from scene color skip getting fogged, because the contents of the scene color lookup have already been fogged
|
|
// This is not foolproof, as any additional color the material adds will then not be fogged correctly
|
|
#define TRANSLUCENCY_NEEDS_BASEPASS_FOGGING (MATERIAL_ENABLE_TRANSLUCENCY_FOGGING && MATERIALBLENDING_ANY_TRANSLUCENT && !MATERIAL_USES_SCENE_COLOR_COPY)
|
|
// With forward shading, fog always needs to be computed in the base pass to work correctly with MSAA
|
|
#define OPAQUE_NEEDS_BASEPASS_FOGGING (!MATERIALBLENDING_ANY_TRANSLUCENT && FORWARD_SHADING)
|
|
|
|
#define NEEDS_BASEPASS_VERTEX_FOGGING (TRANSLUCENCY_NEEDS_BASEPASS_FOGGING && !MATERIAL_COMPUTE_FOG_PER_PIXEL || OPAQUE_NEEDS_BASEPASS_FOGGING && PROJECT_VERTEX_FOGGING_FOR_OPAQUE)
|
|
#define NEEDS_BASEPASS_PIXEL_FOGGING (TRANSLUCENCY_NEEDS_BASEPASS_FOGGING && MATERIAL_COMPUTE_FOG_PER_PIXEL || OPAQUE_NEEDS_BASEPASS_FOGGING && !PROJECT_VERTEX_FOGGING_FOR_OPAQUE)
|
|
|
|
// Volumetric fog interpolated per vertex gives very poor results, always sample the volumetric fog texture per-pixel
|
|
// Opaque materials in the deferred renderer get volumetric fog applied in a deferred fog pass
|
|
#define NEEDS_BASEPASS_PIXEL_VOLUMETRIC_FOGGING (TRANSLUCENCY_NEEDS_BASEPASS_FOGGING || FORWARD_SHADING)
|
|
|
|
#define NEEDS_LIGHTMAP (NEEDS_LIGHTMAP_COORDINATE)
|
|
|
|
#define USES_GBUFFER (FEATURE_LEVEL >= FEATURE_LEVEL_SM4 && (MATERIALBLENDING_SOLID || MATERIALBLENDING_MASKED) && !SIMPLE_FORWARD_SHADING && !FORWARD_SHADING)
|
|
|
|
// Only some shader models actually need custom data.
|
|
#define WRITES_CUSTOMDATA_TO_GBUFFER (USES_GBUFFER && (MATERIAL_SHADINGMODEL_SUBSURFACE || MATERIAL_SHADINGMODEL_PREINTEGRATED_SKIN || MATERIAL_SHADINGMODEL_SUBSURFACE_PROFILE || MATERIAL_SHADINGMODEL_CLEAR_COAT || MATERIAL_SHADINGMODEL_TWOSIDED_FOLIAGE || MATERIAL_SHADINGMODEL_HAIR || MATERIAL_SHADINGMODEL_CLOTH || MATERIAL_SHADINGMODEL_EYE))
|
|
|
|
// Based on GetPrecomputedShadowMasks()
|
|
// Note: WRITES_PRECSHADOWFACTOR_TO_GBUFFER is currently disabled because we use the precomputed shadow factor GBuffer outside of STATICLIGHTING_TEXTUREMASK to store UseSingleSampleShadowFromStationaryLights
|
|
#define GBUFFER_HAS_PRECSHADOWFACTOR (USES_GBUFFER && ALLOW_STATIC_LIGHTING)
|
|
#define WRITES_PRECSHADOWFACTOR_ZERO (!(STATICLIGHTING_TEXTUREMASK && STATICLIGHTING_SIGNEDDISTANCEFIELD) && (HQ_TEXTURE_LIGHTMAP || LQ_TEXTURE_LIGHTMAP))
|
|
#define WRITES_PRECSHADOWFACTOR_TO_GBUFFER (GBUFFER_HAS_PRECSHADOWFACTOR && !WRITES_PRECSHADOWFACTOR_ZERO)
|
|
|
|
// If a primitive has static lighting, we assume it is not moving. If it is, it will be rerendered in an extra renderpass.
|
|
#define SUPPORTS_WRITING_VELOCITY_TO_BASE_PASS (FEATURE_LEVEL >= FEATURE_LEVEL_SM4 && (MATERIALBLENDING_SOLID || MATERIALBLENDING_MASKED) && !SIMPLE_FORWARD_SHADING)
|
|
#define WRITES_VELOCITY_TO_GBUFFER ((SUPPORTS_WRITING_VELOCITY_TO_BASE_PASS || USES_GBUFFER) && GBUFFER_HAS_VELOCITY)
|
|
|
|
#define TRANSLUCENCY_ANY_PERVERTEX_LIGHTING (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL)
|
|
#define TRANSLUCENCY_ANY_VOLUMETRIC (TRANSLUCENCY_LIGHTING_VOLUMETRIC_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_DIRECTIONAL || TRANSLUCENCY_ANY_PERVERTEX_LIGHTING)
|
|
#define TRANSLUCENCY_PERVERTEX_LIGHTING_VOLUME (!FORWARD_SHADING && (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL))
|
|
#define TRANSLUCENCY_PERVERTEX_FORWARD_SHADING (FORWARD_SHADING && (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL))
|
|
|
|
// We consider that the cloud shadow is always enabled but the interpolator is only used when render lit translucent with forward shading. We only support per vertex cloud shadow as of today.
|
|
#define NEEDS_BASEPASS_CLOUD_SHADOW_INTERPOLATOR (SUPPORT_CLOUD_SHADOW_ON_FORWARD_LIT_TRANSLUCENT && IS_MATERIAL_TRANSLUCENT_AND_LIT && !TRANSLUCENCY_PERVERTEX_FORWARD_SHADING && !TRANSLUCENCY_PERVERTEX_LIGHTING_VOLUME)
|
|
|
|
struct FSharedBasePassInterpolants
|
|
{
|
|
//for texture-lightmapped translucency we can pass the vertex fog in its own interpolator
|
|
#if NEEDS_BASEPASS_VERTEX_FOGGING
|
|
float4 VertexFog : TEXCOORD7;
|
|
#endif
|
|
|
|
#if NEEDS_BASEPASS_CLOUD_SHADOW_INTERPOLATOR
|
|
float VertexCloudShadow: TEXCOORD8;
|
|
#endif
|
|
|
|
#if USE_WORLD_POSITION_EXCLUDING_SHADER_OFFSETS && !IS_NANITE_PASS
|
|
float3 PixelPositionExcludingWPO : TEXCOORD9;
|
|
#endif
|
|
|
|
#if TRANSLUCENCY_PERVERTEX_LIGHTING_VOLUME
|
|
float3 AmbientLightingVector : TEXCOORD12;
|
|
#endif
|
|
|
|
#if TRANSLUCENCY_PERVERTEX_LIGHTING_VOLUME && TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL
|
|
float3 DirectionalLightingVector : TEXCOORD13;
|
|
#endif
|
|
|
|
#if TRANSLUCENCY_PERVERTEX_FORWARD_SHADING
|
|
float3 VertexDiffuseLighting : TEXCOORD12;
|
|
#endif
|
|
|
|
#if PRECOMPUTED_IRRADIANCE_VOLUME_LIGHTING
|
|
#if TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL
|
|
float3 VertexIndirectAmbient : TEXCOORD14;
|
|
#elif TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL
|
|
float4 VertexIndirectSH[3] : TEXCOORD14;
|
|
#endif
|
|
#endif
|
|
|
|
#if WRITES_VELOCITY_TO_GBUFFER && !IS_NANITE_PASS
|
|
// .xy is clip position, pre divide by w; .w is clip W; .z is 0 or 1 to mask out the velocity output
|
|
float4 VelocityPrevScreenPosition : VELOCITY_PREV_POS;
|
|
#endif
|
|
};
|
|
|
|
#define FBasePassInterpolantsVSToPS FSharedBasePassInterpolants
|
|
|
|
#define SharedAmbientInnerSampler View.SharedBilinearClampedSampler
|
|
#define SharedAmbientOuterSampler View.SharedBilinearClampedSampler
|
|
#define SharedDirectionalInnerSampler View.SharedBilinearClampedSampler
|
|
#define SharedDirectionalOuterSampler View.SharedBilinearClampedSampler
|
|
|
|
void ComputeVolumeUVs(float3 TranslatedWorldPosition, float3 LightingPositionOffset, out float3 InnerVolumeUVs, out float3 OuterVolumeUVs, out float FinalLerpFactor)
|
|
{
|
|
// Apply a stable offset to the world position used for lighting, which breaks up artifacts from using a low res volume texture
|
|
InnerVolumeUVs = (TranslatedWorldPosition + LightingPositionOffset - View.TranslucencyLightingVolumeMin[0].xyz) * View.TranslucencyLightingVolumeInvSize[0].xyz;
|
|
OuterVolumeUVs = (TranslatedWorldPosition + LightingPositionOffset - View.TranslucencyLightingVolumeMin[1].xyz) * View.TranslucencyLightingVolumeInvSize[1].xyz;
|
|
|
|
// Controls how fast the lerp between the inner and outer cascades happens
|
|
// Larger values result in a shorter transition distance
|
|
float TransitionScale = 6;
|
|
// Setup a 3d lerp factor going to 0 at the edge of the inner volume
|
|
float3 LerpFactors = saturate((.5f - abs(InnerVolumeUVs - .5f)) * TransitionScale);
|
|
FinalLerpFactor = LerpFactors.x * LerpFactors.y * LerpFactors.z;
|
|
}
|
|
|
|
float4 GetAmbientLightingVectorFromTranslucentLightingVolume(float3 InnerVolumeUVs, float3 OuterVolumeUVs, float FinalLerpFactor)
|
|
{
|
|
// Lookup the inner and outer cascade ambient lighting values
|
|
float4 InnerLighting = Texture3DSampleLevel(TranslucentBasePass.TranslucencyLightingVolumeAmbientInner, SharedAmbientInnerSampler, InnerVolumeUVs, 0);
|
|
float4 OuterLighting = Texture3DSampleLevel(TranslucentBasePass.TranslucencyLightingVolumeAmbientOuter, SharedAmbientOuterSampler, OuterVolumeUVs, 0);
|
|
|
|
// Lerp between cascades
|
|
return lerp(OuterLighting, InnerLighting, FinalLerpFactor);
|
|
}
|
|
|
|
float3 GetDirectionalLightingVectorFromTranslucentLightingVolume(float3 InnerVolumeUVs, float3 OuterVolumeUVs, float FinalLerpFactor)
|
|
{
|
|
// Fetch both the ambient and directional values for both cascades
|
|
float3 InnerVector1 = Texture3DSampleLevel(TranslucentBasePass.TranslucencyLightingVolumeDirectionalInner, SharedDirectionalInnerSampler, InnerVolumeUVs, 0).rgb;
|
|
float3 OuterVector1 = Texture3DSampleLevel(TranslucentBasePass.TranslucencyLightingVolumeDirectionalOuter, SharedDirectionalOuterSampler, OuterVolumeUVs, 0).rgb;
|
|
|
|
// Lerp between cascades
|
|
return lerp(OuterVector1, InnerVector1, FinalLerpFactor);
|
|
}
|