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

#pragma once

// Change this to force recompilation of all MegaLights shaders
#pragma message("UESHADERMETADATA_VERSION VE4B3E07-ACF4-A565-BF1C-747A9EA5FD52")

#include "/Engine/Shared/MegaLightsDefinitions.h"

bool IsSimpleShadingTileType(uint TileType)
{
	return TileType == TILE_MODE_SIMPLE_SHADING
		|| TileType == TILE_MODE_SIMPLE_SHADING_RECT
		|| TileType == TILE_MODE_SIMPLE_SHADING_RECT_TEXTURED;
}

bool IsRectLightTileType(uint TileType)
{
	return TileType == TILE_MODE_SIMPLE_SHADING_RECT
		|| TileType == TILE_MODE_COMPLEX_SHADING_RECT
		|| TileType == TILE_MODE_SIMPLE_SHADING_RECT_TEXTURED
		|| TileType == TILE_MODE_COMPLEX_SHADING_RECT_TEXTURED
		#if SUBSTRATE_ENABLED
		|| TileType == TILE_MODE_SINGLE_SHADING_RECT
		|| TileType == TILE_MODE_COMPLEX_SPECIAL_SHADING_RECT
		|| TileType == TILE_MODE_SINGLE_SHADING_RECT_TEXTURED
		|| TileType == TILE_MODE_COMPLEX_SPECIAL_SHADING_RECT_TEXTURED
		#endif
		;
}

bool IsTexturedLightTileType(uint TileType)
{ 
	return TileType == TILE_MODE_SIMPLE_SHADING_RECT_TEXTURED
		|| TileType == TILE_MODE_COMPLEX_SHADING_RECT_TEXTURED
		#if SUBSTRATE_ENABLED
		|| TileType == TILE_MODE_SINGLE_SHADING_RECT_TEXTURED
		|| TileType == TILE_MODE_COMPLEX_SPECIAL_SHADING_RECT_TEXTURED
		#endif
		;
}

#if SUBSTRATE_ENABLED
	#define MAX_USED_TILE_MODE TILE_MODE_MAX
#else
	#define MAX_USED_TILE_MODE TILE_MODE_MAX_LEGACY
#endif

#if TILE_TYPE == TILE_MODE_SIMPLE_SHADING_RECT_TEXTURED || TILE_TYPE == TILE_MODE_COMPLEX_SHADING_RECT_TEXTURED || TILE_TYPE == TILE_MODE_SINGLE_SHADING_RECT_TEXTURED || TILE_TYPE == TILE_MODE_COMPLEX_SPECIAL_SHADING_RECT_TEXTURED
	#define USE_SOURCE_TEXTURE 1
#else
	#define USE_SOURCE_TEXTURE 0
#endif

#ifndef DEBUG_MODE
	#define SHADER_PRINT_ALLOW 0
#endif

#include "../LightGridCommon.ush"
#define SUPPORT_CONTACT_SHADOWS 0
#define NON_DIRECTIONAL_DIRECT_LIGHTING 0
#include "../DeferredLightingCommon.ush"
#include "../SceneData.ush"
#include "../Hash.ush"

#include "../ShaderPrint.ush"
#define FontValue FontWhite
#define FontSelected FontRed
#define FontTitle FontEmerald
#define FontBackground float4(0, 0, 0, 0.25f)

#include "../Lumen/LumenPosition.ush"
#include "../StochasticLighting/StochasticLightingUpsample.ush"

#if !PLATFORM_SUPPORTS_REAL_TYPES
	#define half3x2 float3x2
#endif

#define DEBUG_MODE_VISUALIZE_TRACING	1
#define DEBUG_MODE_VISUALIZE_SAMPLING	2
#define DEBUG_MODE_TILE_CLASSIFICATION	3

void PrintTileTypeString(inout FShaderPrintContext Context, uint TileType, FFontColor InColor = FontWhite)
{
#if DEBUG_MODE
	switch (TileType)
	{
		case TILE_MODE_SIMPLE_SHADING:							Print(Context, TEXT("Simple               "), InColor); break;
		case TILE_MODE_COMPLEX_SHADING:							Print(Context, TEXT("Complex              "), InColor); break;
		case TILE_MODE_SIMPLE_SHADING_RECT:						Print(Context, TEXT("Simple Rect          "), InColor); break;
		case TILE_MODE_COMPLEX_SHADING_RECT:					Print(Context, TEXT("Complex Rect         "), InColor); break;
		case TILE_MODE_SIMPLE_SHADING_RECT_TEXTURED:			Print(Context, TEXT("Simple Textured Rect "), InColor); break;
		case TILE_MODE_COMPLEX_SHADING_RECT_TEXTURED:			Print(Context, TEXT("Complex Textured Rect"), InColor); break;
		case TILE_MODE_EMPTY:									Print(Context, TEXT("Empty                "), InColor); break;
	#if SUBSTRATE_ENABLED
		case TILE_MODE_SINGLE_SHADING:							Print(Context, TEXT("Single               "), InColor); break;
		case TILE_MODE_COMPLEX_SPECIAL_SHADING:					Print(Context, TEXT("Complex Special      "), InColor); break;
		case TILE_MODE_SINGLE_SHADING_RECT:						Print(Context, TEXT("Single Rect          "), InColor); break;
		case TILE_MODE_COMPLEX_SPECIAL_SHADING_RECT:			Print(Context, TEXT("Complex Special Rect "), InColor); break;
		case TILE_MODE_SINGLE_SHADING_RECT_TEXTURED:			Print(Context, TEXT("Single Textured Rect "), InColor); break;
		case TILE_MODE_COMPLEX_SPECIAL_SHADING_RECT_TEXTURED:	Print(Context, TEXT("Complex Sp.Text. Rect"), InColor); break;
	#endif
	}
#endif
}

int2 DebugCursorPosition;

int2 GetDebugScreenCoord()
{
	const int2 CursorPosition = all(DebugCursorPosition >= 0) ? DebugCursorPosition : View.CursorPosition * View.ViewResolutionFraction;
	const int2 DebugScreenCoord = CursorPosition.x >= 0 ? View.ViewRectMin.xy + CursorPosition : -1;	
	return DebugScreenCoord;
}

uint2 DownsampleFactor;

// Utility to avoid int mult/div operations
uint2 GetDownsampleFactor()
{
	return select(DownsampleFactor == 1, uint2(1, 1), uint2(2, 2));
}

FShaderPrintContext InitDebugContext(uint2 ScreenCoord, bool bDownsampled, float2 StartPos)
{
	FShaderPrintContext DebugContext;
#if DEBUG_MODE
	int2 DebugScreenCoord = GetDebugScreenCoord();
	if (bDownsampled)
	{
		DebugScreenCoord /= GetDownsampleFactor();
	}
	DebugContext = InitShaderPrintContext(all(ScreenCoord == DebugScreenCoord), StartPos);
#else
	DebugContext = InitShaderPrintContext(false, StartPos);
#endif
	return DebugContext;
}

FShaderPrintContext InitDebugContext(bool bActive, float2 StartPos)
{
	FShaderPrintContext DebugContext;
#if DEBUG_MODE
	DebugContext = InitShaderPrintContext(bActive, StartPos);
#else
	DebugContext = InitShaderPrintContext(false, StartPos);
#endif
	return DebugContext;
}

uint PackTile(uint2 TileCoord)
{
	return TileCoord.x | (TileCoord.y << 16);
}

uint2 UnpackTile(uint PackedTile)
{
	return uint2(PackedTile & 0xFFFF, PackedTile >> 16);
}

struct FLightSample
{
	uint LocalLightIndex;
	float Weight;
	bool bVisible;
	bool bGuidedAsVisible;
};

FLightSample InitLightSample()
{
	FLightSample LightSample;
	LightSample.LocalLightIndex = MAX_LOCAL_LIGHT_INDEX;
	LightSample.Weight = 0.0f;
	LightSample.bVisible = false;
	LightSample.bGuidedAsVisible = false;
	return LightSample;
}

uint PackLightSample(FLightSample LightSample)
{
	uint PackedLightSample = LightSample.LocalLightIndex & 0xFFFF;
	PackedLightSample |= (f32tof16(LightSample.Weight) & 0x7FFE) << 16;
	PackedLightSample |= LightSample.bGuidedAsVisible ? 0x10000 : 0;
	PackedLightSample |= LightSample.bVisible ? 0x80000000 : 0;
	return PackedLightSample;
}

FLightSample UnpackLightSample(uint PackedLightSample)
{
	FLightSample LightSample = InitLightSample();
	LightSample.LocalLightIndex = PackedLightSample & 0xFFFF;
	LightSample.Weight = f16tof32((PackedLightSample >> 16) & 0x7FFE);
	LightSample.bGuidedAsVisible = PackedLightSample & 0x10000 ? true : false;
	LightSample.bVisible = PackedLightSample & 0x80000000 ? true : false;
	return LightSample;
}

struct FLightSampleRay
{
	float RayDistance;			// Distance traversed by ray
	float2 UV;
	bool bCompleted;			// Whether tracing was completed
	bool bHair;
	bool bBackfaceDiffuse;
};

FLightSampleRay InitLightSampleRay()
{
	FLightSampleRay LightSampleRay;
	LightSampleRay.UV = 0.5f;
	LightSampleRay.RayDistance = 0.0f;
	LightSampleRay.bCompleted = true;
	LightSampleRay.bHair = false;
	LightSampleRay.bBackfaceDiffuse = false;
	return LightSampleRay;
}

uint PackLightSampleRay(FLightSampleRay LightSampleRay)
{
	uint Packed = 0;

	Packed = f32tof16(LightSampleRay.RayDistance);
	Packed |= LightSampleRay.bBackfaceDiffuse ? 0x8000 : 0;

	Packed |= uint(LightSampleRay.UV.x * 0x7F + 0.5f) << 16;
	Packed |= uint(LightSampleRay.UV.y * 0x7F + 0.5f) << 23;
	Packed |= LightSampleRay.bCompleted	? 0x40000000 : 0;
	Packed |= LightSampleRay.bHair		? 0x80000000 : 0;

	return Packed;
}

FLightSampleRay UnpackLightSampleRay(uint Packed)
{
	FLightSampleRay LightSampleRay = InitLightSampleRay();

	LightSampleRay.RayDistance = f16tof32(Packed & 0x7FFF);
	LightSampleRay.bBackfaceDiffuse    = Packed & 0x8000 ? true : false;

	LightSampleRay.UV.x = ((Packed >> 16) & 0x7F) / float(0x7F);
	LightSampleRay.UV.y = ((Packed >> 23) & 0x7F) / float(0x7F);
	LightSampleRay.bCompleted   = Packed & 0x40000000 ? true : false;
	LightSampleRay.bHair		= Packed & 0x80000000 ? true : false;

	return LightSampleRay;
}

struct FVolumeLightSampleRay
{
	bool bCompleted;			// Whether tracing was completed
};

FVolumeLightSampleRay InitVolumeLightSampleRay()
{
	FVolumeLightSampleRay VolumeLightSampleRay;
	VolumeLightSampleRay.bCompleted = true;
	return VolumeLightSampleRay;
}

uint PackVolumeLightSampleRay(FVolumeLightSampleRay VolumeLightSampleRay)
{
	uint Packed = 0;

	Packed |= VolumeLightSampleRay.bCompleted ? 0x1 : 0;

	return Packed;
}

FVolumeLightSampleRay UnpackVolumeLightSampleRay(uint Packed)
{
	FVolumeLightSampleRay VolumeLightSampleRay = InitVolumeLightSampleRay();

	VolumeLightSampleRay.bCompleted = Packed & 0x1 ? true : false;

	return VolumeLightSampleRay;
}

bool GetLightVisibility(uint VisibleLightHash[VISIBLE_LIGHT_HASH_SIZE], uint PrevLocalLightIndex)
{
	uint Hash = PCGHash(PrevLocalLightIndex);
	uint WrappedLocalLightIndex = Hash % (4 * 32);
	uint DWORDIndex = WrappedLocalLightIndex / 32;
	uint BitMask = 1u << (WrappedLocalLightIndex % 32);
	bool Test0 = (VisibleLightHash[DWORDIndex] & BitMask) != 0;

	WrappedLocalLightIndex = (Hash >> 8) % (4 * 32);
	DWORDIndex = WrappedLocalLightIndex / 32;
	BitMask = 1u << (WrappedLocalLightIndex % 32);
	bool Test1 = (VisibleLightHash[DWORDIndex] & BitMask) != 0;

	return Test0 && Test1;
}

uint MegaLightsStateFrameIndex;

/** 
 * Returns sample jitter offset in the range [0, DOWNSAMPLE_FACTOR_XY - 1]
 */
uint2 GetSampleScreenCoordJitter(uint2 DownsampledScreenCoord)
{
	uint2 Jitter = 0;

	if (DownsampleFactor.x != 1)
	{
		if (DownsampleFactor.y != 1)
		{
			Jitter = GetDownsampleJitter2x2(DownsampledScreenCoord);
		}
		else
		{
			Jitter = GetDownsampleJitter2x1(DownsampledScreenCoord);
		}
	}

	return Jitter;
}

uint2 DownsampledScreenCoordToScreenCoord(uint2 DownsampledScreenCoord)
{
	return DownsampledScreenCoord * GetDownsampleFactor() + GetSampleScreenCoordJitter(DownsampledScreenCoord);
}

float2 DownsampledScreenCoordToScreenUV(uint2 DownsampledScreenCoord)
{
	uint2 ScreenCoord = DownsampledScreenCoordToScreenCoord(DownsampledScreenCoord);
	float2 ScreenUV = (ScreenCoord + 0.5f) * View.BufferSizeAndInvSize.zw;
	return ScreenUV;
}

uint2 NumSamplesPerPixelDivideShift;

uint2 SampleCoordToDownsampledScreenCoord(uint2 SampleCoord)
{
	// SampleCoord / NumSamplesPerPixel
	return SampleCoord >> NumSamplesPerPixelDivideShift;
}

uint3 NumSamplesPerVoxelDivideShift;

uint3 SampleCoordToDownsampledVolumeCoord(uint3 SampleCoord)
{
	// SampleCoord / NumSamplesPerVoxel
	return SampleCoord >> NumSamplesPerVoxelDivideShift;
}

uint2 SampleCoordToScreenCoord(uint2 SampleCoord)
{
	uint2 DownsampledScreenCoord = SampleCoordToDownsampledScreenCoord(SampleCoord);
	return DownsampledScreenCoord * GetDownsampleFactor() + GetSampleScreenCoordJitter(DownsampledScreenCoord);
}