Function prepare

src/renderers/createScatterRenderer.ts:258–340

(seriesConfig, data, xScale, yScale, gridArea)

  };

  const prepare: ScatterRenderer['prepare'] = (seriesConfig, data, xScale, yScale, gridArea) => {
    assertNotDisposed();

    const { xMin, xMax, yMin, yMax } = computeDataBounds(data);
    const { a: ax, b: bx } = computeClipAffineFromScale(xScale, xMin, xMax);
    const { a: ay, b: by } = computeClipAffineFromScale(yScale, yMin, yMax);

    if (gridArea) {
      lastCanvasWidth = gridArea.canvasWidth;
      lastCanvasHeight = gridArea.canvasHeight;
      writeVsUniforms(ax, bx, ay, by, gridArea.canvasWidth, gridArea.canvasHeight);
      lastScissor = computePlotScissorDevicePx(gridArea);
    } else {
      // Backward-compatible: keep rendering with the last known viewport (or safe default).
      writeVsUniforms(ax, bx, ay, by, lastViewportPx[0], lastViewportPx[1]);
      lastScissor = null;
    }

    const [r, g, b, a] = parseSeriesColorToRgba01(seriesConfig.color);
    fsUniformScratchF32[0] = r;
    fsUniformScratchF32[1] = g;
    fsUniformScratchF32[2] = b;
    fsUniformScratchF32[3] = clamp01(a);
    writeUniformBuffer(device, fsUniformBuffer, fsUniformScratchF32);

    const dpr = gridArea?.devicePixelRatio ?? 1;
    const hasValidDpr = dpr > 0 && Number.isFinite(dpr);

    const seriesSymbolSize = seriesConfig.symbolSize;
    const getSeriesSizeCssPx =
      typeof seriesSymbolSize === 'function'
        ? (point: DataPoint): number => {
            const v = seriesSymbolSize(toScatterTuple(point));
            return typeof v === 'number' && Number.isFinite(v) ? v : DEFAULT_SCATTER_RADIUS_CSS_PX;
          }
        : typeof seriesSymbolSize === 'number' && Number.isFinite(seriesSymbolSize)
          ? (): number => seriesSymbolSize
          : (): number => DEFAULT_SCATTER_RADIUS_CSS_PX;

    ensureCpuInstanceCapacityFloats(data.length * INSTANCE_STRIDE_FLOATS);
    const f32 = cpuInstanceStagingF32;
    let outFloats = 0;

    for (let i = 0; i < data.length; i++) {
      const p = data[i];
      const { x, y } = getPointXY(p);
      if (!Number.isFinite(x) || !Number.isFinite(y)) continue;

      const sizeCss = getPointSizeCssPx(p) ?? getSeriesSizeCssPx(p);
      const radiusCss = Number.isFinite(sizeCss) ? Math.max(0, sizeCss) : DEFAULT_SCATTER_RADIUS_CSS_PX;
      const radiusDevicePx = hasValidDpr ? radiusCss * dpr : radiusCss;
      if (!(radiusDevicePx > 0)) continue;

      f32[outFloats + 0] = x;
      f32[outFloats + 1] = y;
      f32[outFloats + 2] = radiusDevicePx;
      f32[outFloats + 3] = 0; // pad
      outFloats += INSTANCE_STRIDE_FLOATS;