New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@types/three

Package Overview
Dependencies
Maintainers
1
Versions
235
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@types/three - npm Package Compare versions

Comparing version 0.84.4 to 0.84.5

three/test/references.d.ts
three/three-core.d.ts
three/three-examples.d.ts

22

three/detector.d.ts

@@ -1,16 +0,8 @@

// Type definitions for three.js (Detector.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/Detector.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
export var canvas: boolean;
export var webgl: boolean;
export var workers: boolean;
export var fileapi: boolean;
export function getWebGLErrorMessage(): HTMLElement;
export function addGetWebGLMessage(parameters?: {id?: string; parent?: HTMLElement}): void;
interface DetectorStatic {
canvas: boolean;
webgl: boolean;
workers: boolean;
fileapi: boolean;
getWebGLErrorMessage(): HTMLElement;
addGetWebGLMessage(parameters?: {id?: string; parent?: HTMLElement}): void;
}
declare var Detector: DetectorStatic;
export as namespace Detector;

27

three/package.json
{
"name": "@types/three",
"version": "0.84.4",
"version": "0.84.5",
"description": "TypeScript definitions for three.js",

@@ -34,2 +34,22 @@ "license": "MIT",

"url": "https://github.com/piranha771"
},
{
"name": "Brandon Roberge, Qinsi ZHU",
"url": "https://github.com/qszhusightp"
},
{
"name": "Toshiya Nakakura",
"url": "https://github.com/nakakura"
},
{
"name": "Poul Kjeldager Sørensen",
"url": "https://github.com/s093294"
},
{
"name": "Stefan Profanter",
"url": "https://github.com/Pro"
},
{
"name": "Edmund Fokschaner",
"url": "https://github.com/efokschaner"
}

@@ -44,7 +64,10 @@ ],

"dependencies": {
"@types/dat-gui": "*",
"@types/stats.js": "*",
"@types/tween.js": "*",
"@types/webvr-api": "*"
},
"peerDependencies": {},
"typesPublisherContentHash": "874d402629fd58c9dc6e87589ff52105dd1637c677f78be8278086c6a4d1446a",
"typesPublisherContentHash": "cfba7f58715bf5d8e3165696fcf81cdc9af3bbe5400700d515a07fce802c0eaf",
"typeScriptVersion": "2.0"
}

6

three/README.md

@@ -11,7 +11,7 @@ # Installation

Additional Details
* Last updated: Tue, 18 Apr 2017 15:11:46 GMT
* Dependencies: webvr-api
* Last updated: Wed, 19 Apr 2017 21:19:05 GMT
* Dependencies: dat-gui, stats.js, tween.js, webvr-api
* Global values: Detector, THREE
# Credits
These definitions were written 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>, Ivo <https://github.com/ivoisbelongtous>, David Asmuth <https://github.com/piranha771>.
These definitions were written 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>, Ivo <https://github.com/ivoisbelongtous>, David Asmuth <https://github.com/piranha771>, Brandon Roberge, Qinsi ZHU <https://github.com/qszhusightp>, Toshiya Nakakura <https://github.com/nakakura>, Poul Kjeldager Sørensen <https://github.com/s093294>, Stefan Profanter <https://github.com/Pro>, Edmund Fokschaner <https://github.com/efokschaner>.

96

three/three-canvasrenderer.d.ts

@@ -1,74 +0,76 @@

// 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: https://github.com/DefinitelyTyped/DefinitelyTyped
import {
Camera,
Color,
Material,
MaterialParameters,
Renderer,
Scene
} from "./three-core";
declare namespace THREE {
export interface SpriteCanvasMaterialParameters extends MaterialParameters {
color?: number;
program?: (context: CanvasRenderingContext2D, color: Color) => void;
}
export interface SpriteCanvasMaterialParameters extends MaterialParameters {
color?: number;
program?: (context: CanvasRenderingContext2D, color: Color) => void;
}
export class SpriteCanvasMaterial extends Material {
constructor(parameters?: SpriteCanvasMaterialParameters);
export class SpriteCanvasMaterial extends Material {
constructor(parameters?: SpriteCanvasMaterialParameters);
color: Color;
color: Color;
program(context: CanvasRenderingContext2D, color: Color): void;
}
program(context: CanvasRenderingContext2D, color: Color): void;
}
export interface CanvasRendererParameters {
canvas?: HTMLCanvasElement;
devicePixelRatio?: number;
alpha?: boolean;
}
export interface CanvasRendererParameters {
canvas?: HTMLCanvasElement;
devicePixelRatio?: number;
alpha?: boolean;
}
export class CanvasRenderer implements Renderer {
constructor(parameters?: CanvasRendererParameters);
export class CanvasRenderer implements Renderer {
constructor(parameters?: CanvasRendererParameters);
domElement: HTMLCanvasElement;
autoClear: boolean;
sortObjects: boolean;
sortElements: boolean;
info: {render: {vertices: number; faces: number;};};
domElement: HTMLCanvasElement;
autoClear: boolean;
sortObjects: boolean;
sortElements: boolean;
info: {render: {vertices: number; faces: number;};};
supportsVertexTextures(): void;
supportsVertexTextures(): void;
setFaceCulling(): void;
setFaceCulling(): void;
getPixelRatio(): number;
getPixelRatio(): number;
setPixelRatio(value: number): void;
setPixelRatio(value: number): void;
setSize(width: number, height: number, updateStyle?: boolean): void;
setSize(width: number, height: number, updateStyle?: boolean): void;
setViewport(x: number, y: number, width: number, height: number): void;
setViewport(x: number, y: number, width: number, height: number): void;
setScissor(): void;
setScissor(): void;
enableScissorTest(): void;
enableScissorTest(): void;
setClearColor(color: Color | string | number, opacity?: number): void;
setClearColor(color: Color | string | number, opacity?: number): void;
// setClearColor(color: string, opacity?: number): void;
// setClearColor(color: number, opacity?: number): void;
// setClearColor(color: string, opacity?: number): void;
// setClearColor(color: number, opacity?: number): void;
setClearColorHex(hex: number, alpha?: number): void;
setClearColorHex(hex: number, alpha?: number): void;
getClearColor(): Color;
getClearColor(): Color;
getClearAlpha(): number;
getClearAlpha(): number;
getMaxAnisotropy(): number;
getMaxAnisotropy(): number;
clear(): void;
clear(): void;
clearColor(): void;
clearColor(): void;
clearDepth(): void;
clearDepth(): void;
clearStencil(): void;
clearStencil(): void;
render(scene: Scene, camera: Camera): void;
}
render(scene: Scene, camera: Camera): void;
}

35

three/three-colladaLoader.d.ts

@@ -1,23 +0,20 @@

// Type definitions for three.js (ColladaLoader2.js)
// NOTE : These typings are for the loader named ColladaLoader2.js
// supplied by the npm package @types/three 0.81.
// Definitions by: Brandon Roberge
import {
Scene
} from "./three-core";
declare namespace THREE {
export interface ColladaLoaderReturnType {
export interface ColladaLoaderReturnType {
}
}
export class ColladaModel {
animations: any[];
kinematics: any;
scene: THREE.Scene;
library: any;
}
export class ColladaLoader {
constructor();
export class ColladaModel {
animations: any[];
kinematics: any;
scene: Scene;
library: any;
}
export class ColladaLoader {
constructor();
load(url: string, onLoad: (model: ColladaModel) => void, onProgress?: (request: ProgressEvent) => void, onError?:(event: ErrorEvent) => void): void;
setCrossOrigin(value: any): void;
parse(text: string): ColladaModel;
}
load(url: string, onLoad: (model: ColladaModel) => void, onProgress?: (request: ProgressEvent) => void, onError?:(event: ErrorEvent) => void): void;
setCrossOrigin(value: any): void;
parse(text: string): ColladaModel;
}

11

three/three-copyshader.d.ts

@@ -1,9 +0,2 @@

// Type definitions for three.js (CopyShader.js)
// Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/shaders/CopyShader.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare namespace THREE {
export var CopyShader: Shader;
}
import { Shader } from "./three-core";
export var CopyShader: Shader;

38

three/three-css3drenderer.d.ts

@@ -1,32 +0,24 @@

// Type definitions for three.js (CSS3DRenderer.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/renderers/CSS3DRenderer.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Camera, Object3D, Scene } from "./three-core";
// This renderer does not work in IE. Can be found here for more information.
// https://github.com/mrdoob/three.js/issues/4783
export class CSS3DObject extends Object3D {
constructor(element: any);
element: any;
}
declare namespace THREE {
class CSS3DObject extends Object3D {
constructor(element: any);
export class CSS3DSprite extends CSS3DObject {
constructor(element: any);
element: any;
}
}
class CSS3DSprite extends CSS3DObject {
constructor(element: any);
// This renderer does not work in IE. Can be found here for more information.
// https://github.com/mrdoob/three.js/issues/4783
export class CSS3DRenderer {
constructor();
}
domElement: HTMLElement;
setSize(width: number, height: number): void;
class CSS3DRenderer {
constructor();
domElement: HTMLElement;
setSize(width: number, height: number): void;
render(scene: THREE.Scene, camera: THREE.Camera): void;
}
render(scene: Scene, camera: Camera): void;
}

54

three/three-ctmloader.d.ts

@@ -1,36 +0,28 @@

// 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
import { Loader } from "./three-core";
/// <reference types="three" />
export class CTMLoader extends Loader {
constructor();
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 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;
/**
* 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;
}
/**
* create buffergeometry by ctm file.
* @param file(required)
* @param callback(required)
*/
createModel(file: string, callback: () => any): any;
}

29

three/three-editorcontrols.d.ts

@@ -1,28 +0,19 @@

// Type definitions for three.js (EditorControls.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/EditorControls.js
// Definitions by: Qinsi ZHU <https://github.com/qszhusightp>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Camera, EventDispatcher, Object3D, Vector3 } from "./three-core";
export class EditorControls extends EventDispatcher {
declare namespace THREE {
constructor(object: Camera, domElement?: HTMLElement);
class EditorControls extends EventDispatcher {
enabled: boolean;
center: Vector3;
constructor(object: Camera, domElement?: HTMLElement);
focus(target: Object3D, frame: boolean): void;
enabled: boolean;
center: THREE.Vector3;
pan(delta: Vector3): void;
focus(target: THREE.Object3D, frame: boolean): void;
zoom(delta: Vector3): void;
pan(delta: THREE.Vector3): void;
rotate(delta: Vector3): void;
zoom(delta: THREE.Vector3): void;
rotate(delta: THREE.Vector3): void;
dispose(): void;
}
dispose(): void;
}

37

three/three-effectcomposer.d.ts

@@ -1,30 +0,25 @@

// Type definitions for three.js (EffectComposer.js)
// Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/EffectComposer.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { WebGLRenderTarget, WebGLRenderer } from "./three-core";
import { ShaderPass } from "./three-shaderpass";
export class EffectComposer {
constructor(renderer: WebGLRenderer, renderTarget?: WebGLRenderTarget);
declare namespace THREE {
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;
swapBuffers(): void;
addPass(pass: any): void;
addPass(pass: any): void;
insertPass(pass: any, index: number): void;
insertPass(pass: any, index: number): void;
render(delta?: number): void;
render(delta?: number): void;
reset(renderTarget?: WebGLRenderTarget): void;
reset(renderTarget?: WebGLRenderTarget): void;
setSize(width: number, height: number): void;
}
setSize(width: number, height: number): void;
}

77

three/three-FirstPersonControls.d.ts

@@ -1,47 +0,40 @@

// Type definitions for three.js
// Project: http://mrdoob.github.com/three.js/
// Definitions by: Poul Kjeldager Sørensen <https://github.com/s093294>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
//Source : https://github.com/NTaylorMullen/CycleR/blob/master/CycleR/CycleR.Game.Client/Client/Interfaces/ThreeJS/Cameras/FirstPersonControls.d.ts
import { Camera, Object3D, Vector3 } from "./three-core";
export class FirstPersonControls {
constructor(object: Camera, domElement?: HTMLElement);
declare namespace THREE {
class FirstPersonControls {
constructor(object: Camera, domElement?: HTMLElement);
object: Object3D;
target: Vector3;
domElement: HTMLCanvasElement | HTMLDocument;
enabled: boolean;
movementSpeed: number;
lookSpeed: number;
noFly: boolean;
lookVertical: boolean;
autoForward: boolean;
activeLook: boolean;
heightSpeed: boolean;
heightCoef: number;
heightMin: number;
heightMax: number;
constrainVertical: boolean;
verticalMin: number;
verticalMax: number;
autoSpeedFactor: number;
mouseX: number;
mouseY: number;
lat: number;
lon: number;
phi: number;
theta: number;
moveForward: boolean;
moveBackward: boolean;
moveLeft: boolean;
moveRight: boolean;
freeze: boolean;
mouseDragOn: boolean;
object: THREE.Object3D;
target: THREE.Vector3;
domElement: HTMLCanvasElement | HTMLDocument;
enabled: boolean;
movementSpeed: number;
lookSpeed: number;
noFly: boolean;
lookVertical: boolean;
autoForward: boolean;
activeLook: boolean;
heightSpeed: boolean;
heightCoef: number;
heightMin: number;
heightMax: number;
constrainVertical: boolean;
verticalMin: number;
verticalMax: number;
autoSpeedFactor: number;
mouseX: number;
mouseY: number;
lat: number;
lon: number;
phi: number;
theta: number;
moveForward: boolean;
moveBackward: boolean;
moveLeft: boolean;
moveRight: boolean;
freeze: boolean;
mouseDragOn: boolean;
update(delta: number): void;
update(delta: number): void;
dispose(): void;
}
dispose(): void;
}

36

three/three-maskpass.d.ts

@@ -1,28 +0,22 @@

// Type definitions for three.js (MaskPass.js)
// Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/MaskPass.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Camera, Scene, WebGLRenderTarget, WebGLRenderer } from "./three-core";
export class MaskPass {
constructor(scene: Scene, camera: Camera);
declare namespace THREE {
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;
}
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;
}
render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
}

45

three/three-octree.d.ts

@@ -1,42 +0,33 @@

// 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
import { Vector3 } from "./three-core";
/// <reference types="three" />
export class Octree {
constructor(parameters?: any);
declare namespace THREE {
export class Octree {
constructor(parameters?: any);
update(): void;
update(): void;
add(object: any, options?: any): any;
add(object: any, options?: any): any;
addDeferred(object: any, options?: any): any;
addDeferred(object: any, options?: any): any;
addObjectData(object: any, part: any): any;
addObjectData(object: any, part: any): any;
remove(object: any): any;
remove(object: any): any;
extend(octree: Octree): any;
extend(octree: Octree): any;
rebuild(): any;
rebuild(): any;
updateObject(object: any): any;
updateObject(object: any): any;
search(position: Vector3, radius: number, organizeByObject: boolean, direction: Vector3): any;
search(position: THREE.Vector3, radius: number, organizeByObject: boolean, direction: THREE.Vector3): any;
setRoot(root: any): any;
setRoot(root: any): any;
getDepthEnd(): number;
getDepthEnd(): number;
getNodeCountEnd(): number;
getNodeCountEnd(): number;
getObjectCountEnd(): number;
getObjectCountEnd(): number;
toConsole(): any;
}
}
toConsole(): any;
}

98

three/three-orbitcontrols.d.ts

@@ -1,75 +0,69 @@

// Type definitions for three.js (OrbitControls.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/OrbitControls.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Camera, MOUSE, Object3D, Vector3 } from "./three-core";
export class OrbitControls {
constructor(object: Camera, domElement?: HTMLElement);
declare namespace THREE {
class OrbitControls {
constructor(object: Camera, domElement?: HTMLElement);
object: Camera;
domElement: HTMLElement | HTMLDocument;
object: Camera;
domElement: HTMLElement | HTMLDocument;
// API
enabled: boolean;
target: Vector3;
// API
enabled: boolean;
target: THREE.Vector3;
// deprecated
center: Vector3;
// deprecated
center: THREE.Vector3;
enableZoom: boolean;
zoomSpeed: number;
minDistance: number;
maxDistance: number;
enableRotate: boolean;
rotateSpeed: number;
enablePan: boolean;
keyPanSpeed: number;
autoRotate: boolean;
autoRotateSpeed: number;
minPolarAngle: number;
maxPolarAngle: number;
minAzimuthAngle: number;
maxAzimuthAngle: number;
enableKeys: boolean;
keys: {LEFT: number; UP: number; RIGHT: number; BOTTOM: number;};
mouseButtons: {ORBIT: MOUSE; ZOOM: MOUSE; PAN: MOUSE;};
enableDamping: boolean;
dampingFactor: number;
enableZoom: boolean;
zoomSpeed: number;
minDistance: number;
maxDistance: number;
enableRotate: boolean;
rotateSpeed: number;
enablePan: boolean;
keyPanSpeed: number;
autoRotate: boolean;
autoRotateSpeed: number;
minPolarAngle: number;
maxPolarAngle: number;
minAzimuthAngle: number;
maxAzimuthAngle: number;
enableKeys: boolean;
keys: {LEFT: number; UP: number; RIGHT: number; BOTTOM: number;};
mouseButtons: {ORBIT: MOUSE; ZOOM: MOUSE; PAN: MOUSE;};
enableDamping: boolean;
dampingFactor: number;
rotateLeft(angle?: number): void;
rotateLeft(angle?: number): void;
rotateUp(angle?: number): void;
rotateUp(angle?: number): void;
panLeft(distance?: number): void;
panLeft(distance?: number): void;
panUp(distance?: number): void;
panUp(distance?: number): void;
pan(deltaX: number, deltaY: number): void;
pan(deltaX: number, deltaY: number): void;
dollyIn(dollyScale: number): void;
dollyIn(dollyScale: number): void;
dollyOut(dollyScale: number): void;
dollyOut(dollyScale: number): void;
update(): void;
update(): void;
reset(): void;
reset(): void;
dispose(): void;
dispose(): void;
getPolarAngle(): number;
getPolarAngle(): number;
getAzimuthalAngle(): number;
getAzimuthalAngle(): number;
// EventDispatcher mixins
addEventListener(type: string, listener: (event: any) => void): void;
// EventDispatcher mixins
addEventListener(type: string, listener: (event: any) => void): void;
hasEventListener(type: string, listener: (event: any) => void): void;
hasEventListener(type: string, listener: (event: any) => void): void;
removeEventListener(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;
}

76

three/three-orthographictrackballcontrols.d.ts

@@ -1,56 +0,50 @@

// Type definitions for three.js (OrthographicTrackballControls.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/OrthographicTrackballControls.js
// Definitions by: Stefan Profanter <https://github.com/pro>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
import { Camera, EventDispatcher, Vector3 } from "./three-core";
export class OrthographicTrackballControls extends EventDispatcher {
constructor(object: Camera, domElement?: HTMLElement);
declare namespace THREE {
export 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: Vector3;
target: THREE.Vector3;
position0: Vector3;
target0: Vector3;
up0: 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;
reset(): void;
checkDistances(): void;
checkDistances(): void;
zoomCamera(): void;
zoomCamera(): void;
panCamera(): void;
panCamera(): void;
rotateCamera(): void;
rotateCamera(): void;
handleResize(): void;
handleResize(): void;
handleEvent(event: any): void;
}
handleEvent(event: any): void;
}

163

three/three-projector.d.ts

@@ -1,96 +0,101 @@

// Type definitions for three.js (Projector.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/renderers/Projector.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {
Camera,
Color,
Face3,
Light,
Material,
Object3D,
Scene,
Vector2,
Vector3,
Vector4
} from "./three-core";
// Renderers / Renderables /////////////////////////////////////////////////////////////////////
export class RenderableObject {
constructor();
declare namespace THREE {
// Renderers / Renderables /////////////////////////////////////////////////////////////////////
export class RenderableObject {
constructor();
id: number;
object: any;
z: number;
}
id: number;
object: any;
z: number;
}
export class RenderableFace {
constructor();
export class RenderableFace {
constructor();
id: number;
v1: RenderableVertex;
v2: RenderableVertex;
v3: RenderableVertex;
normalModel: Vector3;
vertexNormalsModel: Vector3[];
vertexNormalsLength: number;
color: Color;
material: Material;
uvs: Vector2[][];
z: number;
id: number;
v1: RenderableVertex;
v2: RenderableVertex;
v3: RenderableVertex;
normalModel: Vector3;
vertexNormalsModel: Vector3[];
vertexNormalsLength: number;
color: Color;
material: Material;
uvs: Vector2[][];
z: number;
}
}
export class RenderableVertex {
constructor();
export class RenderableVertex {
constructor();
position: Vector3;
positionWorld: Vector3;
positionScreen: Vector4;
visible: boolean;
position: Vector3;
positionWorld: Vector3;
positionScreen: Vector4;
visible: boolean;
copy(vertex: RenderableVertex): void;
}
copy(vertex: RenderableVertex): void;
}
export class RenderableLine {
constructor();
export class RenderableLine {
constructor();
id: number;
v1: RenderableVertex;
v2: RenderableVertex;
vertexColors: Color[];
material: Material;
z: number;
}
id: number;
v1: RenderableVertex;
v2: RenderableVertex;
vertexColors: Color[];
material: Material;
z: number;
}
export class RenderableSprite {
constructor();
export class RenderableSprite {
constructor();
id: number;
object: any;
x: number;
y: number;
z: number;
rotation: number;
scale: Vector2;
material: Material;
}
id: number;
object: any;
x: number;
y: number;
z: number;
rotation: number;
scale: Vector2;
material: Material;
}
/**
* Projects points between spaces.
*/
export class Projector {
constructor();
// deprecated.
projectVector(vector: Vector3, camera: Camera): Vector3;
// deprecated.
unprojectVector(vector: Vector3, camera: Camera): Vector3;
/**
* Projects points between spaces.
* Transforms a 3D scene object into 2D render data that can be rendered in a screen with your renderer of choice, projecting and clipping things out according to the used camera.
* If the scene were a real scene, this method would be the equivalent of taking a picture with the camera (and developing the film would be the next step, using a Renderer).
*
* @param scene scene to project.
* @param camera camera to use in the projection.
* @param sort select whether to sort elements using the Painter's algorithm.
*/
export class Projector {
constructor();
// deprecated.
projectVector(vector: Vector3, camera: Camera): Vector3;
// deprecated.
unprojectVector(vector: Vector3, camera: Camera): Vector3;
/**
* Transforms a 3D scene object into 2D render data that can be rendered in a screen with your renderer of choice, projecting and clipping things out according to the used camera.
* If the scene were a real scene, this method would be the equivalent of taking a picture with the camera (and developing the film would be the next step, using a Renderer).
*
* @param scene scene to project.
* @param camera camera to use in the projection.
* @param sort select whether to sort elements using the Painter's algorithm.
*/
projectScene(scene: Scene, camera: Camera, sortObjects: boolean, sortElements?: boolean): {
objects: Object3D[]; // Mesh, Line or other object
sprites: Object3D[]; // Sprite or Particle
lights: Light[];
elements: Face3[]; // Line, Particle, Face3 or Face4
};
}
projectScene(scene: Scene, camera: Camera, sortObjects: boolean, sortElements?: boolean): {
objects: Object3D[]; // Mesh, Line or other object
sprites: Object3D[]; // Sprite or Particle
lights: Light[];
elements: Face3[]; // Line, Particle, Face3 or Face4
};
}

43

three/three-renderpass.d.ts

@@ -1,26 +0,25 @@

// Type definitions for three.js (RenderPass.js)
// Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/RenderPass.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {
Camera,
Color,
Material,
Scene,
WebGLRenderTarget,
WebGLRenderer
} from "./three-core";
export class RenderPass {
constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color | string | number, clearAlpha?: number);
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?: Color | string | number, clearAlpha?: number);
// constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: number, clearAlpha?: number);
scene: Scene;
camera: Camera;
overrideMaterial: Material;
clearColor: Color | string | 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;
}
render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, delta: number): void;
}

44

three/three-shaderpass.d.ts

@@ -1,24 +0,26 @@

// Type definitions for three.js (ShaderPass.js)
// Project: https://github.com/mrdoob/three.js/blob/r68/examples/js/postprocessing/ShaderPass.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {
Camera,
Mesh,
Scene,
Shader,
ShaderMaterial,
WebGLRenderTarget,
WebGLRenderer
} from "./three-core";
export class ShaderPass {
constructor(shader: Shader, textureID?: string);
declare namespace THREE {
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;
}

70

three/three-trackballcontrols.d.ts

@@ -1,51 +0,45 @@

// Type definitions for three.js (TrackballControls.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/TrackballControls.js
// Definitions by: Satoru Kimura <https://github.com/gyohk>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Camera, EventDispatcher, Vector3 } from "./three-core";
export class TrackballControls extends EventDispatcher {
constructor(object: Camera, domElement?: HTMLElement);
declare namespace THREE {
class TrackballControls 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};
rotateSpeed: number;
zoomSpeed: number;
panSpeed: number;
noRotate: boolean;
noZoom: boolean;
noPan: boolean;
noRoll: boolean;
staticMoving: boolean;
dynamicDampingFactor: number;
minDistance: number;
maxDistance: number;
keys: number[];
// 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[];
target: Vector3;
position0: Vector3;
target0: Vector3;
up0: Vector3;
target: THREE.Vector3;
position0: THREE.Vector3;
target0: THREE.Vector3;
up0: THREE.Vector3;
update(): void;
update(): void;
reset(): void;
reset(): void;
checkDistances(): void;
checkDistances(): void;
zoomCamera(): void;
zoomCamera(): void;
panCamera(): void;
panCamera(): void;
rotateCamera(): void;
rotateCamera(): void;
handleResize(): void;
handleResize(): void;
handleEvent(event: any): void;
}
handleEvent(event: any): void;
}

30

three/three-transformcontrols.d.ts

@@ -1,30 +0,24 @@

// Type definitions for three.js (TransformControls.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/TransformControls.js
// Definitions by: Stefan Profanter <https://github.com/Pro>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import { Camera, Object3D } from "./three-core";
export class TransformControls extends Object3D {
constructor(object: Camera, domElement?: HTMLElement);
declare namespace THREE {
class TransformControls extends Object3D {
constructor(object: Camera, domElement?: HTMLElement);
object: Object3D;
object: Object3D;
update(): void;
update(): void;
detach(): void;
detach(): void;
attach(object: Object3D): void;
attach(object: Object3D): void;
getMode(): string;
getMode(): string;
setMode(mode: string): void;
setMode(mode: string): void;
setSnap(snap: any): void;
setSnap(snap: any): void;
setSize(size: number): void;
setSize(size: number): void;
setSpace(space: string): void;
setSpace(space: string): void;
}
}

28

three/three-vrcontrols.d.ts

@@ -1,24 +0,18 @@

// Type definitions for three.js (VRControls.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/controls/VRControls.js
// Definitions by: Toshiya Nakakura <https://github.com/nakakura>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="three" />
/// <reference types="webvr-api" />
declare namespace THREE {
export class VRControls {
constructor(camera: Camera, callback?: (param: string) => void);
import { Camera } from "./three-core";
/**
* Update VR Instance Tracking
*/
update(): void;
export class VRControls {
constructor(camera: Camera, callback?: (param: string) => void);
zeroSensor(): void;
/**
* Update VR Instance Tracking
*/
update(): void;
scale: number;
zeroSensor(): void;
setVRDisplay(display: VRDisplay): void;
}
scale: number;
setVRDisplay(display: VRDisplay): void;
}

50

three/three-vreffect.d.ts

@@ -1,41 +0,35 @@

// Type definitions for three.js (VREffect.js)
// Project: https://github.com/mrdoob/three.js/blob/master/examples/js/effects/VREffect.js
// Definitions by: Toshiya Nakakura <https://github.com/nakakura>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="three" />
/// <reference types="webvr-api" />
declare namespace THREE {
export class VREffect {
constructor(renderer: Renderer, callback?: (params: string) => void);
import { Camera, Matrix4, Renderer, Scene } from "./three-core";
render(scene: Scene, camera: Camera): void;
export class VREffect {
constructor(renderer: Renderer, callback?: (params: string) => void);
setSize(width: number, height: number): void;
render(scene: Scene, camera: Camera): void;
setFullScreen(flag: boolean): void;
setSize(width: number, height: number): void;
startFullscreen(): void;
setFullScreen(flag: boolean): void;
FovToNDCScaleOffset(fov: VRFov): VREffectOffset;
startFullscreen(): void;
FovPortToProjection(fov: VRFov, rightHanded: boolean, zNear: number, zFar: number): Matrix4;
FovToNDCScaleOffset(fov: VRFov): VREffectOffset;
FovToProjection(fov: VRFov, rightHanded: boolean, zNear: number, zFar: number): Matrix4;
FovPortToProjection(fov: VRFov, rightHanded: boolean, zNear: number, zFar: number): Matrix4;
setVRDisplay(display: VRDisplay): void;
}
FovToProjection(fov: VRFov, rightHanded: boolean, zNear: number, zFar: number): Matrix4;
export interface VRFov {
leftTan: number;
rightTan: number;
upTan: number;
downTan: number;
}
setVRDisplay(display: VRDisplay): void;
}
export interface VREffectOffset {
scale: number;
offset: number;
}
export interface VRFov {
leftTan: number;
rightTan: number;
upTan: number;
downTan: number;
}
export interface VREffectOffset {
scale: number;
offset: number;
}
three/index.d.ts

Sorry, the diff of this file is too big to display

three/LICENSE

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc