apply method

@override void apply(Skeleton skeleton, double lastTime, double time, List<Event?> events, double alpha, MixPose pose, MixDirection direction,)

Implementation

@override
void apply(Skeleton skeleton, double lastTime, double time,
    List<Event?> events, double alpha, MixPose pose, MixDirection direction) {
  final Slot slot = skeleton.slots[slotIndex];
  final Attachment? slotAttachment = slot.getAttachment();

  if (slotAttachment is! VertexAttachment) return;

  final VertexAttachment vertexAttachment = slotAttachment;
  if (vertexAttachment.applyDeform(attachment) == false) return;

  final List<double> verticesArray =
      List<double>.from(slot.attachmentVertices);
  if (verticesArray.isEmpty) alpha = 1.0;

  final List<Float32List?> frameVertices = this.frameVertices;
  final int vertexCount = frameVertices[0]!.length;

  final Float32List frames = this.frames;
  if (time < frames[0]) {
    if (pose == MixPose.setup) {
      verticesArray.length = 0;
    } else if (pose == MixPose.current) {
      if (alpha == 1) {
        verticesArray.length = 0;
        return;
      }
      final Float32List vertices = Float32List.fromList(
          ArrayUtils.copyWithNewArraySize(
              verticesArray, vertexCount, double.infinity));
      if (vertexAttachment.bones == null) {
        // Unweighted vertex positions.
        final Float32List setupVertices = vertexAttachment.vertices!;
        for (int i = 0; i < vertexCount; i++) {
          vertices[i] += (setupVertices[i] - vertices[i]) * alpha;
        }
      } else {
        // Weighted deform offsets.
        alpha = 1 - alpha;
        for (int i = 0; i < vertexCount; i++) {
          vertices[i] *= alpha;
        }
      }
    }
    return;
  }

  Float32List vertices = Float32List.fromList(ArrayUtils.copyWithNewArraySize(
      verticesArray, vertexCount, double.infinity));
  if (time >= frames[frames.length - 1]) {
    // Time is after last frame.
    final Float32List lastVertices = frameVertices[frames.length - 1]!;
    if (alpha == 1) {
      vertices = Float32List.fromList(ArrayUtils.arrayCopyWithGrowth(
          lastVertices, 0, vertices, 0, vertexCount, double.infinity));
    } else if (pose == MixPose.setup) {
      if (vertexAttachment.bones == null) {
        // Unweighted vertex positions, with alpha.
        final Float32List setupVertices = vertexAttachment.vertices!;
        for (int i = 0; i < vertexCount; i++) {
          final double setup = setupVertices[i];
          vertices[i] = setup + (lastVertices[i] - setup) * alpha;
        }
      } else {
        // Weighted deform offsets, with alpha.
        for (int i = 0; i < vertexCount; i++) {
          vertices[i] = lastVertices[i] * alpha;
        }
      }
    } else {
      for (int i = 0; i < vertexCount; i++) {
        vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
      }
    }
    return;
  }

  // Interpolate between the previous frame and the current frame.
  final int frame = Animation.binarySearch(frames, time);
  final Float32List? prevVertices = frameVertices[frame - 1];
  final Float32List? nextVertices = frameVertices[frame];
  final double frameTime = frames[frame];
  final double percent = getCurvePercent(
      frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));

  if (alpha == 1) {
    for (int i = 0; i < vertexCount; i++) {
      final double prev = prevVertices![i];
      vertices[i] = prev + (nextVertices![i] - prev) * percent;
    }
  } else if (pose == MixPose.setup) {
    if (vertexAttachment.bones == null) {
      // Unweighted vertex positions, with alpha.
      final Float32List? setupVertices = vertexAttachment.vertices;
      for (int i = 0; i < vertexCount; i++) {
        final double prev = prevVertices![i], setup = setupVertices![i];
        vertices[i] = setup +
            (prev + (nextVertices![i] - prev) * percent - setup) * alpha;
      }
    } else {
      // Weighted deform offsets, with alpha.
      for (int i = 0; i < vertexCount; i++) {
        final double prev = prevVertices![i];
        vertices[i] = (prev + (nextVertices![i] - prev) * percent) * alpha;
      }
    }
  } else {
    // Vertex positions or deform offsets, with alpha.
    for (int i = 0; i < vertexCount; i++) {
      final double prev = prevVertices![i];
      vertices[i] +=
          (prev + (nextVertices![i] - prev) * percent - vertices[i]) * alpha;
    }
  }
}