// Copyright Epic Games, Inc. All Rights Reserved.

/*=============================================================================
	PathTracingCommon.ush: path tracing payload structures
=============================================================================*/

#pragma once

#include "Material/PathTracingMaterialCommon.ush"
#include "Utilities/PathTracingRandomSequence.ush"
#include "Utilities/PathTracingRIS.ush"
#include "../RayTracing/RayTracingCommon.ush"
#include "../OctahedralCommon.ush"
#include "../DoubleFloat.ush"
#include "/Engine/Shared/PathTracingDefinitions.h"

// These flags are analogous to RAY_TRACING_PAYLOAD_* flags. There are currently 9 bits available.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_FRONT_FACE                   (1 << 0) // Indicates that ray has hit the front face of a primitive. Set by closest hit shader.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_TWO_SIDED_MATERIAL           (1 << 1) // Indicates that ray has hit a primitive surface with a two sided material. Set by closest hit shader. Used by GPU Lightmass to detect invalid surfaces.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_IS_HOLDOUT                   (1 << 2) // Indicates that ray has hit a primitive which should be held out from alpha.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_MASK_SHIFT    (3)
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_COLOR         (1 << 3) // Indicates that ray has hit a primitive that receives decals color. Set by closest hit shader.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_NORMAL        (1 << 4) // Indicates that ray has hit a primitive that receives decals normal. Set by closest hit shader.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_ROUGHNESS     (1 << 5) // Indicates that ray has hit a primitive that receives decals metallic/specular/roughness. Set by closest hit shader.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_USE_DBUFFER_LOOKUP           (1 << 6) // Indicates that ray has hit a primitive that uses DBufferTextureLookup. Set by closest hit shader.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_OUTOUT_DEPTH				  (1 << 7) // Indicates that ray has hit a primitive that needs to output depth. Set by closest hit shader and used in primary ray only.
#define PATH_TRACING_PAYLOAD_OUTPUT_FLAG_UNUSED8                      (1 << 8) // Free for future use

#define PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_MASK                 (7 << 0) // Reserve 3 bits for ray-mask
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_CAMERA                0       // Indicates that this is a camera ray which can trigger a number of special behaviors in the closest hit shader
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_SHADOW                1       // Indicates that this is a path tracer visibility ray (which supports material evaluation for transparent shadows and fake caustics)
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_INDIRECT_DIFFUSE      2
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_INDIRECT_SPECULAR     3
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_INDIRECT_VOLUME       4
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_HAS_SCENE_DEPTH               (1 << 4) // Indicates the payload contains a scene depth value (exclusive with dbuffer usage)
#define PATH_TRACING_PAYLOAD_INPUT_FLAG_IGNORE_TRANSLUCENT            (1 << 5) // Indicates this ray should not process any translucent geometry (so we can skip them in our opaque traces)

#define PATH_TRACING_PAYLOAD_NORMAL_BITS  		32
#define PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS 16 						// Could be dropped to 12 or even 10 if we need more room in the future

// shading model extensions beyond the default count
#define SHADINGMODELID_MEDIUM  			(SHADINGMODELID_NUM + 1)
#define SHADINGMODELID_SOLID_GLASS 		(SHADINGMODELID_NUM + 2)

HLSL_STATIC_ASSERT(SHADINGMODELID_MEDIUM      <= SHADINGMODELID_MASK, "");
HLSL_STATIC_ASSERT(SHADINGMODELID_SOLID_GLASS <= SHADINGMODELID_MASK, "");

#define PATH_TRACING_ABSORPTION_SCALE  0.01        // inverse distance at which we hit the transmission color (Beer's law)


// Given a ray with origin O in direction D, assuming we have found a valid hit at THit, compute a new TMin value that we can use to retrace
// the same ray and find more hits. This is used for transparency, mesh decals and SSS tracing.
float ComputeNewTMin(float3 O, float3 D, float THit)
{
#if NEED_TMIN_WORKAROUND
	// Some hardware shifts the ray origin to TMin which can lead to erroneous hits against TMin when shifted back
	// This code tries to find to smallest increment that causes the shifted origin to change
	uint Inc = 1;
	float TMin = asfloat(asuint(THit) + Inc);
	while (all((mad(D, TMin, O) == mad(D, THit, O)))) {
		Inc *= 2;
		TMin = asfloat(asuint(THit) + Inc);
	}
	return TMin;
#else
	// On conformant hardware, the following is sufficient to avoid the previous hit
	return asfloat(asuint(THit) + 1);
#endif
}


// Utilities to help weight the contribution of the albedo/normal to the denoising buffers
// We want cases like low roughness mirrors to "pass through" the signal
static const float DenoiserMaxRoughness = 0.15f; // don't bother past this level
static const float DenoiserMinRoughness = 0.10f; // capture anything below this level

// Given the current path roughness, how much contribution should the current hit make to the denoiser AOVs?
float DenoiserAOVWeight(float PathRoughness)
{
	return 1 - saturate((PathRoughness - DenoiserMinRoughness) / (DenoiserMaxRoughness - DenoiserMinRoughness));
}
// For a given surface of roughness R, how much should its own contribution be counted
// This heuristic lets us skip the contribution a mirror's albedo would normally make because we will be seeing "through" it to the next hit
float DenoiserRoughnessWeight(float Roughness, float PathRoughness)
{
	float MinRoughness = max(DenoiserMinRoughness, PathRoughness);
	return saturate((Roughness - MinRoughness) / (DenoiserMaxRoughness - MinRoughness));
}

// This function is meant for the solid glass case so we can store the transmittance as a color in [0,1]
float3 PathTracingGlassTransmittanceToExtinction(float3 TransmittanceColor)
{
	return -log(max(TransmittanceColor, 1e-8f)) * PATH_TRACING_ABSORPTION_SCALE;
}

uint PayloadEncodeUnitVector(float3 Normal)
{
	const int BITS = PATH_TRACING_PAYLOAD_NORMAL_BITS;
	const float Scale = float((1u << (BITS / 2)) - 2) / 2; // largest representable even number (so we can encode 0)
	float2 OctF = UnitVectorToOctahedron(Normal);
	int2 Oct = int2(round(OctF * Scale + Scale));
	return Oct.x + (1u << (BITS / 2)) * Oct.y;
}

float3 PayloadDecodeUnitVector(uint Encoded)
{
	const int BITS = PATH_TRACING_PAYLOAD_NORMAL_BITS;
	const uint Mask = (1u << (BITS / 2)) - 1;
	const float Scale = float((1u << (BITS / 2)) - 2);

	int2 Oct = int2(Encoded & Mask, (Encoded >> (BITS / 2)) & Mask);
	float2 OctF = saturate(float2(Oct) / Scale);
	return OctahedronToUnitVector(2 * OctF - 1);
}

// Encode a tangent vector relative to a given Normal
uint PayloadEncodeTangentAngle(float3 Normal, float3 Tangent)
{
	const uint Mask = (1u << (PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS - 2)) - 1;
	const uint SignShiftX = 31 - (PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS - 2);
	const uint SignShiftY = 31 - (PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS - 1);
	const uint SignMaskX = 0x80000000u >> SignShiftX;
	const uint SignMaskY = 0x80000000u >> SignShiftY;
	const float Scale = float(Mask);

	float3x3 Basis = GetTangentBasis(Normal);
	float X = dot(Basis[0], Tangent);
	float Y = dot(Basis[1], Tangent);
	// NOTE: We use 'Y' to define the angle so that if Tangent happens to be (0,0,0) it will be decoded back as the "x" axis in the reference basis
	float PseudoAngle = abs(Y) / (abs(X) + abs(Y)); // Coarse ArcTan, returns value in [0,1]
	uint QuantizedBits = uint(round(PseudoAngle * Scale));
	// Merge with sign bits of X and Y
	return QuantizedBits | ((asuint(X) >> SignShiftX) & SignMaskX) | ((asuint(Y) >> SignShiftY) & SignMaskY);
}

// Decode a tangent vector relative to a given Normal
float3 PayloadDecodeTangentAngle(float3 Normal, uint Bits)
{
	const uint Mask = (1u << (PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS - 2)) - 1;
	const uint SignShiftX = 31 - (PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS - 2);
	const uint SignShiftY = 31 - (PATH_TRACING_PAYLOAD_TANGENT_ANGLE_BITS - 1);
	const uint SignMaskX = 0x80000000u >> SignShiftX;
	const uint SignMaskY = 0x80000000u >> SignShiftY;
	const float Scale = float(Mask);

	float3x3 Basis = GetTangentBasis(Normal);
	float Y = float(Bits & Mask) / Scale;
	float2 P = float2(1.0f - Y, Y);
	// restore sign bits
	P.x = asfloat(asuint(P.x) | ((Bits & SignMaskX) << SignShiftX));
	P.y = asfloat(asuint(P.y) | ((Bits & SignMaskY) << SignShiftY));
	P = normalize(P);
	return Basis[0] * P.x + Basis[1] * P.y;
}

uint PayloadEncodeHDRColor(float3 rgb)
{
	return PackRGB998E6(rgb);
}

float3 PayloadDecodeHDRColor(uint rgb)
{
	return UnpackRGB998E6(rgb);
}

uint PayloadEncodeLDRColor(float3 rgb)
{
	return PackRGB111110(rgb);
}

float3 PayloadDecodeLDRColor(uint rgb)
{
	return UnpackRGB111110(rgb);
}

uint PayloadEncodeRoughnessAniso(float3 RoughnessData, float Anisotropy)
{
	uint r = uint(floor(saturate(RoughnessData.x) * 255.0 + 0.5));
	uint g = uint(floor(saturate(RoughnessData.y) * 255.0 + 0.5));
	uint b = uint(floor(saturate(RoughnessData.z) * 255.0 + 0.5));
	uint a = uint(floor(clamp(Anisotropy, -1.0, 1.0) * 127.0 + 127.0)); // Range is [-1,1] so use an SNorm encoding here so we can represent 0.0 exactly
	return (r << 24) | (g << 16) | (b << 8) | a;
}

float4 PayloadDecodeRoughnessAniso(uint rgba)
{
	float r = float((rgba >> 24)      ) * (1.0 / 255.0);
	float g = float((rgba >> 16) & 255) * (1.0 / 255.0);
	float b = float((rgba >>  8) & 255) * (1.0 / 255.0);
	float a = float((rgba      ) & 255) * (1.0 / 127.0) - 1.0;
	return float4(r, g, b, a);
}

uint PayloadEncodeFuzzAndBottomNormal(float FuzzAmount, float FuzzRoughness, uint BottomNormalOct16bits)
{
	uint r = uint(floor(saturate(FuzzAmount) * 255.0 + 0.5));
	uint g = uint(floor(saturate(FuzzRoughness) * 255.0 + 0.5));
	return (r << 24) | (g << 16) | (BottomNormalOct16bits & 0xFFFF);
}

void PayloadDecodeFuzzAndBottomNormal(uint rgba, inout float FuzzAmount, inout float FuzzRoughness, inout uint BottomNormalOct16bits)
{
	FuzzAmount = float((rgba >> 24)) * (1.0 / 255.0);
	FuzzRoughness = float((rgba >> 16) & 255) * (1.0 / 255.0);
	BottomNormalOct16bits = rgba & 0xFFFF;
}

float3 AdjustShadingNormal(float3 ShadingNormal, float3 GeoNormal, float3 RayDirection)
{
	// Clip shading normal in a view dependent way such that the reflection stays above the geometric normal
	// This introduces a bit of view-dependency to the shading normal but fixes dark artifacts around grazing angles

	float3 D = RayDirection;
	float3 R = reflect(D, ShadingNormal);

	// https://iquilezles.org/www/articles/dontflip/dontflip.htm
	float k = dot(R, GeoNormal);
	if (k < 0.0)
	{
		return normalize(normalize(R - k * GeoNormal) - D);
	}
	return ShadingNormal;
}


#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_PATH_TRACING_MATERIAL) && IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
#error "Path tracing and GPULightmass payloads are mutually exclusive. They should not be both enabled at once."
#endif

#if SUBSTRATE_ENABLED && !IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
#define PATHTRACING_SUBSTRATE_PAYLOAD 1
#else
#define PATHTRACING_SUBSTRATE_PAYLOAD 0
#endif

// This payload structure is what we transport between RGS/CHS/AHS programs
struct FPackedPathTracingPayload : FMinimalPayload
{
	// float FMinimalPayload::HitT                       // 4  bytes
#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	uint PackedData[7];                                  // 28 bytes (encoded data, depends on shading model and ray type)
	// 32 bytes total
#elif PATHTRACING_SUBSTRATE_PAYLOAD
	// Need a bit more space for Substrate slab data
	uint PackedData[18];                                 // 72 bytes
	// 76 bytes total
#else
	uint PackedData[15];								 // 60 bytes (encoded data, depends on shading model and ray type)
	// 64 bytes total
#endif

	float UnpackBSDFOpacity() { return f16tof32(PackedData[0]); }
	uint GetShadingModelID() { return (PackedData[0] >> 16) & 0xF; }
	uint GetFlags() { return (PackedData[0] >> 20) & 0x1FF; }
	void SetFlag(uint Flag) { PackedData[0] |= Flag << 20; }
	void RemoveFlag(uint Flag) { PackedData[0] &= ~(Flag << 20); }
	uint GetPrimitiveLightingChannelMask() { return (PackedData[0] >> 29) & 0x7; }

	// Flag methods
	void SetCameraRay() { SetFlag(PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_CAMERA); }
	bool IsCameraRay() { return (GetFlags() & PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_MASK) == PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_CAMERA; }

	void SetVisibilityRay() { SetFlag(PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_SHADOW); }
	bool IsVisibilityRay() { return (GetFlags() & PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_MASK) == PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_SHADOW; }

	bool IsFrontFace() { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_FRONT_FACE) != 0; }
	
	bool IsDecalReceiver() 
	{
		const uint Mask = 
			PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_COLOR |
			PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_NORMAL | 
			PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_ROUGHNESS | 
			PATH_TRACING_PAYLOAD_OUTPUT_FLAG_USE_DBUFFER_LOOKUP;
		return (GetFlags() & Mask) != 0;
	}
	bool HasDecalResponseColor()     { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_COLOR    ) != 0; }
	bool HasDecalResponseNormal()    { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_NORMAL   ) != 0; }
	bool HasDecalResponseRoughness() { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_ROUGHNESS) != 0; }
	bool UsesDBufferLookup()         { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_USE_DBUFFER_LOOKUP      ) != 0; }

	void SetOutputDepth() { SetFlag(PATH_TRACING_PAYLOAD_OUTPUT_FLAG_OUTOUT_DEPTH); }
	bool ShouldOutputDepth() { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_OUTOUT_DEPTH) != 0; }

	bool IsHoldout() { return (GetFlags() & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_IS_HOLDOUT) != 0; }

	// These method are meant to be used only when IsVisibilityRay() is true
	float3 GetRayThroughput()
	{
		return float3(
			asfloat(PackedData[1]),
			asfloat(PackedData[2]),
			asfloat(PackedData[3])
		);
	}

	void SetRayThroughput(float3 RayThroughput)
	{
		PackedData[1] = asuint(RayThroughput.x);
		PackedData[2] = asuint(RayThroughput.y);
		PackedData[3] = asuint(RayThroughput.z);
	}

	float GetPathRoughness()
	{
		return asfloat(PackedData[4]);
	}

	void SetPathRoughness(float PathRoughness)
	{
		PackedData[4] = asuint(PathRoughness);
	}

#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	float3 UnpackWorldGeoNormal()    { return PayloadDecodeUnitVector(PackedData[1]); }
	float3 UnpackWorldNormal()       { return PayloadDecodeUnitVector(PackedData[2]); }
	float3 UnpackRadiance()          { return PayloadDecodeHDRColor(PackedData[3]); }
	float3 UnpackBaseColor()         { return PayloadDecodeLDRColor(PackedData[4]); }
	float3 UnpackTransparencyColor() { return PayloadDecodeLDRColor(PackedData[5]); }
	float3 UnpackSubsurfaceColor()   { return PayloadDecodeLDRColor(PackedData[6]); }


#else

	float3 UnpackWorldGeoNormal() 	 { return PayloadDecodeUnitVector(PackedData[1]); }
	float3 UnpackWorldSmoothNormal() { return PayloadDecodeUnitVector(PackedData[2]); }
	float3 UnpackWorldNormal()       { return PayloadDecodeUnitVector(PackedData[3]); }
	float3 UnpackRadiance()          { return PayloadDecodeHDRColor(PackedData[4]); }

	void PackWorldNormal(float3 N)   { PackedData[3] = PayloadEncodeUnitVector(N); }
	void PackRadiance(float3 R)      { PackedData[4] = PayloadEncodeHDRColor(R); }

	float3 UnpackWorldTangent()       { return PayloadDecodeTangentAngle(UnpackWorldNormal(), PackedData[5]); }
	float UnpackIor()                 { return f16tof32(PackedData[5] >> 16); }
	
#if PATHTRACING_SUBSTRATE_PAYLOAD

	float3 UnpackDiffuseColor()       { return PayloadDecodeLDRColor(PackedData[6]); }
	float3 UnpackSpecularColor()      { return PayloadDecodeLDRColor(PackedData[7]); }
	float3 UnpackSpecularEdgeColor()  { return PayloadDecodeLDRColor(PackedData[8]); }
	float4 UnpackRoughnessAniso()     { return PayloadDecodeRoughnessAniso(PackedData[9]); }
	float3 UnpackTransparencyColor()  { return PayloadDecodeLDRColor(PackedData[10]); }
	float3 UnpackMeanFreePath()       { return float3(f16tof32(PackedData[11]),
	                                                  f16tof32(PackedData[11] >> 16),
	                                                  f16tof32(PackedData[12])); }
	float UnpackPhaseG()              { return f16tof32(PackedData[12] >> 16); }
	float3 UnpackFuzzColor()          { return PayloadDecodeLDRColor(PackedData[13]); }
	float3 UnpackWeightV()            { return PayloadDecodeLDRColor(PackedData[15]); }
	float3 UnpackTransmittanceN()     { return PayloadDecodeLDRColor(PackedData[16]); }

	float UnpackCoverageAboveAlongN() { return abs(f16tof32(PackedData[17] >> 16)); }
	float UnpackSpecularProfileId()   { return f16tof32(PackedData[17]); }

	void PackDiffuseColor(float3 C)   { PackedData[6] = PayloadEncodeLDRColor(C); }
	void PackSpecularColor(float3 C)  { PackedData[7] = PayloadEncodeLDRColor(C); }
	void PackRoughnessAniso(float4 D) { PackedData[9] = PayloadEncodeRoughnessAniso(D.xyz, D.w); }

#else
	float3 UnpackBaseColor()         { return PayloadDecodeLDRColor(PackedData[6]); }
	float3 UnpackTransparencyColor() { return PayloadDecodeLDRColor(PackedData[7]); }
	float UnpackMetallic()           { return f16tof32(PackedData[8]); }
	float UnpackSpecular()           { return f16tof32(PackedData[8] >> 16); }
	float UnpackRoughness()          { return f16tof32(PackedData[9]); }
	float UnpackAnisotropy()         { return f16tof32(PackedData[9] >> 16); }
	float4 UnpackCustomData0()       { return float4(UnpackFloat2FromUInt(PackedData[10]),
													 UnpackFloat2FromUInt(PackedData[11])); }
	float4 UnpackCustomData1()       { return float4(UnpackFloat2FromUInt(PackedData[12]),
													 UnpackFloat2FromUInt(PackedData[13])); }

	void PackBaseColor(float3 C) { PackedData[6] = PayloadEncodeLDRColor(C); }
	void PackMetallicSpecular(float M, float S) { PackedData[8] = PackFloat2ToUInt(float2(M, S)); }
	void PackRoughnessAniso(float R, float A)   { PackedData[9] = PackFloat2ToUInt(float2(R, A)); }

#endif
	
	// tau: optical depth along shadow ray, this is the integral of the extinction coefficient
	float3 GetTau()
	{
		return float3(
			asfloat(PackedData[5]),
			asfloat(PackedData[6]),
			asfloat(PackedData[7])
		);
	}

	void SetTau(float3 Tau)
	{
		PackedData[5] = asuint(Tau.x);
		PackedData[6] = asuint(Tau.y);
		PackedData[7] = asuint(Tau.z);
	}

	float4 GetDBufferA()
	{
		return float4(
			UnpackFloat2FromUInt(PackedData[8]),
			UnpackFloat2FromUInt(PackedData[9])
		);
	}

	void SetDBufferA(float4 DBufferA)
	{
		PackedData[8] = PackFloat2ToUInt(DBufferA.xy);
		PackedData[9] = PackFloat2ToUInt(DBufferA.zw);
	}

	float4 GetDBufferB()
	{
		return float4(
			UnpackFloat2FromUInt(PackedData[10]),
			UnpackFloat2FromUInt(PackedData[11])
		);
	}

	void SetDBufferB(float4 DBufferB)
	{
		PackedData[10] = PackFloat2ToUInt(DBufferB.xy);
		PackedData[11] = PackFloat2ToUInt(DBufferB.zw);
	}

	float4 GetDBufferC()
	{
		return float4(
			UnpackFloat2FromUInt(PackedData[12]),
			UnpackFloat2FromUInt(PackedData[13])
		);
	}

	void SetDBufferC(float4 DBufferC)
	{
		PackedData[12] = PackFloat2ToUInt(DBufferC.xy);
		PackedData[13] = PackFloat2ToUInt(DBufferC.zw);
	}
	
	void SetStochasticSlabRand(float SlabRand)
	{
		PackedData[14] = asuint(SlabRand);
	}
	
	float GetStochasticSlabRand()
	{
		return asfloat(PackedData[14]);
	}

	float GetSceneDepth()
	{
		// NOTE: This is aliased with GetDBufferA, but this is ok as the two features may not be used together
		return asfloat(PackedData[8]);
	}

	void SetSceneDepth(float SceneZ)
	{
		PackedData[8] = asuint(SceneZ);
	}

#if PATH_TRACER_USE_CLOUD_SHADER
	// Volumetric callable shaders
	void SetVolumetricCallableShaderInput(float3 Origin, float3 Direction, float TMin, float TMax, RandomSequence RandSeq, uint Flags, float3 Throughput, float CloudDensity)
	{
		HitT = TMin;
		PackedData[0]  = asuint(TMax);
		PackedData[1]  = asuint(Origin.x);
		PackedData[2]  = asuint(Origin.y);
		PackedData[3]  = asuint(Origin.z);
		PackedData[4]  = asuint(Direction.x);
		PackedData[5]  = asuint(Direction.y);
		PackedData[6]  = asuint(Direction.z);
		PackedData[7]  = RandSeq.SampleIndex;
		PackedData[8]  = RandSeq.SampleSeed;
		PackedData[9]  = (Flags & 0xFFFF) | (f32tof16(CloudDensity) << 16);
		PackedData[10] = asuint(Throughput.x);
		PackedData[11] = asuint(Throughput.y);
		PackedData[12] = asuint(Throughput.z);
	}
	
	void SetVolumetricCallableShaderInputCloudFactor(float CloudFactor)
	{
		PackedData[13] = asuint(CloudFactor);
	}

	void SetVolumetricCallableShaderRISContext(FRISContext SurfaceContext)
	{
		PackedData[13] = asuint(SurfaceContext.WeightSum);
		PackedData[14] = asuint(SurfaceContext.RandSample);
	}

	FRayDesc GetVolumetricCallableShaderInputRay()
	{
		FRayDesc Ray;
		Ray.Origin    = asfloat(uint3(PackedData[1], PackedData[2], PackedData[3]));
		Ray.Direction = asfloat(uint3(PackedData[4], PackedData[5], PackedData[6]));
		Ray.TMin      = HitT;
		Ray.TMax      = asfloat(PackedData[0]);
		return Ray;
	}

	RandomSequence GetVolumetricCallableShaderInputRandSequence()
	{
		RandomSequence RandSeq;
		RandSeq.SampleIndex = PackedData[7];
		RandSeq.SampleSeed  = PackedData[8];
		return RandSeq;
	}

	uint GetVolumetricCallableShaderInputFlags()
	{
		return PackedData[9] & 0xFFFF;
	}

	float3 GetVolumetricCallableShaderInputThroughput()
	{
		return asfloat(uint3(PackedData[10], PackedData[11], PackedData[12]));
	}

	float GetVolumetricCallableShaderInputCloudFactor()
	{
		return asfloat(PackedData[13]);
	}

	float GetVolumetricCallableShaderInputCloudDensity()
	{
		return f16tof32(PackedData[9] >> 16);
	}

	FRISContext GetVolumetricCallableShaderRISContext()
	{
		FRISContext Context;
		Context.WeightSum  = asfloat(PackedData[13]);
		Context.RandSample = asfloat(PackedData[14]);
		return Context;
	}

	void SetVolumetricCallableShaderOutput(RandomSequence RandSeq, float3 Throughput, float3 Albedo)
	{
		PackedData[0] = RandSeq.SampleIndex;
		PackedData[1] = RandSeq.SampleSeed;
		// sampling mode: need to pack transmittance and albedo together
		PackedData[2] = PackFloat2ToUInt(Throughput.xy);
		PackedData[3] = PackFloat2ToUInt(float2(Throughput.z, Albedo.x));
		PackedData[4] = PackFloat2ToUInt(Albedo.yz);
	}

	void SetVolumetricCallableShaderOutput(RandomSequence RandSeq, float3 Throughput)
	{
		// Increased precision for Transmittance mode
		PackedData[0] = RandSeq.SampleIndex;
		PackedData[1] = RandSeq.SampleSeed;
		PackedData[2] = asuint(Throughput.x);
		PackedData[3] = asuint(Throughput.y);
		PackedData[4] = asuint(Throughput.z);
	}

	void SetVolumetricCallableShaderOutputSample(float SampleT, float3 AlbedoRayleigh, float3 AlbedoHG1, float PhaseG, float3 AlbedoHG2, float3 DualPhaseData, float3 PayloadThroughput)
	{
		HitT = SampleT;
		PackedData[5]  = PackFloat2ToUInt(PayloadThroughput.xy);
		PackedData[6]  = PackFloat2ToUInt(float2(PayloadThroughput.z, PhaseG));
		PackedData[7]  = PayloadEncodeLDRColor(AlbedoRayleigh);
		PackedData[8]  = PayloadEncodeLDRColor(AlbedoHG1);
		PackedData[9]  = PayloadEncodeLDRColor(AlbedoHG2);
		PackedData[10] = PayloadEncodeLDRColor(DualPhaseData * float3(0.5, 0.5, 1.0) + float3(0.5, 0.5, 0.0));
	}

	void SetVolumetricCallableShaderOutputCloudDensityFactor(float Factor)
	{
		PackedData[12] &= 0xFFFFu; // clear upper bits
		PackedData[12] |= f32tof16(Factor) << 16;
	}

	void SetVolumetricCallableShaderOutputRadiance(float3 Radiance, float Alpha)
	{
		PackedData[11] = PayloadEncodeHDRColor(Radiance);
		PackedData[12] &= 0xFFFF0000u; // clear lower bits
		PackedData[12] |= f32tof16(Alpha);
	}

	RandomSequence GetVolumetricCallableShaderOutputRandSeq()
	{
		RandomSequence RandSeq;
		RandSeq.SampleIndex = PackedData[0];
		RandSeq.SampleSeed  = PackedData[1];
		return RandSeq;
	}

	float3 GetVolumetricCallableShaderOutputThroughput()
	{
		return float3(UnpackFloat2FromUInt(PackedData[2]), UnpackFloat2FromUInt(PackedData[3]).x);
	}

	float3 GetVolumetricCallableShaderOutputAlbedo()
	{
		return float3(UnpackFloat2FromUInt(PackedData[3]).y, UnpackFloat2FromUInt(PackedData[4]));
	}

	float3 GetVolumetricCallableShaderOutputTransmittanceThroughput()
	{
		// Increased precision for Transmittance mode
		return asfloat(uint3(PackedData[2], PackedData[3], PackedData[4]));
	}

	float3 GetVolumetricCallableShaderOutputPayloadThroughput()
	{
		return float3(UnpackFloat2FromUInt(PackedData[5]), UnpackFloat2FromUInt(PackedData[6]).x);
	}

	float3 GetVolumetricCallableShaderOutputRayleighWeight()
	{
		return PayloadDecodeLDRColor(PackedData[7]);
	}

	float4 GetVolumetricCallableShaderOutputHG()
	{
		return float4(PayloadDecodeLDRColor(PackedData[8]), UnpackFloat2FromUInt(PackedData[6]).y);
	}

	float3 GetVolumetricCallableShaderOutputDualHGWeight()
	{
		return PayloadDecodeLDRColor(PackedData[9]);
	}

	float3 GetVolumetricCallableShaderOutputDualHGPhaseData()
	{
		return PayloadDecodeLDRColor(PackedData[10]) * float3(2, 2, 1) - float3(1, 1, 0);
	}

	float3 GetVolumetricCallableShaderOutputRadiance()
	{
		return PayloadDecodeHDRColor(PackedData[11]);
	}

	float GetVolumetricCallableShaderOutputAlpha()
	{
		return f16tof32(PackedData[12]);
	}

	float GetVolumetricCallableShaderOutputCloudDensityFactor()
	{
		return f16tof32(PackedData[12] >> 16);
	}

#endif // PATH_TRACER_USE_CLOUD_SHADER

#endif // IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
};

#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_PATH_TRACING_MATERIAL)
CHECK_RT_PAYLOAD_SIZE(FPackedPathTracingPayload)
#endif
#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
CHECK_RT_PAYLOAD_SIZE(FPackedPathTracingPayload)
#endif

// This payload structure is the expanded version of the above which is more convenient to work with
struct FPathTracingPayload : FMinimalPayload
{
	float3 Radiance;
	float3 WorldGeoNormal;           // normal of the actual triangle (faceted)
	float3 WorldNormal;              // normal output of the material (includes normal/bump)
#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	// skip smooth normal for GPULightmass
#else
	float3 WorldSmoothNormal;        // smooth normal before normal/bump is applied
#endif

	float  BSDFOpacity;              // how much should we weigh down the bsdf by? (for glass, controls the blend between solid and glass lobes)
	float3 TransparencyColor;        // how much do we see straight through the surface?
	uint   ShadingModelID;
	uint   Flags;
	uint   PrimitiveLightingChannelMask;

#if PATHTRACING_SUBSTRATE_PAYLOAD
	float3 DiffuseColor;
	float3 SpecularColor;
	float3 SpecularEdgeColor;
	float3 RoughnessData; // r0,r1,rblend
	uint BottomNormalOct16bits;
	float  Anisotropy;
	float3 WorldTangent;
	float3 MeanFreePath;
	float PhaseG;
	float Ior;
	float FuzzAmount;
	float FuzzRoughness;
	float3 FuzzColor;
	float3 WeightV;
	float3 TransmittanceN;
	float CoverageAboveAlongN;
	float SpecularProfileId;
	float GlintValue;
	float2 GlintUV;
	float2 GlintUVdx;
	float2 GlintUVdy;

	// not transported through packed payload, but used in raygen
	float3 SubsurfaceColor;

#else // PATHTRACING_SUBSTRATE_PAYLOAD
	
	float3 BaseColor;
#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	float3 SubsurfaceColor;
#else
	float3 DiffuseColor;
	float3 SpecularColor;
	float  Metallic;
	float  Specular;
	float  Roughness;
	float  Anisotropy;
	float  Ior;
	float4 CustomData0;
	float4 CustomData1;
	float3 WorldTangent;
	float3 SubsurfaceColor;
	float3 SubsurfaceRadius;
#endif // IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
#endif // PATHTRACING_SUBSTRATE_PAYLOAD
	float3 TranslatedWorldPos;

	void SetFrontFace() { Flags |= PATH_TRACING_PAYLOAD_OUTPUT_FLAG_FRONT_FACE; }
	bool IsFrontFace() { return (Flags & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_FRONT_FACE) != 0; }

	void SetDecalReceiver(uint DecalResponseMask) { Flags |= (DecalResponseMask & 0x07) << PATH_TRACING_PAYLOAD_OUTPUT_FLAG_DECAL_RESPONSE_MASK_SHIFT; }

	void SetUseDBufferLookup() { Flags |= PATH_TRACING_PAYLOAD_OUTPUT_FLAG_USE_DBUFFER_LOOKUP; }
	bool UsesDBufferLookup() { return (Flags & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_USE_DBUFFER_LOOKUP) != 0; }
	
	void SetHoldout() { Flags |= PATH_TRACING_PAYLOAD_OUTPUT_FLAG_IS_HOLDOUT; }
	bool IsHoldout() { return (Flags & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_IS_HOLDOUT) != 0; }

	void SetMaterialTwoSided() { Flags |= PATH_TRACING_PAYLOAD_OUTPUT_FLAG_TWO_SIDED_MATERIAL; }
	bool IsMaterialTwoSided() { return (Flags & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_TWO_SIDED_MATERIAL) != 0; }

	void SetOutputDepth() { Flags |= PATH_TRACING_PAYLOAD_OUTPUT_FLAG_OUTOUT_DEPTH; }
	bool ShouldOutputDepth() { return Flags & PATH_TRACING_PAYLOAD_OUTPUT_FLAG_OUTOUT_DEPTH; }

#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	float3 GetBaseColor() { return BaseColor; }
	float3 GetSubsurfaceColor() { return SubsurfaceColor; }
	bool IsMaterialTransmissive()
	{
		return ShadingModelID == SHADINGMODELID_TWOSIDED_FOLIAGE;
	}
#else // IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)

#if PATHTRACING_SUBSTRATE_PAYLOAD
	// SHADINGMODELID_SUBSTRATE
	float3 GetMaxLobeWeight()
	{
		return WeightV * lerp(1.0f, TransmittanceN, CoverageAboveAlongN); // largest value LobeWeight() could return
	}


	// SHADINGMODELID_NUM (Lambert diffuse) and SHADINGMODELID_MEDIUM
	float3 GetBaseColor() { return DiffuseColor; }
	void SetBaseColor(float3 BaseColor) { DiffuseColor = BaseColor; }

	// SHADINGMODELID_MEDIUM
	float3 GetHGWeight() { return SpecularColor; }
	float GetHGPhaseG() { return PhaseG; }
	void SetHG(float3 Weight, float G)
	{
		SpecularColor = Weight;
		PhaseG = G;
	}
	float3 GetDualHGWeight() { return SpecularEdgeColor; }
	float3 GetDualHGPhaseData() { return RoughnessData; }
	void SetDualHG(float3 Weight, float3 PhaseData)
	{
		SpecularEdgeColor = Weight;
		RoughnessData = PhaseData;
	}
	float GetCloudFactor() { return Anisotropy; }
	void SetCloudFactor(float Factor) { Anisotropy = Factor; }

	// SHADINGMODELID_EYE
	float GetEyeRoughness() { return RoughnessData.x; }
	void SetEyeRoughness(float R) { RoughnessData.x = R; }
	float3 GetEyeCausticNormal() { return normalize(2.0 * FuzzColor - 1.0); } // SUBSTRATE_TODO: not optimal since packed as color
	void SetEyeCausticNormal(float3 CausticNormal) { FuzzColor = 0.5 * CausticNormal + 0.5; }
	float GetEyeIrisMask() { return Anisotropy; }
	void SetEyeIrisMask(float IrisMask) { Anisotropy = IrisMask; }
	float3 GetEyeIrisNormal() { return normalize(2.0 * SpecularEdgeColor - 1.0); }  // SUBSTRATE_TODO: not optimal since packed as color
	void SetEyeIrisNormal(float3 IrisNormal) { SpecularEdgeColor = IrisNormal * 0.5 + 0.5; }

	// SHADINGMODELID_HAIR
	float GetHairLongitudinalRoughness() { return RoughnessData.x; }
	void SetHairLongitudinalRoughness(float Roughness) { RoughnessData.x = Roughness;}
	float GetHairAzimuthalRoughness() { return RoughnessData.y; }
	void SetHairAzimuthalRoughness(float AzimuthalRoughness) { RoughnessData.y = AzimuthalRoughness; }
	float GetHairSpecular() { return RoughnessData.z; }
	void SetHairSpecular(float Specular) { RoughnessData.z = Specular; }
	float2 GetHairPrimitiveUV() { return SpecularEdgeColor.xy; }
	void SetHairPrimitiveUV(float2 UV) { SpecularEdgeColor.xy = UV; }

	float3 GetExtinction() { return rcp(max(MeanFreePath, 1e-5)); }

	// SHADINGMODELID_THIN_TRANSLUCENT
	float3 GetTransmittanceColor() { return exp(-GetExtinction() * SUBSTRATE_SIMPLEVOLUME_THICKNESS_CM); }

	// SHADINGMODELID_TWOSIDED_FOLIAGE
	float3 GetFoliageTransmissionColor() { return MeanFreePath; }
	void SetFoliageTransmissionColor(float3 C) { MeanFreePath = C; }


#else // PATHTRACING_SUBSTRATE_PAYLOAD
	// Various ways to interpret CustomData (depending on ShadingModelID)
	// NOTE: This is not always following the same conventions as GetMaterialCustomData0,1()

	// SHADINGMODELID_CLOTH
	float3 GetClothColor() { return CustomData0.xyz; }
	void SetClothColor(float3 ClothColor) { CustomData0.xyz = ClothColor; }
	float GetClothAmount() { return CustomData0.w; }
	void SetClothAmount(float ClothAmount) { CustomData0.w = ClothAmount; }

	// SHADINGMODELID_CLEAR_COAT
	float GetClearCoat() { return CustomData0.x; }
	float GetClearCoatRoughness() { return CustomData0.y; }
	void SetClearCoat(float ClearCoat) { CustomData0.x = ClearCoat; }
	void SetClearCoatRoughness(float ClearCoatRoughness) { CustomData0.y = ClearCoatRoughness; }
	float3 GetClearCoatBottomNormal() { return CustomData1.xyz; }
	void SetClearCoatBottomNormal(float3 BottomNormal) { CustomData1.xyz = BottomNormal; }

	// SHADINGMODELID_SUBSURFACE, SHADINGMODELID_SUBSURFACE_PROFILE and SHADINGMODELID_EYE
	float3 GetSubsurfaceRadius() { return CustomData0.rgb; }
	void SetSubsurfaceRadius(float3 Radius) { CustomData0.rgb = Radius; }
	float GetSubsurfacePhaseFunction() { return CustomData0.a; }
	void SetSubsurfacePhaseFunction(float G) { CustomData0.a = G; }

	// SHADINGMODELID_SUBSURFACE, SHADINGMODELID_TWOSIDED_FOLIAGE (note that SHADINGMODELID_SUBSURFACE_PROFILE and SHADINGMODELID_EYE don't use this as they use DiffuseColor directly)
	float3 GetSubsurfaceColor() { return CustomData1.xyz; }
	void SetSubsurfaceColor(float3 SubsurfaceColor) { CustomData1.xyz = SubsurfaceColor; }
	
	// SHADINGMODELID_SUBSURFACE_PROFILE
	float3 GetDualRoughnessSpecular() { return CustomData1.xyz; }
	void SetDualRoughnessSpecular(float Roughness0, float Roughness1, float LobeMix) { CustomData1.xyz = float3(Roughness0, Roughness1, LobeMix); }


	// SHADINGMODELID_EYE
	float GetEyeRoughness() { return Roughness; }
	void SetEyeRoughness(float R) { Roughness = R; }
	float3 GetEyeCausticNormal() { return OctahedronToUnitVector(CustomData1.xy); }
	void SetEyeCausticNormal(float3 CausticNormal) { CustomData1.xy = UnitVectorToOctahedron(CausticNormal); }
	float GetEyeIrisMask() { return Anisotropy; }
	void SetEyeIrisMask(float IrisMask) { Anisotropy = IrisMask; }
	float3 GetEyeIrisNormal() { return OctahedronToUnitVector(CustomData1.zw); }
	void SetEyeIrisNormal(float3 IrisNormal) { CustomData1.zw = UnitVectorToOctahedron(IrisNormal); }

	// SHADINGMODELID_HAIR
	float GetHairLongitudinalRoughness() { return Roughness; }
	void SetHairLongitudinalRoughness(float R) { Roughness = R; }
	float GetHairAzimuthalRoughness() { return Metallic; }
	void SetHairAzimuthalRoughness(float AzimuthalRoughness) { Metallic = AzimuthalRoughness; }
	float GetHairSpecular() { return Specular; }
	void SetHairSpecular(float S) { Specular = S; }
	float2 GetHairPrimitiveUV() { return CustomData0.xy; }
	void SetHairPrimitiveUV(float2 UV) { CustomData0.xy = UV; }

	// SHADINGMODELID_THIN_TRANSLUCENT
	float3 GetTransmittanceColor() { return CustomData0.xyz; }
	void SetTransmittanceColor(float3 TransmittanceColor) { CustomData0.xyz = TransmittanceColor; }

	// SHADINGMODELID_DEFAULT_LIT
	float3 GetExtinction() { return CustomData0.xyz; }
	void SetExtinction(float3 SigmaT) { CustomData0.xyz = SigmaT; }

	// SHADINGMODELID_NUM (Lambert diffuse) and SHADINGMODELID_MEDIUM
	float3 GetBaseColor() { return BaseColor; }
	void SetBaseColor(float3 C)
	{
		BaseColor = C;
	}

	// SHADINGMODELID_MEDIUM
	float3 GetHGWeight() { return CustomData0.xyz; }
	float GetHGPhaseG() { return CustomData0.w; }
	void SetHG(float3 Weight, float G) { CustomData0 = float4(Weight, G); }
	float3 GetDualHGWeight() { return CustomData1.xyz; }
	float3 GetDualHGPhaseData() { return float3(Metallic, Specular, Roughness); }
	void SetDualHG(float3 Weight, float3 PhaseData)
	{
		CustomData1.xyz = Weight;
		Metallic = PhaseData.x;
		Specular = PhaseData.y;
		Roughness = PhaseData.z;
	}
	float GetCloudFactor() { return CustomData1.w; }
	void SetCloudFactor(float Factor) { CustomData1.w = Factor; }
#endif // PATHTRACING_SUBSTRATE_PAYLOAD

	// Methods used by the integrator

	bool HasRefraction()
	{
		return Ior > 0.0;
	}

	bool IsMaterialSolidGlass()
	{
		return ShadingModelID == SHADINGMODELID_SOLID_GLASS;
	}

	bool IsMaterialThinGlass()
	{
		return ShadingModelID == SHADINGMODELID_THIN_TRANSLUCENT && HasRefraction();
	}

	bool IsMaterialTransmissive()
	{
		return ShadingModelID == SHADINGMODELID_TWOSIDED_FOLIAGE ||
			   ShadingModelID == SHADINGMODELID_HAIR ||
			   ShadingModelID == SHADINGMODELID_MEDIUM ||
			   ShadingModelID == SHADINGMODELID_UNLIT || // Volumetric Directional/Non-Directional
			   IsMaterialSolidGlass() ||
			   IsMaterialThinGlass();
	}

	bool IsSubsurfaceMaterial()
	{
#if PATHTRACING_SUBSTRATE_PAYLOAD
		return ShadingModelID == SHADINGMODELID_SUBSTRATE ||
		       ShadingModelID == SHADINGMODELID_EYE;
#else
		return ShadingModelID == SHADINGMODELID_SUBSURFACE ||
			   ShadingModelID == SHADINGMODELID_PREINTEGRATED_SKIN ||
			   ShadingModelID == SHADINGMODELID_SUBSURFACE_PROFILE ||
			   ShadingModelID == SHADINGMODELID_EYE;
#endif

	}
#endif // IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
};

FPackedPathTracingPayload InitPathTracingPayload(uint ScatterType, float PathRoughness)
{
	FPackedPathTracingPayload Output = (FPackedPathTracingPayload)0;
	Output.SetPathRoughness(PathRoughness);
	Output.SetMiss();
	switch (ScatterType)
	{
		case PATHTRACER_SCATTER_DIFFUSE:   Output.SetFlag(PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_INDIRECT_DIFFUSE);  break;
		case PATHTRACER_SCATTER_SPECULAR:  
		case PATHTRACER_SCATTER_REFRACT:   Output.SetFlag(PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_INDIRECT_SPECULAR); break;
		case PATHTRACER_SCATTER_VOLUME:    Output.SetFlag(PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_INDIRECT_VOLUME);   break;
		case PATHTRACER_SCATTER_CAMERA: 
		default:                           Output.SetFlag(PATH_TRACING_PAYLOAD_INPUT_FLAG_RAY_TYPE_CAMERA); break;
	}
	return Output;
}

FPackedPathTracingPayload InitPathTracingVisibilityPayload(float PathRoughness)
{
	FPackedPathTracingPayload Output = (FPackedPathTracingPayload)0;
	// Signal to the AHS we want to evaluate the opacity
	// The payload is used to carry the path throughput (for transparent shadows)
	// and current path roughness (for approximate caustics)
	Output.SetVisibilityRay();
	Output.SetPathRoughness(PathRoughness);
	Output.SetRayThroughput(1.0);
	// NOTE: We start with HitT = 0 which counts as "IsHit()". This will be changed by the miss shader if we don't register any hits (or the AHS writes don't accumulate all the way to 0)
	// This is because we want to be able to skip the CHS on shadow rays. Therefore the miss shader is the one that will be responsible for telling us a ray did not hit anything opaque.
	// If after tracing the ray we still have IsHit() returning true, this means we must have hit something opaque (without having run either CHS or AHS).
	// This also has the benefit of preparing the "mailbox" used for detecting duplicate invocations of AHS with an invalid value.
	Output.HitT = 0.0;
	return Output;
}

FPackedPathTracingPayload PackPathTracingPayload(FPathTracingPayload Input)
{
	FPackedPathTracingPayload Output = (FPackedPathTracingPayload)0;
	Output.HitT = Input.HitT;

	Output.PackedData[0] = f32tof16(Input.BSDFOpacity);
	Output.PackedData[0] |= (Input.ShadingModelID & 0xF) << 16;               // 4 bits
	Output.PackedData[0] |= (Input.Flags & 0x1FF) << 20;                      // 9 bits
	Output.PackedData[0] |= (Input.PrimitiveLightingChannelMask & 0x7) << 29; // 3 bits
	                                                                   // total 32 bits
#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	Output.PackedData[1] = PayloadEncodeUnitVector(Input.WorldGeoNormal);
	Output.PackedData[2] = PayloadEncodeUnitVector(Input.WorldNormal);
	Output.PackedData[3] = PayloadEncodeHDRColor(Input.Radiance);
	Output.PackedData[4] = PayloadEncodeLDRColor(Input.BaseColor);
	Output.PackedData[5] = PayloadEncodeLDRColor(Input.TransparencyColor);
	Output.PackedData[6] = PayloadEncodeLDRColor(Input.SubsurfaceColor);
#else
	Output.PackedData[1] = PayloadEncodeUnitVector(Input.WorldGeoNormal);
	Output.PackedData[2] = PayloadEncodeUnitVector(Input.WorldSmoothNormal);
	Output.PackedData[3] = PayloadEncodeUnitVector(Input.WorldNormal);
	Output.PackedData[4] = PayloadEncodeHDRColor(Input.Radiance);
	Output.PackedData[5] = PayloadEncodeTangentAngle(Output.UnpackWorldNormal(), Input.WorldTangent);
	Output.PackedData[5]|= f32tof16(Input.Ior) << 16;
#if PATHTRACING_SUBSTRATE_PAYLOAD
	Output.PackedData[6] = PayloadEncodeLDRColor(Input.DiffuseColor);
	Output.PackedData[7] = PayloadEncodeLDRColor(Input.SpecularColor);
	Output.PackedData[8] = PayloadEncodeLDRColor(Input.SpecularEdgeColor);
	Output.PackedData[9] = PayloadEncodeRoughnessAniso(Input.RoughnessData, Input.Anisotropy);
	Output.PackedData[10] = PayloadEncodeLDRColor(Input.TransparencyColor);
	Output.PackedData[11] = PackFloat2ToUInt(float2(Input.MeanFreePath.xy));
	Output.PackedData[12] = PackFloat2ToUInt(float2(Input.MeanFreePath.z, Input.PhaseG));
	Output.PackedData[13] = PayloadEncodeLDRColor(Input.FuzzColor);
	Output.PackedData[14] = PayloadEncodeFuzzAndBottomNormal(Input.FuzzAmount, Input.FuzzRoughness, Input.BottomNormalOct16bits);
	Output.PackedData[15] = PayloadEncodeLDRColor(Input.WeightV);
	Output.PackedData[16] = PayloadEncodeLDRColor(Input.TransmittanceN);
	Output.PackedData[17] = PackFloat2ToUInt(float2(Input.SpecularProfileId, abs(Input.CoverageAboveAlongN)));

	// In order to not increase the data payload size, we alias SSS/Fuzz parameters when glint are enabled
	if (Input.GlintValue < 1)
	{
		const uint2 PackedGlintsData = PackGlints(Input.GlintValue, Input.GlintUV);
		Output.PackedData[11] = PackedGlintsData.x;
		Output.PackedData[12] = PackedGlintsData.y;
		Output.PackedData[13] = PackFloat2ToUInt(Input.GlintUVdx);
		Output.PackedData[14] = PackFloat2ToUInt(Input.GlintUVdx);
		Output.PackedData[17] |= 0x80000000u; // Encode presence of glints in sign bit of CoverageAboveAlongN
	}

#else // PATHTRACING_SUBSTRATE_PAYLOAD

	Output.PackedData[ 6] = PayloadEncodeLDRColor(Input.BaseColor);
	Output.PackedData[ 7] = PayloadEncodeLDRColor(Input.TransparencyColor);
	Output.PackedData[ 8] = PackFloat2ToUInt(float2(Input.Metallic , Input.Specular  ));
	Output.PackedData[ 9] = PackFloat2ToUInt(float2(Input.Roughness, Input.Anisotropy));
	Output.PackedData[10] = PackFloat2ToUInt(Input.CustomData0.xy);
	Output.PackedData[11] = PackFloat2ToUInt(Input.CustomData0.zw);
	Output.PackedData[12] = PackFloat2ToUInt(Input.CustomData1.xy);
	Output.PackedData[13] = PackFloat2ToUInt(Input.CustomData1.zw);

#endif // PATHTRACING_SUBSTRATE_PAYLOAD

#endif // IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	return Output;
}

#if RAYGENSHADER
FPathTracingPayload UnpackPathTracingPayload(FPackedPathTracingPayload Input, FRayDesc Ray)
{
	FPathTracingPayload Output = (FPathTracingPayload)0;

	Output.HitT = Input.HitT;
	Output.TranslatedWorldPos = Ray.Origin + Output.HitT * Ray.Direction;

	Output.BSDFOpacity                  = Input.UnpackBSDFOpacity();
	Output.ShadingModelID               = Input.GetShadingModelID();
	Output.Flags                        = Input.GetFlags();
	Output.PrimitiveLightingChannelMask = Input.GetPrimitiveLightingChannelMask();
#if IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	Output.WorldGeoNormal    = Input.UnpackWorldGeoNormal();
	Output.WorldNormal       = Input.UnpackWorldNormal();
	Output.Radiance          = Input.UnpackRadiance();
	Output.BaseColor         = Input.UnpackBaseColor();
	Output.TransparencyColor = Input.UnpackTransparencyColor();
	Output.SubsurfaceColor   = Input.UnpackSubsurfaceColor();
#else
	Output.WorldGeoNormal    = Input.UnpackWorldGeoNormal();
	Output.WorldSmoothNormal = Input.UnpackWorldSmoothNormal();
	Output.WorldNormal       = Input.UnpackWorldNormal();
	Output.Radiance          = Input.UnpackRadiance();
	Output.WorldTangent      = Input.UnpackWorldTangent();
	Output.Ior               = Input.UnpackIor();

#if PATHTRACING_SUBSTRATE_PAYLOAD
	Output.DiffuseColor        = Input.UnpackDiffuseColor();
	Output.SpecularColor       = Input.UnpackSpecularColor();
	Output.SpecularEdgeColor   = Input.UnpackSpecularEdgeColor();
	float4 RoughnessAniso      = Input.UnpackRoughnessAniso();
	Output.RoughnessData       = RoughnessAniso.xyz;
	Output.Anisotropy          = RoughnessAniso.w;
	Output.TransparencyColor   = Input.UnpackTransparencyColor();
	Output.MeanFreePath        = Input.UnpackMeanFreePath();
	Output.PhaseG              = Input.UnpackPhaseG();
	Output.FuzzColor           = Input.UnpackFuzzColor();
	PayloadDecodeFuzzAndBottomNormal(Input.PackedData[14], Output.FuzzAmount, Output.FuzzRoughness, Output.BottomNormalOct16bits);
	Output.WeightV             = Input.UnpackWeightV();
	Output.TransmittanceN      = Input.UnpackTransmittanceN();
	Output.CoverageAboveAlongN = Input.UnpackCoverageAboveAlongN();
	Output.SpecularProfileId   = Input.UnpackSpecularProfileId();
	
	// TODO: figure out how to make glint unpacking closer to functions above
	// In order to not increase the data payload size, we alias SSS/Fuzz parameters when glint are enabled
	const bool bHasGlints = Input.PackedData[17] >> 31u;
	if (bHasGlints)
	{
		Output.MeanFreePath.x      = 0.f;
		Output.MeanFreePath.y      = 0.f;
		Output.MeanFreePath.z      = 0.f;
		Output.PhaseG              = 0.f;
		Output.FuzzColor           = 0.f;
		Output.FuzzAmount          = 0.f;
		Output.FuzzRoughness       = 0.f;

		UnpackGlints(uint2(Input.PackedData[11], Input.PackedData[12]), Output.GlintValue, Output.GlintUV);
		Output.GlintUVdx = UnpackFloat2FromUInt(Input.PackedData[13]);
		Output.GlintUVdy = UnpackFloat2FromUInt(Input.PackedData[14]);
	}
	else
	{
		// When glints are not used, default to full density so we get the regular specular highlight
		Output.GlintValue = 1.0f;
	}

#else
	// !PATHTRACING_SUBSTRATE_PAYLOAD
	Output.BaseColor         = Input.UnpackBaseColor();
	Output.TransparencyColor = Input.UnpackTransparencyColor();
	Output.Metallic          = Input.UnpackMetallic();
	Output.Specular          = Input.UnpackSpecular();
	Output.Roughness         = Input.UnpackRoughness();
	Output.Anisotropy        = Input.UnpackAnisotropy();
	Output.CustomData0       = Input.UnpackCustomData0();
	Output.CustomData1       = Input.UnpackCustomData1();

	// 
	Output.DiffuseColor  = Output.BaseColor - Output.BaseColor * Output.Metallic;
	Output.SpecularColor = ComputeF0(Output.Specular, Output.BaseColor, Output.Metallic);
#endif // PATHTRACING_SUBSTRATE_PAYLOAD
#endif // IS_PAYLOAD_ENABLED(RT_PAYLOAD_TYPE_GPULIGHTMASS)
	return Output;
}
#endif