#pragma kernel ShadeDeferred_Fptl SHADE_DEFERRED_ENTRY=ShadeDeferred_Fptl USE_FPTL_LIGHTLIST=1 ENABLE_DEBUG=0

#pragma kernel ShadeDeferred_Clustered SHADE_DEFERRED_ENTRY=ShadeDeferred_Clustered USE_CLUSTERED_LIGHTLIST=1 ENABLE_DEBUG=0 //TODO: disabled clustered permutations so far as it leads to the error "All kernels must use same constant buffer layouts"

#pragma kernel ShadeDeferred_Fptl_Debug SHADE_DEFERRED_ENTRY=ShadeDeferred_Fptl_Debug USE_FPTL_LIGHTLIST=1 ENABLE_DEBUG=1

#pragma kernel ShadeDeferred_Clustered_Debug SHADE_DEFERRED_ENTRY=ShadeDeferred_Clustered_Debug USE_CLUSTERED_LIGHTLIST=1 ENABLE_DEBUG=1

#define TILE_SIZE 8

// Hacks to get the header to compile in compute

#define SHADER_TARGET 50

#define UNITY_PBS_USE_BRDF1

#define fixed4 float4

#include "UnityLightingCommon.cginc"

#undef fixed4

float3 EvalMaterial(UnityLight light, UnityIndirect ind);

float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind);

// uses the optimized single layered light list for opaques only

#ifdef USE_FPTL_LIGHTLIST

#define OPAQUES_ONLY

#endif

#include "TiledLightingTemplate.hlsl"

#include "TiledReflectionTemplate.hlsl"

Texture2D_float _CameraDepthTexture;

Texture2D _CameraGBufferTexture0;

Texture2D _CameraGBufferTexture1;

Texture2D _CameraGBufferTexture2;

Texture2D _CameraGBufferTexture3;

RWTexture2D<float4> uavOutput : register(u0);

struct v2f {

float4 vertex : SV_POSITION;

float2 texcoord : TEXCOORD0;

};

v2f vert(float4 vertex : POSITION, float2 texcoord : TEXCOORD0)

{

v2f o;

o.vertex = UnityObjectToClipPos(vertex);

o.texcoord = texcoord.xy;

return o;

}

struct StandardData

{

float3 specularColor;

float3 diffuseColor;

float3 normalWorld;

float smoothness;

float occlusion;

float3 emission;

};

struct LocalDataBRDF

{

StandardData gbuf;

// extras

float oneMinusReflectivity;

float3 Vworld;

};

static LocalDataBRDF g_localParams;

StandardData UnityStandardDataFromGbufferAux(float4 gbuffer0, float4 gbuffer1, float4 gbuffer2, float4 gbuffer3)

{

StandardData data;

data.normalWorld = normalize(2 * gbuffer2.xyz - 1);

data.smoothness = gbuffer1.a;

data.diffuseColor = gbuffer0.xyz; data.specularColor = gbuffer1.xyz;

data.occlusion = gbuffer0.a;

data.emission = gbuffer3.xyz;

return data;

}

half3 BRDF3_Direct2(half3 diffColor, half3 specColor, half rlPow4, half smoothness)

{

half LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp

// Lookup texture to save instructions

half specular = tex2Dlod(unity_NHxRoughness, half4(rlPow4, SmoothnessToPerceptualRoughness(smoothness), 0, 0)).UNITY_ATTEN_CHANNEL * LUT_RANGE;

#if defined(_SPECULARHIGHLIGHTS_OFF)

specular = 0.0;

#endif

return diffColor + specular * specColor;

}

float3 EvalMaterial(UnityLight light, UnityIndirect ind)

{

StandardData data = g_localParams.gbuf;

return UNITY_BRDF_PBS(data.diffuseColor, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind);

}

float3 EvalIndirectSpecular(UnityLight light, UnityIndirect ind)

{

StandardData data = g_localParams.gbuf;

return data.occlusion * UNITY_BRDF_PBS(0, data.specularColor, g_localParams.oneMinusReflectivity, data.smoothness, data.normalWorld, g_localParams.Vworld, light, ind).rgb;

}

[numthreads(TILE_SIZE, TILE_SIZE, 1)]

void SHADE_DEFERRED_ENTRY(uint2 dispatchThreadId : SV_DispatchThreadID, uint2 groupId : SV_GroupID)

{

uint2 pixCoord = dispatchThreadId;

float zbufDpth = FetchDepth(_CameraDepthTexture, pixCoord.xy).x;

float linDepth = GetLinearDepth(zbufDpth);

float3 vP = GetViewPosFromLinDepth(pixCoord, linDepth);

float3 vPw = mul(g_mViewToWorld, float4(vP, 1)).xyz;

float3 Vworld = normalize(mul((float3x3) g_mViewToWorld, -vP).xyz); //unity_CameraToWorld

float4 gbuffer0 = _CameraGBufferTexture0.Load(uint3(pixCoord.xy, 0));

float4 gbuffer1 = _CameraGBufferTexture1.Load(uint3(pixCoord.xy, 0));

float4 gbuffer2 = _CameraGBufferTexture2.Load(uint3(pixCoord.xy, 0));

float4 gbuffer3 = _CameraGBufferTexture3.Load(uint3(pixCoord.xy, 0));

StandardData data = UnityStandardDataFromGbufferAux(gbuffer0, gbuffer1, gbuffer2, gbuffer3);

g_localParams.gbuf = data;

g_localParams.oneMinusReflectivity = 1.0 - SpecularStrength(data.specularColor.rgb);

g_localParams.Vworld = Vworld;

uint2 tileCoord = groupId >> 1;

uint numLightsProcessed = 0;

float3 c = data.emission + ExecuteLightList(numLightsProcessed, tileCoord, vP, vPw, Vworld);

uint numReflectionsProcessed = 0;

c += ExecuteReflectionList(numReflectionsProcessed, tileCoord, vP, data.normalWorld, Vworld, data.smoothness);

#if ENABLE_DEBUG

c = OverlayHeatMap(pixCoord & 15, numLightsProcessed, c);

#endif

uavOutput[pixCoord] = float4(c, 1.0);

}