declare module 'babylonjs/bones' { class Bone extends Node { name: string; private static _tmpVecs; private static _tmpQuat; private static _tmpMats; children: Bone[]; animations: Animation[]; length: number; _index: Nullable; private _skeleton; private _localMatrix; private _restPose; private _baseMatrix; private _worldTransform; private _absoluteTransform; private _invertedAbsoluteTransform; private _parent; private _scaleMatrix; private _scaleVector; private _negateScaleChildren; private _scalingDeterminant; _matrix: Matrix; constructor(name: string, skeleton: Skeleton, parentBone?: Nullable, localMatrix?: Nullable, restPose?: Nullable, baseMatrix?: Nullable, index?: Nullable); getSkeleton(): Skeleton; getParent(): Nullable; setParent(parent: Nullable, updateDifferenceMatrix?: boolean): void; getLocalMatrix(): Matrix; getBaseMatrix(): Matrix; getRestPose(): Matrix; returnToRest(): void; getWorldMatrix(): Matrix; getInvertedAbsoluteTransform(): Matrix; getAbsoluteTransform(): Matrix; position: Vector3; rotation: Vector3; rotationQuaternion: Quaternion; scaling: Vector3; updateMatrix(matrix: Matrix, updateDifferenceMatrix?: boolean): void; _updateDifferenceMatrix(rootMatrix?: Matrix): void; markAsDirty(): void; copyAnimationRange(source: Bone, rangeName: string, frameOffset: number, rescaleAsRequired?: boolean, skelDimensionsRatio?: Nullable): boolean; /** * Translate the bone in local or world space. * @param vec The amount to translate the bone. * @param space The space that the translation is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ translate(vec: Vector3, space?: Space, mesh?: AbstractMesh): void; /** * Set the postion of the bone in local or world space. * @param position The position to set the bone. * @param space The space that the position is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ setPosition(position: Vector3, space?: Space, mesh?: AbstractMesh): void; /** * Set the absolute postion of the bone (world space). * @param position The position to set the bone. * @param mesh The mesh that this bone is attached to. */ setAbsolutePosition(position: Vector3, mesh?: AbstractMesh): void; /** * Set the scale of the bone on the x, y and z axes. * @param x The scale of the bone on the x axis. * @param x The scale of the bone on the y axis. * @param z The scale of the bone on the z axis. * @param scaleChildren Set this to true if children of the bone should be scaled. */ setScale(x: number, y: number, z: number, scaleChildren?: boolean): void; /** * Scale the bone on the x, y and z axes. * @param x The amount to scale the bone on the x axis. * @param x The amount to scale the bone on the y axis. * @param z The amount to scale the bone on the z axis. * @param scaleChildren Set this to true if children of the bone should be scaled. */ scale(x: number, y: number, z: number, scaleChildren?: boolean): void; /** * Set the yaw, pitch, and roll of the bone in local or world space. * @param yaw The rotation of the bone on the y axis. * @param pitch The rotation of the bone on the x axis. * @param roll The rotation of the bone on the z axis. * @param space The space that the axes of rotation are in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ setYawPitchRoll(yaw: number, pitch: number, roll: number, space?: Space, mesh?: AbstractMesh): void; /** * Rotate the bone on an axis in local or world space. * @param axis The axis to rotate the bone on. * @param amount The amount to rotate the bone. * @param space The space that the axis is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ rotate(axis: Vector3, amount: number, space?: Space, mesh?: AbstractMesh): void; /** * Set the rotation of the bone to a particular axis angle in local or world space. * @param axis The axis to rotate the bone on. * @param angle The angle that the bone should be rotated to. * @param space The space that the axis is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ setAxisAngle(axis: Vector3, angle: number, space?: Space, mesh?: AbstractMesh): void; /** * Set the euler rotation of the bone in local of world space. * @param rotation The euler rotation that the bone should be set to. * @param space The space that the rotation is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ setRotation(rotation: Vector3, space?: Space, mesh?: AbstractMesh): void; /** * Set the quaternion rotation of the bone in local of world space. * @param quat The quaternion rotation that the bone should be set to. * @param space The space that the rotation is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ setRotationQuaternion(quat: Quaternion, space?: Space, mesh?: AbstractMesh): void; /** * Set the rotation matrix of the bone in local of world space. * @param rotMat The rotation matrix that the bone should be set to. * @param space The space that the rotation is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. */ setRotationMatrix(rotMat: Matrix, space?: Space, mesh?: AbstractMesh): void; private _rotateWithMatrix(rmat, space?, mesh?); private _getNegativeRotationToRef(rotMatInv, space?, mesh?); /** * Get the scale of the bone * @returns the scale of the bone */ getScale(): Vector3; /** * Copy the scale of the bone to a vector3. * @param result The vector3 to copy the scale to */ getScaleToRef(result: Vector3): void; /** * Get the position of the bone in local or world space. * @param space The space that the returned position is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @returns The position of the bone */ getPosition(space?: Space, mesh?: Nullable): Vector3; /** * Copy the position of the bone to a vector3 in local or world space. * @param space The space that the returned position is in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @param result The vector3 to copy the position to. */ getPositionToRef(space: Space | undefined, mesh: Nullable, result: Vector3): void; /** * Get the absolute position of the bone (world space). * @param mesh The mesh that this bone is attached to. * @returns The absolute position of the bone */ getAbsolutePosition(mesh?: Nullable): Vector3; /** * Copy the absolute position of the bone (world space) to the result param. * @param mesh The mesh that this bone is attached to. * @param result The vector3 to copy the absolute position to. */ getAbsolutePositionToRef(mesh: AbstractMesh, result: Vector3): void; /** * Compute the absolute transforms of this bone and its children. */ computeAbsoluteTransforms(): void; private _syncScaleVector(); /** * Get the world direction from an axis that is in the local space of the bone. * @param localAxis The local direction that is used to compute the world direction. * @param mesh The mesh that this bone is attached to. * @returns The world direction */ getDirection(localAxis: Vector3, mesh?: Nullable): Vector3; /** * Copy the world direction to a vector3 from an axis that is in the local space of the bone. * @param localAxis The local direction that is used to compute the world direction. * @param mesh The mesh that this bone is attached to. * @param result The vector3 that the world direction will be copied to. */ getDirectionToRef(localAxis: Vector3, mesh: AbstractMesh | null | undefined, result: Vector3): void; /** * Get the euler rotation of the bone in local or world space. * @param space The space that the rotation should be in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @returns The euler rotation */ getRotation(space?: Space, mesh?: Nullable): Vector3; /** * Copy the euler rotation of the bone to a vector3. The rotation can be in either local or world space. * @param space The space that the rotation should be in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @param result The vector3 that the rotation should be copied to. */ getRotationToRef(space: Space | undefined, mesh: AbstractMesh | null | undefined, result: Vector3): void; /** * Get the quaternion rotation of the bone in either local or world space. * @param space The space that the rotation should be in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @returns The quaternion rotation */ getRotationQuaternion(space?: Space, mesh?: Nullable): Quaternion; /** * Copy the quaternion rotation of the bone to a quaternion. The rotation can be in either local or world space. * @param space The space that the rotation should be in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @param result The quaternion that the rotation should be copied to. */ getRotationQuaternionToRef(space: Space | undefined, mesh: AbstractMesh | null | undefined, result: Quaternion): void; /** * Get the rotation matrix of the bone in local or world space. * @param space The space that the rotation should be in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @returns The rotation matrix */ getRotationMatrix(space: Space | undefined, mesh: AbstractMesh): Matrix; /** * Copy the rotation matrix of the bone to a matrix. The rotation can be in either local or world space. * @param space The space that the rotation should be in. * @param mesh The mesh that this bone is attached to. This is only used in world space. * @param result The quaternion that the rotation should be copied to. */ getRotationMatrixToRef(space: Space | undefined, mesh: AbstractMesh, result: Matrix): void; /** * Get the world position of a point that is in the local space of the bone. * @param position The local position * @param mesh The mesh that this bone is attached to. * @returns The world position */ getAbsolutePositionFromLocal(position: Vector3, mesh?: Nullable): Vector3; /** * Get the world position of a point that is in the local space of the bone and copy it to the result param. * @param position The local position * @param mesh The mesh that this bone is attached to. * @param result The vector3 that the world position should be copied to. */ getAbsolutePositionFromLocalToRef(position: Vector3, mesh: AbstractMesh | null | undefined, result: Vector3): void; /** * Get the local position of a point that is in world space. * @param position The world position * @param mesh The mesh that this bone is attached to. * @returns The local position */ getLocalPositionFromAbsolute(position: Vector3, mesh?: Nullable): Vector3; /** * Get the local position of a point that is in world space and copy it to the result param. * @param position The world position * @param mesh The mesh that this bone is attached to. * @param result The vector3 that the local position should be copied to. */ getLocalPositionFromAbsoluteToRef(position: Vector3, mesh: AbstractMesh | null | undefined, result: Vector3): void; } } declare module 'babylonjs/bones' { class BoneIKController { private static _tmpVecs; private static _tmpQuat; private static _tmpMats; targetMesh: AbstractMesh; poleTargetMesh: AbstractMesh; poleTargetBone: Nullable; targetPosition: Vector3; poleTargetPosition: Vector3; poleTargetLocalOffset: Vector3; poleAngle: number; mesh: AbstractMesh; slerpAmount: number; private _bone1Quat; private _bone1Mat; private _bone2Ang; private _bone1; private _bone2; private _bone1Length; private _bone2Length; private _maxAngle; private _maxReach; private _rightHandedSystem; private _bendAxis; private _slerping; private _adjustRoll; maxAngle: number; constructor(mesh: AbstractMesh, bone: Bone, options?: { targetMesh?: AbstractMesh; poleTargetMesh?: AbstractMesh; poleTargetBone?: Bone; poleTargetLocalOffset?: Vector3; poleAngle?: number; bendAxis?: Vector3; maxAngle?: number; slerpAmount?: number; }); private _setMaxAngle(ang); update(): void; } } declare module 'babylonjs/bones' { class BoneLookController { private static _tmpVecs; private static _tmpQuat; private static _tmpMats; /** * The target Vector3 that the bone will look at. */ target: Vector3; /** * The mesh that the bone is attached to. */ mesh: AbstractMesh; /** * The bone that will be looking to the target. */ bone: Bone; /** * The up axis of the coordinate system that is used when the bone is rotated. */ upAxis: Vector3; /** * The space that the up axis is in - BABYLON.Space.BONE, BABYLON.Space.LOCAL (default), or BABYLON.Space.WORLD. */ upAxisSpace: Space; /** * Used to make an adjustment to the yaw of the bone. */ adjustYaw: number; /** * Used to make an adjustment to the pitch of the bone. */ adjustPitch: number; /** * Used to make an adjustment to the roll of the bone. */ adjustRoll: number; /** * The amount to slerp (spherical linear interpolation) to the target. Set this to a value between 0 and 1 (a value of 1 disables slerp). */ slerpAmount: number; private _minYaw; private _maxYaw; private _minPitch; private _maxPitch; private _minYawSin; private _minYawCos; private _maxYawSin; private _maxYawCos; private _midYawConstraint; private _minPitchTan; private _maxPitchTan; private _boneQuat; private _slerping; private _transformYawPitch; private _transformYawPitchInv; private _firstFrameSkipped; private _yawRange; private _fowardAxis; /** * Get/set the minimum yaw angle that the bone can look to. */ minYaw: number; /** * Get/set the maximum yaw angle that the bone can look to. */ maxYaw: number; /** * Get/set the minimum pitch angle that the bone can look to. */ minPitch: number; /** * Get/set the maximum pitch angle that the bone can look to. */ maxPitch: number; /** * Create a BoneLookController * @param mesh the mesh that the bone belongs to * @param bone the bone that will be looking to the target * @param target the target Vector3 to look at * @param settings optional settings: * - maxYaw: the maximum angle the bone will yaw to * - minYaw: the minimum angle the bone will yaw to * - maxPitch: the maximum angle the bone will pitch to * - minPitch: the minimum angle the bone will yaw to * - slerpAmount: set the between 0 and 1 to make the bone slerp to the target. * - upAxis: the up axis of the coordinate system * - upAxisSpace: the space that the up axis is in - BABYLON.Space.BONE, BABYLON.Space.LOCAL (default), or BABYLON.Space.WORLD. * - yawAxis: set yawAxis if the bone does not yaw on the y axis * - pitchAxis: set pitchAxis if the bone does not pitch on the x axis * - adjustYaw: used to make an adjustment to the yaw of the bone * - adjustPitch: used to make an adjustment to the pitch of the bone * - adjustRoll: used to make an adjustment to the roll of the bone **/ constructor(mesh: AbstractMesh, bone: Bone, target: Vector3, options?: { maxYaw?: number; minYaw?: number; maxPitch?: number; minPitch?: number; slerpAmount?: number; upAxis?: Vector3; upAxisSpace?: Space; yawAxis?: Vector3; pitchAxis?: Vector3; adjustYaw?: number; adjustPitch?: number; adjustRoll?: number; }); /** * Update the bone to look at the target. This should be called before the scene is rendered (use scene.registerBeforeRender()). */ update(): void; private _getAngleDiff(ang1, ang2); private _getAngleBetween(ang1, ang2); private _isAngleBetween(ang, ang1, ang2); } } declare module 'babylonjs/bones' { class Skeleton implements IAnimatable { name: string; id: string; bones: Bone[]; dimensionsAtRest: Vector3; needInitialSkinMatrix: boolean; animations: Array; private _scene; private _isDirty; private _transformMatrices; private _meshesWithPoseMatrix; private _animatables; private _identity; private _synchronizedWithMesh; private _ranges; private _lastAbsoluteTransformsUpdateId; /** * An event triggered before computing the skeleton's matrices * @type {BABYLON.Observable} */ onBeforeComputeObservable: Observable; constructor(name: string, id: string, scene: Scene); getTransformMatrices(mesh: AbstractMesh): Float32Array; getScene(): Scene; /** * @param {boolean} fullDetails - support for multiple levels of logging within scene loading */ toString(fullDetails?: boolean): string; /** * Get bone's index searching by name * @param {string} name is bone's name to search for * @return {number} Indice of the bone. Returns -1 if not found */ getBoneIndexByName(name: string): number; createAnimationRange(name: string, from: number, to: number): void; deleteAnimationRange(name: string, deleteFrames?: boolean): void; getAnimationRange(name: string): Nullable; /** * Returns as an Array, all AnimationRanges defined on this skeleton */ getAnimationRanges(): Nullable[]; /** * note: This is not for a complete retargeting, only between very similar skeleton's with only possible bone length differences */ copyAnimationRange(source: Skeleton, name: string, rescaleAsRequired?: boolean): boolean; returnToRest(): void; private _getHighestAnimationFrame(); beginAnimation(name: string, loop?: boolean, speedRatio?: number, onAnimationEnd?: () => void): Nullable; _markAsDirty(): void; _registerMeshWithPoseMatrix(mesh: AbstractMesh): void; _unregisterMeshWithPoseMatrix(mesh: AbstractMesh): void; _computeTransformMatrices(targetMatrix: Float32Array, initialSkinMatrix: Nullable): void; prepare(): void; getAnimatables(): IAnimatable[]; clone(name: string, id: string): Skeleton; enableBlending(blendingSpeed?: number): void; dispose(): void; serialize(): any; static Parse(parsedSkeleton: any, scene: Scene): Skeleton; computeAbsoluteTransforms(forceUpdate?: boolean): void; getPoseMatrix(): Nullable; sortBones(): void; private _sortBones(index, bones, visited); } } import {EffectFallbacks,EffectCreationOptions,Effect,Nullable,float,double,int,FloatArray,IndicesArray,KeyboardEventTypes,KeyboardInfo,KeyboardInfoPre,PointerEventTypes,PointerInfoBase,PointerInfoPre,PointerInfo,ToGammaSpace,ToLinearSpace,Epsilon,Color3,Color4,Vector2,Vector3,Vector4,ISize,Size,Quaternion,Matrix,Plane,Viewport,Frustum,Space,Axis,BezierCurve,Orientation,Angle,Arc2,Path2,Path3D,Curve3,PositionNormalVertex,PositionNormalTextureVertex,Tmp,Scalar,expandToProperty,serialize,serializeAsTexture,serializeAsColor3,serializeAsFresnelParameters,serializeAsVector2,serializeAsVector3,serializeAsMeshReference,serializeAsColorCurves,serializeAsColor4,serializeAsImageProcessingConfiguration,serializeAsQuaternion,SerializationHelper,EventState,Observer,MultiObserver,Observable,SmartArray,SmartArrayNoDuplicate,IAnimatable,LoadFileError,RetryStrategy,IFileRequest,Tools,PerfCounter,className,AsyncLoop,_AlphaState,_DepthCullingState,_StencilState,InstancingAttributeInfo,RenderTargetCreationOptions,EngineCapabilities,EngineOptions,IDisplayChangedEventArgs,Engine,Node,BoundingSphere,BoundingBox,ICullable,BoundingInfo,TransformNode,AbstractMesh,Light,Camera,RenderingManager,RenderingGroup,IDisposable,IActiveMeshCandidateProvider,RenderingGroupInfo,Scene,Buffer,VertexBuffer,InternalTexture,BaseTexture,Texture,_InstancesBatch,Mesh,BaseSubMesh,SubMesh,MaterialDefines,Material,UniformBuffer,IGetSetVerticesData,VertexData,Geometry,_PrimitiveGeometry,RibbonGeometry,BoxGeometry,SphereGeometry,DiscGeometry,CylinderGeometry,TorusGeometry,GroundGeometry,TiledGroundGeometry,PlaneGeometry,TorusKnotGeometry,PostProcessManager,PerformanceMonitor,RollingAverage,IImageProcessingConfigurationDefines,ImageProcessingConfiguration,ColorGradingTexture,ColorCurves,Behavior,MaterialHelper,PushMaterial,StandardMaterialDefines,StandardMaterial} from 'babylonjs/core'; import {EngineInstrumentation,SceneInstrumentation,_TimeToken} from 'babylonjs/instrumentation'; import {Particle,IParticleSystem,ParticleSystem,BoxParticleEmitter,ConeParticleEmitter,SphereParticleEmitter,SphereDirectedParticleEmitter,IParticleEmitterType} from 'babylonjs/particles'; import {GPUParticleSystem} from 'babylonjs/gpuParticles'; import {FramingBehavior,BouncingBehavior,AutoRotationBehavior} from 'babylonjs/cameraBehaviors'; import {NullEngineOptions,NullEngine} from 'babylonjs/nullEngine'; import {TextureTools} from 'babylonjs/textureTools'; import {SolidParticle,ModelShape,DepthSortedParticle,SolidParticleSystem} from 'babylonjs/solidParticles'; import {Collider,CollisionWorker,ICollisionCoordinator,SerializedMesh,SerializedSubMesh,SerializedGeometry,BabylonMessage,SerializedColliderToWorker,WorkerTaskType,WorkerReply,CollisionReplyPayload,InitPayload,CollidePayload,UpdatePayload,WorkerReplyType,CollisionCoordinatorWorker,CollisionCoordinatorLegacy} from 'babylonjs/collisions'; import {IntersectionInfo,PickingInfo,Ray} from 'babylonjs/picking'; import {SpriteManager,Sprite} from 'babylonjs/sprites'; import {AnimationRange,AnimationEvent,PathCursor,Animation,TargetedAnimation,AnimationGroup,RuntimeAnimation,Animatable,IEasingFunction,EasingFunction,CircleEase,BackEase,BounceEase,CubicEase,ElasticEase,ExponentialEase,PowerEase,QuadraticEase,QuarticEase,QuinticEase,SineEase,BezierCurveEase} from 'babylonjs/animations'; import {Condition,ValueCondition,PredicateCondition,StateCondition,Action,ActionEvent,ActionManager,InterpolateValueAction,SwitchBooleanAction,SetStateAction,SetValueAction,IncrementValueAction,PlayAnimationAction,StopAnimationAction,DoNothingAction,CombineAction,ExecuteCodeAction,SetParentAction,PlaySoundAction,StopSoundAction} from 'babylonjs/actions'; import {GroundMesh,InstancedMesh,LinesMesh} from 'babylonjs/additionalMeshes'; import {ShaderMaterial} from 'babylonjs/shaderMaterial'; import {MeshBuilder} from 'babylonjs/meshBuilder'; import {PBRBaseMaterial,PBRBaseSimpleMaterial,PBRMaterial,PBRMetallicRoughnessMaterial,PBRSpecularGlossinessMaterial} from 'babylonjs/pbrMaterial'; import {CameraInputTypes,ICameraInput,CameraInputsMap,CameraInputsManager,TargetCamera} from 'babylonjs/targetCamera'; import {ArcRotateCameraKeyboardMoveInput,ArcRotateCameraMouseWheelInput,ArcRotateCameraPointersInput,ArcRotateCameraInputsManager,ArcRotateCamera} from 'babylonjs/arcRotateCamera'; import {FreeCameraMouseInput,FreeCameraKeyboardMoveInput,FreeCameraInputsManager,FreeCamera} from 'babylonjs/freeCamera'; import {HemisphericLight} from 'babylonjs/hemisphericLight'; import {IShadowLight,ShadowLight,PointLight} from 'babylonjs/pointLight'; import {DirectionalLight} from 'babylonjs/directionalLight'; import {SpotLight} from 'babylonjs/spotLight'; import {CubeTexture,RenderTargetTexture,IMultiRenderTargetOptions,MultiRenderTarget,MirrorTexture,RefractionTexture,DynamicTexture,VideoTexture,RawTexture} from 'babylonjs/additionalTextures'; import {AudioEngine,Sound,SoundTrack,Analyser} from 'babylonjs/audio'; import {ILoadingScreen,DefaultLoadingScreen,SceneLoaderProgressEvent,ISceneLoaderPluginExtensions,ISceneLoaderPluginFactory,ISceneLoaderPlugin,ISceneLoaderPluginAsync,SceneLoader,FilesInput} from 'babylonjs/loader'; import {IShadowGenerator,ShadowGenerator} from 'babylonjs/shadows'; import {StringDictionary} from 'babylonjs/stringDictionary'; import {Tags,AndOrNotEvaluator} from 'babylonjs/userData'; import {FresnelParameters} from 'babylonjs/fresnel'; import {MultiMaterial} from 'babylonjs/multiMaterial'; import {Database} from 'babylonjs/offline'; import {FreeCameraTouchInput,TouchCamera} from 'babylonjs/touchCamera'; import {ProceduralTexture,CustomProceduralTexture} from 'babylonjs/procedural'; import {FreeCameraGamepadInput,ArcRotateCameraGamepadInput,GamepadManager,StickValues,GamepadButtonChanges,Gamepad,GenericPad,Xbox360Button,Xbox360Dpad,Xbox360Pad,PoseEnabledControllerType,MutableGamepadButton,ExtendedGamepadButton,PoseEnabledControllerHelper,PoseEnabledController,WebVRController,OculusTouchController,ViveController,GenericController,WindowsMotionController} from 'babylonjs/gamepad'; import {FollowCamera,ArcFollowCamera,UniversalCamera,GamepadCamera} from 'babylonjs/additionalCameras'; import {DepthRenderer} from 'babylonjs/depthRenderer'; import {GeometryBufferRenderer} from 'babylonjs/geometryBufferRenderer'; import {PostProcessOptions,PostProcess,PassPostProcess} from 'babylonjs/postProcesses'; import {BlurPostProcess} from 'babylonjs/additionalPostProcess_blur'; import {FxaaPostProcess} from 'babylonjs/additionalPostProcess_fxaa'; import {HighlightsPostProcess} from 'babylonjs/additionalPostProcess_highlights'; import {RefractionPostProcess,BlackAndWhitePostProcess,ConvolutionPostProcess,FilterPostProcess,VolumetricLightScatteringPostProcess,ColorCorrectionPostProcess,TonemappingOperator,TonemapPostProcess,DisplayPassPostProcess,ImageProcessingPostProcess} from 'babylonjs/additionalPostProcesses'; import {PostProcessRenderPipelineManager,PostProcessRenderPass,PostProcessRenderEffect,PostProcessRenderPipeline} from 'babylonjs/renderingPipeline'; import {SSAORenderingPipeline,SSAO2RenderingPipeline,LensRenderingPipeline,StandardRenderingPipeline} from 'babylonjs/additionalRenderingPipeline'; import {DefaultRenderingPipeline} from 'babylonjs/defaultRenderingPipeline'; import {SphericalPolynomial,SphericalHarmonics,CubeMapToSphericalPolynomialTools,CubeMapInfo,PanoramaToCubeMapTools,HDRInfo,HDRTools,HDRCubeTexture} from 'babylonjs/hdr'; import {CSG} from 'babylonjs/csg'; import {Polygon,PolygonMeshBuilder} from 'babylonjs/polygonMesh'; import {LensFlare,LensFlareSystem} from 'babylonjs/lensFlares'; import {PhysicsJointData,PhysicsJoint,DistanceJoint,MotorEnabledJoint,HingeJoint,Hinge2Joint,IMotorEnabledJoint,DistanceJointData,SpringJointData,PhysicsImpostorParameters,IPhysicsEnabledObject,PhysicsImpostor,PhysicsImpostorJoint,PhysicsEngine,IPhysicsEnginePlugin,PhysicsHelper,PhysicsRadialExplosionEvent,PhysicsGravitationalFieldEvent,PhysicsUpdraftEvent,PhysicsVortexEvent,PhysicsRadialImpulseFalloff,PhysicsUpdraftMode,PhysicsForceAndContactPoint,PhysicsRadialExplosionEventData,PhysicsGravitationalFieldEventData,PhysicsUpdraftEventData,PhysicsVortexEventData,CannonJSPlugin,OimoJSPlugin} from 'babylonjs/physics'; import {TGATools,DDSInfo,DDSTools,KhronosTextureContainer} from 'babylonjs/textureFormats'; import {Debug,RayHelper,DebugLayer,BoundingBoxRenderer} from 'babylonjs/debug'; import {MorphTarget,MorphTargetManager} from 'babylonjs/morphTargets'; import {IOctreeContainer,Octree,OctreeBlock} from 'babylonjs/octrees'; import {SIMDHelper} from 'babylonjs/simd'; import {VRDistortionCorrectionPostProcess,AnaglyphPostProcess,StereoscopicInterlacePostProcess,FreeCameraDeviceOrientationInput,ArcRotateCameraVRDeviceOrientationInput,VRCameraMetrics,DevicePose,PoseControlled,WebVROptions,WebVRFreeCamera,DeviceOrientationCamera,VRDeviceOrientationFreeCamera,VRDeviceOrientationGamepadCamera,VRDeviceOrientationArcRotateCamera,AnaglyphFreeCamera,AnaglyphArcRotateCamera,AnaglyphGamepadCamera,AnaglyphUniversalCamera,StereoscopicFreeCamera,StereoscopicArcRotateCamera,StereoscopicGamepadCamera,StereoscopicUniversalCamera,VRTeleportationOptions,VRExperienceHelperOptions,VRExperienceHelper} from 'babylonjs/vr'; import {JoystickAxis,VirtualJoystick,VirtualJoysticksCamera,FreeCameraVirtualJoystickInput} from 'babylonjs/virtualJoystick'; import {ISimplifier,ISimplificationSettings,SimplificationSettings,ISimplificationTask,SimplificationQueue,SimplificationType,DecimationTriangle,DecimationVertex,QuadraticMatrix,Reference,QuadraticErrorSimplification,MeshLODLevel,SceneOptimization,TextureOptimization,HardwareScalingOptimization,ShadowsOptimization,PostProcessesOptimization,LensFlaresOptimization,ParticlesOptimization,RenderTargetsOptimization,MergeMeshesOptimization,SceneOptimizerOptions,SceneOptimizer} from 'babylonjs/optimizations'; import {OutlineRenderer,EdgesRenderer,IHighlightLayerOptions,HighlightLayer} from 'babylonjs/highlights'; import {SceneSerializer} from 'babylonjs/serialization'; import {AssetTaskState,AbstractAssetTask,IAssetsProgressEvent,AssetsProgressEvent,MeshAssetTask,TextFileAssetTask,BinaryFileAssetTask,ImageAssetTask,ITextureAssetTask,TextureAssetTask,CubeTextureAssetTask,HDRCubeTextureAssetTask,AssetsManager} from 'babylonjs/assetsManager'; import {ReflectionProbe} from 'babylonjs/probes'; import {BackgroundMaterial} from 'babylonjs/backgroundMaterial'; import {Layer} from 'babylonjs/layer'; import {IEnvironmentHelperOptions,EnvironmentHelper} from 'babylonjs/environmentHelper';