#include "shared/point.hlsl"
#include "shared/quat-functions.hlsl"
#include "shared/hash-functions.hlsl"

static const float4 Corners[] = 
{
    //   px py  u v
  float4(-1, -1, 0,1),
  float4( 1, -1, 1,1), 
  float4( 1,  1, 1,0), 
  float4( 1,  1, 1,0), 
  float4(-1,  1, 0,0), 
  float4(-1, -1, 0,1),  
};

cbuffer Params : register(b0)
{
    float Style;
    float Complexity;
    float Gamma;

    float ScatterDistribution;
    float ScatterLength;
    float ScatterBrightness;
    float Colorize;

    float CoreBrightness;
    float CircularCompletion;
    float CircularCompletionEdge;
    float Time;

    float UseRGSSMultiSampling;

    float TargetWidth;
    float TargetHeight;

    float CompletionAffectsLength;
};

cbuffer Transforms : register(b1)
{
    float4x4 CameraToClipSpace;
    float4x4 ClipSpaceToCamera;
    float4x4 WorldToCamera;
    float4x4 CameraToWorld;
    float4x4 WorldToClipSpace;
    float4x4 ClipSpaceToWorld;
    float4x4 ObjectToWorld;
    float4x4 WorldToObject;
    float4x4 ObjectToCamera;
    float4x4 ObjectToClipSpace;
};

struct psInput
{
    float4 position : SV_POSITION;
    float4 color : COLOR;
    float2 texCoord : TEXCOORD;
    float spriteIndex : COLOR1;
    float rotation: ROTATION;
};


struct Sprite
{
    float2 PosInClipSpace;
    float2 Size;
    float Rotation;
    float4 Color;
    float2 UvMin;
    float2 UvMax;
    float3 __padding;
};

sampler WrappedSampler : register(s0);
sampler ClampedSampler : register(s1);

StructuredBuffer<Sprite> Sprites : t0;
Texture2D<float4> NoiseImage : register(t1);
Texture2D<float4> Gradient : register(t2);

static const float ShimmerStyle = 0;
static const float SparkleStyle = 1;
static const float TextureStyle = 2;

float3 hsb2rgb(float3 c)
{
    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
    return c.z < 0.5 ?
        //float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
        c.z*2 * lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y)
        : lerp(K.xxx, clamp(p - K.xxx, 0.0, 1.0), lerp(c.y, 0, (c.z * 2 - 1) ) );
}




psInput vsMain(uint id: SV_VertexID)
{
    psInput output;
    float discardFactor = 1;
    int cornerIndex = id % 6;
    int particleId = id / 6;
    output.spriteIndex = particleId;
    float4 cornerFactors = Corners[cornerIndex];

    float4 aspect = float4(CameraToClipSpace[1][1] / CameraToClipSpace[0][0],1,1,1);    

    Sprite sprite = Sprites[particleId];

    float2 corner = float2(cornerFactors.x * sprite.Size.x, 
                          cornerFactors.y * sprite.Size.y);


    float imageRotationRad = (-sprite.Rotation - 90) / 180 * PI;     

    float sina = sin(-imageRotationRad - PI/2);
    float cosa = cos(-imageRotationRad - PI/2);

    corner = float2(
        cosa * corner.x - sina * corner.y,
        cosa * corner.y + sina * corner.x 
    );                              

    float2 p = float2( corner.x / aspect.x + sprite.PosInClipSpace.x,
                       corner.y + sprite.PosInClipSpace.y);

    output.position = float4(p, 0,1);
    output.rotation = sprite.Rotation;

    output.texCoord = lerp(sprite.UvMin, sprite.UvMax, cornerFactors.zw);
    output.color = sprite.Color;
    return output;    
}

float remap(float value, float inMin, float inMax, float outMin, float outMax) {
    float factor = (value - inMin) / (inMax - inMin);
    float v = factor * (outMax - outMin) + outMin;
    return v;
}

static const float SimmerComplexitFactor = 100;
static float _rotation = 0;


float4 ComputeShimmer(float2 p, float spriteIndex) {
    float2 Center = 0;

    float d = length(p) * 2;
    float angle = (atan2(p.x, p.y)) / (2*PI)+0.5;

    // Scatter distribution...
    float distributrionComplexity = Complexity / SimmerComplexitFactor;
    float angleForFx = (angle + _rotation/360 + 0.5) % 1;
    float2 noiseAPos = float2(angleForFx * distributrionComplexity +  spriteIndex*0.1, 
                             angleForFx*0.2 + Time*0.1 + spriteIndex * 0.2);

    float4 noiseA =  NoiseImage.SampleLevel(WrappedSampler, noiseAPos, 0.0) * 1;

    float distributionOffset = (noiseA.r - 0.5) * ScatterDistribution / Complexity*2;
    angleForFx += distributionOffset;
    angleForFx %= 1;

    // Noise for other effects
    float4 noiseB =  NoiseImage.SampleLevel(WrappedSampler, float2(
                        angleForFx * Complexity / SimmerComplexitFactor + spriteIndex * 0.2, 
                        angleForFx*0.3 + Time*-0.11 + spriteIndex * 0.13
                        ), 0.0);

    float brightness =  1-pow(d, 1+Gamma);
    
    // Completion
    float c2 = CircularCompletion/720;
    float cEdge = CircularCompletionEdge/720;
    float cc= smoothstep(c2+cEdge, c2, angle) + smoothstep(1-c2- cEdge, 1-c2, angle);    
    brightness *= lerp(1, (noiseB.b), ScatterBrightness) * cc;

    float completionRatio = CircularCompletion/360;
    brightness +=  pow( 1-d, lerp(50, 20, completionRatio) ) * CoreBrightness * pow(completionRatio,0.1);
    brightness = pow(brightness, Gamma);

    // Colorize
    float4 randomColor = float4(noiseB.rbg,1);
    randomColor.xyz /= length(randomColor.xyz);

    
    float4 colorOut = float4(brightness.xxx * lerp(1,randomColor.rgb, Colorize),1);

    float2 uv = float2(d + (noiseB.g - 0.5) * ScatterLength, 0.75);
    colorOut *= Gradient.Sample(ClampedSampler, uv);

    return clamp(colorOut,0,1000);
}




float4 ComputeSparkle(float2 p, float spriteIndex) {
    float2 Center = 0;

    float angle = (atan2(p.x, p.y)) / (2*PI)+0.5;

    float2 noisePos = float2(angle * Complexity/64 +  spriteIndex*0.1, 
                             angle*0.2 + Time*0.1 + spriteIndex * 0.2);

    float4 noiseA =  NoiseImage.SampleLevel(WrappedSampler, noisePos, 0.0) * 1;
    float noiseDistort = (noiseA.r - 0.5) * ScatterDistribution/Complexity;
    angle += noiseDistort;
    
    float c2 = CircularCompletion/720;
    float cEdge = CircularCompletionEdge/720;
    float cc= (smoothstep(c2+cEdge/2, c2-cEdge/2, angle) + smoothstep(1-c2- cEdge/2, 1-c2+cEdge/2, angle));
    
    // return float4(
    //     smoothstep(c2+cEdge/2, c2-cEdge/2, angle),
    //     smoothstep(1-c2- cEdge/2, 1-c2+cEdge/2, angle),
    //     0,1);

    float repeatFraction = 1/Complexity;

    float segments = angle * Complexity;
    float segmentF = segments %  1;
    float segmentIndex = segments - segmentF;

    float mappedGamma = 0.8- Gamma /2;

    float d = length(p) * 2;
    float constantLineWidthOffset =  0.5-  mappedGamma/d;
    float segmentFill = abs(segmentF - 0.5) * 2 + constantLineWidthOffset;

    float filled = smoothstep(mappedGamma + 0.4, mappedGamma, segmentFill);

    float4 segmentNoise =  NoiseImage.SampleLevel(WrappedSampler, float2(
                         (segmentIndex / Complexity*173.1236) %1 + spriteIndex * 0.213 - Time*0.14, 
                         Time*0.2 + segmentIndex *0.14
                         ), 0.0);
                    
    float segmentD = (d + (segmentNoise.r-0.5) * ScatterLength) / lerp(1, cc, CompletionAffectsLength);
    

    float4 gradient= Gradient.Sample(ClampedSampler, float2(1-segmentD, 0.25));
    filled *= 1+ (segmentNoise.r - 0.5) * ScatterBrightness;

    // Colorize
    float4 randomColor = float4(segmentNoise.rbg,1);
    randomColor.xyz /= length(randomColor.xyz);
    gradient.xyz *= lerp(1, randomColor.xyz, Colorize);

    float4 colorOut = gradient * filled;
    colorOut.a *= cc;

    //return float4(randomColor.rgb,1) ;

    //d= gradient.r;    


    // float brightness = pow(1-d,3);
    // brightness *= lerp(1, (noiseB.b), ScatterBrightness) * cc;

    //float completionRatio = CircularCompletion/360;
    //brightness +=  pow(1-d, lerp(50, 20, completionRatio) ) * CoreBrightness * pow(completionRatio,0.1);

    // brightness = pow(brightness, Gamma);
    // float4 colorOut = float4(brightness.xxx * lerp(1,noiseB.rgb, Colorize),1);
    // colorOut *= float4(1,0,0,1);
    //float4 colorOut = float4(x.xxx,1);
    return clamp(colorOut,0,1000);
}


float4 psMain(psInput input) : SV_TARGET
{
    float2 p = input.texCoord;
    p -= 0.5;

    _rotation = input.rotation;
    //return float4(_rotation/360, 0,0,1);

    float4 colorOut =0;
    float d = length(p) * 2;
    if(d > 1)
        return 0;

    if(Style < 0.5) 
    {
        //float4 gradient= Gradient.SampleLevel(WrappedSampler,1-d,0);
        //d= gradient.r;

        if(UseRGSSMultiSampling) 
        {
            // 4x rotated grid
            float4 offsets[2];
            offsets[0] = float4(-0.375, 0.125, 0.125, 0.375);
            offsets[1] = float4(0.375, -0.125, -0.125, -0.375);
            
            float2 sxy = float2(TargetWidth, TargetHeight);
            
            float4 colorOut4 = ComputeShimmer(p + offsets[0].xy / sxy, input.spriteIndex)+
                            ComputeShimmer(p + offsets[0].zw / sxy, input.spriteIndex)+
                            ComputeShimmer(p + offsets[1].xy / sxy, input.spriteIndex)+
                            ComputeShimmer(p + offsets[1].zw / sxy, input.spriteIndex);

            float4 colorOutB = colorOut4 /4 * input.color;
            return clamp(float4(colorOutB.rgb, colorOutB.a), 0, float4(1000,1000,1000,1));
        }

        colorOut = ComputeShimmer(p, input.spriteIndex) * input.color;
    }
    else {
        float4 gradient= Gradient.SampleLevel(WrappedSampler,1-d,0);
        d= gradient.r;

        if(UseRGSSMultiSampling) 
        {
            // 4x rotated grid
            float4 offsets[2];
            offsets[0] = float4(-0.375, 0.125, 0.125, 0.375);
            offsets[1] = float4(0.375, -0.125, -0.125, -0.375);
            
            float2 sxy = float2(TargetWidth, TargetHeight);
            
            float4 colorOut4 = ComputeSparkle(p + offsets[0].xy / sxy, input.spriteIndex)+
                            ComputeSparkle(p + offsets[0].zw / sxy, input.spriteIndex)+
                            ComputeSparkle(p + offsets[1].xy / sxy, input.spriteIndex)+
                            ComputeSparkle(p + offsets[1].zw / sxy, input.spriteIndex);

            float4 colorOutB = colorOut4 * input.color /4;
            return clamp(float4(colorOutB.rgb, colorOutB.a), 0, float4(1000,1000,1000,1));
        }

        colorOut = ComputeSparkle(p, input.spriteIndex) * input.color;
    }

    return clamp(float4(colorOut.rgb, colorOut.a), 0, float4(1000,1000,1000,1));
}