@opsydyn/effect-three 0.0.0-stage → 0.2.0

package/dist/runtime/SceneSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneSchema.d.ts","sourceRoot":"","sources":["../../src/runtime/SceneSchema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAc,KAAK,SAAS,IAAI,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAMzF,8DAA8D;AAC9D,eAAO,MAAM,IAAI,sEAA8D,CAAC;AAEhF,uBAAuB;AACvB,eAAO,MAAM,IAAI,2CAAmC,CAAC;AAErD,mDAAmD;AACnD,eAAO,MAAM,GAAG,YAAwE,CAAC;AAEzF,4EAA4E;AAC5E,eAAO,MAAM,QAAQ;;;;;;IAOnB,CAAC;AAEH,+BAA+B;AAC/B,eAAO,MAAM,WAAW;;;;EAItB,CAAC;AAIH,kCAAkC;AAClC,eAAO,MAAM,cAAc;;;;EAIzB,CAAC;AAEH,iCAAiC;AACjC,eAAO,MAAM,aAAa;;;EAAsE,CAAC;AAEjG,gEAAgE;AAChE,eAAO,MAAM,gBAAgB;;;;;EAK3B,CAAC;AAEH,iCAAiC;AACjC,eAAO,MAAM,aAAa;;;;;EAKxB,CAAC;AAEH,gCAAgC;AAChC,eAAO,MAAM,YAAY;;;;EAIvB,CAAC;AAEH,mCAAmC;AACnC,eAAO,MAAM,eAAe;;;;;EAK1B,CAAC;AAEH,gCAAgC;AAChC,eAAO,MAAM,YAAY;;;;EAIvB,CAAC;AAEH,kCAAkC;AAClC,eAAO,MAAM,cAAc;;;EAGzB,CAAC;AAIH,sCAAsC;AACtC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;EAkBvB,CAAC;AAEH,0BAA0B;AAC1B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWxB,CAAC;AAEH,gEAAgE;AAChE,eAAO,MAAM,MAAM;;;EAGjB,CAAC;AAEH,mCAAmC;AACnC,eAAO,MAAM,MAAM,uFAA+E,CAAC;AAEnG,gDAAgD;AAChD,eAAO,MAAM,UAAU;;;IAGrB,CAAC;AAEH,oCAAoC;AACpC,eAAO,MAAM,YAAY,uDAA+C,CAAC;AAczE,iCAAiC;AACjC,eAAO,MAAM,aAAa;;;;;;;EAIxB,CAAC;AAEH,iCAAiC;AACjC,eAAO,MAAM,eAAe;;;;;;;;;EAK1B,CAAC;AAEH,iCAAiC;AACjC,eAAO,MAAM,aAAa;;;;;;;;;;;EAOxB,CAAC;AAWH,0CAA0C;AAC1C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAAyD,CAAC;AAEvF,qGAAqG;AACrG,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;EAO3B,CAAC;AAEH,2CAA2C;AAC3C,eAAO,MAAM,cAAc;;;;;;EAAwC,CAAC;AAEpE,uDAAuD;AACvD,eAAO,MAAM,cAAc;;;EAAuE,CAAC;AAEnG,yBAAyB;AACzB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQ1B,CAAC;AAEH,wDAAwD;AACxD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAItB,CAAC;AAEH,wDAAwD;AACxD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGtB,CAAC;AAEH,mCAAmC;AACnC,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG9B,CAAC;AAKH,gDAAgD;AAChD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;EAW9B,CAAC;AAIH,qFAAqF;AACrF,eAAO,MAAM,iBAAiB;;;EAG5B,CAAC;AAEH,0DAA0D;AAC1D,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBf,CAAC;AAKH,kEAAkE;AAClE,eAAO,MAAM,OAAO;;;;;;;;;;;;IAOlB,CAAC;AAEH,yDAAyD;AACzD,eAAO,MAAM,OAAO;;;EAGlB,CAAC;AAEH,qFAAqF;AACrF,eAAO,MAAM,UAAU;;;;;EAKrB,CAAC;AAEH,iCAAiC;AACjC,eAAO,MAAM,WAAW,uDAA+C,CAAC;AAExE,oCAAoC;AACpC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBpB,CAAC;AAEH,kCAAkC;AAClC,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQhB,CAAC;AAEH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlB,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAanB,CAAC;AAEH,yCAAyC;AACzC,eAAO,MAAM,QAAQ;;;;;;EAMnB,CAAC;AAEH,mDAAmD;AACnD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEH,0DAA0D;AAC1D,eAAO,MAAM,SAAS;;;;EAIpB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWvB,CAAC;AAEH,2BAA2B;AAC3B,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BpB,CAAC;AAEH,6BAA6B;AAC7B,eAAO,MAAM,gBAAgB;;;;EAI3B,CAAC;AAYH,eAAO,MAAM,oBAAoB;;;;;;;;;EAS/B,CAAC;AAEH,mBAAmB;AACnB,eAAO,MAAM,cAAc;;;;;;;;;;EAUzB,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,aAAa;;;;;;;;;;;;;EAexB,CAAC;AAEH,wBAAwB;AACxB,uCAAuC;AACvC,eAAO,MAAM,QAAQ;;;;;;;EAOnB,CAAC;AAEH,0BAA0B;AAC1B,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;EAiBzB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;EAM9B,CAAC;AAEH,+CAA+C;AAC/C,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,eAAe,CAwBlD,CAAC;AAKH,4BAA4B;AAC5B,eAAO,MAAM,iBAAiB;;;;;;;;EAQ5B,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,kBAAkB;;;;;;;;EAQ7B,CAAC;AAEH,yBAAyB;AACzB,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;IAAwD,CAAC;AAI5E,gCAAgC;AAChC,eAAO,MAAM,UAAU;;;;;;;;;;IAQrB,CAAC;AAEH,kCAAkC;AAClC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAUzB,CAAC;AAEH,mDAAmD;AACnD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;EASf,CAAC;AAEH,uDAAuD;AACvD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;EAOxB,CAAC;AAEH,oCAAoC;AACpC,+BAA+B;AAC/B,eAAO,MAAM,OAAO;;;;;;;;;EASlB,CAAC;AAEH,2CAA2C;AAC3C,eAAO,MAAM,WAAW;;;;;;EAMtB,CAAC;AAEH,sBAAsB;AACtB,eAAO,MAAM,GAAG;;;;;;;;EAQd,CAAC;AAEH,2BAA2B;AAC3B,eAAO,MAAM,cAAc;;;;;;;;;;EAUzB,CAAC;AAEH,8BAA8B;AAC9B,qDAAqD;AACrD,eAAO,MAAM,QAAQ;;;;EAAuE,CAAC;AAE7F,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;EAmBb,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,QAAQ,6CAAqC,CAAC;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe3B,CAAC;AAEH,kEAAkE;AAClE,eAAO,MAAM,SAAS;;EAAwC,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;EAWpB,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;EAA6D,CAAC;AAEvF,6EAA6E;AAC7E,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;EAItB,CAAC;AAEH,sDAAsD;AACtD,eAAO,MAAM,UAAU;;EAAwC,CAAC;AAEhE,yDAAyD;AACzD,eAAO,MAAM,GAAG;;;EAAuB,CAAC;AAExC,0FAA0F;AAC1F,eAAO,MAAM,UAAU;;;;;;;EAAsE,CAAC;AAE9F,kFAAkF;AAClF,eAAO,MAAM,iBAAiB;;;EAG5B,CAAC;AAEH,0CAA0C;AAC1C,eAAO,MAAM,SAAS;;;;;EAKpB,CAAC;AAUH,wFAAwF;AACxF,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAqBlB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;EAQ1B,CAAC;AAIH,gFAAgF;AAChF,eAAO,MAAM,aAAa;;;EAGxB,CAAC;AAEH,2EAA2E;AAC3E,eAAO,MAAM,cAAc;;;;EAIzB,CAAC;AAEH,gEAAgE;AAChE,eAAO,MAAM,aAAa;;;EAA0D,CAAC;AAErF,6EAA6E;AAC7E,eAAO,MAAM,eAAe;;;;EAA6D,CAAC;AAE1F,8CAA8C;AAC9C,eAAO,MAAM,OAAO;;;;;;;EAOlB,CAAC;AAEH,sFAAsF;AACtF,eAAO,MAAM,cAAc;;;;;;;;;EAAmD,CAAC;AAE/E,oFAAoF;AACpF,eAAO,MAAM,MAAM;;;;;EAKjB,CAAC;AAEH,qFAAqF;AACrF,eAAO,MAAM,cAAc;;;;;;;EAAkD,CAAC;AAE9E,gFAAgF;AAChF,eAAO,MAAM,kBAAkB;;;;;;;;;;;EAW7B,CAAC;AAIH,iFAAiF;AACjF,eAAO,MAAM,mBAAmB;;;;EAI9B,CAAC;AAEH,8DAA8D;AAC9D,eAAO,MAAM,cAAc;;;;EAA8D,CAAC;AAE1F,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB;;;EAG5B,CAAC;AAEH,gCAAgC;AAChC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsC,CAAC;AAEjE,iEAAiE;AACjE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0BrB,CAAC;AAEH,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkB3B,CAAC"}

package/dist/runtime/errors.d.ts

@@ -0,0 +1,19 @@
+import type { DescriptionError } from '../kernel/index.ts';
+declare const InvalidScene_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "InvalidScene";
+} & Readonly<A>;
+/** A scene description was rejected. Nothing was applied. */
+export declare class InvalidScene extends InvalidScene_base<{
+    readonly error: DescriptionError;
+}> {
+}
+declare const RendererUnavailable_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RendererUnavailable";
+} & Readonly<A>;
+/** The renderer backend could not be created (for example, no WebGL2 context). */
+export declare class RendererUnavailable extends RendererUnavailable_base<{
+    readonly cause: unknown;
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/runtime/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/runtime/errors.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;;;;AAE3D,6DAA6D;AAC7D,qBAAa,YAAa,SAAQ,kBAAiC;IACjE,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;CAClC,CAAC;CAAG;;;;AAEL,kFAAkF;AAClF,qBAAa,mBAAoB,SAAQ,yBAAwC;IAC/E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG"}

package/dist/runtime/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The Effect runtime: lifetimes, services and typed errors around the kernel.
+ *
+ * @module
+ */
+export { InvalidScene, RendererUnavailable } from './errors.ts';
+export * as FrameSource from './FrameSource.ts';
+export * as ResourceRegistry from './ResourceRegistry.ts';
+export * as SceneRuntime from './SceneRuntime.ts';
+export * as SceneSchema from './SceneSchema.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC;AAChD,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAC"}

package/dist/webgl/contactShadows.d.ts

@@ -0,0 +1,5 @@
+import type { SceneRenderer } from '../kernel/renderer.ts';
+import type { ContactShadowPasses, ShadowedScene } from '../kernel/renderKit.ts';
+/** Creates the contact shadow passes for one scene graph and renderer, in GLSL. */
+export declare const createContactShadows: (graph: ShadowedScene, renderer: SceneRenderer) => ContactShadowPasses;
+//# sourceMappingURL=contactShadows.d.ts.map

package/dist/webgl/contactShadows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contactShadows.d.ts","sourceRoot":"","sources":["../../src/webgl/contactShadows.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA6CjF,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,UACxB,aAAa,YACV,aAAa,KACtB,mBAAuF,CAAC"}

package/dist/webgl/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The WebGL render kit: the scene parts written in GLSL (the sky, the shader grid,
+ * contact shadows), for renderers drawing with three.js's `WebGLRenderer`. The Foldkit
+ * adapter's `webglRendererFactory` carries it; pass it to `createSceneGraph({ kit })`
+ * when using the kernel directly.
+ *
+ * @module
+ */
+import type { RenderKit } from '../kernel/renderKit.ts';
+export declare const webglKit: RenderKit;
+//# sourceMappingURL=index.d.ts.map

package/dist/webgl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/webgl/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAKxD,eAAO,MAAM,QAAQ,EAAE,SAKtB,CAAC"}

package/dist/webgl/index.js

@@ -0,0 +1,239 @@
+import {
+  createContactShadowPasses
+} from "../index-4045wme0.js";
+
+// src/webgl/contactShadows.ts
+import { MeshDepthMaterial, ShaderMaterial } from "three";
+import { HorizontalBlurShader } from "three/addons/shaders/HorizontalBlurShader.js";
+import { VerticalBlurShader } from "three/addons/shaders/VerticalBlurShader.js";
+var shadowShader = {
+  depthOutput: "gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );",
+  shadowOutput: "gl_FragColor = vec4( shadowColor * fragCoordZ * 2.0, 1.0 - fragCoordZ );"
+};
+var depth = (color) => {
+  const material = new MeshDepthMaterial;
+  material.depthTest = false;
+  material.depthWrite = false;
+  material.onBeforeCompile = (shader) => {
+    shader.uniforms["shadowColor"] = { value: color };
+    shader.fragmentShader = `uniform vec3 shadowColor;
+${shader.fragmentShader.replace(shadowShader.depthOutput, shadowShader.shadowOutput)}`;
+  };
+  return material;
+};
+var blurShaders = {
+  horizontal: { shader: HorizontalBlurShader, step: "h" },
+  vertical: { shader: VerticalBlurShader, step: "v" }
+};
+var blur = (direction) => {
+  const { shader, step } = blurShaders[direction];
+  const material = new ShaderMaterial({ ...shader, depthTest: false });
+  return {
+    material,
+    set: (source, amount) => {
+      Reflect.set(material.uniforms["tDiffuse"] ?? {}, "value", source);
+      Reflect.set(material.uniforms[step] ?? {}, "value", amount);
+    }
+  };
+};
+var webglShadowMaterials = { depth, blur, flippedTargets: false };
+var createContactShadows = (graph, renderer) => createContactShadowPasses(graph, renderer, webglShadowMaterials);
+
+// src/webgl/shaderGrid.ts
+import {
+  BackSide,
+  Color,
+  DoubleSide,
+  FrontSide,
+  Mesh,
+  Plane,
+  PlaneGeometry,
+  ShaderMaterial as ShaderMaterial2,
+  Vector3
+} from "three";
+var sides = { front: FrontSide, back: BackSide, double: DoubleSide };
+var vertexShader = `
+  uniform vec3 cameraOnPlane;
+  uniform vec3 planeOrigin;
+  uniform float fadeDistance;
+  uniform bool infiniteGrid;
+  uniform bool followCamera;
+
+  varying vec3 gridPosition;
+  varying vec4 worldPosition;
+
+  void main() {
+    // The plane geometry lies in XY; the grid lies in XZ.
+    gridPosition = position.xzy;
+    if (infiniteGrid) gridPosition *= 1.0 + fadeDistance;
+    worldPosition = modelMatrix * vec4(gridPosition, 1.0);
+    if (followCamera) {
+      worldPosition.xyz += cameraOnPlane - planeOrigin;
+      gridPosition = (inverse(modelMatrix) * worldPosition).xyz;
+    }
+    gl_Position = projectionMatrix * viewMatrix * worldPosition;
+  }
+`;
+var fragmentShader = `
+  uniform vec3 cameraOnPlane;
+  uniform float cellSize;
+  uniform float cellThickness;
+  uniform vec3 cellColor;
+  uniform float sectionSize;
+  uniform float sectionThickness;
+  uniform vec3 sectionColor;
+  uniform float fadeDistance;
+  uniform float fadeStrength;
+  uniform float fadeFrom;
+
+  varying vec3 gridPosition;
+  varying vec4 worldPosition;
+
+  // 1 on a line of a grid with this spacing, 0 between, antialiased over a pixel.
+  float lines(float spacing, float thickness) {
+    vec2 at = gridPosition.xz / spacing;
+    vec2 away = abs(fract(at - 0.5) - 0.5) / fwidth(at);
+    return 1.0 - min(min(away.x, away.y) + 1.0 - thickness, 1.0);
+  }
+
+  void main() {
+    float cell = lines(cellSize, cellThickness);
+    float section = lines(sectionSize, sectionThickness);
+    float distanceAway = distance(cameraOnPlane * fadeFrom, worldPosition.xyz);
+    float fade = pow(1.0 - min(distanceAway / fadeDistance, 1.0), fadeStrength);
+    vec3 color = mix(cellColor, sectionColor, min(1.0, sectionThickness * section));
+    float alpha = (cell + section) * fade;
+    alpha = mix(0.75 * alpha, alpha, section);
+    if (alpha <= 0.0) discard;
+    gl_FragColor = vec4(color, alpha);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+  }
+`;
+var up = new Vector3(0, 1, 0);
+var origin = new Vector3;
+var plane = new Plane;
+var cameraPosition = new Vector3;
+var writeUniforms = (material, node) => {
+  const { uniforms } = material;
+  const set = (name, value) => {
+    const uniform = uniforms[name];
+    if (uniform !== undefined)
+      uniform.value = value;
+  };
+  set("cellSize", node.cellSize);
+  set("cellThickness", node.cellThickness);
+  set("sectionSize", node.sectionSize);
+  set("sectionThickness", node.sectionThickness);
+  set("fadeDistance", node.fadeDistance);
+  set("fadeStrength", node.fadeStrength);
+  set("fadeFrom", node.fadeFrom);
+  set("infiniteGrid", node.infinite);
+  set("followCamera", node.followCamera);
+  uniforms["cellColor"]?.value.setHex(node.cellColor);
+  uniforms["sectionColor"]?.value.setHex(node.sectionColor);
+  material.side = sides[node.side];
+};
+var writePlacement = (mesh, node) => {
+  mesh.position.fromArray(node.position);
+  mesh.rotation.fromArray([...node.rotation]);
+};
+var createShaderGrid = (node) => {
+  const material = new ShaderMaterial2({
+    uniforms: {
+      cellSize: { value: 0 },
+      cellThickness: { value: 0 },
+      cellColor: { value: new Color },
+      sectionSize: { value: 0 },
+      sectionThickness: { value: 0 },
+      sectionColor: { value: new Color },
+      fadeDistance: { value: 0 },
+      fadeStrength: { value: 0 },
+      fadeFrom: { value: 0 },
+      infiniteGrid: { value: false },
+      followCamera: { value: false },
+      cameraOnPlane: { value: new Vector3 },
+      planeOrigin: { value: new Vector3 }
+    },
+    vertexShader,
+    fragmentShader,
+    transparent: true
+  });
+  writeUniforms(material, node);
+  const mesh = new Mesh(new PlaneGeometry(...node.size), material);
+  mesh.frustumCulled = false;
+  writePlacement(mesh, node);
+  mesh.onBeforeRender = (_renderer, _scene, camera) => {
+    plane.setFromNormalAndCoplanarPoint(up, origin).applyMatrix4(mesh.matrixWorld);
+    plane.projectPoint(cameraPosition.setFromMatrixPosition(camera.matrixWorld), material.uniforms["cameraOnPlane"]?.value);
+    material.uniforms["planeOrigin"]?.value.set(0, 0, 0).applyMatrix4(mesh.matrixWorld);
+  };
+  return mesh;
+};
+var updateShaderGrid = (mesh, previous, next) => {
+  if (previous.size[0] !== next.size[0] || previous.size[1] !== next.size[1]) {
+    mesh.geometry.dispose();
+    mesh.geometry = new PlaneGeometry(...next.size);
+  }
+  writeUniforms(mesh.material, next);
+  writePlacement(mesh, next);
+};
+var disposeShaderGrid = (mesh) => {
+  mesh.geometry.dispose();
+  mesh.material.dispose();
+};
+var hostShaderGrid = (node) => {
+  const mesh = createShaderGrid(node);
+  return {
+    object: mesh,
+    update: (previous, next) => updateShaderGrid(mesh, previous, next),
+    dispose: () => disposeShaderGrid(mesh)
+  };
+};
+
+// src/webgl/sky.ts
+import { Vector3 as Vector32 } from "three";
+import { Sky as SkyMesh } from "three/addons/objects/Sky.js";
+var writeSky = (mesh, description) => {
+  const { uniforms } = mesh.material;
+  const set = (name, value) => {
+    const uniform = uniforms[name];
+    if (uniform !== undefined)
+      uniform.value = value;
+  };
+  set("turbidity", description.turbidity);
+  set("rayleigh", description.rayleigh);
+  set("mieCoefficient", description.mieCoefficient);
+  set("mieDirectionalG", description.mieDirectionalG);
+  set("cloudCoverage", description.clouds);
+  set("sunPosition", new Vector32().fromArray(description.sunPosition));
+  mesh.scale.setScalar(description.distance);
+};
+var hostSky = () => {
+  const mesh = new SkyMesh;
+  mesh.raycast = () => {
+    return;
+  };
+  return {
+    object: mesh,
+    update: (description) => writeSky(mesh, description),
+    dispose: () => {
+      mesh.geometry.dispose();
+      mesh.material.dispose();
+    }
+  };
+};
+
+// src/webgl/index.ts
+var webglKit = {
+  shading: "webgl",
+  sky: hostSky,
+  shaderGrid: hostShaderGrid,
+  contactShadows: createContactShadows
+};
+export {
+  webglKit
+};
+
+//# debugId=E10747A03E7930B464756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/webgl/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/webgl/contactShadows.ts", "../src/webgl/shaderGrid.ts", "../src/webgl/sky.ts", "../src/webgl/index.ts"],
+  "sourcesContent": [
+    "/**\n * The WebGL kit's contact shadow materials: three's depth material with its output\n * replaced by the shadow (as Drei's `ContactShadows`, `bf6f4ad`), and three's horizontal\n * and vertical blur shaders. The passes themselves are the kernel's.\n *\n * @module\n */\nimport { type Color, MeshDepthMaterial, ShaderMaterial } from 'three';\nimport { HorizontalBlurShader } from 'three/addons/shaders/HorizontalBlurShader.js';\nimport { VerticalBlurShader } from 'three/addons/shaders/VerticalBlurShader.js';\n\nimport {\n  type BlurPass,\n  createContactShadowPasses,\n  type ShadowMaterials,\n} from '../kernel/contactShadowPasses.ts';\nimport type { SceneRenderer } from '../kernel/renderer.ts';\nimport type { ContactShadowPasses, ShadowedScene } from '../kernel/renderKit.ts';\n\n/**\n * The shadow pass's edit to three's depth shader: its basic-packing output, and the\n * shadow written instead (darkest where an object touches the plane).\n */\nconst shadowShader = {\n  depthOutput: 'gl_FragColor = vec4( vec3( 1.0 - fragCoordZ ), opacity );',\n  shadowOutput: 'gl_FragColor = vec4( shadowColor * fragCoordZ * 2.0, 1.0 - fragCoordZ );',\n} as const;\n\nconst depth = (color: Color): MeshDepthMaterial => {\n  const material = new MeshDepthMaterial();\n  material.depthTest = false;\n  material.depthWrite = false;\n  material.onBeforeCompile = (shader) => {\n    shader.uniforms['shadowColor'] = { value: color };\n    shader.fragmentShader = `uniform vec3 shadowColor;\\n${shader.fragmentShader.replace(\n      shadowShader.depthOutput,\n      shadowShader.shadowOutput,\n    )}`;\n  };\n  return material;\n};\n\n/** three's blur shaders: `h` (horizontal) or `v` (vertical) is the step, `tDiffuse` the source. */\nconst blurShaders = {\n  horizontal: { shader: HorizontalBlurShader, step: 'h' },\n  vertical: { shader: VerticalBlurShader, step: 'v' },\n} as const;\n\nconst blur = (direction: 'horizontal' | 'vertical'): BlurPass => {\n  const { shader, step } = blurShaders[direction];\n  const material = new ShaderMaterial({ ...shader, depthTest: false });\n  return {\n    material,\n    set: (source, amount) => {\n      Reflect.set(material.uniforms['tDiffuse'] ?? {}, 'value', source);\n      Reflect.set(material.uniforms[step] ?? {}, 'value', amount);\n    },\n  };\n};\n\nconst webglShadowMaterials: ShadowMaterials = { depth, blur, flippedTargets: false };\n\n/** Creates the contact shadow passes for one scene graph and renderer, in GLSL. */\nexport const createContactShadows = (\n  graph: ShadowedScene,\n  renderer: SceneRenderer,\n): ContactShadowPasses => createContactShadowPasses(graph, renderer, webglShadowMaterials);\n",
+    "/**\n * Drei's `Grid` (`src/core/Grid.tsx` at `bf6f4ad`, MIT; itself after Fyrestar's\n * `THREE.InfiniteGridHelper` and threlte's `Grid`): a plane whose shader draws thin cell\n * lines and thicker section lines from screen-space derivatives, fading with distance\n * from the camera's foot on the plane. An infinite grid stretches the plane by the fade\n * distance; one that follows the camera slides under it.\n *\n * Each frame the material needs the camera drawing it projected onto the grid's plane.\n * Drei sets that in `useFrame`; here `onBeforeRender` does it, so every view (and each\n * eye in XR) gets its own camera.\n *\n * @module\n */\nimport {\n  BackSide,\n  Color,\n  DoubleSide,\n  FrontSide,\n  Mesh,\n  Plane,\n  PlaneGeometry,\n  ShaderMaterial,\n  type Side,\n  Vector3,\n} from 'three';\n\nimport type { MaterialSide, ShaderGridNode } from '../kernel/description.ts';\nimport type { HostedShaderGrid } from '../kernel/renderKit.ts';\n\n/** The mesh a shader grid is hosted as. */\nexport type HostShaderGrid = Mesh<PlaneGeometry, ShaderMaterial>;\n\nconst sides = { front: FrontSide, back: BackSide, double: DoubleSide } satisfies Record<\n  MaterialSide,\n  Side\n>;\n\nconst vertexShader = /* glsl */ `\n  uniform vec3 cameraOnPlane;\n  uniform vec3 planeOrigin;\n  uniform float fadeDistance;\n  uniform bool infiniteGrid;\n  uniform bool followCamera;\n\n  varying vec3 gridPosition;\n  varying vec4 worldPosition;\n\n  void main() {\n    // The plane geometry lies in XY; the grid lies in XZ.\n    gridPosition = position.xzy;\n    if (infiniteGrid) gridPosition *= 1.0 + fadeDistance;\n    worldPosition = modelMatrix * vec4(gridPosition, 1.0);\n    if (followCamera) {\n      worldPosition.xyz += cameraOnPlane - planeOrigin;\n      gridPosition = (inverse(modelMatrix) * worldPosition).xyz;\n    }\n    gl_Position = projectionMatrix * viewMatrix * worldPosition;\n  }\n`;\n\nconst fragmentShader = /* glsl */ `\n  uniform vec3 cameraOnPlane;\n  uniform float cellSize;\n  uniform float cellThickness;\n  uniform vec3 cellColor;\n  uniform float sectionSize;\n  uniform float sectionThickness;\n  uniform vec3 sectionColor;\n  uniform float fadeDistance;\n  uniform float fadeStrength;\n  uniform float fadeFrom;\n\n  varying vec3 gridPosition;\n  varying vec4 worldPosition;\n\n  // 1 on a line of a grid with this spacing, 0 between, antialiased over a pixel.\n  float lines(float spacing, float thickness) {\n    vec2 at = gridPosition.xz / spacing;\n    vec2 away = abs(fract(at - 0.5) - 0.5) / fwidth(at);\n    return 1.0 - min(min(away.x, away.y) + 1.0 - thickness, 1.0);\n  }\n\n  void main() {\n    float cell = lines(cellSize, cellThickness);\n    float section = lines(sectionSize, sectionThickness);\n    float distanceAway = distance(cameraOnPlane * fadeFrom, worldPosition.xyz);\n    float fade = pow(1.0 - min(distanceAway / fadeDistance, 1.0), fadeStrength);\n    vec3 color = mix(cellColor, sectionColor, min(1.0, sectionThickness * section));\n    float alpha = (cell + section) * fade;\n    alpha = mix(0.75 * alpha, alpha, section);\n    if (alpha <= 0.0) discard;\n    gl_FragColor = vec4(color, alpha);\n    #include <tonemapping_fragment>\n    #include <colorspace_fragment>\n  }\n`;\n\nconst up = new Vector3(0, 1, 0);\nconst origin = new Vector3();\nconst plane = new Plane();\nconst cameraPosition = new Vector3();\n\n/** Writes a node's settings into its material's uniforms. */\nconst writeUniforms = (material: ShaderMaterial, node: ShaderGridNode): void => {\n  const { uniforms } = material;\n  const set = (name: string, value: unknown): void => {\n    const uniform = uniforms[name];\n    if (uniform !== undefined) uniform.value = value;\n  };\n  set('cellSize', node.cellSize);\n  set('cellThickness', node.cellThickness);\n  set('sectionSize', node.sectionSize);\n  set('sectionThickness', node.sectionThickness);\n  set('fadeDistance', node.fadeDistance);\n  set('fadeStrength', node.fadeStrength);\n  set('fadeFrom', node.fadeFrom);\n  set('infiniteGrid', node.infinite);\n  set('followCamera', node.followCamera);\n  uniforms['cellColor']?.value.setHex(node.cellColor);\n  uniforms['sectionColor']?.value.setHex(node.sectionColor);\n  material.side = sides[node.side];\n};\n\n/** Places the grid and its plane from its description. */\nconst writePlacement = (mesh: HostShaderGrid, node: ShaderGridNode): void => {\n  mesh.position.fromArray(node.position);\n  mesh.rotation.fromArray([...node.rotation]);\n};\n\n/** Creates the grid mesh for a node. */\nexport const createShaderGrid = (node: ShaderGridNode): HostShaderGrid => {\n  const material = new ShaderMaterial({\n    uniforms: {\n      cellSize: { value: 0 },\n      cellThickness: { value: 0 },\n      cellColor: { value: new Color() },\n      sectionSize: { value: 0 },\n      sectionThickness: { value: 0 },\n      sectionColor: { value: new Color() },\n      fadeDistance: { value: 0 },\n      fadeStrength: { value: 0 },\n      fadeFrom: { value: 0 },\n      infiniteGrid: { value: false },\n      followCamera: { value: false },\n      cameraOnPlane: { value: new Vector3() },\n      planeOrigin: { value: new Vector3() },\n    },\n    vertexShader,\n    fragmentShader,\n    transparent: true,\n  });\n  writeUniforms(material, node);\n  const mesh: HostShaderGrid = new Mesh(new PlaneGeometry(...node.size), material);\n  // The shader moves vertices (infinite, following): the plane's own bounds mean nothing.\n  mesh.frustumCulled = false;\n  writePlacement(mesh, node);\n  mesh.onBeforeRender = (_renderer, _scene, camera) => {\n    plane.setFromNormalAndCoplanarPoint(up, origin).applyMatrix4(mesh.matrixWorld);\n    plane.projectPoint(\n      cameraPosition.setFromMatrixPosition(camera.matrixWorld),\n      material.uniforms['cameraOnPlane']?.value,\n    );\n    material.uniforms['planeOrigin']?.value.set(0, 0, 0).applyMatrix4(mesh.matrixWorld);\n  };\n  return mesh;\n};\n\n/** Applies a new description to a grid mesh. */\nexport const updateShaderGrid = (\n  mesh: HostShaderGrid,\n  previous: ShaderGridNode,\n  next: ShaderGridNode,\n): void => {\n  if (previous.size[0] !== next.size[0] || previous.size[1] !== next.size[1]) {\n    mesh.geometry.dispose();\n    mesh.geometry = new PlaneGeometry(...next.size);\n  }\n  writeUniforms(mesh.material, next);\n  writePlacement(mesh, next);\n};\n\n/** Frees the grid's geometry and material, which are its own. */\nexport const disposeShaderGrid = (mesh: HostShaderGrid): void => {\n  mesh.geometry.dispose();\n  mesh.material.dispose();\n};\n\n/** The WebGL kit's shader grid: the mesh, updated in place and freed with it. */\nexport const hostShaderGrid = (node: ShaderGridNode): HostedShaderGrid => {\n  const mesh = createShaderGrid(node);\n  return {\n    object: mesh,\n    update: (previous, next) => updateShaderGrid(mesh, previous, next),\n    dispose: () => disposeShaderGrid(mesh),\n  };\n};\n",
+    "/**\n * The WebGL kit's sky: three.js's `Sky` (Preetham, `addons/objects/Sky.js` at 0.186.1),\n * as Drei's `Sky` draws it (`bf6f4ad`, `src/core/Sky.tsx`): a box scaled to `distance`\n * whose shader paints the daylight sky for a sun position. Never picked.\n *\n * @module\n */\nimport { Vector3 } from 'three';\nimport { Sky as SkyMesh } from 'three/addons/objects/Sky.js';\n\nimport type { Sky } from '../kernel/description.ts';\nimport type { HostedSky } from '../kernel/renderKit.ts';\n\n/** Writes a sky's description into the mesh's uniforms and scale. */\nconst writeSky = (mesh: SkyMesh, description: Sky): void => {\n  const { uniforms } = mesh.material;\n  const set = (name: string, value: unknown): void => {\n    const uniform = uniforms[name];\n    if (uniform !== undefined) uniform.value = value;\n  };\n  set('turbidity', description.turbidity);\n  set('rayleigh', description.rayleigh);\n  set('mieCoefficient', description.mieCoefficient);\n  set('mieDirectionalG', description.mieDirectionalG);\n  set('cloudCoverage', description.clouds);\n  set('sunPosition', new Vector3().fromArray(description.sunPosition));\n  mesh.scale.setScalar(description.distance);\n};\n\n/** Creates the sky mesh; the scene graph adds it and writes its description. */\nexport const hostSky = (): HostedSky => {\n  const mesh = new SkyMesh();\n  mesh.raycast = () => undefined;\n  return {\n    object: mesh,\n    update: (description) => writeSky(mesh, description),\n    dispose: () => {\n      mesh.geometry.dispose();\n      mesh.material.dispose();\n    },\n  };\n};\n",
+    "/**\n * The WebGL render kit: the scene parts written in GLSL (the sky, the shader grid,\n * contact shadows), for renderers drawing with three.js's `WebGLRenderer`. The Foldkit\n * adapter's `webglRendererFactory` carries it; pass it to `createSceneGraph({ kit })`\n * when using the kernel directly.\n *\n * @module\n */\nimport type { RenderKit } from '../kernel/renderKit.ts';\nimport { createContactShadows } from './contactShadows.ts';\nimport { hostShaderGrid } from './shaderGrid.ts';\nimport { hostSky } from './sky.ts';\n\nexport const webglKit: RenderKit = {\n  shading: 'webgl',\n  sky: hostSky,\n  shaderGrid: hostShaderGrid,\n  contactShadows: createContactShadows,\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "E10747A03E7930B464756E2164756E21",
+  "names": []
+}

package/dist/webgl/shaderGrid.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Drei's `Grid` (`src/core/Grid.tsx` at `bf6f4ad`, MIT; itself after Fyrestar's
+ * `THREE.InfiniteGridHelper` and threlte's `Grid`): a plane whose shader draws thin cell
+ * lines and thicker section lines from screen-space derivatives, fading with distance
+ * from the camera's foot on the plane. An infinite grid stretches the plane by the fade
+ * distance; one that follows the camera slides under it.
+ *
+ * Each frame the material needs the camera drawing it projected onto the grid's plane.
+ * Drei sets that in `useFrame`; here `onBeforeRender` does it, so every view (and each
+ * eye in XR) gets its own camera.
+ *
+ * @module
+ */
+import { Mesh, PlaneGeometry, ShaderMaterial } from 'three';
+import type { ShaderGridNode } from '../kernel/description.ts';
+import type { HostedShaderGrid } from '../kernel/renderKit.ts';
+/** The mesh a shader grid is hosted as. */
+export type HostShaderGrid = Mesh<PlaneGeometry, ShaderMaterial>;
+/** Creates the grid mesh for a node. */
+export declare const createShaderGrid: (node: ShaderGridNode) => HostShaderGrid;
+/** Applies a new description to a grid mesh. */
+export declare const updateShaderGrid: (mesh: HostShaderGrid, previous: ShaderGridNode, next: ShaderGridNode) => void;
+/** Frees the grid's geometry and material, which are its own. */
+export declare const disposeShaderGrid: (mesh: HostShaderGrid) => void;
+/** The WebGL kit's shader grid: the mesh, updated in place and freed with it. */
+export declare const hostShaderGrid: (node: ShaderGridNode) => HostedShaderGrid;
+//# sourceMappingURL=shaderGrid.d.ts.map

package/dist/webgl/shaderGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaderGrid.d.ts","sourceRoot":"","sources":["../../src/webgl/shaderGrid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAKL,IAAI,EAEJ,aAAa,EACb,cAAc,EAGf,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,2CAA2C;AAC3C,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;AAmGjE,wCAAwC;AACxC,eAAO,MAAM,gBAAgB,SAAU,cAAc,KAAG,cAmCvD,CAAC;AAEF,gDAAgD;AAChD,eAAO,MAAM,gBAAgB,SACrB,cAAc,YACV,cAAc,QAClB,cAAc,KACnB,IAOF,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,SAAU,cAAc,KAAG,IAGxD,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,cAAc,SAAU,cAAc,KAAG,gBAOrD,CAAC"}

package/dist/webgl/sky.d.ts

@@ -0,0 +1,4 @@
+import type { HostedSky } from '../kernel/renderKit.ts';
+/** Creates the sky mesh; the scene graph adds it and writes its description. */
+export declare const hostSky: () => HostedSky;
+//# sourceMappingURL=sky.d.ts.map

package/dist/webgl/sky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sky.d.ts","sourceRoot":"","sources":["../../src/webgl/sky.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAkBxD,gFAAgF;AAChF,eAAO,MAAM,OAAO,QAAO,SAW1B,CAAC"}

package/dist/webgpu/contactShadows.d.ts

@@ -0,0 +1,5 @@
+import type { SceneRenderer } from '../kernel/renderer.ts';
+import type { ContactShadowPasses, ShadowedScene } from '../kernel/renderKit.ts';
+/** Creates the contact shadow passes for one scene graph and renderer, in TSL. */
+export declare const createContactShadows: (graph: ShadowedScene, renderer: SceneRenderer) => ContactShadowPasses;
+//# sourceMappingURL=contactShadows.d.ts.map

package/dist/webgpu/contactShadows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contactShadows.d.ts","sourceRoot":"","sources":["../../src/webgpu/contactShadows.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AA4DjF,kFAAkF;AAClF,eAAO,MAAM,oBAAoB,UACxB,aAAa,YACV,aAAa,KACtB,mBAAwF,CAAC"}

package/dist/webgpu/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The WebGPU render kit: the scene's shaded parts (the sky, the shader grid, contact
+ * shadows) written in TSL, for three.js's `WebGPURenderer` on either of its backends.
+ * The Foldkit adapter's `webgpuRendererFactory` carries it.
+ *
+ * @module
+ */
+import type { RenderKit } from '../kernel/renderKit.ts';
+export declare const webgpuKit: RenderKit;
+//# sourceMappingURL=index.d.ts.map

package/dist/webgpu/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/webgpu/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAKxD,eAAO,MAAM,SAAS,EAAE,SAMvB,CAAC"}

package/dist/webgpu/index.js

@@ -0,0 +1,216 @@
+import {
+  createContactShadowPasses
+} from "../index-4045wme0.js";
+
+// src/webgpu/contactShadows.ts
+import { NoBlending, Texture } from "three";
+import { depth, float, texture, uniform, uv, vec2 } from "three/tsl";
+import { MeshBasicNodeMaterial } from "three/webgpu";
+var plainMaterial = () => {
+  const material = new MeshBasicNodeMaterial;
+  material.transparent = true;
+  material.blending = NoBlending;
+  material.depthTest = false;
+  material.depthWrite = false;
+  material.toneMapped = false;
+  return material;
+};
+var depthMaterial = (color) => {
+  const material = plainMaterial();
+  material.colorNode = uniform(color).mul(depth).mul(2);
+  material.opacityNode = float(1).sub(depth);
+  return material;
+};
+var taps = [
+  [-4, 0.051],
+  [-3, 0.0918],
+  [-2, 0.12245],
+  [-1, 0.1531],
+  [0, 0.1633],
+  [1, 0.1531],
+  [2, 0.12245],
+  [3, 0.0918],
+  [4, 0.051]
+];
+var blur = (direction) => {
+  const source = texture(new Texture);
+  const step = uniform(0);
+  const along = direction === "horizontal" ? vec2(step, 0) : vec2(0, step);
+  const [first, ...rest] = taps.map(([offset, weight]) => source.sample(uv().add(along.mul(offset))).mul(weight));
+  const sum = rest.reduce((total, tap) => total.add(tap), first ?? source);
+  const material = plainMaterial();
+  material.colorNode = sum.rgb;
+  material.opacityNode = sum.a;
+  return {
+    material,
+    set: (map, amount) => {
+      source.value = map;
+      step.value = amount;
+    }
+  };
+};
+var webgpuShadowMaterials = {
+  depth: depthMaterial,
+  blur,
+  flippedTargets: true
+};
+var createContactShadows = (graph, renderer) => createContactShadowPasses(graph, renderer, webgpuShadowMaterials);
+
+// src/webgpu/shaderGrid.ts
+import {
+  BackSide,
+  Color,
+  DoubleSide,
+  FrontSide,
+  Mesh,
+  Plane,
+  PlaneGeometry,
+  Vector3
+} from "three";
+import {
+  abs,
+  distance,
+  float as float2,
+  fract,
+  fwidth,
+  min,
+  mix,
+  modelWorldMatrix,
+  modelWorldMatrixInverse,
+  positionGeometry,
+  pow,
+  select,
+  uniform as uniform2,
+  varying,
+  vec4
+} from "three/tsl";
+import { MeshBasicNodeMaterial as MeshBasicNodeMaterial2 } from "three/webgpu";
+var sides = { front: FrontSide, back: BackSide, double: DoubleSide };
+var createUniforms = () => ({
+  cellSize: uniform2(0.5),
+  cellThickness: uniform2(0.5),
+  cellColor: uniform2(new Color),
+  sectionSize: uniform2(1),
+  sectionThickness: uniform2(1),
+  sectionColor: uniform2(new Color),
+  fadeDistance: uniform2(100),
+  fadeStrength: uniform2(1),
+  fadeFrom: uniform2(1),
+  infinite: uniform2(0),
+  followCamera: uniform2(0),
+  cameraOnPlane: uniform2(new Vector3),
+  planeOrigin: uniform2(new Vector3)
+});
+var gridMaterial = (u) => {
+  const material = new MeshBasicNodeMaterial2({ transparent: true });
+  const lifted = positionGeometry.xzy.mul(select(u.infinite.greaterThan(0.5), u.fadeDistance.add(1), 1));
+  const shift = modelWorldMatrixInverse.mul(vec4(u.cameraOnPlane.sub(u.planeOrigin), 0)).xyz;
+  const local = select(u.followCamera.greaterThan(0.5), lifted.add(shift), lifted);
+  material.positionNode = local;
+  const gridPosition = varying(local);
+  const worldPosition = varying(modelWorldMatrix.mul(vec4(local, 1)).xyz);
+  const lines = (spacing, thickness) => {
+    const at = gridPosition.xz.div(spacing);
+    const away = abs(fract(at.sub(0.5)).sub(0.5)).div(fwidth(at));
+    return float2(1).sub(min(min(away.x, away.y).add(1).sub(thickness), 1));
+  };
+  const cell = lines(u.cellSize, u.cellThickness);
+  const section = lines(u.sectionSize, u.sectionThickness);
+  const away = distance(u.cameraOnPlane.mul(u.fadeFrom), worldPosition);
+  const fade = pow(float2(1).sub(min(away.div(u.fadeDistance), 1)), u.fadeStrength);
+  const alpha = cell.add(section).mul(fade);
+  material.colorNode = mix(u.cellColor, u.sectionColor, min(1, u.sectionThickness.mul(section)));
+  material.opacityNode = mix(alpha.mul(0.75), alpha, section);
+  material.alphaTest = 0.0001;
+  return material;
+};
+var writeUniforms = (u, material, node) => {
+  u.cellSize.value = node.cellSize;
+  u.cellThickness.value = node.cellThickness;
+  u.cellColor.value.setHex(node.cellColor);
+  u.sectionSize.value = node.sectionSize;
+  u.sectionThickness.value = node.sectionThickness;
+  u.sectionColor.value.setHex(node.sectionColor);
+  u.fadeDistance.value = node.fadeDistance;
+  u.fadeStrength.value = node.fadeStrength;
+  u.fadeFrom.value = node.fadeFrom;
+  u.infinite.value = node.infinite ? 1 : 0;
+  u.followCamera.value = node.followCamera ? 1 : 0;
+  material.side = sides[node.side];
+};
+var up = new Vector3(0, 1, 0);
+var origin = new Vector3;
+var plane = new Plane;
+var cameraPosition = new Vector3;
+var hostShaderGrid = (node) => {
+  const u = createUniforms();
+  const material = gridMaterial(u);
+  writeUniforms(u, material, node);
+  const mesh = new Mesh(new PlaneGeometry(...node.size), material);
+  mesh.frustumCulled = false;
+  const place = (next) => {
+    mesh.position.fromArray(next.position);
+    mesh.rotation.fromArray([...next.rotation]);
+  };
+  place(node);
+  mesh.onBeforeRender = (_renderer, _scene, camera) => {
+    plane.setFromNormalAndCoplanarPoint(up, origin).applyMatrix4(mesh.matrixWorld);
+    plane.projectPoint(cameraPosition.setFromMatrixPosition(camera.matrixWorld), u.cameraOnPlane.value);
+    u.planeOrigin.value.set(0, 0, 0).applyMatrix4(mesh.matrixWorld);
+  };
+  return {
+    object: mesh,
+    update: (previous, next) => {
+      if (previous.size[0] !== next.size[0] || previous.size[1] !== next.size[1]) {
+        mesh.geometry.dispose();
+        mesh.geometry = new PlaneGeometry(...next.size);
+      }
+      writeUniforms(u, material, next);
+      place(next);
+    },
+    dispose: () => {
+      mesh.geometry.dispose();
+      material.dispose();
+    }
+  };
+};
+
+// src/webgpu/sky.ts
+import { SkyMesh } from "three/addons/objects/SkyMesh.js";
+var writeSky = (mesh, description) => {
+  mesh.turbidity.value = description.turbidity;
+  mesh.rayleigh.value = description.rayleigh;
+  mesh.mieCoefficient.value = description.mieCoefficient;
+  mesh.mieDirectionalG.value = description.mieDirectionalG;
+  mesh.cloudCoverage.value = description.clouds;
+  mesh.sunPosition.value.fromArray(description.sunPosition);
+  mesh.scale.setScalar(description.distance);
+};
+var hostSky = () => {
+  const mesh = new SkyMesh;
+  mesh.raycast = () => {
+    return;
+  };
+  return {
+    object: mesh,
+    update: (description) => writeSky(mesh, description),
+    dispose: () => {
+      mesh.geometry.dispose();
+      mesh.material.dispose();
+    }
+  };
+};
+
+// src/webgpu/index.ts
+var webgpuKit = {
+  shading: "tsl",
+  sky: hostSky,
+  shaderGrid: hostShaderGrid,
+  contactShadows: createContactShadows
+};
+export {
+  webgpuKit
+};
+
+//# debugId=3D261B4594F0512A64756E2164756E21
+//# sourceMappingURL=index.js.map