let centerY;

let radius;

let dotRadiusMin = 2.5;

let dotRadiusMax = 7.5;

let powerBase = 1.6;

let allDots;

let intersection0X;

let intersection0Y;

let intersection1X;

let intersection1Y;

​

function setup()

{

  createCanvas(400, 400);

  fill(40);

  Begin();

}

​

function keyPressed()

{

  if (keyCode === 32)

    Begin();

}

​

function draw()

{

  if (allDots === undefined)

    return;

  if (movedX === 0 && movedY === 0)

    return;

  SegmentVsCircle(pmouseX, pmouseY, mouseX, mouseY);

  if (intersection0X !== undefined)  // no need to check both

    AttemptDrawPoint(intersection0X, intersection0Y);

  if (intersection1X !== undefined)  // no need to check both

    AttemptDrawPoint(intersection1X, intersection1Y);

  AttemptDrawPoint(mouseX, mouseY);

}

​

function Begin()

{

  blendMode(BLEND);

  background(40);

  blendMode(ADD);

  allDots = new Set();

  centerX = 400 * Math.random();

  centerY = 400 * Math.random();

  radius = (200 - 10) * Math.random() + 10;

}

​

function AttemptDrawPoint(x, y)

{

  if (x < 0 || y < 0 || x >= width || y >= height)

    return;

  let key = y * width + x;

  if (allDots.has(key))

    return;

  allDots.add(key);

  DrawPoint(x, y);

}

​

function DrawPoint(x, y)

{

  let distance = dist(centerX, centerY, x, y);

  let delta = abs(distance - radius);

  let alpha = pow(powerBase, -delta);

  stroke(alpha * 250, alpha * 180, alpha * 50);

  strokeWeight( (dotRadiusMax - dotRadiusMin) * Math.random() + dotRadiusMin);

  point(x, y);

}

​

function SegmentVsCircle(startX, startY, endX, endY)

{

  let diffX = endX - startX;

  let diffY = endY - startY;

  let segmentLength = sqrt(diffX * diffX + diffY * diffY);

  let dX = diffX / segmentLength;

  let dY = diffY / segmentLength;

  let mX = startX - centerX;

  let mY = startY - centerY;

  let mDotD = mX * dX + mY * dY;

  let mSq = mX * mX + mY * mY;

  let rSq = radius * radius;

  let a = dX * dX + dY * dY;

  let b = 2 * mDotD;

  let c = mSq - rSq;

  let discriminant = b * b - 4 * a * c;

  if (discriminant < 0)

  {

    intersection0X = undefined;

    intersection0Y = undefined;

    intersection1X = undefined;

    intersection1Y = undefined;

    return;

  }

  if (discriminant === 0)

  {

    intersection1X = undefined;

    intersection1Y = undefined;

    let t = -b / (2 * a);

    if (t < 0 || t > segmentLength)

    {

      intersection0X = undefined;

      intersection0Y = undefined;

      return;

    }

    intersection0X = int(startX + t * dX);

    intersection0Y = int(startY + t * dY);

    return;

  }

  let root = sqrt(discriminant);

  let denominator = 2 * a;

  let t0 = (-b + root) / denominator;

  let t1 = (-b - root) / denominator;

  if (t0 < 0 || t0 > segmentLength)

  {

    intersection0X = undefined;

    intersection0Y = undefined;

  }

  else

  {

    intersection0X = int(startX + t0 * dX);

    intersection0Y = int(startY + t0 * dY);

  }

  if (t1 < 0 || t1 > segmentLength)

  {

    intersection1X = undefined;

    intersection1Y = undefined;

  }

  else

  {

    intersection1X = int(startX + t1 * dX);

    intersection1Y = int(startY + t1 * dY);

  }

}

​