@haiyue/extensions 0.1.0

package/src/gltf-animation3d.ts

@@ -0,0 +1,10 @@
+/** Stable glTF adapter for the source-independent Animation3D runtime. */
+export {
+  GltfAnimation3DRuntime,
+  createGltfAnimation3DClips,
+  createGltfAnimation3DRuntime,
+} from './gltf/GltfAnimation3DAdapter.js';
+export type {
+  GltfAnimation3DRuntimeOptions,
+  GltfAnimation3DRuntimeState,
+} from './gltf/GltfAnimation3DAdapter.js';

package/src/gltf-worker-runtime.ts

@@ -0,0 +1,10 @@
+/**
+ * Self-contained module entry consumed by module workers.
+ *
+ * Keep these exports backed by the production glTF loader so worker parsing,
+ * Draco decoding, and geometry preparation cannot drift from the main thread.
+ */
+export {
+  loadParsedGltfAsset,
+  prepareGltfGeometryPayloads,
+} from './gltf/gltfLoader';

package/src/gltf.ts

@@ -0,0 +1,56 @@
+export { GltfModelComponent } from './gltf/GltfModelComponent';
+export type { GltfModelComponentOptions, GltfModelStatus } from './gltf/GltfModelComponent';
+export { GltfModelSystem } from './gltf/GltfModelSystem';
+export type { GltfModelSystemOptions } from './gltf/GltfModelSystem';
+export { applyGltfAnimationClip, disposeGltfModel, GLTF_EXTENSION_CAPABILITIES, loadGltfModel, setGltfMaterialVariant } from './gltf/gltfLoader';
+export {
+  DEFAULT_GLTF_EXTENSION_ADAPTERS,
+  collectGltfMaterialExtensionPatches,
+  collectGltfMaterialVariantNames,
+  collectGltfMaterialVariantReferences,
+  resolveGltfExtensionAdapters,
+} from './gltf/GltfExtensionAdapter';
+export { encodeGltfPbrMaterial } from './gltf/GltfMaterialEncoder';
+export type {
+  EncodedGltfPbrMaterial,
+  EncodeGltfPbrMaterialOptions,
+} from './gltf/GltfMaterialEncoder';
+export type {
+  DracoDecoderConfig,
+  DracoDecoderFactory,
+  DracoDecoderModule,
+  GltfAssetWorker,
+  GltfAnimationClip,
+  GltfAnimationInfo,
+  GltfAnimationInterpolation,
+  GltfAnimationPath,
+  GltfAssetStats,
+  GltfExtensionCapability,
+  GltfExtensionAdapter,
+  GltfExtensionReport,
+  GltfExtensionReportEntry,
+  GltfExtensionSupport,
+  GltfLoadWarning,
+  GltfCompatibilityExtensionEntry,
+  GltfCompatibilityIssue,
+  GltfCompatibilityPerformanceSummary,
+  GltfCompatibilityReport,
+  GltfCompatibilityStatus,
+  GltfPrimitiveBoundsCompatibilityEntry,
+  GltfPrimitiveBoundsSupport,
+  GltfPrimitiveUvSemanticCompatibilityEntry,
+  GltfTextureCompatibilityEntry,
+  GltfTextureMipmapSource,
+  LoadedGltfModel,
+  LoadGltfOptions,
+} from './gltf/gltfLoader';
+export type {
+  GltfMaterialExtensionContext,
+  GltfMaterialExtensionPatch,
+  GltfMaterialStatePatch,
+  GltfMaterialTextureBinding,
+  GltfMaterialVariantReference,
+  GltfPrimitiveExtensionContext,
+} from './gltf/GltfExtensionAdapter';
+export { createGltfPlugin } from './gltf/GltfPlugin';
+export type { GltfPluginOptions } from './gltf/GltfPlugin';

package/src/grid/Grid2DComponent.ts

@@ -0,0 +1,69 @@
+import { Component } from '@haiyue/engine';
+import { UniqueCheckType } from '@haiyue/engine/ecs';
+
+export interface Grid2DComponentOptions {
+  columns?: number;
+  rows?: number;
+  cellWidth?: number;
+  cellHeight?: number;
+  originX?: number;
+  originY?: number;
+}
+
+export class Grid2DComponent extends Component {
+  static override UniqueCheckType = UniqueCheckType.SYMBOL | UniqueCheckType.REPLACE;
+  static override UniqueSymbol = Symbol.for('Grid2DComponent');
+
+  columns: number;
+  rows: number;
+  cellWidth: number;
+  cellHeight: number;
+  originX: number;
+  originY: number;
+
+  constructor(options: Grid2DComponentOptions = {}) {
+    super('Grid2DComponent');
+    this.columns = Math.max(1, Math.floor(options.columns ?? 10));
+    this.rows = Math.max(1, Math.floor(options.rows ?? 20));
+    this.cellWidth = options.cellWidth ?? 32;
+    this.cellHeight = options.cellHeight ?? 32;
+    this.originX = options.originX ?? 0;
+    this.originY = options.originY ?? 0;
+  }
+
+  gridToWorld(column: number, row: number): [number, number] {
+    return [
+      this.originX + column * this.cellWidth,
+      this.originY + row * this.cellHeight,
+    ];
+  }
+
+  gridToWorldCenter(column: number, row: number): [number, number] {
+    return [
+      this.originX + (column + 0.5) * this.cellWidth,
+      this.originY + (row + 0.5) * this.cellHeight,
+    ];
+  }
+
+  worldToGrid(x: number, y: number): [number, number] {
+    return [
+      Math.floor((x - this.originX) / this.cellWidth),
+      Math.floor((y - this.originY) / this.cellHeight),
+    ];
+  }
+
+  contains(column: number, row: number): boolean {
+    return column >= 0 && row >= 0 && column < this.columns && row < this.rows;
+  }
+
+  override clone(): Grid2DComponent {
+    return new Grid2DComponent({
+      columns: this.columns,
+      rows: this.rows,
+      cellWidth: this.cellWidth,
+      cellHeight: this.cellHeight,
+      originX: this.originX,
+      originY: this.originY,
+    });
+  }
+}

package/src/grid.ts

@@ -0,0 +1,2 @@
+export { Grid2DComponent } from './grid/Grid2DComponent';
+export type { Grid2DComponentOptions } from './grid/Grid2DComponent';

package/src/hya-state-machine.ts

@@ -0,0 +1,19 @@
+export { Animation2DStateMachineComponent } from './animation/Animation2DStateMachineComponent';
+export type { Animation2DStateMachineComponentOptions } from './animation/Animation2DStateMachineComponent';
+export { Animation2DStateMachineSystem } from './animation/Animation2DStateMachineSystem';
+export type { Animation2DStateMachineSystemOptions } from './animation/Animation2DStateMachineSystem';
+export {
+  createHyaAnimation2DClips,
+  getHyaStateMachineExtension,
+} from './animation/HyaAnimation2DClipAdapter';
+export {
+  AnimationStateMachineChannelError,
+  assertAudioStateMachineCompatible,
+  audioStateMachineCompatibilityDiagnostic,
+  hyaStateMachineChannelCapability,
+  HYA_STATE_MACHINE_CHANNEL_REGISTRY,
+} from './animation-state-machine/AnimationStateMachineChannels';
+export type {
+  AnimationStateMachineChannelDiagnostic,
+  AnimationStateMachineChannelDiagnosticCode,
+} from './animation-state-machine/AnimationStateMachineChannels';

package/src/index.ts

@@ -0,0 +1,2 @@
+export { RenderSystem2DBase } from './utils/RenderSystem2DBase';
+export type { RenderSystem2DBaseOptions } from './utils/RenderSystem2DBase';

package/src/plugins/pluginUtils.ts

@@ -0,0 +1,50 @@
+import type { EnginePlugin, RenderPipelineEntryOptions, ScenePluginContext, System } from '@haiyue/engine/experimental';
+import type { Entity, HaiyueEngine, World } from '@haiyue/engine';
+
+export const EXTENSIONS_PLUGIN_VERSION = '0.1.0';
+
+export interface EditorViewportContributionContext {
+  world: World;
+  engine: HaiyueEngine;
+  camera2DEntity: Entity;
+  registerRenderSystem?: (system: System, options?: RenderPipelineEntryOptions) => void;
+}
+
+export function removeSystem(context: ScenePluginContext, system: System | null): void {
+  if (system) context.world.removeSystem(system);
+}
+
+export function installEditorRenderSystem<T extends System & { autoUpdate: boolean; setCameraEntity?(entity: Entity): unknown }>(
+  context: EditorViewportContributionContext,
+  constructor: new (...args: never[]) => T,
+  create: () => T,
+): { dispose(): void } {
+  let system = context.world.getSystem(constructor) as T | null;
+  const created = system === null;
+  if (!system) {
+    system = create();
+    context.world.addSystem(system);
+  }
+  system.setCameraEntity?.(context.camera2DEntity);
+  if (context.registerRenderSystem) {
+    system.autoUpdate = false;
+    context.registerRenderSystem(system);
+  } else {
+    system.autoUpdate = true;
+  }
+  return ownedEditorViewportSystem(context.world, system, created);
+}
+
+export function ownedEditorViewportSystem(
+  world: World,
+  system: System,
+  owned: boolean,
+): { dispose(): void } {
+  return {
+    dispose() {
+      if (owned && world.hasSystem(system)) world.removeSystem(system);
+    },
+  };
+}
+
+export type { EnginePlugin, RenderPipelineEntryOptions };

package/src/plugins.ts

@@ -0,0 +1,6 @@
+export { createGltfPlugin } from './gltf/GltfPlugin';
+export type { GltfPluginOptions } from './gltf/GltfPlugin';
+export { createSpinePlugin } from './spine/SpinePlugin';
+export type { SpinePluginOptions } from './spine/SpinePlugin';
+export { createTilemapPlugin } from './tilemap/TilemapPlugin';
+export type { TilemapPluginOptions } from './tilemap/TilemapPlugin';

package/src/shaders/generated/2d-ui-animation-2d.generated.wgsl

@@ -0,0 +1,242 @@
+// haiyue:builtin-render animation-2d
+// source: shader-language/builtin-components-2d-ui-family.json
+
+struct CameraUniforms {
+  viewProj : mat4x4<f32>,
+}
+
+struct ObjectUniforms {
+  model : mat4x4<f32>,
+  color : vec4<f32>,
+  params : vec4<f32>, // x: composite layer count, y: output offscreen source
+  uvRect : vec4<f32>,
+  compositeParams : array<vec4<f32>, 8>, // mode, operation, feather x/y
+  compositeExpansion0 : vec4<f32>,
+  compositeExpansion1 : vec4<f32>,
+  gradientParams : vec4<f32>, // kind, stop count, opacity
+  gradientGeometry : vec4<f32>, // start.xy, end.xy
+  gradientColors : array<vec4<f32>, 8>,
+  gradientOffsets0 : vec4<f32>,
+  gradientOffsets1 : vec4<f32>,
+  effectKinds0 : vec4<f32>,
+  effectKinds1 : vec4<f32>,
+  effectData : array<EffectData, 8>,
+}
+
+struct EffectData {
+  data0 : vec4<f32>,
+  data1 : vec4<f32>,
+  data2 : vec4<f32>,
+  data3 : vec4<f32>,
+  data4 : vec4<f32>,
+  data5 : vec4<f32>,
+}
+
+@group(0) @binding(0) var<uniform> camera : CameraUniforms;
+@group(1) @binding(0) var<uniform> object : ObjectUniforms;
+@group(2) @binding(0) var baseTexture : texture_2d<f32>;
+@group(2) @binding(1) var baseSampler : sampler;
+@group(3) @binding(0) var compositeTexture0 : texture_2d<f32>;
+@group(3) @binding(1) var compositeTexture1 : texture_2d<f32>;
+@group(3) @binding(2) var compositeTexture2 : texture_2d<f32>;
+@group(3) @binding(3) var compositeTexture3 : texture_2d<f32>;
+@group(3) @binding(4) var compositeTexture4 : texture_2d<f32>;
+@group(3) @binding(5) var compositeTexture5 : texture_2d<f32>;
+@group(3) @binding(6) var compositeTexture6 : texture_2d<f32>;
+@group(3) @binding(7) var compositeTexture7 : texture_2d<f32>;
+@group(3) @binding(8) var compositeSampler : sampler;
+
+struct VertexInput {
+  @location(0) position : vec2<f32>,
+  @location(1) uv : vec2<f32>,
+}
+
+struct VertexOutput {
+  @builtin(position) clipPos : vec4<f32>,
+  @location(0) uv : vec2<f32>,
+  @location(1) localPosition : vec2<f32>,
+}
+
+@vertex
+fn vs_main(input : VertexInput) -> VertexOutput {
+  var out : VertexOutput;
+  out.clipPos = camera.viewProj * object.model * vec4<f32>(input.position, 0.0, 1.0);
+  out.uv = object.uvRect.xy + input.uv * object.uvRect.zw;
+  out.localPosition = input.position;
+  return out;
+}
+
+struct EffectVertexOutput {
+  @builtin(position) clipPos : vec4<f32>,
+  @location(0) uv : vec2<f32>,
+  @location(1) @interpolate(flat) effectIndex : u32,
+}
+
+@vertex
+fn vs_effect(@builtin(vertex_index) vertexIndex : u32, @builtin(instance_index) effectIndex : u32) -> EffectVertexOutput {
+  let uv = vec2<f32>(f32((vertexIndex << 1u) & 2u), f32(vertexIndex & 2u));
+  var out : EffectVertexOutput;
+  out.clipPos = vec4<f32>(uv * vec2<f32>(2.0, -2.0) + vec2<f32>(-1.0, 1.0), 0.0, 1.0);
+  out.uv = uv;
+  out.effectIndex = effectIndex;
+  return out;
+}
+
+fn decode_coverage(value : vec4<f32>, mode : f32) -> f32 {
+  var coverage = select(value.a, dot(value.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), mode > 1.5);
+  if ((mode > 0.5 && mode < 1.5) || mode > 2.5) { coverage = 1.0 - coverage; }
+  return clamp(coverage, 0.0, 1.0);
+}
+
+fn filtered_coverage(
+  source : texture_2d<f32>,
+  uv : vec2<f32>,
+  parameters : vec4<f32>,
+  expansion : f32,
+) -> f32 {
+  let dimensions = vec2<f32>(textureDimensions(source));
+  let radius = max(vec2<f32>(abs(expansion)), parameters.zw);
+  let stepUv = radius / max(dimensions, vec2<f32>(1.0));
+  let center = decode_coverage(textureSample(source, compositeSampler, uv), parameters.x);
+  if (max(radius.x, radius.y) < 0.001) { return center; }
+  let a = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, -stepUv.y)), parameters.x);
+  let b = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(0.0, -stepUv.y)), parameters.x);
+  let c = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, -stepUv.y)), parameters.x);
+  let d = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, 0.0)), parameters.x);
+  let e = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, 0.0)), parameters.x);
+  let f = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, stepUv.y)), parameters.x);
+  let g = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(0.0, stepUv.y)), parameters.x);
+  let h = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, stepUv.y)), parameters.x);
+  var expanded = center;
+  if (expansion > 0.001) { expanded = max(center, max(max(max(a, b), max(c, d)), max(max(e, f), max(g, h)))); }
+  if (expansion < -0.001) { expanded = min(center, min(min(min(a, b), min(c, d)), min(min(e, f), min(g, h)))); }
+  if (max(parameters.z, parameters.w) < 0.001) { return expanded; }
+  let blurred = (center * 2.0 + a + b + c + d + e + f + g + h) / 10.0;
+  return mix(expanded, blurred, clamp(max(parameters.z, parameters.w), 0.0, 1.0));
+}
+
+fn combine_coverage(current : f32, next : f32, operation : f32) -> f32 {
+  if (operation < 0.5) { return current + next * (1.0 - current); }
+  if (operation < 1.5) { return max(0.0, current - next); }
+  if (operation < 2.5) { return current * next; }
+  return abs(current - next);
+}
+
+fn gradient_offset(index : i32) -> f32 {
+  if (index < 4) { return object.gradientOffsets0[index]; }
+  return object.gradientOffsets1[index - 4];
+}
+
+fn gradient_color(position : vec2<f32>) -> vec4<f32> {
+  let start = object.gradientGeometry.xy;
+  let delta = object.gradientGeometry.zw - start;
+  var progress = dot(position - start, delta) / max(dot(delta, delta), 1e-6);
+  if (object.gradientParams.x > 1.5) { progress = length(position - start) / max(length(delta), 1e-6); }
+  progress = clamp(progress, 0.0, 1.0);
+  var previousOffset = gradient_offset(0);
+  var previousColor = object.gradientColors[0];
+  for (var index = 1; index < 8; index++) {
+    if (f32(index) >= object.gradientParams.y) { break; }
+    let nextOffset = gradient_offset(index);
+    let nextColor = object.gradientColors[index];
+    if (progress <= nextOffset) {
+      let local = clamp((progress - previousOffset) / max(nextOffset - previousOffset, 1e-6), 0.0, 1.0);
+      return mix(previousColor, nextColor, local) * vec4<f32>(1.0, 1.0, 1.0, object.gradientParams.z);
+    }
+    previousOffset = nextOffset;
+    previousColor = nextColor;
+  }
+  return previousColor * vec4<f32>(1.0, 1.0, 1.0, object.gradientParams.z);
+}
+
+fn effect_kind(index : u32) -> f32 {
+  if (index < 4u) { return object.effectKinds0[index]; }
+  return object.effectKinds1[index - 4u];
+}
+
+fn unpremultiply(value : vec4<f32>) -> vec4<f32> {
+  if (value.a <= 1e-6) { return vec4<f32>(0.0); }
+  return vec4<f32>(value.rgb / value.a, value.a);
+}
+
+fn apply_color_effect(value : vec4<f32>, index : u32) -> vec4<f32> {
+  let kind = effect_kind(index);
+  let data = object.effectData[index];
+  var color = unpremultiply(value);
+  if (kind < 1.5) {
+    let luminance = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+    let tinted = mix(data.data0.xyz, vec3<f32>(data.data0.w, data.data1.x, data.data1.y), luminance);
+    color = vec4<f32>(mix(color.rgb, tinted, clamp(data.data1.z, 0.0, 1.0)), color.a);
+  } else if (kind < 2.5) {
+    color = vec4<f32>(data.data0.rgb, color.a);
+    color.a = color.a * data.data0.a * clamp(data.data1.x, 0.0, 1.0);
+  } else if (kind < 3.5) {
+    color.a = color.a * clamp(data.data0.x, 0.0, 1.0);
+  } else if (kind < 4.5) {
+    let source = color;
+    color = vec4<f32>(
+      dot(source, data.data0) + data.data1.x,
+      dot(source, vec4<f32>(data.data1.yzw, data.data2.x)) + data.data2.y,
+      dot(source, vec4<f32>(data.data2.zw, data.data3.xy)) + data.data3.z,
+      dot(source, vec4<f32>(data.data3.w, data.data4.xyz)) + data.data4.w
+    );
+    color = clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));
+  }
+  return vec4<f32>(color.rgb * color.a, color.a);
+}
+
+fn sample_blurred(uv : vec2<f32>, radius : vec2<f32>) -> vec4<f32> {
+  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));
+  let stepUv = radius / dimensions;
+  if (max(radius.x, radius.y) < 0.01) { return textureSampleLevel(baseTexture, baseSampler, uv, 0.0); }
+  var value = textureSampleLevel(baseTexture, baseSampler, uv, 0.0) * 0.25;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, 0.0), 0.0) * 0.125;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, 0.0), 0.0) * 0.125;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(0.0, -stepUv.y), 0.0) * 0.125;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(0.0, stepUv.y), 0.0) * 0.125;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, -stepUv.y), 0.0) * 0.0625;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, -stepUv.y), 0.0) * 0.0625;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, stepUv.y), 0.0) * 0.0625;
+  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, stepUv.y), 0.0) * 0.0625;
+  return value;
+}
+
+@fragment
+fn fs_effect(input : EffectVertexOutput) -> @location(0) vec4<f32> {
+  let kind = effect_kind(input.effectIndex);
+  let data = object.effectData[input.effectIndex];
+  if (kind < 4.5) { return apply_color_effect(textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0), input.effectIndex); }
+  if (kind < 5.5) { return sample_blurred(input.uv, max(data.data0.xy, vec2<f32>(0.0))); }
+  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));
+  let shadowUv = input.uv - data.data1.yz / dimensions;
+  let shadowCoverage = sample_blurred(shadowUv, vec2<f32>(max(data.data1.w, 0.0))).a;
+  let shadowAlpha = clamp(shadowCoverage * data.data1.x * data.data0.a, 0.0, 1.0);
+  let shadow = vec4<f32>(data.data0.rgb * shadowAlpha, shadowAlpha);
+  let foreground = textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0);
+  return foreground + shadow * (1.0 - foreground.a);
+}
+
+@fragment
+fn fs_present(input : EffectVertexOutput) -> @location(0) vec4<f32> {
+  return textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0);
+}
+
+@fragment
+fn fs_main(input : VertexOutput) -> @location(0) vec4<f32> {
+  var base = textureSample(baseTexture, baseSampler, input.uv) * object.color;
+  if (object.gradientParams.x > 0.5) { base = gradient_color(input.localPosition) * object.color; }
+  var coverage = 1.0;
+  if (object.params.x > 0.5) {
+    let uv = input.clipPos.xy / vec2<f32>(textureDimensions(compositeTexture0));
+    coverage = select(0.0, 1.0, object.compositeParams[0].y > 0.5 && object.compositeParams[0].y < 2.5);
+    coverage = combine_coverage(coverage, filtered_coverage(compositeTexture0, uv, object.compositeParams[0], object.compositeExpansion0.x), object.compositeParams[0].y);
+    if (object.params.x > 1.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture1, uv, object.compositeParams[1], object.compositeExpansion0.y), object.compositeParams[1].y); }
+    if (object.params.x > 2.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture2, uv, object.compositeParams[2], object.compositeExpansion0.z), object.compositeParams[2].y); }
+    if (object.params.x > 3.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture3, uv, object.compositeParams[3], object.compositeExpansion0.w), object.compositeParams[3].y); }
+    if (object.params.x > 4.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture4, uv, object.compositeParams[4], object.compositeExpansion1.x), object.compositeParams[4].y); }
+    if (object.params.x > 5.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture5, uv, object.compositeParams[5], object.compositeExpansion1.y), object.compositeParams[5].y); }
+    if (object.params.x > 6.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture6, uv, object.compositeParams[6], object.compositeExpansion1.z), object.compositeParams[6].y); }
+    if (object.params.x > 7.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture7, uv, object.compositeParams[7], object.compositeExpansion1.w), object.compositeParams[7].y); }
+  }
+  return vec4<f32>(base.rgb, base.a * coverage);
+}