#include <flutter/runtime_effect.glsl>

// 0..1 : canvas size in logical px
uniform vec2  u_size;
// 2    : how many circles to draw (as float)
uniform float uCount;
// 3..10: up to 8 radii in logical px
uniform float uRadii[8];

out vec4 fragColor;

// draw a red circle with hard edge
vec4 drawCircle(vec2 p, vec2 center, float r) {
    float m = step(length(p - center), r);
    return vec4(1.0, 0.0, 0.0, m);
}

void main() {
    vec2 p   = FlutterFragCoord().xy;       // logical px
    float cy = 0.5 * u_size.y;              // vertical center
    vec4 col = vec4(0.0);

    // loop unrolled to max 8
    for (int i = 0; i < 8; i++) {
        if (float(i) < uCount) {
            // evenly spaced X
            float cx = (float(i) + 1.0) / (uCount + 1.0) * u_size.x;
            float r  = uRadii[i];
            col = max(col, drawCircle(p, vec2(cx, cy), r));
        }
    }

    fragColor = col;
}

import 'dart:ui';
import 'package:flutter/material.dart';

void main() => runApp(const MaterialApp(home: LogicalCirclesDemo()));

class LogicalCirclesDemo extends StatefulWidget {
  const LogicalCirclesDemo({super.key});
  @override
  State<LogicalCirclesDemo> createState() => _LogicalCirclesDemoState();
}

class _LogicalCirclesDemoState extends State<LogicalCirclesDemo> {
  late final FragmentProgram _prog;
  bool _ready = false;

  // your desired radii in **logical** pixels:
  final List<double> _radii = [50, 30, 70, 40, 60];

  @override
  void initState() {
    super.initState();
    FragmentProgram.fromAsset('shaders/circle.frag')
      .then((p) => setState(() {
        _prog = p;
        _ready = true;
      }));
  }

  @override
  Widget build(BuildContext context) {
    if (!_ready) {
      return const Scaffold(
        body: Center(child: CircularProgressIndicator()),
      );
    }

    // **Logical** size of the canvas:
    final sizeLogical = MediaQuery.of(context).size;

    return Scaffold(
      body: CustomPaint(
        size: sizeLogical,
        painter: _LogicalCirclesPainter(
          program: _prog,
          size:    sizeLogical,
          radii:   _radii,
        ),
      ),
    );
  }
}

class _LogicalCirclesPainter extends CustomPainter {
  final FragmentProgram program;
  final Size           size;
  final List<double>   radii;

  _LogicalCirclesPainter({
    required this.program,
    required this.size,
    required this.radii,
  });

  @override
  void paint(Canvas canvas, Size _) {
    // configure the shader with **logical** dimensions
    final shader = program.fragmentShader()
      // u_size.xy in logical px
      ..setFloat(0, size.width)
      ..setFloat(1, size.height)
      // uCount
      ..setFloat(2, radii.length.toDouble());

    // uRadius0..uRadius7 → slots 3..10
    for (int i = 0; i < radii.length && i < 8; i++) {
      shader.setFloat(3 + i, radii[i]);
    }
    // zero out any unused
    for (int i = radii.length; i < 8; i++) {
      shader.setFloat(3 + i, 0.0);
    }

    // draw a full‐screen quad in logical space:
    final paint = Paint()..shader = shader;
    canvas.drawRect(Offset.zero & size, paint);
  }

  @override
  bool shouldRepaint(covariant CustomPainter old) => false;
}