mage-engine 3.17.6 → 3.17.7

package/dist/mage.js

@@ -53545,7 +53545,8 @@ if ( typeof window !== 'undefined' ) {
 }var three_module=/*#__PURE__*/Object.freeze({__proto__:null,ACESFilmicToneMapping:ACESFilmicToneMapping,AddEquation:AddEquation,AddOperation:AddOperation,AdditiveAnimationBlendMode:AdditiveAnimationBlendMode,AdditiveBlending:AdditiveBlending,AlphaFormat:AlphaFormat,AlwaysDepth:AlwaysDepth,AlwaysStencilFunc:AlwaysStencilFunc,AmbientLight:AmbientLight$1,AmbientLightProbe:AmbientLightProbe,AnimationClip:AnimationClip,AnimationLoader:AnimationLoader,AnimationMixer:AnimationMixer,AnimationObjectGroup:AnimationObjectGroup,AnimationUtils:AnimationUtils,ArcCurve:ArcCurve,ArrayCamera:ArrayCamera,ArrowHelper:ArrowHelper,Audio:Audio$2,AudioAnalyser:AudioAnalyser,AudioContext:AudioContext,AudioListener:AudioListener,AudioLoader:AudioLoader,AxesHelper:AxesHelper,AxisHelper:AxisHelper,BackSide:BackSide,BasicDepthPacking:BasicDepthPacking,BasicShadowMap:BasicShadowMap,BinaryTextureLoader:BinaryTextureLoader,Bone:Bone,BooleanKeyframeTrack:BooleanKeyframeTrack,BoundingBoxHelper:BoundingBoxHelper,Box2:Box2,Box3:Box3,Box3Helper:Box3Helper,BoxBufferGeometry:BoxGeometry,BoxGeometry:BoxGeometry,BoxHelper:BoxHelper,BufferAttribute:BufferAttribute,BufferGeometry:BufferGeometry,BufferGeometryLoader:BufferGeometryLoader,ByteType:ByteType,Cache:Cache,Camera:Camera$1,CameraHelper:CameraHelper,CanvasRenderer:CanvasRenderer,CanvasTexture:CanvasTexture,CatmullRomCurve3:CatmullRomCurve3,CineonToneMapping:CineonToneMapping,CircleBufferGeometry:CircleGeometry,CircleGeometry:CircleGeometry,ClampToEdgeWrapping:ClampToEdgeWrapping,Clock:Clock,Color:Color$1,ColorKeyframeTrack:ColorKeyframeTrack,CompressedTexture:CompressedTexture,CompressedTextureLoader:CompressedTextureLoader,ConeBufferGeometry:ConeGeometry,ConeGeometry:ConeGeometry,CubeCamera:CubeCamera,CubeReflectionMapping:CubeReflectionMapping,CubeRefractionMapping:CubeRefractionMapping,CubeTexture:CubeTexture,CubeTextureLoader:CubeTextureLoader,CubeUVReflectionMapping:CubeUVReflectionMapping,CubeUVRefractionMapping:CubeUVRefractionMapping,CubicBezierCurve:CubicBezierCurve,CubicBezierCurve3:CubicBezierCurve3,CubicInterpolant:CubicInterpolant,CullFaceBack:CullFaceBack,CullFaceFront:CullFaceFront,CullFaceFrontBack:CullFaceFrontBack,CullFaceNone:CullFaceNone,Curve:Curve,CurvePath:CurvePath,CustomBlending:CustomBlending,CustomToneMapping:CustomToneMapping,CylinderBufferGeometry:CylinderGeometry,CylinderGeometry:CylinderGeometry,Cylindrical:Cylindrical,DataTexture:DataTexture,DataTexture2DArray:DataTexture2DArray,DataTexture3D:DataTexture3D,DataTextureLoader:DataTextureLoader,DataUtils:DataUtils,DecrementStencilOp:DecrementStencilOp,DecrementWrapStencilOp:DecrementWrapStencilOp,DefaultLoadingManager:DefaultLoadingManager,DepthFormat:DepthFormat,DepthStencilFormat:DepthStencilFormat,DepthTexture:DepthTexture,DirectionalLight:DirectionalLight,DirectionalLightHelper:DirectionalLightHelper,DiscreteInterpolant:DiscreteInterpolant,DodecahedronBufferGeometry:DodecahedronGeometry,DodecahedronGeometry:DodecahedronGeometry,DoubleSide:DoubleSide,DstAlphaFactor:DstAlphaFactor,DstColorFactor:DstColorFactor,DynamicBufferAttribute:DynamicBufferAttribute,DynamicCopyUsage:DynamicCopyUsage,DynamicDrawUsage:DynamicDrawUsage,DynamicReadUsage:DynamicReadUsage,EdgesGeometry:EdgesGeometry,EdgesHelper:EdgesHelper,EllipseCurve:EllipseCurve,EqualDepth:EqualDepth,EqualStencilFunc:EqualStencilFunc,EquirectangularReflectionMapping:EquirectangularReflectionMapping,EquirectangularRefractionMapping:EquirectangularRefractionMapping,Euler:Euler,EventDispatcher:EventDispatcher,ExtrudeBufferGeometry:ExtrudeGeometry,ExtrudeGeometry:ExtrudeGeometry,FaceColors:FaceColors,FileLoader:FileLoader,FlatShading:FlatShading,Float16BufferAttribute:Float16BufferAttribute,Float32Attribute:Float32Attribute,Float32BufferAttribute:Float32BufferAttribute,Float64Attribute:Float64Attribute,Float64BufferAttribute:Float64BufferAttribute,FloatType:FloatType$1,Fog:Fog,FogExp2:FogExp2,Font:Font,FontLoader:FontLoader,FrontSide:FrontSide,Frustum:Frustum$1,GLBufferAttribute:GLBufferAttribute,GLSL1:GLSL1,GLSL3:GLSL3,GammaEncoding:GammaEncoding,GreaterDepth:GreaterDepth,GreaterEqualDepth:GreaterEqualDepth,GreaterEqualStencilFunc:GreaterEqualStencilFunc,GreaterStencilFunc:GreaterStencilFunc,GridHelper:GridHelper,Group:Group,HalfFloatType:HalfFloatType,HemisphereLight:HemisphereLight$1,HemisphereLightHelper:HemisphereLightHelper,HemisphereLightProbe:HemisphereLightProbe,IcosahedronBufferGeometry:IcosahedronGeometry,IcosahedronGeometry:IcosahedronGeometry,ImageBitmapLoader:ImageBitmapLoader,ImageLoader:ImageLoader,ImageUtils:ImageUtils,ImmediateRenderObject:ImmediateRenderObject,IncrementStencilOp:IncrementStencilOp,IncrementWrapStencilOp:IncrementWrapStencilOp,InstancedBufferAttribute:InstancedBufferAttribute,InstancedBufferGeometry:InstancedBufferGeometry,InstancedInterleavedBuffer:InstancedInterleavedBuffer,InstancedMesh:InstancedMesh,Int16Attribute:Int16Attribute,Int16BufferAttribute:Int16BufferAttribute,Int32Attribute:Int32Attribute,Int32BufferAttribute:Int32BufferAttribute,Int8Attribute:Int8Attribute,Int8BufferAttribute:Int8BufferAttribute,IntType:IntType,InterleavedBuffer:InterleavedBuffer,InterleavedBufferAttribute:InterleavedBufferAttribute,Interpolant:Interpolant,InterpolateDiscrete:InterpolateDiscrete,InterpolateLinear:InterpolateLinear,InterpolateSmooth:InterpolateSmooth,InvertStencilOp:InvertStencilOp,JSONLoader:JSONLoader,KeepStencilOp:KeepStencilOp,KeyframeTrack:KeyframeTrack,LOD:LOD,LatheBufferGeometry:LatheGeometry,LatheGeometry:LatheGeometry,Layers:Layers,LensFlare:LensFlare,LessDepth:LessDepth,LessEqualDepth:LessEqualDepth,LessEqualStencilFunc:LessEqualStencilFunc,LessStencilFunc:LessStencilFunc,Light:Light$1,LightProbe:LightProbe,Line:Line$1,Line3:Line3,LineBasicMaterial:LineBasicMaterial,LineCurve:LineCurve,LineCurve3:LineCurve3,LineDashedMaterial:LineDashedMaterial,LineLoop:LineLoop,LinePieces:LinePieces,LineSegments:LineSegments,LineStrip:LineStrip,LinearEncoding:LinearEncoding,LinearFilter:LinearFilter,LinearInterpolant:LinearInterpolant,LinearMipMapLinearFilter:LinearMipMapLinearFilter,LinearMipMapNearestFilter:LinearMipMapNearestFilter,LinearMipmapLinearFilter:LinearMipmapLinearFilter,LinearMipmapNearestFilter:LinearMipmapNearestFilter,LinearToneMapping:LinearToneMapping,Loader:Loader$1,LoaderUtils:LoaderUtils,LoadingManager:LoadingManager,LogLuvEncoding:LogLuvEncoding,LoopOnce:LoopOnce,LoopPingPong:LoopPingPong,LoopRepeat:LoopRepeat,LuminanceAlphaFormat:LuminanceAlphaFormat,LuminanceFormat:LuminanceFormat,MOUSE:MOUSE,Material:Material,MaterialLoader:MaterialLoader,Math:MathUtils,MathUtils:MathUtils,Matrix3:Matrix3,Matrix4:Matrix4,MaxEquation:MaxEquation,Mesh:Mesh,MeshBasicMaterial:MeshBasicMaterial,MeshDepthMaterial:MeshDepthMaterial,MeshDistanceMaterial:MeshDistanceMaterial,MeshFaceMaterial:MeshFaceMaterial,MeshLambertMaterial:MeshLambertMaterial,MeshMatcapMaterial:MeshMatcapMaterial,MeshNormalMaterial:MeshNormalMaterial,MeshPhongMaterial:MeshPhongMaterial,MeshPhysicalMaterial:MeshPhysicalMaterial,MeshStandardMaterial:MeshStandardMaterial,MeshToonMaterial:MeshToonMaterial,MinEquation:MinEquation,MirroredRepeatWrapping:MirroredRepeatWrapping,MixOperation:MixOperation,MultiMaterial:MultiMaterial,MultiplyBlending:MultiplyBlending,MultiplyOperation:MultiplyOperation,NearestFilter:NearestFilter,NearestMipMapLinearFilter:NearestMipMapLinearFilter,NearestMipMapNearestFilter:NearestMipMapNearestFilter,NearestMipmapLinearFilter:NearestMipmapLinearFilter,NearestMipmapNearestFilter:NearestMipmapNearestFilter,NeverDepth:NeverDepth,NeverStencilFunc:NeverStencilFunc,NoBlending:NoBlending,NoColors:NoColors,NoToneMapping:NoToneMapping,NormalAnimationBlendMode:NormalAnimationBlendMode,NormalBlending:NormalBlending,NotEqualDepth:NotEqualDepth,NotEqualStencilFunc:NotEqualStencilFunc,NumberKeyframeTrack:NumberKeyframeTrack,Object3D:Object3D,ObjectLoader:ObjectLoader,ObjectSpaceNormalMap:ObjectSpaceNormalMap,OctahedronBufferGeometry:OctahedronGeometry,OctahedronGeometry:OctahedronGeometry,OneFactor:OneFactor,OneMinusDstAlphaFactor:OneMinusDstAlphaFactor,OneMinusDstColorFactor:OneMinusDstColorFactor,OneMinusSrcAlphaFactor:OneMinusSrcAlphaFactor,OneMinusSrcColorFactor:OneMinusSrcColorFactor,OrthographicCamera:OrthographicCamera,PCFShadowMap:PCFShadowMap,PCFSoftShadowMap:PCFSoftShadowMap,PMREMGenerator:PMREMGenerator,ParametricBufferGeometry:ParametricGeometry,ParametricGeometry:ParametricGeometry,Particle:Particle,ParticleBasicMaterial:ParticleBasicMaterial,ParticleSystem:ParticleSystem,ParticleSystemMaterial:ParticleSystemMaterial,Path:Path,PerspectiveCamera:PerspectiveCamera,Plane:Plane$1,PlaneBufferGeometry:PlaneGeometry,PlaneGeometry:PlaneGeometry,PlaneHelper:PlaneHelper,PointCloud:PointCloud,PointCloudMaterial:PointCloudMaterial,PointLight:PointLight$1,PointLightHelper:PointLightHelper,Points:Points,PointsMaterial:PointsMaterial,PolarGridHelper:PolarGridHelper,PolyhedronBufferGeometry:PolyhedronGeometry,PolyhedronGeometry:PolyhedronGeometry,PositionalAudio:PositionalAudio,PropertyBinding:PropertyBinding,PropertyMixer:PropertyMixer,QuadraticBezierCurve:QuadraticBezierCurve,QuadraticBezierCurve3:QuadraticBezierCurve3,Quaternion:Quaternion,QuaternionKeyframeTrack:QuaternionKeyframeTrack,QuaternionLinearInterpolant:QuaternionLinearInterpolant,REVISION:REVISION,RGBADepthPacking:RGBADepthPacking,RGBAFormat:RGBAFormat,RGBAIntegerFormat:RGBAIntegerFormat,RGBA_ASTC_10x10_Format:RGBA_ASTC_10x10_Format,RGBA_ASTC_10x5_Format:RGBA_ASTC_10x5_Format,RGBA_ASTC_10x6_Format:RGBA_ASTC_10x6_Format,RGBA_ASTC_10x8_Format:RGBA_ASTC_10x8_Format,RGBA_ASTC_12x10_Format:RGBA_ASTC_12x10_Format,RGBA_ASTC_12x12_Format:RGBA_ASTC_12x12_Format,RGBA_ASTC_4x4_Format:RGBA_ASTC_4x4_Format,RGBA_ASTC_5x4_Format:RGBA_ASTC_5x4_Format,RGBA_ASTC_5x5_Format:RGBA_ASTC_5x5_Format,RGBA_ASTC_6x5_Format:RGBA_ASTC_6x5_Format,RGBA_ASTC_6x6_Format:RGBA_ASTC_6x6_Format,RGBA_ASTC_8x5_Format:RGBA_ASTC_8x5_Format,RGBA_ASTC_8x6_Format:RGBA_ASTC_8x6_Format,RGBA_ASTC_8x8_Format:RGBA_ASTC_8x8_Format,RGBA_BPTC_Format:RGBA_BPTC_Format,RGBA_ETC2_EAC_Format:RGBA_ETC2_EAC_Format,RGBA_PVRTC_2BPPV1_Format:RGBA_PVRTC_2BPPV1_Format,RGBA_PVRTC_4BPPV1_Format:RGBA_PVRTC_4BPPV1_Format,RGBA_S3TC_DXT1_Format:RGBA_S3TC_DXT1_Format,RGBA_S3TC_DXT3_Format:RGBA_S3TC_DXT3_Format,RGBA_S3TC_DXT5_Format:RGBA_S3TC_DXT5_Format,RGBDEncoding:RGBDEncoding,RGBEEncoding:RGBEEncoding,RGBEFormat:RGBEFormat,RGBFormat:RGBFormat,RGBIntegerFormat:RGBIntegerFormat,RGBM16Encoding:RGBM16Encoding,RGBM7Encoding:RGBM7Encoding,RGB_ETC1_Format:RGB_ETC1_Format,RGB_ETC2_Format:RGB_ETC2_Format,RGB_PVRTC_2BPPV1_Format:RGB_PVRTC_2BPPV1_Format,RGB_PVRTC_4BPPV1_Format:RGB_PVRTC_4BPPV1_Format,RGB_S3TC_DXT1_Format:RGB_S3TC_DXT1_Format,RGFormat:RGFormat,RGIntegerFormat:RGIntegerFormat,RawShaderMaterial:RawShaderMaterial,Ray:Ray,Raycaster:Raycaster,RectAreaLight:RectAreaLight,RedFormat:RedFormat,RedIntegerFormat:RedIntegerFormat,ReinhardToneMapping:ReinhardToneMapping,RepeatWrapping:RepeatWrapping$1,ReplaceStencilOp:ReplaceStencilOp,ReverseSubtractEquation:ReverseSubtractEquation,RingBufferGeometry:RingGeometry,RingGeometry:RingGeometry,SRGB8_ALPHA8_ASTC_10x10_Format:SRGB8_ALPHA8_ASTC_10x10_Format,SRGB8_ALPHA8_ASTC_10x5_Format:SRGB8_ALPHA8_ASTC_10x5_Format,SRGB8_ALPHA8_ASTC_10x6_Format:SRGB8_ALPHA8_ASTC_10x6_Format,SRGB8_ALPHA8_ASTC_10x8_Format:SRGB8_ALPHA8_ASTC_10x8_Format,SRGB8_ALPHA8_ASTC_12x10_Format:SRGB8_ALPHA8_ASTC_12x10_Format,SRGB8_ALPHA8_ASTC_12x12_Format:SRGB8_ALPHA8_ASTC_12x12_Format,SRGB8_ALPHA8_ASTC_4x4_Format:SRGB8_ALPHA8_ASTC_4x4_Format,SRGB8_ALPHA8_ASTC_5x4_Format:SRGB8_ALPHA8_ASTC_5x4_Format,SRGB8_ALPHA8_ASTC_5x5_Format:SRGB8_ALPHA8_ASTC_5x5_Format,SRGB8_ALPHA8_ASTC_6x5_Format:SRGB8_ALPHA8_ASTC_6x5_Format,SRGB8_ALPHA8_ASTC_6x6_Format:SRGB8_ALPHA8_ASTC_6x6_Format,SRGB8_ALPHA8_ASTC_8x5_Format:SRGB8_ALPHA8_ASTC_8x5_Format,SRGB8_ALPHA8_ASTC_8x6_Format:SRGB8_ALPHA8_ASTC_8x6_Format,SRGB8_ALPHA8_ASTC_8x8_Format:SRGB8_ALPHA8_ASTC_8x8_Format,Scene:Scene$2,SceneUtils:SceneUtils,ShaderChunk:ShaderChunk,ShaderLib:ShaderLib,ShaderMaterial:ShaderMaterial,ShadowMaterial:ShadowMaterial,Shape:Shape,ShapeBufferGeometry:ShapeGeometry,ShapeGeometry:ShapeGeometry,ShapePath:ShapePath,ShapeUtils:ShapeUtils,ShortType:ShortType,Skeleton:Skeleton,SkeletonHelper:SkeletonHelper,SkinnedMesh:SkinnedMesh,SmoothShading:SmoothShading,Sphere:Sphere$1,SphereBufferGeometry:SphereGeometry,SphereGeometry:SphereGeometry,Spherical:Spherical,SphericalHarmonics3:SphericalHarmonics3,SplineCurve:SplineCurve,SpotLight:SpotLight$1,SpotLightHelper:SpotLightHelper,Sprite:Sprite$1,SpriteMaterial:SpriteMaterial,SrcAlphaFactor:SrcAlphaFactor,SrcAlphaSaturateFactor:SrcAlphaSaturateFactor,SrcColorFactor:SrcColorFactor,StaticCopyUsage:StaticCopyUsage,StaticDrawUsage:StaticDrawUsage,StaticReadUsage:StaticReadUsage,StereoCamera:StereoCamera,StreamCopyUsage:StreamCopyUsage,StreamDrawUsage:StreamDrawUsage,StreamReadUsage:StreamReadUsage,StringKeyframeTrack:StringKeyframeTrack,SubtractEquation:SubtractEquation,SubtractiveBlending:SubtractiveBlending,TOUCH:TOUCH,TangentSpaceNormalMap:TangentSpaceNormalMap,TetrahedronBufferGeometry:TetrahedronGeometry,TetrahedronGeometry:TetrahedronGeometry,TextBufferGeometry:TextGeometry,TextGeometry:TextGeometry,Texture:Texture,TextureLoader:TextureLoader,TorusBufferGeometry:TorusGeometry,TorusGeometry:TorusGeometry,TorusKnotBufferGeometry:TorusKnotGeometry,TorusKnotGeometry:TorusKnotGeometry,Triangle:Triangle,TriangleFanDrawMode:TriangleFanDrawMode,TriangleStripDrawMode:TriangleStripDrawMode,TrianglesDrawMode:TrianglesDrawMode,TubeBufferGeometry:TubeGeometry,TubeGeometry:TubeGeometry,UVMapping:UVMapping,Uint16Attribute:Uint16Attribute,Uint16BufferAttribute:Uint16BufferAttribute,Uint32Attribute:Uint32Attribute,Uint32BufferAttribute:Uint32BufferAttribute,Uint8Attribute:Uint8Attribute,Uint8BufferAttribute:Uint8BufferAttribute,Uint8ClampedAttribute:Uint8ClampedAttribute,Uint8ClampedBufferAttribute:Uint8ClampedBufferAttribute,Uniform:Uniform,UniformsLib:UniformsLib,UniformsUtils:UniformsUtils,UnsignedByteType:UnsignedByteType,UnsignedInt248Type:UnsignedInt248Type,UnsignedIntType:UnsignedIntType,UnsignedShort4444Type:UnsignedShort4444Type,UnsignedShort5551Type:UnsignedShort5551Type,UnsignedShort565Type:UnsignedShort565Type,UnsignedShortType:UnsignedShortType,VSMShadowMap:VSMShadowMap,Vector2:Vector2,Vector3:Vector3$1,Vector4:Vector4,VectorKeyframeTrack:VectorKeyframeTrack,Vertex:Vertex,VertexColors:VertexColors,VideoTexture:VideoTexture,WebGL1Renderer:WebGL1Renderer,WebGLCubeRenderTarget:WebGLCubeRenderTarget,WebGLMultisampleRenderTarget:WebGLMultisampleRenderTarget,WebGLRenderTarget:WebGLRenderTarget,WebGLRenderTargetCube:WebGLRenderTargetCube,WebGLRenderer:WebGLRenderer,WebGLUtils:WebGLUtils,WireframeGeometry:WireframeGeometry,WireframeHelper:WireframeHelper,WrapAroundEnding:WrapAroundEnding,XHRLoader:XHRLoader,ZeroCurvatureEnding:ZeroCurvatureEnding,ZeroFactor:ZeroFactor,ZeroSlopeEnding:ZeroSlopeEnding,ZeroStencilOp:ZeroStencilOp,sRGBEncoding:sRGBEncoding});var PREFIX = '[Mage]';
 var DEPRECATED = '[DEPRECATED]';
 var DEPRECATIONS = {
-  MODELS_GETMODEL: "".concat(PREFIX, " ").concat(DEPRECATED, " Models.getModel is deprecated, use Models.get instead. WIll be removed in next major release"),
+  PARTICLES_ADD_PARTICLE_EMITTER: "".concat(PREFIX, " ").concat(DEPRECATED, " Particles.addParticleEmitter is deprecated, use Particles.add instead. Will be removed in the next major release"),
+  MODELS_GETMODEL: "".concat(PREFIX, " ").concat(DEPRECATED, " Models.getModel is deprecated, use Models.get instead. Will be removed in next major release"),
   SCRIPTS_CREATE: "".concat(PREFIX, " ").concat(DEPRECATED, " Scripts.create is deprecated, use Scripts.register instead. Will be removed in next major release."),
   ELEMENT_SET_TEXTURE_MAP: "".concat(PREFIX, " ").concat(DEPRECATED, " Element.setTextureMap is deprecated, use Element.setTexture() instead. Will be removed in next major release.")
 };
@@ -53594,9 +53595,24 @@ var LIGHT_HOLDER_MODEL_NOT_FOUND = "".concat(PREFIX, " This light holder model c
     }
   }, {
     key: "__hasStarted",
-    value: function __hasStarted(flag) {
+    value: function __hasStarted() {
+      return this.hasStarted;
+    }
+  }, {
+    key: "__isDisposed",
+    value: function __isDisposed() {
+      return this.isDisposed;
+    }
+  }, {
+    key: "__setStartedFlag",
+    value: function __setStartedFlag(flag) {
       this.hasStarted = flag;
     }
+  }, {
+    key: "__setDisposedFlag",
+    value: function __setDisposedFlag(flag) {
+      this.isDisposed = flag;
+    }
   }]);
 
   function BaseScript(name) {
@@ -54479,9 +54495,8 @@ var Config$1 = new Config();var Universe = /*#__PURE__*/function () {
     });
 
     _defineProperty$1(this, "forEach", function (callback) {
-      var keys = Object.keys(_this.reality);
-      keys.forEach(function (k) {
-        return callback(_this.reality[k]);
+      Object.keys(_this.reality).forEach(function (k) {
+        return callback(_this.reality[k], k);
       });
     });
 
@@ -54489,14 +54504,14 @@ var Config$1 = new Config();var Universe = /*#__PURE__*/function () {
       var keys = Object.keys(_this.reality);
       return new Promise(function (resolve) {
         Promise.all(keys.map(function (k) {
-          return callback(_this.reality[k]);
+          return callback(_this.reality[k], k);
         })).then(resolve);
       });
     });
 
     _defineProperty$1(this, "bigfreeze", function () {
       _this.forEach(function (o) {
-        return o.dispose();
+        o && o.dispose && o.dispose();
       });
 
       _this.reset();
@@ -54913,8 +54928,12 @@ function createBase64WorkerFactory(base64, sourcemapArg, enableUnicodeArg) {
   }
 };var PI = Math.PI;
 var PI_2$1 = PI / 2;
-var pickRandom = function pickRandom(list) {
-  return list.length && list[Math.floor(Math.random() * list.length)];
+var identity = function identity(a) {
+  return a;
+};
+var pickRandom = function pickRandom() {
+  var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return list[Math.floor(Math.random() * list.length)];
 };
 var degToRad = function degToRad(angle) {
   return angle * (PI / 180);
@@ -55041,7 +55060,7 @@ var smoothDampAngle = function smoothDampAngle(current, target, currentVelocity,
   var dt = arguments.length > 5 ? arguments[5] : undefined;
   target = current + deltaAngle(current, target);
   return smoothDamp(current, target, currentVelocity, smoothTime, maxSpeed, dt);
-};var math=/*#__PURE__*/Object.freeze({__proto__:null,PI:PI,PI_2:PI_2$1,pickRandom:pickRandom,degToRad:degToRad,getProportion:getProportion,clamp:clamp,isWithin:isWithin,randomIntFromInterval:randomIntFromInterval,getDistance:getDistance,findPointBetweenAtDistance:findPointBetweenAtDistance,lerpVectors:lerpVectors,lerp:lerp,scaleVector:scaleVector,getSphereVolume:getSphereVolume,repeat:repeat,deltaAngle:deltaAngle,smoothDamp:smoothDamp,smoothDampAngle:smoothDampAngle});var LIBRARY_NAME = 'ammo.js';
+};var math=/*#__PURE__*/Object.freeze({__proto__:null,PI:PI,PI_2:PI_2$1,identity:identity,pickRandom:pickRandom,degToRad:degToRad,getProportion:getProportion,clamp:clamp,isWithin:isWithin,randomIntFromInterval:randomIntFromInterval,getDistance:getDistance,findPointBetweenAtDistance:findPointBetweenAtDistance,lerpVectors:lerpVectors,lerp:lerp,scaleVector:scaleVector,getSphereVolume:getSphereVolume,repeat:repeat,deltaAngle:deltaAngle,smoothDamp:smoothDamp,smoothDampAngle:smoothDampAngle});var LIBRARY_NAME = 'ammo.js';
 var TYPES = {
   BOX: 'BOX',
   SPHERE: 'SPHERE',
@@ -55501,17 +55520,6 @@ var Physics = /*#__PURE__*/function (_EventDispatcher) {
       }
     });
 
-    _defineProperty$1(_assertThisInitialized(_this), "disposeElement", function (element) {
-      if (Config$1.physics().enabled) {
-        var uuid = element.uuid();
-
-        _this.worker.postMessage({
-          event: PHYSICS_EVENTS.ELEMENT.DISPOSE,
-          uuid: uuid
-        });
-      }
-    });
-
     _defineProperty$1(_assertThisInitialized(_this), "explosion", function (element, strength, radius) {
       if (Config$1.physics().enabled) {
         var uuid = element.uuid();
@@ -57196,7 +57204,7 @@ function applyMiddleware() {
 
 var thunk = createThunkMiddleware();
 thunk.withExtraArgument = createThunkMiddleware;var name = "mage-engine";
-var version = "3.17.6";
+var version = "3.17.7";
 var description = "A WebGL Javascript Game Engine, built on top of THREE.js and many other libraries.";
 var main = "dist/mage.js";
 var author$1 = {
@@ -58712,1601 +58720,1642 @@ var Scripts = /*#__PURE__*/function () {
 
   return Scripts;
 }();
-var Scripts$1 = new Scripts();var Entity = /*#__PURE__*/function (_EventDispatcher) {
-  _inherits(Entity, _EventDispatcher);
+var Scripts$1 = new Scripts();var inverseProjectionMatrix = new Matrix4();
 
-  var _super = _createSuper(Entity);
+var Frustum = /*#__PURE__*/function () {
+  function Frustum(data) {
+    _classCallCheck(this, Frustum);
 
-  function Entity() {
-    var _this;
+    data = data || {};
+    this.vertices = {
+      near: [new Vector3$1(), new Vector3$1(), new Vector3$1(), new Vector3$1()],
+      far: [new Vector3$1(), new Vector3$1(), new Vector3$1(), new Vector3$1()]
+    };
 
-    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref$serializable = _ref.serializable,
-        serializable = _ref$serializable === void 0 ? true : _ref$serializable,
-        _ref$tag = _ref.tag,
-        tag = _ref$tag === void 0 ? '' : _ref$tag,
-        _ref$tags = _ref.tags,
-        tags = _ref$tags === void 0 ? [] : _ref$tags;
+    if (data.projectionMatrix !== undefined) {
+      this.setFromProjectionMatrix(data.projectionMatrix, data.maxFar || 10000);
+    }
+  }
 
-    _classCallCheck(this, Entity);
+  _createClass(Frustum, [{
+    key: "setFromProjectionMatrix",
+    value: function setFromProjectionMatrix(projectionMatrix, maxFar) {
+      var isOrthographic = projectionMatrix.elements[2 * 4 + 3] === 0;
+      inverseProjectionMatrix.copy(projectionMatrix).invert(); // 3 --- 0  vertices.near/far order
+      // |     |
+      // 2 --- 1
+      // clip space spans from [-1, 1]
 
-    _this = _super.call(this);
+      this.vertices.near[0].set(1, 1, -1);
+      this.vertices.near[1].set(1, -1, -1);
+      this.vertices.near[2].set(-1, -1, -1);
+      this.vertices.near[3].set(-1, 1, -1);
+      this.vertices.near.forEach(function (v) {
+        v.applyMatrix4(inverseProjectionMatrix);
+      });
+      this.vertices.far[0].set(1, 1, 1);
+      this.vertices.far[1].set(1, -1, 1);
+      this.vertices.far[2].set(-1, -1, 1);
+      this.vertices.far[3].set(-1, 1, 1);
+      this.vertices.far.forEach(function (v) {
+        v.applyMatrix4(inverseProjectionMatrix);
+        var absZ = Math.abs(v.z);
 
-    _defineProperty$1(_assertThisInitialized(_this), "getBodyByName", function (name) {
-      if (name && _this.hasBody()) {
-        return _this.getBody().getObjectByName(name);
+        if (isOrthographic) {
+          v.z *= Math.min(maxFar / absZ, 1.0);
+        } else {
+          v.multiplyScalar(Math.min(maxFar / absZ, 1.0));
+        }
+      });
+      return this.vertices;
+    }
+  }, {
+    key: "split",
+    value: function split(breaks, target) {
+      while (breaks.length > target.length) {
+        target.push(new Frustum());
       }
 
-      console.warn(ELEMENT_NAME_NOT_PROVIDED);
-    });
+      target.length = breaks.length;
 
-    _defineProperty$1(_assertThisInitialized(_this), "addTag", function (tagName) {
-      if (!tagName) return;
+      for (var i = 0; i < breaks.length; i++) {
+        var cascade = target[i];
 
-      if (!_this.hasTag(tagName)) {
-        _this.tags.push(tagName);
+        if (i === 0) {
+          for (var j = 0; j < 4; j++) {
+            cascade.vertices.near[j].copy(this.vertices.near[j]);
+          }
+        } else {
+          for (var _j = 0; _j < 4; _j++) {
+            cascade.vertices.near[_j].lerpVectors(this.vertices.near[_j], this.vertices.far[_j], breaks[i - 1]);
+          }
+        }
 
-        return true;
-      } else {
-        console.log(TAG_ALREADY_EXISTS, tagName);
-        return false;
+        if (i === breaks - 1) {
+          for (var _j2 = 0; _j2 < 4; _j2++) {
+            cascade.vertices.far[_j2].copy(this.vertices.far[_j2]);
+          }
+        } else {
+          for (var _j3 = 0; _j3 < 4; _j3++) {
+            cascade.vertices.far[_j3].lerpVectors(this.vertices.near[_j3], this.vertices.far[_j3], breaks[i]);
+          }
+        }
       }
-    });
-
-    _defineProperty$1(_assertThisInitialized(_this), "hasStateMachine", function () {
-      return !!_this.stateMachine;
-    });
-
-    _defineProperty$1(_assertThisInitialized(_this), "hasScripts", function () {
-      return _this.scripts.length > 0;
-    });
-
-    _defineProperty$1(_assertThisInitialized(_this), "parseScripts", function (list, options, enabled) {
-      return list.map(function (script, i) {
-        return {
-          script: script,
-          name: script.getName(),
-          enabled: enabled,
-          options: options[i]
-        };
-      });
-    });
-
-    _defineProperty$1(_assertThisInitialized(_this), "isMesh", function () {
-      return _this.getEntityType() === ENTITY_TYPES.MESH;
-    });
-
-    _defineProperty$1(_assertThisInitialized(_this), "isModel", function () {
-      return _this.getEntityType() === ENTITY_TYPES.MODEL;
-    });
-
-    _defineProperty$1(_assertThisInitialized(_this), "isSprite", function () {
-      return _this.getEntityType() === ENTITY_TYPES.SPRITE;
-    });
+    }
+  }, {
+    key: "toSpace",
+    value: function toSpace(cameraMatrix, target) {
+      for (var i = 0; i < 4; i++) {
+        target.vertices.near[i].copy(this.vertices.near[i]).applyMatrix4(cameraMatrix);
+        target.vertices.far[i].copy(this.vertices.far[i]).applyMatrix4(cameraMatrix);
+      }
+    }
+  }]);
 
-    _defineProperty$1(_assertThisInitialized(_this), "isLight", function () {
-      return Object.values(ENTITY_TYPES.LIGHT).includes(_this.getEntityType());
-    });
+  return Frustum;
+}();var Shader$1 = {
+  lights_fragment_begin:
+  /* glsl */
+  "\nGeometricContext geometry;\n\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n\n#ifdef CLEARCOAT\n\n    geometry.clearcoatNormal = clearcoatNormal;\n\n#endif\n\nIncidentLight directLight;\n\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\n    PointLight pointLight;\n    #if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n    PointLightShadow pointLightShadow;\n    #endif\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\n        pointLight = pointLights[ i ];\n\n        getPointDirectLightIrradiance( pointLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n        pointLightShadow = pointLightShadows[ i ];\n        directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n        #endif\n\n        RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\n    SpotLight spotLight;\n    #if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n    SpotLightShadow spotLightShadow;\n    #endif\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\n        spotLight = spotLights[ i ];\n\n        getSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n        spotLightShadow = spotLightShadows[ i ];\n        directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n        #endif\n\n        RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if ( NUM_DIR_LIGHTS > 0) && defined( RE_Direct ) && defined( USE_CSM ) && defined( CSM_CASCADES )\n\n    DirectionalLight directionalLight;\n    float linearDepth = (vViewPosition.z) / (shadowFar - cameraNear);\n    #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n    DirectionalLightShadow directionalLightShadow;\n    #endif\n\n    #if defined( USE_SHADOWMAP ) && defined( CSM_FADE )\n    vec2 cascade;\n    float cascadeCenter;\n    float closestEdge;\n    float margin;\n    float csmx;\n    float csmy;\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\n        directionalLight = directionalLights[ i ];\n        getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n        // NOTE: Depth gets larger away from the camera.\n        // cascade.x is closer, cascade.y is further\n        cascade = CSM_cascades[ i ];\n        cascadeCenter = ( cascade.x + cascade.y ) / 2.0;\n        closestEdge = linearDepth < cascadeCenter ? cascade.x : cascade.y;\n        margin = 0.25 * pow( closestEdge, 2.0 );\n        csmx = cascade.x - margin / 2.0;\n        csmy = cascade.y + margin / 2.0;\n        if( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS && linearDepth >= csmx && ( linearDepth < csmy || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 ) ) {\n\n            float dist = min( linearDepth - csmx, csmy - linearDepth );\n            float ratio = clamp( dist / margin, 0.0, 1.0 );\n            if( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS ) {\n\n                vec3 prevColor = directLight.color;\n                directionalLightShadow = directionalLightShadows[ i ];\n                directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\n                bool shouldFadeLastCascade = UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth > cascadeCenter;\n                directLight.color = mix( prevColor, directLight.color, shouldFadeLastCascade ? ratio : 1.0 );\n\n            }\n\n            ReflectedLight prevLight = reflectedLight;\n            RE_Direct( directLight, geometry, material, reflectedLight );\n\n            bool shouldBlend = UNROLLED_LOOP_INDEX != CSM_CASCADES - 1 || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth < cascadeCenter;\n            float blendRatio = shouldBlend ? ratio : 1.0;\n\n            reflectedLight.directDiffuse = mix( prevLight.directDiffuse, reflectedLight.directDiffuse, blendRatio );\n            reflectedLight.directSpecular = mix( prevLight.directSpecular, reflectedLight.directSpecular, blendRatio );\n            reflectedLight.indirectDiffuse = mix( prevLight.indirectDiffuse, reflectedLight.indirectDiffuse, blendRatio );\n            reflectedLight.indirectSpecular = mix( prevLight.indirectSpecular, reflectedLight.indirectSpecular, blendRatio );\n\n        }\n\n    }\n    #pragma unroll_loop_end\n    #else\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\n        directionalLight = directionalLights[ i ];\n        getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\n        directionalLightShadow = directionalLightShadows[ i ];\n        if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y) directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\n        #endif\n\n        if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && (linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1)) RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n    #endif\n\n#endif\n\n\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct ) && !defined( USE_CSM ) && !defined( CSM_CASCADES )\n\n    DirectionalLight directionalLight;\n    #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n    DirectionalLightShadow directionalLightShadow;\n    #endif\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\n        directionalLight = directionalLights[ i ];\n\n        getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n        directionalLightShadow = directionalLightShadows[ i ];\n        directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n        #endif\n\n        RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\n    RectAreaLight rectAreaLight;\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\n        rectAreaLight = rectAreaLights[ i ];\n        RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if defined( RE_IndirectDiffuse )\n\n    vec3 iblIrradiance = vec3( 0.0 );\n\n    vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\n    irradiance += getLightProbeIrradiance( lightProbe, geometry );\n\n    #if ( NUM_HEMI_LIGHTS > 0 )\n\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\n            irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\n        }\n        #pragma unroll_loop_end\n\n    #endif\n\n#endif\n\n#if defined( RE_IndirectSpecular )\n\n    vec3 radiance = vec3( 0.0 );\n    vec3 clearcoatRadiance = vec3( 0.0 );\n\n#endif\n",
+  lights_pars_begin:
+  /* glsl */
+  "\n#if defined( USE_CSM ) && defined( CSM_CASCADES )\nuniform vec2 CSM_cascades[CSM_CASCADES];\nuniform float cameraNear;\nuniform float shadowFar;\n#endif\n    " + ShaderChunk.lights_pars_begin
+};var _cameraToLightMatrix = new Matrix4();
 
-    _defineProperty$1(_assertThisInitialized(_this), "isHelper", function () {
-      return Object.values(ENTITY_TYPES.HELPER).includes(_this.getEntityType());
-    });
+var _lightSpaceFrustum = new Frustum();
 
-    _defineProperty$1(_assertThisInitialized(_this), "isEffect", function () {
-      return Object.values(ENTITY_TYPES.EFFECT).includes(_this.getEntityType());
-    });
+var _center = new Vector3$1();
 
-    _defineProperty$1(_assertThisInitialized(_this), "setQuaternion", function (_ref2) {
-      var x = _ref2.x,
-          y = _ref2.y,
-          z = _ref2.z,
-          w = _ref2.w;
+var _bbox = new Box3();
 
-      _this.body.quaternion.set(x, y, z, w);
-    });
+var _uniformArray = [];
+var _logArray = [];
+var DEFAULT_MAX_FAR = 100000;
+var DEFAULT_MODE = 'practical';
+var DEFAULT_SHADOWMAP_SIZE = 2048;
+var DEFAULT_CASCADE = 3;
+var DEFAULT_BIAS$3 = 0.000001;
+var DEFAULT_INTENSITY$5 = 1;
+var DEFAULT_NEAR$3 = 1;
+var DEFAULT_FAR$3 = 2000;
+var DEFAULT_MARGIN = 200;
+var CascadeShadowMaps = /*#__PURE__*/function () {
+  function CascadeShadowMaps(_ref) {
+    var _ref$camera = _ref.camera,
+        camera = _ref$camera === void 0 ? Scene$1.getCameraBody() : _ref$camera,
+        _ref$parent = _ref.parent,
+        parent = _ref$parent === void 0 ? Scene$1.getScene() : _ref$parent,
+        _ref$cascades = _ref.cascades,
+        cascades = _ref$cascades === void 0 ? DEFAULT_CASCADE : _ref$cascades,
+        _ref$maxFar = _ref.maxFar,
+        maxFar = _ref$maxFar === void 0 ? DEFAULT_MAX_FAR : _ref$maxFar,
+        _ref$mode = _ref.mode,
+        mode = _ref$mode === void 0 ? DEFAULT_MODE : _ref$mode,
+        _ref$shadowMapSize = _ref.shadowMapSize,
+        shadowMapSize = _ref$shadowMapSize === void 0 ? DEFAULT_SHADOWMAP_SIZE : _ref$shadowMapSize,
+        _ref$shadowBias = _ref.shadowBias,
+        shadowBias = _ref$shadowBias === void 0 ? DEFAULT_BIAS$3 : _ref$shadowBias,
+        _ref$lightDirection = _ref.lightDirection,
+        lightDirection = _ref$lightDirection === void 0 ? new Vector3$1(1, -1, 1).normalize() : _ref$lightDirection,
+        _ref$lightIntensity = _ref.lightIntensity,
+        lightIntensity = _ref$lightIntensity === void 0 ? DEFAULT_INTENSITY$5 : _ref$lightIntensity,
+        _ref$lightNear = _ref.lightNear,
+        lightNear = _ref$lightNear === void 0 ? DEFAULT_NEAR$3 : _ref$lightNear,
+        _ref$lightFar = _ref.lightFar,
+        lightFar = _ref$lightFar === void 0 ? DEFAULT_FAR$3 : _ref$lightFar,
+        _ref$lightMargin = _ref.lightMargin,
+        lightMargin = _ref$lightMargin === void 0 ? DEFAULT_MARGIN : _ref$lightMargin,
+        customSplitsCallback = _ref.customSplitsCallback;
 
-    _defineProperty$1(_assertThisInitialized(_this), "setUuid", function (uuid) {
-      if (uuid) {
-        _this.body.uuid = uuid;
-      }
-    });
+    _classCallCheck(this, CascadeShadowMaps);
 
-    _this.scripts = [];
-    _this.tags = [];
-    _this.children = [];
-    _this.isMage = true;
-    _this.parent = false;
+    this.camera = camera;
+    this.parent = parent;
+    this.cascades = cascades;
+    this.maxFar = maxFar;
+    this.mode = mode;
+    this.shadowMapSize = shadowMapSize;
+    this.shadowBias = shadowBias;
+    this.lightDirection = lightDirection;
+    this.lightIntensity = lightIntensity;
+    this.lightNear = lightNear;
+    this.lightFar = lightFar;
+    this.lightMargin = lightMargin;
+    this.customSplitsCallback = customSplitsCallback;
+    this.fade = false;
+    this.mainFrustum = new Frustum();
+    this.frustums = [];
+    this.breaks = [];
+    this.lights = [];
+    this.shaders = new Map();
+    this.createLights();
+    this.updateFrustums();
+    this.injectInclude();
+  }
 
-    _this.addTags([DEFAULT_TAG, tag].concat(_toConsumableArray(tags)));
-
-    _this.serializable = serializable;
-    return _this;
-  }
-
-  _createClass(Entity, [{
-    key: "isSerializable",
-    value: function isSerializable() {
-      return !!this.serializable;
-    }
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.scripts = [];
-      this.children = [];
-      this.isMage = true;
-      this.parent = false;
-      this.tags = [DEFAULT_TAG];
-    }
-  }, {
-    key: "hasBody",
-    value: function hasBody() {
-      return !!this.body;
-    }
-  }, {
-    key: "getBody",
-    value: function getBody() {
-      return this.body;
-    }
-  }, {
-    key: "setBody",
-    value: function setBody(body) {
-      this.body = body;
-    }
-  }, {
-    key: "hasParent",
-    value: function hasParent() {
-      return !!this.parent;
-    }
-  }, {
-    key: "getParent",
-    value: function getParent() {
-      return this.parent;
+  _createClass(CascadeShadowMaps, [{
+    key: "createLights",
+    value: function createLights() {
+      for (var i = 0; i < this.cascades; i++) {
+        var light = new DirectionalLight(0xffffff, this.lightIntensity);
+        light.castShadow = true;
+        light.shadow.mapSize.width = this.shadowMapSize;
+        light.shadow.mapSize.height = this.shadowMapSize;
+        light.shadow.camera.near = this.lightNear;
+        light.shadow.camera.far = this.lightFar;
+        light.shadow.bias = this.shadowBias;
+        this.parent.add(light);
+        this.parent.add(light.target);
+        this.lights.push(light);
+      }
     }
   }, {
-    key: "setParent",
-    value: function setParent(parent) {
-      this.parent = parent;
+    key: "initCascades",
+    value: function initCascades() {
+      var camera = this.camera;
+      camera.updateProjectionMatrix();
+      this.mainFrustum.setFromProjectionMatrix(camera.projectionMatrix, this.maxFar);
+      this.mainFrustum.split(this.breaks, this.frustums);
     }
   }, {
-    key: "add",
-    value: function add(child) {
-      var _this2 = this;
-
-      var container = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getBody();
+    key: "updateShadowBounds",
+    value: function updateShadowBounds() {
+      var frustums = this.frustums;
 
-      if (this.hasBody()) {
-        var _add = function _add(toAdd) {
-          if (toAdd instanceof Entity) {
-            _this2.children.push(toAdd);
+      for (var i = 0; i < frustums.length; i++) {
+        var light = this.lights[i];
+        var shadowCam = light.shadow.camera;
+        var frustum = this.frustums[i]; // Get the two points that represent that furthest points on the frustum assuming
+        // that's either the diagonal across the far plane or the diagonal across the whole
+        // frustum itself.
 
-            toAdd.setParent(_this2);
-            container.add(toAdd.getBody());
-          } else {
-            console.log(ENTITY_CANT_ADD_NOT_ENTITY);
-          }
-        };
+        var nearVerts = frustum.vertices.near;
+        var farVerts = frustum.vertices.far;
+        var point1 = farVerts[0];
+        var point2 = void 0;
 
-        if (Array.isArray(child)) {
-          child.forEach(_add);
+        if (point1.distanceTo(farVerts[2]) > point1.distanceTo(nearVerts[2])) {
+          point2 = farVerts[2];
         } else {
-          _add(child);
+          point2 = nearVerts[2];
         }
-      } else {
-        console.log(ENTITY_NOT_SET);
+
+        var squaredBBWidth = point1.distanceTo(point2);
+
+        if (this.fade) {
+          // expand the shadow extents by the fade margin if fade is enabled.
+          var camera = this.camera;
+          var far = Math.max(camera.far, this.maxFar);
+          var linearDepth = frustum.vertices.far[0].z / (far - camera.near);
+          var margin = 0.25 * Math.pow(linearDepth, 2.0) * (far - camera.near);
+          squaredBBWidth += margin;
+        }
+
+        shadowCam.left = -squaredBBWidth / 2;
+        shadowCam.right = squaredBBWidth / 2;
+        shadowCam.top = squaredBBWidth / 2;
+        shadowCam.bottom = -squaredBBWidth / 2;
+        shadowCam.updateProjectionMatrix();
       }
     }
   }, {
-    key: "isParentOf",
-    value: function isParentOf(child) {
-      var comparator = function comparator(child) {
-        return !!child.getBody().getObjectById(child.id);
-      };
+    key: "getBreaks",
+    value: function getBreaks() {
+      var camera = this.camera;
+      var far = Math.min(camera.far, this.maxFar);
+      this.breaks.length = 0;
 
-      if (child.isMage) {
-        comparator = function comparator(child) {
-          return child.getBody().getObjectById(child.id());
-        };
+      switch (this.mode) {
+        case 'uniform':
+          uniformSplit(this.cascades, camera.near, far, this.breaks);
+          break;
+
+        case 'logarithmic':
+          logarithmicSplit(this.cascades, camera.near, far, this.breaks);
+          break;
+
+        case 'practical':
+          practicalSplit(this.cascades, camera.near, far, 0.5, this.breaks);
+          break;
+
+        case 'custom':
+          if (this.customSplitsCallback === undefined) console.error('CSM: Custom split scheme callback not defined.');
+          this.customSplitsCallback(this.cascades, camera.near, far, this.breaks);
+          break;
       }
 
-      return this.children.filter(comparator).length > 0;
-    }
-  }, {
-    key: "has",
-    value: function has(child) {
-      if (child.isMage) {
-        return this.equals(child) || this.isParentOf(child);
-      } else {
-        return !!this.getBody().getObjectById(child.id);
+      function uniformSplit(amount, near, far, target) {
+        for (var i = 1; i < amount; i++) {
+          target.push((near + (far - near) * i / amount) / far);
+        }
+
+        target.push(1);
       }
-    }
-  }, {
-    key: "remove",
-    value: function remove(element) {
-      if (this.hasBody() && this.has(element)) {
-        if (element.isMage) {
-          this.body.remove(element.getBody());
-          var index = this.children.findIndex(function (m) {
-            return m.equals(element);
-          });
-          if (index) this.children.splice(index, 1);
-        } else {
-          this.body.remove(element.getBody());
+
+      function logarithmicSplit(amount, near, far, target) {
+        for (var i = 1; i < amount; i++) {
+          target.push(near * Math.pow(far / near, i / amount) / far);
+        }
+
+        target.push(1);
+      }
+
+      function practicalSplit(amount, near, far, lambda, target) {
+        _uniformArray.length = 0;
+        _logArray.length = 0;
+        logarithmicSplit(amount, near, far, _logArray);
+        uniformSplit(amount, near, far, _uniformArray);
+
+        for (var i = 1; i < amount; i++) {
+          target.push(MathUtils.lerp(_uniformArray[i - 1], _logArray[i - 1], lambda));
         }
+
+        target.push(1);
       }
     }
   }, {
-    key: "addTo",
-    value: function addTo(target, childName) {
-      if (target && target.isMage) {
-        if (childName) {
-          target.add(this, target.getBodyByName(childName));
-        } else {
-          target.add(this);
+    key: "update",
+    value: function update() {
+      var camera = this.camera;
+      var frustums = this.frustums;
+
+      for (var i = 0; i < frustums.length; i++) {
+        var light = this.lights[i];
+        var shadowCam = light.shadow.camera;
+        var texelWidth = (shadowCam.right - shadowCam.left) / this.shadowMapSize;
+        var texelHeight = (shadowCam.top - shadowCam.bottom) / this.shadowMapSize;
+        light.shadow.camera.updateMatrixWorld(true);
+
+        _cameraToLightMatrix.multiplyMatrices(light.shadow.camera.matrixWorldInverse, camera.matrixWorld);
+
+        frustums[i].toSpace(_cameraToLightMatrix, _lightSpaceFrustum);
+        var nearVerts = _lightSpaceFrustum.vertices.near;
+        var farVerts = _lightSpaceFrustum.vertices.far;
+
+        _bbox.makeEmpty();
+
+        for (var j = 0; j < 4; j++) {
+          _bbox.expandByPoint(nearVerts[j]);
+
+          _bbox.expandByPoint(farVerts[j]);
         }
+
+        _bbox.getCenter(_center);
+
+        _center.z = _bbox.max.z + this.lightMargin;
+        _center.x = Math.floor(_center.x / texelWidth) * texelWidth;
+        _center.y = Math.floor(_center.y / texelHeight) * texelHeight;
+
+        _center.applyMatrix4(light.shadow.camera.matrixWorld);
+
+        light.position.copy(_center);
+        light.target.position.copy(_center);
+        light.target.position.x += this.lightDirection.x;
+        light.target.position.y += this.lightDirection.y;
+        light.target.position.z += this.lightDirection.z;
       }
     }
   }, {
-    key: "getHierarchy",
-    value: function getHierarchy() {
-      return {
-        element: this,
-        children: this.children.map(function (e) {
-          return e.getHierarchy();
-        })
-      };
+    key: "injectInclude",
+    value: function injectInclude() {
+      ShaderChunk.lights_fragment_begin = Shader$1.lights_fragment_begin;
+      ShaderChunk.lights_pars_begin = Shader$1.lights_pars_begin;
     }
   }, {
-    key: "addTags",
-    value: function addTags() {
-      var tags = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      tags.forEach(this.addTag);
-    }
-  }, {
-    key: "removeTag",
-    value: function removeTag(tagName) {
-      if (tagName === DEFAULT_TAG) {
-        console.log(TAG_CANT_BE_REMOVED);
-        return;
-      }
+    key: "setupMaterial",
+    value: function setupMaterial(material) {
+      material.defines = material.defines || {};
+      material.defines.USE_CSM = 1;
+      material.defines.CSM_CASCADES = this.cascades;
 
-      if (this.hasTag(tagName)) {
-        this.tags.splice(this.tags.indexOf(tagName), 1);
-      } else {
-        console.log(TAG_NOT_EXISTING_REMOVAL);
+      if (this.fade) {
+        material.defines.CSM_FADE = '';
       }
-    }
-  }, {
-    key: "removeAllTags",
-    value: function removeAllTags() {
-      this.tags = [DEFAULT_TAG];
-    }
-  }, {
-    key: "hasTag",
-    value: function hasTag(tagName) {
-      return this.tags.includes(tagName);
-    }
-  }, {
-    key: "getTags",
-    value: function getTags() {
-      return this.tags;
-    }
-  }, {
-    key: "stopScripts",
-    value: function stopScripts() {
-      if (this.hasScripts()) {
-        this.scripts.forEach(function (_ref3) {
-          var script = _ref3.script,
-              enabled = _ref3.enabled;
 
-          if (enabled) {
-            script.onDispose();
+      var breaksVec2 = [];
+      var scope = this;
+      var shaders = this.shaders;
 
-            script.__hasStarted(false);
-          }
-        });
-      }
+      material.onBeforeCompile = function (shader) {
+        var far = Math.min(scope.camera.far, scope.maxFar);
+        scope.getExtendedBreaks(breaksVec2);
+        shader.uniforms.CSM_cascades = {
+          value: breaksVec2
+        };
+        shader.uniforms.cameraNear = {
+          value: scope.camera.near
+        };
+        shader.uniforms.shadowFar = {
+          value: far
+        };
+        shaders.set(material, shader);
+      };
+
+      shaders.set(material, null);
     }
   }, {
-    key: "start",
-    value: function start() {
-      var _this3 = this;
+    key: "updateUniforms",
+    value: function updateUniforms() {
+      var far = Math.min(this.camera.far, this.maxFar);
+      var shaders = this.shaders;
+      shaders.forEach(function (shader, material) {
+        if (shader !== null) {
+          var uniforms = shader.uniforms;
+          this.getExtendedBreaks(uniforms.CSM_cascades.value);
+          uniforms.cameraNear.value = this.camera.near;
+          uniforms.shadowFar.value = far;
+        }
 
-      if (this.hasScripts()) {
-        this.scripts.forEach(function (_ref4) {
-          var script = _ref4.script,
-              enabled = _ref4.enabled,
-              options = _ref4.options;
+        if (!this.fade && 'CSM_FADE' in material.defines) {
+          delete material.defines.CSM_FADE;
+          material.needsUpdate = true;
+        } else if (this.fade && !('CSM_FADE' in material.defines)) {
+          material.defines.CSM_FADE = '';
+          material.needsUpdate = true;
+        }
+      }, this);
+    }
+  }, {
+    key: "getExtendedBreaks",
+    value: function getExtendedBreaks(target) {
+      while (target.length < this.breaks.length) {
+        target.push(new Vector2());
+      }
 
-          if (enabled) {
-            script.start(_this3, options);
+      target.length = this.breaks.length;
 
-            script.__hasStarted(true);
-          }
-        });
+      for (var i = 0; i < this.cascades; i++) {
+        var amount = this.breaks[i];
+        var prev = this.breaks[i - 1] || 0;
+        target[i].x = prev;
+        target[i].y = amount;
       }
     }
   }, {
-    key: "update",
-    value: function update(dt) {
-      if (this.hasScripts()) {
-        this.scripts.forEach(function (_ref5) {
-          var script = _ref5.script,
-              enabled = _ref5.enabled;
-
-          if (script && enabled) {
-            script.update(dt);
-          }
-        });
-      }
+    key: "updateFrustums",
+    value: function updateFrustums() {
+      this.getBreaks();
+      this.initCascades();
+      this.updateShadowBounds();
+      this.updateUniforms();
     }
   }, {
-    key: "onPhysicsUpdate",
-    value: function onPhysicsUpdate(dt) {
-      if (this.hasScripts()) {
-        this.scripts.forEach(function (_ref6) {
-          var script = _ref6.script,
-              enabled = _ref6.enabled;
-
-          if (script && enabled) {
-            script.physicsUpdate(dt);
-          }
-        });
+    key: "remove",
+    value: function remove() {
+      for (var i = 0; i < this.lights.length; i++) {
+        this.parent.remove(this.lights[i]);
       }
     }
   }, {
     key: "dispose",
     value: function dispose() {
-      if (this.hasBody()) {
-        this.stopStateMachine();
-        this.stopScripts();
-        this.reset();
-      }
+      var shaders = this.shaders;
+      shaders.forEach(function (shader, material) {
+        delete material.onBeforeCompile;
+        delete material.defines.USE_CSM;
+        delete material.defines.CSM_CASCADES;
+        delete material.defines.CSM_FADE;
 
-      this.dispatchEvent({
-        type: ENTITY_EVENTS.DISPOSE
+        if (shader !== null) {
+          delete shader.uniforms.CSM_cascades;
+          delete shader.uniforms.cameraNear;
+          delete shader.uniforms.shadowFar;
+        }
+
+        material.needsUpdate = true;
       });
+      shaders.clear();
     }
-  }, {
-    key: "addStateMachine",
-    value: function addStateMachine(description) {
-      var _this4 = this;
+  }]);
 
-      this.stateMachine = interpret(createMachine(description)).onTransition(function (state) {
-        _this4.dispatchEvent({
-          type: ENTITY_EVENTS.STATE_MACHINE.CHANGE,
-          state: state
-        });
-      });
+  return CascadeShadowMaps;
+}();var POINTLIGHT = 'pointlight';
+var AMBIENTLIGHT = 'ambientlight';
+var SUNLIGHT = 'sunlight';
+var SPOTLIGHT = 'spotlight';
+var HEMISPHERELIGHT = 'hemisphere';
+var TIME_TO_UPDATE = 5;
+var Lights = /*#__PURE__*/function () {
+  function Lights() {
+    _classCallCheck(this, Lights);
 
-      if (description.autostart) {
-        this.startStateMachine();
-      }
-    }
-  }, {
-    key: "startStateMachine",
-    value: function startStateMachine() {
-      if (this.hasStateMachine()) {
-        this.stateMachine.start();
-      } else {
-        console.log(STATE_MACHINE_NOT_AVAILABLE);
-      }
+    this.delayFactor = 0.1;
+    this.delayStep = 30;
+    this.holderRadius = 0.01;
+    this.holderSegments = 1;
+    this.numLights = 0;
+    this.map = {};
+    this.lights = [];
+    this.csm = undefined;
+  }
+
+  _createClass(Lights, [{
+    key: "isUsingCSM",
+    value: function isUsingCSM() {
+      return !!this.csm;
     }
   }, {
-    key: "stopStateMachine",
-    value: function stopStateMachine() {
-      if (this.hasStateMachine()) {
-        this.stateMachine.stop();
-      }
+    key: "setUpCSM",
+    value: function setUpCSM() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      this.csm = new CascadeShadowMaps(options);
     }
   }, {
-    key: "changeState",
-    value: function changeState(event) {
-      if (this.hasStateMachine()) {
-        this.stateMachine.send(event);
-      } else {
-        console.log(STATE_MACHINE_NOT_AVAILABLE);
-      }
+    key: "add",
+    value: function add(light) {
+      this.lights.push(light);
     }
   }, {
-    key: "getScript",
-    value: function getScript(name) {
-      var script = this.scripts.filter(function (script) {
-        return script.name === name;
-      })[0].script;
-
-      if (script) {
-        return script;
-      } else {
-        console.warn(SCRIPT_NOT_FOUND);
+    key: "update",
+    value: function update(dt) {
+      if (this.isUsingCSM()) {
+        this.csm.update();
       }
-    }
-  }, {
-    key: "addScripts",
-    value: function addScripts() {
-      var _this5 = this;
 
-      var scripts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-      var enabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-      var parsedScripts = this.parseScripts(scripts, options, enabled);
-      this.scripts = [].concat(_toConsumableArray(this.scripts), [parsedScripts]);
+      var start = new Date();
 
-      if (enabled) {
-        parsedScripts.forEach(function (parsed) {
-          return parsed.start(_this5, parsed.options);
-        });
+      for (var index in this.lights) {
+        var light = this.lights[index];
+        light.update(dt);
+        if (+new Date() - start > TIME_TO_UPDATE) break;
       }
     }
   }, {
-    key: "addScript",
-    value: function addScript(name) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      var script = Scripts$1.get(name);
-      var _options$enabled = options.enabled,
-          enabled = _options$enabled === void 0 ? true : _options$enabled;
-
-      if (script) {
-        this.scripts.push({
-          script: script,
-          name: name,
-          enabled: enabled,
-          options: options
-        });
-
-        if (enabled) {
-          script.start(this, options);
-        }
-      } else {
-        console.log(SCRIPT_NOT_FOUND);
-      }
-
-      return script;
-    }
-  }, {
-    key: "enableScripts",
-    value: function enableScripts() {
-      this.scriptsEnabled = true;
-    }
-  }, {
-    key: "disableScripts",
-    value: function disableScripts() {
-      this.scriptsEnabled = false;
-    }
-  }, {
-    key: "setEntityType",
-    value: function setEntityType(type) {
-      if (FLAT_ENTITY_TYPES.includes(type)) {
-        this.entityType = type;
-      } else {
-        console.log(ENTITY_TYPE_NOT_ALLOWED);
-        this.entityType = ENTITY_TYPES.UNKNOWN;
-      }
-    }
-  }, {
-    key: "getEntityType",
-    value: function getEntityType() {
-      return this.entityType;
-    }
-  }, {
-    key: "addLight",
-    // TODO: sounds should become entities
-    // addSound(name, options) {
-    //     const { autoplay = false, ...opts } = options;
-    //     this.isPlayingSound = autoplay;
-    //     this.sound = new Sound(name, {
-    //         autoplay,
-    //         ...opts
-    //     });
-    //     this.sound.setTarget(this);
-    //     return this.sound;
-    // }
-    // addDirectionalSound(name, options) {
-    //     const { autoplay = false, ...opts } = options;
-    //     this.isPlayingSound = autoplay;
-    //     this.sound = new DirectionalSound(name, {
-    //         autoplay,
-    //         ...opts
-    //     });
-    //     this.sound.setTarget(this);
-    //     return this.sound;
-    // }
-    // addAmbientSound(name, options) {
-    //     const { autoplay = false, ...opts } = options;
-    //     this.isPlayingSound = autoplay;
-    //     this.sound = new AmbientSound(name, {
-    //         body: this.body,
-    //         autoplay,
-    //         ...opts
-    //     });
-    //     return this.sound;
-    // }
-    value: function addLight(light) {
-      var _this$getPosition = this.getPosition(),
-          x = _this$getPosition.x,
-          y = _this$getPosition.y,
-          z = _this$getPosition.z;
-
-      light.setPosition({
-        x: x,
-        y: y,
-        z: z
-      });
-      this.light = light;
-    }
-  }, {
-    key: "playSound",
-    value: function playSound() {
-      if (this.sound && !this.isPlayingSound) {
-        this.sound.play();
-        this.isPlayingSound = true;
-      }
-    }
-  }, {
-    key: "stopSound",
-    value: function stopSound() {
-      if (this.sound && this.isPlayingSound) {
-        this.sound.stop();
-        this.isPlayingSound = false;
-      }
-    }
-  }, {
-    key: "getScale",
-    value: function getScale() {
+    key: "toJSON",
+    value: function toJSON() {
       return {
-        x: this.body.scale.x,
-        y: this.body.scale.y,
-        z: this.body.scale.z
+        lights: this.lights.map(function (l) {
+          return l.toJSON();
+        })
       };
     }
-  }, {
-    key: "setScale",
-    value: function setScale(howbig) {
-      if (this.hasBody()) {
-        var scale = _objectSpread2$1(_objectSpread2$1({}, this.getScale()), howbig);
+  }]);
 
-        this.body.scale.set(scale.x, scale.y, scale.z);
-      }
-    }
-  }, {
-    key: "getQuaternion",
-    value: function getQuaternion() {
-      if (this.hasBody()) {
-        return this.getBody().quaternion.clone();
-      }
-    }
-  }, {
-    key: "getPosition",
-    value: function getPosition() {
-      return this.getBody().position.clone();
+  return Lights;
+}();
+var Lights$1 = new Lights();var ToonShader = {
+  uniforms: {
+    "uDirLightPos": {
+      type: "v3",
+      value: new Vector3$1()
+    },
+    "uDirLightColor": {
+      type: "c",
+      value: new Color$1(0xffffff)
+    },
+    "uMaterialColor": {
+      type: "c",
+      value: new Color$1(0xffffff)
+    },
+    uKd: {
+      type: "f",
+      value: 1
+    },
+    uBorder: {
+      type: "f",
+      value: 0.4
     }
-  }, {
-    key: "setPosition",
-    value: function setPosition(where) {
-      if (this.hasBody()) {
-        var _this$getPosition2 = this.getPosition(),
-            x = _this$getPosition2.x,
-            y = _this$getPosition2.y,
-            z = _this$getPosition2.z;
+  },
+  vertexShader: ["varying vec3 vNormal;", "varying vec3 vViewPosition;", "void main() {", "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", "vNormal = normalize( normalMatrix * normal );", "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", "vViewPosition = -mvPosition.xyz;", "}"].join("\n"),
+  fragmentShader: ["uniform vec3 uMaterialColor;", "uniform vec3 uDirLightPos;", "uniform vec3 uDirLightColor;", "uniform float uKd;", "uniform float uBorder;", "varying vec3 vNormal;", "varying vec3 vViewPosition;", "void main() {", // compute direction to light
+  "vec4 lDirection = viewMatrix * vec4( uDirLightPos, 0.0 );", "vec3 lVector = normalize( lDirection.xyz );", // diffuse: N * L. Normal must be normalized, since it's interpolated.
+  "vec3 normal = normalize( vNormal );", //was: "float diffuse = max( dot( normal, lVector ), 0.0);",
+  // solution
+  "float diffuse = dot( normal, lVector );", "if ( diffuse > 0.6 ) { diffuse = 1.0; }", "else if ( diffuse > -0.2 ) { diffuse = 0.7; }", "else { diffuse = 0.3; }", "gl_FragColor = vec4( uKd * uMaterialColor * uDirLightColor * diffuse, 1.0 );", "}"].join("\n")
+};
 
-        var position = _objectSpread2$1({
-          x: x,
-          y: y,
-          z: z
-        }, where);
+var ToonMaterial = /*#__PURE__*/function (_ShaderMaterial) {
+  _inherits(ToonMaterial, _ShaderMaterial);
 
-        this.body.position.set(position.x, position.y, position.z);
-      }
-    }
-  }, {
-    key: "getRotation",
-    value: function getRotation() {
-      return this.getBody().rotation.clone();
+  var _super = _createSuper(ToonMaterial);
+
+  function ToonMaterial(_ref) {
+    var _this;
+
+    var _ref$light = _ref.light,
+        light = _ref$light === void 0 ? {} : _ref$light,
+        color = _ref.color;
+
+    _classCallCheck(this, ToonMaterial);
+
+    var uniforms = UniformsUtils.clone(ToonShader.uniforms);
+    var vertexShader = ToonShader.vertexShader,
+        fragmentShader = ToonShader.fragmentShader;
+    _this = _super.call(this, {
+      uniforms: uniforms,
+      vertexShader: vertexShader,
+      fragmentShader: fragmentShader,
+      flatShading: true
+    });
+    var position = light.position,
+        lightColor = light.color;
+
+    if (color) {
+      var materialColor = new Color$1(color);
+
+      _this.uniforms.uMaterialColor.value.copy(materialColor);
     }
-  }, {
-    key: "setRotation",
-    value: function setRotation(how) {
-      if (this.hasBody()) {
-        var _this$getRotation = this.getRotation(),
-            x = _this$getRotation.x,
-            y = _this$getRotation.y,
-            z = _this$getRotation.z;
 
-        var rotation = _objectSpread2$1({
-          x: x,
-          y: y,
-          z: z
-        }, how);
+    _this.uniforms.uDirLightPos.value = position;
 
-        this.body.rotation.set(rotation.x, rotation.y, rotation.z);
+    _this.uniforms.uDirLightColor.value.copy(new Color$1(lightColor));
+
+    _this.side = DoubleSide;
+    return _this;
+  }
+
+  return ToonMaterial;
+}(ShaderMaterial);var setUpLightsAndShadows = function setUpLightsAndShadows(mesh) {
+  var _Config$lights = Config$1.lights(),
+      textureAnisotropy = _Config$lights.textureAnisotropy,
+      shadows = _Config$lights.shadows;
+
+  mesh.castShadow = Boolean(shadows);
+  mesh.receiveShadow = Boolean(shadows);
+
+  if (hasMaterial(mesh)) {
+    var setUpMaterial = function setUpMaterial(material) {
+      if (Lights$1.isUsingCSM()) {
+        Lights$1.csm.setupMaterial(material);
       }
-    }
-  }, {
-    key: "getWorldTransform",
-    value: function getWorldTransform() {
-      var position = this.getBody().getWorldPosition(new Vector3$1());
-      var quaternion = this.getBody().getWorldQuaternion(new Quaternion(0, 0, 0, 1));
-      var rotation = new Euler(0, 0, 0, 'XYZ').setFromQuaternion(quaternion, 'XYZ');
-      return {
-        position: position,
-        rotation: rotation,
-        quaternion: quaternion
-      };
-    }
-  }, {
-    key: "translate",
-    value: function translate(_ref7) {
-      var _ref7$x = _ref7.x,
-          x = _ref7$x === void 0 ? 0 : _ref7$x,
-          _ref7$y = _ref7.y,
-          y = _ref7$y === void 0 ? 0 : _ref7$y,
-          _ref7$z = _ref7.z,
-          z = _ref7$z === void 0 ? 0 : _ref7$z;
 
-      if (this.hasBody()) {
-        this.body.translateX(x);
-        this.body.translateY(y);
-        this.body.translateZ(z);
+      if (material.map) {
+        material.map.anisotropy = textureAnisotropy;
       }
-    }
-  }, {
-    key: "rotateTo",
-    value: function rotateTo() {
-      var _this6 = this;
 
-      var rotation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getRotation();
-      var time = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 250;
+      return material;
+    };
 
-      var _this$getRotation2 = this.getRotation(),
-          x = _this$getRotation2.x,
-          y = _this$getRotation2.y,
-          z = _this$getRotation2.z;
+    mesh.material = processMaterial(mesh.material, setUpMaterial);
+  }
+};
+var isScene = function isScene(mesh) {
+  return mesh.isScene;
+};
 
-      return new Promise(function (resolve) {
-        return new Between({
-          x: x,
-          y: y,
-          z: z
-        }, rotation).time(time).on('update', function (value) {
-          return _this6.setRotation(value);
-        }).on('complete', resolve);
+var hasMaterial = function hasMaterial(mesh) {
+  return Boolean(mesh.material);
+};
+var hasGeometry = function hasGeometry(mesh) {
+  return Boolean(mesh.geometry);
+};
+var processMaterial = function processMaterial(material, callback) {
+  return Array.isArray(material) ? material.map(callback) : callback(material);
+};
+var changeMaterialByName = function changeMaterialByName(name, mesh, materialOptions) {
+  if (!hasMaterial(mesh)) return;
+
+  switch (name) {
+    case MATERIALS.LAMBERT:
+      return cloneMaterial(MeshLambertMaterial, mesh, materialOptions);
+
+    case MATERIALS.PHONG:
+      return cloneMaterial(MeshPhongMaterial, mesh, materialOptions);
+
+    case MATERIALS.DEPTH:
+      return cloneMaterial(MeshDepthMaterial, mesh, materialOptions);
+
+    case MATERIALS.STANDARD:
+      return cloneMaterial(MeshStandardMaterial, mesh, materialOptions);
+
+    case MATERIALS.TOON:
+      return cloneMaterial(ToonMaterial, mesh, materialOptions);
+
+    case MATERIALS.THREE_TOON:
+      return cloneMaterial(MeshToonMaterial, mesh, materialOptions);
+
+    case MATERIALS.BASIC:
+    default:
+      return cloneMaterial(MeshBasicMaterial, mesh, materialOptions);
+  }
+};
+
+var cloneMaterial = function cloneMaterial(MeshMaterial, mesh) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  var _cloneMaterial = function _cloneMaterial(material) {
+    var clone = material.clone();
+    var newMaterial = new MeshMaterial(_objectSpread2$1({
+      map: clone.map,
+      color: clone.color
+    }, options));
+    newMaterial.skinning = true;
+    return newMaterial;
+  };
+
+  mesh.material = processMaterial(mesh.material, _cloneMaterial);
+  setUpLightsAndShadows(mesh);
+};
+
+var disposeTextures = function disposeTextures(mesh) {
+  if (hasMaterial(mesh)) {
+    var _disposeTexture = function _disposeTexture(material) {
+      Object.values(TEXTURES).forEach(function (key) {
+        if (material[key]) {
+          material[key].dispose();
+        }
       });
-    }
-  }, {
-    key: "goTo",
-    value: function goTo() {
-      var _this7 = this;
+    };
+
+    processMaterial(mesh.material, _disposeTexture);
+  }
+};
+var disposeMaterial = function disposeMaterial(mesh) {
+  if (hasMaterial(mesh)) {
+    mesh.material.dispose && mesh.material.dispose();
+  }
+};
+var disposeGeometry = function disposeGeometry(mesh) {
+  if (hasGeometry(mesh)) {
+    mesh.geometry.dispose && mesh.geometry.dispose();
+  }
+};
+var prepareModel = function prepareModel(model) {
+  setUpLightsAndShadows(model);
+  model.traverse(function (mesh) {
+    setUpLightsAndShadows(mesh);
+  });
+  return model;
+};var Entity = /*#__PURE__*/function (_EventDispatcher) {
+  _inherits(Entity, _EventDispatcher);
+
+  var _super = _createSuper(Entity);
+
+  function Entity() {
+    var _this;
+
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$serializable = _ref.serializable,
+        serializable = _ref$serializable === void 0 ? true : _ref$serializable,
+        _ref$tag = _ref.tag,
+        tag = _ref$tag === void 0 ? '' : _ref$tag,
+        _ref$tags = _ref.tags,
+        tags = _ref$tags === void 0 ? [] : _ref$tags;
 
-      var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getPosition();
-      var time = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 250;
+    _classCallCheck(this, Entity);
 
-      var _this$getPosition3 = this.getPosition(),
-          x = _this$getPosition3.x,
-          y = _this$getPosition3.y,
-          z = _this$getPosition3.z;
+    _this = _super.call(this);
 
-      return new Promise(function (resolve) {
-        return new Between({
-          x: x,
-          y: y,
-          z: z
-        }, position).time(time).on('update', function (value) {
-          return _this7.setPosition(value);
-        }).on('complete', resolve);
-      });
-    }
-  }, {
-    key: "uuid",
-    value: function uuid() {
-      return this.body.uuid;
-    }
-  }, {
-    key: "setId",
-    value: function setId() {
-      return this.body.id;
-    }
-  }, {
-    key: "id",
-    value: function id() {
-      return this.body.id;
-    }
-  }, {
-    key: "setVisible",
-    value: function setVisible() {
-      var flag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-      this.getBody().visible = flag;
-    }
-  }, {
-    key: "equals",
-    value: function equals(entity) {
-      try {
-        return entity.uuid ? this.uuid() === entity.uuid() : false;
-      } catch (e) {
-        return false;
-      }
-    }
-  }, {
-    key: "setName",
-    value: function setName(name) {
-      this.name = name;
-    }
-  }, {
-    key: "getName",
-    value: function getName() {
-      return this.name;
-    }
-  }, {
-    key: "setData",
-    value: function setData(key, value) {
-      if (this.getBody().userData) {
-        if (key && value) {
-          this.getBody().userData[key] = value;
-        } else {
-          console.log(KEY_VALUE_IS_MISSING);
-        }
-      } else {
-        console.log(USER_DATA_IS_MISSING);
+    _defineProperty$1(_assertThisInitialized(_this), "getBodyByName", function (name) {
+      if (name && _this.hasBody()) {
+        return _this.getBody().getObjectByName(name);
       }
-    }
-  }, {
-    key: "getData",
-    value: function getData(key) {
-      if (this.getBody().userData) {
-        if (key) {
-          return this.getBody().userData[key];
-        } else {
-          console.log(KEY_IS_MISSING);
-        }
+
+      console.warn(ELEMENT_NAME_NOT_PROVIDED);
+    });
+
+    _defineProperty$1(_assertThisInitialized(_this), "addTag", function (tagName) {
+      if (!tagName) return;
+
+      if (!_this.hasTag(tagName)) {
+        _this.tags.push(tagName);
+
+        return true;
       } else {
-        console.log(USER_DATA_IS_MISSING);
+        console.log(TAG_ALREADY_EXISTS, tagName);
+        return false;
       }
-    }
-  }, {
-    key: "mapScriptsToJSON",
-    value: function mapScriptsToJSON() {
-      this.scripts.reduce(function (acc, _ref8) {
-        var name = _ref8.name,
-            _ref8$options = _ref8.options,
-            options = _ref8$options === void 0 ? {} : _ref8$options;
-        acc.names.push(name);
-        acc.options.push(options);
-        return acc;
-      }, {
-        names: [],
-        options: []
-      });
-    }
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      if (this.isSerializable()) {
+    });
+
+    _defineProperty$1(_assertThisInitialized(_this), "hasStateMachine", function () {
+      return !!_this.stateMachine;
+    });
+
+    _defineProperty$1(_assertThisInitialized(_this), "hasScripts", function () {
+      return _this.scripts.length > 0;
+    });
+
+    _defineProperty$1(_assertThisInitialized(_this), "parseScripts", function (list, options, enabled) {
+      return list.map(function (script, i) {
         return {
-          position: this.getPosition(),
-          rotation: this.getRotation(),
-          scale: this.getScale(),
-          entityType: this.getEntityType(),
-          tags: this.getTags()
+          script: script,
+          name: script.getName(),
+          enabled: enabled,
+          options: options[i]
         };
-      }
-    }
-  }], [{
-    key: "create",
-    value: function create() {
-      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      return new this(options);
-    }
-  }]);
+      });
+    });
 
-  return Entity;
-}(EventDispatcher);var AnimationHandler = /*#__PURE__*/function (_EventDispatcher) {
-  _inherits(AnimationHandler, _EventDispatcher);
+    _defineProperty$1(_assertThisInitialized(_this), "isMesh", function () {
+      return _this.getEntityType() === ENTITY_TYPES.MESH;
+    });
 
-  var _super = _createSuper(AnimationHandler);
+    _defineProperty$1(_assertThisInitialized(_this), "isModel", function () {
+      return _this.getEntityType() === ENTITY_TYPES.MODEL;
+    });
 
-  function AnimationHandler(mesh) {
-    var _this;
+    _defineProperty$1(_assertThisInitialized(_this), "isSprite", function () {
+      return _this.getEntityType() === ENTITY_TYPES.SPRITE;
+    });
 
-    var animations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _defineProperty$1(_assertThisInitialized(_this), "isLight", function () {
+      return Object.values(ENTITY_TYPES.LIGHT).includes(_this.getEntityType());
+    });
 
-    _classCallCheck(this, AnimationHandler);
+    _defineProperty$1(_assertThisInitialized(_this), "isHelper", function () {
+      return Object.values(ENTITY_TYPES.HELPER).includes(_this.getEntityType());
+    });
 
-    _this = _super.call(this);
+    _defineProperty$1(_assertThisInitialized(_this), "isEffect", function () {
+      return Object.values(ENTITY_TYPES.EFFECT).includes(_this.getEntityType());
+    });
 
-    _defineProperty$1(_assertThisInitialized(_this), "getAnimationEventHandler", function (type) {
-      return function (_ref) {
-        var action = _ref.action,
-            direction = _ref.direction;
+    _defineProperty$1(_assertThisInitialized(_this), "setQuaternion", function (_ref2) {
+      var x = _ref2.x,
+          y = _ref2.y,
+          z = _ref2.z,
+          w = _ref2.w;
 
-        _this.dispatchEvent({
-          type: type,
-          action: action,
-          direction: direction
-        });
-      };
+      _this.body.quaternion.set(x, y, z, w);
     });
 
-    _this.mixer = new AnimationMixer(mesh);
-    _this.animations = animations;
-    _this.isPlaying = false;
+    _defineProperty$1(_assertThisInitialized(_this), "setUuid", function (uuid) {
+      if (uuid) {
+        _this.body.uuid = uuid;
+      }
+    });
 
-    _this.addEventsListeners();
+    _this.scripts = [];
+    _this.tags = [];
+    _this.children = [];
+    _this.isMage = true;
+    _this.parent = false;
+    _this.disposed = false;
+
+    _this.addTags([DEFAULT_TAG, tag].concat(_toConsumableArray(tags)));
 
+    _this.serializable = serializable;
     return _this;
   }
 
-  _createClass(AnimationHandler, [{
-    key: "addEventsListeners",
-    value: function addEventsListeners() {
-      this.mixer.addEventListener('loop', this.getAnimationEventHandler(ENTITY_EVENTS.ANIMATION.LOOP));
-      this.mixer.addEventListener('finished', this.getAnimationEventHandler(ENTITY_EVENTS.ANIMATION.FINISHED));
-    }
-  }, {
-    key: "getAction",
-    value: function getAction(id) {
-      var action;
-
-      if (typeof id === 'number') {
-        action = this.animations[id];
-      } else if (typeof id === 'string') {
-        action = AnimationClip.findByName(this.animations, id);
-      }
-
-      return action;
+  _createClass(Entity, [{
+    key: "isSerializable",
+    value: function isSerializable() {
+      return !!this.serializable;
     }
   }, {
-    key: "getAvailableAnimations",
-    value: function getAvailableAnimations() {
-      return this.animations.map(function (_ref2) {
-        var name = _ref2.name;
-        return name;
-      });
+    key: "isDisposed",
+    value: function isDisposed() {
+      return this.disposed;
     }
   }, {
-    key: "stopAll",
-    value: function stopAll() {
-      this.mixer.stopAllAction();
-      this.isPlaying = false;
+    key: "reset",
+    value: function reset() {
+      this.scripts = [];
+      this.children = [];
+      this.isMage = true;
+      this.parent = false;
+      this.tags = [DEFAULT_TAG];
     }
   }, {
-    key: "stopCurrentAnimation",
-    value: function stopCurrentAnimation() {
-      if (this.currentAction) {
-        this.currentAction.stop();
-      }
-
-      this.isPlaying = false;
+    key: "hasBody",
+    value: function hasBody() {
+      return !!this.body;
     }
   }, {
-    key: "playAnimation",
-    value: function playAnimation(id, options) {
-      var action = this.getAction(id);
-      var _options$loop = options.loop,
-          loop = _options$loop === void 0 ? LoopRepeat : _options$loop;
-      this.isPlaying = true;
-
-      if (this.currentAction) {
-        this.fadeToAnimation(action, options);
-      } else if (action) {
-        this.currentAction = this.mixer.clipAction(action).setLoop(loop).play();
-      } else {
-        console.warn(ANIMATION_NOT_FOUND);
-      }
+    key: "getBody",
+    value: function getBody() {
+      return this.body;
     }
   }, {
-    key: "fadeToAnimation",
-    value: function fadeToAnimation(action) {
-      var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-          _ref3$duration = _ref3.duration,
-          duration = _ref3$duration === void 0 ? 0.2 : _ref3$duration,
-          _ref3$loop = _ref3.loop,
-          loop = _ref3$loop === void 0 ? LoopRepeat : _ref3$loop;
-
-      var previousAction = this.currentAction;
-      this.currentAction = this.mixer.clipAction(action);
-
-      if (previousAction !== this.currentAction) {
-        previousAction.fadeOut(duration);
-      }
-
-      this.currentAction.reset().setEffectiveTimeScale(1).setEffectiveWeight(1).fadeIn(duration).setLoop(loop).play();
+    key: "setBody",
+    value: function setBody(body) {
+      this.body = body;
     }
   }, {
-    key: "update",
-    value: function update(dt) {
-      this.mixer.update(dt);
+    key: "hasParent",
+    value: function hasParent() {
+      return !!this.parent;
     }
-  }]);
-
-  return AnimationHandler;
-}(EventDispatcher);var inverseProjectionMatrix = new Matrix4();
-
-var Frustum = /*#__PURE__*/function () {
-  function Frustum(data) {
-    _classCallCheck(this, Frustum);
-
-    data = data || {};
-    this.vertices = {
-      near: [new Vector3$1(), new Vector3$1(), new Vector3$1(), new Vector3$1()],
-      far: [new Vector3$1(), new Vector3$1(), new Vector3$1(), new Vector3$1()]
-    };
-
-    if (data.projectionMatrix !== undefined) {
-      this.setFromProjectionMatrix(data.projectionMatrix, data.maxFar || 10000);
+  }, {
+    key: "getParent",
+    value: function getParent() {
+      return this.parent;
     }
-  }
-
-  _createClass(Frustum, [{
-    key: "setFromProjectionMatrix",
-    value: function setFromProjectionMatrix(projectionMatrix, maxFar) {
-      var isOrthographic = projectionMatrix.elements[2 * 4 + 3] === 0;
-      inverseProjectionMatrix.copy(projectionMatrix).invert(); // 3 --- 0  vertices.near/far order
-      // |     |
-      // 2 --- 1
-      // clip space spans from [-1, 1]
-
-      this.vertices.near[0].set(1, 1, -1);
-      this.vertices.near[1].set(1, -1, -1);
-      this.vertices.near[2].set(-1, -1, -1);
-      this.vertices.near[3].set(-1, 1, -1);
-      this.vertices.near.forEach(function (v) {
-        v.applyMatrix4(inverseProjectionMatrix);
-      });
-      this.vertices.far[0].set(1, 1, 1);
-      this.vertices.far[1].set(1, -1, 1);
-      this.vertices.far[2].set(-1, -1, 1);
-      this.vertices.far[3].set(-1, 1, 1);
-      this.vertices.far.forEach(function (v) {
-        v.applyMatrix4(inverseProjectionMatrix);
-        var absZ = Math.abs(v.z);
-
-        if (isOrthographic) {
-          v.z *= Math.min(maxFar / absZ, 1.0);
-        } else {
-          v.multiplyScalar(Math.min(maxFar / absZ, 1.0));
-        }
-      });
-      return this.vertices;
+  }, {
+    key: "setParent",
+    value: function setParent(parent) {
+      this.parent = parent;
     }
   }, {
-    key: "split",
-    value: function split(breaks, target) {
-      while (breaks.length > target.length) {
-        target.push(new Frustum());
-      }
+    key: "add",
+    value: function add(child) {
+      var _this2 = this;
 
-      target.length = breaks.length;
+      var container = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getBody();
 
-      for (var i = 0; i < breaks.length; i++) {
-        var cascade = target[i];
+      if (this.hasBody()) {
+        var _add = function _add(toAdd) {
+          if (toAdd instanceof Entity) {
+            _this2.children.push(toAdd);
 
-        if (i === 0) {
-          for (var j = 0; j < 4; j++) {
-            cascade.vertices.near[j].copy(this.vertices.near[j]);
-          }
-        } else {
-          for (var _j = 0; _j < 4; _j++) {
-            cascade.vertices.near[_j].lerpVectors(this.vertices.near[_j], this.vertices.far[_j], breaks[i - 1]);
+            toAdd.setParent(_this2);
+            container.add(toAdd.getBody());
+          } else {
+            console.log(ENTITY_CANT_ADD_NOT_ENTITY);
           }
-        }
+        };
 
-        if (i === breaks - 1) {
-          for (var _j2 = 0; _j2 < 4; _j2++) {
-            cascade.vertices.far[_j2].copy(this.vertices.far[_j2]);
-          }
+        if (Array.isArray(child)) {
+          child.forEach(_add);
         } else {
-          for (var _j3 = 0; _j3 < 4; _j3++) {
-            cascade.vertices.far[_j3].lerpVectors(this.vertices.near[_j3], this.vertices.far[_j3], breaks[i]);
-          }
+          _add(child);
         }
+      } else {
+        console.log(ENTITY_NOT_SET);
       }
     }
   }, {
-    key: "toSpace",
-    value: function toSpace(cameraMatrix, target) {
-      for (var i = 0; i < 4; i++) {
-        target.vertices.near[i].copy(this.vertices.near[i]).applyMatrix4(cameraMatrix);
-        target.vertices.far[i].copy(this.vertices.far[i]).applyMatrix4(cameraMatrix);
-      }
-    }
-  }]);
-
-  return Frustum;
-}();var Shader$1 = {
-  lights_fragment_begin:
-  /* glsl */
-  "\nGeometricContext geometry;\n\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( vViewPosition );\n\n#ifdef CLEARCOAT\n\n    geometry.clearcoatNormal = clearcoatNormal;\n\n#endif\n\nIncidentLight directLight;\n\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n\n    PointLight pointLight;\n    #if defined( USE_SHADOWMAP ) && NUM_POINT_LIGHT_SHADOWS > 0\n    PointLightShadow pointLightShadow;\n    #endif\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n\n        pointLight = pointLights[ i ];\n\n        getPointDirectLightIrradiance( pointLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_POINT_LIGHT_SHADOWS )\n        pointLightShadow = pointLightShadows[ i ];\n        directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getPointShadow( pointShadowMap[ i ], pointLightShadow.shadowMapSize, pointLightShadow.shadowBias, pointLightShadow.shadowRadius, vPointShadowCoord[ i ], pointLightShadow.shadowCameraNear, pointLightShadow.shadowCameraFar ) : 1.0;\n        #endif\n\n        RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n\n    SpotLight spotLight;\n    #if defined( USE_SHADOWMAP ) && NUM_SPOT_LIGHT_SHADOWS > 0\n    SpotLightShadow spotLightShadow;\n    #endif\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n\n        spotLight = spotLights[ i ];\n\n        getSpotDirectLightIrradiance( spotLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_SPOT_LIGHT_SHADOWS )\n        spotLightShadow = spotLightShadows[ i ];\n        directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( spotShadowMap[ i ], spotLightShadow.shadowMapSize, spotLightShadow.shadowBias, spotLightShadow.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n        #endif\n\n        RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if ( NUM_DIR_LIGHTS > 0) && defined( RE_Direct ) && defined( USE_CSM ) && defined( CSM_CASCADES )\n\n    DirectionalLight directionalLight;\n    float linearDepth = (vViewPosition.z) / (shadowFar - cameraNear);\n    #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n    DirectionalLightShadow directionalLightShadow;\n    #endif\n\n    #if defined( USE_SHADOWMAP ) && defined( CSM_FADE )\n    vec2 cascade;\n    float cascadeCenter;\n    float closestEdge;\n    float margin;\n    float csmx;\n    float csmy;\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\n        directionalLight = directionalLights[ i ];\n        getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n        // NOTE: Depth gets larger away from the camera.\n        // cascade.x is closer, cascade.y is further\n        cascade = CSM_cascades[ i ];\n        cascadeCenter = ( cascade.x + cascade.y ) / 2.0;\n        closestEdge = linearDepth < cascadeCenter ? cascade.x : cascade.y;\n        margin = 0.25 * pow( closestEdge, 2.0 );\n        csmx = cascade.x - margin / 2.0;\n        csmy = cascade.y + margin / 2.0;\n        if( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS && linearDepth >= csmx && ( linearDepth < csmy || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 ) ) {\n\n            float dist = min( linearDepth - csmx, csmy - linearDepth );\n            float ratio = clamp( dist / margin, 0.0, 1.0 );\n            if( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS ) {\n\n                vec3 prevColor = directLight.color;\n                directionalLightShadow = directionalLightShadows[ i ];\n                directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\n                bool shouldFadeLastCascade = UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth > cascadeCenter;\n                directLight.color = mix( prevColor, directLight.color, shouldFadeLastCascade ? ratio : 1.0 );\n\n            }\n\n            ReflectedLight prevLight = reflectedLight;\n            RE_Direct( directLight, geometry, material, reflectedLight );\n\n            bool shouldBlend = UNROLLED_LOOP_INDEX != CSM_CASCADES - 1 || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1 && linearDepth < cascadeCenter;\n            float blendRatio = shouldBlend ? ratio : 1.0;\n\n            reflectedLight.directDiffuse = mix( prevLight.directDiffuse, reflectedLight.directDiffuse, blendRatio );\n            reflectedLight.directSpecular = mix( prevLight.directSpecular, reflectedLight.directSpecular, blendRatio );\n            reflectedLight.indirectDiffuse = mix( prevLight.indirectDiffuse, reflectedLight.indirectDiffuse, blendRatio );\n            reflectedLight.indirectSpecular = mix( prevLight.indirectSpecular, reflectedLight.indirectSpecular, blendRatio );\n\n        }\n\n    }\n    #pragma unroll_loop_end\n    #else\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\n        directionalLight = directionalLights[ i ];\n        getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n\n        directionalLightShadow = directionalLightShadows[ i ];\n        if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y) directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n\n        #endif\n\n        if(linearDepth >= CSM_cascades[UNROLLED_LOOP_INDEX].x && (linearDepth < CSM_cascades[UNROLLED_LOOP_INDEX].y || UNROLLED_LOOP_INDEX == CSM_CASCADES - 1)) RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n    #endif\n\n#endif\n\n\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct ) && !defined( USE_CSM ) && !defined( CSM_CASCADES )\n\n    DirectionalLight directionalLight;\n    #if defined( USE_SHADOWMAP ) && NUM_DIR_LIGHT_SHADOWS > 0\n    DirectionalLightShadow directionalLightShadow;\n    #endif\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n\n        directionalLight = directionalLights[ i ];\n\n        getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n\n        #if defined( USE_SHADOWMAP ) && ( UNROLLED_LOOP_INDEX < NUM_DIR_LIGHT_SHADOWS )\n        directionalLightShadow = directionalLightShadows[ i ];\n        directLight.color *= all( bvec2( directLight.visible, receiveShadow ) ) ? getShadow( directionalShadowMap[ i ], directionalLightShadow.shadowMapSize, directionalLightShadow.shadowBias, directionalLightShadow.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n        #endif\n\n        RE_Direct( directLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\n\n    RectAreaLight rectAreaLight;\n\n    #pragma unroll_loop_start\n    for ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\n\n        rectAreaLight = rectAreaLights[ i ];\n        RE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\n\n    }\n    #pragma unroll_loop_end\n\n#endif\n\n#if defined( RE_IndirectDiffuse )\n\n    vec3 iblIrradiance = vec3( 0.0 );\n\n    vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n\n    irradiance += getLightProbeIrradiance( lightProbe, geometry );\n\n    #if ( NUM_HEMI_LIGHTS > 0 )\n\n        #pragma unroll_loop_start\n        for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n\n            irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n\n        }\n        #pragma unroll_loop_end\n\n    #endif\n\n#endif\n\n#if defined( RE_IndirectSpecular )\n\n    vec3 radiance = vec3( 0.0 );\n    vec3 clearcoatRadiance = vec3( 0.0 );\n\n#endif\n",
-  lights_pars_begin:
-  /* glsl */
-  "\n#if defined( USE_CSM ) && defined( CSM_CASCADES )\nuniform vec2 CSM_cascades[CSM_CASCADES];\nuniform float cameraNear;\nuniform float shadowFar;\n#endif\n    " + ShaderChunk.lights_pars_begin
-};var _cameraToLightMatrix = new Matrix4();
-
-var _lightSpaceFrustum = new Frustum();
-
-var _center = new Vector3$1();
-
-var _bbox = new Box3();
-
-var _uniformArray = [];
-var _logArray = [];
-var DEFAULT_MAX_FAR = 100000;
-var DEFAULT_MODE = 'practical';
-var DEFAULT_SHADOWMAP_SIZE = 2048;
-var DEFAULT_CASCADE = 3;
-var DEFAULT_BIAS$3 = 0.000001;
-var DEFAULT_INTENSITY$5 = 1;
-var DEFAULT_NEAR$3 = 1;
-var DEFAULT_FAR$3 = 2000;
-var DEFAULT_MARGIN = 200;
-var CascadeShadowMaps = /*#__PURE__*/function () {
-  function CascadeShadowMaps(_ref) {
-    var _ref$camera = _ref.camera,
-        camera = _ref$camera === void 0 ? Scene$1.getCameraBody() : _ref$camera,
-        _ref$parent = _ref.parent,
-        parent = _ref$parent === void 0 ? Scene$1.getScene() : _ref$parent,
-        _ref$cascades = _ref.cascades,
-        cascades = _ref$cascades === void 0 ? DEFAULT_CASCADE : _ref$cascades,
-        _ref$maxFar = _ref.maxFar,
-        maxFar = _ref$maxFar === void 0 ? DEFAULT_MAX_FAR : _ref$maxFar,
-        _ref$mode = _ref.mode,
-        mode = _ref$mode === void 0 ? DEFAULT_MODE : _ref$mode,
-        _ref$shadowMapSize = _ref.shadowMapSize,
-        shadowMapSize = _ref$shadowMapSize === void 0 ? DEFAULT_SHADOWMAP_SIZE : _ref$shadowMapSize,
-        _ref$shadowBias = _ref.shadowBias,
-        shadowBias = _ref$shadowBias === void 0 ? DEFAULT_BIAS$3 : _ref$shadowBias,
-        _ref$lightDirection = _ref.lightDirection,
-        lightDirection = _ref$lightDirection === void 0 ? new Vector3$1(1, -1, 1).normalize() : _ref$lightDirection,
-        _ref$lightIntensity = _ref.lightIntensity,
-        lightIntensity = _ref$lightIntensity === void 0 ? DEFAULT_INTENSITY$5 : _ref$lightIntensity,
-        _ref$lightNear = _ref.lightNear,
-        lightNear = _ref$lightNear === void 0 ? DEFAULT_NEAR$3 : _ref$lightNear,
-        _ref$lightFar = _ref.lightFar,
-        lightFar = _ref$lightFar === void 0 ? DEFAULT_FAR$3 : _ref$lightFar,
-        _ref$lightMargin = _ref.lightMargin,
-        lightMargin = _ref$lightMargin === void 0 ? DEFAULT_MARGIN : _ref$lightMargin,
-        customSplitsCallback = _ref.customSplitsCallback;
-
-    _classCallCheck(this, CascadeShadowMaps);
+    key: "isParentOf",
+    value: function isParentOf(child) {
+      var comparator = function comparator(child) {
+        return !!child.getBody().getObjectById(child.id);
+      };
 
-    this.camera = camera;
-    this.parent = parent;
-    this.cascades = cascades;
-    this.maxFar = maxFar;
-    this.mode = mode;
-    this.shadowMapSize = shadowMapSize;
-    this.shadowBias = shadowBias;
-    this.lightDirection = lightDirection;
-    this.lightIntensity = lightIntensity;
-    this.lightNear = lightNear;
-    this.lightFar = lightFar;
-    this.lightMargin = lightMargin;
-    this.customSplitsCallback = customSplitsCallback;
-    this.fade = false;
-    this.mainFrustum = new Frustum();
-    this.frustums = [];
-    this.breaks = [];
-    this.lights = [];
-    this.shaders = new Map();
-    this.createLights();
-    this.updateFrustums();
-    this.injectInclude();
-  }
+      if (child.isMage) {
+        comparator = function comparator(child) {
+          return child.getBody().getObjectById(child.id());
+        };
+      }
 
-  _createClass(CascadeShadowMaps, [{
-    key: "createLights",
-    value: function createLights() {
-      for (var i = 0; i < this.cascades; i++) {
-        var light = new DirectionalLight(0xffffff, this.lightIntensity);
-        light.castShadow = true;
-        light.shadow.mapSize.width = this.shadowMapSize;
-        light.shadow.mapSize.height = this.shadowMapSize;
-        light.shadow.camera.near = this.lightNear;
-        light.shadow.camera.far = this.lightFar;
-        light.shadow.bias = this.shadowBias;
-        this.parent.add(light);
-        this.parent.add(light.target);
-        this.lights.push(light);
+      return this.children.filter(comparator).length > 0;
+    }
+  }, {
+    key: "has",
+    value: function has(child) {
+      if (child.isMage) {
+        return this.equals(child) || this.isParentOf(child);
+      } else {
+        return !!this.getBody().getObjectById(child.id);
       }
     }
   }, {
-    key: "initCascades",
-    value: function initCascades() {
-      var camera = this.camera;
-      camera.updateProjectionMatrix();
-      this.mainFrustum.setFromProjectionMatrix(camera.projectionMatrix, this.maxFar);
-      this.mainFrustum.split(this.breaks, this.frustums);
+    key: "remove",
+    value: function remove(element) {
+      if (this.hasBody() && this.has(element)) {
+        if (element.isMage) {
+          this.body.remove(element.getBody());
+          var index = this.children.findIndex(function (m) {
+            return m.equals(element);
+          });
+          if (index) this.children.splice(index, 1);
+        } else {
+          this.body.remove(element.getBody());
+        }
+      }
     }
   }, {
-    key: "updateShadowBounds",
-    value: function updateShadowBounds() {
-      var frustums = this.frustums;
+    key: "addTo",
+    value: function addTo(target, childName) {
+      if (target && target.isMage) {
+        if (childName) {
+          target.add(this, target.getBodyByName(childName));
+        } else {
+          target.add(this);
+        }
+      }
+    }
+  }, {
+    key: "hasChildren",
+    value: function hasChildren() {
+      return this.children.length > 0;
+    }
+  }, {
+    key: "getHierarchy",
+    value: function getHierarchy() {
+      return {
+        element: this,
+        children: this.children.map(function (e) {
+          return e.getHierarchy();
+        })
+      };
+    }
+  }, {
+    key: "addTags",
+    value: function addTags() {
+      var tags = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      tags.forEach(this.addTag);
+    }
+  }, {
+    key: "removeTag",
+    value: function removeTag(tagName) {
+      if (tagName === DEFAULT_TAG) {
+        console.log(TAG_CANT_BE_REMOVED);
+        return;
+      }
 
-      for (var i = 0; i < frustums.length; i++) {
-        var light = this.lights[i];
-        var shadowCam = light.shadow.camera;
-        var frustum = this.frustums[i]; // Get the two points that represent that furthest points on the frustum assuming
-        // that's either the diagonal across the far plane or the diagonal across the whole
-        // frustum itself.
+      if (this.hasTag(tagName)) {
+        this.tags.splice(this.tags.indexOf(tagName), 1);
+      } else {
+        console.log(TAG_NOT_EXISTING_REMOVAL);
+      }
+    }
+  }, {
+    key: "removeAllTags",
+    value: function removeAllTags() {
+      this.tags = [DEFAULT_TAG];
+    }
+  }, {
+    key: "hasTag",
+    value: function hasTag(tagName) {
+      return this.tags.includes(tagName);
+    }
+  }, {
+    key: "getTags",
+    value: function getTags() {
+      return this.tags;
+    }
+  }, {
+    key: "disposeScripts",
+    value: function disposeScripts() {
+      if (this.hasScripts()) {
+        var length = this.scripts.length;
 
-        var nearVerts = frustum.vertices.near;
-        var farVerts = frustum.vertices.far;
-        var point1 = farVerts[0];
-        var point2 = void 0;
+        for (var i = 0; i < length; i++) {
+          var _this$scripts$i = this.scripts[i],
+              script = _this$scripts$i.script,
+              enabled = _this$scripts$i.enabled;
 
-        if (point1.distanceTo(farVerts[2]) > point1.distanceTo(nearVerts[2])) {
-          point2 = farVerts[2];
-        } else {
-          point2 = nearVerts[2];
-        }
+          if (enabled) {
+            script.onDispose();
 
-        var squaredBBWidth = point1.distanceTo(point2);
+            script.__setStartedFlag(false);
+          }
 
-        if (this.fade) {
-          // expand the shadow extents by the fade margin if fade is enabled.
-          var camera = this.camera;
-          var far = Math.max(camera.far, this.maxFar);
-          var linearDepth = frustum.vertices.far[0].z / (far - camera.near);
-          var margin = 0.25 * Math.pow(linearDepth, 2.0) * (far - camera.near);
-          squaredBBWidth += margin;
+          delete this.scripts[i];
         }
-
-        shadowCam.left = -squaredBBWidth / 2;
-        shadowCam.right = squaredBBWidth / 2;
-        shadowCam.top = squaredBBWidth / 2;
-        shadowCam.bottom = -squaredBBWidth / 2;
-        shadowCam.updateProjectionMatrix();
       }
     }
   }, {
-    key: "getBreaks",
-    value: function getBreaks() {
-      var camera = this.camera;
-      var far = Math.min(camera.far, this.maxFar);
-      this.breaks.length = 0;
-
-      switch (this.mode) {
-        case 'uniform':
-          uniformSplit(this.cascades, camera.near, far, this.breaks);
-          break;
+    key: "start",
+    value: function start() {
+      var _this3 = this;
 
-        case 'logarithmic':
-          logarithmicSplit(this.cascades, camera.near, far, this.breaks);
-          break;
+      if (this.hasScripts()) {
+        this.scripts.forEach(function (_ref3) {
+          var script = _ref3.script,
+              enabled = _ref3.enabled,
+              options = _ref3.options;
 
-        case 'practical':
-          practicalSplit(this.cascades, camera.near, far, 0.5, this.breaks);
-          break;
+          if (enabled) {
+            script.start(_this3, options);
 
-        case 'custom':
-          if (this.customSplitsCallback === undefined) console.error('CSM: Custom split scheme callback not defined.');
-          this.customSplitsCallback(this.cascades, camera.near, far, this.breaks);
-          break;
+            script.__setStartedFlag(true);
+          }
+        });
       }
+    }
+  }, {
+    key: "update",
+    value: function update(dt) {
+      if (this.hasScripts()) {
+        this.scripts.forEach(function (_ref4) {
+          var script = _ref4.script,
+              enabled = _ref4.enabled;
 
-      function uniformSplit(amount, near, far, target) {
-        for (var i = 1; i < amount; i++) {
-          target.push((near + (far - near) * i / amount) / far);
-        }
+          if (script && enabled) {
+            script.update(dt);
+          }
+        });
+      }
+    }
+  }, {
+    key: "onPhysicsUpdate",
+    value: function onPhysicsUpdate(dt) {
+      if (this.hasScripts()) {
+        this.scripts.forEach(function (_ref5) {
+          var script = _ref5.script,
+              enabled = _ref5.enabled;
 
-        target.push(1);
+          if (script && enabled) {
+            script.physicsUpdate(dt);
+          }
+        });
       }
+    }
+  }, {
+    key: "disposeBody",
+    value: function disposeBody() {
+      this.getBody().clear();
 
-      function logarithmicSplit(amount, near, far, target) {
-        for (var i = 1; i < amount; i++) {
-          target.push(near * Math.pow(far / near, i / amount) / far);
-        }
+      if (this.getBody().dispose && !isScene(this.getBody())) {
+        this.getBody().dispose();
+      }
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      if (this.hasChildren()) {
+        this.children.forEach(function (child) {
+          child.dispose();
+        });
+      }
 
-        target.push(1);
+      if (this.hasBody()) {
+        this.stopStateMachine();
+        this.disposeScripts();
+        Scene$1.remove(this.getBody());
+        this.disposeBody();
       }
 
-      function practicalSplit(amount, near, far, lambda, target) {
-        _uniformArray.length = 0;
-        _logArray.length = 0;
-        logarithmicSplit(amount, near, far, _logArray);
-        uniformSplit(amount, near, far, _uniformArray);
+      this.dispatchEvent({
+        type: ENTITY_EVENTS.DISPOSE
+      });
+      this.reset();
+    }
+  }, {
+    key: "addStateMachine",
+    value: function addStateMachine(description) {
+      var _this4 = this;
 
-        for (var i = 1; i < amount; i++) {
-          target.push(MathUtils.lerp(_uniformArray[i - 1], _logArray[i - 1], lambda));
-        }
+      this.stateMachine = interpret(createMachine(description)).onTransition(function (state) {
+        _this4.dispatchEvent({
+          type: ENTITY_EVENTS.STATE_MACHINE.CHANGE,
+          state: state
+        });
+      });
+
+      if (description.autostart) {
+        this.startStateMachine();
+      }
+    }
+  }, {
+    key: "startStateMachine",
+    value: function startStateMachine() {
+      if (this.hasStateMachine()) {
+        this.stateMachine.start();
+      } else {
+        console.log(STATE_MACHINE_NOT_AVAILABLE);
+      }
+    }
+  }, {
+    key: "stopStateMachine",
+    value: function stopStateMachine() {
+      if (this.hasStateMachine()) {
+        this.stateMachine.stop();
+      }
+    }
+  }, {
+    key: "changeState",
+    value: function changeState(event) {
+      if (this.hasStateMachine()) {
+        this.stateMachine.send(event);
+      } else {
+        console.log(STATE_MACHINE_NOT_AVAILABLE);
+      }
+    }
+  }, {
+    key: "getScript",
+    value: function getScript(name) {
+      var script = this.scripts.filter(function (script) {
+        return script.name === name;
+      })[0].script;
 
-        target.push(1);
+      if (script) {
+        return script;
+      } else {
+        console.warn(SCRIPT_NOT_FOUND);
       }
     }
   }, {
-    key: "update",
-    value: function update() {
-      var camera = this.camera;
-      var frustums = this.frustums;
-
-      for (var i = 0; i < frustums.length; i++) {
-        var light = this.lights[i];
-        var shadowCam = light.shadow.camera;
-        var texelWidth = (shadowCam.right - shadowCam.left) / this.shadowMapSize;
-        var texelHeight = (shadowCam.top - shadowCam.bottom) / this.shadowMapSize;
-        light.shadow.camera.updateMatrixWorld(true);
-
-        _cameraToLightMatrix.multiplyMatrices(light.shadow.camera.matrixWorldInverse, camera.matrixWorld);
+    key: "addScripts",
+    value: function addScripts() {
+      var _this5 = this;
 
-        frustums[i].toSpace(_cameraToLightMatrix, _lightSpaceFrustum);
-        var nearVerts = _lightSpaceFrustum.vertices.near;
-        var farVerts = _lightSpaceFrustum.vertices.far;
+      var scripts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+      var enabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      var parsedScripts = this.parseScripts(scripts, options, enabled);
+      this.scripts = [].concat(_toConsumableArray(this.scripts), [parsedScripts]);
 
-        _bbox.makeEmpty();
+      if (enabled) {
+        parsedScripts.forEach(function (parsed) {
+          return parsed.start(_this5, parsed.options);
+        });
+      }
+    }
+  }, {
+    key: "addScript",
+    value: function addScript(name) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var script = Scripts$1.get(name);
+      var _options$enabled = options.enabled,
+          enabled = _options$enabled === void 0 ? true : _options$enabled;
 
-        for (var j = 0; j < 4; j++) {
-          _bbox.expandByPoint(nearVerts[j]);
+      if (script) {
+        this.scripts.push({
+          script: script,
+          name: name,
+          enabled: enabled,
+          options: options
+        });
 
-          _bbox.expandByPoint(farVerts[j]);
+        if (enabled) {
+          script.start(this, options);
         }
+      } else {
+        console.log(SCRIPT_NOT_FOUND);
+      }
 
-        _bbox.getCenter(_center);
-
-        _center.z = _bbox.max.z + this.lightMargin;
-        _center.x = Math.floor(_center.x / texelWidth) * texelWidth;
-        _center.y = Math.floor(_center.y / texelHeight) * texelHeight;
-
-        _center.applyMatrix4(light.shadow.camera.matrixWorld);
-
-        light.position.copy(_center);
-        light.target.position.copy(_center);
-        light.target.position.x += this.lightDirection.x;
-        light.target.position.y += this.lightDirection.y;
-        light.target.position.z += this.lightDirection.z;
+      return script;
+    }
+  }, {
+    key: "enableScripts",
+    value: function enableScripts() {
+      this.scriptsEnabled = true;
+    }
+  }, {
+    key: "disableScripts",
+    value: function disableScripts() {
+      this.scriptsEnabled = false;
+    }
+  }, {
+    key: "setEntityType",
+    value: function setEntityType(type) {
+      if (FLAT_ENTITY_TYPES.includes(type)) {
+        this.entityType = type;
+      } else {
+        console.log(ENTITY_TYPE_NOT_ALLOWED);
+        this.entityType = ENTITY_TYPES.UNKNOWN;
       }
     }
   }, {
-    key: "injectInclude",
-    value: function injectInclude() {
-      ShaderChunk.lights_fragment_begin = Shader$1.lights_fragment_begin;
-      ShaderChunk.lights_pars_begin = Shader$1.lights_pars_begin;
+    key: "getEntityType",
+    value: function getEntityType() {
+      return this.entityType;
     }
   }, {
-    key: "setupMaterial",
-    value: function setupMaterial(material) {
-      material.defines = material.defines || {};
-      material.defines.USE_CSM = 1;
-      material.defines.CSM_CASCADES = this.cascades;
+    key: "addLight",
+    // TODO: sounds should become entities
+    // addSound(name, options) {
+    //     const { autoplay = false, ...opts } = options;
+    //     this.isPlayingSound = autoplay;
+    //     this.sound = new Sound(name, {
+    //         autoplay,
+    //         ...opts
+    //     });
+    //     this.sound.setTarget(this);
+    //     return this.sound;
+    // }
+    // addDirectionalSound(name, options) {
+    //     const { autoplay = false, ...opts } = options;
+    //     this.isPlayingSound = autoplay;
+    //     this.sound = new DirectionalSound(name, {
+    //         autoplay,
+    //         ...opts
+    //     });
+    //     this.sound.setTarget(this);
+    //     return this.sound;
+    // }
+    // addAmbientSound(name, options) {
+    //     const { autoplay = false, ...opts } = options;
+    //     this.isPlayingSound = autoplay;
+    //     this.sound = new AmbientSound(name, {
+    //         body: this.body,
+    //         autoplay,
+    //         ...opts
+    //     });
+    //     return this.sound;
+    // }
+    value: function addLight(light) {
+      var _this$getPosition = this.getPosition(),
+          x = _this$getPosition.x,
+          y = _this$getPosition.y,
+          z = _this$getPosition.z;
 
-      if (this.fade) {
-        material.defines.CSM_FADE = '';
+      light.setPosition({
+        x: x,
+        y: y,
+        z: z
+      });
+      this.light = light;
+    }
+  }, {
+    key: "playSound",
+    value: function playSound() {
+      if (this.sound && !this.isPlayingSound) {
+        this.sound.play();
+        this.isPlayingSound = true;
       }
-
-      var breaksVec2 = [];
-      var scope = this;
-      var shaders = this.shaders;
-
-      material.onBeforeCompile = function (shader) {
-        var far = Math.min(scope.camera.far, scope.maxFar);
-        scope.getExtendedBreaks(breaksVec2);
-        shader.uniforms.CSM_cascades = {
-          value: breaksVec2
-        };
-        shader.uniforms.cameraNear = {
-          value: scope.camera.near
-        };
-        shader.uniforms.shadowFar = {
-          value: far
-        };
-        shaders.set(material, shader);
+    }
+  }, {
+    key: "stopSound",
+    value: function stopSound() {
+      if (this.sound && this.isPlayingSound) {
+        this.sound.stop();
+        this.isPlayingSound = false;
+      }
+    }
+  }, {
+    key: "getScale",
+    value: function getScale() {
+      return {
+        x: this.body.scale.x,
+        y: this.body.scale.y,
+        z: this.body.scale.z
       };
-
-      shaders.set(material, null);
     }
   }, {
-    key: "updateUniforms",
-    value: function updateUniforms() {
-      var far = Math.min(this.camera.far, this.maxFar);
-      var shaders = this.shaders;
-      shaders.forEach(function (shader, material) {
-        if (shader !== null) {
-          var uniforms = shader.uniforms;
-          this.getExtendedBreaks(uniforms.CSM_cascades.value);
-          uniforms.cameraNear.value = this.camera.near;
-          uniforms.shadowFar.value = far;
-        }
+    key: "setScale",
+    value: function setScale(howbig) {
+      if (this.hasBody()) {
+        var scale = _objectSpread2$1(_objectSpread2$1({}, this.getScale()), howbig);
 
-        if (!this.fade && 'CSM_FADE' in material.defines) {
-          delete material.defines.CSM_FADE;
-          material.needsUpdate = true;
-        } else if (this.fade && !('CSM_FADE' in material.defines)) {
-          material.defines.CSM_FADE = '';
-          material.needsUpdate = true;
-        }
-      }, this);
+        this.body.scale.set(scale.x, scale.y, scale.z);
+      }
     }
   }, {
-    key: "getExtendedBreaks",
-    value: function getExtendedBreaks(target) {
-      while (target.length < this.breaks.length) {
-        target.push(new Vector2());
+    key: "getQuaternion",
+    value: function getQuaternion() {
+      if (this.hasBody()) {
+        return this.getBody().quaternion.clone();
+      }
+    }
+  }, {
+    key: "getPosition",
+    value: function getPosition() {
+      return this.getBody().position.clone();
+    }
+  }, {
+    key: "setPosition",
+    value: function setPosition(where) {
+      if (this.hasBody()) {
+        var _this$getPosition2 = this.getPosition(),
+            x = _this$getPosition2.x,
+            y = _this$getPosition2.y,
+            z = _this$getPosition2.z;
+
+        var position = _objectSpread2$1({
+          x: x,
+          y: y,
+          z: z
+        }, where);
+
+        this.body.position.set(position.x, position.y, position.z);
       }
+    }
+  }, {
+    key: "getRotation",
+    value: function getRotation() {
+      return this.getBody().rotation.clone();
+    }
+  }, {
+    key: "setRotation",
+    value: function setRotation(how) {
+      if (this.hasBody()) {
+        var _this$getRotation = this.getRotation(),
+            x = _this$getRotation.x,
+            y = _this$getRotation.y,
+            z = _this$getRotation.z;
 
-      target.length = this.breaks.length;
+        var rotation = _objectSpread2$1({
+          x: x,
+          y: y,
+          z: z
+        }, how);
 
-      for (var i = 0; i < this.cascades; i++) {
-        var amount = this.breaks[i];
-        var prev = this.breaks[i - 1] || 0;
-        target[i].x = prev;
-        target[i].y = amount;
+        this.body.rotation.set(rotation.x, rotation.y, rotation.z);
       }
     }
   }, {
-    key: "updateFrustums",
-    value: function updateFrustums() {
-      this.getBreaks();
-      this.initCascades();
-      this.updateShadowBounds();
-      this.updateUniforms();
+    key: "getWorldTransform",
+    value: function getWorldTransform() {
+      var position = this.getBody().getWorldPosition(new Vector3$1());
+      var quaternion = this.getBody().getWorldQuaternion(new Quaternion(0, 0, 0, 1));
+      var rotation = new Euler(0, 0, 0, 'XYZ').setFromQuaternion(quaternion, 'XYZ');
+      return {
+        position: position,
+        rotation: rotation,
+        quaternion: quaternion
+      };
     }
   }, {
-    key: "remove",
-    value: function remove() {
-      for (var i = 0; i < this.lights.length; i++) {
-        this.parent.remove(this.lights[i]);
+    key: "translate",
+    value: function translate(_ref6) {
+      var _ref6$x = _ref6.x,
+          x = _ref6$x === void 0 ? 0 : _ref6$x,
+          _ref6$y = _ref6.y,
+          y = _ref6$y === void 0 ? 0 : _ref6$y,
+          _ref6$z = _ref6.z,
+          z = _ref6$z === void 0 ? 0 : _ref6$z;
+
+      if (this.hasBody()) {
+        this.body.translateX(x);
+        this.body.translateY(y);
+        this.body.translateZ(z);
       }
     }
   }, {
-    key: "dispose",
-    value: function dispose() {
-      var shaders = this.shaders;
-      shaders.forEach(function (shader, material) {
-        delete material.onBeforeCompile;
-        delete material.defines.USE_CSM;
-        delete material.defines.CSM_CASCADES;
-        delete material.defines.CSM_FADE;
+    key: "rotateTo",
+    value: function rotateTo() {
+      var _this6 = this;
 
-        if (shader !== null) {
-          delete shader.uniforms.CSM_cascades;
-          delete shader.uniforms.cameraNear;
-          delete shader.uniforms.shadowFar;
-        }
+      var rotation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getRotation();
+      var time = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 250;
 
-        material.needsUpdate = true;
+      var _this$getRotation2 = this.getRotation(),
+          x = _this$getRotation2.x,
+          y = _this$getRotation2.y,
+          z = _this$getRotation2.z;
+
+      return new Promise(function (resolve) {
+        return new Between({
+          x: x,
+          y: y,
+          z: z
+        }, rotation).time(time).on('update', function (value) {
+          return !_this6.isDisposed() && _this6.setRotation(value);
+        }).on('complete', resolve);
       });
-      shaders.clear();
     }
-  }]);
+  }, {
+    key: "goTo",
+    value: function goTo() {
+      var _this7 = this;
 
-  return CascadeShadowMaps;
-}();var POINTLIGHT = 'pointlight';
-var AMBIENTLIGHT = 'ambientlight';
-var SUNLIGHT = 'sunlight';
-var SPOTLIGHT = 'spotlight';
-var HEMISPHERELIGHT = 'hemisphere';
-var TIME_TO_UPDATE = 5;
-var Lights = /*#__PURE__*/function () {
-  function Lights() {
-    _classCallCheck(this, Lights);
+      var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.getPosition();
+      var time = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 250;
 
-    this.delayFactor = 0.1;
-    this.delayStep = 30;
-    this.holderRadius = 0.01;
-    this.holderSegments = 1;
-    this.numLights = 0;
-    this.map = {};
-    this.lights = [];
-    this.csm = undefined;
-  }
+      var _this$getPosition3 = this.getPosition(),
+          x = _this$getPosition3.x,
+          y = _this$getPosition3.y,
+          z = _this$getPosition3.z;
 
-  _createClass(Lights, [{
-    key: "isUsingCSM",
-    value: function isUsingCSM() {
-      return !!this.csm;
+      return new Promise(function (resolve) {
+        return new Between({
+          x: x,
+          y: y,
+          z: z
+        }, position).time(time).on('update', function (value) {
+          return !_this7.isDisposed() && _this7.setPosition(value);
+        }).on('complete', resolve);
+      });
     }
   }, {
-    key: "setUpCSM",
-    value: function setUpCSM() {
-      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      this.csm = new CascadeShadowMaps(options);
+    key: "uuid",
+    value: function uuid() {
+      return this.body.uuid;
     }
   }, {
-    key: "add",
-    value: function add(light) {
-      this.lights.push(light);
+    key: "setId",
+    value: function setId() {
+      return this.body.id;
     }
   }, {
-    key: "update",
-    value: function update(dt) {
-      if (this.isUsingCSM()) {
-        this.csm.update();
+    key: "id",
+    value: function id() {
+      return this.body.id;
+    }
+  }, {
+    key: "setVisible",
+    value: function setVisible() {
+      var flag = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      this.getBody().visible = flag;
+    }
+  }, {
+    key: "equals",
+    value: function equals(entity) {
+      try {
+        return entity.uuid ? this.uuid() === entity.uuid() : false;
+      } catch (e) {
+        return false;
       }
-
-      var start = new Date();
-
-      for (var index in this.lights) {
-        var light = this.lights[index];
-        light.update(dt);
-        if (+new Date() - start > TIME_TO_UPDATE) break;
+    }
+  }, {
+    key: "setName",
+    value: function setName(name) {
+      this.name = name;
+    }
+  }, {
+    key: "getName",
+    value: function getName() {
+      return this.name;
+    }
+  }, {
+    key: "setData",
+    value: function setData(key, value) {
+      if (this.getBody().userData) {
+        if (key && value) {
+          this.getBody().userData[key] = value;
+        } else {
+          console.log(KEY_VALUE_IS_MISSING);
+        }
+      } else {
+        console.log(USER_DATA_IS_MISSING);
+      }
+    }
+  }, {
+    key: "getData",
+    value: function getData(key) {
+      if (this.getBody().userData) {
+        if (key) {
+          return this.getBody().userData[key];
+        } else {
+          console.log(KEY_IS_MISSING);
+        }
+      } else {
+        console.log(USER_DATA_IS_MISSING);
       }
     }
+  }, {
+    key: "mapScriptsToJSON",
+    value: function mapScriptsToJSON() {
+      this.scripts.reduce(function (acc, _ref7) {
+        var name = _ref7.name,
+            _ref7$options = _ref7.options,
+            options = _ref7$options === void 0 ? {} : _ref7$options;
+        acc.names.push(name);
+        acc.options.push(options);
+        return acc;
+      }, {
+        names: [],
+        options: []
+      });
+    }
   }, {
     key: "toJSON",
     value: function toJSON() {
-      return {
-        lights: this.lights.map(function (l) {
-          return l.toJSON();
-        })
-      };
-    }
-  }]);
-
-  return Lights;
-}();
-var Lights$1 = new Lights();var ToonShader = {
-  uniforms: {
-    "uDirLightPos": {
-      type: "v3",
-      value: new Vector3$1()
-    },
-    "uDirLightColor": {
-      type: "c",
-      value: new Color$1(0xffffff)
-    },
-    "uMaterialColor": {
-      type: "c",
-      value: new Color$1(0xffffff)
-    },
-    uKd: {
-      type: "f",
-      value: 1
-    },
-    uBorder: {
-      type: "f",
-      value: 0.4
+      if (this.isSerializable()) {
+        return {
+          position: this.getPosition(),
+          rotation: this.getRotation(),
+          scale: this.getScale(),
+          entityType: this.getEntityType(),
+          scripts: this.mapScriptsToJSON(),
+          tags: this.getTags()
+        };
+      }
     }
-  },
-  vertexShader: ["varying vec3 vNormal;", "varying vec3 vViewPosition;", "void main() {", "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );", "vNormal = normalize( normalMatrix * normal );", "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", "vViewPosition = -mvPosition.xyz;", "}"].join("\n"),
-  fragmentShader: ["uniform vec3 uMaterialColor;", "uniform vec3 uDirLightPos;", "uniform vec3 uDirLightColor;", "uniform float uKd;", "uniform float uBorder;", "varying vec3 vNormal;", "varying vec3 vViewPosition;", "void main() {", // compute direction to light
-  "vec4 lDirection = viewMatrix * vec4( uDirLightPos, 0.0 );", "vec3 lVector = normalize( lDirection.xyz );", // diffuse: N * L. Normal must be normalized, since it's interpolated.
-  "vec3 normal = normalize( vNormal );", //was: "float diffuse = max( dot( normal, lVector ), 0.0);",
-  // solution
-  "float diffuse = dot( normal, lVector );", "if ( diffuse > 0.6 ) { diffuse = 1.0; }", "else if ( diffuse > -0.2 ) { diffuse = 0.7; }", "else { diffuse = 0.3; }", "gl_FragColor = vec4( uKd * uMaterialColor * uDirLightColor * diffuse, 1.0 );", "}"].join("\n")
-};
+  }], [{
+    key: "create",
+    value: function create() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return new this(options);
+    }
+  }]);
 
-var ToonMaterial = /*#__PURE__*/function (_ShaderMaterial) {
-  _inherits(ToonMaterial, _ShaderMaterial);
+  return Entity;
+}(EventDispatcher);var AnimationHandler = /*#__PURE__*/function (_EventDispatcher) {
+  _inherits(AnimationHandler, _EventDispatcher);
 
-  var _super = _createSuper(ToonMaterial);
+  var _super = _createSuper(AnimationHandler);
 
-  function ToonMaterial(_ref) {
+  function AnimationHandler(mesh) {
     var _this;
 
-    var _ref$light = _ref.light,
-        light = _ref$light === void 0 ? {} : _ref$light,
-        color = _ref.color;
+    var animations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
 
-    _classCallCheck(this, ToonMaterial);
+    _classCallCheck(this, AnimationHandler);
 
-    var uniforms = UniformsUtils.clone(ToonShader.uniforms);
-    var vertexShader = ToonShader.vertexShader,
-        fragmentShader = ToonShader.fragmentShader;
-    _this = _super.call(this, {
-      uniforms: uniforms,
-      vertexShader: vertexShader,
-      fragmentShader: fragmentShader,
-      flatShading: true
-    });
-    var position = light.position,
-        lightColor = light.color;
+    _this = _super.call(this);
 
-    if (color) {
-      var materialColor = new Color$1(color);
+    _defineProperty$1(_assertThisInitialized(_this), "getAnimationEventHandler", function (type) {
+      return function (_ref) {
+        var action = _ref.action,
+            direction = _ref.direction;
 
-      _this.uniforms.uMaterialColor.value.copy(materialColor);
-    }
+        _this.dispatchEvent({
+          type: type,
+          action: action,
+          direction: direction
+        });
+      };
+    });
 
-    _this.uniforms.uDirLightPos.value = position;
+    _this.mixer = new AnimationMixer(mesh);
+    _this.animations = animations;
+    _this.isPlaying = false;
 
-    _this.uniforms.uDirLightColor.value.copy(new Color$1(lightColor));
+    _this.addEventsListeners();
 
-    _this.side = DoubleSide;
     return _this;
   }
 
-  return ToonMaterial;
-}(ShaderMaterial);var setUpLightsAndShadows = function setUpLightsAndShadows(mesh) {
-  var _Config$lights = Config$1.lights(),
-      textureAnisotropy = _Config$lights.textureAnisotropy,
-      shadows = _Config$lights.shadows;
-
-  mesh.castShadow = Boolean(shadows);
-  mesh.receiveShadow = Boolean(shadows);
+  _createClass(AnimationHandler, [{
+    key: "addEventsListeners",
+    value: function addEventsListeners() {
+      this.mixer.addEventListener('loop', this.getAnimationEventHandler(ENTITY_EVENTS.ANIMATION.LOOP));
+      this.mixer.addEventListener('finished', this.getAnimationEventHandler(ENTITY_EVENTS.ANIMATION.FINISHED));
+    }
+  }, {
+    key: "getAction",
+    value: function getAction(id) {
+      var action;
 
-  if (hasMaterial(mesh)) {
-    var setUpMaterial = function setUpMaterial(material) {
-      if (Lights$1.isUsingCSM()) {
-        Lights$1.csm.setupMaterial(material);
+      if (typeof id === 'number') {
+        action = this.animations[id];
+      } else if (typeof id === 'string') {
+        action = AnimationClip.findByName(this.animations, id);
       }
 
-      if (material.map) {
-        material.map.anisotropy = textureAnisotropy;
+      return action;
+    }
+  }, {
+    key: "getAvailableAnimations",
+    value: function getAvailableAnimations() {
+      return this.animations.map(function (_ref2) {
+        var name = _ref2.name;
+        return name;
+      });
+    }
+  }, {
+    key: "stopAll",
+    value: function stopAll() {
+      this.mixer.stopAllAction();
+      this.isPlaying = false;
+    }
+  }, {
+    key: "stopCurrentAnimation",
+    value: function stopCurrentAnimation() {
+      if (this.currentAction) {
+        this.currentAction.stop();
       }
 
-      return material;
-    };
-
-    mesh.material = processMaterial(mesh.material, setUpMaterial);
-  }
-};
-
-var hasMaterial = function hasMaterial(mesh) {
-  return Boolean(mesh.material);
-};
-var hasGeometry = function hasGeometry(mesh) {
-  return Boolean(mesh.geometry);
-};
-var processMaterial = function processMaterial(material, callback) {
-  return Array.isArray(material) ? material.map(callback) : callback(material);
-};
-var changeMaterialByName = function changeMaterialByName(name, mesh, materialOptions) {
-  if (!hasMaterial(mesh)) return;
-
-  switch (name) {
-    case MATERIALS.LAMBERT:
-      return cloneMaterial(MeshLambertMaterial, mesh, materialOptions);
-
-    case MATERIALS.PHONG:
-      return cloneMaterial(MeshPhongMaterial, mesh, materialOptions);
-
-    case MATERIALS.DEPTH:
-      return cloneMaterial(MeshDepthMaterial, mesh, materialOptions);
-
-    case MATERIALS.STANDARD:
-      return cloneMaterial(MeshStandardMaterial, mesh, materialOptions);
-
-    case MATERIALS.TOON:
-      return cloneMaterial(ToonMaterial, mesh, materialOptions);
-
-    case MATERIALS.THREE_TOON:
-      return cloneMaterial(MeshToonMaterial, mesh, materialOptions);
-
-    case MATERIALS.BASIC:
-    default:
-      return cloneMaterial(MeshBasicMaterial, mesh, materialOptions);
-  }
-};
+      this.isPlaying = false;
+    }
+  }, {
+    key: "playAnimation",
+    value: function playAnimation(id, options) {
+      var action = this.getAction(id);
+      var _options$loop = options.loop,
+          loop = _options$loop === void 0 ? LoopRepeat : _options$loop;
+      this.isPlaying = true;
 
-var cloneMaterial = function cloneMaterial(MeshMaterial, mesh) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      if (this.currentAction) {
+        this.fadeToAnimation(action, options);
+      } else if (action) {
+        this.currentAction = this.mixer.clipAction(action).setLoop(loop).play();
+      } else {
+        console.warn(ANIMATION_NOT_FOUND);
+      }
+    }
+  }, {
+    key: "fadeToAnimation",
+    value: function fadeToAnimation(action) {
+      var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          _ref3$duration = _ref3.duration,
+          duration = _ref3$duration === void 0 ? 0.2 : _ref3$duration,
+          _ref3$loop = _ref3.loop,
+          loop = _ref3$loop === void 0 ? LoopRepeat : _ref3$loop;
 
-  var _cloneMaterial = function _cloneMaterial(material) {
-    var clone = material.clone();
-    var newMaterial = new MeshMaterial(_objectSpread2$1({
-      map: clone.map,
-      color: clone.color
-    }, options));
-    newMaterial.skinning = true;
-    return newMaterial;
-  };
+      var previousAction = this.currentAction;
+      this.currentAction = this.mixer.clipAction(action);
 
-  mesh.material = processMaterial(mesh.material, _cloneMaterial);
-  setUpLightsAndShadows(mesh);
-};
+      if (previousAction !== this.currentAction) {
+        previousAction.fadeOut(duration);
+      }
 
-var disposeTextures = function disposeTextures(mesh) {
-  if (hasMaterial(mesh)) {
-    var _disposeTexture = function _disposeTexture(material) {
-      material.map && material.dispose();
-    };
+      this.currentAction.reset().setEffectiveTimeScale(1).setEffectiveWeight(1).fadeIn(duration).setLoop(loop).play();
+    }
+  }, {
+    key: "update",
+    value: function update(dt) {
+      this.mixer.update(dt);
+    }
+  }]);
 
-    processMaterial(mesh.material, _disposeTexture);
-  }
-};
-var disposeMaterial = function disposeMaterial(mesh) {
-  if (hasMaterial(mesh)) {
-    mesh.material.dispose();
-  }
-};
-var disposeGeometry = function disposeGeometry(mesh) {
-  if (hasGeometry(mesh)) {
-    mesh.geometry.dispose();
-  }
-};
-var prepareModel = function prepareModel(model) {
-  setUpLightsAndShadows(model);
-  model.traverse(function (mesh) {
-    setUpLightsAndShadows(mesh);
-  });
-  return model;
-};var _MATERIAL_TEXTURE_MAP;
+  return AnimationHandler;
+}(EventDispatcher);var _MATERIAL_TEXTURE_MAP;
 var MATERIAL_TEXTURE_MAP = (_MATERIAL_TEXTURE_MAP = {}, _defineProperty$1(_MATERIAL_TEXTURE_MAP, MATERIALS.BASIC, [TEXTURES.ALPHA, TEXTURES.AO, TEXTURES.ENV, TEXTURES.LIGHT, TEXTURES.MAP, TEXTURES.SPECULAR]), _defineProperty$1(_MATERIAL_TEXTURE_MAP, MATERIALS.LAMBERT, [TEXTURES.ALPHA, TEXTURES.AO, TEXTURES.ENV, TEXTURES.LIGHT, TEXTURES.MAP, TEXTURES.SPECULAR, TEXTURES.EMISSIVE]), _defineProperty$1(_MATERIAL_TEXTURE_MAP, MATERIALS.PHONG, [TEXTURES.ALPHA, TEXTURES.AO, TEXTURES.ENV, TEXTURES.LIGHT, TEXTURES.MAP, TEXTURES.SPECULAR, TEXTURES.EMISSIVE, TEXTURES.BUMP, TEXTURES.DISPLACEMENT, TEXTURES.NORMAL]), _defineProperty$1(_MATERIAL_TEXTURE_MAP, MATERIALS.DEPTH, [TEXTURES.ALPHA, TEXTURES.MAP, TEXTURES.DISPLACEMENT]), _defineProperty$1(_MATERIAL_TEXTURE_MAP, MATERIALS.STANDARD, [TEXTURES.ALPHA, TEXTURES.AO, TEXTURES.ENV, TEXTURES.LIGHT, TEXTURES.MAP, TEXTURES.EMISSIVE, TEXTURES.BUMP, TEXTURES.DISPLACEMENT, TEXTURES.NORMAL, TEXTURES.METALNESS, TEXTURES.ROUGHNESS]), _defineProperty$1(_MATERIAL_TEXTURE_MAP, MATERIALS.THREE_TOON, [TEXTURES.ALPHA, TEXTURES.AO, TEXTURES.BUMP, TEXTURES.DISPLACEMENT, TEXTURES.EMISSIVE, TEXTURES.GRADIENT, TEXTURES.LIGHT, TEXTURES.MAP, TEXTURES.NORMAL]), _MATERIAL_TEXTURE_MAP);
 var isTextureMapAllowedForMaterial = function isTextureMapAllowedForMaterial(materialType, textureType) {
   return MATERIAL_TEXTURE_MAP[materialType] && MATERIAL_TEXTURE_MAP[materialType].includes(textureType);
@@ -60976,7 +61025,7 @@ var Element = /*#__PURE__*/function (_Entity) {
 
       return new Promise(function (resolve) {
         return new Between(_this4.opacity, opacity).time(time).on('update', function (value) {
-          return _this4.setOpacity(value);
+          return !_this4.isDisposed() && _this4.setOpacity(value);
         }).on('complete', resolve);
       });
     }
@@ -61013,19 +61062,21 @@ var Element = /*#__PURE__*/function (_Entity) {
   }, {
     key: "disposeBody",
     value: function disposeBody() {
-      if (hasMaterial(this.body)) {
+      _get(_getPrototypeOf(Element.prototype), "disposeBody", this).call(this);
+
+      if (hasMaterial(this.getBody())) {
         disposeTextures(this.getBody());
         disposeMaterial(this.getBody());
         disposeGeometry(this.getBody());
-      } else {
-        this.body.traverse(function (child) {
-          if (hasMaterial(child)) {
-            disposeTextures(child);
-            disposeMaterial(child);
-            disposeGeometry(child);
-          }
-        });
       }
+
+      this.getBody().traverse(function (child) {
+        if (hasMaterial(child)) {
+          disposeTextures(child);
+          disposeMaterial(child);
+          disposeGeometry(child);
+        }
+      });
     }
   }, {
     key: "update",
@@ -61046,11 +61097,6 @@ var Element = /*#__PURE__*/function (_Entity) {
     value: function dispose() {
       _get(_getPrototypeOf(Element.prototype), "dispose", this).call(this);
 
-      if (this.hasBody()) {
-        Scene$1.remove(this.getBody());
-        this.disposeBody();
-      }
-
       if (this.hasAnimationHandler()) {
         this.removeAnimationHandlerListeners();
       }
@@ -61063,7 +61109,6 @@ var Element = /*#__PURE__*/function (_Entity) {
       if (this.isSerializable()) {
         return _objectSpread2$1(_objectSpread2$1({}, _get(_getPrototypeOf(Element.prototype), "toJSON", this).call(this)), {}, {
           body: this.body.toJSON(),
-          scripts: this.mapScriptsToJSON(),
           textures: this.textures
         }, this.options);
       }
@@ -73867,7 +73912,7 @@ var Light = /*#__PURE__*/function (_Entity) {
       var intensity = this.getIntensity();
       return new Promise(function (resolve) {
         return new Between(intensity, value).time(time).on('update', function (value) {
-          return _this2.setIntensity(value);
+          return !_this2.isDisposed() && _this2.setIntensity(value);
         }).on('complete', resolve);
       });
     }
@@ -76737,12 +76782,17 @@ var index$1=/*#__PURE__*/Object.freeze({__proto__:null,Emitter:k,Particle:P,Part
         this.system.particleSystem.rotation.set(rotation.x, rotation.y, rotation.z);
       }
     }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      _get(_getPrototypeOf(ParticleEmitter.prototype), "dispose", this).call(this);
+    }
   }, {
     key: "update",
     value: function update(dt) {
       _get(_getPrototypeOf(ParticleEmitter.prototype), "update", this).call(this, dt);
 
-      if (this.hasSystem()) {
+      if (this.hasSystem() && !this.isSystemDead()) {
         this.system.update(dt);
       }
 
@@ -76985,6 +77035,7 @@ var index$1=/*#__PURE__*/Object.freeze({__proto__:null,Emitter:k,Particle:P,Part
   return ParticleEmitterGroup;
 }(Entity);var _excluded$2 = ["initializers", "behaviours", "texture", "color", "rate"];
 var DEFAULT_PARTICLE_COLOR = PALETTES.BASE.BLACK;
+var SYSTEM_DISPOSE_TIMEOUT = 700;
 
 var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
   _inherits(ProtonParticleEmitter, _ParticleEmitter);
@@ -76992,6 +77043,8 @@ var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
   var _super = _createSuper(ProtonParticleEmitter);
 
   function ProtonParticleEmitter() {
+    var _this;
+
     var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
     _classCallCheck(this, ProtonParticleEmitter);
@@ -77015,7 +77068,17 @@ var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
       rate: rate
     }, rest);
 
-    return _super.call(this, parsedOptions);
+    _this = _super.call(this, parsedOptions);
+
+    _defineProperty$1(_assertThisInitialized(_this), "disposeSystem", function () {
+      if (_this.hasSystem()) {
+        _this.system.removeAllParticles();
+
+        _this.system.destroy();
+      }
+    });
+
+    return _this;
   }
 
   _createClass(ProtonParticleEmitter, [{
@@ -77043,7 +77106,7 @@ var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
   }, {
     key: "setSystem",
     value: function setSystem() {
-      var _this = this;
+      var _this2 = this;
 
       var _this$options = this.options,
           _this$options$initial = _this$options.initializers,
@@ -77056,7 +77119,7 @@ var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
       this.system = new Proton.Emitter();
       this.system.rate = rate;
       initializers.forEach(function (initializer) {
-        return _this.system.addInitialize(initializer);
+        return _this2.system.addInitialize(initializer);
       });
 
       if (texture) {
@@ -77064,7 +77127,7 @@ var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
       }
 
       behaviours.forEach(function (behaviour) {
-        return _this.system.addBehaviour(behaviour);
+        return _this2.system.addBehaviour(behaviour);
       });
     }
   }, {
@@ -77105,8 +77168,8 @@ var ProtonParticleEmitter = /*#__PURE__*/function (_ParticleEmitter) {
     value: function dispose() {
       _get(_getPrototypeOf(ProtonParticleEmitter.prototype), "dispose", this).call(this);
 
-      this.system.stopEmit();
-      this.system.destroy();
+      this.stop();
+      setTimeout(this.disposeSystem, SYSTEM_DISPOSE_TIMEOUT);
     }
   }]);
 
@@ -77449,7 +77512,14 @@ var Particles = /*#__PURE__*/function () {
     }
   }, {
     key: "addParticleEmitter",
-    value: function addParticleEmitter(_emitter) {
+    value: function addParticleEmitter(emitter) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      console.warn(DEPRECATIONS.PARTICLES_ADD_PARTICLE_EMITTER);
+      return this.add(emitter, options);
+    }
+  }, {
+    key: "add",
+    value: function add(_emitter) {
       var _this2 = this;
 
       var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -77502,7 +77572,7 @@ var Particles = /*#__PURE__*/function () {
       }
 
       if (emitter.isSystemDead()) {
-        this.toDispose.push(emitter.uuid);
+        this.toDispose.push(emitter.uuid());
       }
     }
   }, {