struct RNG
{
    uint4 seed;

    float uintTofloat(uint x)
    {
        return asfloat(0x3f800000u | (x >> 9u)) - 1.0f;
    }

    uint4 pcg4d(uint4  v)
    {
        v = v * 1664525u + 1013904223u;

        v.x += v.y * v.w; v.y += v.z * v.x;
        v.z += v.x * v.y; v.w += v.y * v.z;

        v.x = v.x ^ (v.x >> 16u); v.y = v.y ^ (v.y >> 16u);
        v.z = v.z ^ (v.z >> 16u); v.w = v.w ^ (v.w >> 16u);

        v.x += v.y * v.w; v.y += v.z * v.x;
        v.z += v.x * v.y; v.w += v.y * v.z;

        return v;
    }

    void init(uint2 pixelCoords, uint sampleIndex, uint dim)
    {
        //< Seed for PCG uses a sequential sample number in 4th channel,
        //  which increments on every RNG call and starts from 0
        seed = uint4(pixelCoords.x, pixelCoords.y, sampleIndex, dim);
    }

    float4 rand()
    {
        seed.w++;
        uint4 v = pcg4d(seed);
        return float4(uintTofloat(v.x), uintTofloat(v.y), uintTofloat(v.z), uintTofloat(v.w));
    }
};

#include "Random.hlsl"

struct RayPayload
{
    bool hit;
    float3 radiance;
    float3 emission;
    float3 position;
    float3 normal;
    float4 randVal;
    float3 reflect_direction;
    float3 weight;
};

#define MAX_RAY_DEPTH 10

RayPayload payload = (RayPayload)0;

RNG rng;
rng.init(dispatchIdx, 0 /*frame count*/, 0 /* dimension */);

float3 radiance = 0;
float3 throughput = 1;

[unroll]
for(int i = 0; i < MAX_RAY_DEPTH; i++)
{
    // この反射で使う乱数
    payload.randVal = rng.rand();

    // レイを飛ばす
    TraceRay(_Scene, 0, 0xFF, 0, 1, 0, ray, payload);

    // 直接光を評価
    if (payload.hit)
    {
        radiance += throughput * payload.radiance;
    }

    // 空を評価
    if (!payload.hit)
    {
        radiance += throughput * payload.radiance;
        break;
    }

    // 発光を評価
    if (any(payload.emission != 0))
    {
        radiance += throughput * payload.emission;
        break;
    }

    // スループットを更新
    throughput *= payload.weight;

    // レイを更新
    ray.Origin = payload.position + 1e-6 * payload.normal;
    ray.Direction = payload.reflect_direction;
}
_Result[dispatchIdx] = float4(radiance, 1.0);

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ImageBasedLighting.hlsl"

if(any(surfaceData.emission != 0))
{
    // 発光面（Le != 0）では直接光も評価しないで終了とする
    payload.emission = surfaceData.emission;
    payload.weight = 1;
    payload.radiance = 0;
}
else
{
    // 数値的なライトを評価
    float3 directLighting = MyUniversalFragmentPBR(inputData, surfaceData).rgb;
    payload.radiance = directLighting;
    payload.emission = 0;

    float nl, w;
    // ImageBasedLighting.hlsl
    ImportanceSampleLambert(payload.randVal.xy, inputData.tangentToWorld,
                            /*out*/ payload.reflect_direction, /*out*/ nl, /*out*/ w);

    // 本当は BRDFData.diffuse を使うべきだが、今はベースカラーをそのまま拡散反射の色とする
    payload.weight = surfaceData.albedo * w;
}

payload.hit = true;
payload.position = inputData.positionWS;
payload.normal = inputData.normalWS;

// weightOverPdf return the weight (without the diffuseAlbedo term) over pdf. diffuseAlbedo term must be apply by the caller.
void ImportanceSampleLambert(real2   u,
                             real3x3 localToWorld,
                         out real3   L,
                         out real    NdotL,
                         out real    weightOverPdf)

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityInput.hlsl"

#include "Payload.hlsl"
#include "Random.hlsl"

#pragma max_recursion_depth 2

RaytracingAccelerationStructure _Scene;
RWTexture2D<float4> _Result;

// https://github.com/boksajak/referencePT/blob/master/shaders/PathTracer.hlsl
RayDesc generatePinholeCameraRay(float2 pixel)
{
    float4x4 view = unity_WorldToCamera;
    float4x4 proj = unity_CameraProjection;

    // Setup the ray
    RayDesc ray;
    ray.Origin = _WorldSpaceCameraPos;
    ray.TMin = T_MIN;
    ray.TMax = T_MAX;

    // Extract the aspect ratio and field of view from the projection matrix
    float aspect = proj[1][1] / proj [0][0];
    float tanHalfFovY = 1.0f / proj [1][1];

    // Compute the ray direction for this pixel
    ray.Direction = normalize(
        (pixel.x * view[0].xyz * tanHalfFovY * aspect) -
        (pixel.y * view[1].xyz * tanHalfFovY) + view[2].xyz);

    return ray;
}

#define MAX_RAY_DEPTH 10

[shader("raygeneration")]
void MyRaygenShader()
{
    uint2 dispatchIdx = DispatchRaysIndex().xy;
    uint2 dispatchSize = DispatchRaysDimensions().xy;

    // Create the ray descriptor for this pixel
    float2 clipPixel = (dispatchIdx + 0.5) / (float2)dispatchSize;
    clipPixel.y = 1.0 - clipPixel.y;
    clipPixel = clipPixel * 2.0 - 1.0;
    RayDesc ray = generatePinholeCameraRay(clipPixel);

    RayPayload payload = (RayPayload)0;

    RNG rng;
    rng.init(dispatchIdx, /* sample index */ 0, /* dimension */ 0);

    float3 radiance = 0;
    float3 throughput = 1;

    [unroll]
    for(int i = 0; i < MAX_RAY_DEPTH; i++)
    {
        // この反射で使う乱数
        payload.randVal = rng.rand();

        // レイを飛ばす
        TraceRay(_Scene, 0, 0xFF, 0, 1, 0, ray, payload);

        // 直接光を評価
        if (payload.hit)
        {
            radiance += throughput * payload.radiance;
        }

        // 空を評価
        if (!payload.hit)
        {
            radiance += throughput * payload.radiance;
            break;
        }

        // 発光を評価
        if (any(payload.emission != 0))
        {
            radiance += throughput * payload.emission;
            break;
        }

        // スループットを更新
        throughput *= payload.weight;

        // レイを更新
        ray.Origin = payload.position + 1e-6 * payload.normal;
        ray.Direction = payload.reflect_direction;
    }
    _Result[dispatchIdx] = float4(radiance, 1.0);
}

[shader("miss")]
void MyMissShader(inout RayPayload payload : SV_RayPayload)
{
    float t = WorldRayDirection().y * 0.9 + 0.1;
    t = saturate(pow(t, 0.2));
    payload.radiance = lerp(float3(0.5, 0.5, 0.7), float3(0.1, 0.3, 0.8), t) * 5;
    payload.weight = 1;
    payload.hit = false;
}

[shader("miss")]
void ShadowMissShader(inout ShadowPayload payload : SV_RayPayload)
{
    payload.hit = false;
}

// 先に SAMPLE_TEXTURE2D を定義するインクルードをしておく
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

// 現状は RayTracing シェーダでミップマップは使えないので、
// SAMPLE_TEXTURE2D を使ったときに Mip0 に強制するように定義を置き換える
#ifdef SAMPLE_TEXTURE2D
    #undef SAMPLE_TEXTURE2D
    #define SAMPLE_TEXTURE2D(textureName, samplerName, coord) \
        SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord, 0)
#endif

#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/ImageBasedLighting.hlsl"

#include "Packages/com.unity.render-pipelines.universal/Shaders/LitInput.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl"

#include "UnityRaytracingMeshUtils.cginc"

#include "Payload.hlsl"

#define M_PI    3.14159265
#define EPSILON 1e-12

RaytracingAccelerationStructure _Scene;

struct AttributeData
{
    float2 barycentrics;
};

struct Vertex
{
    float3 position;
    float3 normal;
    float4 tangent;
    float2 texCoord0;
    float2 texCoord1;
    float2 texCoord2;
    float2 texCoord3;
    float4 color;
};

// Unity ビルトイン関数を使って頂点データを得る関数
Vertex FetchVertex(uint vertexIndex)
{
    Vertex v;
    v.position = UnityRayTracingFetchVertexAttribute3(vertexIndex, kVertexAttributePosition);
    v.normal = UnityRayTracingFetchVertexAttribute3(vertexIndex, kVertexAttributeNormal);
    v.tangent = UnityRayTracingFetchVertexAttribute4(vertexIndex, kVertexAttributeTangent);
    v.texCoord0 = UnityRayTracingFetchVertexAttribute2(vertexIndex, kVertexAttributeTexCoord0);
    v.texCoord1 = UnityRayTracingFetchVertexAttribute2(vertexIndex, kVertexAttributeTexCoord1);
    v.texCoord2 = UnityRayTracingFetchVertexAttribute2(vertexIndex, kVertexAttributeTexCoord2);
    v.texCoord3 = UnityRayTracingFetchVertexAttribute2(vertexIndex, kVertexAttributeTexCoord3);
    v.color = UnityRayTracingFetchVertexAttribute4(vertexIndex, kVertexAttributeColor);
    return v;
}

// レイトレのヒットした位置から頂点データを補間する関数
Vertex InterpolateVertices(Vertex v0, Vertex v1, Vertex v2, float3 barycentrics)
{
    Vertex v;
    #define INTERPOLATE_ATTRIBUTE(attr) v.attr = v0.attr * barycentrics.x + v1.attr * barycentrics.y + v2.attr * barycentrics.z
    INTERPOLATE_ATTRIBUTE(position);
    INTERPOLATE_ATTRIBUTE(normal);
    INTERPOLATE_ATTRIBUTE(tangent);
    INTERPOLATE_ATTRIBUTE(texCoord0);
    INTERPOLATE_ATTRIBUTE(texCoord1);
    INTERPOLATE_ATTRIBUTE(texCoord2);
    INTERPOLATE_ATTRIBUTE(texCoord3);
    INTERPOLATE_ATTRIBUTE(color);
    return v;
}

// from : LitForwardPass.hlsl
void InitializeInputData(Vertex input, half3 normalTS, out InputData inputData)
{
    inputData.positionWS = WorldRayOrigin() + RayTCurrent() * WorldRayDirection();
    inputData.positionCS = 0;
    inputData.viewDirectionWS = WorldRayDirection();
    inputData.shadowCoord = 0;
    inputData.fogCoord = 0;
    inputData.vertexLighting = 0;
    inputData.bakedGI = 0;
    inputData.shadowMask = 0;
    inputData.normalizedScreenSpaceUV = DispatchRaysIndex().xy / DispatchRaysDimensions().xy;

    // レイトレ用の変換行列を使ってワールド法線と接線を解決する
    float3 normalWS = normalize(mul(input.normal, (float3x3)WorldToObject3x4()));

    // Tangent はあるものとして計算（レイトレではノーマルマップの計算以外にも必須）
    float4 tangentWS = float4(normalize(mul(input.tangent.xyz, (float3x3)WorldToObject3x4())), input.tangent.w);
    inputData.tangentToWorld = BuildTangentToWorld(tangentWS, normalWS); // ShaderGraphFuction.hlsl

    #if defined(_NORMALMAP) || defined(_DETAIL)
        inputData.normalWS = TransformTangentToWorld(normalTS, inputData.tangentToWorld); // SpaceTransforms.hlsl
    #else
        inputData.normalWS = normalWS;
    #endif

    // inputData は Shadow/GI 関係のデータも扱うが、今回はそれらはレイトレで解決するので用意しない
}

float TraceShadow(float3 lightDirection, float3 normalWS, float3 positionWS)
{
    RayDesc ray;
    ray.Origin = positionWS + 1e-6 * normalWS;
    ray.Direction = lightDirection;

    // シーンスケールに合わせて適切に設定すべき
    ray.TMin = 0.1;
    ray.TMax = 100;

    ShadowPayload payload = (ShadowPayload)0;
    payload.hit = true;
    TraceRay(_Scene, RAY_FLAG_SKIP_CLOSEST_HIT_SHADER | RAY_FLAG_ACCEPT_FIRST_HIT_AND_END_SEARCH,
             0xFF, 0, 1, 1 /* ShadowMissShader */, ray, payload);
    return (float)!payload.hit;
}

// from : Lighting.hlsl
half4 MyUniversalFragmentPBR(InputData inputData, SurfaceData surfaceData)
{
    #if defined(_SPECULARHIGHLIGHTS_OFF)
    bool specularHighlightsOff = true;
    #else
    bool specularHighlightsOff = false;
    #endif
    BRDFData brdfData;

    // NOTE: can modify "surfaceData"...
    InitializeBRDFData(surfaceData, brdfData);

    // Clear-coat calculation...
    BRDFData brdfDataClearCoat = CreateClearCoatBRDFData(surfaceData, brdfData);
    uint meshRenderingLayers = GetMeshRenderingLayer();

    Light mainLight = GetMainLight();
    mainLight.shadowAttenuation = TraceShadow(mainLight.direction, inputData.normalWS, inputData.positionWS);

    LightingData lightingData = CreateLightingData(inputData, surfaceData);
    lightingData.giColor = 0; // GI はパストレで解決する

#ifdef _LIGHT_LAYERS
    if (IsMatchingLightLayer(mainLight.layerMask, meshRenderingLayers))
#endif
    {
        lightingData.mainLightColor = LightingPhysicallyBased(brdfData, brdfDataClearCoat,
                                                              mainLight,
                                                              inputData.normalWS, inputData.viewDirectionWS,
                                                              surfaceData.clearCoatMask, specularHighlightsOff);
    }

    #if defined(_ADDITIONAL_LIGHTS)
    uint pixelLightCount = GetAdditionalLightsCount();

    #if USE_FORWARD_PLUS
    [loop] for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
    {
        FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK

        Light light = GetAdditionalLight(lightIndex, inputData.positionWS);
        //light.shadowAttenuation = TraceShadow(light.direction, inputData.normalWS, inputData.positionWS);

        #ifdef _LIGHT_LAYERS
            if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
        #endif
        {
            lightingData.additionalLightsColor += LightingPhysicallyBased(brdfData, brdfDataClearCoat, light,
                                                                          inputData.normalWS, inputData.viewDirectionWS,
                                                                          surfaceData.clearCoatMask, specularHighlightsOff);
        }
    }
    #endif // USE_FORWARD_PLUS

    LIGHT_LOOP_BEGIN(pixelLightCount)
        Light light = GetAdditionalLight(lightIndex, inputData.positionWS);
        //light.shadowAttenuation = TraceShadow(light.direction, inputData.normalWS, inputData.positionWS);

        #ifdef _LIGHT_LAYERS
            if (IsMatchingLightLayer(light.layerMask, meshRenderingLayers))
        #endif
        {
            lightingData.additionalLightsColor += LightingPhysicallyBased(brdfData, brdfDataClearCoat, light,
                                                                          inputData.normalWS, inputData.viewDirectionWS,
                                                                          surfaceData.clearCoatMask, specularHighlightsOff);
        }
    LIGHT_LOOP_END
    #endif // _ADDITIONAL_LIGHTS

    #if REAL_IS_HALF
        // Clamp any half.inf+ to HALF_MAX
        return min(CalculateFinalColor(lightingData, surfaceData.alpha), HALF_MAX);
    #else
        return CalculateFinalColor(lightingData, surfaceData.alpha);
    #endif
}

[shader("closesthit")]
void ClosestHitMain(inout RayPayload payload : SV_RayPayload, AttributeData attribs : SV_IntersectionAttributes)
{
    // レイトレのヒットした位置から頂点インデックスを取得
    uint3 triangleIndices = UnityRayTracingFetchTriangleIndices(PrimitiveIndex());

    // 頂点インデックスから三角形の3頂点を取得
    Vertex v0, v1, v2;
    v0 = FetchVertex(triangleIndices.x);
    v1 = FetchVertex(triangleIndices.y);
    v2 = FetchVertex(triangleIndices.z);

    // 3頂点からをヒット位置で補間
    float3 barycentricCoords = float3(1.0 - attribs.barycentrics.x - attribs.barycentrics.y, attribs.barycentrics.x, attribs.barycentrics.y);
    Vertex v = InterpolateVertices(v0, v1, v2, barycentricCoords);

    // テクスチャ座標の変形（元は LitPassVertex の処理）
    v.texCoord0 = TRANSFORM_TEX(v.texCoord0, _BaseMap);

    SurfaceData surfaceData;
    InitializeStandardLitSurfaceData(v.texCoord0, surfaceData);

    InputData inputData;
    InitializeInputData(v, surfaceData.normalTS, inputData);

    if(any(surfaceData.emission != 0))
    {
        // 発光面（Le != 0）では直接光も評価しないで終了とする
        payload.emission = surfaceData.emission;
        payload.weight = 1;
        payload.radiance = 0;
    }
    else
    {
        // 数値的なライトを評価
        float3 directLighting = MyUniversalFragmentPBR(inputData, surfaceData).rgb;
        payload.radiance = directLighting;
        payload.emission = 0;
        
        float nl, w;
        // ImageBasedLighting.hlsl
        ImportanceSampleLambert(payload.randVal.xy, inputData.tangentToWorld,
                                /*out*/ payload.reflect_direction, /*out*/ nl, /*out*/ w);

        // 本当は BRDFData.diffuse を使うべきだが、今はベースカラーをそのまま拡散反射の色とする
        payload.weight = surfaceData.albedo * w;
    }

    payload.hit = true;
    payload.position = inputData.positionWS;
    payload.normal = inputData.normalWS;
}