@aura3d/rendering 3.0.1 → 4.0.0

package/dist/shaders/debug-view.glsl.js

@@ -0,0 +1,153 @@
+/** `u_prd05DebugView` value → channel define suffix. */
+export const PRD05_DEBUG_VIEW_CHANNELS = [
+    "TEXEL_DENSITY", "MIP_LEVEL", "FACET", "LOD_LEVEL",
+    "BASE_COLOR", "WORLD_NORMAL", "ROUGHNESS", "METALLIC", "OCCLUSION", "UV_LAYOUT"
+];
+const CHANNEL_BY_NAME = {
+    texelDensity: 1,
+    mipLevel: 2,
+    facet: 3,
+    lodLevel: 4,
+    baseColor: 5,
+    normal: 6,
+    roughness: 7,
+    metallic: 8,
+    occlusion: 9,
+    uvLayout: 10
+};
+/** Material-param value for a named channel (what the look-dev app sets). */
+export function prd05DebugViewValue(channel) {
+    return CHANNEL_BY_NAME[channel];
+}
+export function prd05DebugViewDefineName(value) {
+    const name = PRD05_DEBUG_VIEW_CHANNELS[value - 1];
+    return name === undefined ? undefined : `A3D_PRD05_DEBUG_VIEW_${name}`;
+}
+const glslPars = /* glsl */ `
+#if defined(A3D_PRD05_DEBUG_VIEW_TEXEL_DENSITY) || defined(A3D_PRD05_DEBUG_VIEW_MIP_LEVEL) || defined(A3D_PRD05_DEBUG_VIEW_FACET) || defined(A3D_PRD05_DEBUG_VIEW_LOD_LEVEL) || defined(A3D_PRD05_DEBUG_VIEW_BASE_COLOR) || defined(A3D_PRD05_DEBUG_VIEW_WORLD_NORMAL) || defined(A3D_PRD05_DEBUG_VIEW_ROUGHNESS) || defined(A3D_PRD05_DEBUG_VIEW_METALLIC) || defined(A3D_PRD05_DEBUG_VIEW_OCCLUSION) || defined(A3D_PRD05_DEBUG_VIEW_UV_LAYOUT)
+uniform highp sampler2D a3d_prd05_debugSampler;
+uniform float u_prd05LodLevel;
+uniform vec2 u_prd05TexelBand;
+
+// 0..1 → blue → green → yellow → red heatmap.
+vec3 a3dPrd05DebugHeat( float t ) {
+	float c = clamp( t, 0.0, 1.0 );
+	vec3 cool = mix( vec3( 0.05, 0.1, 0.45 ), vec3( 0.05, 0.55, 0.45 ), clamp( c * 2.0, 0.0, 1.0 ) );
+	vec3 hot = mix( vec3( 0.05, 0.55, 0.45 ), vec3( 0.9, 0.12, 0.05 ), clamp( ( c - 0.5 ) * 2.0, 0.0, 1.0 ) );
+	return mix( cool, hot, step( 0.5, c ) );
+}
+
+// Screen texels/pixel for the bound debug sampler at v_uv.
+float a3dPrd05TexelDensity( vec2 uv ) {
+	vec2 texSize = vec2( textureSize( a3d_prd05_debugSampler, 0 ) );
+	vec2 dudx = dFdx( uv ) * texSize;
+	vec2 dudy = dFdy( uv ) * texSize;
+	return max( length( dudx ), length( dudy ) );
+}
+#endif
+`;
+const wgslPars = /* wgsl */ `
+var<private> a3d_prd05_debug_dummy: f32 = 0.0;
+// WGSL twin lands with the C-02 webgpu emitter; GLSL is the conformance path.
+`;
+/** fragment:pars chunk — declares the debug sampler/uniforms + helpers. */
+export const debugViewParsChunk = {
+    name: "a3d_prd05_debug_view",
+    owner: "prd05",
+    stage: "fragment",
+    glsl: glslPars,
+    wgsl: wgslPars
+};
+/**
+ * fragment:end body. Entirely inside the channel `#ifdef`s: outside a
+ * generated program (ChunkHarness) it is empty, so the chunk compiles even
+ * though it names `v_uv`/`v_worldPosition`/`u_baseColorMap`.
+ */
+export const debugViewEndChunk = {
+    name: "a3d_prd05_debug_view_end",
+    owner: "prd05",
+    stage: "fragment",
+    // No `requires` on the pars chunk: hookSplice appends required chunks
+    // AFTER the requiring one at the SAME hook, so the pars chunk's
+    // uniform declarations would land inside main() (Q-05-8). The feature's
+    // hooks list already splices the pars chunk at fragment:pars.
+    requires: [],
+    glsl: /* glsl */ `
+#ifdef A3D_PRD05_DEBUG_VIEW_TEXEL_DENSITY
+	#ifdef A3D_NEED_UV0
+		a3dColor = a3dPrd05DebugHeat( clamp( ( a3dPrd05TexelDensity( v_uv ) - u_prd05TexelBand.x ) / ( u_prd05TexelBand.y - u_prd05TexelBand.x ), 0.0, 1.0 ) );
+	#else
+		a3dColor = vec3( 0.4 );
+	#endif
+#elif defined( A3D_PRD05_DEBUG_VIEW_MIP_LEVEL )
+	#ifdef A3D_NEED_UV0
+		vec2 a3dPrd05Lod = textureQueryLod( a3d_prd05_debugSampler, v_uv );
+		a3dColor = a3dPrd05DebugHeat( clamp( a3dPrd05Lod.x / 8.0, 0.0, 1.0 ) );
+	#else
+		a3dColor = vec3( 0.4 );
+	#endif
+#elif defined( A3D_PRD05_DEBUG_VIEW_FACET )
+	{
+		vec3 a3dPrd05Facet = normalize( cross( dFdx( v_worldPosition ), dFdy( v_worldPosition ) ) );
+		a3dColor = a3dPrd05Facet * 0.5 + 0.5;
+	}
+#elif defined( A3D_PRD05_DEBUG_VIEW_LOD_LEVEL )
+	a3dColor = a3dPrd05DebugHeat( clamp( u_prd05LodLevel / 4.0, 0.0, 1.0 ) );
+#elif defined( A3D_PRD05_DEBUG_VIEW_BASE_COLOR )
+	a3dColor = a3dBaseColor.rgb;
+#elif defined( A3D_PRD05_DEBUG_VIEW_WORLD_NORMAL )
+	#ifdef A3D_NEED_NORMAL
+		a3dColor = normalize( v_normal ) * 0.5 + 0.5;
+	#else
+		a3dColor = vec3( 0.4 );
+	#endif
+#elif defined( A3D_PRD05_DEBUG_VIEW_ROUGHNESS )
+	a3dColor = vec3( a3dRoughness );
+#elif defined( A3D_PRD05_DEBUG_VIEW_METALLIC )
+	a3dColor = vec3( a3dMetallic );
+#elif defined( A3D_PRD05_DEBUG_VIEW_OCCLUSION )
+	#if defined( USE_OCCLUSION_MAP ) && defined( A3D_NEED_UV0 )
+		a3dColor = vec3( texture( u_occlusionMap, v_uv ).r );
+	#else
+		a3dColor = vec3( 1.0 );
+	#endif
+#elif defined( A3D_PRD05_DEBUG_VIEW_UV_LAYOUT )
+	#ifdef A3D_NEED_UV0
+		a3dColor = vec3( fract( v_uv ), 0.0 );
+	#else
+		a3dColor = vec3( 0.4 );
+	#endif
+#endif
+`,
+    wgsl: `// fragment:end splice — WGSL twin lands with the C-02 webgpu emitter.`
+};
+/** Forward-pass feature: active only while a material carries `u_prd05DebugView`. */
+export const debugViewFeature = {
+    id: "prd05.debugView",
+    owner: "prd05",
+    flag: "A3D_QR_ASSETS_LOOKDEV",
+    chunks: ["a3d_prd05_debug_view", "a3d_prd05_debug_view_end"],
+    hooks: ["fragment:pars", "fragment:end"],
+    select(input) {
+        if (input.pass !== "forward")
+            return undefined;
+        const material = input.item.material;
+        const value = material?.getParameter("u_prd05DebugView");
+        return typeof value === "number" && prd05DebugViewDefineName(value) !== undefined ? value : undefined;
+    },
+    defines(value) {
+        const name = typeof value === "number" ? prd05DebugViewDefineName(value) : undefined;
+        return name === undefined ? {} : { [name]: true };
+    },
+    bindUniforms(_value, item, set) {
+        const material = item.material;
+        // The debug sampler mirrors the material's base-colour texture binding.
+        const baseColorTexture = material?.getParameter("u_baseColorTexture");
+        if (baseColorTexture !== undefined)
+            set("a3d_prd05_debugSampler", baseColorTexture);
+        set("u_prd05LodLevel", item.lodLevel ?? 0);
+        const band = material?.getParameter("u_prd05TexelBand");
+        set("u_prd05TexelBand", band ?? [0.5, 4]);
+    }
+};
+//# sourceMappingURL=debug-view.glsl.js.map

package/dist/shaders/debug-view.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-view.glsl.js","sourceRoot":"","sources":["../../../../../packages/rendering/src/shaders/debug-view.glsl.ts"],"names":[],"mappings":"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"}

package/dist/shaders/deform/deform.glsl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * C-18 chunk `a3d_prd06_deform` (PRD-06 §8.3/§8.5) — the shared deformation
+ * entry spliced at hook `vertex:deform` by feature `prd06.deform`. Ordering is
+ * morph → skin → model (glTF/three.js). `A3D_DEPTH_ONLY` skips normal/tangent
+ * work for depth and distance passes; `A3D_HAS_TANGENT` guards the tangent
+ * attribute; `A3D_VELOCITY` exposes `a3dDeformPrevious` for C-14.
+ *
+ * Depends on `a3d_prd06_skinning_common` and `a3d_prd06_morph_texture` being
+ * spliced ahead of it (both are `#ifdef`-guarded no-ops when inactive).
+ *
+ * `a_normal` is only declared when the program defines `A3D_NEED_NORMAL`
+ * (unlit forward variants do not), so the deform read guards on it as well;
+ * `a_tangent` (legacy location 3) is declared here under `A3D_HAS_TANGENT`
+ * since the generated attribute block does not carry it.
+ */
+export declare const A3D_PRD06_DEFORM_GLSL = "\n#ifdef A3D_HAS_TANGENT\nlayout(location = 3) in vec4 a_tangent;\n#endif\n// Wind composes after morph/skin through its canonical C-18 entry.\n#define A3D_DEFORM_ENTRY 1\n#ifdef A3D_PRD10_WIND\nvoid a3dDeformBeforeWind(out vec4 localPos, out vec3 localNormal, out vec4 localTangent) {\n#else\nvoid a3dDeform(out vec4 localPos, out vec3 localNormal, out vec4 localTangent) {\n#endif\n#ifdef A3D_DEPTH_ONLY\n  vec3 p = a_position;\n  vec3 n = vec3(0.0); vec4 tg = vec4(0.0, 0.0, 0.0, 1.0);\n#else\n  vec3 p = a_position;\n#ifdef A3D_NEED_NORMAL\n  vec3 n = a_normal;\n#else\n  vec3 n = vec3(0.0, 0.0, 1.0);\n#endif\n#ifdef A3D_HAS_TANGENT\n  vec4 tg = a_tangent;\n#else\n  vec4 tg = vec4(0.0, 0.0, 0.0, 1.0);\n#endif\n#endif\n#ifdef A3D_MORPH\n  a3dApplyMorph(p, n, tg);\n#endif\n#ifdef A3D_SKINNING\n  // Zero-weight guard (legacy ShaderLibrary skinned-unlit semantics): an\n  // unweighted vertex on a skinned mesh keeps its raw position instead of\n  // collapsing to the origin.\n  float a3d_wsum = a_weights.x + a_weights.y + a_weights.z + a_weights.w;\n#if A3D_SKINNING == 8\n  a3d_wsum += a_weights1.x + a_weights1.y + a_weights1.z + a_weights1.w;\n#endif\n  if (a3d_wsum > 1e-4) {\n    mat4 s = a3dSkin(u_boneTexture);\n    // Affine output (three.js transformed parity): the skinned point is the\n    // blend's xyz with w pinned to 1. Some palette producers pack per-joint\n    // data in the matrix bottom row; letting it into gl_Position would\n    // projectively warp the rasterized silhouette away from the positions\n    // a CPU skinning reference computes.\n    vec4 a3d_skinned = s * vec4(p, 1.0);\n    localPos = vec4(a3d_skinned.xyz, 1.0);\n    localNormal = mat3(s) * n;\n    localTangent = vec4(mat3(s) * tg.xyz, tg.w);\n  } else {\n    localPos = vec4(p, 1.0); localNormal = n; localTangent = tg;\n  }\n#else\n  localPos = vec4(p, 1.0); localNormal = n; localTangent = tg;\n#endif\n}\n#ifdef A3D_VELOCITY\nvoid a3dDeformPrevious(out vec4 pos) {\n  vec3 p = a_position; vec3 n = vec3(0.0); vec4 tg = vec4(0.0, 0.0, 0.0, 1.0);\n#ifdef A3D_MORPH\n  for (int k = 0; k < A3D_MORPH_MAX_ACTIVE; ++k) {\n    if (k >= int(u_morphActiveCount)) break;\n    int tgt = a3dMorphTargetIndex(k); float w = u_morphPrevWeight4[k >> 2][k & 3];\n    p += a3dMorphFetch(tgt, 0).xyz * w;\n  }\n#endif\n#ifdef A3D_SKINNING\n  float a3d_wsum = a_weights.x + a_weights.y + a_weights.z + a_weights.w;\n#if A3D_SKINNING == 8\n  a3d_wsum += a_weights1.x + a_weights1.y + a_weights1.z + a_weights1.w;\n#endif\n  if (a3d_wsum > 1e-4) {\n    vec4 a3d_prev = a3dSkin(u_prevBoneTexture) * vec4(p, 1.0);\n    pos = vec4(a3d_prev.xyz, 1.0);\n  } else {\n    pos = vec4(p, 1.0);\n  }\n#else\n  pos = vec4(p, 1.0);\n#endif\n}\n#endif\n";
+//# sourceMappingURL=deform.glsl.d.ts.map

package/dist/shaders/deform/deform.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deform.glsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/deform.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB,sqFAkFjC,CAAC"}

package/dist/shaders/deform/deform.glsl.js

@@ -0,0 +1,99 @@
+/**
+ * C-18 chunk `a3d_prd06_deform` (PRD-06 §8.3/§8.5) — the shared deformation
+ * entry spliced at hook `vertex:deform` by feature `prd06.deform`. Ordering is
+ * morph → skin → model (glTF/three.js). `A3D_DEPTH_ONLY` skips normal/tangent
+ * work for depth and distance passes; `A3D_HAS_TANGENT` guards the tangent
+ * attribute; `A3D_VELOCITY` exposes `a3dDeformPrevious` for C-14.
+ *
+ * Depends on `a3d_prd06_skinning_common` and `a3d_prd06_morph_texture` being
+ * spliced ahead of it (both are `#ifdef`-guarded no-ops when inactive).
+ *
+ * `a_normal` is only declared when the program defines `A3D_NEED_NORMAL`
+ * (unlit forward variants do not), so the deform read guards on it as well;
+ * `a_tangent` (legacy location 3) is declared here under `A3D_HAS_TANGENT`
+ * since the generated attribute block does not carry it.
+ */
+export const A3D_PRD06_DEFORM_GLSL = /* glsl */ `
+#ifdef A3D_HAS_TANGENT
+layout(location = 3) in vec4 a_tangent;
+#endif
+// Wind composes after morph/skin through its canonical C-18 entry.
+#define A3D_DEFORM_ENTRY 1
+#ifdef A3D_PRD10_WIND
+void a3dDeformBeforeWind(out vec4 localPos, out vec3 localNormal, out vec4 localTangent) {
+#else
+void a3dDeform(out vec4 localPos, out vec3 localNormal, out vec4 localTangent) {
+#endif
+#ifdef A3D_DEPTH_ONLY
+  vec3 p = a_position;
+  vec3 n = vec3(0.0); vec4 tg = vec4(0.0, 0.0, 0.0, 1.0);
+#else
+  vec3 p = a_position;
+#ifdef A3D_NEED_NORMAL
+  vec3 n = a_normal;
+#else
+  vec3 n = vec3(0.0, 0.0, 1.0);
+#endif
+#ifdef A3D_HAS_TANGENT
+  vec4 tg = a_tangent;
+#else
+  vec4 tg = vec4(0.0, 0.0, 0.0, 1.0);
+#endif
+#endif
+#ifdef A3D_MORPH
+  a3dApplyMorph(p, n, tg);
+#endif
+#ifdef A3D_SKINNING
+  // Zero-weight guard (legacy ShaderLibrary skinned-unlit semantics): an
+  // unweighted vertex on a skinned mesh keeps its raw position instead of
+  // collapsing to the origin.
+  float a3d_wsum = a_weights.x + a_weights.y + a_weights.z + a_weights.w;
+#if A3D_SKINNING == 8
+  a3d_wsum += a_weights1.x + a_weights1.y + a_weights1.z + a_weights1.w;
+#endif
+  if (a3d_wsum > 1e-4) {
+    mat4 s = a3dSkin(u_boneTexture);
+    // Affine output (three.js transformed parity): the skinned point is the
+    // blend's xyz with w pinned to 1. Some palette producers pack per-joint
+    // data in the matrix bottom row; letting it into gl_Position would
+    // projectively warp the rasterized silhouette away from the positions
+    // a CPU skinning reference computes.
+    vec4 a3d_skinned = s * vec4(p, 1.0);
+    localPos = vec4(a3d_skinned.xyz, 1.0);
+    localNormal = mat3(s) * n;
+    localTangent = vec4(mat3(s) * tg.xyz, tg.w);
+  } else {
+    localPos = vec4(p, 1.0); localNormal = n; localTangent = tg;
+  }
+#else
+  localPos = vec4(p, 1.0); localNormal = n; localTangent = tg;
+#endif
+}
+#ifdef A3D_VELOCITY
+void a3dDeformPrevious(out vec4 pos) {
+  vec3 p = a_position; vec3 n = vec3(0.0); vec4 tg = vec4(0.0, 0.0, 0.0, 1.0);
+#ifdef A3D_MORPH
+  for (int k = 0; k < A3D_MORPH_MAX_ACTIVE; ++k) {
+    if (k >= int(u_morphActiveCount)) break;
+    int tgt = a3dMorphTargetIndex(k); float w = u_morphPrevWeight4[k >> 2][k & 3];
+    p += a3dMorphFetch(tgt, 0).xyz * w;
+  }
+#endif
+#ifdef A3D_SKINNING
+  float a3d_wsum = a_weights.x + a_weights.y + a_weights.z + a_weights.w;
+#if A3D_SKINNING == 8
+  a3d_wsum += a_weights1.x + a_weights1.y + a_weights1.z + a_weights1.w;
+#endif
+  if (a3d_wsum > 1e-4) {
+    vec4 a3d_prev = a3dSkin(u_prevBoneTexture) * vec4(p, 1.0);
+    pos = vec4(a3d_prev.xyz, 1.0);
+  } else {
+    pos = vec4(p, 1.0);
+  }
+#else
+  pos = vec4(p, 1.0);
+#endif
+}
+#endif
+`;
+//# sourceMappingURL=deform.glsl.js.map

package/dist/shaders/deform/deform.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deform.glsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/deform.glsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkF/C,CAAC"}

package/dist/shaders/deform/deform.wgsl.d.ts

@@ -0,0 +1,15 @@
+/**
+ * PRD-06 T2.7 — WGSL twin of `a3d_prd06_deform`
+ * (`shaders/deform/deform.glsl.ts`). The GLSL `#ifdef` matrix
+ * (A3D_DEPTH_ONLY / A3D_NEED_NORMAL / A3D_HAS_TANGENT / A3D_MORPH /
+ * A3D_SKINNING==4|8 / A3D_VELOCITY) has no preprocessor equivalent in WGSL:
+ * the twin takes the caller's pre-selected inputs plus `applyMorph`,
+ * `applySkin`, and `secondInfluences` selectors, and the generated entry
+ * point passes exactly the define-selected set. `a3dDeformPrevious` is the
+ * §8.5 velocity variant — same index list, previous-frame weights and
+ * palette.
+ *
+ * Return type replaces the GLSL `out` parameters with a struct.
+ */
+export declare const A3D_PRD06_DEFORM_WGSL = "\nstruct A3dDeformOut {\n  localPos: vec4<f32>,\n  localNormal: vec3<f32>,\n  localTangent: vec4<f32>,\n};\n\nfn a3dSkinWeightSum(weights: vec4<f32>, weights1: vec4<f32>, secondInfluences: bool) -> f32 {\n  var wsum = weights.x + weights.y + weights.z + weights.w;\n  if (secondInfluences) {\n    wsum = wsum + weights1.x + weights1.y + weights1.z + weights1.w;\n  }\n  return wsum;\n}\n\nfn a3dSkinSelect(joints: vec4<u32>, weights: vec4<f32>, joints1: vec4<u32>, weights1: vec4<f32>, secondInfluences: bool) -> mat4x4<f32> {\n  if (secondInfluences) {\n    return a3dSkin8(joints, weights, joints1, weights1);\n  }\n  return a3dSkin4(joints, weights);\n}\nfn a3dSkinPrevSelect(joints: vec4<u32>, weights: vec4<f32>, joints1: vec4<u32>, weights1: vec4<f32>, secondInfluences: bool) -> mat4x4<f32> {\n  if (secondInfluences) {\n    return a3dSkinPrev8(joints, weights, joints1, weights1);\n  }\n  return a3dSkinPrev4(joints, weights);\n}\n\nfn a3dDeform(position: vec3<f32>, normal: vec3<f32>, tangent: vec4<f32>,\n             joints: vec4<u32>, weights: vec4<f32>,\n             joints1: vec4<u32>, weights1: vec4<f32>,\n             secondInfluences: bool, vertexIndex: u32,\n             applyMorph: bool, applySkin: bool) -> A3dDeformOut {\n  var p = position;\n  var n = normal;\n  var tg = tangent;\n  var result: A3dDeformOut;\n  if (applyMorph) {\n    a3dApplyMorph(vertexIndex, &p, &n, &tg);\n  }\n  // Zero-weight guard (legacy skinned-unlit semantics): an unweighted vertex\n  // on a skinned mesh keeps its raw position instead of collapsing to origin.\n  if (applySkin && a3dSkinWeightSum(weights, weights1, secondInfluences) > 1e-4) {\n    let s = a3dSkinSelect(joints, weights, joints1, weights1, secondInfluences);\n    let s3 = mat3x3<f32>(s[0].xyz, s[1].xyz, s[2].xyz);\n    result.localPos = s * vec4<f32>(p, 1.0);\n    result.localNormal = s3 * n;\n    result.localTangent = vec4<f32>(s3 * tg.xyz, tg.w);\n  } else {\n    result.localPos = vec4<f32>(p, 1.0);\n    result.localNormal = n;\n    result.localTangent = tg;\n  }\n  return result;\n}\n\nfn a3dDeformPrevious(position: vec3<f32>,\n                     joints: vec4<u32>, weights: vec4<f32>,\n                     joints1: vec4<u32>, weights1: vec4<f32>,\n                     secondInfluences: bool, vertexIndex: u32,\n                     applyMorph: bool, applySkin: bool) -> vec4<f32> {\n  var p = position;\n  if (applyMorph) {\n    for (var k: u32 = 0u; k < A3D_MORPH_MAX_ACTIVE; k = k + 1u) {\n      if (k >= a3dMorphActiveCount()) { break; }\n      let tgt = a3dMorphTargetIndex(k);\n      p = p + a3dMorphFetch(vertexIndex, tgt, 0u).xyz * a3dMorphPrevWeight(k);\n    }\n  }\n  if (applySkin && a3dSkinWeightSum(weights, weights1, secondInfluences) > 1e-4) {\n    return a3dSkinPrevSelect(joints, weights, joints1, weights1, secondInfluences) * vec4<f32>(p, 1.0);\n  }\n  return vec4<f32>(p, 1.0);\n}\n";
+//# sourceMappingURL=deform.wgsl.d.ts.map

package/dist/shaders/deform/deform.wgsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deform.wgsl.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/deform.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,qBAAqB,+0FA0EjC,CAAC"}

package/dist/shaders/deform/deform.wgsl.js

@@ -0,0 +1,89 @@
+/**
+ * PRD-06 T2.7 — WGSL twin of `a3d_prd06_deform`
+ * (`shaders/deform/deform.glsl.ts`). The GLSL `#ifdef` matrix
+ * (A3D_DEPTH_ONLY / A3D_NEED_NORMAL / A3D_HAS_TANGENT / A3D_MORPH /
+ * A3D_SKINNING==4|8 / A3D_VELOCITY) has no preprocessor equivalent in WGSL:
+ * the twin takes the caller's pre-selected inputs plus `applyMorph`,
+ * `applySkin`, and `secondInfluences` selectors, and the generated entry
+ * point passes exactly the define-selected set. `a3dDeformPrevious` is the
+ * §8.5 velocity variant — same index list, previous-frame weights and
+ * palette.
+ *
+ * Return type replaces the GLSL `out` parameters with a struct.
+ */
+export const A3D_PRD06_DEFORM_WGSL = /* wgsl */ `
+struct A3dDeformOut {
+  localPos: vec4<f32>,
+  localNormal: vec3<f32>,
+  localTangent: vec4<f32>,
+};
+
+fn a3dSkinWeightSum(weights: vec4<f32>, weights1: vec4<f32>, secondInfluences: bool) -> f32 {
+  var wsum = weights.x + weights.y + weights.z + weights.w;
+  if (secondInfluences) {
+    wsum = wsum + weights1.x + weights1.y + weights1.z + weights1.w;
+  }
+  return wsum;
+}
+
+fn a3dSkinSelect(joints: vec4<u32>, weights: vec4<f32>, joints1: vec4<u32>, weights1: vec4<f32>, secondInfluences: bool) -> mat4x4<f32> {
+  if (secondInfluences) {
+    return a3dSkin8(joints, weights, joints1, weights1);
+  }
+  return a3dSkin4(joints, weights);
+}
+fn a3dSkinPrevSelect(joints: vec4<u32>, weights: vec4<f32>, joints1: vec4<u32>, weights1: vec4<f32>, secondInfluences: bool) -> mat4x4<f32> {
+  if (secondInfluences) {
+    return a3dSkinPrev8(joints, weights, joints1, weights1);
+  }
+  return a3dSkinPrev4(joints, weights);
+}
+
+fn a3dDeform(position: vec3<f32>, normal: vec3<f32>, tangent: vec4<f32>,
+             joints: vec4<u32>, weights: vec4<f32>,
+             joints1: vec4<u32>, weights1: vec4<f32>,
+             secondInfluences: bool, vertexIndex: u32,
+             applyMorph: bool, applySkin: bool) -> A3dDeformOut {
+  var p = position;
+  var n = normal;
+  var tg = tangent;
+  var result: A3dDeformOut;
+  if (applyMorph) {
+    a3dApplyMorph(vertexIndex, &p, &n, &tg);
+  }
+  // Zero-weight guard (legacy skinned-unlit semantics): an unweighted vertex
+  // on a skinned mesh keeps its raw position instead of collapsing to origin.
+  if (applySkin && a3dSkinWeightSum(weights, weights1, secondInfluences) > 1e-4) {
+    let s = a3dSkinSelect(joints, weights, joints1, weights1, secondInfluences);
+    let s3 = mat3x3<f32>(s[0].xyz, s[1].xyz, s[2].xyz);
+    result.localPos = s * vec4<f32>(p, 1.0);
+    result.localNormal = s3 * n;
+    result.localTangent = vec4<f32>(s3 * tg.xyz, tg.w);
+  } else {
+    result.localPos = vec4<f32>(p, 1.0);
+    result.localNormal = n;
+    result.localTangent = tg;
+  }
+  return result;
+}
+
+fn a3dDeformPrevious(position: vec3<f32>,
+                     joints: vec4<u32>, weights: vec4<f32>,
+                     joints1: vec4<u32>, weights1: vec4<f32>,
+                     secondInfluences: bool, vertexIndex: u32,
+                     applyMorph: bool, applySkin: bool) -> vec4<f32> {
+  var p = position;
+  if (applyMorph) {
+    for (var k: u32 = 0u; k < A3D_MORPH_MAX_ACTIVE; k = k + 1u) {
+      if (k >= a3dMorphActiveCount()) { break; }
+      let tgt = a3dMorphTargetIndex(k);
+      p = p + a3dMorphFetch(vertexIndex, tgt, 0u).xyz * a3dMorphPrevWeight(k);
+    }
+  }
+  if (applySkin && a3dSkinWeightSum(weights, weights1, secondInfluences) > 1e-4) {
+    return a3dSkinPrevSelect(joints, weights, joints1, weights1, secondInfluences) * vec4<f32>(p, 1.0);
+  }
+  return vec4<f32>(p, 1.0);
+}
+`;
+//# sourceMappingURL=deform.wgsl.js.map

package/dist/shaders/deform/deform.wgsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deform.wgsl.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/deform.wgsl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0E/C,CAAC"}

package/dist/shaders/deform/depthFeature.d.ts

@@ -0,0 +1,22 @@
+/**
+ * PRD-06 T0.13 — `prd06.deform` depth/velocity variant feature.
+ *
+ * Registered through the C-11 `registerDepthVariantFeature` registry under
+ * `A3D_QR_ANIMATION_SKINNED_SHADOWS` (the registry's `active(flags)` gates on
+ * the entry flag). `DepthPass.ts` (owner 02) consumes registered features —
+ * that composition is C-11 real (Q-02-1); this module only declares the
+ * feature and its shared `SkinningUniforms.bindBoneTexture` bind.
+ *
+ * `select` returns the variant pass name as the feature value so `defines`
+ * can emit `A3D_DEPTH_ONLY` for the `depth`/`distance` passes while `velocity`
+ * keeps the previous-palette path (`u_prevBoneTexture` is bound
+ * unconditionally — the deform chunk declares it under `#ifdef A3D_VELOCITY`).
+ */
+import type { QrFlagName } from "../../contracts/core.js";
+import { type DepthVariantFeature } from "../../contracts/shadows.js";
+import type { SkinningPaletteTextureCache } from "../../SkinningPaletteTextureCache.js";
+export declare const PRD06_DEFORM_DEPTH_FLAG: QrFlagName;
+export declare function createPrd06DeformDepthFeature(cache: SkinningPaletteTextureCache): DepthVariantFeature;
+/** Returns the C-11 registry disposer. */
+export declare function registerPrd06DeformDepthFeature(cache: SkinningPaletteTextureCache): () => void;
+//# sourceMappingURL=depthFeature.d.ts.map

package/dist/shaders/deform/depthFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthFeature.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/depthFeature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAG1D,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEnG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAGxF,eAAO,MAAM,uBAAuB,EAAE,UAA+C,CAAC;AAEtF,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,2BAA2B,GAAG,mBAAmB,CAoBrG;AAED,0CAA0C;AAC1C,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,2BAA2B,GAAG,MAAM,IAAI,CAE9F"}

package/dist/shaders/deform/depthFeature.js

@@ -0,0 +1,44 @@
+/**
+ * PRD-06 T0.13 — `prd06.deform` depth/velocity variant feature.
+ *
+ * Registered through the C-11 `registerDepthVariantFeature` registry under
+ * `A3D_QR_ANIMATION_SKINNED_SHADOWS` (the registry's `active(flags)` gates on
+ * the entry flag). `DepthPass.ts` (owner 02) consumes registered features —
+ * that composition is C-11 real (Q-02-1); this module only declares the
+ * feature and its shared `SkinningUniforms.bindBoneTexture` bind.
+ *
+ * `select` returns the variant pass name as the feature value so `defines`
+ * can emit `A3D_DEPTH_ONLY` for the `depth`/`distance` passes while `velocity`
+ * keeps the previous-palette path (`u_prevBoneTexture` is bound
+ * unconditionally — the deform chunk declares it under `#ifdef A3D_VELOCITY`).
+ */
+import { registerDepthVariantFeature } from "../../contracts/shadows.js";
+import { bindBoneTexture } from "../../SkinningUniforms.js";
+export const PRD06_DEFORM_DEPTH_FLAG = "A3D_QR_ANIMATION_SKINNED_SHADOWS";
+export function createPrd06DeformDepthFeature(cache) {
+    return {
+        id: "prd06.deform",
+        owner: "prd06",
+        flag: PRD06_DEFORM_DEPTH_FLAG,
+        passes: ["depth", "distance", "velocity"],
+        select(input) {
+            if (!input.item.skinning)
+                return undefined;
+            return input.pass === "depth" || input.pass === "distance" || input.pass === "velocity" ? input.pass : undefined;
+        },
+        defines(value) {
+            return value === "depth" || value === "distance" ? { A3D_DEPTH_ONLY: true } : {};
+        },
+        chunks: ["a3d_prd06_skinning_common", "a3d_prd06_deform"],
+        hooks: ["vertex:deform"],
+        bindUniforms(_value, item, set) {
+            // The texture this frame's forward bind already uploaded — no second upload.
+            bindBoneTexture(set, cache, item);
+        }
+    };
+}
+/** Returns the C-11 registry disposer. */
+export function registerPrd06DeformDepthFeature(cache) {
+    return registerDepthVariantFeature(createPrd06DeformDepthFeature(cache));
+}
+//# sourceMappingURL=depthFeature.js.map

package/dist/shaders/deform/depthFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"depthFeature.js","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/depthFeature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,EAAE,2BAA2B,EAA4B,MAAM,4BAA4B,CAAC;AAGnG,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,MAAM,CAAC,MAAM,uBAAuB,GAAe,kCAAkC,CAAC;AAEtF,MAAM,UAAU,6BAA6B,CAAC,KAAkC;IAC9E,OAAO;QACL,EAAE,EAAE,cAAc;QAClB,KAAK,EAAE,OAAO;QACd,IAAI,EAAE,uBAAuB;QAC7B,MAAM,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,UAAU,CAAC;QACzC,MAAM,CAAC,KAA+B;YACpC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ;gBAAE,OAAO,SAAS,CAAC;YAC3C,OAAO,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,IAAI,KAAK,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;QACnH,CAAC;QACD,OAAO,CAAC,KAAgC;YACtC,OAAO,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACnF,CAAC;QACD,MAAM,EAAE,CAAC,2BAA2B,EAAE,kBAAkB,CAAC;QACzD,KAAK,EAAE,CAAC,eAAe,CAAC;QACxB,YAAY,CAAC,MAAiC,EAAE,IAAgB,EAAE,GAA4C;YAC5G,6EAA6E;YAC7E,eAAe,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QACpC,CAAC;KACF,CAAC;AACJ,CAAC;AAED,0CAA0C;AAC1C,MAAM,UAAU,+BAA+B,CAAC,KAAkC;IAChF,OAAO,2BAA2B,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAAC;AAC3E,CAAC"}

package/dist/shaders/deform/forwardFeature.d.ts

@@ -0,0 +1,114 @@
+/**
+ * PRD-06 T2.2 — the forward `prd06.deform` C-02 `ShaderFeature`
+ * (PRD-06 §269, §1145, §1222).
+ *
+ * `select` produces the deform program key per item:
+ *   `skin4` | `skin8`            — joint-palette skinning (4/8 influences)
+ *   `morph<B>[n][t]`             — §8.2 bucket {4,8,16,32}, `n`/`t` when the
+ *                                  packed set carries normal/tangent deltas
+ *   `|k<K>`                      — `A3D_MORPH_MAX_ACTIVE` (C-27 tier cap)
+ * Combined with `|` (e.g. `skin8|morph16n|k32`); a rigid item returns
+ * `undefined` so it keeps the base program.
+ *
+ * `defines` emits `A3D_SKINNING`, `A3D_MORPH` (bucket), `A3D_MORPH_NORMALS`,
+ * `A3D_MORPH_TANGENTS`, `A3D_HAS_TANGENT` and `A3D_MORPH_MAX_ACTIVE` parsed
+ * back out of the key. A `true` stamp (the pre-select MaterialFeatures record)
+ * contributes the chunks/hook with no defines — a compile-clean passthrough
+ * until the per-item select consumer lands (qr-request Q-01-4).
+ *
+ * `bindUniforms` binds the shared bone-texture palette (`bindBoneTexture`,
+ * same cache entry as the forward/draw-time bind so depth and velocity see
+ * this frame's upload) plus the morph array texture and the packed top-K
+ * active list when the item carries morphs.
+ *
+ * Draw-time consumption note: nothing in the forward path calls
+ * `select`/`bindUniforms` per item yet (Q-01-4). The lane-side consumer is
+ * `applyGpuMorphUniforms` in `forward/Deform.ts`, which delegates to
+ * `bindPrd06MorphTextureUniforms` when the bound program declares
+ * `u_morphTexture` — its K comes from the program's own reflected
+ * `u_morphActiveIndex4` array bound, which equals the `A3D_MORPH_MAX_ACTIVE`
+ * it was compiled with.
+ */
+import type { AuraQualityTierSettings } from "../../contracts/quality.js";
+import type { QrFlags } from "../../contracts/core.js";
+import type { RenderItem } from "../../contracts/renderItem.js";
+import { type ShaderFeature, type ShaderFeatureSelectInput } from "../../contracts/program.js";
+import type { UniformValue, RenderShaderProgram } from "../../RenderDevice.js";
+import type { Geometry } from "../../Geometry.js";
+import type { MorphTargetDelta } from "../../MorphTarget.js";
+import type { SkinningPaletteTextureCache } from "../../SkinningPaletteTextureCache.js";
+import { type MorphTargetTextureResult, type MorphTextureLimits } from "../../resources/MorphTargetTexture.js";
+/**
+ * C-27 active-morph caps (§285/§699): 8 Low / 16 Medium / 32 High / 64 Ultra.
+ * `AuraQualityTierSettings` carries no tier name, so `maxLightsPerPixel`
+ * (4/8/16/32, unique per stock tier) discriminates; custom overrides keep the
+ * nearest lower cap. Q-11-2 allows PRD-06 constants keyed by tier until the
+ * C-27 contract lands.
+ */
+export declare function morphMaxActiveForTier(tier: AuraQualityTierSettings): number;
+/** The `prd06.deform` feature key for an item, or undefined when rigid. */
+export declare function selectPrd06DeformValue(item: RenderItem, pass: ShaderFeatureSelectInput["pass"], tier: AuraQualityTierSettings, flags: QrFlags): string | undefined;
+export interface Prd06DeformKey {
+    readonly influences: 4 | 8 | null;
+    readonly morphBucket: 4 | 8 | 16 | 32 | null;
+    readonly morphNormals: boolean;
+    readonly morphTangents: boolean;
+    readonly morphMaxActive: number | null;
+}
+/** Parse a select-produced key back into its parts. Unknown segments are ignored. */
+export declare function parsePrd06DeformKey(value: string): Prd06DeformKey;
+/** `defines` for a select-produced key; `true` (pre-select stamp) contributes no defines. */
+export declare function prd06DeformDefines(value: string | number | boolean): Readonly<Record<string, string | number | true>>;
+/** Build function injected at registration — the C-18 provider (flag-deferring). */
+type MorphTextureBuilder = (geometry: Geometry, targets: readonly MorphTargetDelta[], limits: MorphTextureLimits, format?: "rgba16f" | "rgba32f") => MorphTargetTextureResult;
+/**
+ * Conservative bind-time texture limits. `MorphTextureLimits` normally derives
+ * from tier device caps; at uniform-bind time only the compiled program is
+ * visible, so the WebGL2 baseline-safe `{4096, 32}` applies (the builder
+ * falls back to CPU when exceeded — `applyGpuMorphUniforms` then reports the
+ * CPU path). 32 layers is the §8.2 bucket ceiling.
+ */
+export declare const PRD06_MORPH_TEXTURE_LIMITS: MorphTextureLimits;
+/**
+ * §16 S3 — public acquire seam: build-or-return the §8.2 morph array texture
+ * for an item, exactly the call the feature's `bindUniforms` makes per frame.
+ * Exported so teardown paths and the lifecycle spec's acquisition step use
+ * the same cache the feature binds from (no second morph-texture source).
+ */
+export declare function ensureMorphTargetTexture(item: RenderItem): MorphTargetTextureResult | undefined;
+/**
+ * §16 S3 — actor teardown frees its morph array texture: the cached
+ * `Texture` is disposed (dropping it from the WebGL2 live-texture count) and
+ * the geometry's cache entry cleared so a later load rebuilds fresh. Mirrors
+ * `releasePalette`'s seam — `GLTFSceneAnimationRuntime.dispose` and the
+ * `prd06.animation` actor-extension dispose call it per renderable geometry.
+ */
+export declare function releaseMorphTargetTexture(geometry: Geometry): void;
+/** §16 S3 counter — live (non-disposed) morph array textures + bytes. */
+export declare function morphTextureDiagnostics(): {
+    readonly textures: number;
+    readonly bytes: number;
+};
+/**
+ * §8.2 top-K packing: non-zero weights sorted by |w| desc, first `maxActive`,
+ * padded to a multiple of 4 with index 0 / weight 0. Returns the packed index
+ * and weight arrays (`maxActive` floats each — K/4 vec4 slots on the wire).
+ */
+export declare function packActiveMorphs(weights: readonly number[] | Float32Array, targetCount: number, maxActive: number, previousWeights?: Float32Array): {
+    indices: Float32Array;
+    current: Float32Array;
+    previous: Float32Array | null;
+    count: number;
+};
+/**
+ * Bind the §8.2 morph uniforms onto `uniforms`. Returns false when the item
+ * has no morphs, no builder is registered, or the texture build fell back to
+ * CPU (caller then takes the CPU path). `maxActive` is the compiled
+ * `A3D_MORPH_MAX_ACTIVE` — the program's own `u_morphActiveIndex4` array bound.
+ */
+export declare function bindPrd06MorphTextureUniforms(item: RenderItem, shader: RenderShaderProgram, uniforms: Map<string, UniformValue>): boolean;
+export declare function createPrd06DeformFeature(cache: SkinningPaletteTextureCache, buildMorphTexture: MorphTextureBuilder): ShaderFeature;
+/** Registers the forward feature; returns the C-02 registry disposer. Idempotent per call site. */
+export declare function registerPrd06DeformFeature(cache: SkinningPaletteTextureCache, buildMorphTexture: MorphTextureBuilder): () => void;
+export {};
+//# sourceMappingURL=forwardFeature.d.ts.map

package/dist/shaders/deform/forwardFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwardFeature.d.ts","sourceRoot":"","sources":["../../../../../../packages/rendering/src/shaders/deform/forwardFeature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC/E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF,OAAO,EAAqB,KAAK,wBAAwB,EAAE,KAAK,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAKlI;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAG3E;AAkBD,2EAA2E;AAC3E,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,wBAAwB,CAAC,MAAM,CAAC,EACtC,IAAI,EAAE,uBAAuB,EAC7B,KAAK,EAAE,OAAO,GACb,MAAM,GAAG,SAAS,CAQpB;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAsBjE;AAED,6FAA6F;AAC7F,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC,CAerH;AAID,oFAAoF;AACpF,KAAK,mBAAmB,GAAG,CACzB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,KAC3B,wBAAwB,CAAC;AAE9B;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,kBAAiE,CAAC;AAgC3G;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,wBAAwB,GAAG,SAAS,CAE/F;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAQlE;AAED,yEAAyE;AACzE,wBAAgB,uBAAuB,IAAI;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAS/F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,EACzC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,YAAY,GAC7B;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAmBhG;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,mBAAmB,EAC3B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GAClC,OAAO,CAgBT;AAID,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,2BAA2B,EAAE,iBAAiB,EAAE,mBAAmB,GAAG,aAAa,CAmClI;AAED,mGAAmG;AACnG,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,2BAA2B,EAAE,iBAAiB,EAAE,mBAAmB,GAAG,MAAM,IAAI,CAEjI"}