@typegpu/three 0.9.0 → 0.9.2

package/index.cjs

@@ -28,13 +28,19 @@ const WGSLNodeBuilder__default = /*#__PURE__*/_interopDefaultCompat(WGSLNodeBuil
 
 class StageData {
   stage;
-  names;
   namespace;
-  codeGeneratedThusFar;
   constructor(stage) {
     this.stage = stage;
-    this.names = /* @__PURE__ */ new WeakMap();
     this.namespace = tgpu__default["~unstable"].namespace();
+  }
+}
+class GenerateStageData extends StageData {
+  names;
+  type = "generate";
+  codeGeneratedThusFar;
+  constructor(stage) {
+    super(stage);
+    this.names = /* @__PURE__ */ new WeakMap();
     this.codeGeneratedThusFar = "";
     this.namespace.on("name", (event) => {
       if (tgpu.isVariable(event.target)) {
@@ -43,16 +49,29 @@ class StageData {
     });
   }
 }
+class AnalyzeStageData extends StageData {
+  type = "analyze";
+}
 class BuilderData {
-  stageDataMap;
+  generateStageDataMap;
+  analyzeStageDataMap;
   constructor() {
-    this.stageDataMap = /* @__PURE__ */ new Map();
+    this.generateStageDataMap = /* @__PURE__ */ new Map();
+    this.analyzeStageDataMap = /* @__PURE__ */ new Map();
+  }
+  getGenerateStageData(stage) {
+    let stageData = this.generateStageDataMap.get(stage);
+    if (!stageData) {
+      stageData = new GenerateStageData(stage);
+      this.generateStageDataMap.set(stage, stageData);
+    }
+    return stageData;
   }
-  getStageData(stage) {
-    let stageData = this.stageDataMap.get(stage);
+  getAnalyzeStageData(stage) {
+    let stageData = this.analyzeStageDataMap.get(stage);
     if (!stageData) {
-      stageData = new StageData(stage);
-      this.stageDataMap.set(stage, stageData);
+      stageData = new AnalyzeStageData(stage);
+      this.analyzeStageDataMap.set(stage, stageData);
     }
     return stageData;
   }
@@ -89,7 +108,7 @@ class TgpuFnNode extends THREE__namespace.Node {
       builderData = new BuilderData();
       builderDataMap.set(builder, builderData);
     }
-    const stageData = builderData.getStageData(builder.shaderStage);
+    const stageData = builderData.getGenerateStageData(builder.shaderStage);
     if (!nodeData.custom) {
       if (currentlyGeneratingFnNodeCtx !== void 0) {
         console.warn("[@typegpu/three] Nested function generation detected");
@@ -136,16 +155,48 @@ fn ${functionId}`
     }
     return nodeData.custom.nodeFunction;
   }
+  #analyzeFunction(builder) {
+    let builderData = builderDataMap.get(builder);
+    if (!builderData) {
+      builderData = new BuilderData();
+      builderDataMap.set(builder, builderData);
+    }
+    const stageData = builderData.getAnalyzeStageData(builder.shaderStage);
+    const ctx = {
+      builder,
+      stageData,
+      dependencies: []
+    };
+    currentlyGeneratingFnNodeCtx = ctx;
+    try {
+      tgpu__default.resolve({
+        names: stageData.namespace,
+        template: "___ID___ fnName",
+        externals: { fnName: this.#impl }
+      });
+    } finally {
+      currentlyGeneratingFnNodeCtx = void 0;
+    }
+  }
+  /**
+   * Replicating Three.js `analyze` traversal.
+   * Setting `needsInterpolation` flag to true in varying nodes
+   */
+  analyze(builder, output) {
+    super.analyze(builder, output);
+    this.#analyzeFunction(builder);
+  }
   generate(builder, output) {
     this.#getNodeFunction(builder);
     const nodeData = builder.getDataFromNode(this);
     const builderData = builderDataMap.get(builder);
-    const stageData = builderData.getStageData(builder.shaderStage);
-    for (const dep of nodeData.custom.dependencies) {
+    const stageData = builderData.getGenerateStageData(builder.shaderStage);
+    const uniqueDeps = [...new Set(nodeData.custom.dependencies)];
+    for (const dep of uniqueDeps) {
       dep.node.build(builder);
     }
     nodeData.custom.priorCode.build(builder);
-    for (const dep of nodeData.custom.dependencies) {
+    for (const dep of uniqueDeps) {
       if (!dep.var) {
         continue;
       }
@@ -154,10 +205,7 @@ fn ${functionId}`
       builder.addLineFlowCode(`${varName} = ${varValue};
 `, this);
     }
-    if (output === "property") {
-      return nodeData.custom.functionId;
-    }
-    return `${nodeData.custom.functionId}()`;
+    return output === "property" ? nodeData.custom.functionId : `${nodeData.custom.functionId}()`;
   }
 }
 function toTSL(fn) {
@@ -165,29 +213,44 @@ function toTSL(fn) {
 }
 class TSLAccessor {
   #dataType;
-  var;
+  #var;
   node;
   constructor(node, dataType) {
     this.node = node;
     this.#dataType = dataType;
     if (
-      // @ts-expect-error: The properties exist on the node
-      !node.isStorageBufferNode && !node.isUniformNode || node.isTextureNode
+      // @ts-expect-error: they are assigned at runtime
+      !node.isStorageBufferNode && !node.isUniformNode || // @ts-expect-error: it is assigned at runtime
+      node.isTextureNode
     ) {
-      this.var = ((globalThis.__TYPEGPU_AUTONAME__ ?? (a => a))(tgpu__default.privateVar(dataType), "var"));
+      this.#var = tgpu__default.privateVar(dataType);
     }
   }
+  get var() {
+    return this.#var;
+  }
   get $() {
     const ctx = currentlyGeneratingFnNodeCtx;
     if (!ctx) {
       throw new Error("Can only access TSL nodes on the GPU.");
     }
+    if (ctx.stageData.type === "analyze") {
+      this.node.traverse((node) => {
+        node.analyze(ctx.builder);
+      });
+      return tgpu__default["~unstable"].rawCodeSnippet("", this.#dataType, "runtime").$;
+    }
     ctx.dependencies.push(this);
+    const builtNode = this.node.build(ctx.builder);
+    const trueVaryingNode = this.node.isVaryingNode && builtNode.includes("varyings.");
+    if (trueVaryingNode) {
+      this.#var = void 0;
+    }
     if (this.var) {
       return this.var.$;
     }
     return tgpu__default["~unstable"].rawCodeSnippet(
-      this.node.build(ctx.builder),
+      builtNode,
       this.#dataType
     ).$;
   }
@@ -221,7 +284,14 @@ const fromTSL = ((globalThis.__TYPEGPU_AUTONAME__ ?? (a => a))(tgpu__default["~u
   if (!sharedBuilder) {
     sharedBuilder = new WGSLNodeBuilder__default();
   }
-  const nodeType = node.getNodeType(sharedBuilder);
+  let nodeType = null;
+  try {
+    nodeType = node.getNodeType(sharedBuilder);
+  } catch (e) {
+    console.warn(
+      `fromTSL: failed to infer node type via getNodeType; skipping type comparison.`
+    );
+  }
   if (nodeType) {
     const wgslTypeFromTSL = sharedBuilder.getType(nodeType);
     if (wgslTypeFromTSL !== wgslTypeFromTgpu) {
@@ -258,7 +328,7 @@ const wgslTypeToGlslType = {
 
 function uniform(value, dataType) {
   let glslType = wgslTypeToGlslType[dataType.type];
-  if (value.isNode) {
+  if (value.isNode || value.isColor) {
     glslType = void 0;
   }
   return fromTSL(TSL.uniform(value, glslType), dataType);

package/index.d.cts

@@ -8,9 +8,9 @@ import InputNode from 'three/src/nodes/core/InputNode.js';
 declare function toTSL(fn: () => unknown): THREE.TSL.NodeObject<THREE.Node>;
 declare class TSLAccessor<T extends d.AnyWgslData, TNode extends THREE.Node> {
     #private;
-    readonly var: TgpuVar<'private', T> | undefined;
     readonly node: THREE.TSL.NodeObject<TNode>;
     constructor(node: THREE.TSL.NodeObject<TNode>, dataType: T);
+    get var(): TgpuVar<'private', T> | undefined;
     get $(): d.InferGPU<T>;
 }
 declare const fromTSL: typegpu.TgpuComptime<(<T extends d.AnyWgslData, TNode extends THREE.Node>(node: THREE.TSL.NodeObject<TNode>, type: (length: number) => T) => TSLAccessor<T, TNode>) & (<T extends d.AnyWgslData, TNode extends THREE.Node>(node: THREE.TSL.NodeObject<TNode>, type: T) => TSLAccessor<T, TNode>)>;

package/index.d.mts

@@ -8,9 +8,9 @@ import InputNode from 'three/src/nodes/core/InputNode.js';
 declare function toTSL(fn: () => unknown): THREE.TSL.NodeObject<THREE.Node>;
 declare class TSLAccessor<T extends d.AnyWgslData, TNode extends THREE.Node> {
     #private;
-    readonly var: TgpuVar<'private', T> | undefined;
     readonly node: THREE.TSL.NodeObject<TNode>;
     constructor(node: THREE.TSL.NodeObject<TNode>, dataType: T);
+    get var(): TgpuVar<'private', T> | undefined;
     get $(): d.InferGPU<T>;
 }
 declare const fromTSL: typegpu.TgpuComptime<(<T extends d.AnyWgslData, TNode extends THREE.Node>(node: THREE.TSL.NodeObject<TNode>, type: (length: number) => T) => TSLAccessor<T, TNode>) & (<T extends d.AnyWgslData, TNode extends THREE.Node>(node: THREE.TSL.NodeObject<TNode>, type: T) => TSLAccessor<T, TNode>)>;

package/index.d.ts

@@ -8,9 +8,9 @@ import InputNode from 'three/src/nodes/core/InputNode.js';
 declare function toTSL(fn: () => unknown): THREE.TSL.NodeObject<THREE.Node>;
 declare class TSLAccessor<T extends d.AnyWgslData, TNode extends THREE.Node> {
     #private;
-    readonly var: TgpuVar<'private', T> | undefined;
     readonly node: THREE.TSL.NodeObject<TNode>;
     constructor(node: THREE.TSL.NodeObject<TNode>, dataType: T);
+    get var(): TgpuVar<'private', T> | undefined;
     get $(): d.InferGPU<T>;
 }
 declare const fromTSL: typegpu.TgpuComptime<(<T extends d.AnyWgslData, TNode extends THREE.Node>(node: THREE.TSL.NodeObject<TNode>, type: (length: number) => T) => TSLAccessor<T, TNode>) & (<T extends d.AnyWgslData, TNode extends THREE.Node>(node: THREE.TSL.NodeObject<TNode>, type: T) => TSLAccessor<T, TNode>)>;

package/index.mjs

@@ -7,13 +7,19 @@ import WGSLNodeBuilder from 'three/src/renderers/webgpu/nodes/WGSLNodeBuilder.js
 
 class StageData {
   stage;
-  names;
   namespace;
-  codeGeneratedThusFar;
   constructor(stage) {
     this.stage = stage;
-    this.names = /* @__PURE__ */ new WeakMap();
     this.namespace = tgpu["~unstable"].namespace();
+  }
+}
+class GenerateStageData extends StageData {
+  names;
+  type = "generate";
+  codeGeneratedThusFar;
+  constructor(stage) {
+    super(stage);
+    this.names = /* @__PURE__ */ new WeakMap();
     this.codeGeneratedThusFar = "";
     this.namespace.on("name", (event) => {
       if (isVariable(event.target)) {
@@ -22,16 +28,29 @@ class StageData {
     });
   }
 }
+class AnalyzeStageData extends StageData {
+  type = "analyze";
+}
 class BuilderData {
-  stageDataMap;
+  generateStageDataMap;
+  analyzeStageDataMap;
   constructor() {
-    this.stageDataMap = /* @__PURE__ */ new Map();
+    this.generateStageDataMap = /* @__PURE__ */ new Map();
+    this.analyzeStageDataMap = /* @__PURE__ */ new Map();
+  }
+  getGenerateStageData(stage) {
+    let stageData = this.generateStageDataMap.get(stage);
+    if (!stageData) {
+      stageData = new GenerateStageData(stage);
+      this.generateStageDataMap.set(stage, stageData);
+    }
+    return stageData;
   }
-  getStageData(stage) {
-    let stageData = this.stageDataMap.get(stage);
+  getAnalyzeStageData(stage) {
+    let stageData = this.analyzeStageDataMap.get(stage);
     if (!stageData) {
-      stageData = new StageData(stage);
-      this.stageDataMap.set(stage, stageData);
+      stageData = new AnalyzeStageData(stage);
+      this.analyzeStageDataMap.set(stage, stageData);
     }
     return stageData;
   }
@@ -68,7 +87,7 @@ class TgpuFnNode extends THREE.Node {
       builderData = new BuilderData();
       builderDataMap.set(builder, builderData);
     }
-    const stageData = builderData.getStageData(builder.shaderStage);
+    const stageData = builderData.getGenerateStageData(builder.shaderStage);
     if (!nodeData.custom) {
       if (currentlyGeneratingFnNodeCtx !== void 0) {
         console.warn("[@typegpu/three] Nested function generation detected");
@@ -115,16 +134,48 @@ fn ${functionId}`
     }
     return nodeData.custom.nodeFunction;
   }
+  #analyzeFunction(builder) {
+    let builderData = builderDataMap.get(builder);
+    if (!builderData) {
+      builderData = new BuilderData();
+      builderDataMap.set(builder, builderData);
+    }
+    const stageData = builderData.getAnalyzeStageData(builder.shaderStage);
+    const ctx = {
+      builder,
+      stageData,
+      dependencies: []
+    };
+    currentlyGeneratingFnNodeCtx = ctx;
+    try {
+      tgpu.resolve({
+        names: stageData.namespace,
+        template: "___ID___ fnName",
+        externals: { fnName: this.#impl }
+      });
+    } finally {
+      currentlyGeneratingFnNodeCtx = void 0;
+    }
+  }
+  /**
+   * Replicating Three.js `analyze` traversal.
+   * Setting `needsInterpolation` flag to true in varying nodes
+   */
+  analyze(builder, output) {
+    super.analyze(builder, output);
+    this.#analyzeFunction(builder);
+  }
   generate(builder, output) {
     this.#getNodeFunction(builder);
     const nodeData = builder.getDataFromNode(this);
     const builderData = builderDataMap.get(builder);
-    const stageData = builderData.getStageData(builder.shaderStage);
-    for (const dep of nodeData.custom.dependencies) {
+    const stageData = builderData.getGenerateStageData(builder.shaderStage);
+    const uniqueDeps = [...new Set(nodeData.custom.dependencies)];
+    for (const dep of uniqueDeps) {
       dep.node.build(builder);
     }
     nodeData.custom.priorCode.build(builder);
-    for (const dep of nodeData.custom.dependencies) {
+    for (const dep of uniqueDeps) {
       if (!dep.var) {
         continue;
       }
@@ -133,10 +184,7 @@ fn ${functionId}`
       builder.addLineFlowCode(`${varName} = ${varValue};
 `, this);
     }
-    if (output === "property") {
-      return nodeData.custom.functionId;
-    }
-    return `${nodeData.custom.functionId}()`;
+    return output === "property" ? nodeData.custom.functionId : `${nodeData.custom.functionId}()`;
   }
 }
 function toTSL(fn) {
@@ -144,29 +192,44 @@ function toTSL(fn) {
 }
 class TSLAccessor {
   #dataType;
-  var;
+  #var;
   node;
   constructor(node, dataType) {
     this.node = node;
     this.#dataType = dataType;
     if (
-      // @ts-expect-error: The properties exist on the node
-      !node.isStorageBufferNode && !node.isUniformNode || node.isTextureNode
+      // @ts-expect-error: they are assigned at runtime
+      !node.isStorageBufferNode && !node.isUniformNode || // @ts-expect-error: it is assigned at runtime
+      node.isTextureNode
     ) {
-      this.var = ((globalThis.__TYPEGPU_AUTONAME__ ?? (a => a))(tgpu.privateVar(dataType), "var"));
+      this.#var = tgpu.privateVar(dataType);
     }
   }
+  get var() {
+    return this.#var;
+  }
   get $() {
     const ctx = currentlyGeneratingFnNodeCtx;
     if (!ctx) {
       throw new Error("Can only access TSL nodes on the GPU.");
     }
+    if (ctx.stageData.type === "analyze") {
+      this.node.traverse((node) => {
+        node.analyze(ctx.builder);
+      });
+      return tgpu["~unstable"].rawCodeSnippet("", this.#dataType, "runtime").$;
+    }
     ctx.dependencies.push(this);
+    const builtNode = this.node.build(ctx.builder);
+    const trueVaryingNode = this.node.isVaryingNode && builtNode.includes("varyings.");
+    if (trueVaryingNode) {
+      this.#var = void 0;
+    }
     if (this.var) {
       return this.var.$;
     }
     return tgpu["~unstable"].rawCodeSnippet(
-      this.node.build(ctx.builder),
+      builtNode,
       this.#dataType
     ).$;
   }
@@ -200,7 +263,14 @@ const fromTSL = ((globalThis.__TYPEGPU_AUTONAME__ ?? (a => a))(tgpu["~unstable"]
   if (!sharedBuilder) {
     sharedBuilder = new WGSLNodeBuilder();
   }
-  const nodeType = node.getNodeType(sharedBuilder);
+  let nodeType = null;
+  try {
+    nodeType = node.getNodeType(sharedBuilder);
+  } catch (e) {
+    console.warn(
+      `fromTSL: failed to infer node type via getNodeType; skipping type comparison.`
+    );
+  }
   if (nodeType) {
     const wgslTypeFromTSL = sharedBuilder.getType(nodeType);
     if (wgslTypeFromTSL !== wgslTypeFromTgpu) {
@@ -237,7 +307,7 @@ const wgslTypeToGlslType = {
 
 function uniform(value, dataType) {
   let glslType = wgslTypeToGlslType[dataType.type];
-  if (value.isNode) {
+  if (value.isNode || value.isColor) {
     glslType = void 0;
   }
   return fromTSL(uniform$1(value, glslType), dataType);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@typegpu/three",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Utilities for integrating TypeGPU with Three.js",
   "exports": {
     "./package.json": "./package.json",