@haiyue/extensions 0.1.0 → 0.2.0

package/dist/animation3d.js

@@ -1,5 +1,5 @@
 import { A as Animation3DError, b as animation3DMixerRuntime, d as Animation3DPoseBuffer, e as Animation3DMixer, G as GltfAnimation3DRuntime } from './chunks/GltfAnimation3DAdapter-Cu3rQQsW.js';
-import { A as Animation3DStateMachineController$1, r as runAnimationStateMachineControllerUpdateTransaction, b as compileAnimation3DStateMachineDefinition$1, d as validateAnimation3DStateMachineDefinition$1, c as compileAnimationStateMachineDefinition } from './chunks/AnimationStateMachineController-BIcAh-sT.js';
+import { A as Animation3DStateMachineController$1, r as runAnimationStateMachineControllerUpdateTransaction, c as compileAnimation3DStateMachineDefinition$1, v as validateAnimation3DStateMachineDefinition$1, a as compileAnimationStateMachineDefinition } from './chunks/AnimationStateMachineController-4sKaqh9E.js';
 import { Entity, Mesh3D, Component, Camera3D } from '@haiyue/engine';
 import { MeshHelper, Transform3D, ParticleEmitter3D } from '@haiyue/engine/components';
 import { createCone3D, createCylinder3D, createPlane3D, createSphere3D, createBox3D } from '@haiyue/engine/geometry';

package/dist/canvas-text.js

@@ -3,7 +3,7 @@ import { UniqueCheckType } from '@haiyue/engine/ecs';
 import { CssMaterial } from '@haiyue/engine/material';
 import { beginRenderCommandPass, getExtensionGPUResourceTracker, requireEngineDevice } from '@haiyue/engine/extension-authoring';
 import { Transform2D } from '@haiyue/engine/components';
-import { R as RenderSystem2DBase, w as writeObjectMatrixIfChanged, d as destroyCamera2DGpu, a as destroyTexture2DGpu, c as createCamera2DGpu, b as createObject2DLayout, e as createTexture2DGpu } from './chunks/RenderSystem2DBase-DDT61dAu.js';
+import { R as RenderSystem2DBase, w as writeObjectMatrixIfChanged, d as destroyCamera2DGpu, a as destroyTexture2DGpu, c as createCamera2DGpu, b as createObject2DLayout, e as createTexture2DGpu } from './chunks/RenderSystem2DBase-CF2s00vg.js';
 import { C as CanvasText2dWgsl } from './chunks/2d-ui-canvas-text-2d.generated-C0Eaej2m.js';
 import 'wgpu-matrix';
 

package/dist/chunks/2d-ui-animation-2d.generated-FpziAeGJ.js

@@ -0,0 +1,4 @@
+var Animation2dWgsl = "// haiyue:builtin-render animation-2d\n// source: shader-language/builtin-components-2d-ui-family.json\n\nstruct CameraUniforms {\n  viewProj : mat4x4<f32>,\n}\n\nstruct ObjectUniforms {\n  model : mat4x4<f32>,\n  color : vec4<f32>,\n  multiplyColor : vec4<f32>,\n  screenColor : vec4<f32>,\n  params : vec4<f32>, // x: composite layer count, y: output offscreen source\n  uvRect : vec4<f32>,\n  compositeParams : array<vec4<f32>, 8>, // mode, operation, feather x/y\n  compositeExpansion0 : vec4<f32>,\n  compositeExpansion1 : vec4<f32>,\n  gradientParams : vec4<f32>, // kind, stop count, opacity\n  gradientGeometry : vec4<f32>, // start.xy, end.xy\n  gradientColors : array<vec4<f32>, 8>,\n  gradientOffsets0 : vec4<f32>,\n  gradientOffsets1 : vec4<f32>,\n  effectKinds0 : vec4<f32>,\n  effectKinds1 : vec4<f32>,\n  effectData : array<EffectData, 8>,\n}\n\nstruct EffectData {\n  data0 : vec4<f32>,\n  data1 : vec4<f32>,\n  data2 : vec4<f32>,\n  data3 : vec4<f32>,\n  data4 : vec4<f32>,\n  data5 : vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> camera : CameraUniforms;\n@group(1) @binding(0) var<uniform> object : ObjectUniforms;\n@group(2) @binding(0) var baseTexture : texture_2d<f32>;\n@group(2) @binding(1) var baseSampler : sampler;\n@group(3) @binding(0) var compositeTexture0 : texture_2d<f32>;\n@group(3) @binding(1) var compositeTexture1 : texture_2d<f32>;\n@group(3) @binding(2) var compositeTexture2 : texture_2d<f32>;\n@group(3) @binding(3) var compositeTexture3 : texture_2d<f32>;\n@group(3) @binding(4) var compositeTexture4 : texture_2d<f32>;\n@group(3) @binding(5) var compositeTexture5 : texture_2d<f32>;\n@group(3) @binding(6) var compositeTexture6 : texture_2d<f32>;\n@group(3) @binding(7) var compositeTexture7 : texture_2d<f32>;\n@group(3) @binding(8) var compositeSampler : sampler;\n\nstruct VertexInput {\n  @location(0) position : vec2<f32>,\n  @location(1) uv : vec2<f32>,\n}\n\nstruct VertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) uv : vec2<f32>,\n  @location(1) localPosition : vec2<f32>,\n}\n\n@vertex\nfn vs_main(input : VertexInput) -> VertexOutput {\n  var out : VertexOutput;\n  out.clipPos = camera.viewProj * object.model * vec4<f32>(input.position, 0.0, 1.0);\n  out.uv = object.uvRect.xy + input.uv * object.uvRect.zw;\n  out.localPosition = input.position;\n  return out;\n}\n\nstruct EffectVertexOutput {\n  @builtin(position) clipPos : vec4<f32>,\n  @location(0) uv : vec2<f32>,\n  @location(1) @interpolate(flat) effectIndex : u32,\n}\n\n@vertex\nfn vs_effect(@builtin(vertex_index) vertexIndex : u32, @builtin(instance_index) effectIndex : u32) -> EffectVertexOutput {\n  let uv = vec2<f32>(f32((vertexIndex << 1u) & 2u), f32(vertexIndex & 2u));\n  var out : EffectVertexOutput;\n  out.clipPos = vec4<f32>(uv * vec2<f32>(2.0, -2.0) + vec2<f32>(-1.0, 1.0), 0.0, 1.0);\n  out.uv = uv;\n  out.effectIndex = effectIndex;\n  return out;\n}\n\nfn decode_coverage(value : vec4<f32>, mode : f32) -> f32 {\n  var coverage = select(value.a, dot(value.rgb, vec3<f32>(0.2126, 0.7152, 0.0722)), mode > 1.5);\n  if ((mode > 0.5 && mode < 1.5) || mode > 2.5) { coverage = 1.0 - coverage; }\n  return clamp(coverage, 0.0, 1.0);\n}\n\nfn filtered_coverage(\n  source : texture_2d<f32>,\n  uv : vec2<f32>,\n  parameters : vec4<f32>,\n  expansion : f32,\n) -> f32 {\n  let dimensions = vec2<f32>(textureDimensions(source));\n  let radius = max(vec2<f32>(abs(expansion)), parameters.zw);\n  let stepUv = radius / max(dimensions, vec2<f32>(1.0));\n  let center = decode_coverage(textureSample(source, compositeSampler, uv), parameters.x);\n  if (max(radius.x, radius.y) < 0.001) { return center; }\n  let a = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, -stepUv.y)), parameters.x);\n  let b = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(0.0, -stepUv.y)), parameters.x);\n  let c = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, -stepUv.y)), parameters.x);\n  let d = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, 0.0)), parameters.x);\n  let e = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, 0.0)), parameters.x);\n  let f = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(-stepUv.x, stepUv.y)), parameters.x);\n  let g = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(0.0, stepUv.y)), parameters.x);\n  let h = decode_coverage(textureSample(source, compositeSampler, uv + vec2<f32>(stepUv.x, stepUv.y)), parameters.x);\n  var expanded = center;\n  if (expansion > 0.001) { expanded = max(center, max(max(max(a, b), max(c, d)), max(max(e, f), max(g, h)))); }\n  if (expansion < -0.001) { expanded = min(center, min(min(min(a, b), min(c, d)), min(min(e, f), min(g, h)))); }\n  if (max(parameters.z, parameters.w) < 0.001) { return expanded; }\n  let blurred = (center * 2.0 + a + b + c + d + e + f + g + h) / 10.0;\n  return mix(expanded, blurred, clamp(max(parameters.z, parameters.w), 0.0, 1.0));\n}\n\nfn combine_coverage(current : f32, next : f32, operation : f32) -> f32 {\n  if (operation < 0.5) { return current + next * (1.0 - current); }\n  if (operation < 1.5) { return max(0.0, current - next); }\n  if (operation < 2.5) { return current * next; }\n  return abs(current - next);\n}\n\nfn gradient_offset(index : i32) -> f32 {\n  if (index < 4) { return object.gradientOffsets0[index]; }\n  return object.gradientOffsets1[index - 4];\n}\n\nfn gradient_color(position : vec2<f32>) -> vec4<f32> {\n  let start = object.gradientGeometry.xy;\n  let delta = object.gradientGeometry.zw - start;\n  var progress = dot(position - start, delta) / max(dot(delta, delta), 1e-6);\n  if (object.gradientParams.x > 1.5) { progress = length(position - start) / max(length(delta), 1e-6); }\n  progress = clamp(progress, 0.0, 1.0);\n  var previousOffset = gradient_offset(0);\n  var previousColor = object.gradientColors[0];\n  for (var index = 1; index < 8; index++) {\n    if (f32(index) >= object.gradientParams.y) { break; }\n    let nextOffset = gradient_offset(index);\n    let nextColor = object.gradientColors[index];\n    if (progress <= nextOffset) {\n      let local = clamp((progress - previousOffset) / max(nextOffset - previousOffset, 1e-6), 0.0, 1.0);\n      // Rive interpolates the authored straight RGBA stops and premultiplies\n      // the resulting sample. Premultiplying each stop before interpolation\n      // makes an opaque-white -> transparent-blue ramp stay white throughout.\n      let straightColor = mix(previousColor, nextColor, local);\n      return vec4<f32>(straightColor.rgb * straightColor.a, straightColor.a) * object.gradientParams.z;\n    }\n    previousOffset = nextOffset;\n    previousColor = nextColor;\n  }\n  return vec4<f32>(previousColor.rgb * previousColor.a, previousColor.a) * object.gradientParams.z;\n}\n\nfn effect_kind(index : u32) -> f32 {\n  if (index < 4u) { return object.effectKinds0[index]; }\n  return object.effectKinds1[index - 4u];\n}\n\nfn unpremultiply(value : vec4<f32>) -> vec4<f32> {\n  if (value.a <= 1e-6) { return vec4<f32>(0.0); }\n  return vec4<f32>(value.rgb / value.a, value.a);\n}\n\nfn apply_color_effect(value : vec4<f32>, index : u32) -> vec4<f32> {\n  let kind = effect_kind(index);\n  let data = object.effectData[index];\n  var color = unpremultiply(value);\n  if (kind < 1.5) {\n    let luminance = dot(color.rgb, vec3<f32>(0.2126, 0.7152, 0.0722));\n    let tinted = mix(data.data0.xyz, vec3<f32>(data.data0.w, data.data1.x, data.data1.y), luminance);\n    color = vec4<f32>(mix(color.rgb, tinted, clamp(data.data1.z, 0.0, 1.0)), color.a);\n  } else if (kind < 2.5) {\n    color = vec4<f32>(data.data0.rgb, color.a);\n    color.a = color.a * data.data0.a * clamp(data.data1.x, 0.0, 1.0);\n  } else if (kind < 3.5) {\n    color.a = color.a * clamp(data.data0.x, 0.0, 1.0);\n  } else if (kind < 4.5) {\n    let source = color;\n    color = vec4<f32>(\n      dot(source, data.data0) + data.data1.x,\n      dot(source, vec4<f32>(data.data1.yzw, data.data2.x)) + data.data2.y,\n      dot(source, vec4<f32>(data.data2.zw, data.data3.xy)) + data.data3.z,\n      dot(source, vec4<f32>(data.data3.w, data.data4.xyz)) + data.data4.w\n    );\n    color = clamp(color, vec4<f32>(0.0), vec4<f32>(1.0));\n  }\n  return vec4<f32>(color.rgb * color.a, color.a);\n}\n\nfn sample_blurred(uv : vec2<f32>, radius : vec2<f32>) -> vec4<f32> {\n  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));\n  let stepUv = radius / dimensions;\n  if (max(radius.x, radius.y) < 0.01) { return textureSampleLevel(baseTexture, baseSampler, uv, 0.0); }\n  var value = textureSampleLevel(baseTexture, baseSampler, uv, 0.0) * 0.25;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, 0.0), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, 0.0), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(0.0, -stepUv.y), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(0.0, stepUv.y), 0.0) * 0.125;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, -stepUv.y), 0.0) * 0.0625;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, -stepUv.y), 0.0) * 0.0625;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(-stepUv.x, stepUv.y), 0.0) * 0.0625;\n  value += textureSampleLevel(baseTexture, baseSampler, uv + vec2<f32>(stepUv.x, stepUv.y), 0.0) * 0.0625;\n  return value;\n}\n\nfn local_to_output_pixels(value : vec2<f32>, dimensions : vec2<f32>) -> vec2<f32> {\n  let localToClip = camera.viewProj * object.model;\n  let clipDelta = (localToClip * vec4<f32>(value, 0.0, 0.0)).xy;\n  return vec2<f32>(clipDelta.x * dimensions.x * 0.5, -clipDelta.y * dimensions.y * 0.5);\n}\n\nfn feather_to_output_pixels(value : vec2<f32>, dimensions : vec2<f32>, worldSpace : bool) -> vec2<f32> {\n  if (!worldSpace) { return local_to_output_pixels(value, dimensions); }\n  let clipDelta = (camera.viewProj * vec4<f32>(value, 0.0, 0.0)).xy;\n  return vec2<f32>(clipDelta.x * dimensions.x * 0.5, -clipDelta.y * dimensions.y * 0.5);\n}\n\nfn sample_inner_feather(uv : vec2<f32>, parameters : vec4<f32>) -> vec4<f32> {\n  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));\n  let radius = vec2<f32>(\n    length(local_to_output_pixels(vec2<f32>(parameters.x, 0.0), dimensions)),\n    length(local_to_output_pixels(vec2<f32>(0.0, parameters.y), dimensions)),\n  );\n  let offsetUv = local_to_output_pixels(parameters.zw, dimensions) / dimensions;\n  let foreground = textureSampleLevel(baseTexture, baseSampler, uv, 0.0);\n  // Inner feather keeps the authored paint in the shape interior and softens\n  // only its edge with the blurred source coverage. Sampling the paint itself\n  // at the original UV preserves gradient coordinates and clips the result to\n  // the original path.\n  let featherCoverage = sample_blurred(uv - offsetUv, radius).a;\n  return foreground * featherCoverage;\n}\n\nfn sample_vector_feather(uv : vec2<f32>, data : EffectData) -> vec4<f32> {\n  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));\n  let worldSpace = data.data1.y > 0.5;\n  // Rive's feather strength covers three standard deviations. Its renderer\n  // exposes a support radius of strength * (3 / 2).\n  let radius = vec2<f32>(\n    length(feather_to_output_pixels(vec2<f32>(data.data0.x, 0.0), dimensions, worldSpace)),\n    length(feather_to_output_pixels(vec2<f32>(0.0, data.data0.y), dimensions, worldSpace)),\n  ) * 1.5;\n  let offsetUv = feather_to_output_pixels(data.data0.zw, dimensions, worldSpace) / dimensions;\n  let foreground = textureSampleLevel(baseTexture, baseSampler, uv, 0.0);\n  let feathered = sample_blurred(uv - offsetUv, radius);\n  if (data.data1.x > 0.5) {\n    return foreground * feathered.a;\n  }\n  return feathered;\n}\n\n@fragment\nfn fs_effect(input : EffectVertexOutput) -> @location(0) vec4<f32> {\n  let kind = effect_kind(input.effectIndex);\n  let data = object.effectData[input.effectIndex];\n  if (kind < 4.5) { return apply_color_effect(textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0), input.effectIndex); }\n  if (kind < 5.5) { return sample_blurred(input.uv, max(data.data0.xy, vec2<f32>(0.0))); }\n  if (kind > 7.5) {\n    return sample_vector_feather(input.uv, data);\n  }\n  if (kind > 6.5) {\n    return sample_inner_feather(input.uv, vec4<f32>(max(data.data0.xy, vec2<f32>(0.0)), data.data0.zw));\n  }\n  let dimensions = max(vec2<f32>(textureDimensions(baseTexture)), vec2<f32>(1.0));\n  let shadowUv = input.uv - data.data1.yz / dimensions;\n  let shadowCoverage = sample_blurred(shadowUv, vec2<f32>(max(data.data1.w, 0.0))).a;\n  let shadowAlpha = clamp(shadowCoverage * data.data1.x * data.data0.a, 0.0, 1.0);\n  let shadow = vec4<f32>(data.data0.rgb * shadowAlpha, shadowAlpha);\n  let foreground = textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0);\n  return foreground + shadow * (1.0 - foreground.a);\n}\n\n@fragment\nfn fs_present(input : EffectVertexOutput) -> @location(0) vec4<f32> {\n  return textureSampleLevel(baseTexture, baseSampler, input.uv, 0.0);\n}\n\nfn animation_color(input : VertexOutput, premultipliedTexture : bool) -> vec4<f32> {\n  var source = textureSample(baseTexture, baseSampler, input.uv);\n  var sourcePremultiplied = premultipliedTexture;\n  if (object.gradientParams.x > 0.5) {\n    source = gradient_color(input.localPosition);\n    sourcePremultiplied = true;\n  }\n  if (!sourcePremultiplied) { source = vec4<f32>(source.rgb * source.a, source.a); }\n  // Frozen Cubism drawable-color order. Tint alpha is pose metadata only.\n  // Setup-mask rendering skips both RGB operations so mask coverage is tint-independent.\n  if (object.params.y < 0.5) {\n    source = vec4<f32>(source.rgb * object.multiplyColor.rgb, source.a);\n    source = vec4<f32>(source.rgb + object.screenColor.rgb * source.a - source.rgb * object.screenColor.rgb, source.a);\n  }\n  var coverage = 1.0;\n  if (object.params.x > 0.5) {\n    let uv = input.clipPos.xy / vec2<f32>(textureDimensions(compositeTexture0));\n    coverage = select(0.0, 1.0, object.compositeParams[0].y > 0.5 && object.compositeParams[0].y < 2.5);\n    coverage = combine_coverage(coverage, filtered_coverage(compositeTexture0, uv, object.compositeParams[0], object.compositeExpansion0.x), object.compositeParams[0].y);\n    if (object.params.x > 1.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture1, uv, object.compositeParams[1], object.compositeExpansion0.y), object.compositeParams[1].y); }\n    if (object.params.x > 2.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture2, uv, object.compositeParams[2], object.compositeExpansion0.z), object.compositeParams[2].y); }\n    if (object.params.x > 3.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture3, uv, object.compositeParams[3], object.compositeExpansion0.w), object.compositeParams[3].y); }\n    if (object.params.x > 4.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture4, uv, object.compositeParams[4], object.compositeExpansion1.x), object.compositeParams[4].y); }\n    if (object.params.x > 5.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture5, uv, object.compositeParams[5], object.compositeExpansion1.y), object.compositeParams[5].y); }\n    if (object.params.x > 6.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture6, uv, object.compositeParams[6], object.compositeExpansion1.z), object.compositeParams[6].y); }\n    if (object.params.x > 7.5) { coverage = combine_coverage(coverage, filtered_coverage(compositeTexture7, uv, object.compositeParams[7], object.compositeExpansion1.w), object.compositeParams[7].y); }\n  }\n  let alpha = source.a * object.color.a;\n  return vec4<f32>(source.rgb * object.color.rgb * object.color.a * coverage, alpha * coverage);\n}\n\n@fragment\nfn fs_main(input : VertexOutput) -> @location(0) vec4<f32> {\n  return animation_color(input, false);\n}\n\n@fragment\nfn fs_main_premultiplied_texture(input : VertexOutput) -> @location(0) vec4<f32> {\n  return animation_color(input, true);\n}\n";
+
+export { Animation2dWgsl as A };
+//# sourceMappingURL=2d-ui-animation-2d.generated-FpziAeGJ.js.map

package/dist/chunks/2d-ui-indexed-sprite.generated-DmKR0CC3.js

@@ -0,0 +1,4 @@
+var IndexedSpriteWgsl = "// haiyue:builtin-render indexed-sprite\n// source: shader-language/builtin-components-2d-ui-family.json\n\nstruct ViewportUniforms {\n  size: vec2f,\n  _pad: vec2f,\n}\n\nstruct SpriteInstance {\n  position_scale: vec4f,\n  size_axis: vec4f,\n  uv_rect: vec4f,\n  rotation_opacity: vec4f,\n  metadata: vec4u,\n  tint: vec4f,\n  color_matrix_0: vec4f,\n  color_matrix_1: vec4f,\n  color_matrix_2: vec4f,\n}\n\nstruct VertexOutput {\n  @builtin(position) position: vec4f,\n  @location(0) local_uv: vec2f,\n  @location(1) @interpolate(flat) uv_rect: vec4f,\n  @location(2) @interpolate(flat) size_palette_flags: vec4u,\n  @location(3) @interpolate(flat) tint_opacity: vec4f,\n  @location(4) @interpolate(flat) color_matrix_0: vec4f,\n  @location(5) @interpolate(flat) color_matrix_1: vec4f,\n  @location(6) @interpolate(flat) color_matrix_2: vec4f,\n}\n\n@group(0) @binding(0) var<uniform> viewport: ViewportUniforms;\n@group(0) @binding(1) var<storage, read> instances: array<SpriteInstance>;\n@group(1) @binding(0) var index_atlas: texture_2d<u32>;\n@group(1) @binding(1) var color_atlas: texture_2d<f32>;\n@group(1) @binding(2) var palette_bank: texture_2d<f32>;\n@group(1) @binding(3) var color_sampler: sampler;\n\nfn corner(vertex_index: u32) -> vec2f {\n  let corners = array<vec2f, 6>(\n    vec2f(0.0, 0.0), vec2f(1.0, 0.0), vec2f(0.0, 1.0),\n    vec2f(0.0, 1.0), vec2f(1.0, 0.0), vec2f(1.0, 1.0));\n  return corners[vertex_index];\n}\n\n@vertex\nfn vs_main(@builtin(vertex_index) vertex_index: u32, @builtin(instance_index) instance_index: u32) -> VertexOutput {\n  let instance = instances[instance_index];\n  let uv = corner(vertex_index);\n  var local = uv * instance.size_axis.xy - instance.size_axis.zw;\n  if ((instance.metadata.y & 4u) != 0u) { local.x = -local.x; }\n  if ((instance.metadata.y & 8u) != 0u) { local.y = -local.y; }\n  local *= instance.position_scale.zw;\n  let cosine = cos(instance.rotation_opacity.x);\n  let sine = sin(instance.rotation_opacity.x);\n  let rotated = vec2f(cosine * local.x - sine * local.y, sine * local.x + cosine * local.y);\n  let world = instance.position_scale.xy + rotated;\n  let ndc = vec2f(world.x / viewport.size.x * 2.0 - 1.0, 1.0 - world.y / viewport.size.y * 2.0);\n  var output: VertexOutput;\n  output.position = vec4f(ndc, instance.rotation_opacity.y, 1.0);\n  output.local_uv = uv;\n  output.uv_rect = instance.uv_rect;\n  output.size_palette_flags = vec4u(u32(instance.size_axis.x), u32(instance.size_axis.y), instance.metadata.x, instance.metadata.y);\n  output.tint_opacity = vec4f(instance.tint.rgb, instance.tint.a * instance.rotation_opacity.z);\n  output.color_matrix_0 = instance.color_matrix_0;\n  output.color_matrix_1 = instance.color_matrix_1;\n  output.color_matrix_2 = instance.color_matrix_2;\n  return output;\n}\n\nfn apply_color_matrix(color: vec4f, input: VertexOutput) -> vec4f {\n  let rgb = vec3f(\n    dot(input.color_matrix_0.xyz, color.rgb) + input.color_matrix_0.w,\n    dot(input.color_matrix_1.xyz, color.rgb) + input.color_matrix_1.w,\n    dot(input.color_matrix_2.xyz, color.rgb) + input.color_matrix_2.w);\n  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), color.a) * input.tint_opacity;\n}\n\nfn palette_color(index: u32, row: u32) -> vec4f {\n  let dimensions = textureDimensions(palette_bank);\n  return textureLoad(palette_bank, vec2i(i32(min(index, dimensions.x - 1u)), i32(min(row, dimensions.y - 1u))), 0);\n}\n\nfn indexed_nearest(input: VertexOutput) -> vec4f {\n  let size = input.size_palette_flags.xy;\n  let pixel = min(vec2u(input.local_uv * vec2f(size)), size - vec2u(1u));\n  let origin = vec2u(input.uv_rect.xy);\n  let index = textureLoad(index_atlas, vec2i(origin + pixel), 0).r;\n  return palette_color(index, input.size_palette_flags.z);\n}\n\nfn indexed_linear(input: VertexOutput) -> vec4f {\n  let size = input.size_palette_flags.xy;\n  let coordinate = input.local_uv * vec2f(size) - vec2f(0.5);\n  let low = vec2i(floor(coordinate));\n  let fraction = fract(coordinate);\n  let maximum = vec2i(size) - vec2i(1);\n  let p00 = clamp(low, vec2i(0), maximum);\n  let p10 = clamp(low + vec2i(1, 0), vec2i(0), maximum);\n  let p01 = clamp(low + vec2i(0, 1), vec2i(0), maximum);\n  let p11 = clamp(low + vec2i(1, 1), vec2i(0), maximum);\n  let origin = vec2i(input.uv_rect.xy);\n  let row = input.size_palette_flags.z;\n  let c00 = palette_color(textureLoad(index_atlas, origin + p00, 0).r, row);\n  let c10 = palette_color(textureLoad(index_atlas, origin + p10, 0).r, row);\n  let c01 = palette_color(textureLoad(index_atlas, origin + p01, 0).r, row);\n  let c11 = palette_color(textureLoad(index_atlas, origin + p11, 0).r, row);\n  return mix(mix(c00, c10, fraction.x), mix(c01, c11, fraction.x), fraction.y);\n}\n\nfn color_sample(input: VertexOutput) -> vec4f {\n  let atlas_size = vec2f(textureDimensions(color_atlas));\n  let size = vec2f(input.size_palette_flags.xy);\n  let pixel = input.uv_rect.xy + vec2f(0.5) + input.local_uv * max(size - vec2f(1.0), vec2f(0.0));\n  return textureSampleLevel(color_atlas, color_sampler, pixel / atlas_size, 0.0);\n}\n\n@fragment\nfn fs_main(input: VertexOutput) -> @location(0) vec4f {\n  let flags = input.size_palette_flags.w;\n  if ((flags & 1u) != 0u) {\n    if ((flags & 2u) != 0u) {\n      return apply_color_matrix(indexed_linear(input), input);\n    }\n    return apply_color_matrix(indexed_nearest(input), input);\n  }\n  return apply_color_matrix(color_sample(input), input);\n}\n";
+
+export { IndexedSpriteWgsl as I };
+//# sourceMappingURL=2d-ui-indexed-sprite.generated-DmKR0CC3.js.map