You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
50944fd712
This represents UE4/Main @ 16130047 and Dev-PerfTest @ 16126156 [CL 16163576 by aurel cordonnier in ue5-main branch]
140 lines
8.6 KiB
Plaintext
140 lines
8.6 KiB
Plaintext
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
/*=============================================================================
|
|
BasePassCommon.ush: Base pass definitions used by both vertex and pixel shader
|
|
=============================================================================*/
|
|
|
|
// Defining SSProfilesTexture here overrides the default definition in SubsurfaceProfileCommon.ush
|
|
#if MATERIALBLENDING_ANY_TRANSLUCENT
|
|
#define ForwardLightData TranslucentBasePass.Shared.Forward
|
|
#define ReflectionStruct TranslucentBasePass.Shared.Reflection
|
|
#define PlanarReflectionStruct TranslucentBasePass.Shared.PlanarReflection
|
|
#define FogStruct TranslucentBasePass.Shared.Fog
|
|
#define ActualSSProfilesTexture TranslucentBasePass.Shared.SSProfilesTexture
|
|
#else
|
|
#define ForwardLightData OpaqueBasePass.Shared.Forward
|
|
#define ReflectionStruct OpaqueBasePass.Shared.Reflection
|
|
#define PlanarReflectionStruct OpaqueBasePass.Shared.PlanarReflection
|
|
#define FogStruct OpaqueBasePass.Shared.Fog
|
|
#define ActualSSProfilesTexture OpaqueBasePass.Shared.SSProfilesTexture
|
|
#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 && (!SELECTIVE_BASEPASS_OUTPUTS || !(STATICLIGHTING_TEXTUREMASK || STATICLIGHTING_SIGNEDDISTANCEFIELD || HQ_TEXTURE_LIGHTMAP || LQ_TEXTURE_LIGHTMAP || WATER_MESH_FACTORY)))
|
|
|
|
#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))
|
|
|
|
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
|
|
|
|
// Note: TEXCOORD8 is unused
|
|
|
|
#if USE_WORLD_POSITION_EXCLUDING_SHADER_OFFSETS && !VF_NANITE
|
|
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 && !VF_NANITE
|
|
// .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 WorldPosition, 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 = (WorldPosition + LightingPositionOffset - View.TranslucencyLightingVolumeMin[0].xyz) * View.TranslucencyLightingVolumeInvSize[0].xyz;
|
|
OuterVolumeUVs = (WorldPosition + 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);
|
|
}
|