|
|
@@ -2202,7 +2202,7 @@ declare module BABYLON {
|
|
|
_rebuildTextures(): void;
|
|
|
createDefaultCameraOrLight(createArcRotateCamera?: boolean, replace?: boolean, attachCameraControls?: boolean): void;
|
|
|
createDefaultSkybox(environmentTexture?: BaseTexture, pbr?: boolean, scale?: number, blur?: number): Mesh;
|
|
|
- createDefaultVRExperience(): void;
|
|
|
+ createDefaultVRExperience(webVROptions?: WebVROptions): void;
|
|
|
private _getByTags(list, tagsQuery, forEach?);
|
|
|
getMeshesByTags(tagsQuery: string, forEach?: (mesh: AbstractMesh) => void): Mesh[];
|
|
|
getCamerasByTags(tagsQuery: string, forEach?: (camera: Camera) => void): Camera[];
|
|
|
@@ -2298,6 +2298,7 @@ declare module BABYLON {
|
|
|
targetType: string;
|
|
|
value: string;
|
|
|
};
|
|
|
+<<<<<<< HEAD
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -2638,6 +2639,283 @@ declare module BABYLON {
|
|
|
restart(): void;
|
|
|
stop(animationName?: string): void;
|
|
|
_animate(delay: number): boolean;
|
|
|
+=======
|
|
|
+>>>>>>> 19d2adf834725b080fd4d343b09b45539f1a64a9
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class AnimationRange {
|
|
|
+ name: string;
|
|
|
+ from: number;
|
|
|
+ to: number;
|
|
|
+ constructor(name: string, from: number, to: number);
|
|
|
+ clone(): AnimationRange;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Composed of a frame, and an action function
|
|
|
+ */
|
|
|
+ class AnimationEvent {
|
|
|
+ frame: number;
|
|
|
+ action: () => void;
|
|
|
+ onlyOnce: boolean;
|
|
|
+ isDone: boolean;
|
|
|
+ constructor(frame: number, action: () => void, onlyOnce?: boolean);
|
|
|
+ }
|
|
|
+ class PathCursor {
|
|
|
+ private path;
|
|
|
+ private _onchange;
|
|
|
+ value: number;
|
|
|
+ animations: Animation[];
|
|
|
+ constructor(path: Path2);
|
|
|
+ getPoint(): Vector3;
|
|
|
+ moveAhead(step?: number): PathCursor;
|
|
|
+ moveBack(step?: number): PathCursor;
|
|
|
+ move(step: number): PathCursor;
|
|
|
+ private ensureLimits();
|
|
|
+ private markAsDirty(propertyName);
|
|
|
+ private raiseOnChange();
|
|
|
+ onchange(f: (cursor: PathCursor) => void): PathCursor;
|
|
|
+ }
|
|
|
+ class Animation {
|
|
|
+ name: string;
|
|
|
+ targetProperty: string;
|
|
|
+ framePerSecond: number;
|
|
|
+ dataType: number;
|
|
|
+ loopMode: number;
|
|
|
+ enableBlending: boolean;
|
|
|
+ static AllowMatricesInterpolation: boolean;
|
|
|
+ private _keys;
|
|
|
+ private _easingFunction;
|
|
|
+ _runtimeAnimations: RuntimeAnimation[];
|
|
|
+ private _events;
|
|
|
+ targetPropertyPath: string[];
|
|
|
+ blendingSpeed: number;
|
|
|
+ private _ranges;
|
|
|
+ static _PrepareAnimation(name: string, targetProperty: string, framePerSecond: number, totalFrame: number, from: any, to: any, loopMode?: number, easingFunction?: EasingFunction): Animation;
|
|
|
+ /**
|
|
|
+ * Sets up an animation.
|
|
|
+ * @param property the property to animate
|
|
|
+ * @param animationType the animation type to apply
|
|
|
+ * @param easingFunction the easing function used in the animation
|
|
|
+ * @returns The created animation
|
|
|
+ */
|
|
|
+ static CreateAnimation(property: string, animationType: number, framePerSecond: number, easingFunction: BABYLON.EasingFunction): BABYLON.Animation;
|
|
|
+ static CreateAndStartAnimation(name: string, node: Node, targetProperty: string, framePerSecond: number, totalFrame: number, from: any, to: any, loopMode?: number, easingFunction?: EasingFunction, onAnimationEnd?: () => void): Animatable;
|
|
|
+ static CreateMergeAndStartAnimation(name: string, node: Node, targetProperty: string, framePerSecond: number, totalFrame: number, from: any, to: any, loopMode?: number, easingFunction?: EasingFunction, onAnimationEnd?: () => void): Animatable;
|
|
|
+ /**
|
|
|
+ * Transition property of the Camera to the target Value.
|
|
|
+ * @param property The property to transition
|
|
|
+ * @param targetValue The target Value of the property
|
|
|
+ * @param host The object where the property to animate belongs
|
|
|
+ * @param scene Scene used to run the animation
|
|
|
+ * @param frameRate Framerate (in frame/s) to use
|
|
|
+ * @param transition The transition type we want to use
|
|
|
+ * @param duration The duration of the animation, in milliseconds
|
|
|
+ * @param onAnimationEnd Call back trigger at the end of the animation.
|
|
|
+ */
|
|
|
+ static TransitionTo(property: string, targetValue: any, host: any, scene: Scene, frameRate: number, transition: Animation, duration: number, onAnimationEnd?: () => void): Animatable;
|
|
|
+ /**
|
|
|
+ * Return the array of runtime animations currently using this animation
|
|
|
+ */
|
|
|
+ readonly runtimeAnimations: RuntimeAnimation[];
|
|
|
+ readonly hasRunningRuntimeAnimations: boolean;
|
|
|
+ constructor(name: string, targetProperty: string, framePerSecond: number, dataType: number, loopMode?: number, enableBlending?: boolean);
|
|
|
+ /**
|
|
|
+ * @param {boolean} fullDetails - support for multiple levels of logging within scene loading
|
|
|
+ */
|
|
|
+ toString(fullDetails?: boolean): string;
|
|
|
+ /**
|
|
|
+ * Add an event to this animation.
|
|
|
+ */
|
|
|
+ addEvent(event: AnimationEvent): void;
|
|
|
+ /**
|
|
|
+ * Remove all events found at the given frame
|
|
|
+ * @param frame
|
|
|
+ */
|
|
|
+ removeEvents(frame: number): void;
|
|
|
+ getEvents(): AnimationEvent[];
|
|
|
+ createRange(name: string, from: number, to: number): void;
|
|
|
+ deleteRange(name: string, deleteFrames?: boolean): void;
|
|
|
+ getRange(name: string): AnimationRange;
|
|
|
+ getKeys(): Array<{
|
|
|
+ frame: number;
|
|
|
+ value: any;
|
|
|
+ inTangent?: any;
|
|
|
+ outTangent?: any;
|
|
|
+ }>;
|
|
|
+ getHighestFrame(): number;
|
|
|
+ getEasingFunction(): IEasingFunction;
|
|
|
+ setEasingFunction(easingFunction: EasingFunction): void;
|
|
|
+ floatInterpolateFunction(startValue: number, endValue: number, gradient: number): number;
|
|
|
+ floatInterpolateFunctionWithTangents(startValue: number, outTangent: number, endValue: number, inTangent: number, gradient: number): number;
|
|
|
+ quaternionInterpolateFunction(startValue: Quaternion, endValue: Quaternion, gradient: number): Quaternion;
|
|
|
+ quaternionInterpolateFunctionWithTangents(startValue: Quaternion, outTangent: Quaternion, endValue: Quaternion, inTangent: Quaternion, gradient: number): Quaternion;
|
|
|
+ vector3InterpolateFunction(startValue: Vector3, endValue: Vector3, gradient: number): Vector3;
|
|
|
+ vector3InterpolateFunctionWithTangents(startValue: Vector3, outTangent: Vector3, endValue: Vector3, inTangent: Vector3, gradient: number): Vector3;
|
|
|
+ vector2InterpolateFunction(startValue: Vector2, endValue: Vector2, gradient: number): Vector2;
|
|
|
+ vector2InterpolateFunctionWithTangents(startValue: Vector2, outTangent: Vector2, endValue: Vector2, inTangent: Vector2, gradient: number): Vector2;
|
|
|
+ sizeInterpolateFunction(startValue: Size, endValue: Size, gradient: number): Size;
|
|
|
+ color3InterpolateFunction(startValue: Color3, endValue: Color3, gradient: number): Color3;
|
|
|
+ matrixInterpolateFunction(startValue: Matrix, endValue: Matrix, gradient: number): Matrix;
|
|
|
+ clone(): Animation;
|
|
|
+ setKeys(values: Array<{
|
|
|
+ frame: number;
|
|
|
+ value: any;
|
|
|
+ }>): void;
|
|
|
+ serialize(): any;
|
|
|
+ private static _ANIMATIONTYPE_FLOAT;
|
|
|
+ private static _ANIMATIONTYPE_VECTOR3;
|
|
|
+ private static _ANIMATIONTYPE_QUATERNION;
|
|
|
+ private static _ANIMATIONTYPE_MATRIX;
|
|
|
+ private static _ANIMATIONTYPE_COLOR3;
|
|
|
+ private static _ANIMATIONTYPE_VECTOR2;
|
|
|
+ private static _ANIMATIONTYPE_SIZE;
|
|
|
+ private static _ANIMATIONLOOPMODE_RELATIVE;
|
|
|
+ private static _ANIMATIONLOOPMODE_CYCLE;
|
|
|
+ private static _ANIMATIONLOOPMODE_CONSTANT;
|
|
|
+ static readonly ANIMATIONTYPE_FLOAT: number;
|
|
|
+ static readonly ANIMATIONTYPE_VECTOR3: number;
|
|
|
+ static readonly ANIMATIONTYPE_VECTOR2: number;
|
|
|
+ static readonly ANIMATIONTYPE_SIZE: number;
|
|
|
+ static readonly ANIMATIONTYPE_QUATERNION: number;
|
|
|
+ static readonly ANIMATIONTYPE_MATRIX: number;
|
|
|
+ static readonly ANIMATIONTYPE_COLOR3: number;
|
|
|
+ static readonly ANIMATIONLOOPMODE_RELATIVE: number;
|
|
|
+ static readonly ANIMATIONLOOPMODE_CYCLE: number;
|
|
|
+ static readonly ANIMATIONLOOPMODE_CONSTANT: number;
|
|
|
+ static Parse(parsedAnimation: any): Animation;
|
|
|
+ static AppendSerializedAnimations(source: IAnimatable, destination: any): any;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ interface IEasingFunction {
|
|
|
+ ease(gradient: number): number;
|
|
|
+ }
|
|
|
+ class EasingFunction implements IEasingFunction {
|
|
|
+ private static _EASINGMODE_EASEIN;
|
|
|
+ private static _EASINGMODE_EASEOUT;
|
|
|
+ private static _EASINGMODE_EASEINOUT;
|
|
|
+ static readonly EASINGMODE_EASEIN: number;
|
|
|
+ static readonly EASINGMODE_EASEOUT: number;
|
|
|
+ static readonly EASINGMODE_EASEINOUT: number;
|
|
|
+ private _easingMode;
|
|
|
+ setEasingMode(easingMode: number): void;
|
|
|
+ getEasingMode(): number;
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ ease(gradient: number): number;
|
|
|
+ }
|
|
|
+ class CircleEase extends EasingFunction implements IEasingFunction {
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class BackEase extends EasingFunction implements IEasingFunction {
|
|
|
+ amplitude: number;
|
|
|
+ constructor(amplitude?: number);
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class BounceEase extends EasingFunction implements IEasingFunction {
|
|
|
+ bounces: number;
|
|
|
+ bounciness: number;
|
|
|
+ constructor(bounces?: number, bounciness?: number);
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class CubicEase extends EasingFunction implements IEasingFunction {
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class ElasticEase extends EasingFunction implements IEasingFunction {
|
|
|
+ oscillations: number;
|
|
|
+ springiness: number;
|
|
|
+ constructor(oscillations?: number, springiness?: number);
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class ExponentialEase extends EasingFunction implements IEasingFunction {
|
|
|
+ exponent: number;
|
|
|
+ constructor(exponent?: number);
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class PowerEase extends EasingFunction implements IEasingFunction {
|
|
|
+ power: number;
|
|
|
+ constructor(power?: number);
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class QuadraticEase extends EasingFunction implements IEasingFunction {
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class QuarticEase extends EasingFunction implements IEasingFunction {
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class QuinticEase extends EasingFunction implements IEasingFunction {
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class SineEase extends EasingFunction implements IEasingFunction {
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+ class BezierCurveEase extends EasingFunction implements IEasingFunction {
|
|
|
+ x1: number;
|
|
|
+ y1: number;
|
|
|
+ x2: number;
|
|
|
+ y2: number;
|
|
|
+ constructor(x1?: number, y1?: number, x2?: number, y2?: number);
|
|
|
+ easeInCore(gradient: number): number;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class RuntimeAnimation {
|
|
|
+ currentFrame: number;
|
|
|
+ private _animation;
|
|
|
+ private _target;
|
|
|
+ private _originalBlendValue;
|
|
|
+ private _offsetsCache;
|
|
|
+ private _highLimitsCache;
|
|
|
+ private _stopped;
|
|
|
+ private _blendingFactor;
|
|
|
+ constructor(target: any, animation: Animation);
|
|
|
+ readonly animation: Animation;
|
|
|
+ reset(): void;
|
|
|
+ isStopped(): boolean;
|
|
|
+ dispose(): void;
|
|
|
+ private _getKeyValue(value);
|
|
|
+ private _interpolate(currentFrame, repeatCount, loopMode, offsetValue?, highLimitValue?);
|
|
|
+ setValue(currentValue: any, blend?: boolean): void;
|
|
|
+ goToFrame(frame: number): void;
|
|
|
+ _prepareForSpeedRatioChange(newSpeedRatio: number): void;
|
|
|
+ private _ratioOffset;
|
|
|
+ private _previousDelay;
|
|
|
+ private _previousRatio;
|
|
|
+ animate(delay: number, from: number, to: number, loop: boolean, speedRatio: number, blend?: boolean): boolean;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class Animatable {
|
|
|
+ target: any;
|
|
|
+ fromFrame: number;
|
|
|
+ toFrame: number;
|
|
|
+ loopAnimation: boolean;
|
|
|
+ onAnimationEnd: any;
|
|
|
+ private _localDelayOffset;
|
|
|
+ private _pausedDelay;
|
|
|
+ private _runtimeAnimations;
|
|
|
+ private _paused;
|
|
|
+ private _scene;
|
|
|
+ private _speedRatio;
|
|
|
+ animationStarted: boolean;
|
|
|
+ speedRatio: number;
|
|
|
+ constructor(scene: Scene, target: any, fromFrame?: number, toFrame?: number, loopAnimation?: boolean, speedRatio?: number, onAnimationEnd?: any, animations?: any);
|
|
|
+ getAnimations(): RuntimeAnimation[];
|
|
|
+ appendAnimations(target: any, animations: Animation[]): void;
|
|
|
+ getAnimationByTargetProperty(property: string): Animation;
|
|
|
+ getRuntimeAnimationByTargetProperty(property: string): RuntimeAnimation;
|
|
|
+ reset(): void;
|
|
|
+ enableBlending(blendingSpeed: number): void;
|
|
|
+ disableBlending(): void;
|
|
|
+ goToFrame(frame: number): void;
|
|
|
+ pause(): void;
|
|
|
+ restart(): void;
|
|
|
+ stop(animationName?: string): void;
|
|
|
+ _animate(delay: number): boolean;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -3068,14 +3346,6 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
- interface Behavior<T extends Node> {
|
|
|
- name: string;
|
|
|
- attach(node: T): void;
|
|
|
- detach(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
class Bone extends Node {
|
|
|
name: string;
|
|
|
private static _tmpVecs;
|
|
|
@@ -3557,6 +3827,17 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+<<<<<<< HEAD
|
|
|
+ interface Behavior<T extends Node> {
|
|
|
+ name: string;
|
|
|
+ attach(node: T): void;
|
|
|
+ detach(): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+=======
|
|
|
+>>>>>>> 19d2adf834725b080fd4d343b09b45539f1a64a9
|
|
|
class ArcRotateCamera extends TargetCamera {
|
|
|
alpha: number;
|
|
|
beta: number;
|
|
|
@@ -4397,51 +4678,182 @@ declare module BABYLON {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-declare module BABYLON {
|
|
|
- class Ray {
|
|
|
- origin: Vector3;
|
|
|
- direction: Vector3;
|
|
|
- length: number;
|
|
|
- private _edge1;
|
|
|
- private _edge2;
|
|
|
- private _pvec;
|
|
|
- private _tvec;
|
|
|
- private _qvec;
|
|
|
- private _tmpRay;
|
|
|
- private _rayHelper;
|
|
|
- constructor(origin: Vector3, direction: Vector3, length?: number);
|
|
|
- intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
|
|
|
- intersectsBox(box: BoundingBox): boolean;
|
|
|
- intersectsSphere(sphere: BoundingSphere): boolean;
|
|
|
- intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
|
|
|
- intersectsPlane(plane: Plane): number;
|
|
|
- intersectsMesh(mesh: AbstractMesh, fastCheck?: boolean): PickingInfo;
|
|
|
- intersectsMeshes(meshes: Array<AbstractMesh>, fastCheck?: boolean, results?: Array<PickingInfo>): Array<PickingInfo>;
|
|
|
- private _comparePickingInfo(pickingInfoA, pickingInfoB);
|
|
|
- private static smallnum;
|
|
|
- private static rayl;
|
|
|
- /**
|
|
|
- * Intersection test between the ray and a given segment whithin a given tolerance (threshold)
|
|
|
- * @param sega the first point of the segment to test the intersection against
|
|
|
- * @param segb the second point of the segment to test the intersection against
|
|
|
- * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
|
|
|
- * @return the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
|
|
|
- */
|
|
|
- intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): number;
|
|
|
- static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
|
|
|
- /**
|
|
|
- * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
|
|
|
- * transformed to the given world matrix.
|
|
|
- * @param origin The origin point
|
|
|
- * @param end The end point
|
|
|
- * @param world a matrix to transform the ray to. Default is the identity matrix.
|
|
|
- */
|
|
|
- static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
|
|
|
- static Transform(ray: Ray, matrix: Matrix): Ray;
|
|
|
- static TransformToRef(ray: Ray, matrix: Matrix, result: Ray): void;
|
|
|
+declare module BABYLON {
|
|
|
+ class Ray {
|
|
|
+ origin: Vector3;
|
|
|
+ direction: Vector3;
|
|
|
+ length: number;
|
|
|
+ private _edge1;
|
|
|
+ private _edge2;
|
|
|
+ private _pvec;
|
|
|
+ private _tvec;
|
|
|
+ private _qvec;
|
|
|
+ private _tmpRay;
|
|
|
+ private _rayHelper;
|
|
|
+ constructor(origin: Vector3, direction: Vector3, length?: number);
|
|
|
+ intersectsBoxMinMax(minimum: Vector3, maximum: Vector3): boolean;
|
|
|
+ intersectsBox(box: BoundingBox): boolean;
|
|
|
+ intersectsSphere(sphere: BoundingSphere): boolean;
|
|
|
+ intersectsTriangle(vertex0: Vector3, vertex1: Vector3, vertex2: Vector3): IntersectionInfo;
|
|
|
+ intersectsPlane(plane: Plane): number;
|
|
|
+ intersectsMesh(mesh: AbstractMesh, fastCheck?: boolean): PickingInfo;
|
|
|
+ intersectsMeshes(meshes: Array<AbstractMesh>, fastCheck?: boolean, results?: Array<PickingInfo>): Array<PickingInfo>;
|
|
|
+ private _comparePickingInfo(pickingInfoA, pickingInfoB);
|
|
|
+ private static smallnum;
|
|
|
+ private static rayl;
|
|
|
+ /**
|
|
|
+ * Intersection test between the ray and a given segment whithin a given tolerance (threshold)
|
|
|
+ * @param sega the first point of the segment to test the intersection against
|
|
|
+ * @param segb the second point of the segment to test the intersection against
|
|
|
+ * @param threshold the tolerance margin, if the ray doesn't intersect the segment but is close to the given threshold, the intersection is successful
|
|
|
+ * @return the distance from the ray origin to the intersection point if there's intersection, or -1 if there's no intersection
|
|
|
+ */
|
|
|
+ intersectionSegment(sega: Vector3, segb: Vector3, threshold: number): number;
|
|
|
+ static CreateNew(x: number, y: number, viewportWidth: number, viewportHeight: number, world: Matrix, view: Matrix, projection: Matrix): Ray;
|
|
|
+ /**
|
|
|
+ * Function will create a new transformed ray starting from origin and ending at the end point. Ray's length will be set, and ray will be
|
|
|
+ * transformed to the given world matrix.
|
|
|
+ * @param origin The origin point
|
|
|
+ * @param end The end point
|
|
|
+ * @param world a matrix to transform the ray to. Default is the identity matrix.
|
|
|
+ */
|
|
|
+ static CreateNewFromTo(origin: Vector3, end: Vector3, world?: Matrix): Ray;
|
|
|
+ static Transform(ray: Ray, matrix: Matrix): Ray;
|
|
|
+ static TransformToRef(ray: Ray, matrix: Matrix, result: Ray): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+<<<<<<< HEAD
|
|
|
+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.Debug {
|
|
|
+ class PhysicsViewer {
|
|
|
+ protected _impostors: Array<PhysicsImpostor>;
|
|
|
+ protected _meshes: Array<AbstractMesh>;
|
|
|
+ protected _scene: Scene;
|
|
|
+ protected _numMeshes: number;
|
|
|
+ protected _physicsEnginePlugin: IPhysicsEnginePlugin;
|
|
|
+ private _renderFunction;
|
|
|
+ private _debugBoxMesh;
|
|
|
+ private _debugSphereMesh;
|
|
|
+ private _debugMaterial;
|
|
|
+ constructor(scene: Scene);
|
|
|
+ protected _updateDebugMeshes(): void;
|
|
|
+ showImpostor(impostor: PhysicsImpostor): void;
|
|
|
+ hideImpostor(impostor: PhysicsImpostor): void;
|
|
|
+ private _getDebugMaterial(scene);
|
|
|
+ private _getDebugBoxMesh(scene);
|
|
|
+ private _getDebugSphereMesh(scene);
|
|
|
+ private _getDebugMesh(impostor, scene);
|
|
|
+ dispose(): 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;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+=======
|
|
|
+>>>>>>> 19d2adf834725b080fd4d343b09b45539f1a64a9
|
|
|
declare module BABYLON {
|
|
|
class KeyboardEventTypes {
|
|
|
static _KEYDOWN: number;
|
|
|
@@ -5046,6 +5458,51 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+ class LensFlare {
|
|
|
+ size: number;
|
|
|
+ position: number;
|
|
|
+ color: Color3;
|
|
|
+ texture: Texture;
|
|
|
+ alphaMode: number;
|
|
|
+ private _system;
|
|
|
+ constructor(size: number, position: number, color: any, imgUrl: string, system: LensFlareSystem);
|
|
|
+ dispose: () => void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
+ class LensFlareSystem {
|
|
|
+ name: string;
|
|
|
+ lensFlares: LensFlare[];
|
|
|
+ borderLimit: number;
|
|
|
+ viewportBorder: number;
|
|
|
+ meshesSelectionPredicate: (mesh: Mesh) => boolean;
|
|
|
+ layerMask: number;
|
|
|
+ id: string;
|
|
|
+ private _scene;
|
|
|
+ private _emitter;
|
|
|
+ private _vertexBuffers;
|
|
|
+ private _indexBuffer;
|
|
|
+ private _effect;
|
|
|
+ private _positionX;
|
|
|
+ private _positionY;
|
|
|
+ private _isEnabled;
|
|
|
+ constructor(name: string, emitter: any, scene: Scene);
|
|
|
+ isEnabled: boolean;
|
|
|
+ getScene(): Scene;
|
|
|
+ getEmitter(): any;
|
|
|
+ setEmitter(newEmitter: any): void;
|
|
|
+ getEmitterPosition(): Vector3;
|
|
|
+ computeEffectivePosition(globalViewport: Viewport): boolean;
|
|
|
+ _isVisible(): boolean;
|
|
|
+ render(): boolean;
|
|
|
+ dispose(): void;
|
|
|
+ static Parse(parsedLensFlareSystem: any, scene: Scene, rootUrl: string): LensFlareSystem;
|
|
|
+ serialize(): any;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
class DirectionalLight extends ShadowLight {
|
|
|
private _shadowFrustumSize;
|
|
|
/**
|
|
|
@@ -12755,6 +13212,70 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+ class MorphTarget {
|
|
|
+ name: string;
|
|
|
+ animations: Animation[];
|
|
|
+ private _positions;
|
|
|
+ private _normals;
|
|
|
+ private _tangents;
|
|
|
+ private _influence;
|
|
|
+ onInfluenceChanged: Observable<boolean>;
|
|
|
+ influence: number;
|
|
|
+ constructor(name: string, influence?: number);
|
|
|
+ readonly hasNormals: boolean;
|
|
|
+ readonly hasTangents: boolean;
|
|
|
+ setPositions(data: Float32Array | number[]): void;
|
|
|
+ getPositions(): Float32Array;
|
|
|
+ setNormals(data: Float32Array | number[]): void;
|
|
|
+ getNormals(): Float32Array;
|
|
|
+ setTangents(data: Float32Array | number[]): void;
|
|
|
+ getTangents(): 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 _supportsTangents;
|
|
|
+ private _vertexCount;
|
|
|
+ private _uniqueId;
|
|
|
+ private _tempInfluences;
|
|
|
+ constructor(scene?: Scene);
|
|
|
+ readonly uniqueId: number;
|
|
|
+ readonly vertexCount: number;
|
|
|
+ readonly supportsNormals: boolean;
|
|
|
+ readonly supportsTangents: boolean;
|
|
|
+ readonly numTargets: number;
|
|
|
+ readonly numInfluencers: number;
|
|
|
+ readonly influences: Float32Array;
|
|
|
+ getActiveTarget(index: number): MorphTarget;
|
|
|
+ getTarget(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 GPUParticleSystem implements IDisposable, IParticleSystem {
|
|
|
name: string;
|
|
|
id: string;
|
|
|
@@ -13676,6 +14197,36 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
+ class ReflectionProbe {
|
|
|
+ name: string;
|
|
|
+ private _scene;
|
|
|
+ private _renderTargetTexture;
|
|
|
+ private _projectionMatrix;
|
|
|
+ private _viewMatrix;
|
|
|
+ private _target;
|
|
|
+ private _add;
|
|
|
+ private _attachedMesh;
|
|
|
+ invertYAxis: boolean;
|
|
|
+ position: Vector3;
|
|
|
+ constructor(name: string, size: number, scene: Scene, generateMipMaps?: boolean);
|
|
|
+ samples: number;
|
|
|
+ refreshRate: number;
|
|
|
+ getScene(): Scene;
|
|
|
+ readonly cubeTexture: RenderTargetTexture;
|
|
|
+ readonly renderList: AbstractMesh[];
|
|
|
+ attachToMesh(mesh: AbstractMesh): void;
|
|
|
+ /**
|
|
|
+ * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
|
|
|
+ *
|
|
|
+ * @param renderingGroupId The rendering group id corresponding to its index
|
|
|
+ * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
|
|
|
+ */
|
|
|
+ setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void;
|
|
|
+ dispose(): void;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+declare module BABYLON {
|
|
|
class AnaglyphPostProcess extends PostProcess {
|
|
|
private _passedProcess;
|
|
|
constructor(name: string, options: number | PostProcessOptions, rigCameras: Camera[], samplingMode?: number, engine?: Engine, reusable?: boolean);
|
|
|
@@ -14202,36 +14753,6 @@ declare module BABYLON {
|
|
|
}
|
|
|
|
|
|
declare module BABYLON {
|
|
|
- class ReflectionProbe {
|
|
|
- name: string;
|
|
|
- private _scene;
|
|
|
- private _renderTargetTexture;
|
|
|
- private _projectionMatrix;
|
|
|
- private _viewMatrix;
|
|
|
- private _target;
|
|
|
- private _add;
|
|
|
- private _attachedMesh;
|
|
|
- invertYAxis: boolean;
|
|
|
- position: Vector3;
|
|
|
- constructor(name: string, size: number, scene: Scene, generateMipMaps?: boolean);
|
|
|
- samples: number;
|
|
|
- refreshRate: number;
|
|
|
- getScene(): Scene;
|
|
|
- readonly cubeTexture: RenderTargetTexture;
|
|
|
- readonly renderList: AbstractMesh[];
|
|
|
- attachToMesh(mesh: AbstractMesh): void;
|
|
|
- /**
|
|
|
- * Specifies whether or not the stencil and depth buffer are cleared between two rendering groups.
|
|
|
- *
|
|
|
- * @param renderingGroupId The rendering group id corresponding to its index
|
|
|
- * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
|
|
|
- */
|
|
|
- setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void;
|
|
|
- dispose(): void;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-declare module BABYLON {
|
|
|
class BoundingBoxRenderer {
|
|
|
frontColor: Color3;
|
|
|
backColor: Color3;
|
|
|
@@ -16192,6 +16713,17 @@ declare module BABYLON {
|
|
|
private _clearAnimationLocks();
|
|
|
/**
|
|
|
* Applies any current user interaction to the camera. Takes into account maximum alpha rotation.
|
|
|
+<<<<<<< HEAD
|
|
|
+ */
|
|
|
+ private _applyUserInteraction();
|
|
|
+ /**
|
|
|
+ * Stops and removes all animations that have been applied to the camera
|
|
|
+ */
|
|
|
+ stopAllAnimations(): void;
|
|
|
+ /**
|
|
|
+ * Gets a value indicating if the user is moving the camera
|
|
|
+ */
|
|
|
+=======
|
|
|
*/
|
|
|
private _applyUserInteraction();
|
|
|
/**
|
|
|
@@ -16201,6 +16733,7 @@ declare module BABYLON {
|
|
|
/**
|
|
|
* Gets a value indicating if the user is moving the camera
|
|
|
*/
|
|
|
+>>>>>>> 19d2adf834725b080fd4d343b09b45539f1a64a9
|
|
|
readonly isUserIsMoving: boolean;
|
|
|
/**
|
|
|
* The camera can move all the way towards the mesh.
|
|
|
@@ -16497,7 +17030,16 @@ declare module BABYLON {
|
|
|
private _onVRDisplayChanged;
|
|
|
private _onVRRequestPresentStart;
|
|
|
private _onVRRequestPresentComplete;
|
|
|
+<<<<<<< HEAD
|
|
|
+ onEnteringVR: () => void;
|
|
|
+ onExitingVR: () => void;
|
|
|
+ onControllerMeshLoaded: (WebVRController) => void;
|
|
|
+ constructor(scene: Scene, webVROptions?: WebVROptions);
|
|
|
+ private _onDefaultMeshLoaded(webVRController);
|
|
|
+ private _onFullscreenChange();
|
|
|
+=======
|
|
|
constructor(scene: Scene, webVROptions?: WebVROptions);
|
|
|
+>>>>>>> 19d2adf834725b080fd4d343b09b45539f1a64a9
|
|
|
private isInVRMode();
|
|
|
private onVrDisplayPresentChange();
|
|
|
private onVRDisplayChanged(eventArgs);
|
|
|
@@ -16569,6 +17111,10 @@ declare module BABYLON {
|
|
|
deviceScaleFactor: number;
|
|
|
controllers: Array<WebVRController>;
|
|
|
onControllersAttachedObservable: Observable<WebVRController[]>;
|
|
|
+<<<<<<< HEAD
|
|
|
+ onControllerMeshLoadedObservable: Observable<WebVRController>;
|
|
|
+=======
|
|
|
+>>>>>>> 19d2adf834725b080fd4d343b09b45539f1a64a9
|
|
|
rigParenting: boolean;
|
|
|
private _lightOnControllers;
|
|
|
constructor(name: string, position: Vector3, scene: Scene, webVROptions?: WebVROptions);
|
David Catuhe