@haiyue/extensions 0.1.0 → 0.2.0

package/src/spine/SpineSkeletonRuntime.ts

@@ -1,521 +0,0 @@
-import { EngineError, EngineErrorCode } from '@haiyue/engine';
-import { ErrorDomain, ErrorRecovery } from '@haiyue/engine/core';
-
-export interface BoneData {
-  name: string;
-  parent?: string;
-  inherit?: string;
-  x: number;
-  y: number;
-  rotation: number;
-  shearX: number;
-  shearY: number;
-  scaleX: number;
-  scaleY: number;
-  length: number;
-}
-
-export interface IkConstraintData {
-  name: string;
-  order: number;
-  skin: boolean;
-  bones: string[];
-  target: string;
-  mix: number;
-  softness: number;
-  bendPositive: boolean;
-}
-
-export interface TransformConstraintData {
-  name: string;
-  order: number;
-  skin: boolean;
-  bones: string[];
-  target: string;
-  rotation: number;
-  x: number;
-  y: number;
-  scaleX: number;
-  scaleY: number;
-  shearY: number;
-  mixRotate: number;
-  mixX: number;
-  mixY: number;
-  mixScaleX: number;
-  mixScaleY: number;
-  mixShearY: number;
-  localSource: boolean;
-  localTarget: boolean;
-  additive: boolean;
-}
-
-export interface PathConstraintData {
-  name: string;
-  order: number;
-  skin: boolean;
-  bones: string[];
-  slot: string;
-  position: number;
-  spacing: number;
-  mixRotate: number;
-  mixX: number;
-  mixY: number;
-  positionMode: string;
-  spacingMode: string;
-  rotateMode: string;
-  offsetRotation: number;
-}
-
-export interface SliderConstraintData {
-  name: string;
-  order: number;
-  skin: boolean;
-  animation: string;
-  bone?: string;
-  property: string;
-  scale: number;
-  offset: number;
-  loop: boolean;
-  local: boolean;
-  mix: number;
-}
-
-export interface SlotData {
-  name: string;
-  bone: string;
-  attachment?: string;
-  color?: [number, number, number, number];
-  blend: 'normal' | 'additive' | string;
-}
-
-export interface RegionAttachment {
-  type?: string;
-  name: string;
-  path: string;
-  x: number;
-  y: number;
-  rotation: number;
-  scaleX: number;
-  scaleY: number;
-  width: number;
-  height: number;
-  color?: [number, number, number, number];
-  uvs?: number[];
-  triangles?: number[];
-  vertices?: number[];
-  vertexCount?: number;
-  lengths?: number[];
-  sequence?: { count?: number; start?: number; digits?: number; setup?: number };
-  closed?: boolean;
-  constantSpeed?: boolean;
-  end?: string;
-  skin?: string;
-  source?: string;
-}
-
-export interface SpineAnimationBoneTimelines {
-  rotate?: unknown[];
-  translate?: unknown[];
-  scale?: unknown[];
-  shear?: unknown[];
-  [timeline: string]: unknown;
-}
-
-export interface SpineAnimationData {
-  bones?: Record<string, SpineAnimationBoneTimelines>;
-  slots?: Record<string, {
-    attachment?: Array<{ time?: number; name?: string | null }>;
-    rgba?: unknown[];
-    [timeline: string]: unknown;
-  }>;
-  attachments?: Record<string, Record<string, Record<string, { sequence?: unknown[] }>>>;
-  ik?: Record<string, unknown[]>;
-  transform?: Record<string, unknown[]>;
-  path?: Record<string, unknown[]>;
-  slider?: Record<string, { mix?: unknown[] }>;
-  drawOrder?: Array<{ time?: number; offsets?: Array<{ slot: string; offset?: number }> }>;
-  [timeline: string]: unknown;
-}
-
-export interface SpineData {
-  bones: BoneData[];
-  ik: IkConstraintData[];
-  transform: TransformConstraintData[];
-  path: PathConstraintData[];
-  sliders: SliderConstraintData[];
-  slots: SlotData[];
-  skins: Record<string, Record<string, Record<string, RegionAttachment>>>;
-  skinConstraints: Record<string, { ik: string[]; transform: string[]; path: string[]; slider: string[] }>;
-  animations: Record<string, SpineAnimationData>;
-}
-
-export interface BonePose {
-  data: BoneData;
-  a: number;
-  b: number;
-  c: number;
-  d: number;
-  worldX: number;
-  worldY: number;
-  rotation: number;
-  shearX: number;
-  shearY: number;
-  x: number;
-  y: number;
-  scaleX: number;
-  scaleY: number;
-}
-
-export interface SliderAnimationState {
-  animation: string;
-  time: number;
-  loop: boolean;
-  mix: number;
-}
-
-export function normalizeSpineData(input: unknown): SpineData {
-  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
-    throw invalidSpineData('Spine JSON root must be an object.', 'spine');
-  }
-  const record = input as Record<string, unknown>;
-  if (!Array.isArray(record.bones)) throw invalidSpineData('Spine JSON bones must be an array.', 'spine.bones');
-  if (!Array.isArray(record.slots)) throw invalidSpineData('Spine JSON slots must be an array.', 'spine.slots');
-  for (const [index, bone] of record.bones.entries()) {
-    if (typeof bone !== 'object' || bone === null || typeof (bone as Record<string, unknown>).name !== 'string') {
-      throw invalidSpineData(`Spine bone ${index} must include a string name.`, `spine.bones[${index}].name`);
-    }
-  }
-  for (const [index, slot] of record.slots.entries()) {
-    if (typeof slot !== 'object' || slot === null || typeof (slot as Record<string, unknown>).name !== 'string') {
-      throw invalidSpineData(`Spine slot ${index} must include a string name.`, `spine.slots[${index}].name`);
-    }
-  }
-  return normalizeValidatedSpineData(record as unknown as SpineSourceDocument);
-}
-
-// Spine JSON is an open, version-dependent third-party schema. Dynamic access is
-// intentionally confined to this normalization adapter; domain code consumes SpineData.
-function normalizeValidatedSpineData(input: SpineSourceDocument): SpineData {
-  const skins: SpineData['skins'] = {};
-  const skinConstraints: SpineData['skinConstraints'] = {};
-  if (Array.isArray(input.skins)) {
-    for (const skin of input.skins) {
-      const name = skin.name || 'default';
-      skins[name] = normalizeSkinAttachments(skin.attachments);
-      skinConstraints[name] = {
-        ik: skin.ik ?? [],
-        transform: skin.transform ?? [],
-        path: skin.path ?? [],
-        slider: skin.slider ?? skin.sliders ?? [],
-      };
-    }
-  } else {
-    for (const [name, attachments] of Object.entries(input.skins ?? {})) {
-      skins[name] = normalizeSkinAttachments(attachments);
-    }
-    for (const name of Object.keys(skins)) skinConstraints[name] = { ik: [], transform: [], path: [], slider: [] };
-  }
-  resolveLinkedMeshes(skins);
-  const constraints = Array.isArray(input.constraints)
-    ? input.constraints.map((constraint, index) => ({ ...constraint, __order: index }))
-    : null;
-  const ikConstraints = constraints
-    ? constraints.filter(constraint => constraint.type === 'ik')
-    : (input.ik ?? []);
-  const transformConstraints = constraints
-    ? constraints.filter(constraint => constraint.type === 'transform')
-    : (input.transform ?? []);
-  const pathConstraints = constraints
-    ? constraints.filter(constraint => constraint.type === 'path')
-    : (input.path ?? []);
-  const sliderConstraints = constraints
-    ? constraints.filter(constraint => constraint.type === 'slider')
-    : (input.sliders ?? input.slider ?? []);
-  return {
-    bones: (input.bones ?? []).map(bone => ({
-      name: bone.name,
-      ...(bone.parent === undefined ? {} : { parent: bone.parent }),
-      ...(bone.inherit === undefined ? {} : { inherit: bone.inherit }),
-      x: bone.x ?? 0,
-      y: bone.y ?? 0,
-      rotation: bone.rotation ?? 0,
-      shearX: bone.shearX ?? 0,
-      shearY: bone.shearY ?? 0,
-      scaleX: bone.scaleX ?? 1,
-      scaleY: bone.scaleY ?? 1,
-      length: bone.length ?? 0,
-    })),
-    ik: ikConstraints.map((constraint, index) => ({
-      name: constraint.name,
-      order: constraint.order ?? constraint.__order ?? index,
-      skin: constraint.skin ?? false,
-      bones: constraint.bones ?? [],
-      target: constraint.target ?? constraint.source ?? '',
-      mix: constraint.mix ?? 1,
-      softness: constraint.softness ?? 0,
-      bendPositive: constraint.bendPositive ?? true,
-    })),
-    transform: transformConstraints.map((constraint, index) => ({
-      name: constraint.name,
-      order: constraint.order ?? constraint.__order ?? index,
-      skin: constraint.skin ?? false,
-      bones: constraint.bones ?? [],
-      target: constraint.target ?? constraint.source ?? '',
-      rotation: constraint.rotation ?? 0,
-      x: constraint.x ?? 0,
-      y: constraint.y ?? 0,
-      scaleX: constraint.scaleX ?? 0,
-      scaleY: constraint.scaleY ?? 0,
-      shearY: constraint.shearY ?? 0,
-      ...normalizeTransformMixes(constraint),
-      localSource: constraint.localSource ?? false,
-      localTarget: constraint.localTarget ?? false,
-      additive: constraint.additive ?? false,
-    })),
-    path: pathConstraints.map((constraint, index) => ({
-      name: constraint.name,
-      order: constraint.order ?? constraint.__order ?? index,
-      skin: constraint.skin ?? false,
-      bones: constraint.bones ?? [],
-      slot: constraint.slot ?? '',
-      position: constraint.position ?? 0,
-      spacing: constraint.spacing ?? 0,
-      mixRotate: constraint.mixRotate ?? 1,
-      mixX: constraint.mixX ?? 1,
-      mixY: constraint.mixY ?? constraint.mixX ?? 1,
-      positionMode: constraint.positionMode ?? 'percent',
-      spacingMode: constraint.spacingMode ?? 'length',
-      rotateMode: constraint.rotateMode ?? 'tangent',
-      offsetRotation: constraint.rotation ?? 0,
-    })),
-    sliders: sliderConstraints.map((constraint, index) => ({
-      name: constraint.name,
-      order: constraint.order ?? constraint.__order ?? index,
-      skin: constraint.skin ?? false,
-      animation: constraint.animation ?? '',
-      ...(constraint.bone === undefined ? {} : { bone: constraint.bone }),
-      property: constraint.property ?? 'rotate',
-      scale: constraint.scale ?? 1,
-      offset: constraint.offset ?? 0,
-      loop: constraint.loop ?? false,
-      local: constraint.local ?? false,
-      mix: constraint.mix ?? 1,
-    })),
-    slots: (input.slots ?? []).map(slot => {
-      const color = parseColor(slot.color);
-      return {
-        name: slot.name,
-        bone: slot.bone,
-        ...(slot.attachment === undefined ? {} : { attachment: slot.attachment }),
-        ...(color === undefined ? {} : { color }),
-        blend: slot.blend ?? 'normal',
-      };
-    }),
-    skins,
-    skinConstraints,
-    animations: input.animations ?? {},
-  };
-}
-
-function invalidSpineData(message: string, path: string): EngineError {
-  return new EngineError(EngineErrorCode.AssetInvalidData, message, {
-    domain: ErrorDomain.Component,
-    recovery: ErrorRecovery.ReleaseResource,
-    context: { resourceType: 'skeleton/spine' },
-    path,
-  });
-}
-
-export function parseColor(value?: string): [number, number, number, number] | undefined {
-  if (!value || value.length < 8) return undefined;
-  return [
-    parseInt(value.slice(0, 2), 16) / 255,
-    parseInt(value.slice(2, 4), 16) / 255,
-    parseInt(value.slice(4, 6), 16) / 255,
-    parseInt(value.slice(6, 8), 16) / 255,
-  ];
-}
-
-function resolveLinkedMeshes(skins: SpineData['skins']): void {
-  for (const [skinName, skin] of Object.entries(skins)) {
-    for (const [slotName, attachments] of Object.entries(skin)) {
-      for (const [attachmentName, attachment] of Object.entries(attachments)) {
-        if (attachment.type !== 'linkedmesh') continue;
-        const sourceSkinName = attachment.skin ?? skinName;
-        const sourceName = attachment.source ?? attachmentName;
-        const source = skins[sourceSkinName]?.[slotName]?.[sourceName] ?? skins.default?.[slotName]?.[sourceName];
-        if (!source) continue;
-        attachments[attachmentName] = {
-          ...source,
-          ...attachment,
-          type: source.type ?? 'mesh',
-          ...(source.uvs === undefined ? {} : { uvs: source.uvs }),
-          ...(source.triangles === undefined ? {} : { triangles: source.triangles }),
-          ...(source.vertices === undefined ? {} : { vertices: source.vertices }),
-          ...(source.vertexCount === undefined ? {} : { vertexCount: source.vertexCount }),
-        };
-      }
-    }
-  }
-}
-
-function normalizeSkinAttachments(attachments: SpineSourceSkinAttachments | undefined): Record<string, Record<string, RegionAttachment>> {
-  const normalized: Record<string, Record<string, RegionAttachment>> = {};
-  for (const [slotName, slotAttachments] of Object.entries(attachments ?? {})) {
-    normalized[slotName] = {};
-    for (const [attachmentName, attachment] of Object.entries(slotAttachments ?? {})) {
-      const { color: rawColor, ...attachmentFields } = attachment;
-      const color = typeof rawColor === 'string' ? parseColor(rawColor) : rawColor;
-      normalized[slotName][attachmentName] = {
-        ...attachmentFields,
-        name: attachment.name ?? attachmentName,
-        path: attachment.path ?? attachment.name ?? attachmentName,
-        x: attachment.x ?? 0,
-        y: attachment.y ?? 0,
-        rotation: attachment.rotation ?? 0,
-        scaleX: attachment.scaleX ?? 1,
-        scaleY: attachment.scaleY ?? 1,
-        width: attachment.width ?? 0,
-        height: attachment.height ?? 0,
-        ...(color === undefined ? {} : { color }),
-      };
-    }
-  }
-  return normalized;
-}
-
-function normalizeTransformMixes(constraint: SpineSourceConstraint): Pick<
-  TransformConstraintData,
-  'mixRotate' | 'mixX' | 'mixY' | 'mixScaleX' | 'mixScaleY' | 'mixShearY'
-> {
-  const targets = getTransformPropertyTargets(constraint.properties);
-  if (!targets) {
-    return {
-      mixRotate: constraint.mixRotate ?? 1,
-      mixX: constraint.mixX ?? 1,
-      mixY: constraint.mixY ?? constraint.mixX ?? 1,
-      mixScaleX: constraint.mixScaleX ?? 1,
-      mixScaleY: constraint.mixScaleY ?? constraint.mixScaleX ?? 1,
-      mixShearY: constraint.mixShearY ?? 1,
-    };
-  }
-  return {
-    mixRotate: targets.rotate ? constraint.mixRotate ?? 1 : 0,
-    mixX: targets.x ? constraint.mixX ?? 1 : 0,
-    mixY: targets.y ? constraint.mixY ?? constraint.mixX ?? 1 : 0,
-    mixScaleX: targets.scaleX ? constraint.mixScaleX ?? 1 : 0,
-    mixScaleY: targets.scaleY ? constraint.mixScaleY ?? constraint.mixScaleX ?? 1 : 0,
-    mixShearY: targets.shearY ? constraint.mixShearY ?? 1 : 0,
-  };
-}
-
-function getTransformPropertyTargets(properties: unknown): Record<'rotate' | 'x' | 'y' | 'scaleX' | 'scaleY' | 'shearY', boolean> | null {
-  if (!properties || typeof properties !== 'object') return null;
-  const targets = { rotate: false, x: false, y: false, scaleX: false, scaleY: false, shearY: false };
-  let hasTarget = false;
-  for (const from of Object.values(properties)) {
-    if (!from || typeof from !== 'object') continue;
-    const to = (from as Record<string, unknown>).to;
-    if (!to || typeof to !== 'object') continue;
-    for (const name of Object.keys(to)) {
-      if (name in targets) {
-        targets[name as keyof typeof targets] = true;
-        hasTarget = true;
-      }
-    }
-  }
-  return hasTarget ? targets : null;
-}
-
-type SpineSourceAttachment = Partial<Omit<RegionAttachment, 'color'>> & {
-  color?: string | [number, number, number, number];
-};
-type SpineSourceSkinAttachments = Record<string, Record<string, SpineSourceAttachment>>;
-
-interface SpineSourceSkin {
-  name?: string;
-  attachments?: SpineSourceSkinAttachments;
-  ik?: string[];
-  transform?: string[];
-  path?: string[];
-  slider?: string[];
-  sliders?: string[];
-}
-
-interface SpineSourceConstraint {
-  type?: 'ik' | 'transform' | 'path' | 'slider' | string;
-  __order?: number;
-  name: string;
-  order?: number;
-  skin?: boolean;
-  bones?: string[];
-  target?: string;
-  source?: string;
-  mix?: number;
-  softness?: number;
-  bendPositive?: boolean;
-  rotation?: number;
-  x?: number;
-  y?: number;
-  scaleX?: number;
-  scaleY?: number;
-  shearY?: number;
-  mixRotate?: number;
-  mixX?: number;
-  mixY?: number;
-  mixScaleX?: number;
-  mixScaleY?: number;
-  mixShearY?: number;
-  localSource?: boolean;
-  localTarget?: boolean;
-  additive?: boolean;
-  properties?: unknown;
-  slot?: string;
-  position?: number;
-  spacing?: number;
-  positionMode?: string;
-  spacingMode?: string;
-  rotateMode?: string;
-  animation?: string;
-  bone?: string;
-  property?: string;
-  scale?: number;
-  offset?: number;
-  loop?: boolean;
-  local?: boolean;
-}
-
-interface SpineSourceBone {
-  name: string;
-  parent?: string;
-  inherit?: string;
-  x?: number;
-  y?: number;
-  rotation?: number;
-  shearX?: number;
-  shearY?: number;
-  scaleX?: number;
-  scaleY?: number;
-  length?: number;
-}
-
-interface SpineSourceSlot {
-  name: string;
-  bone: string;
-  attachment?: string;
-  color?: string;
-  blend?: string;
-}
-
-interface SpineSourceDocument {
-  bones?: SpineSourceBone[];
-  slots?: SpineSourceSlot[];
-  skins?: SpineSourceSkin[] | Record<string, SpineSourceSkinAttachments>;
-  constraints?: SpineSourceConstraint[];
-  ik?: SpineSourceConstraint[];
-  transform?: SpineSourceConstraint[];
-  path?: SpineSourceConstraint[];
-  sliders?: SpineSourceConstraint[];
-  slider?: SpineSourceConstraint[];
-  animations?: Record<string, SpineAnimationData>;
-}

package/src/spine/SpineSlotAnimation.ts

@@ -1,195 +0,0 @@
-import type { Spine2DComponent } from './Spine2DComponent';
-import type {
-  RegionAttachment,
-  SliderAnimationState,
-  SlotData,
-  SpineData,
-} from './SpineSkeletonRuntime';
-import {
-  findCompiledFrameIndex,
-  sampleCompiledColor,
-  type SpineTimelineSamplerState,
-} from './SpineTimelineRuntime';
-
-interface SpineSlotAnimationRuntime {
-  readonly data: SpineData;
-  readonly timelineSamplerState: SpineTimelineSamplerState;
-  readonly slotColorScratch: [number, number, number, number];
-  readonly sliderColorScratch: [number, number, number, number];
-}
-
-type SpineSlotAnimationComponent = Pick<Spine2DComponent, 'animation' | 'skin'>;
-
-interface SpineSequenceFrame {
-  readonly time?: number;
-  readonly delay?: number;
-  readonly index?: number;
-  readonly mode?: string;
-}
-
-const WHITE_COLOR: [number, number, number, number] = [1, 1, 1, 1];
-
-/** Resolves the active slot attachment timeline without owning pose evaluation. */
-export function getSpineSlotAttachmentName(
-  runtime: SpineSlotAnimationRuntime,
-  component: SpineSlotAnimationComponent,
-  slot: SlotData,
-  time: number,
-): string | null {
-  let name: string | null = slot.attachment ?? null;
-  const frames = runtime.data.animations[component.animation]?.slots?.[slot.name]?.attachment;
-  if (!Array.isArray(frames) || frames.length === 0) return name;
-  const frameIndex = findCompiledFrameIndex(frames, time, runtime.timelineSamplerState);
-  if (frameIndex >= 0) name = frames[frameIndex]?.name ?? null;
-  return name;
-}
-
-/** Resolves sequence attachments across the base animation and slider overlays. */
-export function getSpineAttachmentRegionName(
-  runtime: SpineSlotAnimationRuntime,
-  component: SpineSlotAnimationComponent,
-  slot: SlotData,
-  attachmentName: string,
-  attachment: RegionAttachment,
-  time: number,
-  sliderStates: readonly SliderAnimationState[],
-): string {
-  const basePath = attachment.path || attachment.name || attachmentName;
-  const sequence = attachment.sequence;
-  if (!sequence?.count) return basePath;
-  let index = sampleSequenceIndex(
-    getSequenceFrames(runtime.data, component.animation, component.skin, slot.name, attachmentName),
-    time,
-    sequence,
-    runtime.timelineSamplerState,
-  );
-  for (const slider of sliderStates) {
-    const frames = getSequenceFrames(runtime.data, slider.animation, component.skin, slot.name, attachmentName);
-    if (Array.isArray(frames) && frames.length > 0) {
-      index = sampleSequenceIndex(frames, slider.time, sequence, runtime.timelineSamplerState);
-    }
-  }
-  const frame = String((sequence.start ?? 0) + index).padStart(sequence.digits ?? 0, '0');
-  return `${basePath}${frame}`;
-}
-
-/** Samples slot RGBA timelines and slider blends into runtime-owned scratch storage. */
-export function getSpineSlotColor(
-  runtime: SpineSlotAnimationRuntime,
-  component: SpineSlotAnimationComponent,
-  slot: SlotData,
-  time: number,
-  sliderStates: readonly SliderAnimationState[],
-): [number, number, number, number] {
-  const frames = runtime.data.animations[component.animation]?.slots?.[slot.name]?.rgba;
-  const fallback = slot.color ?? WHITE_COLOR;
-  const color = runtime.slotColorScratch;
-  if (Array.isArray(frames) && frames.length > 0) {
-    sampleCompiledColor(frames, time, fallback, color, runtime.timelineSamplerState);
-  } else {
-    copyColor(fallback, color);
-  }
-  for (const slider of sliderStates) {
-    const sliderFrames = runtime.data.animations[slider.animation]?.slots?.[slot.name]?.rgba;
-    if (!Array.isArray(sliderFrames) || sliderFrames.length === 0) continue;
-    sampleCompiledColor(
-      sliderFrames,
-      slider.time,
-      color,
-      runtime.sliderColorScratch,
-      runtime.timelineSamplerState,
-    );
-    mixColorInto(color, runtime.sliderColorScratch, slider.mix);
-  }
-  return color;
-}
-
-function getSequenceFrames(
-  data: SpineData,
-  animationName: string,
-  skinName: string,
-  slotName: string,
-  attachmentName: string,
-): SpineSequenceFrame[] | undefined {
-  const frames = data.animations[animationName]?.attachments?.[skinName]?.[slotName]?.[attachmentName]?.sequence
-    ?? data.animations[animationName]?.attachments?.default?.[slotName]?.[attachmentName]?.sequence;
-  return Array.isArray(frames) ? frames as SpineSequenceFrame[] : undefined;
-}
-
-function sampleSequenceIndex(
-  frames: SpineSequenceFrame[] | undefined,
-  time: number,
-  sequence: NonNullable<RegionAttachment['sequence']>,
-  samplerState: SpineTimelineSamplerState,
-): number {
-  const count = Math.max(1, sequence.count ?? 1);
-  if (!Array.isArray(frames) || frames.length === 0) {
-    return clampSequenceIndex(sequence.setup ?? 0, count);
-  }
-  const frameIndex = findCompiledFrameIndex(frames, time, samplerState);
-  if (frameIndex < 0) return clampSequenceIndex(sequence.setup ?? 0, count);
-  const frame = frames[frameIndex];
-  if (!frame) return clampSequenceIndex(sequence.setup ?? 0, count);
-  const before = frame.time ?? 0;
-  const delay = frame.delay ?? 0;
-  let index = frame.index ?? 0;
-  const mode = frame.mode ?? 'hold';
-  if (mode !== 'hold' && delay > 0) {
-    index += Math.floor((time - before) / delay + 0.00001);
-    switch (mode) {
-      case 'once':
-        index = Math.min(count - 1, index);
-        break;
-      case 'loop':
-        index %= count;
-        break;
-      case 'pingpong': {
-        const range = count * 2 - 2;
-        index = range === 0 ? 0 : index % range;
-        if (index >= count) index = range - index;
-        break;
-      }
-      case 'onceReverse':
-        index = Math.max(count - 1 - index, 0);
-        break;
-      case 'loopReverse':
-        index = count - 1 - (index % count);
-        break;
-      case 'pingpongReverse': {
-        const range = count * 2 - 2;
-        index = range === 0 ? 0 : (index + count - 1) % range;
-        if (index >= count) index = range - index;
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  return clampSequenceIndex(index, count);
-}
-
-function clampSequenceIndex(index: number, count: number): number {
-  return Math.max(0, Math.min(count - 1, Math.floor(index)));
-}
-
-function mixColorInto(
-  out: [number, number, number, number],
-  to: [number, number, number, number],
-  mix: number,
-): void {
-  const alpha = Math.max(0, Math.min(1, mix));
-  out[0] += (to[0] - out[0]) * alpha;
-  out[1] += (to[1] - out[1]) * alpha;
-  out[2] += (to[2] - out[2]) * alpha;
-  out[3] += (to[3] - out[3]) * alpha;
-}
-
-function copyColor(
-  source: [number, number, number, number],
-  out: [number, number, number, number],
-): void {
-  out[0] = source[0];
-  out[1] = source[1];
-  out[2] = source[2];
-  out[3] = source[3];
-}