// Copyright Epic Games, Inc. All Rights Reserved. #define PATH_TRACING 1 #define ENABLE_SKY_LIGHT 1 #define NEEDS_LIGHTMAP_COORDINATE 0 // This define controls if we use the "g" factor from the SSS profile or not. This is disabled by default because // we can get a better match to how Metahumans are currently dialed with an isotropic phase function. It may be possible to revisit this // if we get a better alignment between raster SSS techniques and the PT random walk. #define USE_SSS_PROFILE_ANISOTROPY 0 #ifdef NEEDS_VERTEX_FACTORY_INTERPOLATION #undef NEEDS_VERTEX_FACTORY_INTERPOLATION #endif // Needed for VertexFactoryInterpolate to interpolate attributes from vertices to hit point #define NEEDS_VERTEX_FACTORY_INTERPOLATION 1 // This should be good enough for path tracing and avoids having to bind an extra buffer #define EYE_ADAPTATION_PREV_FRAME_EXPOSURE 1 // Ensure that SSS albedo comes through in the material #define SUBSTRATE_SSS_MATERIAL_OVERRIDE 0 // The derivatives are used for texture lookup filtering and Substrate's glints #define USE_ANALYTIC_DERIVATIVES 1 #include "/Engine/Private/Common.ush" #include "/Engine/Private/RayTracing/RayTracingCommon.ush" #include "/Engine/Private/RayTracing/RayTracingHitGroupCommon.ush" #include "/Engine/Private/PathTracing/PathTracingShaderUtils.ush" #include "/Engine/Generated/Material.ush" #include "/Engine/Generated/VertexFactory.ush" #include "/Engine/Private/RayTracing/RayTracingCalcInterpolants.ush" #include "/Engine/Private/ShadingCommon.ush" #include "/Engine/Private/DeferredShadingCommon.ush" #include "/Engine/Private/SubsurfaceProfileCommon.ush" #include "/Engine/Private/BurleyNormalizedSSSCommon.ush" #include "/Engine/Private/PathTracing/PathTracingCommon.ush" #include "/Engine/Private/PathTracing/Material/PathTracingFresnel.ush" #if SUBSTRATE_ENABLED #define MATERIAL_SUBSTRATE_OPAQUE_PRECOMPUTED_LIGHTING 0 #include "/Engine/Private/Substrate/SubstrateExport.ush" #include "/Engine/Private/PathTracing/Material/PathTracingSubstrateCommon.ush" #endif float AdjustMaterialRoughness(float Roughness, float PathRoughness) { // Modify the payload roughness to minimize difficult caustics // This is inspired by a trick used in the Arnold renderer: // https://cgg.mff.cuni.cz/~jaroslav/gicourse2010/giai2010-02-marcos_fajardo-slides.pdf (slide 39) // https://www.arnoldrenderer.com/research/Arnold_TOG2018.pdf (section 4.2) // NOTE: If approximate caustics are disabled, the path roughness passed in here will be 0.0 which effectively turns off this optimization return max(Roughness, PathRoughness); } #if REFRACTION_USE_INDEX_OF_REFRACTION #if SUBSTRATE_ENABLED float GetRefractionIor(FPixelMaterialInputs PixelMaterialInputs, float3 F0) { #if REFRACTION_ROOT_NODE_OVERRIDES_DEFAULT float Ior = GetMaterialRefractionIOR(GetMaterialRefraction(PixelMaterialInputs)); #else float Ior = DielectricF0RGBToIor(F0); #endif return Ior; } #else // SUBSTRATE_ENABLED float GetRefractionIor(FPixelMaterialInputs PixelMaterialInputs) { #if REFRACTION_ROOT_NODE_OVERRIDES_DEFAULT float Ior = GetMaterialRefractionIOR(GetMaterialRefraction(PixelMaterialInputs)); #else float3 BaseColor = GetMaterialBaseColor(PixelMaterialInputs); float Metallic = GetMaterialMetallic(PixelMaterialInputs); float Specular = GetMaterialSpecular(PixelMaterialInputs); float3 F0 = ComputeF0(Specular, BaseColor, Metallic); float Ior = DielectricF0RGBToIor(F0); #endif return Ior; } #endif // SUBSTRATE_ENABLED float FakeCausticsPathFactor(float Roughness, float PathRoughness) { // The heuristic used here is inspired by the following presentations: // - Kulla & Conty: Revisiting Physically Based Shading at Imageworks // https://blog.selfshadow.com/publications/s2017-shading-course/imageworks/s2017_pbs_imageworks_slides_v2.pdf // - Colin Barré-Brisebois - Pica Pica & Nvidia Turing // https://www.ea.com/seed/news/siggraph-2018-picapica-nv-turing // NOTE: this returns 0.0 for PathRoughness <= Roughness which accounts for when we are not using ApproximateCaustics return (1 - Roughness * Roughness) * saturate(PathRoughness - Roughness); } float FakeCaustics(float F0, float Ior, float NoV) { // fake caustics for solid glass, approximates the effect of the boundaries' fresnel float Fr = FresnelReflectance(abs(NoV), Ior, F0); return Pow2(1 - Fr); } float3 ComputeOpticalDepthForHit(float3 LocalSigmaT, bool bIsFrontFace) { // Does the material have any kind of volumetric absorption to apply? // Now track the optical thickness so that we can account for Beer's law along the shadow ray // TODO: to support lights inside glass we would need to track an extra offset, but this is hopefully an uncommon scenario // TODO2: SingleLayerWater needs something similar, but it generally is setup with opaque or masked blend mode and water geometry does not cast shadows ... float Distance = RayTCurrent(); // Front Face: remove contribution from the ray origin to the current hit (assuming the backside will be hit) // Back Face: add contribution from ray origin to current hit (backside) - excess portion not covered by the ray will be removed by the front face hit Distance *= bIsFrontFace ? -1.0 : +1.0; return LocalSigmaT * Distance; } #endif // REFRACTION_USE_INDEX_OF_REFRACTION float3 DecodeSSSProfileRadius(uint ProfileId, float3 DiffuseColor, float Opacity) { // Burley parameterization float3 SurfaceAlbedo = View.SSProfilesTexture.Load(int3(BSSS_SURFACEALBEDO_OFFSET, ProfileId, 0)).xyz; float3 DiffuseMeanFreePath = DecodeDiffuseMeanFreePath(View.SSProfilesTexture.Load(int3(BSSS_DMFP_OFFSET, ProfileId, 0))).xyz; float WorldUnitScale = DecodeWorldUnitScale(View.SSProfilesTexture.Load(int3(SSSS_TINT_SCALE_OFFSET, ProfileId, 0)).a) * BURLEY_CM_2_MM; // Opacity acts as a per-pixel radius multiplier // NOTE: this seems backwards? Opacity=0 acts like default-lit while Opacity=1 acts like SSS? // NOTE2: Confirm if this interpretation of opacity is correct ... float3 SSSRadius = GetMFPFromDMFPApprox(SurfaceAlbedo, DiffuseColor, Opacity * WorldUnitScale * DiffuseMeanFreePath); return SSSRadius * BURLEY_MM_2_CM; } float DecodeSSSProfileScatteringDistribution(uint ProfileId) { float EncodedScatteringDistribution = View.SSProfilesTexture.Load(int3(SSSS_TRANSMISSION_OFFSET, ProfileId, 0)).z; return DecodeScatteringDistribution(EncodedScatteringDistribution); } #if SUBSTRATE_ENABLED float3 GetSimpleVolumeDiffuseColor(float3 DiffuseColor, float3 MeanFreePath) { // See reference in SubstrateEvaluation.ush // SUBSTRATE_TODO: In the case of thin materials, we should also include a backscattering diffuse portion FParticipatingMedia PM = SubstrateSlabCreateParticipatingMedia(DiffuseColor, MeanFreePath); const float DiffuseToVolumeBlend = SubstrateSlabDiffuseToVolumeBlend(PM); const float3 SlabDirectionalAlbedo = IsotropicMediumSlabEnvDirectionalAlbedoALU(PM); return lerp(DiffuseColor, SlabDirectionalAlbedo, DiffuseToVolumeBlend); } #endif RAY_TRACING_ENTRY_CLOSEST_HIT(PathTracingMaterialCHS, FPackedPathTracingPayload, PackedPayload, FRayTracingIntersectionAttributes, Attributes) { PackedPayload.HitT = RayTCurrent(); ResolvedView = ResolveView(); const float3 TranslatedWorldPosition = TranslatedWorldRayOrigin() + RayTCurrent() * WorldRayDirection(); const float4 SvPosition = TranslatedWorldPositionToSvPosition(TranslatedWorldPosition); CurrentPayloadInputFlags = PackedPayload.GetFlags(); PathTracerSceneDepth = (CurrentPayloadInputFlags & PATH_TRACING_PAYLOAD_INPUT_FLAG_HAS_SCENE_DEPTH) ? PackedPayload.GetSceneDepth() : SCENE_TEXTURES_DISABLED_SCENE_DEPTH_VALUE; #if USE_DBUFFER && MATERIAL_USES_DECAL_LOOKUP if ((CurrentPayloadInputFlags & PATH_TRACING_PAYLOAD_INPUT_FLAG_HAS_SCENE_DEPTH) == 0) { CurrentPayloadDBufferA = PackedPayload.GetDBufferA(); CurrentPayloadDBufferB = PackedPayload.GetDBufferB(); CurrentPayloadDBufferC = PackedPayload.GetDBufferC(); } #endif #if VF_SUPPORTS_RAYTRACING_PREPARE_MATERIAL_PIXEL_PARAMETERS // this is a newer codepath that is both more flexible and allows for more direct calculation compared to the other codepath // TODO: implement such a method for all vertex factories float3 GeoNormal = 0; FMaterialPixelParameters MaterialParameters = GetMaterialPixelParameters(TranslatedWorldRayOrigin(), WorldRayDirection(), RayTCurrent(), PrimitiveIndex(), Attributes, HitKind(), SvPosition, GeoNormal); #else FVertexFactoryInterpolantsVSToPS Interpolants; float3 GeoNormal = 0; FRaytracingDerivatives RaytracingDerivatives = (FRaytracingDerivatives)0; CalcInterpolants(SvPosition, (FRayCone)0, Attributes, Interpolants, RaytracingDerivatives, GeoNormal); FMaterialPixelParameters MaterialParameters = GetMaterialPixelParameters(Interpolants, SvPosition); ApplyRaytracingDerivatives(MaterialParameters, RaytracingDerivatives); #endif FPixelMaterialInputs PixelMaterialInputs; const bool bIsFrontFace = HitKind() == HIT_KIND_TRIANGLE_FRONT_FACE; { const float4 ScreenPosition = SvPositionToResolvedScreenPosition(SvPosition); MaterialParameters.CameraVector = -WorldRayDirection(); CalcMaterialParametersEx(MaterialParameters, PixelMaterialInputs, SvPosition, ScreenPosition, bIsFrontFace, TranslatedWorldPosition, TranslatedWorldPosition); } #if SUBSTRATE_ENABLED #if MATERIAL_IS_SUBSTRATE FSubstratePixelHeader SubstratePixelHeader = MaterialParameters.GetFrontSubstrateHeader(); FSubstrateData SubstrateData = PixelMaterialInputs.GetFrontSubstrateData(); #if SUBSTRATE_OPTIMIZED_UNLIT // Unlit BSDF goes through the SubstrateTree to support weighting operations. Technically, layering and mixing could also be supported. float3 UnlitSurfaceLuminancePostCoverage = 0.0f; float UnlitSurfaceCoverage = 0.0f; float3 UnlitSurfaceTransmittancePreCoverage = 0.0f; float3 UnlitSurfaceNormal = 0.0f; SubstratePixelHeader.SubstrateUpdateTreeUnlit( uint2(SvPosition.xy), MaterialParameters.CameraVector, SubstrateData, UnlitSurfaceLuminancePostCoverage, UnlitSurfaceCoverage, UnlitSurfaceTransmittancePreCoverage, UnlitSurfaceNormal); const float3 Transparency = saturate(lerp(1.0, UnlitSurfaceTransmittancePreCoverage, UnlitSurfaceCoverage)); #else // SUBSTRATE_TODO: These should actually be initialized via the corresponding cvars. To do this properly would require binding FSubstrateSceneData in the path tracing shaders // For now, simply match the default substrate settings FSubstrateIntegrationSettings IntegrationSettings = InitSubstrateIntegrationSettings( false /* bForceFullyRough */, true /* SubstrateStruct.bRoughDiffuse */, -1 /* SubstrateStruct.PeelLayersAboveDepth */, true /* SubstrateStruct.bRoughnessTracking */ ); #if SUBSTRATE_BLENDING_COLOREDTRANSMITTANCEONLY const uint BSDFCount = 0; #else const uint BSDFCount = SubstratePixelHeader.SubstrateTree.BSDFCount; #endif float TotalCoverage = 1; float3 TotalTransmittancePreCoverage = 0; const float3 V_World = MaterialParameters.CameraVector; SubstratePixelHeader.SubstrateUpdateTree(SubstrateData, V_World, IntegrationSettings, TotalCoverage, TotalTransmittancePreCoverage); #if REFRACTION_USE_INDEX_OF_REFRACTION // transparency is only used for coverage, transmittance happens through refraction (except for shadows potentially, which is handled below) float3 Transparency = 1 - TotalCoverage; #else // transparency is used for both coverage and transmittance // SUBSTRATE_TODO: Thin case does not seem to be properly handled here, so the TotalTransmittancePreCoverage is recomputed later const float3 Transparency = saturate(lerp(1.0, TotalTransmittancePreCoverage, TotalCoverage)); #endif // REFRACTION_USE_INDEX_OF_REFRACTION #endif // SUBSTRATE_OPTIMIZED_UNLIT #else // MATERIAL_IS_SUBSTRATE // This only happens for invalid materials const float3 Transparency = 0; #endif #endif // SUBSTRATE_ENABLED FPathTracingPayload Payload = (FPathTracingPayload)0; #if !SUBSTRATE_ENABLED /** * Set common material attributes for both full and simplified materials **/ #if (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_DIRECTIONAL) Payload.ShadingModelID = SHADINGMODELID_UNLIT; #else Payload.ShadingModelID = GetMaterialShadingModel(PixelMaterialInputs); #endif #if MATERIALBLENDING_ALPHACOMPOSITE Payload.BSDFOpacity = 1.0; Payload.TransparencyColor = 1.0 - GetMaterialOpacity(PixelMaterialInputs); #elif MATERIALBLENDING_ALPHAHOLDOUT Payload.BSDFOpacity = GetMaterialOpacity(PixelMaterialInputs); Payload.TransparencyColor = 1.0 - GetMaterialOpacity(PixelMaterialInputs); Payload.SetHoldout(); HLSL_STATIC_ASSERT(MATERIAL_SHADINGMODEL_UNLIT == 1, "Alpha holdout blend mode requires unlit shading model"); Payload.ShadingModelID = SHADINGMODELID_UNLIT; #elif MATERIALBLENDING_TRANSLUCENT Payload.BSDFOpacity = GetMaterialOpacity(PixelMaterialInputs); Payload.TransparencyColor = 1.0 - Payload.BSDFOpacity; #elif MATERIALBLENDING_ADDITIVE Payload.BSDFOpacity = GetMaterialOpacity(PixelMaterialInputs); Payload.TransparencyColor = 1.0; #elif MATERIALBLENDING_MODULATE Payload.BSDFOpacity = 0.0; Payload.TransparencyColor = GetMaterialEmissive(PixelMaterialInputs); // NOTE: in the case of substrate materials we could have DEFAULT_LIT here HLSL_STATIC_ASSERT(MATERIAL_SHADINGMODEL_UNLIT == 1 || MATERIAL_SHADINGMODEL_DEFAULT_LIT == 1, "Modulate blend mode requires unlit shading model"); Payload.ShadingModelID = SHADINGMODELID_UNLIT; #elif MATERIALBLENDING_MASKED && MATERIAL_DITHER_OPACITY_MASK // dithering emulates real transparency, so switch to translucent // NOTE: the raster path technically takes into account the opacity mask clip value, so the effective transparency should be: // saturate(MaskRaw - ClipValue + 0.5) // (See derivation in DitheredOpacityMaskToOpacity) // However this behavior is surprising to most users and does not exactly match the rasterizer anyway due to how the realtime AA // code performs blending. // Since the goal of dithered opacity is to emulate ordinary transparency, just use the mask input as opacity directly and // ignore the configured clip value. Payload.BSDFOpacity = saturate(GetMaterialMaskInputRaw(PixelMaterialInputs)); Payload.TransparencyColor = 1.0 - Payload.BSDFOpacity; #elif MATERIALBLENDING_SOLID || MATERIALBLENDING_MASKED Payload.BSDFOpacity = 1.0; Payload.TransparencyColor = 0.0; #else #error Unknown material blending mode #endif #endif // !SUBSTRATE_ENABLED // fetch primitive flags only once // TODO: would be nice to keep this inside MaterialParameters as it is also needed there as well const uint PrimitiveFlags = GetPrimitiveData(MaterialParameters.PrimitiveId).Flags; Payload.PrimitiveLightingChannelMask = GetPrimitive_LightingChannelMask_FromFlags(PrimitiveFlags); Payload.HitT = RayTCurrent(); if (HitKind() == HIT_KIND_TRIANGLE_FRONT_FACE) { Payload.SetFrontFace(); } #if MATERIAL_IS_SKY if (!PackedPayload.IsCameraRay()) { // avoid double counting what was captured by the skylight // also avoid noise from hot spots (they can be properly // importance sampled if a capturing skylight is added) PackedPayload = PackPathTracingPayload(Payload); return; } #endif float GeoNormalSign = MaterialParameters.TwoSidedSign; #if !VF_SUPPORTS_RAYTRACING_PREPARE_MATERIAL_PIXEL_PARAMETERS // Because the geometric normal is computed directly in world space // it doesn't reflect the sign flip from the object transform, so apply it here GeoNormalSign *= GetPrimitive_DeterminantSign_FromFlags(PrimitiveFlags); #endif Payload.WorldGeoNormal = GeoNormalSign * GeoNormal; Payload.WorldSmoothNormal = MaterialParameters.TwoSidedSign * TransformTangentNormalToWorld(MaterialParameters.TangentToWorld, float3(0, 0, 1)); #if (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_DIRECTIONAL) // no need to adjust normal on volumetric shading models #else Payload.WorldSmoothNormal = AdjustShadingNormal(Payload.WorldSmoothNormal, Payload.WorldGeoNormal, WorldRayDirection()); #endif #if SUBSTRATE_ENABLED // unless proven otherwise, we are a basic unlit material Payload.ShadingModelID = SHADINGMODELID_UNLIT; #if MATERIAL_IS_SUBSTRATE // This can become false if the material is invalid #if SUBSTRATE_OPTIMIZED_UNLIT Payload.Radiance = UnlitSurfaceLuminancePostCoverage; #if SUBSTRATE_OPAQUE_MATERIAL Payload.BSDFOpacity = 1; Payload.TransparencyColor = 0; #else Payload.BSDFOpacity = UnlitSurfaceCoverage; Payload.TransparencyColor = UnlitSurfaceTransmittancePreCoverage; #endif #else // SUBSTRATE_OPTIMIZED_UNLIT Payload.BSDFOpacity = 1; #if !SUBSTRATE_OPAQUE_MATERIAL Payload.TransparencyColor = Transparency; #endif if (BSDFCount > 0) { { #if HAIR_STRAND_MESH_FACTORY Payload.WorldSmoothNormal = Payload.WorldGeoNormal; #else // Nudge normal to avoid dark edges in bump // Not that we must recompute tangent vector to keep the basis frame orthogonal for (uint i = 0; i < SubstratePixelHeader.SharedLocalBases.Count; ++i) { float3 N = normalize(SubstratePixelHeader.SharedLocalBases.Normals[i]); #if !MATERIAL_TANGENTSPACENORMAL // already flipped if the material was in tangent space, so add the flip if it wasn't N *= MaterialParameters.TwoSidedSign; #endif N = AdjustShadingNormal(N, Payload.WorldGeoNormal, WorldRayDirection()); SubstratePixelHeader.SharedLocalBases.Normals[i] = N; } #endif } #define BSDF SubstratePixelHeader.SubstrateTree.BSDFs[BSDFIdx] int BSDFIdx = 0; // Accumulate radiance across all BSDFs Payload.Radiance = 0.0; for (BSDFIdx = 0; BSDFIdx < BSDFCount; ++BSDFIdx) { Payload.Radiance += BSDF.LuminanceWeightV * BSDF_GETEMISSIVE(BSDF); } #if SUBSTRATE_CLAMPED_CLOSURE_COUNT > 1 // The material might be using more than one slab -- insert code to stochastically pick one float SlabPdf = 1.0; if (BSDFCount > 1) { float SlabCDF[SUBSTRATE_CLAMPED_CLOSURE_COUNT]; float SlabCDFSum = 0.0; for (BSDFIdx = 0; BSDFIdx < BSDFCount; ++BSDFIdx) { float Pdf = 0.0; // The goal is to predict the weight of each BSDF switch (BSDF_GETTYPE(BSDF)) { case SUBSTRATE_BSDF_TYPE_SLAB: { const float3 WeightV = BSDF.LuminanceWeightV; const float3 TransmittanceN = BSDF.TransmittanceAboveAlongN; const float CoverageAboveAlongN = BSDF.CoverageAboveAlongN; const float3 MaxLobeWeight = WeightV * lerp(1.0f, TransmittanceN, CoverageAboveAlongN); // largest value LobeWeight() could return // Is the slab even visible at all? if (any(MaxLobeWeight > 0.0)) { const float3 N = SubstratePixelHeader.SharedLocalBases.Normals[BSDF_GETSHAREDLOCALBASISID(BSDF)]; const float NoV = saturate(dot(N, V_World)); float3 DiffuseColor = SLAB_DIFFUSEALBEDO(BSDF); float3 F0 = SLAB_F0(BSDF); float3 F90 = SLAB_F90(BSDF) * F0RGBToMicroOcclusion(F0); float Roughness0 = MakeRoughnessSafe(SLAB_ROUGHNESS(BSDF), PackedPayload.GetPathRoughness()); // SUBSTRATE_TODO: Support Fresnel82? float3 Spec0E = ComputeGGXSpecEnergyTermsRGB(Roughness0, NoV, F0, F90).E; float3 Spec1E = Spec0E; float Roughness1 = Roughness0; float SpecBlend = 0.0; bool bUseClearCoat = false; if (BSDF_GETHASHAZINESS(BSDF)) { const FHaziness Haziness = UnpackHaziness(SLAB_HAZINESS(BSDF)); SpecBlend = Haziness.Weight; Roughness1 = MakeRoughnessSafe(Haziness.Roughness, PackedPayload.GetPathRoughness()); if (Haziness.bSimpleClearCoat) { Spec1E = ComputeGGXSpecEnergyTermsRGB(Roughness1, NoV, CLEAR_COAT_F0).E; bUseClearCoat = true; } else { Spec1E = ComputeGGXSpecEnergyTermsRGB(Roughness1, NoV, F0, F90).E; } } if (BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_SIMPLEVOLUME) { DiffuseColor = GetSimpleVolumeDiffuseColor(DiffuseColor, SLAB_SSSMFP(BSDF)); } float FuzzAmount = 0.0; float FuzzRoughness = 1.0; float3 FuzzColor = 0.0; if (BSDF_GETHASFUZZ(BSDF)) { FuzzAmount = SLAB_FUZZ_AMOUNT(BSDF); FuzzColor = SLAB_FUZZ_COLOR(BSDF); FuzzRoughness = SLAB_FUZZ_ROUGHNESS(BSDF); FuzzRoughness = MakeRoughnessSafe(FuzzRoughness, SUBSTRATE_MIN_FUZZ_ROUGHNESS); } const float FuzzE = ComputeSheenEnergyTerms(FuzzRoughness, NoV).E; const float FuzzAttenuation = 1.0 - FuzzAmount * FuzzE; float DiffuseWeight = FuzzAttenuation; float3 Spec0Albedo = FuzzAttenuation * Spec0E; float3 Spec1Albedo = FuzzAttenuation * Spec1E; if (bUseClearCoat) { // clearcoat slab float CoatAttenuation = 1.0 - SpecBlend * Spec1E.x; DiffuseWeight *= CoatAttenuation * (1.0 - Luminance(Spec0E)); Spec0Albedo *= CoatAttenuation; Spec1Albedo *= SpecBlend; } else { // dual-specular slab DiffuseWeight *= 1.0 - Luminance(lerp(Spec0E, Spec1E, SpecBlend)); Spec0Albedo *= 1.0 - SpecBlend; Spec1Albedo *= SpecBlend; } // SUBSTRATE_TODO: Need to account for glass case here for lobe selection .... const float3 FuzzAlbedo = FuzzAmount * FuzzE * FuzzColor; const float3 SlabAlbedo = MaxLobeWeight * (DiffuseWeight * DiffuseColor + Spec0Albedo + Spec1Albedo + FuzzAlbedo); Pdf = LobeColorToWeight(SlabAlbedo); } break; } default: { // In theory none of the other slab types can be layered break; } } SlabCDFSum += Pdf; SlabCDF[BSDFIdx] = SlabCDFSum; } if (SlabCDFSum > 0.0) { // linear search float PreviousCdfValue = 0; float RandSample = SlabCDFSum * PackedPayload.GetStochasticSlabRand(); for (BSDFIdx = 0; BSDFIdx < BSDFCount - 1; ++BSDFIdx) { if (RandSample < SlabCDF[BSDFIdx]) { break; } PreviousCdfValue = SlabCDF[BSDFIdx]; } SlabPdf = (SlabCDF[BSDFIdx] - PreviousCdfValue) / SlabCDFSum; } else { BSDFIdx = 0; SlabPdf = 0.0; } } if (SlabPdf > 0) { #elif SUBSTRATE_CLAMPED_CLOSURE_COUNT == 1 if (BSDFCount > 0) { // There is only one slab active BSDFIdx = 0; #else // shouldn't be possible to reach this point #error Unexpected BSDF Count #endif // SUBSTRATE_CLAMPED_CLOSURE_COUNT #if SUBSTRATE_CLAMPED_CLOSURE_COUNT > 0 Payload.WorldNormal = SubstratePixelHeader.SharedLocalBases.Normals[BSDF_GETSHAREDLOCALBASISID(BSDF)]; if (SubstrateGetSharedLocalBasisType(SubstratePixelHeader.SharedLocalBases.Types, BSDFIdx) == SUBSTRATE_BASIS_TYPE_TANGENT) { Payload.WorldTangent = SubstratePixelHeader.SharedLocalBases.Tangents[BSDF_GETSHAREDLOCALBASISID(BSDF)]; } switch (BSDF_GETTYPE(BSDF)) { case SUBSTRATE_BSDF_TYPE_SLAB: { Payload.ShadingModelID = SHADINGMODELID_SUBSTRATE; Payload.DiffuseColor = SLAB_DIFFUSEALBEDO(BSDF); Payload.SpecularColor = SLAB_F0(BSDF); Payload.SpecularEdgeColor = SLAB_F90(BSDF); Payload.RoughnessData.x = MakeRoughnessSafe(SLAB_ROUGHNESS(BSDF), PackedPayload.GetPathRoughness()); Payload.RoughnessData.y = Payload.RoughnessData.x; Payload.RoughnessData.z = 0; if (BSDF_GETHASHAZINESS(BSDF)) { const FHaziness Haziness = UnpackHaziness(SLAB_HAZINESS(BSDF)); if (Haziness.bSimpleClearCoat) { Payload.ShadingModelID = SHADINGMODELID_CLEAR_COAT; } Payload.RoughnessData.y = MakeRoughnessSafe(Haziness.Roughness, PackedPayload.GetPathRoughness()); Payload.RoughnessData.z = Haziness.Weight; #if CLEAR_COAT_BOTTOM_NORMAL Payload.BottomNormalOct16bits = SLAB_HAZINESS(BSDF) >> 16; #else Payload.BottomNormalOct16bits = 0; #endif } Payload.Anisotropy = BSDF_GETHASANISOTROPY(BSDF) ? SLAB_ANISOTROPY(BSDF) : 0.0; if (BSDF_GETHASFUZZ(BSDF)) { Payload.FuzzAmount = SLAB_FUZZ_AMOUNT(BSDF); Payload.FuzzColor = SLAB_FUZZ_COLOR(BSDF); Payload.FuzzRoughness = MakeRoughnessSafe(SLAB_FUZZ_ROUGHNESS(BSDF), SUBSTRATE_MIN_FUZZ_ROUGHNESS); } else { Payload.FuzzAmount = 0.0; Payload.FuzzColor = 0.0; Payload.FuzzRoughness = 0.0; } if (BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_SIMPLEVOLUME) { // TODO: this case should be represented by a different BSDF Payload.DiffuseColor = GetSimpleVolumeDiffuseColor(Payload.DiffuseColor, SLAB_SSSMFP(BSDF)); } else if (BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_DIFFUSION) { Payload.MeanFreePath = SLAB_SSSMFP(BSDF); Payload.PhaseG = SLAB_SSSPHASEANISOTROPY(BSDF); } else if (BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_DIFFUSION_PROFILE) { const uint ProfileId = SubstrateSubsurfaceProfileIdTo8bits(SLAB_SSSPROFILEID(BSDF)); const float Scale = SLAB_SSSPROFILERADIUSSCALE(BSDF); Payload.MeanFreePath = DecodeSSSProfileRadius(ProfileId, Payload.DiffuseColor, Scale); #if USE_SSS_PROFILE_ANISOTROPY Payload.PhaseG = DecodeSSSProfileScatteringDistribution(ProfileId); Payload.MeanFreePath *= 1 - G; // Compensate the extra translucency by scaling down the MFP #else Payload.PhaseG = 0.0; #endif } else if (BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_WRAP || BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_TWO_SIDED_WRAP) { const bool bFoliage = BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_TWO_SIDED_WRAP; const float TransmittanceNoL = 1.0f; const float3 SlabDiffuseColor = bFoliage ? Payload.DiffuseColor : float3(1, 1, 1); const FParticipatingMedia PM = SubstrateSlabCreateParticipatingMedia(Payload.DiffuseColor, SLAB_SSSMFP(BSDF)); float3 SubsurfaceColor = IsotropicMediumSlabTransmittance(PM, SUBSTRATE_SIMPLEVOLUME_THICKNESS_M, TransmittanceNoL); const float Opacity = 1.f - abs(SLAB_SSSPHASEANISOTROPY(BSDF)); float3 Front = Payload.DiffuseColor; float3 Back = SubsurfaceColor; float3 Sum = Front + Back; float S = max(Sum.x, max(Sum.y, Sum.z)); if (S > 1) { // nudge the material back to something physically plausible // NOTE: we ignore spec here since it should be accounted for by the brdf model itself Payload.DiffuseColor = Front / S; SubsurfaceColor = Back / S; } if (bFoliage) { // foliage case, only the color matters Payload.ShadingModelID = SHADINGMODELID_TWOSIDED_FOLIAGE; Payload.SetFoliageTransmissionColor(SubsurfaceColor); } else { // Match formula from non-Substrate handling of wrap SSS const float SSSRadius = (1 - Opacity) * 10.0; // simple formula, up to 10cm radius // The legacy behavior has both diffuse+sss responses separately, but we can combine them to avoid needing a custom lobe // In practice the diffuse and SSS responses are similar, so the difference should be minimal (and is an approximation of the raster behavior anyway) Payload.DiffuseColor += SubsurfaceColor; Payload.MeanFreePath = SSSRadius; Payload.PhaseG = 0; } } else { // TODO: Are there any other SSS types to consider? Payload.MeanFreePath = 0; Payload.PhaseG = 0; } Payload.SpecularProfileId = 0; Payload.GlintValue = 1.f; #if SUBSTRATE_COMPLEXPATH if (BSDF_GETHASSPECPROFILE(BSDF)) { Payload.SpecularProfileId = SLAB_SPECPROFILEID(BSDF); } #endif #if SUBSTRATE_COMPLEXSPECIALPATH if (BSDF_GETHASGLINT(BSDF)) { Payload.GlintValue = SLAB_GLINT_VALUE(BSDF); Payload.GlintUV = SLAB_GLINT_UV(BSDF); Payload.GlintUVdx = SLAB_GLINT_UVDDX(BSDF); Payload.GlintUVdy = SLAB_GLINT_UVDDY(BSDF); } #endif Payload.WeightV = BSDF.LuminanceWeightV; Payload.TransmittanceN = BSDF.TransmittanceAboveAlongN; Payload.CoverageAboveAlongN = BSDF.CoverageAboveAlongN; #if MATERIAL_ISTHINSURFACE && MATERIALBLENDING_ANY_TRANSLUCENT Payload.ShadingModelID = SHADINGMODELID_THIN_TRANSLUCENT; #endif #if MATERIALBLENDING_ANY_TRANSLUCENT && REFRACTION_USE_INDEX_OF_REFRACTION // NOTE: only the bottom most layer can refract, coatings should never include a refraction lobe Payload.Ior = BSDF.bIsBottom ? GetRefractionIor(PixelMaterialInputs, Payload.SpecularColor) : 0.0; Payload.MeanFreePath = BSDF.bIsBottom ? SLAB_SSSMFP(BSDF) : Payload.MeanFreePath; if (Payload.Ior > 0 && Payload.ShadingModelID == SHADINGMODELID_SUBSTRATE) { Payload.ShadingModelID = SHADINGMODELID_SOLID_GLASS; } #else Payload.Ior = 0.0; #endif #if MATERIAL_ISTHINSURFACE && MATERIALBLENDING_ANY_TRANSLUCENT // Material is configured as a thin surface, and refraction is disabled if (BSDF.bIsBottom && !(Payload.Ior > 0.0)) { Payload.MeanFreePath = SLAB_SSSMFP(BSDF); float3 Transmission = Payload.GetTransmittanceColor(); const float NoV = saturate(dot(Payload.WorldNormal, V_World)); float3 Tr = ComputeThinSlabWeights(Transmission, NoV, Payload.Ior, F0RGBToF0(Payload.SpecularColor)).Transmitted; Payload.TransparencyColor += TotalCoverage * Tr; } #endif break; } case SUBSTRATE_BSDF_TYPE_HAIR: { // clamp the roughness to whatever came along the path Payload.SetBaseColor(HAIR_BASECOLOR(BSDF)); Payload.SetHairLongitudinalRoughness(max(HAIR_ROUGHNESS(BSDF), PackedPayload.GetPathRoughness())); Payload.SetHairAzimuthalRoughness(HAIR_SCATTER(BSDF)); // SUBSTRATE_TODO: Map from scatter param to azimuthal roughness here instead of in the raygen Payload.SetHairSpecular(HAIR_SPECULAR(BSDF)); #if HAIR_STRAND_MESH_FACTORY Payload.WorldSmoothNormal = Payload.WorldNormal = Payload.WorldGeoNormal; Payload.WorldTangent = MaterialParameters.TangentToWorld[2]; Payload.SetHairPrimitiveUV(MaterialParameters.HairPrimitiveUV); #else Payload.SetHairPrimitiveUV(0.5); #endif Payload.ShadingModelID = SHADINGMODELID_HAIR; break; } case SUBSTRATE_BSDF_TYPE_EYE: { Payload.DiffuseColor = EYE_DIFFUSEALBEDO(BSDF); Payload.SpecularColor = EYE_F0(BSDF); // NOTE: EYE_F90 is always 1.0 (does not exist in legacy model), so don't bother with it Payload.SetEyeRoughness(max(EYE_ROUGHNESS(BSDF), PackedPayload.GetPathRoughness())); if (BSDF_GETSSSTYPE(BSDF) == SSS_TYPE_DIFFUSION_PROFILE) { const uint ProfileId = SubstrateSubsurfaceProfileIdTo8bits(EYE_SSSPROFILEID(BSDF)); Payload.MeanFreePath = DecodeSSSProfileRadius(ProfileId, Payload.DiffuseColor, 1.0); Payload.PhaseG = 0.0; } float IrisMask = EYE_IRISMASK(BSDF); float IrisDistance = EYE_IRISDISTANCE(BSDF); // see logic in non-substrate code below const float3 PlaneNormal = normalize(EYE_IRISPLANENORMAL(BSDF)); const float3 CausticNormal = normalize(lerp(PlaneNormal, -Payload.WorldNormal, IrisMask * IrisDistance)); Payload.SetEyeCausticNormal(CausticNormal); Payload.SetEyeIrisMask(IrisMask); Payload.SetEyeIrisNormal(normalize(EYE_IRISNORMAL(BSDF))); Payload.ShadingModelID = SHADINGMODELID_EYE; break; } case SUBSTRATE_BSDF_TYPE_SINGLELAYERWATER: { Payload.ShadingModelID = SHADINGMODELID_SOLID_GLASS; float3 BaseColor = SLW_BASECOLOR(BSDF); float Metallic = SLW_METALLIC(BSDF); float Specular = SLW_SPECULAR(BSDF); float Roughness = SLW_ROUGHNESS(BSDF); float3 Extinction = 0.0; #if SUBSTRATE_INLINE_SINGLELAYERWATER //float Opacity = SLW_TOPMATERIALOPACITY(BSDF); // TODO: Account for this with an extra random decision? //float3 WaterAlbedo = SLW_WATERALBEDO(BSDF); // TODO: Account for scattering in refractive mediums Extinction = SLW_WATEREXTINCTION(BSDF); //float PhaseG = SLW_WATERPHASEG(BSDF); //float3 ColorBehindWater = SLW_COLORSCALEBEHINDWATER(BSDF); #else #endif Payload.WeightV = BSDF.LuminanceWeightV; Payload.TransmittanceN = BSDF.TransmittanceAboveAlongN; Payload.CoverageAboveAlongN = BSDF.CoverageAboveAlongN; Payload.DiffuseColor = ComputeDiffuseAlbedo(BaseColor, Metallic); Payload.SpecularColor = ComputeF0(Specular, BaseColor, Metallic); Payload.RoughnessData.x = MakeRoughnessSafe(Roughness, PackedPayload.GetPathRoughness()); Payload.RoughnessData.yz = 0; Payload.Ior = DielectricF0ToIor(DielectricSpecularToF0(Specular)); Payload.MeanFreePath = rcp(max(Extinction, 1e-5)); Payload.FuzzAmount = 0; Payload.FuzzRoughness = 0; Payload.FuzzColor = 0; Payload.GlintValue = 1; break; } default: { // SUBSTRATE_TODO: handle all other cases break; } } #if SUBSTRATE_CLAMPED_CLOSURE_COUNT > 1 // account for the probability of having chosen this slab Payload.BSDFOpacity /= SlabPdf; #endif } // close brace opened by SUBSTRATE_CLAMPED_CLOSURE_COUNT > 1 or SUBSTRATE_CLAMPED_CLOSURE_COUNT == 1 ifdefs above #endif // SUBSTRATE_CLAMPED_CLOSURE_COUNT > 0 #undef BSDF } // if BSDFCount > 0 #endif // SUBSTRATE_OPTIMIZED_UNLIT #if MATERIAL_TWOSIDED == 0 if (MaterialParameters.TwoSidedSign < 0) { // when viewing the surface from "inside", don't include emission Payload.Radiance = 0; } #endif #endif // MATERIAL_IS_SUBSTRATE #else // SUBSTRATE_ENABLED Payload.Radiance = GetMaterialEmissive(PixelMaterialInputs); Payload.WorldNormal = MaterialParameters.WorldNormal; #if !MATERIAL_TANGENTSPACENORMAL // already flipped if the material was in tangent space, so add the flip if it wasn't Payload.WorldNormal *= MaterialParameters.TwoSidedSign; #endif #if (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_DIRECTIONAL) // volumetric shading doesn't need to adjust normal #else Payload.WorldNormal = AdjustShadingNormal(Payload.WorldNormal, Payload.WorldGeoNormal, WorldRayDirection()); #endif // Store the results in local variables and reuse instead of calling the functions multiple times. half3 BaseColor = GetMaterialBaseColor(PixelMaterialInputs); half Metallic = GetMaterialMetallic(PixelMaterialInputs); half Specular = GetMaterialSpecular(PixelMaterialInputs); half Roughness = GetMaterialRoughness(PixelMaterialInputs); float Ior = 0.0; #if MATERIALBLENDING_TRANSLUCENT && REFRACTION_USE_INDEX_OF_REFRACTION && (MATERIAL_SHADINGMODEL_DEFAULT_LIT || MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT) // NOTE: only default-lit and thin-translucent use ior, the other material models only support plain transparency // This is an attempt to limit the complexity of the material eval/sample API which must take into account an extra lobe if supporting refraction Ior = GetRefractionIor(PixelMaterialInputs); #endif Payload.Radiance *= Payload.BSDFOpacity; // pre-multiply #if MATERIAL_TWOSIDED == 0 if (MaterialParameters.TwoSidedSign < 0) { // when viewing the surface from "inside", don't include emission Payload.Radiance = 0; } #endif Payload.BaseColor = BaseColor; Payload.Specular = Specular; Payload.Metallic = Metallic; Payload.Roughness = Roughness; #if MATERIAL_USES_ANISOTROPY Payload.WorldTangent = CalculateAnisotropyTangent(MaterialParameters, PixelMaterialInputs); Payload.Anisotropy = GetMaterialAnisotropy(PixelMaterialInputs); #endif #if HAIR_STRAND_MESH_FACTORY Payload.WorldSmoothNormal = Payload.WorldNormal = Payload.WorldGeoNormal; Payload.WorldTangent = MaterialParameters.TangentToWorld[2]; // Take into account per-pixel normal shading variation // Note: For hair shading the tangent is actually stored as the normal input Payload.WorldTangent = normalize(MaterialParameters.WorldNormal); #endif #if (TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_NONDIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_DIRECTIONAL) if (Payload.ShadingModelID == SHADINGMODELID_UNLIT) { // encode the directionality using the specular field #if TRANSLUCENCY_LIGHTING_VOLUMETRIC_PERVERTEX_DIRECTIONAL || TRANSLUCENCY_LIGHTING_VOLUMETRIC_DIRECTIONAL Payload.Anisotropy = GetMaterialTranslucencyDirectionalLightingIntensity(); #else Payload.Anisotropy = 0; #endif Payload.Specular = 0; Payload.Metallic = 0; Payload.Roughness = 1; } else #elif MATERIAL_SHADINGMODEL_UNLIT if (Payload.ShadingModelID == SHADINGMODELID_UNLIT) { // Regular unlit material, make sure the volumetric component is zero'ed out Payload.BaseColor = 0; Payload.Specular = 0; } else #endif #if MATERIAL_SHADINGMODEL_CLEAR_COAT if (Payload.ShadingModelID == SHADINGMODELID_CLEAR_COAT) { const float ClearCoat = GetMaterialCustomData0(PixelMaterialInputs); const float ClearCoatRoughness = GetMaterialCustomData1(PixelMaterialInputs); Payload.SetClearCoat(ClearCoat); Payload.SetClearCoatRoughness(AdjustMaterialRoughness(ClearCoatRoughness, PackedPayload.GetPathRoughness())); #if CLEAR_COAT_BOTTOM_NORMAL #if NUM_MATERIAL_OUTPUTS_CLEARCOATBOTTOMNORMAL > 0 #if MATERIAL_TANGENTSPACENORMAL float3 BottomNormal = normalize(TransformTangentVectorToWorld(MaterialParameters.TangentToWorld, ClearCoatBottomNormal0(MaterialParameters))); #else float3 BottomNormal = ClearCoatBottomNormal0(MaterialParameters); #endif // if we got a custom normal for the clearcoat, adjust it now BottomNormal = AdjustShadingNormal(BottomNormal, Payload.WorldGeoNormal, WorldRayDirection()); Payload.SetClearCoatBottomNormal(BottomNormal); #else Payload.SetClearCoatBottomNormal(Payload.WorldNormal); #endif #else Payload.SetClearCoatBottomNormal(Payload.WorldNormal); #endif } else #endif #if MATERIAL_SHADINGMODEL_CLOTH if (Payload.ShadingModelID == SHADINGMODELID_CLOTH) { const float3 ClothColor = GetMaterialSubsurfaceData(PixelMaterialInputs).rgb; const float Fuzz = saturate(GetMaterialCustomData0(PixelMaterialInputs)); Payload.SetClothColor(ClothColor); Payload.SetClothAmount(Fuzz); } else #endif #if MATERIAL_SHADINGMODEL_TWOSIDED_FOLIAGE if (Payload.ShadingModelID == SHADINGMODELID_TWOSIDED_FOLIAGE) { const float3 SubsurfaceColor = GetMaterialSubsurfaceData(PixelMaterialInputs).rgb; Payload.SetSubsurfaceColor(SubsurfaceColor); } else #endif #if MATERIAL_SHADINGMODEL_SUBSURFACE || MATERIAL_SHADINGMODEL_PREINTEGRATED_SKIN if (Payload.ShadingModelID == SHADINGMODELID_SUBSURFACE || Payload.ShadingModelID == SHADINGMODELID_PREINTEGRATED_SKIN) { const float3 SubsurfaceColor = GetMaterialSubsurfaceData(PixelMaterialInputs).rgb; Payload.SetSubsurfaceColor(SubsurfaceColor); #if HAVE_GetSubsurfaceMediumMaterialOutput0 Payload.SetSubsurfaceRadius(GetSubsurfaceMediumMaterialOutput0(MaterialParameters)); #else // TODO: is this accurate enough? hard to measure exactly since the raster path uses a very different approach const float Opacity = GetMaterialOpacity(PixelMaterialInputs); const float SSSRadius = (1 - Opacity) * 10.0; // simple formula, up to 10cm radius Payload.SetSubsurfaceRadius(SSSRadius); #endif #if HAVE_GetSubsurfaceMediumMaterialOutput1 float ScatteringDistribution = clamp(GetSubsurfaceMediumMaterialOutput1(MaterialParameters), -0.99f, 0.99f); Payload.SetSubsurfacePhaseFunction(ScatteringDistribution); #else Payload.SetSubsurfacePhaseFunction(0.0); #endif } else #endif #if MATERIAL_SHADINGMODEL_SUBSURFACE_PROFILE if (Payload.ShadingModelID == SHADINGMODELID_SUBSURFACE_PROFILE) { const uint ProfileId = ExtractSubsurfaceProfileInt(GetMaterialSubsurfaceDataRaw(PixelMaterialInputs).a); // Decode dual roughness info float Lobe0Roughness = 0; float Lobe1Roughness = 0; float LobeMix = 0; // NOTE: we pass 1.0 for opacity because we don't really want to fade-out the dual roughness as opacity is lowered GetSubsurfaceProfileDualSpecular(ProfileId, Payload.Roughness, 1.0, Lobe0Roughness, Lobe1Roughness, LobeMix); Lobe0Roughness = AdjustMaterialRoughness(Lobe0Roughness, PackedPayload.GetPathRoughness()); Lobe1Roughness = AdjustMaterialRoughness(Lobe1Roughness, PackedPayload.GetPathRoughness()); Payload.SetDualRoughnessSpecular(Lobe0Roughness, Lobe1Roughness, LobeMix); #if HAVE_GetSubsurfaceMediumMaterialOutput0 Payload.SetSubsurfaceRadius(GetSubsurfaceMediumMaterialOutput0(MaterialParameters)); #else if (GetSubsurfaceProfileUseBurley(ProfileId)) { // Decode SSS radius const float Opacity = GetMaterialOpacity(PixelMaterialInputs); const float3 DiffuseColor = Payload.BaseColor * (1.0 - Payload.Metallic); Payload.SetSubsurfaceRadius(DecodeSSSProfileRadius(ProfileId, DiffuseColor, Opacity)); } else { Payload.SetSubsurfaceRadius(0.0); } #endif #if HAVE_GetSubsurfaceMediumMaterialOutput1 float ScatteringDistribution = clamp(GetSubsurfaceMediumMaterialOutput1(MaterialParameters), -0.99f, 0.99f); Payload.SetSubsurfacePhaseFunction(ScatteringDistribution); #elif USE_SSS_PROFILE_ANISOTROPY float G = DecodeSSSProfileScatteringDistribution(ProfileId); Payload.SetSubsurfacePhaseFunction(G); Payload.SetSubsurfaceRadius(Payload.GetSubsurfaceRadius() * (1 - G)); #else Payload.SetSubsurfacePhaseFunction(0.0); #endif } else #endif #if MATERIAL_SHADINGMODEL_SINGLELAYERWATER if (Payload.ShadingModelID == SHADINGMODELID_SINGLELAYERWATER) { // For single layer water we always want to treat it as front facing when evaluating parameters // as hitting back face is treated as being underwater and we get completely different parameters. FMaterialPixelParameters WaterMaterialParameters = MaterialParameters; WaterMaterialParameters.TwoSidedSign = 1; const float3 ScatteringCoeff = max(0.0f, DFDemote(GetSingleLayerWaterMaterialOutput0(WaterMaterialParameters))); const float3 AbsorptionCoeff = max(0.0f, DFDemote(GetSingleLayerWaterMaterialOutput1(WaterMaterialParameters))); const float PhaseG = clamp(DFDemote(GetSingleLayerWaterMaterialOutput2(WaterMaterialParameters).x), -0.99f, 0.99f); const float3 WaterExtinction = ScatteringCoeff + AbsorptionCoeff; const float3 WaterAlbedo = select(WaterExtinction > 0.0, ScatteringCoeff / WaterExtinction, float3(0.0, 0.0, 0.0)); Payload.ShadingModelID = SHADINGMODELID_SOLID_GLASS; // replace shading model to avoid extra cases in raygen Payload.BaseColor = WaterAlbedo; // TODO: unused at the moment Payload.SetExtinction(WaterExtinction); Payload.Ior = DielectricF0ToIor(DielectricSpecularToF0(Specular)); // we are using actual refraction, so don't apply any transparency Payload.TransparencyColor = 0.0; Payload.BSDFOpacity = 1.0; } else #endif #if MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT if (Payload.ShadingModelID == SHADINGMODELID_THIN_TRANSLUCENT) { const float3 TransmittanceColor = GetThinTranslucentMaterialOutput0(MaterialParameters); Payload.SetTransmittanceColor(TransmittanceColor); // The material is a blend of glass and default_lit response, model it stochastically if (Payload.BSDFOpacity < PackedPayload.GetStochasticSlabRand()) { // Pick glass lobe - shade as glass (leave SHADINGMODELID_THIN_TRANSLUCENT on) Payload.Ior = Ior; } else { // Pick solid lobe -- toggle back to default_lit response // Ior stays 0.0 since this mode does not include any refraction Payload.ShadingModelID = SHADINGMODELID_DEFAULT_LIT; } float SurfaceCoverage = GetThinTranslucentMaterialOutput1(MaterialParameters); if (Ior > 0.0) { // In this mode we get rough refraction, so any transparency is only due to coverage (affecting both solid and glass lobes) Payload.TransparencyColor = 1 - SurfaceCoverage; } else { // In this mode we just get straight transparency const float3 V = WorldRayDirection(); const float3 N = normalize(Payload.WorldNormal); const float VoN = abs(dot(V, N)); const float3 BaseColor = Payload.BaseColor; const float Metallic = Payload.Metallic; const float Specular = Payload.Specular; const float F0 = F0RGBToF0(ComputeF0(Specular, BaseColor, Metallic)); // This is the portion of transparency due to glass. We always compute it because we don't need to model the amount // of transparency stochastically. /// BSDFOpacity here still represents the blend between solid and glass behaviors. Payload.TransparencyColor = (1 - Payload.BSDFOpacity) * ComputeThinSlabWeights(TransmittanceColor, VoN, 0.0, F0).Transmitted; // Now account for overall coverage (allows the combination of solid/glass to become transparent) Payload.TransparencyColor = lerp(1.0.xxx, Payload.TransparencyColor, SurfaceCoverage); } // Now we can replace the BSDFOpacity with coverage Payload.BSDFOpacity = SurfaceCoverage; } else #endif #if MATERIAL_SHADINGMODEL_HAIR if (Payload.ShadingModelID == SHADINGMODELID_HAIR) { // TODO: encode hair specific info #if HAIR_STRAND_MESH_FACTORY Payload.SetHairPrimitiveUV(MaterialParameters.HairPrimitiveUV); #else Payload.SetHairPrimitiveUV(0.5); #endif } else #endif #if MATERIAL_SHADINGMODEL_EYE if (Payload.ShadingModelID == SHADINGMODELID_EYE) { // This is all based on logic from ShadingModelsMaterial.ush const float IrisMask = saturate(GetMaterialCustomData0(PixelMaterialInputs)); const float IrisDistance = saturate(GetMaterialCustomData1(PixelMaterialInputs)); Payload.SetEyeIrisMask(IrisMask); Payload.Metallic = 0.0; #if NUM_MATERIAL_OUTPUTS_GETTANGENTOUTPUT > 0 // Blend in the negative intersection normal to create some concavity // Not great as it ties the concavity to the convexity of the cornea surface // No good justification for that. On the other hand, if we're just looking to // introduce some concavity, this does the job. const float3 PlaneNormal = normalize(GetTangentOutput0(MaterialParameters)); const float3 CausticNormal = normalize(lerp(PlaneNormal, -Payload.WorldNormal, IrisMask * IrisDistance)); Payload.SetEyeCausticNormal(CausticNormal); // NOTE: calling AdjustShadingNormal on the custom normal does not seem necessary since this is only used for a diffuse calculation #else const float3 PlaneNormal = Payload.WorldNormal; Payload.SetEyeCausticNormal(Payload.WorldNormal); #endif #if IRIS_NORMAL // on Payload.Specular = 0.25; #if NUM_MATERIAL_OUTPUTS_CLEARCOATBOTTOMNORMAL > 0 float3 IrisNormal = normalize( ClearCoatBottomNormal0(MaterialParameters) ); #if MATERIAL_TANGENTSPACENORMAL IrisNormal = normalize( TransformTangentVectorToWorld( MaterialParameters.TangentToWorld, IrisNormal ) ); #endif #else float3 IrisNormal = PlaneNormal; #endif Payload.SetEyeIrisNormal(IrisNormal); #else // IRIS_NORMAL off Payload.SetEyeIrisNormal(PlaneNormal); #endif #if HAVE_GetSubsurfaceMediumMaterialOutput0 Payload.SetSubsurfaceRadius(GetSubsurfaceMediumMaterialOutput0(MaterialParameters)); #else const uint ProfileId = ExtractSubsurfaceProfileInt(GetMaterialSubsurfaceDataRaw(PixelMaterialInputs).a); if (GetSubsurfaceProfileUseBurley(ProfileId)) { // Decode SSS radius const float Opacity = GetMaterialOpacity(PixelMaterialInputs); const float3 DiffuseColor = Payload.BaseColor * (1.0 - Payload.Metallic); Payload.SetSubsurfaceRadius(DecodeSSSProfileRadius(ProfileId, DiffuseColor, Opacity)); } else { Payload.SetSubsurfaceRadius(0.0); } #endif #if HAVE_GetSubsurfaceMediumMaterialOutput1 float ScatteringDistribution = clamp(GetSubsurfaceMediumMaterialOutput1(MaterialParameters), -0.99f, 0.99f); Payload.SetSubsurfacePhaseFunction(ScatteringDistribution); #else Payload.SetSubsurfacePhaseFunction(0.0); #endif } else #endif #if MATERIAL_SHADINGMODEL_DEFAULT_LIT if (Payload.ShadingModelID == SHADINGMODELID_DEFAULT_LIT) { // only allow refraction for default lit materials since we need space for the absorption amount #if HAVE_GetAbsorptionMediumMaterialOutput0 Payload.SetExtinction(PathTracingGlassTransmittanceToExtinction(GetAbsorptionMediumMaterialOutput0(MaterialParameters))); #else // Make the glass totally clear if no custom medium is set Payload.SetExtinction(0.0); #endif if (Ior > 0.0) { // Our material is a blend between glass and default_lit -- use stochastic blending between the two Payload.TransparencyColor = 0.0; if (PackedPayload.GetStochasticSlabRand() < Payload.BSDFOpacity) { // solid case - keep default_lit shading model } else { // glass // we are using actual refraction, so disable transparency Payload.Ior = Ior; Payload.ShadingModelID = SHADINGMODELID_SOLID_GLASS; } Payload.BSDFOpacity = 1.0; // cancels out with the probability of selecting the lobe } } else #endif { // terminal case for the conditionals above } // adjust after everything else (because SSS profile case needs to decode the dual spec info from the unmodified roughness) Payload.Roughness = AdjustMaterialRoughness(Payload.Roughness, PackedPayload.GetPathRoughness()); #endif // SUBSTRATE_ENABLED // Only opaque surfaces can recieve decals. This is both for compatibility with raster and improving performance when we have stacks of transparent surfaces #if MATERIALBLENDING_SOLID || MATERIALBLENDING_MASKED if ((PrimitiveFlags & PRIMITIVE_SCENE_DATA_FLAG_DECAL_RECEIVER) != 0) { #if USE_DBUFFER Payload.SetDecalReceiver(MATERIALDECALRESPONSEMASK); # if MATERIAL_USES_DECAL_LOOKUP Payload.SetUseDBufferLookup(); # endif #else Payload.SetDecalReceiver(0x07); #endif } #endif #if MATERIALBLENDING_ALPHAHOLDOUT // the material is already a holdout, no need to do anything else #else if (PackedPayload.IsCameraRay()) { if ((PrimitiveFlags & PRIMITIVE_SCENE_DATA_FLAG_HOLDOUT) != 0 && ResolvedView.bPrimitiveAlphaHoldoutEnabled) { if (Payload.Ior != 0.0) { // If the surface is marked as refractive then treat it as opaque for holdout Payload.BSDFOpacity = 1.0; } else { // keep the opacity from the material, it might indicate partial transparency // so we should get a partial holdout } Payload.SetHoldout(); Payload.ShadingModelID = SHADINGMODELID_UNLIT; Payload.Radiance = 0; } } #endif #if MATERIAL_VIRTUALTEXTURE_FEEDBACK if (PackedPayload.IsCameraRay()) { // Virtual texturing feedback logic (camera rays only for now) FinalizeVirtualTextureFeedback( MaterialParameters.VirtualTextureFeedback, MaterialParameters.SvPosition, View.VTFeedbackBuffer ); } #endif // Output depth for solid, masked // or when `output depth and velocity' is set and Opacity >= Opacity mask clip value to match the behavior of the rasterizer path. #if (MATERIALBLENDING_SOLID || MATERIALBLENDING_MASKED) Payload.SetOutputDepth(); #elif (TRANSLUCENT_WRITING_VELOCITY && \ (MATERIALBLENDING_TRANSLUCENT || MATERIALBLENDING_ADDITIVE || MATERIALBLENDING_MODULATE || MATERIALBLENDING_ALPHACOMPOSITE || MATERIALBLENDING_ALPHAHOLDOUT)) if (GetMaterialOpacity(PixelMaterialInputs) >= GetMaterialOpacityMaskClipValue()) { Payload.SetOutputDepth(); } #endif PackedPayload = PackPathTracingPayload(Payload); } #if USE_MATERIAL_ANY_HIT_SHADER RAY_TRACING_ENTRY_ANY_HIT(PathTracingMaterialAHS, FPackedPathTracingPayload, PackedPayload, FRayTracingIntersectionAttributes, Attributes) { #if MATERIALBLENDING_MODULATE || (MATERIALBLENDING_MASKED && MATERIAL_DITHER_OPACITY_MASK) || MATERIALBLENDING_ALPHACOMPOSITE || MATERIALBLENDING_TRANSLUCENT if (!PackedPayload.IsVisibilityRay()) { if (PackedPayload.GetFlags() & PATH_TRACING_PAYLOAD_INPUT_FLAG_IGNORE_TRANSLUCENT) { IgnoreHit(); } // not a shadow ray -- don't need to run the AHS logic return; } if (PackedPayload.HitT == RayTCurrent()) { // We just processed this exact hit, don't double-count it IgnoreHit(); return; } #endif // This is the only case which actually needs to run the full material ResolvedView = ResolveView(); const float3 TranslatedWorldPosition = TranslatedWorldRayOrigin() + RayTCurrent() * WorldRayDirection(); const float4 SvPosition = TranslatedWorldPositionToSvPosition(TranslatedWorldPosition); CurrentPayloadInputFlags = PackedPayload.GetFlags(); PathTracerSceneDepth = (CurrentPayloadInputFlags & PATH_TRACING_PAYLOAD_INPUT_FLAG_HAS_SCENE_DEPTH) ? PackedPayload.GetSceneDepth() : SCENE_TEXTURES_DISABLED_SCENE_DEPTH_VALUE; #if VF_SUPPORTS_RAYTRACING_PREPARE_MATERIAL_PIXEL_PARAMETERS // this is a newer codepath that is both more flexible and allows for more direct calculation compared to the other codepath // TODO: implement such a method for all vertex factories float3 GeoNormal = 0; FMaterialPixelParameters MaterialParameters = GetMaterialPixelParameters(TranslatedWorldRayOrigin(), WorldRayDirection(), RayTCurrent(), PrimitiveIndex(), Attributes, HitKind(), SvPosition, GeoNormal); #else FVertexFactoryInterpolantsVSToPS Interpolants; float3 GeoNormal = 0; CalcInterpolants((FRayCone)0, Attributes, Interpolants, GeoNormal); FMaterialPixelParameters MaterialParameters = GetMaterialPixelParameters(Interpolants, SvPosition); #endif FPixelMaterialInputs PixelMaterialInputs; const bool bIsFrontFace = HitKind() == HIT_KIND_TRIANGLE_FRONT_FACE; { const float4 ScreenPosition = SvPositionToResolvedScreenPosition(SvPosition); MaterialParameters.CameraVector = -WorldRayDirection(); CalcMaterialParametersEx(MaterialParameters, PixelMaterialInputs, SvPosition, ScreenPosition, bIsFrontFace, TranslatedWorldPosition, TranslatedWorldPosition); } #if MATERIALBLENDING_MASKED && !MATERIAL_DITHER_OPACITY_MASK // Regardless of payload flags -- we always apply this if (GetMaterialMask(PixelMaterialInputs) < 0) { IgnoreHit(); } #endif // the following blend modes need to process shadows after having executed the material #if MATERIALBLENDING_MODULATE || (MATERIALBLENDING_MASKED && MATERIAL_DITHER_OPACITY_MASK) || MATERIALBLENDING_ALPHACOMPOSITE || MATERIALBLENDING_TRANSLUCENT PackedPayload.HitT = RayTCurrent(); // remember the distance at which we ran the shader, in case we get a double-hit { // TODO: Cleanup this indentation level #if SUBSTRATE_ENABLED float3 Transparency = 0.0; #if MATERIAL_IS_SUBSTRATE FSubstratePixelHeader SubstratePixelHeader = MaterialParameters.GetFrontSubstrateHeader(); FSubstrateData SubstrateData = PixelMaterialInputs.GetFrontSubstrateData(); FSubstrateIntegrationSettings IntegrationSettings = InitSubstrateIntegrationSettings( false /* bForceFullyRough */, true /* SubstrateStruct.bRoughDiffuse */, -1 /* SubstrateStruct.PeelLayersAboveDepth */, true /* SubstrateStruct.bRoughnessTracking */ ); float TotalCoverage = 1; float3 TotalTransmittancePreCoverage = 0; const float3 V_World = MaterialParameters.CameraVector; SubstratePixelHeader.SubstrateUpdateTree(SubstrateData, V_World, IntegrationSettings, TotalCoverage, TotalTransmittancePreCoverage); #if MATERIALBLENDING_TRANSLUCENT && (REFRACTION_USE_INDEX_OF_REFRACTION || MATERIAL_ISTHINSURFACE) // SUBSTRATE_TODO: refraction handling float PathRoughness = PackedPayload.GetPathRoughness(); // SUBSTRATE_TODO: This does not match the logic in DistortAccumulatePS.usf // The idea here is to take F0 from the bottom refraction layers since this matches most closely what the refraction logic below does (only bottom slabs can refract). // The distortion approximation on the raster side instead averages F0 across layers which may produce different results. // In both cases - we get a potentially strange answer when there is more than one bottom slab that produces refraction // SUBSTRATE_TODO: How should we handle MFP when there are multiple bottom slabs? float F0 = 0.0f; float3 RoughnessData = 0.0; float NoV = 0.0f; float3 LocalSigmaT = 0.0f; float Ior = 0.0; SUBSTRATE_UNROLL_N(SUBSTRATE_CLAMPED_CLOSURE_COUNT) for (int BSDFIdx = 0; BSDFIdx < SubstratePixelHeader.SubstrateTree.BSDFCount; ++BSDFIdx) { #define BSDF SubstratePixelHeader.SubstrateTree.BSDFs[BSDFIdx] if (BSDF.bIsBottom) { float3 N = SubstratePixelHeader.SharedLocalBases.Normals[BSDF_GETSHAREDLOCALBASISID(BSDF)]; NoV = dot(N, V_World); switch (BSDF_GETTYPE(BSDF)) { case SUBSTRATE_BSDF_TYPE_SLAB: { // SUBSTRATE_TODO: Also consider the MFP to see how much this slab is contributing to refraction .... F0 = F0RGBToF0(SubstrateGetBSDFSpecularF0(BSDF)); RoughnessData.x = SLAB_ROUGHNESS(BSDF); if (BSDF_GETHASHAZINESS(BSDF)) { // NOTE: It should be safe to assume that the clearcoat case cannot happen here as it is only triggered by legacy clearcoat materials which are unlikely to have refraction const FHaziness Haziness = UnpackHaziness(SLAB_HAZINESS(BSDF)); RoughnessData.y = Haziness.Roughness; RoughnessData.z = Haziness.Weight; } LocalSigmaT = rcp(max(SLAB_SSSMFP(BSDF), 0.0001)); #if REFRACTION_USE_INDEX_OF_REFRACTION Ior = GetRefractionIor(PixelMaterialInputs, F0); #endif break; } case SUBSTRATE_BSDF_TYPE_SINGLELAYERWATER: { RoughnessData.x = SLW_ROUGHNESS(BSDF); RoughnessData.yz = 0; #if SUBSTRATE_INLINE_SINGLELAYERWATER LocalSigmaT = SLW_WATEREXTINCTION(BSDF); #endif float F0 = DielectricSpecularToF0(SLW_SPECULAR(BSDF)); Ior = DielectricF0ToIor(F0); break; } } break; // Found BSDF bottom, exit loop } #undef BSDF } #if MATERIAL_ISTHINSURFACE // Thin Glass Fake Caustics // SUBSTRATE_TODO: Revisit this -- TotalTransmittancePreCoverage should probably account for this in the thin case float3 Transmission = exp(-LocalSigmaT * SUBSTRATE_SIMPLEVOLUME_THICKNESS_CM); float3 Tr = ComputeThinSlabWeights(Transmission, NoV, Ior, F0).Transmitted; #else HLSL_STATIC_ASSERT(REFRACTION_USE_INDEX_OF_REFRACTION == 1, "Expect refraction to be true here"); // Solid Glass Fake Caustics float Tr = FakeCaustics(F0, Ior, NoV); // Account for transmission PackedPayload.SetTau(PackedPayload.GetTau() + ComputeOpticalDepthForHit(LocalSigmaT, bIsFrontFace)); #endif // If material is doing refraction, apply an extra factor to account for ApproximateCaustics #if REFRACTION_USE_INDEX_OF_REFRACTION if (Ior > 0.0) { Tr *= lerp(FakeCausticsPathFactor(RoughnessData.x, PathRoughness), FakeCausticsPathFactor(RoughnessData.y, PathRoughness), RoughnessData.z); } #endif Transparency += TotalCoverage * Tr; // SUBSTRATE_TODO: Is this sanity check necessary? Transparency = saturate(Transparency); #else // MATERIALBLENDING_TRANSLUCENT && (REFRACTION_USE_INDEX_OF_REFRACTION || MATERIAL_ISTHINSURFACE) // All other blend modes, do simple transparency handling Transparency = lerp(1.0, TotalTransmittancePreCoverage, TotalCoverage); #endif #endif // MATERIAL_IS_SUBSTRATE #else // SUBSTRATE_ENABLED #if MATERIALBLENDING_MODULATE const float3 Transparency = GetMaterialEmissive(PixelMaterialInputs); #elif MATERIALBLENDING_ALPHACOMPOSITE const float Opacity = GetMaterialOpacity(PixelMaterialInputs); const float Transparency = 1 - Opacity; #elif MATERIALBLENDING_MASKED && MATERIAL_DITHER_OPACITY_MASK // See MATERIAL_DITHER_OPACITY_MASK comment below const float Opacity = saturate(GetMaterialMaskInputRaw(PixelMaterialInputs)); const float Transparency = 1 - Opacity; #elif MATERIALBLENDING_TRANSLUCENT const float Opacity = GetMaterialOpacity(PixelMaterialInputs); #if MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT // We can only get colored shadows for thin translucent (solid translucent case happens via absorption only) float3 Transparency = 1 - Opacity; #else float Transparency = 1 - Opacity; #endif uint ShadingModelID = GetMaterialShadingModel(PixelMaterialInputs); #if MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT if (ShadingModelID == SHADINGMODELID_THIN_TRANSLUCENT) { float3 Transmission = GetThinTranslucentMaterialOutput0(MaterialParameters); #if REFRACTION_USE_INDEX_OF_REFRACTION float Ior = GetRefractionIor(PixelMaterialInputs); #else float Ior = 0.0; #endif float3 V = WorldRayDirection(); float3 N = normalize(MaterialParameters.WorldNormal); float VoN = abs(dot(V, N)); if (Opacity < 1.0) { float PathRoughness = PackedPayload.GetPathRoughness(); float Roughness = GetMaterialRoughness(PixelMaterialInputs); if (Ior > 0.0 && PathRoughness <= Roughness) { // not using fast caustic approximation - treat as opaque PackedPayload.SetRayThroughput(0.0); return; } // compute transmission through the slab (fresnel + absorption) float3 BaseColor = GetMaterialBaseColor(PixelMaterialInputs); float Metallic = GetMaterialMetallic(PixelMaterialInputs); float Specular = GetMaterialSpecular(PixelMaterialInputs); float F0 = F0RGBToF0(ComputeF0(Specular, BaseColor, Metallic)); Transparency *= ComputeThinSlabWeights(Transmission, VoN, Ior, F0).Transmitted; // fake caustic approximation (see comments below) #if REFRACTION_USE_INDEX_OF_REFRACTION if (Ior > 0.0) { Transparency *= FakeCausticsPathFactor(Roughness, PathRoughness); } #endif } // Fade out the Transparency as a function of the SurfaceCoverage. const float SurfaceCoverage = GetThinTranslucentMaterialOutput1(MaterialParameters); Transparency = lerp(1.0.xxx, Transparency, SurfaceCoverage); } else #endif // MATERIAL_SHADINGMODEL_THIN_TRANSLUCENT #if MATERIAL_SHADINGMODEL_DEFAULT_LIT && REFRACTION_USE_INDEX_OF_REFRACTION if (ShadingModelID == SHADINGMODELID_DEFAULT_LIT) { // Is refraction enabled? float Ior = GetRefractionIor(PixelMaterialInputs); if (Transparency > 0 && Ior > 0.0) { // current hit has some refraction float PathRoughness = PackedPayload.GetPathRoughness(); float Roughness = GetMaterialRoughness(PixelMaterialInputs); float3 BaseColor = GetMaterialBaseColor(PixelMaterialInputs); float Metallic = GetMaterialMetallic(PixelMaterialInputs); float Specular = GetMaterialSpecular(PixelMaterialInputs); float F0 = F0RGBToF0(ComputeF0(Specular, BaseColor, Metallic)); float3 N = normalize(MaterialParameters.WorldNormal); float NoV = dot(WorldRayDirection(), N); Transparency *= FakeCaustics(F0, Ior, NoV) * FakeCausticsPathFactor(Roughness, PathRoughness); #if HAVE_GetAbsorptionMediumMaterialOutput0 // Does the material have any kind of volumetric absorption to apply? float3 TransmittanceColor = GetAbsorptionMediumMaterialOutput0(MaterialParameters); float3 LocalSigmaT = PathTracingGlassTransmittanceToExtinction(TransmittanceColor); PackedPayload.SetTau(PackedPayload.GetTau() + ComputeOpticalDepthForHit(LocalSigmaT, bIsFrontFace)); #endif // HAVE_GetAbsorptionMediumMaterialOutput0 } } else #endif // MATERIAL_SHADINGMODEL_DEFAULT_LIT { // base case for shadingmodel if/else } #else // MATERIALBLENDING_* #error Unhandled blending mode! #endif #endif // SUBSTRATE_ENABLED // Update the ray throughput (it is packed simply into the payload since we don't need to carry any other information across hits) float3 RayThroughput = PackedPayload.GetRayThroughput(); RayThroughput *= Transparency; PackedPayload.SetRayThroughput(RayThroughput); if (any(RayThroughput > 0)) { // keep tracing if we still have some energy left IgnoreHit(); } } #endif } #endif // USE_MATERIAL_ANY_HIT_SHADER