@types/three 0.167.2 → 0.169.0

three/src/{nodes/materials → materials/nodes}/VolumeNodeMaterial.d.ts

@@ -1,4 +1,4 @@
-import Node from "../core/Node.js";
+import Node from "../../nodes/core/Node.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export default class VolumeNodeMaterial extends NodeMaterial {

three/src/materials/nodes/manager/NodeMaterialObserver.d.ts

@@ -0,0 +1,81 @@
+import { Matrix4 } from "../../../math/Matrix4.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import NodeFrame from "../../../nodes/core/NodeFrame.js";
+import RenderObject from "../../../renderers/common/RenderObject.js";
+import { Material } from "../../Material.js";
+declare const refreshUniforms: readonly [
+    "alphaMap",
+    "alphaTest",
+    "anisotropy",
+    "anisotropyMap",
+    "anisotropyRotation",
+    "aoMap",
+    "attenuationColor",
+    "attenuationDistance",
+    "bumpMap",
+    "clearcoat",
+    "clearcoatMap",
+    "clearcoatNormalMap",
+    "clearcoatNormalScale",
+    "clearcoatRoughness",
+    "color",
+    "dispersion",
+    "displacementMap",
+    "emissive",
+    "emissiveMap",
+    "envMap",
+    "gradientMap",
+    "ior",
+    "iridescence",
+    "iridescenceIOR",
+    "iridescenceMap",
+    "iridescenceThicknessMap",
+    "lightMap",
+    "map",
+    "matcap",
+    "metalness",
+    "metalnessMap",
+    "normalMap",
+    "normalScale",
+    "opacity",
+    "roughness",
+    "roughnessMap",
+    "sheen",
+    "sheenColor",
+    "sheenColorMap",
+    "sheenRoughnessMap",
+    "shininess",
+    "specular",
+    "specularColor",
+    "specularColorMap",
+    "specularIntensity",
+    "specularIntensityMap",
+    "specularMap",
+    "thickness",
+    "transmission",
+    "transmissionMap",
+];
+type RefreshUniform = (typeof refreshUniforms)[number];
+type MaterialData = {
+    [K in RefreshUniform]?: unknown;
+};
+interface RenderObjectData {
+    material: MaterialData;
+    worldMatrix: Matrix4;
+    version?: number;
+}
+declare class NodeMaterialObserver {
+    renderObjects: WeakMap<RenderObject, RenderObjectData>;
+    hasNode: boolean;
+    hasAnimation: boolean;
+    refreshUniforms: readonly RefreshUniform[];
+    renderId: number;
+    constructor(builder: NodeBuilder);
+    firstInitialization(renderObject: RenderObject): boolean;
+    getRenderObjectData(renderObject: RenderObject): RenderObjectData;
+    containsNode(builder: NodeBuilder): boolean;
+    getMaterialData(material: Material): MaterialData;
+    equals(renderObject: RenderObject): boolean;
+    needsRefresh(renderObject: RenderObject, nodeFrame: NodeFrame): boolean;
+}
+export default NodeMaterialObserver;

three/src/math/Quaternion.d.ts

@@ -129,7 +129,7 @@ export class Quaternion {
      * @param array the source array or array-like.
      * @param offset (optional) offset into the array. Default is 0.
      */
-    fromArray(array: QuaternionTuple, offset?: number): this;
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
 
     /**
      * Returns an array [x, y, z, w], or copies x, y, z and w into the provided array.
@@ -137,7 +137,8 @@ export class Quaternion {
      * @param offset (optional) optional offset into the array.
      * @return The created or provided array.
      */
-    toArray(array?: number[], offset?: number): QuaternionTuple;
+    toArray(array?: number[], offset?: number): number[];
+    toArray(array?: QuaternionTuple, offset?: 0): QuaternionTuple;
 
     /**
      * Copies x, y, z and w into the provided array-like.
@@ -145,7 +146,7 @@ export class Quaternion {
      * @param offset (optional) optional offset into the array.
      * @return The provided array-like.
      */
-    toArray(array: ArrayLike<number>, offset?: number): QuaternionTuple;
+    toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
 
     /**
      * This method defines the serialization result of Quaternion.

three/src/math/Triangle.d.ts

@@ -82,5 +82,29 @@ export class Triangle {
         v3: Vector4,
         target: Vector4,
     ): Vector4 | null;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector2,
+    ): Vector2;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector3,
+    ): Vector3;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector4,
+    ): Vector4;
     static isFrontFacing(a: Vector3, b: Vector3, c: Vector3, direction: Vector3): boolean;
 }