From 28428d34bee80c815d226353664a62d97b56ffe0 Mon Sep 17 00:00:00 2001 From: satoru kimura Date: Fri, 22 Aug 2014 14:02:08 +0900 Subject: [PATCH 1/2] Rearranged the order of the methods and properties in this definition, to be consistent with the original JS code. --- threejs/three.d.ts | 1945 ++++++++++++++++++++++++-------------------- 1 file changed, 1041 insertions(+), 904 deletions(-) diff --git a/threejs/three.d.ts b/threejs/three.d.ts index 2eb17c19b4..fa62089901 100644 --- a/threejs/three.d.ts +++ b/threejs/three.d.ts @@ -8,33 +8,7 @@ interface WebGLRenderingContext {} declare module THREE { export var REVISION: string; - // custom blending equations - // (numbers start from 100 not to clash with other - // mappings to OpenGL constants defined in Texture.js) - export enum BlendingEquation { } - export var AddEquation: BlendingEquation; - export var SubtractEquation: BlendingEquation; - export var ReverseSubtractEquation: BlendingEquation; - - // custom blending destination factors - export enum BlendingDstFactor { } - export var ZeroFactor: BlendingDstFactor; - export var OneFactor: BlendingDstFactor; - export var SrcColorFactor: BlendingDstFactor; - export var OneMinusSrcColorFactor: BlendingDstFactor; - export var SrcAlphaFactor: BlendingDstFactor; - export var OneMinusSrcAlphaFactor: BlendingDstFactor; - export var DstAlphaFactor: BlendingDstFactor; - export var OneMinusDstAlphaFactor: BlendingDstFactor; - - // custom blending source factors - export enum BlendingSrcFactor { } - export var DstColorFactor: BlendingSrcFactor; - export var OneMinusDstColorFactor: BlendingSrcFactor; - export var SrcAlphaSaturateFactor: BlendingSrcFactor; - // GL STATE CONSTANTS - export enum CullFace { } export var CullFaceNone: CullFace; export var CullFaceBack: CullFace; @@ -45,6 +19,12 @@ declare module THREE { export var FrontFaceDirectionCW: FrontFaceDirection; export var FrontFaceDirectionCCW: FrontFaceDirection; + // Shadowing Type + export enum ShadowMapType { } + export var BasicShadowMap: ShadowMapType; + export var PCFShadowMap: ShadowMapType; + export var PCFSoftShadowMap: ShadowMapType; + // MATERIAL CONSTANTS // side @@ -74,11 +54,30 @@ declare module THREE { export var MultiplyBlending: Blending; export var CustomBlending: Blending; - // Shadowing Type - export enum ShadowMapType { } - export var BasicShadowMap: ShadowMapType; - export var PCFShadowMap: ShadowMapType; - export var PCFSoftShadowMap: ShadowMapType; + // custom blending equations + // (numbers start from 100 not to clash with other + // mappings to OpenGL constants defined in Texture.js) + export enum BlendingEquation { } + export var AddEquation: BlendingEquation; + export var SubtractEquation: BlendingEquation; + export var ReverseSubtractEquation: BlendingEquation; + + // custom blending destination factors + export enum BlendingDstFactor { } + export var ZeroFactor: BlendingDstFactor; + export var OneFactor: BlendingDstFactor; + export var SrcColorFactor: BlendingDstFactor; + export var OneMinusSrcColorFactor: BlendingDstFactor; + export var SrcAlphaFactor: BlendingDstFactor; + export var OneMinusSrcAlphaFactor: BlendingDstFactor; + export var DstAlphaFactor: BlendingDstFactor; + export var OneMinusDstAlphaFactor: BlendingDstFactor; + + // custom blending src factors + export enum BlendingSrcFactor { } + export var DstColorFactor: BlendingSrcFactor; + export var OneMinusDstColorFactor: BlendingSrcFactor; + export var SrcAlphaSaturateFactor: BlendingSrcFactor; // TEXTURE CONSTANTS // Operations @@ -94,9 +93,7 @@ declare module THREE { } export var UVMapping: MappingConstructor; export var CubeReflectionMapping: MappingConstructor; - export var CubeRefractionMapping: MappingConstructor; export var SphericalReflectionMapping: MappingConstructor; - export var SphericalRefractionMapping: MappingConstructor; // Wrapping modes export enum Wrapping { } @@ -125,7 +122,6 @@ declare module THREE { // Pixel types export enum PixelType { } - export var UnsignedShort4444Type: PixelType; export var UnsignedShort5551Type: PixelType; export var UnsignedShort565Type: PixelType; @@ -145,6 +141,7 @@ declare module THREE { export var RGBA_S3TC_DXT3_Format: CompressedPixelFormat; export var RGBA_S3TC_DXT5_Format: CompressedPixelFormat; + // Cameras //////////////////////////////////////////////////////////////////////////////////////// /** @@ -171,6 +168,7 @@ declare module THREE { * @param vector point to look at */ lookAt(vector: Vector3): void; + clone(camera?: Camera): Camera; } @@ -335,9 +333,9 @@ declare module THREE { // Core /////////////////////////////////////////////////////////////////////////////////////////////// export class BufferAttribute { - constructor(array: any, itemSize: number); + constructor(array: any, itemSize: number); // array parameter should be TypedArray. - array: any; + array: number[]; itemSize: number; length: number; @@ -352,47 +350,47 @@ declare module THREE { // deprecated export class Int8Attribute extends BufferAttribute{ - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Uint8Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Uint8ClampedAttribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Int16Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Uint16Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Int32Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Uint32Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Float32Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } // deprecated export class Float64Attribute extends BufferAttribute { - constructor(data: any[], itemSize: number); + constructor(data: any, itemSize: number); } /** @@ -412,7 +410,6 @@ declare module THREE { * Unique number of this buffergeometry instance */ id: number; - uuid: string; name: string; attributes: BufferAttribute[]; @@ -445,6 +442,9 @@ declare module THREE { */ computeBoundingSphere(): void; + // deprecated + computeFaceNormals(): void; + /** * Computes vertex normals by averaging face normals. */ @@ -635,23 +635,21 @@ declare module THREE { */ c: number; - // properties inherits from Face /////////////////////////////////// - /** * Face normal. */ normal: Vector3; - /** - * Face color. - */ - color: Color; - /** * Array of 4 vertex normals. */ vertexNormals: Vector3[]; + /** + * Face color. + */ + color: Color; + /** * Array of 4 vertex normals. */ @@ -716,6 +714,8 @@ declare module THREE { */ id: number; + uuid: string; + /** * Name for this geometry. Default is an empty string. */ @@ -735,13 +735,6 @@ declare module THREE { */ colors: Color[]; - /** - * Array of vertex normals, matching number and order of vertices. - * Normal vectors are nessecary for lighting - * To signal an update in this array, Geometry.normalsNeedUpdate needs to be set to true. - */ -// normals: Vector3[]; - /** * Array of triangles or/and quads. * The array of faces describe how each vertex in the model is connected with each other. @@ -749,13 +742,6 @@ declare module THREE { */ faces: Face3[]; - /** - * Array of face UV layers. - * Each UV layer is an array of UV matching order and number of faces. - * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true. - */ -// faceUvs: Vector2[][]; - /** * Array of face UV layers. * Each UV layer is an array of UV matching order and number of vertices in faces. @@ -901,6 +887,8 @@ declare module THREE { */ computeTangents(): void; + computeLineDistances(): void; + /** * Computes bounding box of the geometry, updating {@link Geometry.boundingBox} attribute. */ @@ -920,6 +908,8 @@ declare module THREE { */ mergeVertices(): number; + makeGroups(usesFaceMaterial: boolean, maxVerticesInGroup: number): void; + /** * Creates a new clone of the Geometry. */ @@ -931,10 +921,6 @@ declare module THREE { */ dispose(): void; - computeLineDistances(): void; - - makeGroups(usesFaceMaterial: boolean, maxVerticesInGroup: number): void; - // EventDispatcher mixins addEventListener(type: string, listener: (event: any) => void ): void; @@ -1063,8 +1049,9 @@ declare module THREE { /** * Order of axis for Euler angles. */ + // deprecated eulerOrder: string; - // eulerOrder:EulerOrder; + /** * This updates the position, rotation and scale with the matrix. @@ -1091,6 +1078,13 @@ declare module THREE { */ setRotationFromQuaternion( q: Quaternion ): void; + /** + * Rotate an object along an axis in object space. The axis is assumed to be normalized. + * @param axis A normalized vector in object space. + * @param angle The angle in radians. + */ + rotateOnAxis(axis: Vector3, angle: number): Object3D; + /** * * @param angle @@ -1109,6 +1103,12 @@ declare module THREE { */ rotateZ(angle: number): Object3D; + /** + * @param axis A normalized vector in object space. + * @param distance The distance to translate. + */ + translateOnAxis(axis: Vector3, distance: number): Object3D; + /** * * @param distance @@ -1187,10 +1187,10 @@ declare module THREE { * @param name String to match to the children's Object3d.name property. * @param recursive Boolean whether to search through the children's children. Default is false. */ - getObjectByName(name: string, recursive: boolean): Object3D; + getObjectByName(name: string, recursive?: boolean): Object3D; - getChildByName( name: string, recursive: boolean ): Object3D; + getChildByName( name: string, recursive?: boolean ): Object3D; /** * Updates local transform. @@ -1209,20 +1209,6 @@ declare module THREE { */ clone(object?: Object3D, recursive?: boolean): Object3D; - /** - * @param axis A normalized vector in object space. - * @param distance The distance to translate. - */ - translateOnAxis(axis: Vector3, distance: number): Object3D; - - /** - * Rotate an object along an axis in object space. The axis is assumed to be normalized. - * @param axis A normalized vector in object space. - * @param angle The angle in radians. - */ - rotateOnAxis(axis: Vector3, angle: number): Object3D; - - // EventDispatcher mixins addEventListener(type: string, listener: (event: any) => void ): void; hasEventListener(type: string, listener: (event: any) => void): void; @@ -1279,6 +1265,7 @@ declare module THREE { export class Raycaster { constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number); + ray: Ray; near: number; far: number; @@ -1324,15 +1311,15 @@ declare module THREE { export class AreaLight extends Light{ constructor(hex: number, intensity?: number); - position: Vector3; - right: Vector3; normal: Vector3; - quadraticAttenuation: number; - height: number; - linearAttenuation: number; - width: number; + right: Vector3; intensity: number; + width: number; + height: number; constantAttenuation: number; + linearAttenuation: number; + quadraticAttenuation: number; + } /** @@ -1350,12 +1337,6 @@ declare module THREE { constructor(hex?: number, intensity?: number); - /** - * Direction of the light is normalized vector from position to (0,0,0). - * Default — new THREE.Vector3(). - */ - position: Vector3; - /** * Target used for shadow camera orientation. */ @@ -1516,7 +1497,6 @@ declare module THREE { export class HemisphereLight extends Light { constructor(skyColorHex?: number, groundColorHex?: number, intensity?: number); - position: Vector3; groundColor: Color; intensity: number; @@ -1534,12 +1514,6 @@ declare module THREE { export class PointLight extends Light { constructor(hex?: number, intensity?: number, distance?: number); - /** - * Light's position. - * Default — new THREE.Vector3(). - */ - position: Vector3; - /* * Light's intensity. * Default - 1.0. @@ -1573,12 +1547,6 @@ declare module THREE { export class SpotLight extends Light { constructor(hex?: number, intensity?: number, distance?: number, angle?: number, exponent?: number); - /** - * Light's position. - * Default — new THREE.Vector3(). - */ - position: Vector3; - /** * Spotlight focus points at target.position. * Default position — (0,0,0). @@ -1668,11 +1636,11 @@ declare module THREE { * Default — 512. */ shadowMapHeight: number; - shadowMatrix: Matrix4; + shadowMap: RenderTarget; shadowMapSize: Vector2; shadowCamera: Camera; - shadowMap: RenderTarget; + shadowMatrix: Matrix4; clone(): SpotLight; } @@ -1734,12 +1702,12 @@ declare module THREE { */ crossOrigin: string; - needsTangents(materials: Material[]): boolean; - updateProgress(progress: Progress): void; - createMaterial(m: Material, texturePath: string): boolean; - initMaterials(materials: Material[], texturePath: string): Material[]; - extractUrlBase(url: string): string; addStatusElement(): HTMLElement; + updateProgress(progress: Progress): void; + extractUrlBase(url: string): string; + initMaterials(materials: Material[], texturePath: string): Material[]; + needsTangents(materials: Material[]): boolean; + createMaterial(m: Material, texturePath: string): boolean; static Handlers:LoaderHandler; } @@ -1756,17 +1724,8 @@ declare module THREE { load(url: string, onLoad: (bufferGeometry: BufferGeometry) => void, onProgress?: (event: any) => void, onError?: (event: any) => void): void; setCrossOrigin(crossOrigin: string): void; parse(json: any): BufferGeometry; - } - /* - * GeometryLoader class is experimental, and it is not yet included in the compiled source code. - * - export class GeometryLoader { - - } - */ - export class Cache{ constructor(); @@ -1777,12 +1736,22 @@ declare module THREE { remove(key: string): void; clear(): void; } + + /* + * GeometryLoader class is experimental, and it is not yet included in the compiled source code. + * + export class GeometryLoader { + + } + */ + /** * A loader for loading an image. * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object. */ export class ImageLoader { constructor(manager?: LoadingManager); + crossOrigin: string; /** @@ -1790,15 +1759,16 @@ declare module THREE { * @param url */ load(url: string, onLoad?: (image: HTMLImageElement) => void, onProgress?: (event: any) => void, onError?: (event: any) => void): HTMLImageElement; + setCrossOrigin(crossOrigin: string): void; } - /** * A loader for loading objects in JSON format. */ export class JSONLoader extends Loader { constructor(showStatus?: boolean); + withCredentials: boolean; /** @@ -1807,12 +1777,13 @@ declare module THREE { * @param texturePath If not specified, textures will be assumed to be in the same folder as the Javascript model file. */ load(url: string, callback: (geometry: JSonLoaderResultGeometry, materials: Material[]) => void , texturePath?: string): void; - parse(json:string, texturePath:string): any; + loadAjaxJSON(context: JSONLoader, url: string, callback: (geometry: Geometry, materials: Material[]) => void , texturePath?: string, callbackProgress?: (progress: Progress) => void ): void; + parse(json:string, texturePath:string): any; } - export class JSonLoaderResultGeometry extends Geometry { + export interface JSonLoaderResultGeometry extends Geometry { animation: AnimationData; } @@ -1883,16 +1854,34 @@ declare module THREE { export class XHRLoader { constructor(manager?: LoadingManager); - cache: Cache; - crossOrigin: string; responseType: string; + crossOrigin: string; load(url: string, onLoad?: (responseText: string) => void, onProgress?: (event: any) => void, onError?: (event: any) => void): void; - setCrossOrigin(crossOrigin: string): void; setResponseType(responseType: string): void; + setCrossOrigin(crossOrigin: string): void; } // Materials ////////////////////////////////////////////////////////////////////////////////// + export interface MaterialParameters { + name?: string; + side?: Side; + opacity?: number; + transparent?: boolean; + blending?: Blending; + blendSrc?: BlendingDstFactor; + blendDst?: BlendingSrcFactor; + blendEquation?: BlendingEquation; + depthTest?: boolean; + depthWrite?: boolean; + polygonOffset?: boolean; + polygonOffsetFactor?: number; + polygonOffsetUnits?: number; + alphaTest?: number; + overdraw?: number; + visible?: boolean; + needsUpdate?: boolean; + } /** * Materials describe the appearance of objects. They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer. @@ -1905,11 +1894,19 @@ declare module THREE { */ id: number; + uuid: string; + /** * Material name. Default is an empty string. */ name: string; + /** + * Defines which of the face sides will be rendered - front, back or both. + * Default is THREE.FrontSide. Other options are THREE.BackSide and THREE.DoubleSide. + */ + side: Side; + /** * Opacity. Default is 1. */ @@ -1982,23 +1979,15 @@ declare module THREE { */ visible: boolean; - /** - * Defines which of the face sides will be rendered - front, back or both. - * Default is THREE.FrontSide. Other options are THREE.BackSide and THREE.DoubleSide. - */ - side: Side; - /** * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL. * This property is automatically set to true when instancing a new material. */ needsUpdate: boolean; - clone(material?:Material): Material; - - dispose(): void; setValues(values: Object): void; - + clone(material?:Material): Material; + dispose(): void; // EventDispatcher mixins addEventListener(type: string, listener: (event: any) => void ): void; @@ -2007,7 +1996,7 @@ declare module THREE { dispatchEvent(event: { type: string; target: any; }): void; } - export interface LineBasicMaterialParameters { + export interface LineBasicMaterialParameters extends MaterialParameters { color?: number; linewidth?: number; linecap?: string; @@ -2017,8 +2006,8 @@ declare module THREE { } export class LineBasicMaterial extends Material { - constructor(parameters?: LineBasicMaterialParameters); + color: Color; linewidth: number; linecap: string; @@ -2029,86 +2018,87 @@ declare module THREE { clone(): LineBasicMaterial; } - export interface LineDashedMaterialParameters { - scale?: number; + export interface LineDashedMaterialParameters extends MaterialParameters { color?: number; - vertexColors?: boolean; - dashSize?: number; - fog?: boolean; - gapSize?: number; linewidth?: number; + scale?: number; + dashSize?: number; + gapSize?: number; + vertexColors?: Colors; + fog?: boolean; } export class LineDashedMaterial extends Material { constructor(parameters?: LineDashedMaterialParameters); - scale: number; + color: Color; - vertexColors: boolean; - dashSize: number; - fog: boolean; - gapSize: number; linewidth: number; + scale: number; + dashSize: number; + gapSize: number; + vertexColors: Colors; + fog: boolean; clone(): LineDashedMaterial; } - /** * parameters is an object with one or more properties defining the material's appearance. */ - export interface MeshBasicMaterialParameters { + export interface MeshBasicMaterialParameters extends MaterialParameters{ color?: number; - wireframe?: boolean; - wireframeLinewidth?: number; - wireframeLinecap?: string; - wireframeLinejoin?: string; - shading?: Shading; - vertexColors?: Colors; - fog?: boolean; + map?: Texture; lightMap?: Texture; specularMap?: Texture; alphaMap?: Texture; envMap?: Texture; - skinning?: boolean; - morphTargets?: boolean; - map?: Texture; combine?: Combine; reflectivity?: number; refractionRatio?: number; + fog?: boolean; + shading?: Shading; + wireframe?: boolean; + wireframeLinewidth?: number; + wireframeLinecap?: string; + wireframeLinejoin?: string; + vertexColors?: Colors; + skinning?: boolean; + morphTargets?: boolean; } export class MeshBasicMaterial extends Material { constructor(parameters?: MeshBasicMaterialParameters); color: Color; - wireframe: boolean; - wireframeLinewidth: number; - wireframeLinecap: string; - wireframeLinejoin: string; - shading: Shading; - vertexColors: Colors; - fog: boolean; + map: Texture; lightMap: Texture; specularMap: Texture; alphaMap: Texture; envMap: Texture; - skinning: boolean; - morphTargets: boolean; - map: Texture; combine: Combine; reflectivity: number; refractionRatio: number; + fog: boolean; + shading: Shading; + wireframe: boolean; + wireframeLinewidth: number; + wireframeLinecap: string; + wireframeLinejoin: string; + vertexColors: Colors; + skinning: boolean; + morphTargets: boolean; clone(): MeshBasicMaterial; } - export interface MeshDepthMaterialParameters { + export interface MeshDepthMaterialParameters extends MaterialParameters{ wireframe?: boolean; wireframeLinewidth?: number; } export class MeshDepthMaterial extends Material { constructor(parameters?: MeshDepthMaterialParameters); + wireframe: boolean; wireframeLinewidth: number; @@ -2124,30 +2114,30 @@ declare module THREE { clone(): MeshFaceMaterial; } - export interface MeshLambertMaterialParameters { + export interface MeshLambertMaterialParameters extends MaterialParameters{ color?: number; ambient?: number; emissive?: number; + wrapAround?: boolean; + wrapRGB?: Vector3; + map?: Texture; + lightMap?: Texture; + specularMap?: Texture; + alphaMap?: Texture; + envMap?: Texture; + combine?: Combine; + reflectivity?: number; + refractionRatio?: number; + fog?: boolean; shading?: Shading; wireframe?: boolean; wireframeLinewidth?: number; wireframeLinecap?: string; wireframeLinejoin?: string; vertexColors?: Colors; - fog?: boolean; - map?: Texture; - lightMap?: Texture; - specularMap?: Texture; - alphaMap?: Texture; - envMap?: Texture; - reflectivity?: number; - refractionRatio?: number; - combine?: Combine; skinning?: boolean; morphTargets?: boolean; - wrapRGB?: Vector3; morphNormals?: boolean; - wrapAround?: boolean; } export class MeshLambertMaterial extends Material { @@ -2155,119 +2145,119 @@ declare module THREE { color: Color; ambient: Color; emissive: Color; + wrapAround: boolean; + wrapRGB: Vector3; + map: Texture; + lightMap: Texture; + specularMap: Texture; + alphaMap: Texture; + envMap: Texture; + combine: Combine; + reflectivity: number; + refractionRatio: number; + fog: boolean; shading: Shading; wireframe: boolean; wireframeLinewidth: number; wireframeLinecap: string; wireframeLinejoin: string; vertexColors: Colors; - fog: boolean; - map: Texture; - lightMap: Texture; - specularMap: Texture; - alphaMap: Texture; - envMap: Texture; - reflectivity: number; - refractionRatio: number; - combine: Combine; skinning: boolean; morphTargets: boolean; - wrapRGB: Vector3; morphNormals: boolean; - wrapAround: boolean; clone(): MeshLambertMaterial; } - export interface MeshNormalMaterialParameters { - morphTargets?: boolean; + export interface MeshNormalMaterialParameters extends MaterialParameters{ shading?: Shading; wireframe?: boolean; wireframeLinewidth?: number; + morphTargets?: boolean; } export class MeshNormalMaterial extends Material { constructor(parameters?: MeshNormalMaterialParameters); - morphTargets: boolean; + shading: Shading; wireframe: boolean; wireframeLinewidth: number; + morphTargets: boolean; clone(): MeshNormalMaterial; } - export interface MeshPhongMaterialParameters { + export interface MeshPhongMaterialParameters extends MaterialParameters{ color?: number; // diffuse ambient?: number; emissive?: number; specular?: number; shininess?: number; + metal?: boolean; + wrapAround?: boolean; + wrapRGB?: Vector3; + map?: Texture; + lightMap?: Texture; + bumpMap?: Texture; + bumpScale?: number; + normalMap?: Texture; + normalScale?: Vector2; + specularMap?: Texture; + alphaMap?: Texture; + envMap?: Texture; + combine?: Combine; + reflectivity?: number; + refractionRatio?: number; + fog?: boolean; shading?: Shading; wireframe?: boolean; wireframeLinewidth?: number; wireframeLinecap?: string; wireframeLinejoin?: string; vertexColors?: Colors; - fog?: boolean; - map?: Texture; - lightMap?: Texture; - specularMap?: Texture; - alphaMap?: Texture; - envMap?: Texture; - reflectivity?: number; - refractionRatio?: number; - combine?: Combine; skinning?: boolean; morphTargets?: boolean; - normalScale?: Vector2; morphNormals?: boolean; - metal?: boolean; - bumpScale?: number; - wrapAround?: boolean; - perPixel?: boolean; - normalMap?: Texture; - bumpMap?: Texture; - wrapRGB?: Vector3; } export class MeshPhongMaterial extends Material { constructor(parameters?: MeshPhongMaterialParameters); + color: Color; // diffuse ambient: Color; emissive: Color; specular: Color; shininess: number; + metal: boolean; + wrapAround: boolean; + wrapRGB: Vector3; + map: Texture; + lightMap: Texture; + bumpMap: Texture; + bumpScale: number; + normalMap: Texture; + normalScale: Vector2; + specularMap: Texture; + alphaMap: Texture; + envMap: Texture; + combine: Combine; + reflectivity: number; + refractionRatio: number; + fog: boolean; shading: Shading; wireframe: boolean; wireframeLinewidth: number; wireframeLinecap: string; wireframeLinejoin: string; vertexColors: Colors; - fog: boolean; - map: Texture; - lightMap: Texture; - specularMap: Texture; - alphaMap: Texture; - envMap: Texture; - reflectivity: number; - refractionRatio: number; - combine: Combine; skinning: boolean; morphTargets: boolean; - normalScale: Vector2; morphNormals: boolean; - metal: boolean; - bumpScale: number; - wrapAround: boolean; - - normalMap: Texture; - bumpMap: Texture; - wrapRGB: Vector3; clone(): MeshPhongMaterial; } - export interface PointCloudMaterialParameters { + export interface PointCloudMaterialParameters extends MaterialParameters{ color?: number; map?: Texture; size?: number; @@ -2277,7 +2267,6 @@ declare module THREE { } export class PointCloudMaterial extends Material { - constructor(parameters?: PointCloudMaterialParameters); color: Color; @@ -2305,75 +2294,47 @@ declare module THREE { } - export interface ShaderMaterialParameters { + export interface ShaderMaterialParameters extends MaterialParameters{ + defines?: any; uniforms?: any; - fragmentShader?: string; - vertexShader?: string; - morphTargets?: boolean; - lights?: boolean; - morphNormals?: boolean; - wireframe?: boolean; - vertexColors?: Colors; - skinning?: boolean; - fog?: boolean; attributes?: any; + vertexShader?: string; + fragmentShader?: string; shading?: Shading; linewidth?: number; + wireframe?: boolean; wireframeLinewidth?: number; - defines?: any; + fog?: boolean; + lights?: boolean; + vertexColors?: Colors; + skinning?: boolean; + morphTargets?: boolean; + morphNormals?: boolean; } export class ShaderMaterial extends Material { constructor(parameters?: ShaderMaterialParameters); + defines: any; uniforms: any; - fragmentShader: string; - vertexShader: string; - morphTargets: boolean; - lights: boolean; - morphNormals: boolean; - wireframe: boolean; - vertexColors: Colors; - skinning: boolean; - fog: boolean; attributes: any; + vertexShader: string; + fragmentShader: string; shading: Shading; linewidth: number; + wireframe: boolean; wireframeLinewidth: number; - defines: any; + fog: boolean; + lights: boolean; + vertexColors: Colors; + skinning: boolean; + morphTargets: boolean; + morphNormals: boolean; clone(): ShaderMaterial; } - export interface SpriteMaterialParameters { - map?: Texture; - uvScale?: Vector2; - sizeAttenuation?: boolean; - color?: number; - uvOffset?: Vector2; - fog?: boolean; - useScreenCoordinates?: boolean; - scaleByViewport?: boolean; - alignment?: Vector2; - } - - export class SpriteMaterial extends Material { - constructor(parameters?: SpriteMaterialParameters); - - map: Texture; - uvScale: Vector2; - sizeAttenuation: boolean; - color: Color; - uvOffset: Vector2; - fog: boolean; - useScreenCoordinates: boolean; - scaleByViewport: boolean; - alignment: Vector2; - - clone(): SpriteMaterial; - } - - export interface SpriteCanvasMaterialParameters { + export interface SpriteCanvasMaterialParameters extends MaterialParameters{ color?: number; } @@ -2387,67 +2348,87 @@ declare module THREE { clone(): SpriteCanvasMaterial; } + export interface SpriteMaterialParameters extends MaterialParameters{ + color?: number; + map?: Texture; + rotation?: number; + fog?: boolean; + } + + export class SpriteMaterial extends Material { + constructor(parameters?: SpriteMaterialParameters); + + color: Color; + map: Texture; + rotation: number; + fog: boolean; + + clone(): SpriteMaterial; + } + // Math ////////////////////////////////////////////////////////////////////////////////// export class Box2 { constructor(min?: Vector2, max?: Vector2); + max: Vector2; min: Vector2; set(min: Vector2, max: Vector2): Box2; - expandByPoint(point: Vector2): Box2; - clampPoint(point: Vector2, optionalTarget?: Vector2): Vector2; - isIntersectionBox(box: Box2): boolean; setFromPoints(points: Vector2[]): Box2; - size(optionalTarget?: Vector2): Vector2; - union(box: Box2): Box2; - getParameter(point: Vector2): Vector2; - expandByScalar(scalar: number): Box2; - intersect(box: Box2): Box2; - containsBox(box: Box2): boolean; - translate(offset: Vector2): Box2; - empty(): boolean; - clone(): Box2; - equals(box: Box2): boolean; - expandByVector(vector: Vector2): Box2; + setFromCenterAndSize(center: Vector2, size: number): Box2; copy(box: Box2): Box2; makeEmpty(): Box2; + empty(): boolean; center(optionalTarget?: Vector2): Vector2; - distanceToPoint(point: Vector2): number; + size(optionalTarget?: Vector2): Vector2; + expandByPoint(point: Vector2): Box2; + expandByVector(vector: Vector2): Box2; + expandByScalar(scalar: number): Box2; containsPoint(point: Vector2): boolean; - setFromCenterAndSize(center: Vector2, size: number): Box2; + containsBox(box: Box2): boolean; + getParameter(point: Vector2): Vector2; + isIntersectionBox(box: Box2): boolean; + clampPoint(point: Vector2, optionalTarget?: Vector2): Vector2; + distanceToPoint(point: Vector2): number; + intersect(box: Box2): Box2; + union(box: Box2): Box2; + translate(offset: Vector2): Box2; + equals(box: Box2): boolean; + clone(): Box2; } export class Box3 { constructor(min?: Vector3, max?: Vector3); + max: Vector3; min: Vector3; set(min: Vector3, max: Vector3): Box3; - applyMatrix4(matrix: Matrix4): Box3; - expandByPoint(point: Vector3): Box3; - clampPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - isIntersectionBox(box: Box3): boolean; setFromPoints(points: Vector3[]): Box3; - size(optionalTarget?: Vector3): Vector3; - union(box: Box3): Box3; - getParameter(point: Vector3): Vector3; - expandByScalar(scalar: number): Box3; - intersect(box: Box3): Box3; - containsBox(box: Box3): boolean; - translate(offset: Vector3): Box3; - empty(): boolean; - clone(): Box3; - equals(box: Box3): boolean; - expandByVector(vector: Vector3): Box3; - copy(box: Box3): Box3; - makeEmpty(): Box3; - center(optionalTarget?: Vector3): Vector3; - getBoundingSphere(): Sphere; - distanceToPoint(point: Vector3): number; - containsPoint(point: Vector3): boolean; setFromCenterAndSize(center: Vector3, size: number): Box3; setFromObject(object: Object3D): Box3; + copy(box: Box3): Box3; + makeEmpty(): Box3; + empty(): boolean; + center(optionalTarget?: Vector3): Vector3; + size(optionalTarget?: Vector3): Vector3; + expandByPoint(point: Vector3): Box3; + expandByVector(vector: Vector3): Box3; + expandByScalar(scalar: number): Box3; + containsPoint(point: Vector3): boolean; + containsBox(box: Box3): boolean; + getParameter(point: Vector3): Vector3; + isIntersectionBox(box: Box3): boolean; + clampPoint(point: Vector3, optionalTarget?: Vector3): Vector3; + distanceToPoint(point: Vector3): number; + getBoundingSphere(): Sphere; + intersect(box: Box3): Box3; + union(box: Box3): Box3; + applyMatrix4(matrix: Matrix4): Box3; + translate(offset: Vector3): Box3; + equals(box: Box3): boolean; + clone(): Box3; } export interface HSL { @@ -2488,6 +2469,31 @@ declare module THREE { set(color: Color): Color; set(color: number): Color; set(color: string): Color; + setHex(hex: number): Color; + + /** + * Sets this color from RGB values. + * @param r Red channel value between 0 and 1. + * @param g Green channel value between 0 and 1. + * @param b Blue channel value between 0 and 1. + */ + setRGB(r: number, g: number, b: number): Color; + + /** + * Sets this color from HSL values. + * Based on MochiKit implementation by Bob Ippolito. + * + * @param h Hue channel value between 0 and 1. + * @param s Saturation value channel between 0 and 1. + * @param l Value channel value between 0 and 1. + */ + setHSL(h: number, s: number, l: number): Color; + + /** + * Sets this color from a CSS context style string. + * @param contextStyle Color in CSS context style format. + */ + setStyle(style: string): Color; /** * Copies given color. @@ -2517,14 +2523,6 @@ declare module THREE { */ convertLinearToGamma(): Color; - /** - * Sets this color from RGB values. - * @param r Red channel value between 0 and 1. - * @param g Green channel value between 0 and 1. - * @param b Blue channel value between 0 and 1. - */ - setRGB(r: number, g: number, b: number): Color; - /** * Returns the hexadecimal value of this color. */ @@ -2535,13 +2533,7 @@ declare module THREE { */ getHexString(): string; - setHex(hex: number): Color; - - /** - * Sets this color from a CSS context style string. - * @param contextStyle Color in CSS context style format. - */ - setStyle(style: string): Color; + getHSL(): HSL; /** * Returns the value of this color in CSS context style. @@ -2549,18 +2541,6 @@ declare module THREE { */ getStyle(): string; - /** - * Sets this color from HSL values. - * Based on MochiKit implementation by Bob Ippolito. - * - * @param h Hue channel value between 0 and 1. - * @param s Saturation value channel between 0 and 1. - * @param l Value channel value between 0 and 1. - */ - setHSL(h: number, s: number, l: number): Color; - - getHSL(): HSL; - offsetHSL(h: number, s: number, l: number): Color; add(color: Color): Color; @@ -2570,6 +2550,8 @@ declare module THREE { multiplyScalar(s: number): Color; lerp(color: Color, alpha: number): Color; equals(color: Color): boolean; + fromArray(rgb: number[]): Color; + toArray(): number[]; /** * Clones this color. @@ -2737,12 +2719,14 @@ declare module THREE { set(x: number, y: number, z: number, order?: string): Euler; copy(euler: Euler): Euler; - setFromRotationMatrix(m: Matrix4, order: string): Euler; - setFromQuaternion(q:Quaternion, order: string): Euler; + setFromRotationMatrix(m: Matrix4, order?: string): Euler; + setFromQuaternion(q:Quaternion, order?: string, update?: boolean): Euler; reorder(newOrder: string): Euler; + equals(euler: Euler): boolean; fromArray(xyzo: any[]): Euler; toArray(): any[]; - equals(euler: Euler): boolean; + onChange: () => void; + clone(): Euler; } @@ -2757,13 +2741,15 @@ declare module THREE { */ planes: Plane[]; - setFromMatrix(m: Matrix4): Frustum; - intersectsObject(object: Object3D): boolean; - clone(): Frustum; set(p0?: number, p1?: number, p2?: number, p3?: number, p4?: number, p5?: number): Frustum; copy(frustum: Frustum): Frustum; - containsPoint(point: Vector3): boolean; + setFromMatrix(m: Matrix4): Frustum; + intersectsObject(object: Object3D): boolean; intersectsSphere(sphere: Sphere): boolean; + intersectsBox(box: Box3): boolean; + containsPoint(point: Vector3): boolean; + clone(): Frustum; + } export class Line3 { @@ -2773,19 +2759,21 @@ declare module THREE { set(start?: Vector3, end?: Vector3): Line3; copy(line: Line3): Line3; - clone(): Line3; - equals(line: Line3): boolean; - distance(): number; - distanceSq(): number; - applyMatrix4(matrix: Matrix4): Line3; - at(t: number, optionalTarget?: Vector3): Vector3; center(optionalTarget?: Vector3): Vector3; delta(optionalTarget?: Vector3): Vector3; - closestPointToPoint(point: Vector3, clampToLine?: boolean, optionalTarget?: Vector3): Vector3; + distanceSq(): number; + distance(): number; + at(t: number, optionalTarget?: Vector3): Vector3; closestPointToPointParameter(point: Vector3, clampToLine?: boolean): number; + closestPointToPoint(point: Vector3, clampToLine?: boolean, optionalTarget?: Vector3): Vector3; + applyMatrix4(matrix: Matrix4): Line3; + equals(line: Line3): boolean; + clone(): Line3; } interface Math { + generateUUID(): string; + /** * Clamps the x to be between a and b. * @@ -2814,6 +2802,10 @@ declare module THREE { */ mapLinear(x: number, a1: number, a2: number, b1: number, b2: number): number; + smoothstep(x: number, min: number, max: number): number; + + smootherstep(x: number, min: number, max: number): number; + /** * Random float from 0 to 1 with 16 bits of randomness. * Standard Math.random() creates repetitive patterns when applied over larger space. @@ -2844,9 +2836,7 @@ declare module THREE { radToDeg(radians: number): number; - smoothstep(x: number, min: number, max: number): number; - - smootherstep(x: number, min: number, max: number): number; + isPowerOfTwo(value: number): boolean; } /** @@ -2874,8 +2864,6 @@ declare module THREE { */ copy(m: Matrix): Matrix; - multiplyVector3Array(a: number[]): number[]; - /** * multiplyScalar(s:number):T; */ @@ -2918,29 +2906,29 @@ declare module THREE { */ elements: Float32Array; + set(n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): Matrix3; + identity(): Matrix3; + copy(m: Matrix3): Matrix3; + applyToVector3Array(array: number[], offset?: number, length?: number): number[]; + multiplyScalar(s: number): Matrix3; + determinant(): number; + getInverse(matrix: Matrix3, throwOnInvertible?: boolean): Matrix3; + getInverse(matrix: Matrix4, throwOnInvertible?: boolean): Matrix3; + /** * Transposes this matrix in place. */ transpose(): Matrix3; + flattenToArrayOffset(array: number[], offset: number): number[]; + getNormalMatrix(m: Matrix4): Matrix3; /** * Transposes this matrix into the supplied array r, and returns itself. */ transposeIntoArray(r: number[]): number[]; - - determinant(): number; - set(n11: number, n12: number, n13: number, n21: number, n22: number, n23: number, n31: number, n32: number, n33: number): Matrix3; - multiplyScalar(s: number): Matrix3; - // DEPRECATED - multiplyVector3Array(a: number[]): number[]; - applyToVector3Array(array: number[], offset?: number, length?: number): number[]; - flattenToArrayOffset(array: number[], offset: number): number[]; - getNormalMatrix(m: Matrix4): Matrix3; - getInverse(matrix: Matrix3, throwOnInvertible?: boolean): Matrix3; - getInverse(matrix: Matrix4, throwOnInvertible?: boolean): Matrix3; - copy(m: Matrix3): Matrix3; + fromArray(array: number[]): Matrix3; + toArray(): number[]; clone(): Matrix3; - identity(): Matrix3; } /** @@ -2992,7 +2980,8 @@ declare module THREE { * Copies the rotation component of the supplied matrix m into this matrix rotation component. */ extractRotation(m: Matrix4): Matrix4; - + makeRotationFromEuler(euler: Euler): Matrix4; + makeRotationFromQuaternion(q: Quaternion): Matrix4; /** * Constructs a rotation matrix, looking from eye towards center with defined up vector. */ @@ -3018,6 +3007,7 @@ declare module THREE { * Multiplies this matrix by s. */ multiplyScalar(s: number): Matrix4; + applyToVector3Array(array: number[], offset?: number, length?: number): number[]; /** * Computes determinant of this matrix. @@ -3046,25 +3036,12 @@ declare module THREE { */ getInverse(m: Matrix4, throwOnInvertible?: boolean): Matrix4; - makeRotationFromEuler(euler: Euler): Matrix4; - makeRotationFromQuaternion(q: Quaternion): Matrix4; - /** * Multiplies the columns of this matrix by vector v. */ scale(v: Vector3): Matrix4; - /** - * Sets this matrix to the transformation composed of translation, rotation and scale. - */ - compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4; - - /** - * Decomposes this matrix into the translation, rotation and scale components. - * If parameters are not passed, new instances will be created. - */ - decompose(translation?: Vector3, rotation?: Quaternion, scale?: Vector3): Object[]; // [Vector3, Quaternion, Vector3] - + getMaxScaleOnAxis(): number; /** * Sets this matrix as translation transform. */ @@ -3105,6 +3082,17 @@ declare module THREE { */ makeScale(x: number, y: number, z: number): Matrix4; + /** + * Sets this matrix to the transformation composed of translation, rotation and scale. + */ + compose(translation: Vector3, rotation: Quaternion, scale: Vector3): Matrix4; + + /** + * Decomposes this matrix into the translation, rotation and scale components. + * If parameters are not passed, new instances will be created. + */ + decompose(translation?: Vector3, rotation?: Quaternion, scale?: Vector3): Object[]; // [Vector3, Quaternion, Vector3] + /** * Creates a frustum matrix. */ @@ -3119,17 +3107,12 @@ declare module THREE { * Creates an orthographic projection matrix. */ makeOrthographic(left: number, right: number, top: number, bottom: number, near: number, far: number): Matrix4; - + fromArray(array: number[]): Matrix4; + toArray(): number[]; /** * Clones this matrix. */ clone(): Matrix4; - - // DEPRECATED - multiplyVector3Array(a: number[]): number[]; - applyToVector3Array(array: number[], offset?: number, length?: number): number[]; - - getMaxScaleOnAxis(): number; } export class Plane { @@ -3138,24 +3121,24 @@ declare module THREE { normal: Vector3; constant: number; - normalize(): Plane; set(normal: Vector3, constant: number): Plane; + setComponents(x: number, y: number, z: number, w: number): Plane; + setFromNormalAndCoplanarPoint(normal: Vector3, point: Vector3): Plane; + setFromCoplanarPoints(a: Vector3, b: Vector3, c: Vector3): Plane; copy(plane: Plane): Plane; - applyMatrix4(matrix: Matrix4, optionalNormalMatrix?: Matrix3): Plane; + normalize(): Plane; + negate(): Plane; + distanceToPoint(point: Vector3): number; + distanceToSphere(sphere: Sphere): number; + projectPoint(point: Vector3, optionalTarget?: Vector3): Vector3; orthoPoint(point: Vector3, optionalTarget?: Vector3): Vector3; isIntersectionLine(line: Line3): boolean; intersectLine(line: Line3, optionalTarget?: Vector3): Vector3; - setFromNormalAndCoplanarPoint(normal: Vector3, point: Vector3): Plane; - clone(): Plane; - distanceToPoint(point: Vector3): number; - equals(plane: Plane): boolean; - setComponents(x: number, y: number, z: number, w: number): Plane; - distanceToSphere(sphere: Sphere): number; - setFromCoplanarPoints(a: Vector3, b: Vector3, c: Vector3): Plane; - projectPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - negate(): Plane; - translate(offset: Vector3): Plane; coplanarPoint(optionalTarget?: boolean): Vector3; + applyMatrix4(matrix: Matrix4, optionalNormalMatrix?: Matrix3): Plane; + translate(offset: Vector3): Plane; + equals(plane: Plane): boolean; + clone(): Plane; } /** @@ -3207,11 +3190,16 @@ declare module THREE { * Sets this quaternion from rotation component of m. Adapted from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm. */ setFromRotationMatrix(m: Matrix4): Quaternion; - + setFromUnitVectors(vFrom: Vector3, vTo: Vector4): Quaternion; /** * Inverts this quaternion. */ inverse(): Quaternion; + + conjugate(): Quaternion; + dot(v: Vector3): number; + lengthSq(): number; + /** * Computes length of this quaternion. */ @@ -3237,6 +3225,11 @@ declare module THREE { * Deprecated. Use Vector3.applyQuaternion instead */ multiplyVector3(vector: Vector3): Vector3; + slerp(qb: Quaternion, t: number): Quaternion; + equals(v: Quaternion): boolean; + fromArray(n: number[]): Quaternion; + toArray(): number[]; + onChange: () => void; /** * Clones this quaternion. @@ -3247,20 +3240,6 @@ declare module THREE { * Adapted from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/. */ static slerp(qa: Quaternion, qb: Quaternion, qm: Quaternion, t: number): Quaternion; - - slerp(qb: Quaternion, t: number): Quaternion; - - toArray(): number[]; - - equals(v: Quaternion): boolean; - - dot(v: Vector3): number; - - lengthSq(): number; - - fromArray(n: number[]): Quaternion; - - conjugate(): Quaternion; } export class Ray { @@ -3269,25 +3248,24 @@ declare module THREE { origin: Vector3; direction: Vector3; - applyMatrix4(matrix4: Matrix4): Ray; - at(t: number, optionalTarget?: Vector3): Vector3; - clone(): Ray; - closestPointToPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - copy(ray: Ray): Ray; - distanceSqToSegment(v0: Vector3, v1: Vector3, optionalPointOnRay?: Vector3, optionalPointOnSegment?: Vector3): number; - distanceToPlane(plane: Plane): number; - distanceToPoint(point: Vector3): number; - equals(ray: Ray): boolean; - intersectBox(box: Box3, optionalTarget?: Vector3): Vector3; - intersectPlane(plane: Plane, optionalTarget?: Vector3): Vector3; - intersectSphere(sphere: Sphere, optionalTarget?: Vector3): Vector3; - intersectTriangle(a: Vector3, b: Vector3, c: Vector3, backfaceCulling: boolean, optionalTarget?: Vector3): Vector3; - isIntersectionBox(box: Box3): boolean; - isIntersectionPlane(plane: Plane): boolean; - isIntersectionSphere(sphere: Sphere): boolean; - - recast(t: number): Ray; set(origin: Vector3, direction: Vector3): Ray; + copy(ray: Ray): Ray; + at(t: number, optionalTarget?: Vector3): Vector3; + recast(t: number): Ray; + closestPointToPoint(point: Vector3, optionalTarget?: Vector3): Vector3; + distanceToPoint(point: Vector3): number; + distanceSqToSegment(v0: Vector3, v1: Vector3, optionalPointOnRay?: Vector3, optionalPointOnSegment?: Vector3): number; + isIntersectionSphere(sphere: Sphere): boolean; + intersectSphere(sphere: Sphere, optionalTarget?: Vector3): Vector3; + isIntersectionPlane(plane: Plane): boolean; + distanceToPlane(plane: Plane): number; + intersectPlane(plane: Plane, optionalTarget?: Vector3): Vector3; + isIntersectionBox(box: Box3): boolean; + intersectBox(box: Box3, optionalTarget?: Vector3): Vector3; + intersectTriangle(a: Vector3, b: Vector3, c: Vector3, backfaceCulling: boolean, optionalTarget?: Vector3): Vector3; + applyMatrix4(matrix4: Matrix4): Ray; + equals(ray: Ray): boolean; + clone(): Ray; } export class Sphere { @@ -3297,18 +3275,19 @@ declare module THREE { radius: number; set(center: Vector3, radius: number): Sphere; - applyMatrix4(matrix: Matrix4): Sphere; - clampPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - translate(offset: Vector3): Sphere; - clone(): Sphere; - equals(sphere: Sphere): boolean; setFromPoints(points: Vector3[], optionalCenter?: Vector3): Sphere; - distanceToPoint(point: Vector3): number; - getBoundingBox(optionalTarget?: Box3): Box3; - containsPoint(point: Vector3): boolean; copy(sphere: Sphere): Sphere; - intersectsSphere(sphere: Sphere): boolean; empty(): boolean; + containsPoint(point: Vector3): boolean; + distanceToPoint(point: Vector3): number; + intersectsSphere(sphere: Sphere): boolean; + clampPoint(point: Vector3, optionalTarget?: Vector3): Vector3; + getBoundingBox(optionalTarget?: Box3): Box3; + applyMatrix4(matrix: Matrix4): Sphere; + translate(offset: Vector3): Sphere; + equals(sphere: Sphere): boolean; + + clone(): Sphere; } export interface SplineControlPoint { @@ -3371,17 +3350,17 @@ declare module THREE { b: Vector3; c: Vector3; - setFromPointsAndIndices(points: Vector3[], i0: number, i1: number, i2: number): Triangle; set(a: Vector3, b: Vector3, c: Vector3): Triangle; - normal(optionalTarget?: Vector3): Vector3; - barycoordFromPoint(point: Vector3, optionalTarget?: Vector3): Vector3; - clone(): Triangle; + setFromPointsAndIndices(points: Vector3[], i0: number, i1: number, i2: number): Triangle; + copy(triangle: Triangle): Triangle; area(): number; midpoint(optionalTarget?: Vector3): Vector3; - equals(triangle: Triangle): boolean; + normal(optionalTarget?: Vector3): Vector3; plane(optionalTarget?: Vector3): Plane; + barycoordFromPoint(point: Vector3, optionalTarget?: Vector3): Vector3; containsPoint(point: Vector3): boolean; - copy(triangle: Triangle): Triangle; + equals(triangle: Triangle): boolean; + clone(): Triangle; static normal(a: Vector3, b: Vector3, c: Vector3, optionalTarget?: Vector3): Vector3; static barycoordFromPoint(point: Vector3, a: Vector3, b: Vector3, c: Vector3, optionalTarget: Vector3): Vector3; @@ -3516,6 +3495,26 @@ declare module THREE { */ set(x: number, y: number): Vector2; + /** + * Sets X component of this vector. + */ + setX(x: number): Vector2; + + /** + * Sets Y component of this vector. + */ + setY(y: number): Vector2; + + /** + * Sets a component of this vector. + */ + setComponent(index: number, value: number): void; + + /** + * Gets a component of this vector. + */ + getComponent(index: number): number; + /** * Copies value of v to this vector. */ @@ -3530,6 +3529,7 @@ declare module THREE { * Sets this vector to a + b. */ addVectors(a: Vector2, b: Vector2): Vector2; + addScalar(s: number): Vector2; /** * Subtracts v from this vector. @@ -3541,24 +3541,34 @@ declare module THREE { */ subVectors(a: Vector2, b: Vector2): Vector2; + multiply(v: Vector2): Vector2; /** * Multiplies this vector by scalar s. */ multiplyScalar(s: number): Vector2; + divide(v: Vector2): Vector2; /** * Divides this vector by scalar s. * Set vector to ( 0, 0 ) if s == 0. */ divideScalar(s: number): Vector2; + min(v: Vector2): Vector2; + + max(v: Vector2): Vector2; + clamp(min: Vector2, max: Vector2): Vector2; + clampScalar(min: number, max: number): Vector2; + floor(): Vector2; + ceil(): Vector2; + round(): Vector2; + roundToZero(): Vector2; + /** * Inverts this vector. */ negate(): Vector2; - - /** * Computes dot product of this vector and v. */ @@ -3594,53 +3604,18 @@ declare module THREE { */ setLength(l: number): Vector2; + lerp(v: Vector2, alpha: number): Vector2; /** * Checks for strict equality of this vector and v. */ equals(v: Vector2): boolean; + fromArray(xy: number[]): Vector2; + toArray(): number[]; /** * Clones this vector. */ clone(): Vector2; - - clamp(min: Vector2, max: Vector2): Vector2; - clampScalar(min: number, max: number): Vector2; - floor(): Vector2; - ceil(): Vector2; - round(): Vector2; - roundToZero(): Vector2; - lerp(v: Vector2, alpha: number): Vector2; - - /** - * Sets a component of this vector. - */ - setComponent(index: number, value: number): void; - - addScalar(s: number): Vector2; - - /** - * Gets a component of this vector. - */ - getComponent(index: number): number; - - fromArray(xy: number[]): Vector2; - - toArray(): number[]; - - min(v: Vector2): Vector2; - - max(v: Vector2): Vector2; - - /** - * Sets X component of this vector. - */ - setX(x: number): Vector2; - - /** - * Sets Y component of this vector. - */ - setY(y: number): Vector2; } /** @@ -3684,6 +3659,9 @@ declare module THREE { */ setZ(z: number): Vector3; + setComponent(index: number, value: number): void; + getComponent(index: number): number; + /** * Copies value of v to this vector. */ @@ -3693,6 +3671,7 @@ declare module THREE { * Adds v to this vector. */ add(a: Object): Vector3; + addScalar(s: number): Vector3; /** * Sets this vector to a + b. @@ -3709,16 +3688,34 @@ declare module THREE { */ subVectors(a: Vector3, b: Vector3): Vector3; + multiply(v: Vector3): Vector3; /** * Multiplies this vector by scalar s. */ multiplyScalar(s: number): Vector3; + multiplyVectors(a: Vector3, b: Vector3): Vector3; + applyEuler(euler: Euler): Vector3; + applyAxisAngle(axis: Vector3, angle: number): Vector3; + applyMatrix3(m: Matrix3): Vector3; + applyMatrix4(m: Matrix4): Vector3; + applyProjection(m: Matrix4): Vector3; + applyQuaternion(q: Quaternion): Vector3; + transformDirection(m: Matrix4): Vector3; + divide(v: Vector3): Vector3; /** * Divides this vector by scalar s. * Set vector to ( 0, 0, 0 ) if s == 0. */ divideScalar(s: number): Vector3; + min(v: Vector3): Vector3; + max(v: Vector3): Vector3; + clamp(min: Vector3, max: Vector3): Vector3; + clampScalar(min: number, max: number): Vector3; + floor(): Vector3; + ceil(): Vector3; + round(): Vector3; + roundToZero(): Vector3; /** * Inverts this vector. @@ -3751,20 +3748,11 @@ declare module THREE { */ normalize(): Vector3; - /** - * Computes distance of this vector to v. - */ - distanceTo(v: Vector3): number; - - /** - * Computes squared distance of this vector to v. - */ - distanceToSquared(v: Vector3): number; - /** * Normalizes this vector and multiplies it by l. */ setLength(l: number): Vector3; + lerp(v: Vector3, alpha: number): Vector3; /** * Sets this vector to cross product of itself and v. @@ -3775,46 +3763,36 @@ declare module THREE { * Sets this vector to cross product of a and b. */ crossVectors(a: Vector3, b: Vector3): Vector3; + projectOnVector(v: Vector3): Vector3; + projectOnPlane(planeNormal: Vector3): Vector3; + reflect(vector: Vector3): Vector3; + angleTo(v: Vector3): number; + + /** + * Computes distance of this vector to v. + */ + distanceTo(v: Vector3): number; + + /** + * Computes squared distance of this vector to v. + */ + distanceToSquared(v: Vector3): number; setFromMatrixPosition(m: Matrix4): Vector3; setFromMatrixScale(m: Matrix4): Vector3; + setFromMatrixColumn(index: number, matrix: Matrix4): Vector3; + /** * Checks for strict equality of this vector and v. */ equals(v: Vector3): boolean; + fromArray(xyz: number[]): Vector3; + toArray(): number[]; + /** * Clones this vector. */ clone(): Vector3; - clamp(min: Vector3, max: Vector3): Vector3; - clampScalar(min: number, max: number): Vector3; - floor(): Vector3; - ceil(): Vector3; - round(): Vector3; - roundToZero(): Vector3; - applyMatrix3(m: Matrix3): Vector3; - applyMatrix4(m: Matrix4): Vector3; - projectOnPlane(planeNormal: Vector3): Vector3; - projectOnVector(v: Vector3): Vector3; - addScalar(s: number): Vector3; - divide(v: Vector3): Vector3; - min(v: Vector3): Vector3; - max(v: Vector3): Vector3; - setComponent(index: number, value: number): void; - transformDirection(m: Matrix4): Vector3; - multiplyVectors(a: Vector3, b: Vector3): Vector3; - getComponent(index: number): number; - applyAxisAngle(axis: Vector3, angle: number): Vector3; - lerp(v: Vector3, alpha: number): Vector3; - angleTo(v: Vector3): number; - setFromMatrixColumn(index: number, matrix: Matrix4): Vector3; - reflect(vector: Vector3): Vector3; - fromArray(xyz: number[]): Vector3; - multiply(v: Vector3): Vector3; - applyProjection(m: Matrix4): Vector3; - toArray(): number[]; - applyEuler(euler: Euler): Vector3; - applyQuaternion(q: Quaternion): Vector3; } /** @@ -3833,6 +3811,30 @@ declare module THREE { * Sets value of this vector. */ set(x: number, y: number, z: number, w: number): Vector4; + + /** + * Sets X component of this vector. + */ + setX(x: number): Vector4; + + /** + * Sets Y component of this vector. + */ + setY(y: number): Vector4; + + /** + * Sets Z component of this vector. + */ + setZ(z: number): Vector4; + + /** + * Sets w component of this vector. + */ + setW(w: number): Vector4; + + setComponent(index: number, value: number): void; + getComponent(index: number): number; + /** * Copies value of v to this vector. */ @@ -3842,6 +3844,7 @@ declare module THREE { * Adds v to this vector. */ add(v: Vector4): Vector4; + addScalar(s: number): Vector4; /** * Sets this vector to a + b. @@ -3862,12 +3865,35 @@ declare module THREE { * Multiplies this vector by scalar s. */ multiplyScalar(s: number): Vector4; + applyMatrix4(m: Matrix4): Vector4; /** * Divides this vector by scalar s. * Set vector to ( 0, 0, 0 ) if s == 0. */ divideScalar(s: number): Vector4; + + /** + * http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm + * @param q is assumed to be normalized + */ + setAxisAngleFromQuaternion(q: Quaternion): Vector4; + + /** + * http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm + * @param m assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) + */ + setAxisAngleFromRotationMatrix(m: Matrix3): Vector4; + + min(v: Vector4): Vector4; + max(v: Vector4): Vector4; + clamp(min: Vector4, max: Vector4): Vector4; + clampScalar(min: number, max: number): Vector4; + floor(): Vector4; + ceil(): Vector4; + round(): Vector4; + roundToZero(): Vector4; + /** * Inverts this vector. */ @@ -3887,6 +3913,7 @@ declare module THREE { * Computes length of this vector. */ length(): number; + lengthManhattan(): number; /** * Normalizes this vector. @@ -3901,62 +3928,19 @@ declare module THREE { * Linearly interpolate between this vector and v with alpha factor. */ lerp(v: Vector4, alpha: number): Vector4; - /** - * Clones this vector. - */ - clone(): Vector4; - clamp(min: Vector4, max: Vector4): Vector4; - clampScalar(min: number, max: number): Vector4; - floor(): Vector4; - ceil(): Vector4; - round(): Vector4; - roundToZero(): Vector4; - applyMatrix4(m: Matrix4): Vector4; - min(v: Vector4): Vector4; - max(v: Vector4): Vector4; - addScalar(s: number): Vector4; /** * Checks for strict equality of this vector and v. */ equals(v: Vector4): boolean; - /** - * http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm - * @param m assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled) - */ - setAxisAngleFromRotationMatrix(m: Matrix3): Vector4; - - /** - * http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm - * @param q is assumed to be normalized - */ - setAxisAngleFromQuaternion(q: Quaternion): Vector4; - - getComponent(index: number): number; - setComponent(index: number, value: number): void; fromArray(xyzw: number[]): number[]; toArray(): number[]; - lengthManhattan(): number; - /** - * Sets X component of this vector. - */ - setX(x: number): Vector4; /** - * Sets Y component of this vector. + * Clones this vector. */ - setY(y: number): Vector4; - - /** - * Sets Z component of this vector. - */ - setZ(z: number): Vector4; - - /** - * Sets w component of this vector. - */ - setW(w: number): Vector4; + clone(): Vector4; } // Objects ////////////////////////////////////////////////////////////////////////////////// @@ -3970,7 +3954,7 @@ declare module THREE { accumulatedPosWeight: number; accumulatedSclWeight: number; - update(forceUpdate?: boolean): void; + updateMatrixWorld(forceUpdate?: boolean): void; } export class Line extends Object3D { @@ -3980,6 +3964,7 @@ declare module THREE { constructor(geometry?: BufferGeometry, material?: LineDashedMaterial, type?: number); constructor(geometry?: BufferGeometry, material?: LineBasicMaterial, type?: number); constructor(geometry?: BufferGeometry, material?: ShaderMaterial, type?: number); + geometry: Geometry; material: LineBasicMaterial; type: LineType; @@ -3996,11 +3981,12 @@ declare module THREE { constructor(); objects: any[]; + addLevel(object: Object3D, distance?: number): void; getObjectForDistance(distance: number): Object3D; raycast(raycaster: Raycaster, intersects: any): void; update(camera: Camera): void; - clone(): LOD; + clone(object?: LOD): LOD; } export class Mesh extends Object3D { @@ -4010,8 +3996,8 @@ declare module THREE { geometry: Geometry; material: Material; - getMorphTargetIndexByName(name: string): number; updateMorphTargets(): void; + getMorphTargetIndexByName(name: string): number; raycast(raycaster: Raycaster, intersects: any): void; clone(object?: Mesh): Mesh; } @@ -4025,24 +4011,25 @@ declare module THREE { constructor(geometry?: Geometry, material?: MeshPhongMaterial); constructor(geometry?: Geometry, material?: ShaderMaterial); - directionBackwards: boolean; - direction: number; - endKeyframe: number; - mirroredLoop: boolean; - startKeyframe: number; - lastKeyframe: number; - length: number; - time: number; duration: number; // milliseconds + mirroredLoop: boolean; + time: number; + lastKeyframe: number; currentKeyframe: number; + direction: number; + directionBackwards: boolean; + + startKeyframe: number; + endKeyframe: number; + length: number; - setDirectionForward(): void; - playAnimation(label: string, fps: number): void; setFrameRange(start: number, end: number): void; + setDirectionForward(): void; setDirectionBackward(): void; parseAnimations(): void; - updateAnimation(delta: number): void; setAnimationLabel(label: string, start: number, end: number): void; + playAnimation(label: string, fps: number): void; + updateAnimation(delta: number): void; interpolateTargets( a: number, b: number, t: number ): void; clone(object?: MorphAnimMesh): MorphAnimMesh; } @@ -4072,7 +4059,6 @@ declare module THREE { * An instance of Material, defining the object's appearance. Default is a ParticleBasicMaterial with randomised colour. */ material: Material; - sortParticles: boolean; raycast(raycaster: Raycaster, intersects: any): void; @@ -4081,9 +4067,15 @@ declare module THREE { export class Skeleton { constructor(bones: Bone[], boneInverses?: Matrix4[], useVertexTexture?: boolean); - bones: Bone[]; + useVertexTexture: boolean; + identityMatrix: Matrix4; + bones: Bone[]; + boneTextureWidth: number; + boneTextureHeight: number; boneMatrices: Float32Array; + boneTexture: DataTexture; + boneInverses: Matrix4[]; calculateInverses(bone: Bone): void; pose(): void; @@ -4126,8 +4118,8 @@ declare module THREE { export interface Renderer { render(scene: Scene, camera: Camera): void; - setSize(width:number, height:number, updateStyle?:boolean): void; - domElement: HTMLCanvasElement; + setSize(width:number, height:number, updateStyle?:boolean): void; + domElement: HTMLCanvasElement; } export interface CanvasRendererParameters { @@ -4138,26 +4130,31 @@ declare module THREE { export class CanvasRenderer implements Renderer { constructor(parameters?: CanvasRendererParameters); - info: { render: { vertices: number; faces: number; }; }; domElement: HTMLCanvasElement; devicePixelRatio: number; autoClear: boolean; sortObjects: boolean; sortElements: boolean; + info: { render: { vertices: number; faces: number; }; }; - getMaxAnisotropy(): number; - render(scene: Scene, camera: Camera): void; - clear(): void; + supportsVertexTextures(): void; + setFaceCulling(): 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; - setFaceCulling(): void; - supportsVertexTextures(): void; - setSize(width: number, height: number, updateStyle?: boolean): void; setClearColorHex(hex: number, alpha?: number): void; getClearColor(): Color; getClearAlpha(): number; - setViewport(x: number, y: number, width: number, height: number): void; + getMaxAnisotropy(): number; + clear(): void; + clearColor(): void; + clearDepth(): void; + clearStencil(): void; + render(scene: Scene, camera: Camera): void; } export interface RendererPlugin { @@ -4240,6 +4237,8 @@ declare module THREE { //context:WebGLRenderingContext; context: any; + devicePixelRatio: number; + /** * Defines whether the renderer should automatically clear its output before rendering. */ @@ -4351,7 +4350,6 @@ declare module THREE { }; shadowMapPlugin: ShadowMapPlugin; - devicePixelRatio: number; /** * Return the WebGL context. @@ -4365,6 +4363,8 @@ declare module THREE { supportsFloatTextures(): boolean; supportsStandardDerivatives(): boolean; supportsCompressedTextureS3TC(): boolean; + getMaxAnisotropy(): number; + getPrecision(): string; /** * Resizes the output canvas to (width, height), and also sets the viewport to fit that size, starting in (0, 0). @@ -4393,6 +4393,17 @@ declare module THREE { setClearColor(color: string, alpha?: number): void; setClearColor(color: number, alpha?: number): void; + /** + * Sets the clear color, using hex for the color and alpha for the opacity. + * + * @example + * // Creates a renderer with black background + * var renderer = new THREE.WebGLRenderer(); + * renderer.setSize(200, 100); + * renderer.setClearColorHex(0x000000, 1); + */ + setClearColorHex(hex: number, alpha: number): void; + /** * Returns a THREE.Color instance with the current clear color. */ @@ -4412,6 +4423,7 @@ declare module THREE { clearColor(): void; clearDepth(): void; clearStencil(): void; + clearTarget(renderTarget:WebGLRenderTarget, color: boolean, depth: boolean, stencil: boolean): void; /** * Initialises the postprocessing plugin, and adds it to the renderPluginsPost array. @@ -4453,26 +4465,12 @@ declare module THREE { * @param frontFace "ccw" or "cw */ setFaceCulling(cullFace?: CullFace, frontFace?: FrontFaceDirection): void; + setMaterialFaces(material: Material): void; setDepthTest(depthTest: boolean): void; setDepthWrite(depthWrite: boolean): void; setBlending(blending: Blending, blendEquation: BlendingEquation, blendSrc: BlendingSrcFactor, blendDst: BlendingDstFactor): void; setTexture(texture: Texture, slot: number): void; setRenderTarget(renderTarget: RenderTarget): void; - getMaxAnisotropy(): number; - getPrecision(): string; - setMaterialFaces(material: Material): void; - clearTarget(renderTarget:WebGLRenderTarget, color: boolean, depth: boolean, stencil: boolean): void; - - /** - * Sets the clear color, using hex for the color and alpha for the opacity. - * - * @example - * // Creates a renderer with black background - * var renderer = new THREE.WebGLRenderer(); - * renderer.setSize(200, 100); - * renderer.setClearColorHex(0x000000, 1); - */ - setClearColorHex(hex: number, alpha: number): void; } export interface RenderTarget { @@ -4492,6 +4490,7 @@ declare module THREE { export class WebGLRenderTarget implements RenderTarget { constructor(width: number, height: number, options?: WebGLRenderTargetOptions); + width: number; height: number; wrapS: Wrapping; @@ -4506,6 +4505,8 @@ declare module THREE { depthBuffer: boolean; stencilBuffer: boolean; generateMipmaps: boolean; + shareDepthFrom: any; + clone(): WebGLRenderTarget; dispose(): void; @@ -4519,134 +4520,132 @@ declare module THREE { export class WebGLRenderTargetCube extends WebGLRenderTarget { constructor(width: number, height: number, options?: WebGLRenderTargetOptions); + activeCubeFace: number; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5 } // Renderers / Renderables ///////////////////////////////////////////////////////////////////// - export class RenderableFace { constructor(); - color: Color; - material: Material; - uvs: Vector2[][]; + id: number; v1: RenderableVertex; v2: RenderableVertex; v3: RenderableVertex; normalModel: Vector3; - vertexNormalsLength: number; - z: number; vertexNormalsModel: Vector3[]; + vertexNormalsLength: number; + color: Color; + material: Material; + uvs: Vector2[][]; + z: number; + } export class RenderableLine { constructor(); + id: number; v1: RenderableVertex; v2: RenderableVertex; - z: number; + vertexColors: Color[]; material: Material; + z: number; } export class RenderableObject { constructor(); + id: number; object: Object; z: number; - id: number; } export class RenderableSprite { constructor(); + id: number; + object: Object; + x: number; + y: number; + z: number; + rotation: number; scale: Vector2; material: Material; - object: Object; - y: number; - x: number; - rotation: number; - z: number; } export class RenderableVertex { constructor(); - visible: boolean; - positionScreen: Vector4; + position: Vector3; positionWorld: Vector3; + positionScreen: Vector4; + visible: boolean; copy(vertex: RenderableVertex): void; } - // Renderers / Shaders ///////////////////////////////////////////////////////////////////// // Renderers / Shaders ///////////////////////////////////////////////////////////////////// export interface ShaderChunk { [name: string]: string; - fog_pars_fragment: string; - fog_fragment: string; - envmap_pars_fragment: string; - envmap_fragment: string; - envmap_pars_vertex: string; - worldpos_vertex: string; - envmap_vertex: string; - map_particle_pars_fragment: string; - map_particle_fragment: string; - map_pars_vertex: string; - map_pars_fragment: string; - map_vertex: string; - map_fragment: string; - lightmap_pars_fragment: string; - lightmap_pars_vertex: string; - lightmap_fragment: string; - lightmap_vertex: string; + + alphamap_fragment: string; + alphamap_pars_fragment: string; + alphatest_fragment: string; bumpmap_pars_fragment: string; - normalmap_pars_fragment: string; - specularmap_pars_fragment: string; - specularmap_fragment: string; - lights_lambert_pars_vertex: string; - lights_lambert_vertex: string; - lights_phong_pars_vertex: string; - lights_phong_vertex: string; - lights_phong_pars_fragment: string; - lights_phong_fragment: string; - color_pars_fragment: string; color_fragment: string; + color_pars_fragment: string; color_pars_vertex: string; color_vertex: string; - skinning_pars_vertex: string; - skinbase_vertex: string; - skinning_vertex: string; + default_vertex: string; + defaultnormal_vertex: string; + envmap_fragment: string; + envmap_pars_fragment: string; + envmap_pars_vertex: string; + envmap_vertex: string; + fog_fragment: string; + fog_pars_fragment: string; + + lightmap_fragment: string; + lightmap_pars_fragment: string; + lightmap_pars_vertex: string; + lightmap_vertex: string; + lights_lambert_pars_vertex: string; + lights_lambert_vertex: string; + lights_phong_fragment: string; + lights_phong_pars_fragment: string; + lights_phong_pars_vertex: string; + lights_phong_vertex: string; + linear_to_gamma_fragment: string; + logdepthbuf_fragment: string; + logdepthbuf_pars_fragment: string; + logdepthbuf_pars_vertex: string; + logdepthbuf_vertex: string; + map_fragment: string; + map_pars_fragment: string; + map_pars_vertex: string; + map_particle_fragment: string; + map_particle_pars_fragment: string; + map_vertex: string; + morphnormal_vertex: string; morphtarget_pars_vertex: string; morphtarget_vertex: string; - default_vertex: string; - morphnormal_vertex: string; - skinnormal_vertex: string; - defaultnormal_vertex: string; - shadowmap_pars_fragment: string; + normalmap_pars_fragment: string; shadowmap_fragment: string; + shadowmap_pars_fragment: string; shadowmap_pars_vertex: string; shadowmap_vertex: string; - alphatest_fragment: string; - linear_to_gamma_fragment: string; + skinbase_vertex: string; + skinning_pars_vertex: string; + skinning_vertex: string; + skinnormal_vertex: string; + specularmap_fragment: string; + specularmap_pars_fragment: string; + worldpos_vertex: string; } export var ShaderChunk: ShaderChunk; - export var UniformsUtils: { - merge(uniforms: any[]): any; - clone(uniforms_src: any): any; - }; - - export var UniformsLib: { - common: any; - bump: any; - normalmap: any; - fog: any; - lights: any; - particle: any; - shadowmap: any; - }; - export interface Shader { uniforms: any; vertexShader: string; @@ -4659,15 +4658,28 @@ declare module THREE { lambert: Shader; phong: Shader; particle_basic: Shader; - depth: Shader; dashed: Shader; + depth: Shader; normal: Shader; normalmap: Shader; cube: Shader; depthRGBA: Shader; }; + export var UniformsLib: { + common: any; + bump: any; + normalmap: any; + fog: any; + lights: any; + particle: any; + shadowmap: any; + }; + export var UniformsUtils: { + merge(uniforms: any[]): any; + clone(uniforms_src: any): any; + }; // Renderers / WebGL ///////////////////////////////////////////////////////////////////// export class WebGLProgram{ @@ -4719,6 +4731,7 @@ declare module THREE { */ export class FogExp2 implements IFog { constructor(hex: number, density?: number); + name: string; color: Color; @@ -4746,13 +4759,12 @@ declare module THREE { * If not null, it will force everything in the scene to be rendered with that material. Default is null. */ overrideMaterial: Material; + autoUpdate: boolean; /** * Default is false. */ matrixAutoUpdate: boolean; - - autoUpdate: boolean; } // Textures ///////////////////////////////////////////////////////////////////// @@ -4769,7 +4781,11 @@ declare module THREE { magFilter?: TextureFilter, minFilter?: TextureFilter, anisotropy?: number - ); + ); + + image: { width: number; height: number; }; + mipmaps: ImageData[]; + generateMipmaps: boolean; clone(): CompressedTexture; } @@ -4785,7 +4801,7 @@ declare module THREE { format?: PixelFormat, type?: TextureDataType, anisotropy?: number - ); + ); images: any[]; @@ -4805,7 +4821,9 @@ declare module THREE { magFilter: TextureFilter, minFilter: TextureFilter, anisotropy?: number - ); + ); + + image: { data: ImageData; width: number; height: number; }; clone(): DataTexture; } @@ -4856,33 +4874,33 @@ declare module THREE { anisotropy?: number ); + id: number; + uuid: string; + name: string; image: any; // HTMLImageElement or ImageData ; + mipmaps: ImageData[]; mapping: Mapping; wrapS: Wrapping; wrapT: Wrapping; magFilter: TextureFilter; minFilter: TextureFilter; + anisotropy: number; format: PixelFormat; type: TextureDataType; - anisotropy: number; - needsUpdate: boolean; - repeat: Vector2; offset: Vector2; - name: string; + repeat: Vector2; generateMipmaps: boolean; - flipY: boolean; - mipmaps: ImageData[]; - unpackAlignment: number; premultiplyAlpha: boolean; + flipY: boolean; + unpackAlignment: number; + needsUpdate: boolean; onUpdate: () => void; - id: number; - - clone(): Texture; - dispose(): void; - static DEFAULT_IMAGE: any; static DEFAULT_MAPPING: any; + clone(): Texture; + update(): void; + dispose(): void; // EventDispatcher mixins addEventListener(type: string, listener: (event: any) => void ): void; @@ -4900,23 +4918,23 @@ declare module THREE { } export var FontUtils: { - - divisions: number; - style: string; - weight: string; - face: string; faces: { [weight: string]: { [style: string]: Face3; }; }; + face: string; + weight: string; + style: string; size: number; + divisions: number; + getFace(): Face3; + loadFace(data: TypefaceData): TypefaceData; drawText(text: string): { paths: Path[]; offset: number; }; + extractGlyphPoints(c: string, face: Face3, scale: number, offset: number, path: Path): { offset: number; path: Path; }; + + generateShapes(text: string, parameters?: { size?: number; curveSegments?: number; font?: string; weight?: string; style?: string; }): Shape[]; Triangulate: { (contour: Vector2[], indices: boolean): Vector2[]; area(contour: Vector2[]): number; }; - extractGlyphPoints(c: string, face: Face3, scale: number, offset: number, path: Path): { offset: number; path: Path; }; - generateShapes(text: string, parameters?: { size?: number; curveSegments?: number; font?: string; weight?: string; style?: string; }): Shape[]; - loadFace(data: TypefaceData): TypefaceData; - getFace(): Face3; }; export var GeometryUtils: { @@ -4933,16 +4951,16 @@ declare module THREE { export var ImageUtils: { crossOrigin: string; - generateDataTexture(width: number, height: number, color: Color): DataTexture; loadTexture(url: string, mapping?: Mapping, onLoad?: (texture: Texture) => void, onError?: (message: string) => void): Texture; - loadTextureCube(array: string[], mapping?: Mapping, onLoad?: () => void , onError?: (message: string) => void ): Texture; + loadTextureCube(array: string[], mapping?: Mapping, onLoad?: (texture: Texture) => void , onError?: (message: string) => void ): Texture; getNormalMap(image: HTMLImageElement, depth?: number): HTMLCanvasElement; + generateDataTexture(width: number, height: number, color: Color): DataTexture; }; export var SceneUtils: { createMultiMaterialObject(geometry: Geometry, materials: Material[]): Object3D; - attach(child: Object3D, scene: Scene, parent: Object3D): void; detach(child: Object3D, parent: Object3D, scene: Scene): void; + attach(child: Object3D, scene: Scene, parent: Object3D): void; }; // Extras / Animation ///////////////////////////////////////////////////////////////////// @@ -4979,6 +4997,7 @@ declare module THREE { loop: boolean; weight: number; keyTypes: string[]; + interpolationType: number; play(startTime?: number, weight?: number): void; stop(): void; @@ -5002,21 +5021,6 @@ declare module THREE { update(deltaTimeMS: number): void; }; - export class MorphAnimation { - constructor(mesh: Mesh); - - mesh: Mesh; - frames: number; - currentTime: number; - duration: number; - loop: boolean; - isPlaying: boolean; - - play(): void; - pause(): void; - update(deltaTimeMS: number): void; - } - export class KeyFrameAnimation { constructor(data: any); @@ -5036,102 +5040,20 @@ declare module THREE { getPrevKeyWith(type: string, h: number, key: number): KeyFrame; } - // Extras / Curves ///////////////////////////////////////////////////////////////////// - export class ArcCurve extends EllipseCurve { - constructor(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean ); + export class MorphAnimation { + constructor(mesh: Mesh); + + mesh: Mesh; + frames: number; + currentTime: number; + duration: number; + loop: boolean; + isPlaying: boolean; + + play(): void; + pause(): void; + update(deltaTimeMS: number): void; } - export class ClosedSplineCurve3 extends Curve { - constructor( points:Vector3[] ); - - points:Vector3[]; - - getPoint(t: number): Vector3; - } - export class CubicBezierCurve extends Curve { - constructor( v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2 ); - - v0: Vector2; - v1: Vector2; - v2: Vector2; - v3: Vector2; - - getPoint(t: number): Vector2; - } - export class CubicBezierCurve3 extends Curve { - constructor( v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3 ); - - v0: Vector3; - v1: Vector3; - v2: Vector3; - v3: Vector3; - - getPoint(t: number): Vector3; - } - export class EllipseCurve extends Curve { - constructor( aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean ); - - aX: number; - aY: number; - xRadius: number; - yRadius: number; - aStartAngle: number; - aEndAngle: number; - aClockwise: boolean; - - getPoint(t: number): Vector2; - } - export class LineCurve extends Curve { - constructor( v1: Vector2, v2: Vector2 ); - - v1: Vector2; - v2: Vector2; - - getPoint(t: number): Vector2; - getPointAt(u: number): Vector2; - getTangent(t: number): Vector2; - } - export class LineCurve3 extends Curve { - constructor( v1: Vector3, v2: Vector3 ); - - v1: Vector3; - v2: Vector3; - - getPoint(t: number): Vector3; - } - export class QuadraticBezierCurve extends Curve { - constructor( v0: Vector2, v1: Vector2, v2: Vector2 ); - - v0: Vector2; - v1: Vector2; - v2: Vector2; - - getPoint(t: number): Vector2; - getTangent(t: number): Vector2; - } - export class QuadraticBezierCurve3 extends Curve { - constructor( v0: Vector3, v1: Vector3, v2: Vector3 ); - - v0: Vector3; - v1: Vector3; - v2: Vector3; - - getPoint(t: number): Vector3; - } - export class SplineCurve extends Curve { - constructor( points: Vector2[] ); - - points:Vector2[]; - - getPoint(t: number): Vector2; - } - export class SplineCurve3 extends Curve { - constructor( points: Vector3[] ); - - points:Vector3[]; - - getPoint(t: number): Vector3; - } - // Extras / Core ///////////////////////////////////////////////////////////////////// @@ -5140,8 +5062,6 @@ declare module THREE { * class Curve<T extends Vector> */ export class Curve { - needsUpdate: boolean; - /** * Returns a vector for point t of the curve where t is between 0 and 1 * getPoint(t: number): T; @@ -5223,29 +5143,31 @@ declare module THREE { bends: Path[]; autoClose: boolean; - getWrapPoints(oldPts: Vector2[], path: Path): Vector2[]; - createPointsGeometry(divisions: number): Geometry; - addWrapPath(bendpath: Path): void; - createGeometry(points: Vector2[]): Geometry; add(curve: Curve): void; - getTransformedSpacedPoints(segments: number, bends?: Path[]): Vector2[]; - createSpacedPointsGeometry(divisions: number): Geometry; - closePath(): void; - getBoundingBox(): BoundingBox; - getCurveLengths(): number; - getTransformedPoints(segments: number, bends?: Path): Vector2[]; checkConnection(): boolean; + closePath(): void; + getPoint(t: number): Vector; + getLength(): number; + getCurveLengths(): number; + getBoundingBox(): BoundingBox; + createPointsGeometry(divisions: number): Geometry; + createSpacedPointsGeometry(divisions: number): Geometry; + createGeometry(points: Vector2[]): Geometry; + addWrapPath(bendpath: Path): void; + getTransformedPoints(segments: number, bends?: Path): Vector2[]; + getTransformedSpacedPoints(segments: number, bends?: Path[]): Vector2[]; + getWrapPoints(oldPts: Vector2[], path: Path): Vector2[]; } export class Gyroscope extends Object3D { constructor(); - scaleWorld: Vector3; translationWorld: Vector3; - quaternionWorld: Quaternion; translationObject: Vector3; - scaleObject: Vector3; + quaternionWorld: Quaternion; quaternionObject: Quaternion; + scaleWorld: Vector3; + scaleObject: Vector3; updateMatrixWorld(force?: boolean): void; } @@ -5283,6 +5205,8 @@ declare module THREE { absarc(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; ellipse(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; absellipse(aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean): void; + getSpacedPoints(divisions?: number, closedPath?: boolean): Vector[]; + getPoints(divisions?: number, closedPath?: boolean): Vector[]; toShapes(): Shape[]; } @@ -5294,22 +5218,120 @@ declare module THREE { holes: Path[]; + extrude(options?: any): ExtrudeGeometry; makeGeometry(options?: any): ShapeGeometry; + getPointsHoles(divisions: number): Vector2[][]; + getSpacedPointsHoles(divisions: number): Vector2[][]; extractAllPoints(divisions: number): { shape: Vector2[]; holes: Vector2[][]; }; - extrude(options?: any): ExtrudeGeometry; extractPoints(divisions: number): Vector2[]; extractAllSpacedPoints(divisions: Vector2): { shape: Vector2[]; holes: Vector2[][]; }; - getPointsHoles(divisions: number): Vector2[][]; - getSpacedPointsHoles(divisions: number): Vector2[][]; + } + // Extras / Curves ///////////////////////////////////////////////////////////////////// + export class ArcCurve extends EllipseCurve { + constructor(aX: number, aY: number, aRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean ); + } + export class ClosedSplineCurve3 extends Curve { + constructor( points?:Vector3[] ); + + points:Vector3[]; + + getPoint(t: number): Vector3; + } + + export class CubicBezierCurve extends Curve { + constructor( v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2 ); + + v0: Vector2; + v1: Vector2; + v2: Vector2; + v3: Vector2; + + getPoint(t: number): Vector2; + getTangent(t: number): Vector2; + } + export class CubicBezierCurve3 extends Curve { + constructor( v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3 ); + + v0: Vector3; + v1: Vector3; + v2: Vector3; + v3: Vector3; + + getPoint(t: number): Vector3; + } + export class EllipseCurve extends Curve { + constructor( aX: number, aY: number, xRadius: number, yRadius: number, aStartAngle: number, aEndAngle: number, aClockwise: boolean ); + + aX: number; + aY: number; + xRadius: number; + yRadius: number; + aStartAngle: number; + aEndAngle: number; + aClockwise: boolean; + + getPoint(t: number): Vector2; + } + export class LineCurve extends Curve { + constructor( v1: Vector2, v2: Vector2 ); + + v1: Vector2; + v2: Vector2; + + getPoint(t: number): Vector2; + getPointAt(u: number): Vector2; + getTangent(t: number): Vector2; + } + export class LineCurve3 extends Curve { + constructor( v1: Vector3, v2: Vector3 ); + + v1: Vector3; + v2: Vector3; + + getPoint(t: number): Vector3; + } + export class QuadraticBezierCurve extends Curve { + constructor( v0: Vector2, v1: Vector2, v2: Vector2 ); + + v0: Vector2; + v1: Vector2; + v2: Vector2; + + getPoint(t: number): Vector2; + getTangent(t: number): Vector2; + } + export class QuadraticBezierCurve3 extends Curve { + constructor( v0: Vector3, v1: Vector3, v2: Vector3 ); + + v0: Vector3; + v1: Vector3; + v2: Vector3; + + getPoint(t: number): Vector3; + } + export class SplineCurve extends Curve { + constructor( points?: Vector2[] ); + + points:Vector2[]; + + getPoint(t: number): Vector2; + } + export class SplineCurve3 extends Curve { + constructor( points?: Vector3[] ); + + points:Vector3[]; + + getPoint(t: number): Vector3; + } // Extras / Geomerties ///////////////////////////////////////////////////////////////////// /** @@ -5325,10 +5347,33 @@ declare module THREE { * @param depthSegments — Number of segmented faces along the depth of the sides. */ constructor(width: number, height: number, depth: number, widthSegments?: number, heightSegments?: number, depthSegments?: number); + + parameters: { + width: number; + height: number; + depth: number; + widthSegments: number; + heightSegments: number; + depthSegments: number; + }; + widthSegments: number; + heightSegments: number; + depthSegments: number; } export class CircleGeometry extends Geometry { constructor(radius?: number, segments?: number, thetaStart?: number, thetaLength?: number); + + parameters: { + radius: number; + segments: number; + thetaStart: number; + thetaLength: number; + }; + radius: number; + segments: number; + thetaStart: number; + thetaLength: number; } export class CubeGeometry extends BoxGeometry { @@ -5344,6 +5389,21 @@ declare module THREE { * @param openEnded - A Boolean indicating whether or not to cap the ends of the cylinder. */ constructor(radiusTop?: number, radiusBottom?: number, height?: number, radiusSegments?: number, heightSegments?: number, openEnded?: boolean); + + parameters: { + radiusTop: number; + radiusBottom: number; + height: number; + radialSegments: number; + heightSegments: number; + openEnded: boolean; + }; + radiusTop: number; + radiusBottom: number; + height: number; + radialSegments: number; + heightSegments: number; + openEnded: boolean; } export class ExtrudeGeometry extends Geometry { @@ -5356,14 +5416,29 @@ declare module THREE { export class IcosahedronGeometry extends PolyhedronGeometry { constructor(radius: number, detail: number); + + parameters: { + radius: number; + detail: number; + }; + radius: number; + detail: number; } export class LatheGeometry extends Geometry { - constructor(points: Vector3[], steps?: number, angle?: number); + constructor(points: Vector3[], segments?: number, phiStart?: number, phiLength?: number); + } export class OctahedronGeometry extends PolyhedronGeometry { constructor(radius: number, detail: number); + + parameters: { + radius: number; + detail: number; + }; + radius: number; + detail: number; } export class ParametricGeometry extends Geometry { @@ -5372,6 +5447,17 @@ declare module THREE { export class PlaneGeometry extends Geometry { constructor(width: number, height: number, widthSegments?: number, heightSegments?: number); + + parameters: { + width: number; + height: number; + widthSegments: number; + heightSegments: number; + }; + width: number; + height: number; + widthSegments: number; + heightSegments: number; } export class PolyhedronGeometry extends Geometry { @@ -5381,6 +5467,7 @@ declare module THREE { export class RingGeometry extends Geometry { constructor(innerRadius?: number, outerRadius?: number, thetaSegments?: number, phiSegments?: number, thetaStart?: number, thetaLength?: number); } + export class ShapeGeometry extends Geometry { constructor(shape: Shape, options?: any); constructor(shapes: Shape[], options?: any); @@ -5397,14 +5484,31 @@ declare module THREE { * The geometry is created by sweeping and calculating vertexes around the Y axis (horizontal sweep) and the Z axis (vertical sweep). Thus, incomplete spheres (akin to 'sphere slices') can be created through the use of different values of phiStart, phiLength, thetaStart and thetaLength, in order to define the points in which we start (or end) calculating those vertices. * * @param radius — sphere radius. Default is 50. - * @param segmentsWidth — number of horizontal segments. Minimum value is 3, and the default is 8. - * @param segmentsHeight — number of vertical segments. Minimum value is 2, and the default is 6. + * @param widthSegments — number of horizontal segments. Minimum value is 3, and the default is 8. + * @param heightSegments — number of vertical segments. Minimum value is 2, and the default is 6. * @param phiStart — specify horizontal starting angle. Default is 0. * @param phiLength — specify horizontal sweep angle size. Default is Math.PI * 2. * @param thetaStart — specify vertical starting angle. Default is 0. * @param thetaLength — specify vertical sweep angle size. Default is Math.PI. */ constructor(radius: number, widthSegments?: number, heightSegments?: number, phiStart?: number, phiLength?: number, thetaStart?: number, thetaLength?: number); + + parameters: { + radius: number; + widthSegments: number; + heightSegments: number; + phiStart: number; + phiLength: number; + thetaStart: number; + thetaLength: number; + }; + radius: number; + widthSegments: number; + heightSegments: number; + phiStart: number; + phiLength: number; + thetaStart: number; + thetaLength: number; } export class TetrahedronGeometry extends PolyhedronGeometry { @@ -5429,19 +5533,56 @@ declare module THREE { export class TorusGeometry extends Geometry { constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number); + + parameters: { + radius: number; + tube: number; + radialSegments: number; + tubularSegments: number; + arc: number; + }; + radius: number; + tube: number; + radialSegments: number; + tubularSegments: number; + arc: number; } export class TorusKnotGeometry extends Geometry { constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, p?: number, q?: number, heightScale?: number); + + parameters: { + radius: number; + tube: number; + radialSegments: number; + tubularSegments: number; + p: number; + q: number; + heightScale: number; + }; + radius: number; + tube: number; + radialSegments: number; + tubularSegments: number; + p: number; + q: number; + heightScale: number; } export class TubeGeometry extends Geometry { constructor(path: Path, segments?: number, radius?: number, radiusSegments?: number, closed?: boolean); + parameters: { + path: Path; + segments: number; + radius: number; + radialSegments: number; + closed: boolean; + }; path: Path; segments: number; radius: number; - radiusSegments: number; + radialSegments: number; closed: boolean; tangents: Vector3[]; normals: Vector3[]; @@ -5458,29 +5599,26 @@ declare module THREE { line: Line; cone: Mesh; - setColor(hex: number): void; - setLength(length: number): void; setDirection(dir: Vector3): void; + setLength(length: number): void; + setColor(hex: number): void; } export class AxisHelper extends Line { - constructor(size: number); + constructor(size?: number); } export class BoundingBoxHelper extends Mesh { - constructor(object: Object3D, hex: number); + constructor(object: Object3D, hex?: number); object: Object3D; - vertices: Vector3[]; + box: Box3[]; update(): void; } export class BoxHelper extends Line { - constructor(object: Object3D); - - object: Object3D; - box: Box3; + constructor(object?: Object3D); update(object?: Object3D): void; } @@ -5488,35 +5626,33 @@ declare module THREE { export class CameraHelper extends Line { constructor(camera: Camera); - pointMap: { [id: string]: number[]; }; camera: Camera; + pointMap: { [id: string]: number[]; }; update(): void; } export class DirectionalLightHelper extends Object3D { - constructor(light: Light, size: number); + constructor(light: Light, size?: number); - lightPlane: Line; light: Light; + lightPlane: Line; targetLine: Line; - update(): void; dispose(): void; + update(): void; } export class EdgesHelper extends Line { constructor(object: Object3D, hex?: number); - matrixAutoUpdate: boolean; - matrixWorld: Matrix4; } export class FaceNormalsHelper extends Line { constructor(object: Object3D, size?: number, hex?: number, linewidth?: number); + object: Object3D; size: number; - matrixAutoUpdate: boolean; normalMatrix: Matrix3; update(object?: Object3D): void; @@ -5525,23 +5661,28 @@ declare module THREE { export class GridHelper extends Line { constructor(size: number, step: number); + color1: Color; + color2: Color; + setColors(colorCenterLine: number, colorGrid: number): void; } export class HemisphereLightHelper extends Object3D { constructor(light: Light, sphereSize: number, arrowLength: number, domeSize: number); - lightSphere: Mesh; light: Light; + colors: Color[]; + lightSphere: Mesh; + dispose(): void; update(): void; } export class PointLightHelper extends Object3D { constructor(light: Light, sphereSize: number); - lightSphere: Mesh; light: Light; + dispose(): void; update(): void; } @@ -5550,8 +5691,7 @@ declare module THREE { bones: Bone[]; root: Object3D; - matrixWorld: Matrix4; - matrixAutoUpdate: boolean; + getBoneList(object: Object3D): Bone[]; update(): void; } @@ -5559,18 +5699,18 @@ declare module THREE { export class SpotLightHelper extends Object3D { constructor(light: Light, sphereSize: number, arrowLength: number); - lightSphere: Mesh; light: Light; - lightCone: Mesh; + cone: Mesh; + dispose(): void; update(): void; } export class VertexNormalsHelper extends Line { constructor(object: Object3D, size?: number, hex?: number, linewidth?: number); + object: Object3D; size: number; - matrixAutoUpdate: boolean; normalMatrix: Matrix3; update(object?: Object3D): void; @@ -5579,8 +5719,8 @@ declare module THREE { export class VertexTangentsHelper extends Line { constructor(object: Object3D, size?: number, hex?: number, linewidth?: number); + object: Object3D; size: number; - matrixAutoUpdate: boolean; update(object?: Object3D): void; } @@ -5588,8 +5728,6 @@ declare module THREE { export class WireframeHelper extends Line { constructor(object: Object3D, hex?: number); - matrixAutoUpdate: boolean; - matrixWorld: Matrix4; } // Extras / Objects ///////////////////////////////////////////////////////////////////// @@ -5650,19 +5788,19 @@ declare module THREE { animationsMap: { [name: string]: MorphBlendMeshAnimation; }; animationsList: MorphBlendMeshAnimation[]; - setAnimationWeight(name: string, weight: number): void; - setAnimationFPS(name: string, fps: number): void; createAnimation(name: string, start: number, end: number, fps: number): void; - playAnimation(name: string): void; - update(delta: number): void; autoCreateAnimations(fps: number): void; - setAnimationDuration(name: string, duration: number): void; setAnimationDirectionForward(name: string): void; - getAnimationDuration(name: string): number; - getAnimationTime(name: string): number; setAnimationDirectionBackward(name: string): void; + setAnimationFPS(name: string, fps: number): void; + setAnimationDuration(name: string, duration: number): void; + setAnimationWeight(name: string, weight: number): void; setAnimationTime(name: string, time: number): void; + getAnimationTime(name: string): number; + getAnimationDuration(name: string): number; + playAnimation(name: string): void; stopAnimation(name: string): void; + update(delta: number): void; } // Extras / Renderers / Plugins ///////////////////////////////////////////////////////////////////// @@ -5674,8 +5812,8 @@ declare module THREE { renderTarget: RenderTarget; init(renderer: Renderer): void; - update(scene: Scene, camera: Camera): void; render(scene: Scene, camera: Camera): void; + update(scene: Scene, camera: Camera): void; } export class LensFlarePlugin implements RendererPlugin { @@ -5689,9 +5827,8 @@ declare module THREE { constructor(); init(renderer: Renderer): void; - - update(scene: Scene, camera: Camera): void; render(scene: Scene, camera: Camera): void; + update(scene: Scene, camera: Camera): void; } export class SpritePlugin implements RendererPlugin { From 867cede314770e5ebf2f3db1c973ba255db70f79 Mon Sep 17 00:00:00 2001 From: satoru kimura Date: Mon, 25 Aug 2014 02:05:22 +0900 Subject: [PATCH 2/2] Modified the test code. --- threejs/tests/canvas/canvas_camera_orthographic.ts | 4 ++-- threejs/tests/canvas/canvas_geometry_cube.ts | 6 +++--- threejs/tests/canvas/canvas_materials.ts | 8 ++++---- threejs/three.d.ts | 2 ++ 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/threejs/tests/canvas/canvas_camera_orthographic.ts b/threejs/tests/canvas/canvas_camera_orthographic.ts index 0674e6fa44..7391d978b0 100644 --- a/threejs/tests/canvas/canvas_camera_orthographic.ts +++ b/threejs/tests/canvas/canvas_camera_orthographic.ts @@ -55,12 +55,12 @@ // Cubes - var geometry = new THREE.BoxGeometry(50, 50, 50); + var geometry2 = new THREE.BoxGeometry(50, 50, 50); var material2 = new THREE.MeshLambertMaterial({ color: 0xffffff, shading: THREE.FlatShading, overdraw: 0.5 }); for (var i = 0; i < 100; i++) { - var cube = new THREE.Mesh(geometry, material2); + var cube = new THREE.Mesh(geometry2, material2); cube.scale.y = Math.floor(Math.random() * 2 + 1); diff --git a/threejs/tests/canvas/canvas_geometry_cube.ts b/threejs/tests/canvas/canvas_geometry_cube.ts index bf5f9ae99f..c8f6b377c2 100644 --- a/threejs/tests/canvas/canvas_geometry_cube.ts +++ b/threejs/tests/canvas/canvas_geometry_cube.ts @@ -61,12 +61,12 @@ // Plane - var geometry = new THREE.PlaneGeometry(200, 200); - geometry.applyMatrix(new THREE.Matrix4().makeRotationX(- Math.PI / 2)); + var geometry2 = new THREE.PlaneGeometry(200, 200); + geometry2.applyMatrix(new THREE.Matrix4().makeRotationX(- Math.PI / 2)); var material = new THREE.MeshBasicMaterial({ color: 0xe0e0e0, overdraw: 0.5 }); - plane = new THREE.Mesh(geometry, material); + plane = new THREE.Mesh(geometry2, material); scene.add(plane); renderer = new THREE.CanvasRenderer(); diff --git a/threejs/tests/canvas/canvas_materials.ts b/threejs/tests/canvas/canvas_materials.ts index a39a780ca9..0d8f8a631e 100644 --- a/threejs/tests/canvas/canvas_materials.ts +++ b/threejs/tests/canvas/canvas_materials.ts @@ -50,7 +50,7 @@ // Spheres - var geometry = new THREE.SphereGeometry(100, 14, 7); + var geometry2 = new THREE.SphereGeometry(100, 14, 7); materials = [ @@ -66,9 +66,9 @@ ]; - for (var i = 0, l = geometry.faces.length; i < l; i++) { + for (var i = 0, l = geometry2.faces.length; i < l; i++) { - var face = geometry.faces[i]; + var face = geometry2.faces[i]; if (Math.random() > 0.5) face.materialIndex = Math.floor(Math.random() * materials.length); } @@ -79,7 +79,7 @@ for (var i = 0, l = materials.length; i < l; i++) { - var sphere = new THREE.Mesh(geometry, materials[i]); + var sphere = new THREE.Mesh(geometry2, materials[i]); sphere.position.x = (i % 5) * 200 - 400; sphere.position.z = Math.floor(i / 5) * 200 - 200; diff --git a/threejs/three.d.ts b/threejs/three.d.ts index fa62089901..3bace76453 100644 --- a/threejs/three.d.ts +++ b/threejs/three.d.ts @@ -93,7 +93,9 @@ declare module THREE { } export var UVMapping: MappingConstructor; export var CubeReflectionMapping: MappingConstructor; + export var CubeRefractionMapping: MappingConstructor; export var SphericalReflectionMapping: MappingConstructor; + export var SphericalRefractionMapping: MappingConstructor; // Wrapping modes export enum Wrapping { }