build method

SlugBatchData? build([ int flushOrdinal = 0 ])

Implementation

SlugBatchData? build([int flushOrdinal = 0]) {
  if (_quadCount == 0) return null;
  final slotCount = _slotData.length;
  var total = 4 * slotCount;
  final bases = Int32List(slotCount);
  for (var i = 0; i < slotCount; i++) {
    bases[i] = total;
    total += _slotData[i].texelCount;
  }
  final height = math.max(1, (total + slugAtlasWidth - 1) ~/ slugAtlasWidth);
  final pixels = Uint8List(slugAtlasWidth * height * 4);
  final u16 = ByteData.sublistView(pixels);
  void put(int texel, int lo, int hi) {
    u16.setUint16(texel * 4, lo, Endian.little);
    u16.setUint16(texel * 4 + 2, hi, Endian.little);
  }

  for (var i = 0; i < slotCount; i++) {
    final d = _slotData[i];
    final base = bases[i];
    put(4 * i, base & 0xFFFF, base >> 16);
    put(4 * i + 1, emToFixed(d.minY),
        emToFixed((d.maxY - d.minY) / d.bandCount));
    put(4 * i + 2, emToFixed(d.minX),
        emToFixed((d.maxX - d.minX) / d.bandCount));
    put(4 * i + 3, _slotQsx[i], _slotQsy[i]);
    pixels.setRange(base * 4, base * 4 + d.stream!.length, d.stream!);
  }

  final positions = _positions.view;
  final texs = _texs.view;
  final cellH = (_maxCellH + 2).ceilToDouble();
  for (var q = 0; q < _quadCount; q++) {
    final vBase = _quadSlot[q] * cellH;
    final t = q * 8;
    texs[t + 1] += vBase;
    texs[t + 3] += vBase;
    texs[t + 5] += vBase;
    texs[t + 7] += vBase;
  }
  final chunks = <SlugChunkData>[];
  for (var start = 0; start < _quadCount; start += slugMaxQuadsPerDraw) {
    final count = math.min(slugMaxQuadsPerDraw, _quadCount - start);
    final pos = Float32List.fromList(
        Float32List.sublistView(positions, start * 8, (start + count) * 8));
    final tex = Float32List.fromList(
        Float32List.sublistView(texs, start * 8, (start + count) * 8));
    final colors =
        Int32List.fromList(_colors.sublist(start * 4, (start + count) * 4));
    final indices = Uint16List(count * 6);
    for (var q = 0; q < count; q++) {
      final v = q * 4, ix = q * 6;
      indices[ix] = v;
      indices[ix + 1] = v + 1;
      indices[ix + 2] = v + 2;
      indices[ix + 3] = v + 1;
      indices[ix + 4] = v + 3;
      indices[ix + 5] = v + 2;
    }
    chunks.add(SlugChunkData(pos, tex, colors, indices));
  }
  final batch = SlugBatchData(flushOrdinal, chunks, pixels, slugAtlasWidth,
      height, _quadCount, cellH);
  _slots.clear();
  _slotData.clear();
  _slotQsx.clear();
  _slotQsy.clear();
  _positions.clear();
  _texs.clear();
  _colors.clear();
  _quadSlot.clear();
  _maxCellH = 0;
  _quadCount = 0;
  _minPX = _minPY = double.infinity;
  _maxPX = _maxPY = double.negativeInfinity;
  return batch;
}