|
|
@@ -158,7 +158,7 @@ declare module BABYLON {
|
|
|
cullBackFaces: boolean;
|
|
|
renderEvenInBackground: boolean;
|
|
|
preventCacheWipeBetweenFrames: boolean;
|
|
|
- enableOfflineSupport: boolean;
|
|
|
+ enableOfflineSupport: typeof Database;
|
|
|
scenes: Scene[];
|
|
|
vrDisplaysPromise: any;
|
|
|
private _vrDisplays;
|
|
|
@@ -1517,7 +1517,8 @@ declare module BABYLON {
|
|
|
gravity: Vector3;
|
|
|
postProcessesEnabled: boolean;
|
|
|
postProcessManager: PostProcessManager;
|
|
|
- postProcessRenderPipelineManager: PostProcessRenderPipelineManager;
|
|
|
+ private _postProcessRenderPipelineManager;
|
|
|
+ readonly postProcessRenderPipelineManager: PostProcessRenderPipelineManager;
|
|
|
renderTargetsEnabled: boolean;
|
|
|
dumpNextRenderTargets: boolean;
|
|
|
customRenderTargets: RenderTargetTexture[];
|
|
|
@@ -3186,6 +3187,249 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+ class Collider {
|
|
|
+ radius: Vector3;
|
|
|
+ retry: number;
|
|
|
+ velocity: Vector3;
|
|
|
+ basePoint: Vector3;
|
|
|
+ epsilon: number;
|
|
|
+ collisionFound: boolean;
|
|
|
+ velocityWorldLength: number;
|
|
|
+ basePointWorld: Vector3;
|
|
|
+ velocityWorld: Vector3;
|
|
|
+ normalizedVelocity: Vector3;
|
|
|
+ initialVelocity: Vector3;
|
|
|
+ initialPosition: Vector3;
|
|
|
+ nearestDistance: number;
|
|
|
+ intersectionPoint: Vector3;
|
|
|
+ collidedMesh: AbstractMesh;
|
|
|
+ private _collisionPoint;
|
|
|
+ private _planeIntersectionPoint;
|
|
|
+ private _tempVector;
|
|
|
+ private _tempVector2;
|
|
|
+ private _tempVector3;
|
|
|
+ private _tempVector4;
|
|
|
+ private _edge;
|
|
|
+ private _baseToVertex;
|
|
|
+ private _destinationPoint;
|
|
|
+ private _slidePlaneNormal;
|
|
|
+ private _displacementVector;
|
|
|
+ private _collisionMask;
|
|
|
+ collisionMask: number;
|
|
|
+ _initialize(source: Vector3, dir: Vector3, e: number): void;
|
|
|
+ _checkPointInTriangle(point: Vector3, pa: Vector3, pb: Vector3, pc: Vector3, n: Vector3): boolean;
|
|
|
+ _canDoCollision(sphereCenter: Vector3, sphereRadius: number, vecMin: Vector3, vecMax: Vector3): boolean;
|
|
|
+ _testTriangle(faceIndex: number, trianglePlaneArray: Array<Plane>, p1: Vector3, p2: Vector3, p3: Vector3, hasMaterial: boolean): void;
|
|
|
+ _collide(trianglePlaneArray: Array<Plane>, pts: Vector3[], indices: IndicesArray, indexStart: number, indexEnd: number, decal: number, hasMaterial: boolean): void;
|
|
|
+ _getResponse(pos: Vector3, vel: Vector3): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ var CollisionWorker: string;
|
|
|
+ interface ICollisionCoordinator {
|
|
|
+ getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
|
|
|
+ init(scene: Scene): void;
|
|
|
+ destroy(): void;
|
|
|
+ onMeshAdded(mesh: AbstractMesh): any;
|
|
|
+ onMeshUpdated(mesh: AbstractMesh): any;
|
|
|
+ onMeshRemoved(mesh: AbstractMesh): any;
|
|
|
+ onGeometryAdded(geometry: Geometry): any;
|
|
|
+ onGeometryUpdated(geometry: Geometry): any;
|
|
|
+ onGeometryDeleted(geometry: Geometry): any;
|
|
|
+ }
|
|
|
+ interface SerializedMesh {
|
|
|
+ id: string;
|
|
|
+ name: string;
|
|
|
+ uniqueId: number;
|
|
|
+ geometryId: string;
|
|
|
+ sphereCenter: Array<number>;
|
|
|
+ sphereRadius: number;
|
|
|
+ boxMinimum: Array<number>;
|
|
|
+ boxMaximum: Array<number>;
|
|
|
+ worldMatrixFromCache: any;
|
|
|
+ subMeshes: Array<SerializedSubMesh>;
|
|
|
+ checkCollisions: boolean;
|
|
|
+ }
|
|
|
+ interface SerializedSubMesh {
|
|
|
+ position: number;
|
|
|
+ verticesStart: number;
|
|
|
+ verticesCount: number;
|
|
|
+ indexStart: number;
|
|
|
+ indexCount: number;
|
|
|
+ hasMaterial: boolean;
|
|
|
+ sphereCenter: Array<number>;
|
|
|
+ sphereRadius: number;
|
|
|
+ boxMinimum: Array<number>;
|
|
|
+ boxMaximum: Array<number>;
|
|
|
+ }
|
|
|
+ interface SerializedGeometry {
|
|
|
+ id: string;
|
|
|
+ positions: Float32Array;
|
|
|
+ indices: Uint32Array;
|
|
|
+ normals: Float32Array;
|
|
|
+ }
|
|
|
+ interface BabylonMessage {
|
|
|
+ taskType: WorkerTaskType;
|
|
|
+ payload: InitPayload | CollidePayload | UpdatePayload;
|
|
|
+ }
|
|
|
+ interface SerializedColliderToWorker {
|
|
|
+ position: Array<number>;
|
|
|
+ velocity: Array<number>;
|
|
|
+ radius: Array<number>;
|
|
|
+ }
|
|
|
+ enum WorkerTaskType {
|
|
|
+ INIT = 0,
|
|
|
+ UPDATE = 1,
|
|
|
+ COLLIDE = 2,
|
|
|
+ }
|
|
|
+ interface WorkerReply {
|
|
|
+ error: WorkerReplyType;
|
|
|
+ taskType: WorkerTaskType;
|
|
|
+ payload?: any;
|
|
|
+ }
|
|
|
+ interface CollisionReplyPayload {
|
|
|
+ newPosition: Array<number>;
|
|
|
+ collisionId: number;
|
|
|
+ collidedMeshUniqueId: number;
|
|
|
+ }
|
|
|
+ interface InitPayload {
|
|
|
+ }
|
|
|
+ interface CollidePayload {
|
|
|
+ collisionId: number;
|
|
|
+ collider: SerializedColliderToWorker;
|
|
|
+ maximumRetry: number;
|
|
|
+ excludedMeshUniqueId?: number;
|
|
|
+ }
|
|
|
+ interface UpdatePayload {
|
|
|
+ updatedMeshes: {
|
|
|
+ [n: number]: SerializedMesh;
|
|
|
+ };
|
|
|
+ updatedGeometries: {
|
|
|
+ [s: string]: SerializedGeometry;
|
|
|
+ };
|
|
|
+ removedMeshes: Array<number>;
|
|
|
+ removedGeometries: Array<string>;
|
|
|
+ }
|
|
|
+ enum WorkerReplyType {
|
|
|
+ SUCCESS = 0,
|
|
|
+ UNKNOWN_ERROR = 1,
|
|
|
+ }
|
|
|
+ class CollisionCoordinatorWorker implements ICollisionCoordinator {
|
|
|
+ private _scene;
|
|
|
+ private _scaledPosition;
|
|
|
+ private _scaledVelocity;
|
|
|
+ private _collisionsCallbackArray;
|
|
|
+ private _init;
|
|
|
+ private _runningUpdated;
|
|
|
+ private _runningCollisionTask;
|
|
|
+ private _worker;
|
|
|
+ private _addUpdateMeshesList;
|
|
|
+ private _addUpdateGeometriesList;
|
|
|
+ private _toRemoveMeshesArray;
|
|
|
+ private _toRemoveGeometryArray;
|
|
|
+ constructor();
|
|
|
+ static SerializeMesh: (mesh: AbstractMesh) => SerializedMesh;
|
|
|
+ static SerializeGeometry: (geometry: Geometry) => SerializedGeometry;
|
|
|
+ getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
|
|
|
+ init(scene: Scene): void;
|
|
|
+ destroy(): void;
|
|
|
+ onMeshAdded(mesh: AbstractMesh): void;
|
|
|
+ onMeshUpdated: (mesh: AbstractMesh) => void;
|
|
|
+ onMeshRemoved(mesh: AbstractMesh): void;
|
|
|
+ onGeometryAdded(geometry: Geometry): void;
|
|
|
+ onGeometryUpdated: (geometry: Geometry) => void;
|
|
|
+ onGeometryDeleted(geometry: Geometry): void;
|
|
|
+ private _afterRender;
|
|
|
+ private _onMessageFromWorker;
|
|
|
+ }
|
|
|
+ class CollisionCoordinatorLegacy implements ICollisionCoordinator {
|
|
|
+ private _scene;
|
|
|
+ private _scaledPosition;
|
|
|
+ private _scaledVelocity;
|
|
|
+ private _finalPosition;
|
|
|
+ getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
|
|
|
+ init(scene: Scene): void;
|
|
|
+ destroy(): void;
|
|
|
+ onMeshAdded(mesh: AbstractMesh): void;
|
|
|
+ onMeshUpdated(mesh: AbstractMesh): void;
|
|
|
+ onMeshRemoved(mesh: AbstractMesh): void;
|
|
|
+ onGeometryAdded(geometry: Geometry): void;
|
|
|
+ onGeometryUpdated(geometry: Geometry): void;
|
|
|
+ onGeometryDeleted(geometry: Geometry): void;
|
|
|
+ private _collideWithWorld(position, velocity, collider, maximumRetry, finalPosition, excludedMesh?);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ var WorkerIncluded: boolean;
|
|
|
+ class CollisionCache {
|
|
|
+ private _meshes;
|
|
|
+ private _geometries;
|
|
|
+ getMeshes(): {
|
|
|
+ [n: number]: SerializedMesh;
|
|
|
+ };
|
|
|
+ getGeometries(): {
|
|
|
+ [s: number]: SerializedGeometry;
|
|
|
+ };
|
|
|
+ getMesh(id: any): SerializedMesh;
|
|
|
+ addMesh(mesh: SerializedMesh): void;
|
|
|
+ removeMesh(uniqueId: number): void;
|
|
|
+ getGeometry(id: string): SerializedGeometry;
|
|
|
+ addGeometry(geometry: SerializedGeometry): void;
|
|
|
+ removeGeometry(id: string): void;
|
|
|
+ }
|
|
|
+ class CollideWorker {
|
|
|
+ collider: Collider;
|
|
|
+ private _collisionCache;
|
|
|
+ private finalPosition;
|
|
|
+ private collisionsScalingMatrix;
|
|
|
+ private collisionTranformationMatrix;
|
|
|
+ constructor(collider: Collider, _collisionCache: CollisionCache, finalPosition: Vector3);
|
|
|
+ collideWithWorld(position: Vector3, velocity: Vector3, maximumRetry: number, excludedMeshUniqueId?: number): void;
|
|
|
+ private checkCollision(mesh);
|
|
|
+ private processCollisionsForSubMeshes(transformMatrix, mesh);
|
|
|
+ private collideForSubMesh(subMesh, transformMatrix, meshGeometry);
|
|
|
+ private checkSubmeshCollision(subMesh);
|
|
|
+ }
|
|
|
+ interface ICollisionDetector {
|
|
|
+ onInit(payload: InitPayload): void;
|
|
|
+ onUpdate(payload: UpdatePayload): void;
|
|
|
+ onCollision(payload: CollidePayload): void;
|
|
|
+ }
|
|
|
+ class CollisionDetectorTransferable implements ICollisionDetector {
|
|
|
+ private _collisionCache;
|
|
|
+ onInit(payload: InitPayload): void;
|
|
|
+ onUpdate(payload: UpdatePayload): void;
|
|
|
+ onCollision(payload: CollidePayload): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class IntersectionInfo {
|
|
|
+ bu: number;
|
|
|
+ bv: number;
|
|
|
+ distance: number;
|
|
|
+ faceId: number;
|
|
|
+ subMeshId: number;
|
|
|
+ constructor(bu: number, bv: number, distance: number);
|
|
|
+ }
|
|
|
+ class PickingInfo {
|
|
|
+ hit: boolean;
|
|
|
+ distance: number;
|
|
|
+ pickedPoint: Vector3;
|
|
|
+ pickedMesh: AbstractMesh;
|
|
|
+ bu: number;
|
|
|
+ bv: number;
|
|
|
+ faceId: number;
|
|
|
+ subMeshId: number;
|
|
|
+ pickedSprite: Sprite;
|
|
|
+ getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3;
|
|
|
+ getTextureCoordinates(): Vector2;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
class ArcRotateCamera extends TargetCamera {
|
|
|
alpha: number;
|
|
|
beta: number;
|
|
|
@@ -3646,354 +3890,6 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
- class Collider {
|
|
|
- radius: Vector3;
|
|
|
- retry: number;
|
|
|
- velocity: Vector3;
|
|
|
- basePoint: Vector3;
|
|
|
- epsilon: number;
|
|
|
- collisionFound: boolean;
|
|
|
- velocityWorldLength: number;
|
|
|
- basePointWorld: Vector3;
|
|
|
- velocityWorld: Vector3;
|
|
|
- normalizedVelocity: Vector3;
|
|
|
- initialVelocity: Vector3;
|
|
|
- initialPosition: Vector3;
|
|
|
- nearestDistance: number;
|
|
|
- intersectionPoint: Vector3;
|
|
|
- collidedMesh: AbstractMesh;
|
|
|
- private _collisionPoint;
|
|
|
- private _planeIntersectionPoint;
|
|
|
- private _tempVector;
|
|
|
- private _tempVector2;
|
|
|
- private _tempVector3;
|
|
|
- private _tempVector4;
|
|
|
- private _edge;
|
|
|
- private _baseToVertex;
|
|
|
- private _destinationPoint;
|
|
|
- private _slidePlaneNormal;
|
|
|
- private _displacementVector;
|
|
|
- private _collisionMask;
|
|
|
- collisionMask: number;
|
|
|
- _initialize(source: Vector3, dir: Vector3, e: number): void;
|
|
|
- _checkPointInTriangle(point: Vector3, pa: Vector3, pb: Vector3, pc: Vector3, n: Vector3): boolean;
|
|
|
- _canDoCollision(sphereCenter: Vector3, sphereRadius: number, vecMin: Vector3, vecMax: Vector3): boolean;
|
|
|
- _testTriangle(faceIndex: number, trianglePlaneArray: Array<Plane>, p1: Vector3, p2: Vector3, p3: Vector3, hasMaterial: boolean): void;
|
|
|
- _collide(trianglePlaneArray: Array<Plane>, pts: Vector3[], indices: IndicesArray, indexStart: number, indexEnd: number, decal: number, hasMaterial: boolean): void;
|
|
|
- _getResponse(pos: Vector3, vel: Vector3): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
- var CollisionWorker: string;
|
|
|
- interface ICollisionCoordinator {
|
|
|
- getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
|
|
|
- init(scene: Scene): void;
|
|
|
- destroy(): void;
|
|
|
- onMeshAdded(mesh: AbstractMesh): any;
|
|
|
- onMeshUpdated(mesh: AbstractMesh): any;
|
|
|
- onMeshRemoved(mesh: AbstractMesh): any;
|
|
|
- onGeometryAdded(geometry: Geometry): any;
|
|
|
- onGeometryUpdated(geometry: Geometry): any;
|
|
|
- onGeometryDeleted(geometry: Geometry): any;
|
|
|
- }
|
|
|
- interface SerializedMesh {
|
|
|
- id: string;
|
|
|
- name: string;
|
|
|
- uniqueId: number;
|
|
|
- geometryId: string;
|
|
|
- sphereCenter: Array<number>;
|
|
|
- sphereRadius: number;
|
|
|
- boxMinimum: Array<number>;
|
|
|
- boxMaximum: Array<number>;
|
|
|
- worldMatrixFromCache: any;
|
|
|
- subMeshes: Array<SerializedSubMesh>;
|
|
|
- checkCollisions: boolean;
|
|
|
- }
|
|
|
- interface SerializedSubMesh {
|
|
|
- position: number;
|
|
|
- verticesStart: number;
|
|
|
- verticesCount: number;
|
|
|
- indexStart: number;
|
|
|
- indexCount: number;
|
|
|
- hasMaterial: boolean;
|
|
|
- sphereCenter: Array<number>;
|
|
|
- sphereRadius: number;
|
|
|
- boxMinimum: Array<number>;
|
|
|
- boxMaximum: Array<number>;
|
|
|
- }
|
|
|
- interface SerializedGeometry {
|
|
|
- id: string;
|
|
|
- positions: Float32Array;
|
|
|
- indices: Uint32Array;
|
|
|
- normals: Float32Array;
|
|
|
- }
|
|
|
- interface BabylonMessage {
|
|
|
- taskType: WorkerTaskType;
|
|
|
- payload: InitPayload | CollidePayload | UpdatePayload;
|
|
|
- }
|
|
|
- interface SerializedColliderToWorker {
|
|
|
- position: Array<number>;
|
|
|
- velocity: Array<number>;
|
|
|
- radius: Array<number>;
|
|
|
- }
|
|
|
- enum WorkerTaskType {
|
|
|
- INIT = 0,
|
|
|
- UPDATE = 1,
|
|
|
- COLLIDE = 2,
|
|
|
- }
|
|
|
- interface WorkerReply {
|
|
|
- error: WorkerReplyType;
|
|
|
- taskType: WorkerTaskType;
|
|
|
- payload?: any;
|
|
|
- }
|
|
|
- interface CollisionReplyPayload {
|
|
|
- newPosition: Array<number>;
|
|
|
- collisionId: number;
|
|
|
- collidedMeshUniqueId: number;
|
|
|
- }
|
|
|
- interface InitPayload {
|
|
|
- }
|
|
|
- interface CollidePayload {
|
|
|
- collisionId: number;
|
|
|
- collider: SerializedColliderToWorker;
|
|
|
- maximumRetry: number;
|
|
|
- excludedMeshUniqueId?: number;
|
|
|
- }
|
|
|
- interface UpdatePayload {
|
|
|
- updatedMeshes: {
|
|
|
- [n: number]: SerializedMesh;
|
|
|
- };
|
|
|
- updatedGeometries: {
|
|
|
- [s: string]: SerializedGeometry;
|
|
|
- };
|
|
|
- removedMeshes: Array<number>;
|
|
|
- removedGeometries: Array<string>;
|
|
|
- }
|
|
|
- enum WorkerReplyType {
|
|
|
- SUCCESS = 0,
|
|
|
- UNKNOWN_ERROR = 1,
|
|
|
- }
|
|
|
- class CollisionCoordinatorWorker implements ICollisionCoordinator {
|
|
|
- private _scene;
|
|
|
- private _scaledPosition;
|
|
|
- private _scaledVelocity;
|
|
|
- private _collisionsCallbackArray;
|
|
|
- private _init;
|
|
|
- private _runningUpdated;
|
|
|
- private _runningCollisionTask;
|
|
|
- private _worker;
|
|
|
- private _addUpdateMeshesList;
|
|
|
- private _addUpdateGeometriesList;
|
|
|
- private _toRemoveMeshesArray;
|
|
|
- private _toRemoveGeometryArray;
|
|
|
- constructor();
|
|
|
- static SerializeMesh: (mesh: AbstractMesh) => SerializedMesh;
|
|
|
- static SerializeGeometry: (geometry: Geometry) => SerializedGeometry;
|
|
|
- getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
|
|
|
- init(scene: Scene): void;
|
|
|
- destroy(): void;
|
|
|
- onMeshAdded(mesh: AbstractMesh): void;
|
|
|
- onMeshUpdated: (mesh: AbstractMesh) => void;
|
|
|
- onMeshRemoved(mesh: AbstractMesh): void;
|
|
|
- onGeometryAdded(geometry: Geometry): void;
|
|
|
- onGeometryUpdated: (geometry: Geometry) => void;
|
|
|
- onGeometryDeleted(geometry: Geometry): void;
|
|
|
- private _afterRender;
|
|
|
- private _onMessageFromWorker;
|
|
|
- }
|
|
|
- class CollisionCoordinatorLegacy implements ICollisionCoordinator {
|
|
|
- private _scene;
|
|
|
- private _scaledPosition;
|
|
|
- private _scaledVelocity;
|
|
|
- private _finalPosition;
|
|
|
- getNewPosition(position: Vector3, velocity: Vector3, collider: Collider, maximumRetry: number, excludedMesh: AbstractMesh, onNewPosition: (collisionIndex: number, newPosition: Vector3, collidedMesh?: AbstractMesh) => void, collisionIndex: number): void;
|
|
|
- init(scene: Scene): void;
|
|
|
- destroy(): void;
|
|
|
- onMeshAdded(mesh: AbstractMesh): void;
|
|
|
- onMeshUpdated(mesh: AbstractMesh): void;
|
|
|
- onMeshRemoved(mesh: AbstractMesh): void;
|
|
|
- onGeometryAdded(geometry: Geometry): void;
|
|
|
- onGeometryUpdated(geometry: Geometry): void;
|
|
|
- onGeometryDeleted(geometry: Geometry): void;
|
|
|
- private _collideWithWorld(position, velocity, collider, maximumRetry, finalPosition, excludedMesh?);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
- var WorkerIncluded: boolean;
|
|
|
- class CollisionCache {
|
|
|
- private _meshes;
|
|
|
- private _geometries;
|
|
|
- getMeshes(): {
|
|
|
- [n: number]: SerializedMesh;
|
|
|
- };
|
|
|
- getGeometries(): {
|
|
|
- [s: number]: SerializedGeometry;
|
|
|
- };
|
|
|
- getMesh(id: any): SerializedMesh;
|
|
|
- addMesh(mesh: SerializedMesh): void;
|
|
|
- removeMesh(uniqueId: number): void;
|
|
|
- getGeometry(id: string): SerializedGeometry;
|
|
|
- addGeometry(geometry: SerializedGeometry): void;
|
|
|
- removeGeometry(id: string): void;
|
|
|
- }
|
|
|
- class CollideWorker {
|
|
|
- collider: Collider;
|
|
|
- private _collisionCache;
|
|
|
- private finalPosition;
|
|
|
- private collisionsScalingMatrix;
|
|
|
- private collisionTranformationMatrix;
|
|
|
- constructor(collider: Collider, _collisionCache: CollisionCache, finalPosition: Vector3);
|
|
|
- collideWithWorld(position: Vector3, velocity: Vector3, maximumRetry: number, excludedMeshUniqueId?: number): void;
|
|
|
- private checkCollision(mesh);
|
|
|
- private processCollisionsForSubMeshes(transformMatrix, mesh);
|
|
|
- private collideForSubMesh(subMesh, transformMatrix, meshGeometry);
|
|
|
- private checkSubmeshCollision(subMesh);
|
|
|
- }
|
|
|
- interface ICollisionDetector {
|
|
|
- onInit(payload: InitPayload): void;
|
|
|
- onUpdate(payload: UpdatePayload): void;
|
|
|
- onCollision(payload: CollidePayload): void;
|
|
|
- }
|
|
|
- class CollisionDetectorTransferable implements ICollisionDetector {
|
|
|
- private _collisionCache;
|
|
|
- onInit(payload: InitPayload): void;
|
|
|
- onUpdate(payload: UpdatePayload): void;
|
|
|
- onCollision(payload: CollidePayload): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
- class IntersectionInfo {
|
|
|
- bu: number;
|
|
|
- bv: number;
|
|
|
- distance: number;
|
|
|
- faceId: number;
|
|
|
- subMeshId: number;
|
|
|
- constructor(bu: number, bv: number, distance: number);
|
|
|
- }
|
|
|
- class PickingInfo {
|
|
|
- hit: boolean;
|
|
|
- distance: number;
|
|
|
- pickedPoint: Vector3;
|
|
|
- pickedMesh: AbstractMesh;
|
|
|
- bu: number;
|
|
|
- bv: number;
|
|
|
- faceId: number;
|
|
|
- subMeshId: number;
|
|
|
- pickedSprite: Sprite;
|
|
|
- getNormal(useWorldCoordinates?: boolean, useVerticesNormals?: boolean): Vector3;
|
|
|
- getTextureCoordinates(): Vector2;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON.Debug {
|
|
|
- class AxesViewer {
|
|
|
- private _xline;
|
|
|
- private _yline;
|
|
|
- private _zline;
|
|
|
- private _xmesh;
|
|
|
- private _ymesh;
|
|
|
- private _zmesh;
|
|
|
- scene: Scene;
|
|
|
- scaleLines: number;
|
|
|
- constructor(scene: Scene, scaleLines?: number);
|
|
|
- update(position: Vector3, xaxis: Vector3, yaxis: Vector3, zaxis: Vector3): void;
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON.Debug {
|
|
|
- class BoneAxesViewer extends Debug.AxesViewer {
|
|
|
- mesh: Mesh;
|
|
|
- bone: Bone;
|
|
|
- pos: Vector3;
|
|
|
- xaxis: Vector3;
|
|
|
- yaxis: Vector3;
|
|
|
- zaxis: Vector3;
|
|
|
- constructor(scene: Scene, bone: Bone, mesh: Mesh, scaleLines?: number);
|
|
|
- update(): void;
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
- class DebugLayer {
|
|
|
- private _scene;
|
|
|
- static InspectorURL: string;
|
|
|
- private _inspector;
|
|
|
- constructor(scene: Scene);
|
|
|
- /** Creates the inspector window. */
|
|
|
- private _createInspector(config?);
|
|
|
- isVisible(): boolean;
|
|
|
- hide(): void;
|
|
|
- show(config?: {
|
|
|
- popup?: boolean;
|
|
|
- initialTab?: number;
|
|
|
- parentElement?: HTMLElement;
|
|
|
- newColors?: {
|
|
|
- backgroundColor?: string;
|
|
|
- backgroundColorLighter?: string;
|
|
|
- backgroundColorLighter2?: string;
|
|
|
- backgroundColorLighter3?: string;
|
|
|
- color?: string;
|
|
|
- colorTop?: string;
|
|
|
- colorBot?: string;
|
|
|
- };
|
|
|
- }): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
- class RayHelper {
|
|
|
- ray: Ray;
|
|
|
- private _renderPoints;
|
|
|
- private _renderLine;
|
|
|
- private _renderFunction;
|
|
|
- private _scene;
|
|
|
- private _updateToMeshFunction;
|
|
|
- private _attachedToMesh;
|
|
|
- private _meshSpaceDirection;
|
|
|
- private _meshSpaceOrigin;
|
|
|
- static CreateAndShow(ray: Ray, scene: Scene, color: Color3): RayHelper;
|
|
|
- constructor(ray: Ray);
|
|
|
- show(scene: Scene, color: Color3): void;
|
|
|
- hide(): void;
|
|
|
- private _render();
|
|
|
- attachToMesh(mesh: AbstractMesh, meshSpaceDirection?: Vector3, meshSpaceOrigin?: Vector3, length?: number): void;
|
|
|
- detachFromMesh(): void;
|
|
|
- private _updateToMesh();
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON.Debug {
|
|
|
- /**
|
|
|
- * Demo available here: http://www.babylonjs-playground.com/#1BZJVJ#8
|
|
|
- */
|
|
|
- class SkeletonViewer {
|
|
|
- skeleton: Skeleton;
|
|
|
- mesh: AbstractMesh;
|
|
|
- autoUpdateBonesMatrices: boolean;
|
|
|
- renderingGroupId: number;
|
|
|
- color: Color3;
|
|
|
- private _scene;
|
|
|
- private _debugLines;
|
|
|
- private _debugMesh;
|
|
|
- private _isEnabled;
|
|
|
- private _renderFunction;
|
|
|
- constructor(skeleton: Skeleton, mesh: AbstractMesh, scene: Scene, autoUpdateBonesMatrices?: boolean, renderingGroupId?: number);
|
|
|
- isEnabled: boolean;
|
|
|
- private _getBonePosition(position, bone, meshMat, x?, y?, z?);
|
|
|
- private _getLinesForBonesWithLength(bones, meshMat);
|
|
|
- private _getLinesForBonesNoLength(bones, meshMat);
|
|
|
- update(): void;
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
class BoundingBox implements ICullable {
|
|
|
minimum: Vector3;
|
|
|
maximum: Vector3;
|
|
|
@@ -4107,6 +4003,111 @@ declare module BABYLON {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+declare module BABYLON.Debug {
|
|
|
+ class AxesViewer {
|
|
|
+ private _xline;
|
|
|
+ private _yline;
|
|
|
+ private _zline;
|
|
|
+ private _xmesh;
|
|
|
+ private _ymesh;
|
|
|
+ private _zmesh;
|
|
|
+ scene: Scene;
|
|
|
+ scaleLines: number;
|
|
|
+ constructor(scene: Scene, scaleLines?: number);
|
|
|
+ update(position: Vector3, xaxis: Vector3, yaxis: Vector3, zaxis: Vector3): void;
|
|
|
+ dispose(): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON.Debug {
|
|
|
+ class BoneAxesViewer extends Debug.AxesViewer {
|
|
|
+ mesh: Mesh;
|
|
|
+ bone: Bone;
|
|
|
+ pos: Vector3;
|
|
|
+ xaxis: Vector3;
|
|
|
+ yaxis: Vector3;
|
|
|
+ zaxis: Vector3;
|
|
|
+ constructor(scene: Scene, bone: Bone, mesh: Mesh, scaleLines?: number);
|
|
|
+ update(): void;
|
|
|
+ dispose(): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class DebugLayer {
|
|
|
+ private _scene;
|
|
|
+ static InspectorURL: string;
|
|
|
+ private _inspector;
|
|
|
+ constructor(scene: Scene);
|
|
|
+ /** Creates the inspector window. */
|
|
|
+ private _createInspector(config?);
|
|
|
+ isVisible(): boolean;
|
|
|
+ hide(): void;
|
|
|
+ show(config?: {
|
|
|
+ popup?: boolean;
|
|
|
+ initialTab?: number;
|
|
|
+ parentElement?: HTMLElement;
|
|
|
+ newColors?: {
|
|
|
+ backgroundColor?: string;
|
|
|
+ backgroundColorLighter?: string;
|
|
|
+ backgroundColorLighter2?: string;
|
|
|
+ backgroundColorLighter3?: string;
|
|
|
+ color?: string;
|
|
|
+ colorTop?: string;
|
|
|
+ colorBot?: string;
|
|
|
+ };
|
|
|
+ }): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class RayHelper {
|
|
|
+ ray: Ray;
|
|
|
+ private _renderPoints;
|
|
|
+ private _renderLine;
|
|
|
+ private _renderFunction;
|
|
|
+ private _scene;
|
|
|
+ private _updateToMeshFunction;
|
|
|
+ private _attachedToMesh;
|
|
|
+ private _meshSpaceDirection;
|
|
|
+ private _meshSpaceOrigin;
|
|
|
+ static CreateAndShow(ray: Ray, scene: Scene, color: Color3): RayHelper;
|
|
|
+ constructor(ray: Ray);
|
|
|
+ show(scene: Scene, color: Color3): void;
|
|
|
+ hide(): void;
|
|
|
+ private _render();
|
|
|
+ attachToMesh(mesh: AbstractMesh, meshSpaceDirection?: Vector3, meshSpaceOrigin?: Vector3, length?: number): void;
|
|
|
+ detachFromMesh(): void;
|
|
|
+ private _updateToMesh();
|
|
|
+ dispose(): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON.Debug {
|
|
|
+ /**
|
|
|
+ * Demo available here: http://www.babylonjs-playground.com/#1BZJVJ#8
|
|
|
+ */
|
|
|
+ class SkeletonViewer {
|
|
|
+ skeleton: Skeleton;
|
|
|
+ mesh: AbstractMesh;
|
|
|
+ autoUpdateBonesMatrices: boolean;
|
|
|
+ renderingGroupId: number;
|
|
|
+ color: Color3;
|
|
|
+ private _scene;
|
|
|
+ private _debugLines;
|
|
|
+ private _debugMesh;
|
|
|
+ private _isEnabled;
|
|
|
+ private _renderFunction;
|
|
|
+ constructor(skeleton: Skeleton, mesh: AbstractMesh, scene: Scene, autoUpdateBonesMatrices?: boolean, renderingGroupId?: number);
|
|
|
+ isEnabled: boolean;
|
|
|
+ private _getBonePosition(position, bone, meshMat, x?, y?, z?);
|
|
|
+ private _getLinesForBonesWithLength(bones, meshMat);
|
|
|
+ private _getLinesForBonesNoLength(bones, meshMat);
|
|
|
+ update(): void;
|
|
|
+ dispose(): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
declare module BABYLON {
|
|
|
/**
|
|
|
* Highlight layer options. This helps customizing the behaviour
|
|
|
@@ -4408,6 +4409,58 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+ interface ISceneLoaderPluginExtensions {
|
|
|
+ [extension: string]: {
|
|
|
+ isBinary: boolean;
|
|
|
+ };
|
|
|
+ }
|
|
|
+ interface ISceneLoaderPlugin {
|
|
|
+ extensions: string | ISceneLoaderPluginExtensions;
|
|
|
+ importMesh: (meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => boolean;
|
|
|
+ load: (scene: Scene, data: string, rootUrl: string) => boolean;
|
|
|
+ }
|
|
|
+ interface ISceneLoaderPluginAsync {
|
|
|
+ extensions: string | ISceneLoaderPluginExtensions;
|
|
|
+ importMeshAsync: (meshesNames: any, scene: Scene, data: any, rootUrl: string, onsuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onerror: () => void) => void;
|
|
|
+ loadAsync: (scene: Scene, data: string, rootUrl: string, onsuccess: () => void, onerror: () => void) => void;
|
|
|
+ }
|
|
|
+ class SceneLoader {
|
|
|
+ private static _ForceFullSceneLoadingForIncremental;
|
|
|
+ private static _ShowLoadingScreen;
|
|
|
+ static readonly NO_LOGGING: number;
|
|
|
+ static readonly MINIMAL_LOGGING: number;
|
|
|
+ static readonly SUMMARY_LOGGING: number;
|
|
|
+ static readonly DETAILED_LOGGING: number;
|
|
|
+ private static _loggingLevel;
|
|
|
+ static ForceFullSceneLoadingForIncremental: boolean;
|
|
|
+ static ShowLoadingScreen: boolean;
|
|
|
+ static loggingLevel: number;
|
|
|
+ private static _registeredPlugins;
|
|
|
+ private static _getDefaultPlugin();
|
|
|
+ private static _getPluginForExtension(extension);
|
|
|
+ private static _getPluginForFilename(sceneFilename);
|
|
|
+ private static _getDirectLoad(sceneFilename);
|
|
|
+ static GetPluginForExtension(extension: string): ISceneLoaderPlugin | ISceneLoaderPluginAsync;
|
|
|
+ static RegisterPlugin(plugin: ISceneLoaderPlugin | ISceneLoaderPluginAsync): void;
|
|
|
+ static ImportMesh(meshesNames: any, rootUrl: string, sceneFilename: string, scene: Scene, onsuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, progressCallBack?: () => void, onerror?: (scene: Scene, message: string, exception?: any) => void): void;
|
|
|
+ /**
|
|
|
+ * Load a scene
|
|
|
+ * @param rootUrl a string that defines the root url for scene and resources
|
|
|
+ * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
|
|
|
+ * @param engine is the instance of BABYLON.Engine to use to create the scene
|
|
|
+ */
|
|
|
+ static Load(rootUrl: string, sceneFilename: any, engine: Engine, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
|
|
|
+ /**
|
|
|
+ * Append a scene
|
|
|
+ * @param rootUrl a string that defines the root url for scene and resources
|
|
|
+ * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
|
|
|
+ * @param scene is the instance of BABYLON.Scene to append to
|
|
|
+ */
|
|
|
+ static Append(rootUrl: string, sceneFilename: any, scene: Scene, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
class DirectionalLight extends Light implements IShadowLight {
|
|
|
position: Vector3;
|
|
|
direction: Vector3;
|
|
|
@@ -4793,58 +4846,6 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
- interface ISceneLoaderPluginExtensions {
|
|
|
- [extension: string]: {
|
|
|
- isBinary: boolean;
|
|
|
- };
|
|
|
- }
|
|
|
- interface ISceneLoaderPlugin {
|
|
|
- extensions: string | ISceneLoaderPluginExtensions;
|
|
|
- importMesh: (meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => boolean;
|
|
|
- load: (scene: Scene, data: string, rootUrl: string) => boolean;
|
|
|
- }
|
|
|
- interface ISceneLoaderPluginAsync {
|
|
|
- extensions: string | ISceneLoaderPluginExtensions;
|
|
|
- importMeshAsync: (meshesNames: any, scene: Scene, data: any, rootUrl: string, onsuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onerror: () => void) => void;
|
|
|
- loadAsync: (scene: Scene, data: string, rootUrl: string, onsuccess: () => void, onerror: () => void) => void;
|
|
|
- }
|
|
|
- class SceneLoader {
|
|
|
- private static _ForceFullSceneLoadingForIncremental;
|
|
|
- private static _ShowLoadingScreen;
|
|
|
- static readonly NO_LOGGING: number;
|
|
|
- static readonly MINIMAL_LOGGING: number;
|
|
|
- static readonly SUMMARY_LOGGING: number;
|
|
|
- static readonly DETAILED_LOGGING: number;
|
|
|
- private static _loggingLevel;
|
|
|
- static ForceFullSceneLoadingForIncremental: boolean;
|
|
|
- static ShowLoadingScreen: boolean;
|
|
|
- static loggingLevel: number;
|
|
|
- private static _registeredPlugins;
|
|
|
- private static _getDefaultPlugin();
|
|
|
- private static _getPluginForExtension(extension);
|
|
|
- private static _getPluginForFilename(sceneFilename);
|
|
|
- private static _getDirectLoad(sceneFilename);
|
|
|
- static GetPluginForExtension(extension: string): ISceneLoaderPlugin | ISceneLoaderPluginAsync;
|
|
|
- static RegisterPlugin(plugin: ISceneLoaderPlugin | ISceneLoaderPluginAsync): void;
|
|
|
- static ImportMesh(meshesNames: any, rootUrl: string, sceneFilename: string, scene: Scene, onsuccess?: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, progressCallBack?: () => void, onerror?: (scene: Scene, message: string, exception?: any) => void): void;
|
|
|
- /**
|
|
|
- * Load a scene
|
|
|
- * @param rootUrl a string that defines the root url for scene and resources
|
|
|
- * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
|
|
|
- * @param engine is the instance of BABYLON.Engine to use to create the scene
|
|
|
- */
|
|
|
- static Load(rootUrl: string, sceneFilename: any, engine: Engine, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
|
|
|
- /**
|
|
|
- * Append a scene
|
|
|
- * @param rootUrl a string that defines the root url for scene and resources
|
|
|
- * @param sceneFilename a string that defines the name of the scene file. can start with "data:" following by the stringified version of the scene
|
|
|
- * @param scene is the instance of BABYLON.Scene to append to
|
|
|
- */
|
|
|
- static Append(rootUrl: string, sceneFilename: any, scene: Scene, onsuccess?: (scene: Scene) => void, progressCallBack?: any, onerror?: (scene: Scene) => void): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
/**
|
|
|
* The color grading curves provide additional color adjustmnent that is applied after any color grading transform (3D LUT).
|
|
|
* They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
|
|
|
@@ -7997,60 +7998,6 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
- class MorphTarget {
|
|
|
- name: string;
|
|
|
- private _positions;
|
|
|
- private _normals;
|
|
|
- private _influence;
|
|
|
- onInfluenceChanged: Observable<boolean>;
|
|
|
- influence: number;
|
|
|
- constructor(name: string, influence?: number);
|
|
|
- readonly hasNormals: boolean;
|
|
|
- setPositions(data: Float32Array | number[]): void;
|
|
|
- getPositions(): Float32Array;
|
|
|
- setNormals(data: Float32Array | number[]): void;
|
|
|
- getNormals(): Float32Array;
|
|
|
- /**
|
|
|
- * Serializes the current target into a Serialization object.
|
|
|
- * Returns the serialized object.
|
|
|
- */
|
|
|
- serialize(): any;
|
|
|
- static Parse(serializationObject: any): MorphTarget;
|
|
|
- static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
- class MorphTargetManager {
|
|
|
- private _targets;
|
|
|
- private _targetObservable;
|
|
|
- private _activeTargets;
|
|
|
- private _scene;
|
|
|
- private _influences;
|
|
|
- private _supportsNormals;
|
|
|
- private _vertexCount;
|
|
|
- private _uniqueId;
|
|
|
- constructor(scene?: Scene);
|
|
|
- readonly uniqueId: number;
|
|
|
- readonly vertexCount: number;
|
|
|
- readonly supportsNormals: boolean;
|
|
|
- readonly numInfluencers: number;
|
|
|
- readonly influences: Float32Array;
|
|
|
- getActiveTarget(index: number): MorphTarget;
|
|
|
- addTarget(target: MorphTarget): void;
|
|
|
- removeTarget(target: MorphTarget): void;
|
|
|
- /**
|
|
|
- * Serializes the current manager into a Serialization object.
|
|
|
- * Returns the serialized object.
|
|
|
- */
|
|
|
- serialize(): any;
|
|
|
- private _onInfluenceChanged(needUpdate);
|
|
|
- private _syncActiveTargets(needUpdate);
|
|
|
- static Parse(serializationObject: any, scene: Scene): MorphTargetManager;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
class AbstractMesh extends Node implements IDisposable, ICullable, IGetSetVerticesData {
|
|
|
private static _BILLBOARDMODE_NONE;
|
|
|
private static _BILLBOARDMODE_X;
|
|
|
@@ -11272,6 +11219,60 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+ class MorphTarget {
|
|
|
+ name: string;
|
|
|
+ private _positions;
|
|
|
+ private _normals;
|
|
|
+ private _influence;
|
|
|
+ onInfluenceChanged: Observable<boolean>;
|
|
|
+ influence: number;
|
|
|
+ constructor(name: string, influence?: number);
|
|
|
+ readonly hasNormals: boolean;
|
|
|
+ setPositions(data: Float32Array | number[]): void;
|
|
|
+ getPositions(): Float32Array;
|
|
|
+ setNormals(data: Float32Array | number[]): void;
|
|
|
+ getNormals(): Float32Array;
|
|
|
+ /**
|
|
|
+ * Serializes the current target into a Serialization object.
|
|
|
+ * Returns the serialized object.
|
|
|
+ */
|
|
|
+ serialize(): any;
|
|
|
+ static Parse(serializationObject: any): MorphTarget;
|
|
|
+ static FromMesh(mesh: AbstractMesh, name?: string, influence?: number): MorphTarget;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class MorphTargetManager {
|
|
|
+ private _targets;
|
|
|
+ private _targetObservable;
|
|
|
+ private _activeTargets;
|
|
|
+ private _scene;
|
|
|
+ private _influences;
|
|
|
+ private _supportsNormals;
|
|
|
+ private _vertexCount;
|
|
|
+ private _uniqueId;
|
|
|
+ constructor(scene?: Scene);
|
|
|
+ readonly uniqueId: number;
|
|
|
+ readonly vertexCount: number;
|
|
|
+ readonly supportsNormals: boolean;
|
|
|
+ readonly numInfluencers: number;
|
|
|
+ readonly influences: Float32Array;
|
|
|
+ getActiveTarget(index: number): MorphTarget;
|
|
|
+ addTarget(target: MorphTarget): void;
|
|
|
+ removeTarget(target: MorphTarget): void;
|
|
|
+ /**
|
|
|
+ * Serializes the current manager into a Serialization object.
|
|
|
+ * Returns the serialized object.
|
|
|
+ */
|
|
|
+ serialize(): any;
|
|
|
+ private _onInfluenceChanged(needUpdate);
|
|
|
+ private _syncActiveTargets(needUpdate);
|
|
|
+ static Parse(serializationObject: any, scene: Scene): MorphTargetManager;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
class Particle {
|
|
|
position: Vector3;
|
|
|
direction: Vector3;
|
|
|
@@ -14865,6 +14866,9 @@ declare module BABYLON {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+declare module BABYLON.Internals {
|
|
|
+}
|
|
|
+
|
|
|
declare module BABYLON {
|
|
|
interface IShadowGenerator {
|
|
|
getShadowMap(): RenderTargetTexture;
|
|
|
@@ -14978,9 +14982,6 @@ declare module BABYLON {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-declare module BABYLON.Internals {
|
|
|
-}
|
|
|
-
|
|
|
declare module BABYLON {
|
|
|
class BaseTexture {
|
|
|
name: string;
|
David Catuhe
