@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.5

package/dist/modules/engine/filter/filter.js

@@ -0,0 +1,88 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const filterShaderModule = {
+    name: 'filter',
+    props: {},
+    uniforms: {},
+    bindingLayout: [{ name: 'filter', group: 2 }],
+    uniformTypes: {
+        enabled: 'i32',
+        min: 'f32',
+        max: 'f32'
+    },
+    defaultUniforms: {
+        enabled: 1,
+        min: 0,
+        max: 1
+    },
+    vs: /* glsl */ `\
+layout(std140) uniform filterUniforms {
+  int enabled;
+  float min;
+  float max;
+} filterState;
+
+bool filter_isVisible(float value) {
+  return filterState.enabled == 0 || (value >= filterState.min && value <= filterState.max);
+}
+`,
+    source: /* wgsl */ `\
+struct FilterUniforms {
+  enabled: i32,
+  min: f32,
+  max: f32,
+};
+
+@group(2) @binding(auto) var<uniform> filterUniforms: FilterUniforms;
+
+fn filter_isVisible(value: f32) -> bool {
+  return filterUniforms.enabled == 0 ||
+    (value >= filterUniforms.min && value <= filterUniforms.max);
+}
+`,
+    getUniforms(props = {}) {
+        const uniforms = {};
+        if (props.enabled !== undefined) {
+            uniforms.enabled = Number(props.enabled);
+        }
+        if (props.min !== undefined) {
+            uniforms.min = props.min;
+        }
+        if (props.max !== undefined) {
+            uniforms.max = props.max;
+        }
+        return uniforms;
+    }
+};
+/** Scalar inclusive-range filtering for shaders that expose the `FILTER_POSITION` vertex hook. */
+export const filterShaderPlugin = {
+    name: 'filter',
+    modules: [filterShaderModule],
+    vertexInputs: {
+        filterValues: 'f32'
+    },
+    glsl: {
+        injections: [
+            {
+                target: 'vs:FILTER_POSITION',
+                injection: `\
+if (!filter_isVisible(filterValues)) {
+  position = vec4(2.0, 2.0, 2.0, 1.0);
+}`
+            }
+        ]
+    },
+    wgsl: {
+        injections: [
+            {
+                target: 'vs:FILTER_POSITION',
+                injection: `\
+if (!filter_isVisible(filterValues)) {
+  *position = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+}`
+            }
+        ]
+    }
+};
+//# sourceMappingURL=filter.js.map

package/dist/modules/engine/filter/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../../../../src/modules/engine/filter/filter.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAoB5D,MAAM,kBAAkB,GAAG;IACzB,IAAI,EAAE,QAAQ;IACd,KAAK,EAAE,EAA6B;IACpC,QAAQ,EAAE,EAAoB;IAC9B,aAAa,EAAE,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAC,CAAC;IAC3C,YAAY,EAAE;QACZ,OAAO,EAAE,KAAK;QACd,GAAG,EAAE,KAAK;QACV,GAAG,EAAE,KAAK;KACX;IACD,eAAe,EAAE;QACf,OAAO,EAAE,CAAC;QACV,GAAG,EAAE,CAAC;QACN,GAAG,EAAE,CAAC;KACP;IACD,EAAE,EAAE,UAAU,CAAC;;;;;;;;;;CAUhB;IACC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;;CAapB;IACC,WAAW,CAAC,QAAiC,EAAE;QAC7C,MAAM,QAAQ,GAA4B,EAAE,CAAC;QAC7C,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YAChC,QAAQ,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC3C,CAAC;QACD,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;YAC5B,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;QAC3B,CAAC;QACD,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,EAAE,CAAC;YAC5B,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;QAC3B,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;CACuE,CAAC;AAE3E,kGAAkG;AAClG,MAAM,CAAC,MAAM,kBAAkB,GAAiB;IAC9C,IAAI,EAAE,QAAQ;IACd,OAAO,EAAE,CAAC,kBAAkB,CAAC;IAC7B,YAAY,EAAE;QACZ,YAAY,EAAE,KAAK;KACpB;IACD,IAAI,EAAE;QACJ,UAAU,EAAE;YACV;gBACE,MAAM,EAAE,oBAAoB;gBAC5B,SAAS,EAAE;;;EAGjB;aACK;SACF;KACF;IACD,IAAI,EAAE;QACJ,UAAU,EAAE;YACV;gBACE,MAAM,EAAE,oBAAoB;gBAC5B,SAAS,EAAE;;;EAGjB;aACK;SACF;KACF;CACF,CAAC"}

package/dist/modules/engine/geometry/geometry.cjs

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var geometry_exports = {};
+__export(geometry_exports, {
+  geometry: () => geometry
+});
+module.exports = __toCommonJS(geometry_exports);
+const vs = (
+  /* glsl */
+  `varying vec4 geometry_vPosition;
+varying vec3 geometry_vNormal;
+
+void geometry_setNormal(vec3 normal) {
+  geometry_vNormal = normal;
+}
+
+void geometry_setPosition(vec4 position) {
+  geometry_vPosition = position;
+}
+
+void geometry_setPosition(vec3 position) {
+  geometry_vPosition = vec4(position, 1.);
+}
+`
+);
+const fs = (
+  /* glsl */
+  `varying vec4 geometry_vPosition;
+varying vec3 geometry_vNormal;
+
+vec4 geometry_getPosition() {
+  return geometry_vPosition;
+}
+
+vec3 geometry_getNormal() {
+  return geometry_vNormal;
+}
+`
+);
+const geometry = {
+  name: "geometry",
+  vs,
+  fs
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  geometry
+});

package/dist/modules/engine/geometry/geometry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Geometry varyings
+ */
+export declare const geometry: {
+    name: string;
+    vs: string;
+    fs: string;
+};
+//# sourceMappingURL=geometry.d.ts.map

package/dist/modules/engine/geometry/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/geometry/geometry.ts"],"names":[],"mappings":"AAqCA;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;CAIpB,CAAC"}

package/dist/modules/engine/geometry/geometry.js

@@ -0,0 +1,42 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// import {ShaderModule} from '../../types';
+// TODO - reuse normal from geometry module
+const vs = /* glsl */ `\
+varying vec4 geometry_vPosition;
+varying vec3 geometry_vNormal;
+
+void geometry_setNormal(vec3 normal) {
+  geometry_vNormal = normal;
+}
+
+void geometry_setPosition(vec4 position) {
+  geometry_vPosition = position;
+}
+
+void geometry_setPosition(vec3 position) {
+  geometry_vPosition = vec4(position, 1.);
+}
+`;
+const fs = /* glsl */ `\
+varying vec4 geometry_vPosition;
+varying vec3 geometry_vNormal;
+
+vec4 geometry_getPosition() {
+  return geometry_vPosition;
+}
+
+vec3 geometry_getNormal() {
+  return geometry_vNormal;
+}
+`;
+/**
+ * Geometry varyings
+ */
+export const geometry = {
+    name: 'geometry',
+    vs,
+    fs
+};
+//# sourceMappingURL=geometry.js.map

package/dist/modules/engine/geometry/geometry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../../src/modules/engine/geometry/geometry.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAE5D,4CAA4C;AAE5C,2CAA2C;AAC3C,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;CAerB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;CAWrB,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,EAAE;IACF,EAAE;CACH,CAAC"}

package/dist/modules/engine/gpu-animation/gpu-animation.cjs

@@ -0,0 +1,255 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gpu_animation_exports = {};
+__export(gpu_animation_exports, {
+  gpuAnimation: () => gpuAnimation
+});
+module.exports = __toCommonJS(gpu_animation_exports);
+const source = (
+  /* wgsl */
+  `
+#ifdef HAS_GPU_CROWD_ANIMATION
+@group(0) @binding(auto) var<storage, read> gpuAnimationFrames: array<vec4f>;
+
+fn readGPUAnimationFrame(frame: u32, offset: u32, frameStride: u32) -> vec4f {
+  return gpuAnimationFrames[frame * frameStride + offset];
+}
+
+fn sampleGPUAnimationFrame(
+  frames: vec4f,
+  blend: vec4f,
+  offset: u32,
+  frameStride: u32
+) -> vec4f {
+  let first = mix(
+    readGPUAnimationFrame(u32(frames.x), offset, frameStride),
+    readGPUAnimationFrame(u32(frames.y), offset, frameStride),
+    frames.z
+  );
+  if (blend.w <= 0.0) {
+    return first;
+  }
+  let second = mix(
+    readGPUAnimationFrame(u32(blend.x), offset, frameStride),
+    readGPUAnimationFrame(u32(blend.y), offset, frameStride),
+    blend.z
+  );
+  return mix(first, second, blend.w);
+}
+
+fn sampleGPUAnimationMatrix(
+  frames: vec4f,
+  blend: vec4f,
+  firstColumn: u32,
+  frameStride: u32
+) -> mat4x4f {
+  return mat4x4f(
+    sampleGPUAnimationFrame(frames, blend, firstColumn, frameStride),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 1u, frameStride),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 2u, frameStride),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 3u, frameStride)
+  );
+}
+
+fn getGPUAnimatedSkinMatrix(
+  weights: vec4f,
+  joints: vec4u,
+  frames: vec4f,
+  blend: vec4f,
+  frameStride: u32
+) -> mat4x4f {
+  return weights.x * sampleGPUAnimationMatrix(frames, blend, 4u + joints.x * 4u, frameStride)
+       + weights.y * sampleGPUAnimationMatrix(frames, blend, 4u + joints.y * 4u, frameStride)
+       + weights.z * sampleGPUAnimationMatrix(frames, blend, 4u + joints.z * 4u, frameStride)
+       + weights.w * sampleGPUAnimationMatrix(frames, blend, 4u + joints.w * 4u, frameStride);
+}
+#endif
+
+#ifdef HAS_INSTANCED_MORPH
+@group(0) @binding(auto) var<storage, read> gpuMorphTargets: array<vec4f>;
+
+#ifndef HAS_GPU_CROWD_ANIMATION
+@group(0) @binding(auto) var<storage, read> gpuMorphWeights: array<vec4f>;
+#endif
+
+fn getGPUCrowdMorphWeight(
+  instanceIndex: u32,
+  targetIndex: u32,
+  targetCount: u32,
+  jointsPerInstance: u32,
+  frames: vec4f,
+  blend: vec4f,
+  frameStride: u32
+) -> f32 {
+#ifdef HAS_GPU_CROWD_ANIMATION
+  let offset = 4u + jointsPerInstance * 4u + targetIndex;
+  return sampleGPUAnimationFrame(frames, blend, offset, frameStride).x;
+#else
+  let packedCount = (targetCount + 3u) / 4u;
+  let packedWeights = gpuMorphWeights[instanceIndex * packedCount + targetIndex / 4u];
+  return packedWeights[targetIndex % 4u];
+#endif
+}
+
+fn getGPUCrowdMorphDelta(
+  instanceIndex: u32,
+  vertexIndex: u32,
+  attributeIndex: u32,
+  vertexCount: u32,
+  targetCount: u32,
+  jointsPerInstance: u32,
+  frames: vec4f,
+  blend: vec4f,
+  frameStride: u32
+) -> vec3f {
+  var result = vec3f(0.0);
+  for (var targetIndex = 0u; targetIndex < targetCount; targetIndex++) {
+    let weight = getGPUCrowdMorphWeight(
+      instanceIndex,
+      targetIndex,
+      targetCount,
+      jointsPerInstance,
+      frames,
+      blend,
+      frameStride
+    );
+    let offset = (targetIndex * 3u + attributeIndex) * vertexCount + vertexIndex;
+    result += gpuMorphTargets[offset].xyz * weight;
+  }
+  return result;
+}
+#endif
+`
+);
+const vs = (
+  /* glsl */
+  `
+#ifdef HAS_GPU_CROWD_ANIMATION
+uniform highp sampler2D gpuAnimationFrames;
+
+vec4 sampleGPUAnimationFrame(vec4 frames, vec4 blend, int offset) {
+  vec4 first = mix(
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(frames.x)), 0),
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(frames.y)), 0),
+    frames.z
+  );
+  if (blend.w <= 0.0) {
+    return first;
+  }
+  vec4 second = mix(
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(blend.x)), 0),
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(blend.y)), 0),
+    blend.z
+  );
+  return mix(first, second, blend.w);
+}
+
+mat4 sampleGPUAnimationMatrix(vec4 frames, vec4 blend, int firstColumn) {
+  return mat4(
+    sampleGPUAnimationFrame(frames, blend, firstColumn),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 1),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 2),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 3)
+  );
+}
+
+mat4 getGPUAnimatedSkinMatrix(vec4 weights, uvec4 joints, vec4 frames, vec4 blend) {
+  return weights.x * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.x) * 4)
+       + weights.y * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.y) * 4)
+       + weights.z * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.z) * 4)
+       + weights.w * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.w) * 4);
+}
+#endif
+
+#ifdef HAS_INSTANCED_MORPH
+uniform highp sampler2D gpuMorphTargets;
+
+#ifndef HAS_GPU_CROWD_ANIMATION
+uniform highp sampler2D gpuMorphWeights;
+#endif
+
+float getGPUCrowdMorphWeight(
+  uint instanceIndex,
+  uint targetIndex,
+  uint jointsPerInstance,
+  vec4 frames,
+  vec4 blend
+) {
+#ifdef HAS_GPU_CROWD_ANIMATION
+  int offset = 4 + int(jointsPerInstance) * 4 + int(targetIndex);
+  return sampleGPUAnimationFrame(frames, blend, offset).x;
+#else
+  vec4 packedWeights = texelFetch(
+    gpuMorphWeights,
+    ivec2(int(targetIndex / 4u), int(instanceIndex)),
+    0
+  );
+  return packedWeights[int(targetIndex % 4u)];
+#endif
+}
+
+vec3 getGPUCrowdMorphDelta(
+  uint instanceIndex,
+  uint vertexIndex,
+  uint attributeIndex,
+  uint targetCount,
+  uint jointsPerInstance,
+  vec4 frames,
+  vec4 blend
+) {
+  vec3 result = vec3(0.0);
+  for (uint targetIndex = 0u; targetIndex < targetCount; targetIndex++) {
+    float weight = getGPUCrowdMorphWeight(
+      instanceIndex,
+      targetIndex,
+      jointsPerInstance,
+      frames,
+      blend
+    );
+    result += texelFetch(
+      gpuMorphTargets,
+      ivec2(int(vertexIndex), int(targetIndex * 3u + attributeIndex)),
+      0
+    ).xyz * weight;
+  }
+  return result;
+}
+#endif
+`
+);
+const gpuAnimation = {
+  name: "gpuAnimation",
+  props: {},
+  uniforms: {},
+  bindings: {},
+  source,
+  vs,
+  fs: "",
+  bindingLayout: [
+    { name: "gpuAnimationFrames", group: 0, visibility: 1 },
+    { name: "gpuMorphTargets", group: 0, visibility: 1 },
+    { name: "gpuMorphWeights", group: 0, visibility: 1 }
+  ],
+  getUniforms(props = {}) {
+    return props;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gpuAnimation
+});

package/dist/modules/engine/gpu-animation/gpu-animation.d.ts

@@ -0,0 +1,34 @@
+import type { ShaderBinding as Binding } from "../../../types.js";
+/** GPU-resident baked animation frames and immutable morph-target resources. */
+export type GPUAnimationProps = {
+    gpuAnimationFrames?: Binding;
+    gpuMorphTargets?: Binding;
+    gpuMorphWeights?: Binding;
+};
+/** Backend-native resources consumed only by the vertex stage. */
+export type GPUAnimationBindings = GPUAnimationProps;
+/** Portable baked clip sampling and independent per-instance morph deformation. */
+export declare const gpuAnimation: {
+    readonly name: "gpuAnimation";
+    readonly props: GPUAnimationProps;
+    readonly uniforms: {};
+    readonly bindings: GPUAnimationBindings;
+    readonly source: "\n#ifdef HAS_GPU_CROWD_ANIMATION\n@group(0) @binding(auto) var<storage, read> gpuAnimationFrames: array<vec4f>;\n\nfn readGPUAnimationFrame(frame: u32, offset: u32, frameStride: u32) -> vec4f {\n  return gpuAnimationFrames[frame * frameStride + offset];\n}\n\nfn sampleGPUAnimationFrame(\n  frames: vec4f,\n  blend: vec4f,\n  offset: u32,\n  frameStride: u32\n) -> vec4f {\n  let first = mix(\n    readGPUAnimationFrame(u32(frames.x), offset, frameStride),\n    readGPUAnimationFrame(u32(frames.y), offset, frameStride),\n    frames.z\n  );\n  if (blend.w <= 0.0) {\n    return first;\n  }\n  let second = mix(\n    readGPUAnimationFrame(u32(blend.x), offset, frameStride),\n    readGPUAnimationFrame(u32(blend.y), offset, frameStride),\n    blend.z\n  );\n  return mix(first, second, blend.w);\n}\n\nfn sampleGPUAnimationMatrix(\n  frames: vec4f,\n  blend: vec4f,\n  firstColumn: u32,\n  frameStride: u32\n) -> mat4x4f {\n  return mat4x4f(\n    sampleGPUAnimationFrame(frames, blend, firstColumn, frameStride),\n    sampleGPUAnimationFrame(frames, blend, firstColumn + 1u, frameStride),\n    sampleGPUAnimationFrame(frames, blend, firstColumn + 2u, frameStride),\n    sampleGPUAnimationFrame(frames, blend, firstColumn + 3u, frameStride)\n  );\n}\n\nfn getGPUAnimatedSkinMatrix(\n  weights: vec4f,\n  joints: vec4u,\n  frames: vec4f,\n  blend: vec4f,\n  frameStride: u32\n) -> mat4x4f {\n  return weights.x * sampleGPUAnimationMatrix(frames, blend, 4u + joints.x * 4u, frameStride)\n       + weights.y * sampleGPUAnimationMatrix(frames, blend, 4u + joints.y * 4u, frameStride)\n       + weights.z * sampleGPUAnimationMatrix(frames, blend, 4u + joints.z * 4u, frameStride)\n       + weights.w * sampleGPUAnimationMatrix(frames, blend, 4u + joints.w * 4u, frameStride);\n}\n#endif\n\n#ifdef HAS_INSTANCED_MORPH\n@group(0) @binding(auto) var<storage, read> gpuMorphTargets: array<vec4f>;\n\n#ifndef HAS_GPU_CROWD_ANIMATION\n@group(0) @binding(auto) var<storage, read> gpuMorphWeights: array<vec4f>;\n#endif\n\nfn getGPUCrowdMorphWeight(\n  instanceIndex: u32,\n  targetIndex: u32,\n  targetCount: u32,\n  jointsPerInstance: u32,\n  frames: vec4f,\n  blend: vec4f,\n  frameStride: u32\n) -> f32 {\n#ifdef HAS_GPU_CROWD_ANIMATION\n  let offset = 4u + jointsPerInstance * 4u + targetIndex;\n  return sampleGPUAnimationFrame(frames, blend, offset, frameStride).x;\n#else\n  let packedCount = (targetCount + 3u) / 4u;\n  let packedWeights = gpuMorphWeights[instanceIndex * packedCount + targetIndex / 4u];\n  return packedWeights[targetIndex % 4u];\n#endif\n}\n\nfn getGPUCrowdMorphDelta(\n  instanceIndex: u32,\n  vertexIndex: u32,\n  attributeIndex: u32,\n  vertexCount: u32,\n  targetCount: u32,\n  jointsPerInstance: u32,\n  frames: vec4f,\n  blend: vec4f,\n  frameStride: u32\n) -> vec3f {\n  var result = vec3f(0.0);\n  for (var targetIndex = 0u; targetIndex < targetCount; targetIndex++) {\n    let weight = getGPUCrowdMorphWeight(\n      instanceIndex,\n      targetIndex,\n      targetCount,\n      jointsPerInstance,\n      frames,\n      blend,\n      frameStride\n    );\n    let offset = (targetIndex * 3u + attributeIndex) * vertexCount + vertexIndex;\n    result += gpuMorphTargets[offset].xyz * weight;\n  }\n  return result;\n}\n#endif\n";
+    readonly vs: "\n#ifdef HAS_GPU_CROWD_ANIMATION\nuniform highp sampler2D gpuAnimationFrames;\n\nvec4 sampleGPUAnimationFrame(vec4 frames, vec4 blend, int offset) {\n  vec4 first = mix(\n    texelFetch(gpuAnimationFrames, ivec2(offset, int(frames.x)), 0),\n    texelFetch(gpuAnimationFrames, ivec2(offset, int(frames.y)), 0),\n    frames.z\n  );\n  if (blend.w <= 0.0) {\n    return first;\n  }\n  vec4 second = mix(\n    texelFetch(gpuAnimationFrames, ivec2(offset, int(blend.x)), 0),\n    texelFetch(gpuAnimationFrames, ivec2(offset, int(blend.y)), 0),\n    blend.z\n  );\n  return mix(first, second, blend.w);\n}\n\nmat4 sampleGPUAnimationMatrix(vec4 frames, vec4 blend, int firstColumn) {\n  return mat4(\n    sampleGPUAnimationFrame(frames, blend, firstColumn),\n    sampleGPUAnimationFrame(frames, blend, firstColumn + 1),\n    sampleGPUAnimationFrame(frames, blend, firstColumn + 2),\n    sampleGPUAnimationFrame(frames, blend, firstColumn + 3)\n  );\n}\n\nmat4 getGPUAnimatedSkinMatrix(vec4 weights, uvec4 joints, vec4 frames, vec4 blend) {\n  return weights.x * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.x) * 4)\n       + weights.y * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.y) * 4)\n       + weights.z * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.z) * 4)\n       + weights.w * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.w) * 4);\n}\n#endif\n\n#ifdef HAS_INSTANCED_MORPH\nuniform highp sampler2D gpuMorphTargets;\n\n#ifndef HAS_GPU_CROWD_ANIMATION\nuniform highp sampler2D gpuMorphWeights;\n#endif\n\nfloat getGPUCrowdMorphWeight(\n  uint instanceIndex,\n  uint targetIndex,\n  uint jointsPerInstance,\n  vec4 frames,\n  vec4 blend\n) {\n#ifdef HAS_GPU_CROWD_ANIMATION\n  int offset = 4 + int(jointsPerInstance) * 4 + int(targetIndex);\n  return sampleGPUAnimationFrame(frames, blend, offset).x;\n#else\n  vec4 packedWeights = texelFetch(\n    gpuMorphWeights,\n    ivec2(int(targetIndex / 4u), int(instanceIndex)),\n    0\n  );\n  return packedWeights[int(targetIndex % 4u)];\n#endif\n}\n\nvec3 getGPUCrowdMorphDelta(\n  uint instanceIndex,\n  uint vertexIndex,\n  uint attributeIndex,\n  uint targetCount,\n  uint jointsPerInstance,\n  vec4 frames,\n  vec4 blend\n) {\n  vec3 result = vec3(0.0);\n  for (uint targetIndex = 0u; targetIndex < targetCount; targetIndex++) {\n    float weight = getGPUCrowdMorphWeight(\n      instanceIndex,\n      targetIndex,\n      jointsPerInstance,\n      frames,\n      blend\n    );\n    result += texelFetch(\n      gpuMorphTargets,\n      ivec2(int(vertexIndex), int(targetIndex * 3u + attributeIndex)),\n      0\n    ).xyz * weight;\n  }\n  return result;\n}\n#endif\n";
+    readonly fs: "";
+    readonly bindingLayout: readonly [{
+        readonly name: "gpuAnimationFrames";
+        readonly group: 0;
+        readonly visibility: 1;
+    }, {
+        readonly name: "gpuMorphTargets";
+        readonly group: 0;
+        readonly visibility: 1;
+    }, {
+        readonly name: "gpuMorphWeights";
+        readonly group: 0;
+        readonly visibility: 1;
+    }];
+    readonly getUniforms: (props?: GPUAnimationProps) => GPUAnimationBindings;
+};
+//# sourceMappingURL=gpu-animation.d.ts.map

package/dist/modules/engine/gpu-animation/gpu-animation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-animation.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/gpu-animation/gpu-animation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,IAAI,OAAO,EAAC,0BAAuB;AAoN7D,gFAAgF;AAChF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,kEAAkE;AAClE,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAErD,mFAAmF;AACnF,eAAO,MAAM,YAAY;;oBAEV,iBAAiB;;uBAEd,oBAAoB;;;;;;;;;;;;;;;;;mCASjB,iBAAiB,KAAQ,oBAAoB;CAGY,CAAC"}