Merge pull request #14487 from omni360/master

add three-octree.d.ts and three-ctmloader.d.ts

three/index.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for three.js 0.83
 // Project: http://mrdoob.github.com/three.js/
-// Definitions by: Kon <http://phyzkit.net/>, Satoru Kimura <https://github.com/gyohk>, Florent Poujol <https://github.com/florentpoujol>, SereznoKot <https://github.com/SereznoKot>
+// Definitions by: Kon <http://phyzkit.net/>, Satoru Kimura <https://github.com/gyohk>, Florent Poujol <https://github.com/florentpoujol>, SereznoKot <https://github.com/SereznoKot>, HouChunlei <https://github.com/omni360>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="detector.d.ts" />
@@ -20,6 +20,8 @@
 /// <reference path="three-transformcontrols.d.ts" />
 /// <reference path="three-vrcontrols.d.ts" />
 /// <reference path="three-vreffect.d.ts" />
+/// <reference path="three-ctmloader.d.ts" />
+/// <reference path="three-octree.d.ts" />
 
 declare namespace THREE {
     export const REVISION: string;
@@ -1996,7 +1998,7 @@ declare namespace THREE {
         mimeType: MimeType;
         path: string;
         responseType: string;
-        withCredentials: string        
+        withCredentials: string;
 
         load(url: string, onLoad?: (responseText: string) => void, onProgress?: (request: ProgressEvent) => void, onError?:(event: ErrorEvent) => void): any;
         setMimeType(mimeType: MimeType): FileLoader;
@@ -3589,7 +3591,7 @@ declare namespace THREE {
         radius: number;
         phi: number;
         theta: number;
-        
+
         set(radius: number, phi: number, theta: number): Spherical;
         clone(): this;
         copy(other: this): this;

three/test/examples/ctm/ctmloader.ts

@@ -0,0 +1,7 @@
+/// <reference types="three" />
+
+let _ctmloader = new THREE.CTMLoader();
+_ctmloader.load('https://github.com/mrdoob/three.js/blob/master/examples/models/ctm/ben.ctm', (geo: any) => {
+    console.log(geo.position);
+});
+

three/test/examples/octree.ts

@@ -0,0 +1,11 @@
+///<reference types="three"/>
+
+let _octree = new THREE.Octree({
+    underferred: false,
+    depthMax: Infinity,
+    objectsThreshold: 8,
+    overlapPct: 0.15,
+});
+
+console.log(_octree.getDepthEnd());
+

three/three-FirstPersonControls.d.ts

@@ -8,6 +8,7 @@
 declare namespace THREE {
     class FirstPersonControls {
         constructor(object: Camera, domElement?: HTMLElement);
+
         object: THREE.Object3D;
         target: THREE.Vector3;
         domElement: HTMLCanvasElement | HTMLDocument;
@@ -38,7 +39,9 @@ declare namespace THREE {
         moveRight: boolean;
         freeze: boolean;
         mouseDragOn: boolean;
+
         update(delta: number): void;
+
         dispose(): void;
     }
 }

three/three-canvasrenderer.d.ts

@@ -1,10 +1,10 @@
 // Type definitions for three.js (CanvasRenderer.js)
 // Project: https://github.com/mrdoob/three.js/blob/master/examples/js/renderers/CanvasRenderer.js
-// Definitions by: Satoru Kimura <https://github.com/gyohk>
+// Definitions by: Satoru Kimura < https://github.com/gyohk >
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare namespace THREE {
-    export interface SpriteCanvasMaterialParameters extends MaterialParameters{
+    export interface SpriteCanvasMaterialParameters extends MaterialParameters {
         color?: number;
         program?: (context: any, color: Color) => void;
     }
@@ -30,27 +30,45 @@ declare namespace THREE {
         autoClear: boolean;
         sortObjects: boolean;
         sortElements: boolean;
-        info: { render: { vertices: number; faces: number; }; };
+        info: {render: {vertices: number; faces: number;};};
 
         supportsVertexTextures(): void;
+
         setFaceCulling(): void;
+
         getPixelRatio(): number;
+
         setPixelRatio(value: number): void;
+
         setSize(width: number, height: number, updateStyle?: boolean): void;
+
         setViewport(x: number, y: number, width: number, height: number): void;
+
         setScissor(): void;
+
         enableScissorTest(): void;
-        setClearColor(color: Color, opacity?: number): void;
-        setClearColor(color: string, opacity?: number): void;
-        setClearColor(color: number, opacity?: number): void;
+
+        setClearColor(color: Color | string | number, opacity?: number): void;
+
+        // setClearColor(color: string, opacity?: number): void;
+        // setClearColor(color: number, opacity?: number): void;
+
         setClearColorHex(hex: number, alpha?: number): void;
+
         getClearColor(): Color;
+
         getClearAlpha(): number;
+
         getMaxAnisotropy(): number;
+
         clear(): void;
+
         clearColor(): void;
+
         clearDepth(): void;
+
         clearStencil(): void;
+
         render(scene: Scene, camera: Camera): void;
     }
 }

three/three-copyshader.d.ts

@@ -4,7 +4,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
-	export var CopyShader: Shader;
+    export var CopyShader: Shader;
 }

three/three-css3drenderer.d.ts

@@ -7,7 +7,6 @@
 // https://github.com/mrdoob/three.js/issues/4783
 
 
-
 declare namespace THREE {
     class CSS3DObject extends Object3D {
         constructor(element: any);
@@ -24,9 +23,10 @@ declare namespace THREE {
     class CSS3DRenderer {
         constructor();
 
-        domElement:HTMLElement;
+        domElement: HTMLElement;
 
         setSize(width: number, height: number): void;
+
         render(scene: THREE.Scene, camera: THREE.Camera): void;
     }
 }

three/three-ctmloader.d.ts

@@ -0,0 +1,36 @@
+// Type definitions for three.js (CTMLoader.js)
+// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/loaders/ctm/CTMLoader.js
+// Definitions by: Hou Chunlei <https://github.com/omni360>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="three" />
+
+declare namespace THREE {
+    export class CTMLoader extends THREE.Loader {
+        constructor();
+
+        /**
+         * load multiple CTM parts defined in JSON.
+         * @param url(required)
+         * @param callback(required)
+         * @param parameters
+         */
+        loadParts(url: string, callback: () => any, parameters?: any): any;
+
+        /**
+         * Load CTMLoader compressed models
+         * @param url(required)
+         * @param callback(required)
+         * @param parameters
+         */
+        load(url: string, callback: (geo: any) => any, parameters?: any): any;
+
+        /**
+         * create buffergeometry by ctm file.
+         * @param file(required)
+         * @param callback(required)
+         */
+        createModel(file: string, callback: () => any): any;
+
+    }
+}

three/three-editorcontrols.d.ts

@@ -4,22 +4,25 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
 
-  class EditorControls extends EventDispatcher {
+    class EditorControls extends EventDispatcher {
 
-    constructor(object: Camera, domElement?:HTMLElement);
+        constructor(object: Camera, domElement?: HTMLElement);
 
-    enabled: boolean;
-    center: THREE.Vector3;
+        enabled: boolean;
+        center: THREE.Vector3;
 
-    focus(target: THREE.Object3D, frame: boolean): void;
-    pan(delta: THREE.Vector3): void;
-    zoom(delta: THREE.Vector3): void;
-    rotate(delta: THREE.Vector3): void;
-    dispose(): void;
+        focus(target: THREE.Object3D, frame: boolean): void;
 
-  }
+        pan(delta: THREE.Vector3): void;
+
+        zoom(delta: THREE.Vector3): void;
+
+        rotate(delta: THREE.Vector3): void;
+
+        dispose(): void;
+
+    }
 
 }

three/three-effectcomposer.d.ts

@@ -4,25 +4,27 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
-
-
 declare namespace THREE {
-	export class EffectComposer {
-		constructor( renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
+    export class EffectComposer {
+        constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
 
-		renderTarget1: WebGLRenderTarget;
-		renderTarget2: WebGLRenderTarget;
-		writeBuffer: WebGLRenderTarget;
-		readBuffer: WebGLRenderTarget;
-		passes: any[];
-		copyPass: ShaderPass;
+        renderTarget1: WebGLRenderTarget;
+        renderTarget2: WebGLRenderTarget;
+        writeBuffer: WebGLRenderTarget;
+        readBuffer: WebGLRenderTarget;
+        passes: any[];
+        copyPass: ShaderPass;
 
-		swapBuffers(): void;
-		addPass(pass: any): void;
-		insertPass(pass: any, index: number): void;
-		render(delta?: number): void;
-		reset(renderTarget?: WebGLRenderTarget): void;
-		setSize( width: number, height: number ): void;
-	}
+        swapBuffers(): void;
+
+        addPass(pass: any): void;
+
+        insertPass(pass: any, index: number): void;
+
+        render(delta?: number): void;
+
+        reset(renderTarget?: WebGLRenderTarget): void;
+
+        setSize(width: number, height: number): void;
+    }
 }

three/three-maskpass.d.ts

@@ -4,26 +4,25 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
-	export class MaskPass {
-		constructor( scene: Scene, camera: Camera);
+    export class MaskPass {
+        constructor(scene: Scene, camera: Camera);
 
-		scene: Scene;
-		camera: Camera;
-		enabled: boolean;
-		clear: boolean;
-		needsSwap: boolean;
-		inverse: boolean;
+        scene: Scene;
+        camera: Camera;
+        enabled: boolean;
+        clear: boolean;
+        needsSwap: boolean;
+        inverse: boolean;
 
         render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
-	}
+    }
 
-	export class ClearMaskPass {
-		constructor();
+    export class ClearMaskPass {
+        constructor();
 
-		enabled: boolean;
+        enabled: boolean;
 
         render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
-	}
+    }
 }

three/three-octree.d.ts

@@ -0,0 +1,42 @@
+// Type definitions for three.js (Octree.js)
+// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/Octree.js
+// Definitions by: Hou Chunlei <https://github.com/omni360>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="three" />
+
+declare  namespace THREE {
+    export class Octree {
+        constructor(parameters?: any);
+
+        update(): void;
+
+        add(object: any, options?: any): any;
+
+        addDeferred(object: any, options?: any): any;
+
+        addObjectData(object: any, part: any): any;
+
+        remove(object: any): any;
+
+        extend(octree: Octree): any;
+
+        rebuild(): any;
+
+        updateObject(object: any): any;
+
+        search(position: THREE.Vector3, radius: number, organizeByObject: boolean, direction: THREE.Vector3): any;
+
+        setRoot(root: any): any;
+
+        getDepthEnd(): number;
+
+        getNodeCountEnd(): number;
+
+        getObjectCountEnd(): number;
+
+        toConsole(): any;
+
+
+    }
+}

three/three-orbitcontrols.d.ts

@@ -4,7 +4,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
     class OrbitControls {
         constructor(object: Camera, domElement?: HTMLElement);
@@ -34,29 +33,43 @@ declare namespace THREE {
         minAzimuthAngle: number;
         maxAzimuthAngle: number;
         enableKeys: boolean;
-        keys: { LEFT: number; UP: number; RIGHT: number; BOTTOM: number; };
-        mouseButtons: { ORBIT: MOUSE; ZOOM: MOUSE; PAN: MOUSE; };
+        keys: {LEFT: number; UP: number; RIGHT: number; BOTTOM: number;};
+        mouseButtons: {ORBIT: MOUSE; ZOOM: MOUSE; PAN: MOUSE;};
         enableDamping: boolean;
         dampingFactor: number;
 
 
         rotateLeft(angle?: number): void;
+
         rotateUp(angle?: number): void;
+
         panLeft(distance?: number): void;
+
         panUp(distance?: number): void;
+
         pan(deltaX: number, deltaY: number): void;
+
         dollyIn(dollyScale: number): void;
+
         dollyOut(dollyScale: number): void;
+
         update(): void;
+
         reset(): void;
+
         dispose(): void;
+
         getPolarAngle(): number;
+
         getAzimuthalAngle(): number;
 
         // EventDispatcher mixins
         addEventListener(type: string, listener: (event: any) => void): void;
+
         hasEventListener(type: string, listener: (event: any) => void): void;
+
         removeEventListener(type: string, listener: (event: any) => void): void;
-        dispatchEvent(event: { type: string; target: any; }): void;
+
+        dispatchEvent(event: {type: string; target: any;}): void;
     }
 }

three/three-orthographictrackballcontrols.d.ts

@@ -4,48 +4,53 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 
+declare namespace THREE {
+    export class OrthographicTrackballControls extends EventDispatcher {
+        constructor(object: Camera, domElement?: HTMLElement);
 
-declare module THREE {
-	class OrthographicTrackballControls extends EventDispatcher {
-		constructor(object:Camera, domElement?:HTMLElement);
+        object: Camera;
+        domElement: HTMLElement;
 
-		object:Camera;
-		domElement:HTMLElement;
+        // API
+        enabled: boolean;
+        screen: {left: number; top: number; width: number; height: number};
+        radius: number;
+        rotateSpeed: number;
+        zoomSpeed: number;
+        panSpeed: number;
+        noRotate: boolean;
+        noZoom: boolean;
+        noPan: boolean;
+        noRoll: boolean;
+        staticMoving: boolean;
+        dynamicDampingFactor: number;
+        keys: number[];
 
-		// API
-		enabled:boolean;
-		screen:{ left: number; top: number; width: number; height: number };
-		radius:number;
-		rotateSpeed:number;
-		zoomSpeed:number;
-		panSpeed:number;
-		noRotate:boolean;
-		noZoom:boolean;
-		noPan:boolean;
-		noRoll:boolean;
-		staticMoving:boolean;
-		dynamicDampingFactor:number;
-		keys:number[];
+        target: THREE.Vector3;
 
-		target: THREE.Vector3;
+        position0: THREE.Vector3;
+        target0: THREE.Vector3;
+        up0: THREE.Vector3;
 
-		position0: THREE.Vector3;
-		target0: THREE.Vector3;
-		up0: THREE.Vector3;
+        left0: number;
+        right0: number;
+        top0: number;
+        bottom0: number;
 
-		left0: number;
-		right0: number;
-		top0: number;
-		bottom0: number;
+        update(): void;
 
-		update():void;
-		reset():void;
-		checkDistances():void;
-		zoomCamera():void;
-		panCamera():void;
-		rotateCamera():void;
+        reset(): void;
 
-		handleResize():void;
-		handleEvent(event: any):void;
-	}
+        checkDistances(): void;
+
+        zoomCamera(): void;
+
+        panCamera(): void;
+
+        rotateCamera(): void;
+
+        handleResize(): void;
+
+        handleEvent(event: any): void;
+    }
 }

three/three-projector.d.ts

@@ -4,14 +4,13 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
     // Renderers / Renderables /////////////////////////////////////////////////////////////////////
     export class RenderableObject {
         constructor();
 
         id: number;
-        object: Object;
+        object: any;
         z: number;
     }
 
@@ -58,7 +57,7 @@ declare namespace THREE {
         constructor();
 
         id: number;
-        object: Object;
+        object: any;
         x: number;
         y: number;
         z: number;

three/three-renderpass.d.ts

@@ -4,24 +4,23 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
-	export class RenderPass {
-		constructor( scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number );
-		constructor( scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: string, clearAlpha?: number );
-		constructor( scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: number, clearAlpha?: number );
+    export class RenderPass {
+        // constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number);
+        constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color | string | number, clearAlpha?: number);
+        // constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: number, clearAlpha?: number);
 
-		scene: Scene;
-		camera: Camera;
-		overrideMaterial: Material;
-		clearColor: any; // Color or string or number
-		clearAlpha: number;
-		oldClearColor: Color;
-		oldClearAlpha: number;
-		enabled: boolean;
-		clear: boolean;
-		needsSwap: boolean;
+        scene: Scene;
+        camera: Camera;
+        overrideMaterial: Material;
+        clearColor: any; // Color or string or number
+        clearAlpha: number;
+        oldClearColor: Color;
+        oldClearAlpha: number;
+        enabled: boolean;
+        clear: boolean;
+        needsSwap: boolean;
 
         render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
-	}
+    }
 }

three/three-shaderpass.d.ts

@@ -4,22 +4,21 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
-	export class ShaderPass {
-		constructor( shader: Shader, textureID?: string );
+    export class ShaderPass {
+        constructor(shader: Shader, textureID?: string);
 
-		textureID: string;
-		uniforms: any;
-		material: ShaderMaterial;
-		renderToScreen: boolean;
-		enabled: boolean;
-		needsSwap: boolean;
-		clear: boolean;
-		camera: Camera;
-		scene: Scene;
-		quad: Mesh;
+        textureID: string;
+        uniforms: any;
+        material: ShaderMaterial;
+        renderToScreen: boolean;
+        enabled: boolean;
+        needsSwap: boolean;
+        clear: boolean;
+        camera: Camera;
+        scene: Scene;
+        quad: Mesh;
 
-		render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
-	}
+        render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
+    }
 }

three/three-trackballcontrols.d.ts

@@ -4,43 +4,48 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
     class TrackballControls extends EventDispatcher {
-        constructor(object:Camera, domElement?:HTMLElement);
+        constructor(object: Camera, domElement?: HTMLElement);
 
-        object:Camera;
-        domElement:HTMLElement;
+        object: Camera;
+        domElement: HTMLElement;
 
         // API
-        enabled:boolean;
-        screen:{ left: number; top: number; width: number; height: number };
-        rotateSpeed:number;
-        zoomSpeed:number;
-        panSpeed:number;
-        noRotate:boolean;
-        noZoom:boolean;
-        noPan:boolean;
-        noRoll:boolean;
-        staticMoving:boolean;
-        dynamicDampingFactor:number;
-        minDistance:number;
-        maxDistance:number;
-        keys:number[];
+        enabled: boolean;
+        screen: {left: number; top: number; width: number; height: number};
+        rotateSpeed: number;
+        zoomSpeed: number;
+        panSpeed: number;
+        noRotate: boolean;
+        noZoom: boolean;
+        noPan: boolean;
+        noRoll: boolean;
+        staticMoving: boolean;
+        dynamicDampingFactor: number;
+        minDistance: number;
+        maxDistance: number;
+        keys: number[];
 
         target: THREE.Vector3;
         position0: THREE.Vector3;
         target0: THREE.Vector3;
         up0: THREE.Vector3;
 
-        update():void;
-        reset():void;
-        checkDistances():void;
-        zoomCamera():void;
-        panCamera():void;
-        rotateCamera():void;
+        update(): void;
 
-        handleResize():void;
-        handleEvent(event: any):void;
+        reset(): void;
+
+        checkDistances(): void;
+
+        zoomCamera(): void;
+
+        panCamera(): void;
+
+        rotateCamera(): void;
+
+        handleResize(): void;
+
+        handleEvent(event: any): void;
     }
 }

three/three-transformcontrols.d.ts

@@ -4,21 +4,27 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 
-
 declare namespace THREE {
-	class TransformControls extends Object3D {
-		constructor(object:Camera, domElement?:HTMLElement);
+    class TransformControls extends Object3D {
+        constructor(object: Camera, domElement?: HTMLElement);
 
-		object: Object3D;
+        object: Object3D;
 
-		update():void;
-		detach(): void;
-		attach(object: Object3D): void;
-		getMode(): string;
-		setMode(mode: string): void;
-		setSnap(snap: any): void;
-		setSize(size:number):void;
-		setSpace(space:string):void;
+        update(): void;
 
-	}
+        detach(): void;
+
+        attach(object: Object3D): void;
+
+        getMode(): string;
+
+        setMode(mode: string): void;
+
+        setSnap(snap: any): void;
+
+        setSize(size: number): void;
+
+        setSpace(space: string): void;
+
+    }
 }

three/three-vrcontrols.d.ts

@@ -8,12 +8,13 @@
 
 declare namespace THREE {
     export class VRControls {
-        constructor(camera: Camera, callback?: (param: string)=>void);
+        constructor(camera: Camera, callback?: (param: string) => void);
 
         /**
          * Update VR Instance Tracking
          */
         update(): void;
+
         zeroSensor(): void;
 
         scale: number;

three/three-vreffect.d.ts

@@ -8,25 +8,33 @@
 
 declare namespace THREE {
     export class VREffect {
-        constructor(renderer: Renderer, callback?: (params: string)=>void);
+        constructor(renderer: Renderer, callback?: (params: string) => void);
+
         render(scene: Scene, camera: Camera): void;
+
         setSize(width: number, height: number): void;
+
         setFullScreen(flag: boolean): void;
+
         startFullscreen(): void;
+
         FovToNDCScaleOffset(fov: VRFov): VREffectOffset;
+
         FovPortToProjection(fov: VRFov, rightHanded: boolean, zNear: number, zFar: number): Matrix4;
+
         FovToProjection(fov: VRFov, rightHanded: boolean, zNear: number, zFar: number): Matrix4;
+
         setVRDisplay(display: VRDisplay): void;
     }
 
-    export interface VRFov{
+    export interface VRFov {
         leftTan: number;
         rightTan: number;
         upTan: number;
         downTan: number;
     }
 
-    export interface VREffectOffset{
+    export interface VREffectOffset {
         scale: number;
         offset: number;
     }

three/tsconfig.json

@@ -49,6 +49,8 @@
         "test/canvas/canvas_particles_floor.ts",
         "test/examples/detector.ts",
         "test/examples/effects/vreffect.ts",
-        "test/examples/controls/vrcontrols.ts"
+        "test/examples/controls/vrcontrols.ts",
+        "test/examples/ctm/ctmloader.ts",
+        "test/examples/octree.ts"
     ]
-}
+}