TSL: Fix label() usage in uniform()

examples-jsm/changes.patch

@@ -2266,10 +2266,10 @@ index f8bb2b37..cee70486 100644
      }
  }
 diff --git a/examples-jsm/examples/nodes/core/UniformNode.ts b/examples-jsm/examples/nodes/core/UniformNode.ts
-index 90e86648..78a60c3b 100644
+index 41e523c4..a0c2ae45 100644
 --- a/examples-jsm/examples/nodes/core/UniformNode.ts
 +++ b/examples-jsm/examples/nodes/core/UniformNode.ts
-@@ -1,10 +1,17 @@
+@@ -1,10 +1,18 @@
  import InputNode from './InputNode.js';
 -import { objectGroup } from './UniformGroupNode.js';
 -import { addNodeClass } from './Node.js';
@@ -2285,22 +2285,30 @@ index 90e86648..78a60c3b 100644
 +class UniformNode<TValue> extends InputNode<TValue> {
 +    readonly isUniformNode: true;
 +
++    name: string;
 +    groupNode: UniformGroupNode;
 +
 +    constructor(value: TValue, nodeType: string | null = null) {
          super(value, nodeType);
 
          this.isUniformNode = true;
-@@ -12,7 +19,7 @@ class UniformNode extends InputNode {
+@@ -13,13 +21,13 @@ class UniformNode extends InputNode {
          this.groupNode = objectGroup;
      }
 
+-    label(name) {
++    label(name: string) {
+         this.name = name;
+
+         return this;
+     }
+
 -    setGroup(group) {
 +    setGroup(group: UniformGroupNode) {
          this.groupNode = group;
 
          return this;
-@@ -22,11 +29,11 @@ class UniformNode extends InputNode {
+@@ -29,11 +37,11 @@ class UniformNode extends InputNode {
          return this.groupNode;
      }
 
@@ -2314,7 +2322,7 @@ index 90e86648..78a60c3b 100644
          const self = this.getSelf();
 
          callback = callback.bind(self);
-@@ -40,12 +47,12 @@ class UniformNode extends InputNode {
+@@ -47,12 +55,12 @@ class UniformNode extends InputNode {
          }, updateType);
      }
 
@@ -2329,16 +2337,16 @@ index 90e86648..78a60c3b 100644
 
          if (sharedNode === undefined) {
              builder.setHashNode(this, hash);
-@@ -58,7 +65,7 @@ class UniformNode extends InputNode {
+@@ -65,7 +73,7 @@ class UniformNode extends InputNode {
          const nodeUniform = builder.getUniformFromNode(
              sharedNode,
              sharedNodeType,
 -            builder.shaderStage,
 +            builder.shaderStage!,
-             builder.context.label,
+             this.name || builder.context.label,
          );
          const propertyName = builder.getPropertyName(nodeUniform);
-@@ -71,11 +78,14 @@ class UniformNode extends InputNode {
+@@ -78,11 +86,14 @@ class UniformNode extends InputNode {
 
  export default UniformNode;
 

types/three/examples/jsm/nodes/core/UniformNode.d.ts

@@ -6,8 +6,10 @@ import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
 declare class UniformNode<TValue> extends InputNode<TValue> {
     readonly isUniformNode: true;
+    name: string;
     groupNode: UniformGroupNode;
     constructor(value: TValue, nodeType?: string | null);
+    label(name: string): this;
     setGroup(group: UniformGroupNode): this;
     getGroup(): UniformGroupNode;
     getUniformHash(builder: NodeBuilder): string;

types/three/examples/jsm/nodes/materials/MeshPhongNodeMaterial.d.ts

@@ -1,6 +1,5 @@
 import { Color, Combine, Euler, MeshPhongMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {
@@ -9,8 +8,8 @@ export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters,
 export default class MeshPhongNodeMaterial extends NodeMaterial {
     readonly isMeshPhongNodeMaterial: true;
 
-    shininessNode: ShaderNodeObject<Node> | null;
-    specularNode: ShaderNodeObject<Node> | null;
+    shininessNode: Node | null;
+    specularNode: Node | null;
 
     // Properties from MeshPhongMaterial
     readonly isMeshPhongMaterial: true;

types/three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -1,7 +1,6 @@
 import { Color, MeshPhysicalMaterialParameters, Texture, Vector2 } from "three";
 
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
 
 export interface MeshPhysicalNodeMaterialParameters
@@ -12,29 +11,29 @@ export interface MeshPhysicalNodeMaterialParameters
 export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     readonly isMeshPhysicalNodeMaterial: true;
 
-    clearcoatNode: ShaderNodeObject<Node> | null;
-    clearcoatRoughnessNode: ShaderNodeObject<Node> | null;
-    clearcoatNormalNode: ShaderNodeObject<Node> | null;
+    clearcoatNode: Node | null;
+    clearcoatRoughnessNode: Node | null;
+    clearcoatNormalNode: Node | null;
 
-    sheenNode: ShaderNodeObject<Node> | null;
-    sheenRoughnessNode: ShaderNodeObject<Node> | null;
+    sheenNode: Node | null;
+    sheenRoughnessNode: Node | null;
 
-    iridescenceNode: ShaderNodeObject<Node> | null;
-    iridescenceIORNode: ShaderNodeObject<Node> | null;
-    iridescenceThicknessNode: ShaderNodeObject<Node> | null;
+    iridescenceNode: Node | null;
+    iridescenceIORNode: Node | null;
+    iridescenceThicknessNode: Node | null;
 
-    iorNode: ShaderNodeObject<Node> | null;
+    iorNode: Node | null;
 
-    specularIntensityNode: ShaderNodeObject<Node> | null;
-    specularColorNode: ShaderNodeObject<Node> | null;
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
 
-    transmissionNode: ShaderNodeObject<Node> | null;
-    thicknessNode: ShaderNodeObject<Node> | null;
-    attenuationDistanceNode: ShaderNodeObject<Node> | null;
-    attenuationColorNode: ShaderNodeObject<Node> | null;
-    dispersionNode: ShaderNodeObject<Node> | null;
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+    dispersionNode: Node | null;
 
-    anisotropyNode: ShaderNodeObject<Node> | null;
+    anisotropyNode: Node | null;
 
     // Properties from MeshPhysicalMaterial
     readonly isMeshPhysicalMaterial: true;

types/three/examples/jsm/nodes/materials/MeshSSSNodeMaterial.d.ts

@@ -1,15 +1,14 @@
 import ConstNode from "../core/ConstNode.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 
 export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {
-    thicknessColorNode: ShaderNodeObject<Node> | null;
-    thicknessDistortionNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessAmbientNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessAttenuationNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessPowerNode: ShaderNodeObject<ConstNode<number>>;
-    thicknessScaleNode: ShaderNodeObject<ConstNode<number>>;
+    thicknessColorNode: Node | null;
+    thicknessDistortionNode: ConstNode<number>;
+    thicknessAmbientNode: ConstNode<number>;
+    thicknessAttenuationNode: ConstNode<number>;
+    thicknessPowerNode: ConstNode<number>;
+    thicknessScaleNode: ConstNode<number>;
 
     constructor(parameters?: MeshPhysicalNodeMaterialParameters);
 

types/three/examples/jsm/nodes/materials/MeshStandardNodeMaterial.d.ts

@@ -1,6 +1,5 @@
 import { Color, Euler, MeshStandardMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
@@ -9,10 +8,10 @@ export interface MeshStandardNodeMaterialParameters extends NodeMaterialParamete
 export default class MeshStandardNodeMaterial extends NodeMaterial {
     readonly isMeshStandardNodeMaterial: true;
 
-    emissiveNode: ShaderNodeObject<Node> | null;
+    emissiveNode: Node | null;
 
-    metalnessNode: ShaderNodeObject<Node> | null;
-    roughnessNode: ShaderNodeObject<Node> | null;
+    metalnessNode: Node | null;
+    roughnessNode: Node | null;
 
     // Properties from MeshStandardMaterial
     readonly isMeshStandardMaterial: true;

types/three/examples/jsm/nodes/materials/NodeMaterial.d.ts

@@ -18,7 +18,6 @@ import LightingModel from "../core/LightingModel.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 import LightsNode from "../lighting/LightsNode.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
 import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
 import MeshMatcapNodeMaterial from "./MeshMatcapNodeMaterial.js";
@@ -36,60 +35,60 @@ export interface NodeMaterialParameters extends MaterialParameters {
 
     colorSpaced?: boolean | undefined;
 
-    lightsNode?: ShaderNodeObject<LightsNode> | null | undefined;
-    envNode?: ShaderNodeObject<Node> | null | undefined;
-    aoNode?: ShaderNodeObject<Node> | null | undefined;
+    lightsNode?: LightsNode | null | undefined;
+    envNode?: Node | null | undefined;
+    aoNode?: Node | null | undefined;
 
-    colorNode?: ShaderNodeObject<Node> | null | undefined;
-    normalNode?: ShaderNodeObject<Node> | null | undefined;
-    opacityNode?: ShaderNodeObject<Node> | null | undefined;
-    backdropNode?: ShaderNodeObject<Node> | null | undefined;
-    backdropAlphaNode?: ShaderNodeObject<Node> | null | undefined;
-    alphaTestNode?: ShaderNodeObject<Node> | null | undefined;
+    colorNode?: Node | null | undefined;
+    normalNode?: Node | null | undefined;
+    opacityNode?: Node | null | undefined;
+    backdropNode?: Node | null | undefined;
+    backdropAlphaNode?: Node | null | undefined;
+    alphaTestNode?: Node | null | undefined;
 
-    positionNode?: ShaderNodeObject<Node> | null | undefined;
+    positionNode?: Node | null | undefined;
 
-    depthNode?: ShaderNodeObject<Node> | null | undefined;
-    shadowNode?: ShaderNodeObject<Node> | null | undefined;
+    depthNode?: Node | null | undefined;
+    shadowNode?: Node | null | undefined;
 
-    outputNode?: ShaderNodeObject<Node> | null | undefined;
+    outputNode?: Node | null | undefined;
 
-    fragmentNode?: ShaderNodeObject<Node> | null | undefined;
-    vertexNode?: ShaderNodeObject<Node> | null | undefined;
+    fragmentNode?: Node | null | undefined;
+    vertexNode?: Node | null | undefined;
 }
 
 export default class NodeMaterial extends Material {
     readonly isNodeMaterial: true;
 
     normals: boolean;
 
-    lightsNode: ShaderNodeObject<LightsNode> | null;
-    envNode: ShaderNodeObject<Node> | null;
-    aoNode: ShaderNodeObject<Node> | null;
+    lightsNode: LightsNode | null;
+    envNode: Node | null;
+    aoNode: Node | null;
 
-    colorNode: ShaderNodeObject<Node> | null;
-    normalNode: ShaderNodeObject<Node> | null;
-    opacityNode: ShaderNodeObject<Node> | null;
-    backdropNode: ShaderNodeObject<Node> | null;
-    backdropAlphaNode: ShaderNodeObject<Node> | null;
-    alphaTestNode: ShaderNodeObject<Node> | null;
+    colorNode: Node | null;
+    normalNode: Node | null;
+    opacityNode: Node | null;
+    backdropNode: Node | null;
+    backdropAlphaNode: Node | null;
+    alphaTestNode: Node | null;
 
-    positionNode: ShaderNodeObject<Node> | null;
+    positionNode: Node | null;
 
-    depthNode: ShaderNodeObject<Node> | null;
-    shadowNode: ShaderNodeObject<Node> | null;
-    shadowPositionNode: ShaderNodeObject<Node> | null;
+    depthNode: Node | null;
+    shadowNode: Node | null;
+    shadowPositionNode: Node | null;
 
-    outputNode: ShaderNodeObject<Node> | null;
+    outputNode: Node | null;
 
-    fragmentNode: ShaderNodeObject<Node> | null;
-    vertexNode: ShaderNodeObject<Node> | null;
+    fragmentNode: Node | null;
+    vertexNode: Node | null;
 
     constructor();
 
     build(builder: NodeBuilder): void;
     setup(builder: NodeBuilder): void;
-    setupClipping(builder: NodeBuilder): ShaderNodeObject<ClippingNode> | null;
+    setupClipping(builder: NodeBuilder): ClippingNode | null;
     setupDepth(builder: NodeBuilder): void;
     setupPosition(builder: NodeBuilder): Node;
     setupDiffuseColor(builder: NodeBuilder): void;

types/three/examples/jsm/nodes/materials/SpriteNodeMaterial.d.ts

@@ -1,6 +1,5 @@
 import { Color, SpriteMaterialParameters, Texture } from "three";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, SpriteMaterialParameters {
@@ -9,8 +8,8 @@ export interface SpriteNodeMaterialParameters extends NodeMaterialParameters, Sp
 export default class SpriteNodeMaterial extends NodeMaterial {
     isSpriteNodeMaterial: true;
 
-    rotationNode: ShaderNodeObject<Node> | null;
-    scaleNode: ShaderNodeObject<Node> | null;
+    rotationNode: Node | null;
+    scaleNode: Node | null;
 
     // Properties from SpriteMaterial
     readonly isSpriteMaterial: true;

types/three/test/unit/src/core/EventDispatcher.ts

@@ -31,9 +31,6 @@ eveDisForTestEvent.addEventListener("foo", e => {
     e.type; // $ExpectType "foo"
     e.target; // $ExpectType EventDispatcher<TestEvent>
     e.foo; // $ExpectType number
-
-    // NOTE: Error in ts lower than 3.9. The minimum typescript version cannot be raised from 3.6 because of the dependency from aframe.
-    // e.foo; // $ExpectType number
     // @ts-expect-error
     e.bar;
 });