flushBuffer method

void flushBuffer()

Implementation

void flushBuffer() {
  batchesRendered++;

  if (this.bufferIndex == 0)
    return;

  var flushIndex = 0;

  final bufferDst = this.bufferDst;
  final bufferSrc = this.bufferSrc;
  final bufferClr = this.bufferClr;
  final image = this.bufferImage;
  final blendMode = this.bufferBlendMode;
  final paint = this.paint;
  final canvas = this.canvas;

  final bufferIndex = this.bufferIndex;

  while (flushIndex < bufferIndex) {
    final remaining = bufferIndex - flushIndex;
    assert (remaining > 0);

    if (remaining == 1) {
      final f = flushIndex << 2;
      _bufferClr1[0] = bufferClr[flushIndex];
      _bufferDst1.setRange(0, 4, bufferDst, f);
      _bufferSrc1.setRange(0, 4, bufferSrc, f);
      canvas.drawRawAtlas(
        image,
        _bufferDst1,
        _bufferSrc1,
        _bufferClr1,
        blendMode,
        null,
        paint,
      );
      this.bufferIndex = 0;
      batches1Rendered++;
      return;
    }

    if (remaining < 4) {
      for (var i = 0; i < 2; i++) {
        final start = i << 2;
        final end = start + 4;
        final f = flushIndex << 2;
        _bufferClr2[i] = bufferClr[flushIndex];
        _bufferDst2.setRange(start, end, bufferDst, f);
        _bufferSrc2.setRange(start, end, bufferSrc, f);
        flushIndex++;
      }
      canvas.drawRawAtlas(
        image,
        _bufferDst2,
        _bufferSrc2,
        _bufferClr2,
        blendMode,
        null,
        paint,
      );
      batches2Rendered++;
      continue;
    }

    if (remaining < 8) {
      final clr = _bufferClr4;
      final dst = _bufferDst4;
      final src = _bufferSrc4;
      for (var i = 0; i < 4; i++) {
        final start = i << 2;
        final end = start + 4;
        final f = flushIndex << 2;
        clr[i] = bufferClr[flushIndex];
        dst.setRange(start, end, bufferDst, f);
        src.setRange(start, end, bufferSrc, f);
        flushIndex++;
      }
      canvas.drawRawAtlas(
        image,
        dst,
        src,
        clr,
        blendMode,
        null,
        paint,
      );
      batches4Rendered++;
      continue;
    }

    if (remaining < 16) {
      final clr = _bufferClr8;
      final dst = _bufferDst8;
      final src = _bufferSrc8;
      for (var i = 0; i < 8; i++) {
        final start = i << 2;
        final end = start + 4;
        final f = flushIndex << 2;
        clr[i] = bufferClr[flushIndex];
        dst.setRange(start, end, bufferDst, f);
        src.setRange(start, end, bufferSrc, f);
        flushIndex++;
      }
      canvas.drawRawAtlas(
        image,
        dst,
        src,
        clr,
        blendMode,
        null,
        paint,
      );
      batches8Rendered++;
      continue;
    }

    if (remaining < 32) {
      final clr = _bufferClr16;
      final dst = _bufferDst16;
      final src = _bufferSrc16;
      for (var i = 0; i < 16; i++) {
        final start = i << 2;
        final end = start + 4;
        final f = flushIndex << 2;
        clr[i] = bufferClr[flushIndex];
        dst.setRange(start, end, bufferDst, f);
        src.setRange(start, end, bufferSrc, f);
        flushIndex++;
      }
      canvas.drawRawAtlas(
        image,
        dst,
        src,
        clr,
        blendMode,
        null,
        paint,
      );
      batches16Rendered++;
      continue;
    }

    if (remaining < 64) {
      final clr = _bufferClr32;
      final dst = _bufferDst32;
      final src = _bufferSrc32;
      for (var i = 0; i < 32; i++) {
        final start = i << 2;
        final end = start + 4;
        final f = flushIndex << 2;
        clr[i] = bufferClr[flushIndex];
        dst.setRange(start, end, bufferDst, f);
        src.setRange(start, end, bufferSrc, f);
        flushIndex++;
      }
      canvas.drawRawAtlas(
        image,
        dst,
        src,
        clr,
        blendMode,
        null,
        paint,
      );
      batches32Rendered++;
      continue;
    }

    if (remaining < 128) {
      final dst64 = _bufferDst64;
      final src64 = _bufferSrc64;
      final clr64 = _bufferClr64;
      for (var i = 0; i < 64; i++) {
        final start = i << 2;
        final end = start + 4;
        final f = flushIndex << 2;
        clr64[i] = bufferClr[flushIndex];
        dst64.setRange(start, end, bufferDst, f);
        src64.setRange(start, end, bufferSrc, f);
        flushIndex++;
      }
      canvas.drawRawAtlas(
        image,
        dst64,
        src64,
        clr64,
        blendMode,
        null,
        paint,
      );
      batches64Rendered++;
      continue;
    }

    throw Exception();
  }
  this.bufferIndex = 0;
}