effect <-
  RuntimeEffect$make(R"{
    // modified from <https://glslsandbox.com/e#109306.1>
    uniform shader image;
    uniform float time;
    uniform vec2 resolution;

    half4 main(vec2 fragCoord) {
      vec2 p = (fragCoord.xy * 2.0 - resolution) / min(resolution.x, resolution.y);
      float lambda = time*2.5;
      float t = 0.02/abs(tan(lambda) - length(p));
      vec2 something = vec2(1., (sin(time)+ 1.)*0.5);
      float dotProduct = dot(vec2(t),something)/length(p);
      return vec4(vec3(dotProduct), 1.0);
    }
  }")

# skiagd does not use any graphics devices to create images,
# however, we can still open a graphics device to define the canvas size.
ragg::agg_png(tempfile(), width = 848, height = 480)

size <- dev_size()
duration_in_frames <- 25 * 6
cv <- canvas("transparent")

for (frame in seq_len(duration_in_frames)) {
  imgf <-
    ImageFilter$runtime_shader(
      effect,
      uniforms = list(
        time = (frame - 1) / 25,
        resolution = as.double(size)
      )
    )

  cv |>
    add_rect(
      matrix(c(0, 0, size), ncol = 4),
      props = paint(
        color = "gray",
        image_filter = imgf
      )
    ) |>
    add_rect(
      matrix(c(0, 0, size), ncol = 4),
      props = paint(
        color = "#0000bb66",
        blend_mode = BlendMode$Exclusion
      )
    ) |>
    as_png() |>
    writeBin(sprintf("temp/pictures/test%03d.png", frame))
}
dev.off()

// kind=shader
uniform shader texture;
uniform vec2 iResolution;
uniform vec2 curvature;
uniform vec2 scanLineOpacity;
uniform float vignetteOpacity;
uniform float brightness;
uniform float vignetteRoundness;

const float PI = 3.1415926538;

vec2 curveRemapUV(vec2 uv)
{
    // as we near the edge of our screen apply greater distortion using a sinusoid.
    uv = uv * 2.0 - 1.0;
    vec2 offset = abs(uv.yx) / vec2(curvature.x, curvature.y);
    uv = uv + uv * offset * offset;
    uv = uv * 0.5 + 0.5;
    return uv;
}

vec4 scanLineIntensity(float uv, float resolution, float opacity)
{
    float intensity = sin(uv * resolution * PI * 2.0);
    intensity = ((0.5 * intensity) + 0.5) * 0.9 + 0.1;
    return vec4(vec3(pow(intensity, opacity)), 1.0);
}

vec4 vignetteIntensity(vec2 uv, vec2 resolution, float opacity, float roundness)
{
    float intensity = uv.x * uv.y * (1.0 - uv.x) * (1.0 - uv.y);
    return vec4(vec3(clamp(pow((resolution.x / roundness) * intensity, opacity), 0.0, 1.0)), 1.0);
}

vec4 main(vec2 fragCoord)
{
    vec2 vUV = fragCoord / iResolution;
    vec2 remappedUV = curveRemapUV(vec2(vUV.x, vUV.y));
    vec4 baseColor = texture.eval(remappedUV);
    vec2 screenResolution = iResolution / 6;

    baseColor *= vignetteIntensity(remappedUV, screenResolution, vignetteOpacity, vignetteRoundness);

    baseColor *= scanLineIntensity(remappedUV.x, screenResolution.x, scanLineOpacity.x);
    baseColor *= scanLineIntensity(remappedUV.y, screenResolution.y, scanLineOpacity.y);

    baseColor *= vec4(vec3(brightness), 1.0);

    if (remappedUV.x < 0.0 || remappedUV.y < 0.0 || remappedUV.x > 1.0 || remappedUV.y > 1.0) {
        return vec4(0.0, 0.0, 0.0, 1.0);
    } else {
        return baseColor;
    }
}