@types/three 0.160.0 → 0.161.0

three/examples/jsm/renderers/common/Renderer.d.ts

@@ -1,42 +1,281 @@
-import { Camera, ColorSpace, CoordinateSystem, Scene, ToneMapping } from '../../../../src/Three.js';
+import {
+    Camera,
+    ColorSpace,
+    CoordinateSystem,
+    Scene,
+    ToneMapping,
+    Vector2,
+    Vector4,
+    Color,
+    Object3D,
+    RenderTarget,
+    FramebufferTexture,
+    BufferGeometry,
+    Material,
+    Group,
+} from '../../../../src/Three.js';
 import Backend from './Backend.js';
 import Info from './Info.js';
+import Color4 from './../common/Color4.js';
+import ComputeNode from '../../nodes/gpgpu/ComputeNode.js';
+import LightsNode from '../../nodes/lighting/LightsNode.js';
 
+export interface RendererParameters {
+    logarithmicDepthBuffer?: boolean | undefined;
+    alpha?: boolean | undefined;
+}
+
+/**
+ * Generic Renderer interface containing either a WebGL or WebGPU backend.
+ */
 export default class Renderer {
-    isRenderer: true;
+    /**
+     * @default true
+     */
+    readonly isRenderer: true;
 
     domElement: HTMLCanvasElement;
 
+    /**
+     * The renderer backend; could be WebGLBackend or WebGPUBackend
+     */
     backend: Backend;
 
+    /**
+     * @default true
+     */
     autoClear: boolean;
+
+    /**
+     * @default true
+     */
     autoClearColor: boolean;
+
+    /**
+     * @default true
+     */
     autoClearDepth: boolean;
+
+    /**
+     * @default true
+     */
     autoClearStencil: boolean;
 
+    /**
+     * @default SRGBColorSpace
+     */
     outputColorSpace: ColorSpace;
 
+    /**
+     * @default NoToneMapping
+     */
     toneMapping: ToneMapping;
+
+    /**
+     * @default 1.0
+     */
     toneMappingExposure: number;
 
+    /**
+     * @default true
+     */
     sortObjects: boolean;
 
+    /**
+     * @default true
+     */
     depth: boolean;
+
+    /**
+     * @default true
+     */
     stencil: boolean;
 
     info: Info;
 
-    constructor(backend: Backend, parameters?: { logarithmicDepthBuffer?: boolean | undefined });
+    constructor(backend: Backend, parameters?: RendererParameters);
 
     init(): Promise<void>;
 
     get coordinateSystem(): CoordinateSystem;
 
-    render(scene: Scene, camera: Camera): Promise<void>;
+    compileAsync(scene: Scene, camera: Camera, targetScene?: Scene | null): Promise<void>;
+
+    renderAsync(scene: Scene, camera: Camera): Promise<void>;
+
+    getMaxAnisotropy(): number;
+
+    getActiveCubeFace(): number;
+
+    getActiveMipmapLevel(): number;
 
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp) => void) | null): Promise<void>;
 
+    /**
+     * Sets the pixel ratio of the Renderer.
+     */
     setPixelRatio(value?: number): void;
 
+    /**
+     * Sets the width and height of the output canvas and optionally updates the CSS style on the DOM element.
+     */
     setSize(width: number, height: number, updateStyle?: boolean): void;
+
+    /**
+     * Gets the Rendering Context of the renderer.
+     */
+    getContext(): RenderingContext;
+
+    /**
+     * Gets the current pixel ratio of the renderer.
+     */
+    getPixelRatio(): number;
+
+    getDrawingBufferSize(target: Vector2): Vector2;
+
+    getSize(target: Vector2): Vector2;
+
+    setDrawingBufferSize(width: number, height: number, pixelRatio: number): void;
+
+    /**
+     * Sets the custom opaque sort function for the RenderLists. Pass null to use the default painterSortStable function.
+     */
+    setOpaqueSort(method: (a: unknown, b: unknown) => number): void;
+
+    /**
+     * Sets the custom transparent sort function for the RenderLists. Pass null to use the default reversePainterSortStable function.
+     */
+    setTransparentSort(method: (a: unknown, b: unknown) => number): void;
+
+    /**
+     * Copies the scissor area into target.
+     */
+    getScissor(target: Vector4): Vector4;
+
+    /**
+     * Sets the scissor area from (x, y) to (x + width, y + height).
+     */
+    setScissor(x: number, y: number, width: number, height: number): void;
+
+    /**
+     * Returns true if scissor test is enabled; returns false otherwise.
+     */
+    getScissorTest(): boolean;
+
+    /**
+     * Enable the scissor test. When this is enabled, only the pixels within the defined scissor area will be affected by further renderer actions.
+     */
+    setScissorTest(boolean: boolean): void;
+
+    /**
+     * Copies the viewport into target.
+     */
+    getViewport(target: Vector4): Vector4;
+
+    /**
+     * Sets the viewport to render from (x, y) to (x + width, y + height).
+     * (x, y) is the lower-left corner of the region.
+     */
+    setViewport(x: number, y: number, width: number, height: number, minDepth?: number, maxDepth?: number): void;
+
+    /**
+     * Returns a Color4 instance with the current clear color.
+     */
+    getClearColor(target: Color4): Color4;
+
+    /**
+     * Sets the clear color, using color for the color and alpha for the opacity.
+     */
+    setClearColor(color: Color, alpha?: number): void;
+
+    /**
+     * Returns a float with the current clear alpha. Ranges from 0 to 1.
+     */
+    getClearAlpha(): number;
+
+    setClearAlpha(alpha: number): void;
+
+    getClearDepth(): number;
+
+    setClearDepth(depth: number): void;
+
+    getClearStencil(): number;
+
+    setClearStencil(stencil: number): void;
+
+    isOccluded(object: Object3D): boolean;
+
+    /**
+     * Tells the renderer to clear its color, depth or stencil drawing buffer(s).
+     * Arguments default to true
+     */
+    clearAsync(color?: boolean, depth?: boolean, stencil?: boolean): Promise<void>;
+
+    /**
+     * Clear the color buffer. Equivalent to calling .clear( true, false, false ).
+     */
+    clearColorAsync(): Promise<void>;
+
+    /**
+     * Clear the depth buffer. Equivalent to calling .clear( false, true, false ).
+     */
+    clearDepthAsync(): Promise<void>;
+
+    /**
+     * Clear the stencil buffer. Equivalent to calling .clear( false, false, true ).
+     */
+    clearStencilAsync(): Promise<void>;
+
+    get currentColorSpace(): ColorSpace;
+
+    dispose(): void;
+
+    setRenderTarget(renderTarget: RenderTarget, activeCubeFace?: number, activeMipmapLevel?: number): void;
+
+    getRenderTarget(): RenderTarget;
+
+    setRenderObjectFunction(renderObjectFunction: () => {}): void;
+
+    getRenderObjectFunction(): () => {};
+
+    /**
+     * Runs a compute pipeline
+     */
+    computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
+
+    hasFeature(name: string): boolean;
+
+    copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+
+    readRenderTargetPixelsAsync(
+        renderTarget: RenderTarget,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+    ): Promise<Float32Array | Uint16Array | Uint8Array | Int8Array | Int16Array | Uint32Array | Int32Array>;
+
+    renderObject(
+        object: Object3D,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        material: Material,
+        group: Group,
+        lightsNode: LightsNode,
+    ): void;
+
+    get compute(): (computeNodes: ComputeNode | ComputeNode[]) => Promise<void>;
+
+    get compile(): (scene: Scene, camera: Camera, targetScene?: Scene | null) => Promise<void>;
+
+    get render(): (scene: Scene, camera: Camera) => Promise<void>;
+
+    get clear(): (color?: boolean, depth?: boolean, stencil?: boolean) => Promise<void>;
+
+    get clearColor(): () => Promise<void>;
+
+    get clearDepth(): () => Promise<void>;
+
+    get clearStencil(): () => Promise<void>;
 }

three/examples/jsm/renderers/common/StorageTexture.d.ts

@@ -0,0 +1,5 @@
+import { Texture } from '../../../../src/Three.js';
+
+export default class StorageTexture extends Texture {
+    constructor(width?: number, height?: number);
+}

three/examples/jsm/renderers/webgl/WebGLBackend.d.ts

@@ -1,8 +1,10 @@
 import { CoordinateSystem } from '../../../../src/Three.js';
-import Backend from '../common/Backend.js';
+import Backend, { BackendParameters } from '../common/Backend.js';
 
 export default class WebGLBackend extends Backend {
-    constructor(parameters?: { canvas?: HTMLCanvasElement | undefined });
+    constructor(parameters?: BackendParameters);
 
     get coordinateSystem(): CoordinateSystem;
+
+    getMaxAnisotropy(): number;
 }

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -2,7 +2,7 @@ import NodeBuilder from '../../../nodes/core/NodeBuilder.js';
 import { Renderer, Object3D } from '../../../../../src/Three.js';
 import Node from '../../../nodes/core/Node.js';
 import SlotNode from './SlotNode.js';
-import { NodeShaderStageOption } from '../../../nodes/core/constants.js';
+import { NodeShaderStage } from '../../../nodes/core/constants.js';
 
 export class WebGLNodeBuilder extends NodeBuilder {
     constructor(
@@ -11,7 +11,7 @@ export class WebGLNodeBuilder extends NodeBuilder {
         shader: { uniforms: any; vertexShader: any; fragmentShader: any },
     );
 
-    addSlot(shaderStage: NodeShaderStageOption, slotNode: SlotNode): Node;
+    addSlot(shaderStage: NodeShaderStage, slotNode: SlotNode): Node;
 
     getUniforms(shaderStage: string): string;
 

three/examples/jsm/renderers/webgpu/WebGPUBackend.d.ts

@@ -1,12 +1,21 @@
 import { CoordinateSystem } from '../../../../src/Three.js';
-import Backend from '../common/Backend.js';
+import Backend, { BackendParameters } from '../common/Backend.js';
+
+export interface WebGPUBackendParameters extends BackendParameters {
+    alpha?: boolean | undefined;
+    antialias?: boolean | undefined;
+    sampleCount?: number | undefined;
+    trackTimestamp?: boolean | undefined;
+}
 
 export default class WebGPUBackend extends Backend {
-    constructor(parameters?: {
-        canvas?: HTMLCanvasElement | undefined;
-        antialias?: boolean | undefined;
-        sampleCount?: number | undefined;
-    });
+    readonly isWebGPUBackend: true;
+
+    constructor(parameters?: WebGPUBackendParameters);
 
     get coordinateSystem(): CoordinateSystem;
+
+    // utils public
+
+    getMaxAnisotropy(): number;
 }

three/examples/jsm/renderers/webgpu/WebGPURenderer.d.ts

@@ -1,10 +1,10 @@
-import Renderer from '../common/Renderer.js';
+import Renderer, { RendererParameters } from '../common/Renderer.js';
+import { WebGPUBackendParameters } from './WebGPUBackend.js';
+
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+    forceWebGL?: boolean | undefined;
+}
 
 export default class WebGPURenderer extends Renderer {
-    constructor(parameters?: {
-        canvas?: HTMLCanvasElement | undefined;
-        antialias?: boolean | undefined;
-        sampleCount?: number | undefined;
-        logarithmicDepthBuffer?: boolean | undefined;
-    });
+    constructor(parameters?: WebGPURendererParameters);
 }

three/examples/jsm/utils/BufferGeometryUtils.d.ts

@@ -35,13 +35,3 @@ export function deinterleaveGeometry(geometry: BufferGeometry): void;
  * @param creaseAngle The crease angle in radians.
  */
 export function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;
-
-/**
- * @deprecated Use mergeGeometries instead.
- */
-export function mergeBufferGeometries(geometries: BufferGeometry[], useGroups?: boolean): BufferGeometry;
-
-/**
- * @deprecated Use mergeAttributes instead.
- */
-export function mergeBufferAttributes(attributes: BufferAttribute[]): BufferAttribute;

three/examples/jsm/webxr/XRControllerModelFactory.d.ts

@@ -1,6 +1,5 @@
-import { Group, Object3D, Texture } from '../../../src/Three.js';
-
-import { GLTFLoader } from '../loaders/GLTFLoader.js';
+import { Group, Loader, Object3D, Texture } from '../../../src/Three.js';
+import { GLTF } from '../loaders/GLTFLoader.js';
 
 export class XRControllerModel extends Object3D {
     constructor();
@@ -13,9 +12,11 @@ export class XRControllerModel extends Object3D {
 }
 
 export class XRControllerModelFactory {
-    constructor(gltfLoader?: GLTFLoader);
-    gltfLoader: GLTFLoader | null;
+    gltfLoader: Loader<GLTF> | null;
     path: string;
+    onLoad: ((scene: Group) => void) | null;
+
+    constructor(gltfLoader?: Loader<GLTF> | null, onLoad?: ((scene: Group) => void) | null);
 
     createControllerModel(controller: Group): XRControllerModel;
 }

three/examples/jsm/webxr/XRHandMeshModel.d.ts

@@ -1,11 +1,19 @@
-import { Object3D } from '../../../src/Three.js';
+import { Loader, Object3D } from '../../../src/Three.js';
+import { GLTF } from '../loaders/GLTFLoader.js';
 
 export class XRHandMeshModel {
     controller: Object3D;
     handModel: Object3D;
     bones: Object3D[];
 
-    constructor(handModel: Object3D, controller: Object3D, path: string, handedness: string);
+    constructor(
+        handModel: Object3D,
+        controller: Object3D,
+        path: string,
+        handedness: string,
+        loader?: Loader<GLTF> | null,
+        onLoad?: ((object: Object3D) => void) | null,
+    );
 
     updateMesh(): void;
 }

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.160.0",
+    "version": "0.161.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -44,6 +44,6 @@
         "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "7de688c4d074af1d79f7696d827bdd1236ff9e159d0b343b35e0b152202c544e",
+    "typesPublisherContentHash": "3aa24058634b97c18523562ed8a4194a3a400d891c67daa36884efcbc24b62ef",
     "typeScriptVersion": "4.6"
 }

three/src/cameras/PerspectiveCamera.d.ts

@@ -1,4 +1,5 @@
 import { Camera } from './Camera.js';
+import { Vector2 } from '../math/Vector2.js';
 
 /**
  * Camera that uses {@link https://en.wikipedia.org/wiki/Perspective_(graphical) | perspective projection}.
@@ -148,6 +149,18 @@ export class PerspectiveCamera extends Camera {
      */
     getFilmHeight(): number;
 
+    /**
+     * Computes the 2D bounds of the camera's viewable rectangle at a given distance along the viewing direction.
+     * Sets minTarget and maxTarget to the coordinates of the lower-left and upper-right corners of the view rectangle.
+     */
+    getViewBounds(distance: number, minTarget: Vector2, maxTarget: Vector2): void;
+
+    /**
+     * Computes the width and height of the camera's viewable rectangle at a given distance along the viewing direction.
+     * Copies the result into the target Vector2, where x is width and y is height.
+     */
+    getViewSize(distance: number, minTarget: Vector2, maxTarget: Vector2): void;
+
     /**
      * Sets an offset in a larger frustum.
      * @remarks

three/src/constants.d.ts

@@ -37,12 +37,11 @@ export type ShadowMapType = typeof BasicShadowMap | typeof PCFShadowMap | typeof
 export const FrontSide: 0;
 export const BackSide: 1;
 export const DoubleSide: 2;
-export const TwoPassDoubleSide: 2;
 /**
  * Defines which side of faces will be rendered - front, back or both.
  * Default is {@link FrontSide}.
  */
-export type Side = typeof FrontSide | typeof BackSide | typeof DoubleSide | typeof TwoPassDoubleSide;
+export type Side = typeof FrontSide | typeof BackSide | typeof DoubleSide;
 
 // blending modes
 export const NoBlending: 0;

three/src/core/InterleavedBufferAttribute.d.ts

@@ -84,13 +84,23 @@ export class InterleavedBufferAttribute {
      * Applies normal matrix {@link Matrix3 | m} to every Vector3 element of this InterleavedBufferAttribute.
      * @param m
      */
-    applyNormalMatrix(matrix: Matrix): this;
+    applyNormalMatrix(m: Matrix): this;
 
     /**
      * Applies matrix {@link Matrix4 | m} to every Vector3 element of this InterleavedBufferAttribute, interpreting the elements as a direction vectors.
      * @param m
      */
-    transformDirection(matrix: Matrix): this;
+    transformDirection(m: Matrix): this;
+
+    /**
+     * Returns the given component of the vector at the given index.
+     */
+    getComponent(index: number, component: number): number;
+
+    /**
+     * Sets the given component of the vector at the given index.
+     */
+    setComponent(index: number, component: number, value: number): this;
 
     /**
      * Returns the x component of the item at the given index.

three/src/core/Object3D.d.ts

@@ -42,7 +42,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * Unique number for this {@link Object3D} instance.
      * @remarks Note that ids are assigned in chronological order: 1, 2, 3, ..., incrementing by one for each new object.
-     * @remarks Expects a `Integer`
+     * Expects a `Integer`
      */
     readonly id: number;
 
@@ -62,7 +62,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * A Read-only _string_ to check `this` object type.
      * @remarks This can be used to find a specific type of Object3D in a scene.
-     * @remarks Sub-classes will update this value.
+     * Sub-classes will update this value.
      * @defaultValue `Object3D`
      */
     readonly type: string | 'Object3D';
@@ -158,7 +158,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * The layer membership of the object.
      * @remarks The object is only visible if it has at least one layer in common with the {@link THREE.Object3DCamera | Camera} in use.
-     * @remarks This property can also be used to filter out unwanted objects in ray-intersection tests when using {@link THREE.Raycaster | Raycaster}.
+     * This property can also be used to filter out unwanted objects in ray-intersection tests when using {@link THREE.Raycaster | Raycaster}.
      * @defaultValue `new THREE.Layers()`
      */
     layers: Layers;
@@ -192,7 +192,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
      * This value allows the default rendering order of {@link https://en.wikipedia.org/wiki/Scene_graph | scene graph}
      * objects to be overridden although opaque and transparent objects remain sorted independently.
      * @remarks When this property is set for an instance of {@link Group | Group}, all descendants objects will be sorted and rendered together.
-     * @remarks Sorting is from lowest to highest renderOrder.
+     * Sorting is from lowest to highest renderOrder.
      * @defaultValue `0`
      */
     renderOrder: number;
@@ -213,7 +213,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * Custom depth material to be used when rendering to the depth map.
      * @remarks Can only be used in context of meshes.
-     * @remarks When shadow-casting with a {@link THREE.DirectionalLight | DirectionalLight} or {@link THREE.SpotLight | SpotLight},
+     * When shadow-casting with a {@link THREE.DirectionalLight | DirectionalLight} or {@link THREE.SpotLight | SpotLight},
      * if you are modifying vertex positions in the vertex shader you must specify a customDepthMaterial for proper shadows.
      * @defaultValue `undefined`
      */
@@ -229,7 +229,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
      * An optional callback that is executed immediately before a 3D object is rendered to a shadow map.
      * @remarks This function is called with the following parameters: renderer, scene, camera, shadowCamera, geometry,
      * depthMaterial, group.
-     * @remarks Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
+     * Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
      * define their visual appearance with geometries and materials like instances of {@link Mesh}, {@link Line},
      * {@link Points} or {@link Sprite}. Instances of {@link Object3D}, {@link Group} or {@link Bone} are not renderable
      * and thus this callback is not executed for such objects.
@@ -247,7 +247,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
      * An optional callback that is executed immediately after a 3D object is rendered to a shadow map.
      * @remarks This function is called with the following parameters: renderer, scene, camera, shadowCamera, geometry,
      * depthMaterial, group.
-     * @remarks Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
+     * Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
      * define their visual appearance with geometries and materials like instances of {@link Mesh}, {@link Line},
      * {@link Points} or {@link Sprite}. Instances of {@link Object3D}, {@link Group} or {@link Bone} are not renderable
      * and thus this callback is not executed for such objects.
@@ -264,7 +264,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * An optional callback that is executed immediately before a 3D object is rendered.
      * @remarks This function is called with the following parameters: renderer, scene, camera, geometry, material, group.
-     * @remarks Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
+     * Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
      * define their visual appearance with geometries and materials like instances of {@link Mesh}, {@link Line},
      * {@link Points} or {@link Sprite}. Instances of {@link Object3D}, {@link Group} or {@link Bone} are not renderable
      * and thus this callback is not executed for such objects.
@@ -281,7 +281,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * An optional callback that is executed immediately after a 3D object is rendered.
      * @remarks This function is called with the following parameters: renderer, scene, camera, geometry, material, group.
-     * @remarks Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
+     * Please notice that this callback is only executed for `renderable` 3D objects. Meaning 3D objects which
      * define their visual appearance with geometries and materials like instances of {@link Mesh}, {@link Line},
      * {@link Points} or {@link Sprite}. Instances of {@link Object3D}, {@link Group} or {@link Bone} are not renderable
      * and thus this callback is not executed for such objects.
@@ -363,7 +363,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * Rotate an object along an axis in world space.
      * @remarks The axis is assumed to be normalized
-     * @remarks Method Assumes no rotated parent.
+     * Method Assumes no rotated parent.
      * @param axis A normalized vector in world space.
      * @param angle The angle in radians. Expects a `Float`
      */
@@ -443,7 +443,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * Adds another {@link Object3D} as child of this {@link Object3D}.
      * @remarks An arbitrary number of objects may be added
-     * @remarks Any current parent on an {@link object} passed in here will be removed, since an {@link Object3D} can have at most one parent.
+     * Any current parent on an {@link object} passed in here will be removed, since an {@link Object3D} can have at most one parent.
      * @see {@link attach}
      * @see {@link THREE.Group | Group} for info on manually grouping objects.
      * @param object
@@ -487,7 +487,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * Searches through an object and its children, starting with the object itself, and returns the first with a matching name.
      * @remarks Note that for most objects the name is an empty string by default
-     * @remarks You will have to set it manually to make use of this method.
+     * You will have to set it manually to make use of this method.
      * @param name String to match to the children's Object3D.name property.
      */
     getObjectByName(name: string): Object3D | undefined;
@@ -555,7 +555,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     /**
      * Like traverse, but the callback will only be executed for visible objects
      * @remarks Descendants of invisible objects are not traversed.
-     * @remarks Note: Modifying the scene graph inside the callback is discouraged.
+     * Note: Modifying the scene graph inside the callback is discouraged.
      * @param callback A function with as first argument an {@link Object3D} object.
      */
     traverseVisible(callback: (object: Object3D) => any): void;