https://survey.com/wp-content/themes/hello-theme-child/map-assets/miniature.earth.js?ver=1790284331

1function Earth( element, options ) {
2
3	if ( typeof element == "string" ) {
4		element = document.getElementById( element );
5	}
6	
7	if ( ! element ) {
8		return false;
9	}
10	
11	
12	// check webgl support
13	
14	if ( ! Earth.isSupported( options.legacySupportIE11 ) ) {		
15		element.classList.add( "earth-show-fallback" );
16		return false;
17	}
18	
19	
20	// remove fallback
21	
22	var fallback = element.querySelector( ".earth-fallback" );
23	if ( fallback ) fallback.style.display = "none";
24	
25	
26	// add required css styles
27	
28	if ( ! Earth.cssAdded && Earth.css ) {
29		Earth.addCss();		
30		Earth.cssAdded = true;
31	}
32	
33	
34	// add default meshes
35	
36	if ( ! Earth.meshesAdded && Earth.markerObj ) {
37		Earth.addMesh( Earth.markerObj );
38		Earth.meshesAdded = true;		
39	}
40	
41	
42	// add container css class if not present
43	
44	element.classList.add( "earth-container" );
45
46	
47	// reference to EarthInstance
48	element.earth = this;
49	
50	// reference to dom element
51	this.element = element;
52	
53	
54	// default options
55	
56	var defaults = {
57		
58		isEarth : true,
59		quality: this.getQuality(),
60
61		location: { lat: 0, lng: 0 },
62		
63		mapLandColor : '#F4F4F4',
64		mapSeaColor : '#0099FF',
65		mapBorderColor : '',
66		mapBorderWidth : 0.3,
67		mapStyles : '',
68		
69		mapSvg : '',
70		mapImage : '',
71		
72		draggable : true,
73		grabCursor : true,
74		dragMomentum : true,
75		dragDamping : 0.7,
76		dragPolarLimit : 0.3,
77		
78		polarLimit : 0.3,
79		
80		autoRotate : false,
81		autoRotateSpeed : 1,
82		autoRotateSpeedUp : 0,
83		autoRotateDelay : 1000,
84		autoRotateStart : 1000,
85		autoRotateEasing : 'in-quad',
86		
87		zoom: 1,
88		zoomable : false,
89		zoomMin: 0.5,
90		zoomMax: 1.25,
91		zoomSpeed : 1,
92		
93		light: 'simple', // none, simple, sun
94		lightAmbience: ( options.light == 'none' ) ? 1 : 0.5,
95		lightIntensity: 0.5,
96		lightColor: '#FFFFFF',
97		lightGroundColor: '#999999',
98		sunLocation : { lat: 0, lng: 0 },
99		sunDirection : false,
100		shadows: ( options.light == 'sun' ),
101		
102		shininess: 0.1,
103		transparent : false,
104		innerOpacity : 1,
105		innerColor : '#FFFFFF',
106		
107		paused : false,
108		showHotspots : false,
109		mapHitTest : false,
110
111	};
112	
113	this.options = Object.assign(defaults, options);
114	
115	this.animations = [];
116	this.overlays = [];
117	this.occludables = [];
118	
119	this.ready = false;
120	this.deltaTime = 0;
121	
122	this.goAnimation = null;
123	this.zoomAnimation = null;
124	
125	this.dragging = false;
126	
127	this.autoRotating = false;
128	this.autoRotateTime = 0;
129
130	this.mouseOver = false;
131	this.mouseOverEarth = false;
132	this.mouseOverObject = null;	
133
134	this.docMousePosition = false;
135	this.lastDocMousePosition = false;
136	this.mousePosition = false;
137	this.lastMousePosition = false;
138	this.lastMouseTime = 0;
139	this.mouseVelocity = new THREE.Vector2();
140	
141	this.momentum = new THREE.Vector2();
142	
143	this.elementSize = new THREE.Vector2();
144	this.elementCenter = new THREE.Vector2();
145	this.bounds = {
146		left: 0,
147		top: 0,
148		bottom: 0,
149		right: 0,
150		width: 1,
151		height: 1
152	};
153	this.radius = 0;
154
155	this.init();
156	
157	return this;
158	
159}
160
161
162
163
164Earth.ClassicEventDispatcher = function() {};
165
166Object.assign( Earth.ClassicEventDispatcher.prototype, {
167
168	addEventListener: function ( type, listener ) {
169
170		if ( this._listeners === undefined ) this._listeners = {};
171
172		const listeners = this._listeners;
173
174		if ( listeners[ type ] === undefined ) {
175
176			listeners[ type ] = [];
177
178		}
179
180		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
181
182			listeners[ type ].push( listener );
183
184		}
185
186	},
187
188	hasEventListener: function ( type, listener ) {
189
190		if ( this._listeners === undefined ) return false;
191
192		const listeners = this._listeners;
193
194		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
195
196	},
197
198	removeEventListener: function ( type, listener ) {
199
200		if ( this._listeners === undefined ) return;
201
202		const listeners = this._listeners;
203		const listenerArray = listeners[ type ];
204
205		if ( listenerArray !== undefined ) {
206
207			const index = listenerArray.indexOf( listener );
208
209			if ( index !== - 1 ) {
210
211				listenerArray.splice( index, 1 );
212
213			}
214
215		}
216
217	},
218
219	dispatchEvent: function ( event ) {
220
221		if ( this._listeners === undefined ) return;
222
223		const listeners = this._listeners;
224		const listenerArray = listeners[ event.type ];
225
226		if ( listenerArray !== undefined ) {
227
228			event.target = this;
229
230			// Make a copy, in case listeners are removed while iterating.
231			const array = listenerArray.slice( 0 );
232
233			for ( let i = 0, l = array.length; i < l; i ++ ) {
234
235				array[ i ].call( this, event );
236
237			}
238
239		}
240
241	}
242
243} );
244
245
246
247
248
249Object.assign( Earth.prototype, Earth.ClassicEventDispatcher.prototype );
250
251
252// private
253
254Earth.prototype.init = function() {
255	
256	this.clock = new THREE.Clock();
257	this.raycaster = new THREE.Raycaster();
258
259	// scene
260	this.scene = new THREE.Scene();
261	
262	// camera
263	this.camera = new THREE.PerspectiveCamera( 50, 1, 1, 2000 );
264	this.camera.position.z = Earth.camDistance;
265	this.scene.add( this.camera );
266	
267	// renderer
268	this.renderer = new THREE.WebGLRenderer( {
269		alpha: true,
270		antialias: true,
271		preserveDrawingBuffer: ( this.options.preserveDrawingBuffer ) ? true : false 
272	} );
273	
274	if ( this.options.shadows ) {
275		this.renderer.shadowMap.enabled = true;
276		this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
277	}
278	
279	this.renderer.setPixelRatio( window.devicePixelRatio );
280	
281	this.canvas = this.renderer.domElement;
282	this.element.appendChild( this.canvas );
283	
284	
285	// check capabilities for first instance on page
286	if ( ! Earth.capabilitiesChecked ) Earth.checkCapabilities( this.renderer );
287	
288
289	// earth
290	
291	this.sphere = new THREE.Mesh(
292		new THREE.SphereBufferGeometry( Earth.earthRadius, this.options.quality*16, this.options.quality*12 ),
293		new THREE.MeshBasicMaterial( { visible: false } )
294	);
295	
296	this.sphere.renderOrder = -2;
297	
298	if ( this.options.shadows ) {

299		this.sphere.receiveShadow = true;
300		this.sphere.castShadow = true;
301	}
302	
303	this.scene.add( this.sphere );
304	
305	
306	// inner earth
307	
308	if ( this.options.transparent ) {
309		this.innerSphere = new THREE.Mesh(
310			new THREE.SphereBufferGeometry( Earth.earthRadius, this.options.quality*16, this.options.quality*12 ), // - 0.001
311			new THREE.MeshBasicMaterial( { visible: false } )
312		);
313
314		this.innerSphere.renderOrder = -3;
315		this.sphere.add( this.innerSphere );
316	}
317	
318	
319	this.loadTexture();
320	
321	
322	// light
323	
324	this.ambientLight = new THREE.AmbientLight( 0xFFFFFF, this.options.lightAmbience );
325	this.scene.add( this.ambientLight );
326	
327	if ( this.options.light == 'simple' ) {
328		
329		this.primaryLight = new THREE.HemisphereLight( new THREE.Color(this.options.lightColor), new THREE.Color(this.options.lightGroundColor), this.options.lightIntensity );
330		this.scene.add( this.primaryLight );
331		
332	} else if ( this.options.light == 'sun' ) {
333		
334		this.primaryLight = new THREE.DirectionalLight( new THREE.Color(this.options.lightColor), this.options.lightIntensity );
335		
336		if ( this.options.shadows ) {
337			this.primaryLight.castShadow = true;
338			
339			this.primaryLight.shadow.mapSize.width =
340			this.primaryLight.shadow.mapSize.height = Earth.shadowSize[ this.options.quality ];
341			
342			var d = 25;
343			this.primaryLight.shadow.camera.left = -d;
344			this.primaryLight.shadow.camera.right = d;
345			this.primaryLight.shadow.camera.top = d;
346			this.primaryLight.shadow.camera.bottom = -d;
347			this.primaryLight.shadow.camera.far = 3000;
348			this.primaryLight.shadow.bias = 0.0001;
349		}
350		
351		this.scene.add( this.primaryLight );
352		
353	}
354	
355	
356	// events
357	
358	var dragStartMousePosition;
359	var ignoreClicks = false;
360	var lastTouchStart;
361	
362	var clickHandler = (function( event ){
363		
364		if ( this.paused ) return;
365		
366		if ( ignoreClicks && event.type == 'click' ) return;
367		
368		
369		// touch to mousevents
370		
371		var touchEndClick = false;
372		
373		if ( event.type == 'touchstart' ||  event.type == 'touchend' ) {
374		
375			if ( event.touches.length > 1 ) return;
376
377			var x = event.changedTouches[0].clientX, y = event.changedTouches[0].clientY;
378		
379			if ( event.type == 'touchstart' ) {
380				
381				var type = 'mousedown';
382				lastTouchStart = new THREE.Vector2( x, y );
383				
384			} else if ( event.type == 'touchend' ) {
385				
386				var type = 'mouseup';
387				touchEndClick = ! ignoreClicks && lastTouchStart && lastTouchStart.distanceTo( new THREE.Vector2( x, y ) ) < Earth.maxClickDistance;
388				
389			}
390			
391		} else {
392			
393			var type = event.type;
394			var x = event.clientX, y = event.clientY;
395			
396		}
397		
398
399		var mouse = Earth.normalizeMouse( this, x, y );
400		var intersects = this.raycast( mouse );
401		var intersect_sphere = false;
402		
403		for ( var i = 0; i < intersects.length; i++ ) {
404			
405			if ( intersects[ i ].object == this.sphere ) {
406				var uv = intersects[ i ].uv;
407				intersects[ i ].object.material.map.transformUv( uv );
408				
409				var mouseEvent = { type: type, x : mouse.x, y : mouse.y, location : Earth.uvToLatLng( uv ), originalEvent: event };
410				
411				if ( this.mapHitTest ) {
412					mouseEvent.id = this.hitTestMap( uv );
413				}
414				
415				this.dispatchEvent( mouseEvent );
416				
417				if ( touchEndClick ) {
418					mouseEvent.type = 'click';
419					this.dispatchEvent( mouseEvent );
420				}
421				
422				intersect_sphere = true;
423
424			} else if ( intersects[ i ].object.userData.marker && intersects[ i ].object.userData.marker.hotspot ) {
425				
426				if ( ! intersect_sphere || (intersects[ i ].object.userData.marker.isSprite && ! intersects[ i ].object.userData.marker.occluded) ) {
427
428					if ( type == 'mousedown' && Earth.hasEvent( intersects[ i ].object.userData.marker, ['mousedown'] ) ) {
429						intersects[ i ].object.userData.marker.dispatchEvent( { type: "mousedown", originalEvent: event } );
430						event.stopImmediatePropagation();
431						event.preventDefault();
432						break;
433						
434					} else if ( type == 'mouseup' && Earth.hasEvent( intersects[ i ].object.userData.marker, ['mouseup'] ) ) {
435						intersects[ i ].object.userData.marker.dispatchEvent( { type: "mouseup" } );
436						if ( touchEndClick ) {
437							intersects[ i ].object.userData.marker.dispatchEvent( { type: "click", originalEvent: event } );
438						}
439						event.stopImmediatePropagation();
440						event.preventDefault();
441						break;
442						
443					} else if ( ( type == 'click' || touchEndClick ) && Earth.hasEvent( intersects[ i ].object.userData.marker, ['click'] ) ) {
444						intersects[ i ].object.userData.marker.dispatchEvent( { type: "click", originalEvent: event } );
445						event.stopImmediatePropagation();
446						event.preventDefault();
447						break;
448						
449					}
450				
451				}
452
453				
454			}
455			
456		}
457
458	}).bind( this );
459	
460	this.canvas.addEventListener( 'click', clickHandler );
461	this.canvas.addEventListener( 'mousedown', clickHandler );
462	this.canvas.addEventListener( 'mouseup', clickHandler );
463	this.canvas.addEventListener( 'touchstart', clickHandler );
464	this.canvas.addEventListener( 'touchend', clickHandler );
465		
466	this.canvas.addEventListener( 'mouseover', (function(event){
467		
468		if ( this.paused ) return;
469		this.mouseOver = true;
470		
471	}).bind( this ) );
472	
473	this.canvas.addEventListener( 'mouseout', (function(event){
474		
475		if ( this.paused ) return;
476		this.mouseOver = false;

477		this.mouseOverEarth = false;
478		
479		if ( this.mouseOverObject ) {
480			this.mouseOverObject.dispatchEvent( { type: "mouseout", originalEvent: event } );
481			this.mouseOverObject = null;
482		}
483		
484	}).bind( this ) );	
485	
486	this.canvas.addEventListener( 'mousemove', (function(event) {
487		
488		if ( this.paused ) return;
489		this.mousePosition = Earth.normalizeMouse( this, event.clientX, event.clientY );
490	
491	}).bind( this ) );
492	
493	this.canvas.addEventListener( 'touchmove', (function(event) {
494		
495		if ( this.paused ) return;
496		this.mousePosition = Earth.normalizeMouse( this, event.touches[0].clientX, event.touches[0].clientY );
497
498	}).bind( this ) );
499	
500	
501	
502	document.addEventListener( 'mousemove', (function(event) {
503		
504		if ( this.paused ) return;
505		this.docMousePosition = Earth.getEventPosition( event );
506	
507	}).bind( this ) );
508	
509	document.body.addEventListener( 'touchmove', (function(event) {
510		
511		if ( this.paused ) return;
512		this.docMousePosition = Earth.getEventPosition( event );
513	
514	}).bind( this ) );
515	
516	
517	
518	// orbit
519	
520	this.orbit = new Earth.Orbit( this.camera, this );
521	
522	this.orbit.addEventListener( "start", (function() {
523		
524		this.dragging = true;
525		if ( this.grabCursor ) document.documentElement.classList.add( 'earth-dragging' );
526		
527		if ( this.goAnimation ) {
528			this.goAnimation.stop();
529		}
530		
531		if ( this.ready ) this.dispatchEvent( { type: 'dragstart' } );
532		
533		// save mouse position
534		dragStartMousePosition = this.docMousePosition;
535		
536	}).bind( this ) );
537	
538	this.orbit.addEventListener( "change", (function( event ) {
539			
540		if ( this.ready ) this.dispatchEvent( { type: 'change' } );
541		
542		this.radius = this.getRadius();
543		
544		// beginn to ignore clicks if dragged a little distance
545		if ( this.dragging && ! ignoreClicks ) {
546			ignoreClicks = dragStartMousePosition && dragStartMousePosition.distanceTo( this.docMousePosition ) > Earth.maxClickDistance;
547		}
548
549	}).bind( this ) );
550
551	this.orbit.addEventListener( "end", (function() {
552		
553		this.momentum.copy( this.mouseVelocity );
554		this.mouseVelocity.set(0, 0);
555		this.lastDocMousePosition = false;
556		
557		document.documentElement.classList.remove( 'earth-dragging' );
558		
559		if ( this.dragging ) {
560			this.dragging = false;
561			if ( this.ready ) this.dispatchEvent( { type: 'dragend' } );
562		}
563		
564		// enable clicks after dragend
565		if ( ignoreClicks ) {
566			setTimeout( function(){ ignoreClicks = false; }, 1 );
567		}
568		
569	}).bind( this ) );
570	
571	
572	// set properties
573	
574	Object.assign( this, this.options );
575	
576	this.update();
577

578	setTimeout( (function() {
579		this.ready = true;
580		this.element.classList.add( 'earth-ready' );
581		this.dispatchEvent( { type: 'ready' } );
582		this.dispatchEvent( { type: 'change' } );
583	}).bind( this ), 1 );
584	
585};
586
587
588// PUBLIC
589// properties
590
591Object.defineProperties( Earth.prototype, {
592
593	location : {
594		get: function() {
595			
596			return Earth.worldToLatLng( this.camera.position );			
597			
598		},
599		set: function( v ) {
600			var latlng = Object.assign( {}, v );
601			latlng = Earth.formatLatLng( latlng );
602			
603			// limit lat
604			if ( ! this.goAnimation ) { // no limits during rotation animation
605				latlng.lat = Math.min( this.maxLat(), Math.max( this.minLat(), latlng.lat ) );
606			}
607			
608			this.orbit.setPosition( Earth.latLngToWorld( latlng, this.camera.position.length() ) );
609			this.resetAutoRotate();
610			
611		}
612	},
613	
614	paused : {
615		get: function() {
616			return this.options.paused;
617		},
618		set: function( v ) {
619			if ( v ) {
620				this.options.paused = true;
621				
622			} else if ( this.options.paused ) { // resume if paused
623				this.options.paused = false;
624				
625				if ( this.ready ) { // if not ready, update will be called when ready
626					this.update();
627				}
628				
629			}
630		}
631	},
632	
633	mapLandColor : {
634		get: function() {
635			return this.options.mapLandColor;
636		},
637		set: function( v ) {
638			this.options.mapLandColor = v;
639		}
640	},	
641	mapSeaColor : {
642		get: function() {
643			return this.options.mapSeaColor;
644		},
645		set: function( v ) {
646			this.options.mapSeaColor = v;
647		}
648	},
649	mapBorderColor : {
650		get: function() {
651			return this.options.mapBorderColor;
652		},
653		set: function( v ) {
654			this.options.mapBorderColor = v;
655		}
656	},
657	mapBorderWidth : {
658		get: function() {
659			return this.options.mapBorderWidth;
660		},
661		set: function( v ) {
662			this.options.mapBorderWidth = v;
663		}
664	},
665	mapStyles : {
666		get: function() {
667			return this.options.mapStyles;
668		},
669		set: function( v ) {
670			this.options.mapStyles = v;
671		}
672	},
673	mapSvg : {
674		get: function() {
675			return this.options.mapSvg;
676		},
677		set: function( v ) {
678			this.options.mapSvg = v;
679			this.removeHitTester();
680		}
681	},
682	mapImage : {
683		get: function() {
684			return this.options.mapImage;
685		},
686		set: function( v ) {
687			this.options.mapImage = v;
688		}
689	},
690	
691	draggable : {
692		get: function() {
693			return this.orbit.enableRotate;
694		},
695		set: function( v ) {
696			this.orbit.enableRotate = v;
697			
698			if ( ! v && this.dragging ) { // stop dragging
699				this.orbit.cancel();
700				//this.orbit.enabled = false;
701			}
702			
703		}
704	},
705
706	dragPolarLimit : {
707		get: function() {
708			return this.options.dragPolarLimit;
709		},
710		set: function( v ) {
711			this.options.dragPolarLimit = Math.max( 0, Math.min( 1, v ) );
712			this.orbit.minPolarAngle = this.options.dragPolarLimit/2 * Math.PI; // radians
713			this.orbit.maxPolarAngle = (1-this.options.dragPolarLimit/2) * Math.PI; // radians
714		}
715	},
716	
717	polarLimit : {
718		get: function() {
719			return this.options.polarLimit;
720		},
721		set: function( v ) {
722			this.options.polarLimit = Math.max( 0, Math.min( 1, v ) );
723		}
724	},
725	
726	
727	autoRotate : {
728		get: function() {
729			return this.options.autoRotate;
730		},
731		set: function( v ) {
732			this.options.autoRotate = v;
733			if ( ! v ) {
734				this.resetAutoRotate();
735			}
736		}
737	},
738
739
740	zoom : {
741		get: function() {
742			return Earth.camDistance / this.camera.position.length();
743		},
744		set: function( v ) {
745			this.orbit.setPosition( this.camera.position.normalize().multiplyScalar( Earth.camDistance / v ) );
746		}
747	},
748	zoomable : {
749		get: function() {
750			return this.orbit.enableZoom;
751		},
752		set: function( v ) {
753			this.orbit.enableZoom = v;
754		}
755	},
756	zoomMin : {
757		get: function() {
758			return 1 / (this.orbit.maxDistance / Earth.camDistance);
759		},
760		set: function( v ) {
761			this.orbit.maxDistance = Earth.camDistance * (1/v);
762		}
763	},
764	zoomMax : {
765		get: function() {
766			return 1 / (this.orbit.minDistance / Earth.camDistance);
767		},
768		set: function( v ) {
769			this.orbit.minDistance = Earth.camDistance * (1/v);
770		}
771	},
772	zoomSpeed : {
773		get: function() {
774			return this.orbit.zoomSpeed;
775		},
776		set: function( v ) {
777			this.orbit.zoomSpeed = v;
778		}
779	},
780	
781	
782	lightAmbience : {
783		get: function() {
784			return this.ambientLight.intensity;
785		},
786		set: function( v ) {
787			this.ambientLight.intensity = v;
788		}
789	},
790	
791	lightIntensity : {
792		get: function() {
793			if ( ! this.primaryLight ) return 1;
794			return this.primaryLight.intensity;
795		},
796		set: function( v ) {
797			if ( ! this.primaryLight ) return;
798			this.primaryLight.intensity = v;
799		}
800	},	
801	lightColor : {
802		get: function() {
803			if ( ! this.primaryLight ) return '#FFFFFF';
804			return '#' + this.primaryLight.color.getHexString();
805		},
806		set: function( v ) {
807			if ( ! this.primaryLight ) return;
808			this.primaryLight.color = new THREE.Color(v);
809		}
810	},
811	lightGroundColor : {
812		get: function() {
813			if ( ! this.primaryLight || ! this.primaryLight.isHemisphereLight ) return '#FFFFFF';
814			return '#' + this.primaryLight.groundColor.getHexString();
815		},
816		set: function( v ) {
817			if ( ! this.primaryLight || ! this.primaryLight.isHemisphereLight ) return;
818			this.primaryLight.groundColor = new THREE.Color(v);
819		}
820	},
821	
822	sunLocation : {
823		get: function() {
824			if ( ! this.primaryLight || ! this.primaryLight.isDirectionalLight ) return { lat: 0, lng: 0 };
825			return Earth.worldToLatLng( this.primaryLight.position );	
826		},
827		set: function( v ) {
828			if ( ! this.primaryLight || ! this.primaryLight.isDirectionalLight ) return;
829			this.primaryLight.position.copy( Earth.latLngToWorld( Earth.formatLatLng(v), Earth.camDistance ) );
830		}
831	},
832	
833	sunDirection : {
834		get: function() {
835			if ( ! this.primaryLight || ! this.primaryLight.isDirectionalLight ) return false;

836			return this.options.sunDirection;	
837		},
838		set: function( v ) {
839			if ( ! this.primaryLight || ! this.primaryLight.isDirectionalLight ) return;
840			if ( ! v || typeof v.x == 'undefined' ) return;
841			if ( this.primaryLight.parent !== this.camera ) {
842				this.camera.add( this.primaryLight );
843			}			
844			this.primaryLight.position.set( v.x*50, v.y*50, 0);
845		}
846	},
847	
848
849} );
850
851
852// private
853// determine quality based on container size
854
855Earth.prototype.getQuality = function() {
856	
857	return ( this.element.offsetWidth >= 720 ) ? 4 : 3;
858	
859};
860
861
862// private
863// get min and max latitude according to polarLimit
864
865Earth.prototype.minLat = function() {
866	return (1 - this.options.polarLimit) * -90;
867};
868Earth.prototype.maxLat = function() {
869	return (1 - this.options.polarLimit) * 90;	
870};
871
872
873
874// private
875// handle autoRotate
876
877Earth.prototype.updateAutoRotate = function() {
878	
879	this.autoRotateTime += this.deltaTime;
880	
881	if ( this.autoRotateTime > this.autoRotateDelay ) {
882		
883		if ( ! this.autoRotate ) { // start autoRotate
884			this.dispatchEvent( { type: 'autorotate' } );
885			this.autoRotate = true;
886		}
887		
888		var t = ( this.autoRotateTime - this.autoRotateDelay ) / this.autoRotateStart;
889		
890		if ( t > 1 ) {
891			this.orbit.autoRotateSpeed = this.autoRotateSpeed;
892			this.orbit.autoRotateSpeedUp = this.autoRotateSpeedUp;
893		} else {
894			this.orbit.autoRotateSpeed = THREE.Math.lerp( 0, this.autoRotateSpeed, Earth.Animation.Easing[ this.autoRotateEasing ](t) );
895			this.orbit.autoRotateSpeedUp = THREE.Math.lerp( 0, this.autoRotateSpeedUp, Earth.Animation.Easing[ this.autoRotateEasing ](t) );
896		}
897	
898	} else {
899
900		this.orbit.autoRotateSpeed = 0;
901		this.orbit.autoRotateSpeedUp = 0;
902	
903	}
904	
905};
906
907
908// PUBLIC
909// start autoRotate without delay
910
911Earth.prototype.startAutoRotate = function( easeIn ) {
912	this.autoRotateTime = this.autoRotateDelay + ( ( easeIn ) ? 0 : this.autoRotateStart );
913	this.autoRotate = true;
914	this.autoRotating = true;
915};
916
917// PUBLIC
918// interrupt rotation
919
920Earth.prototype.resetAutoRotate = function() {
921	this.autoRotateTime = 0;
922	this.autoRotating = false;
923};
924
925
926// private
927// handle momentum
928
929Earth.prototype.updateMomentum = function() {
930	
931	if ( this.dragging ) {
932		
933		this.resetAutoRotate();
934		this.orbit.autoRotateSpeed = 0;
935		this.orbit.autoRotateSpeedUp = 0;
936		this.momentum.set( 0, 0 );
937		
938		return;
939		
940	}
941	
942	if ( this.momentum.equals( Earth.zeroMomentum ) ) {
943		
944		if ( this.autoRotate ) {
945			
946			this.updateAutoRotate();
947			
948		} else {
949			
950			this.orbit.autoRotateSpeed = 0;
951			this.orbit.autoRotateSpeedUp = 0;
952			
953		}
954		
955		return;
956		
957	}
958	
959	this.resetAutoRotate();
960	
961	this.orbit.autoRotateSpeed = this.momentum.x * 10000;
962	this.orbit.autoRotateSpeedUp = this.momentum.y * 10000;
963	
964	this.momentum.set(
965		THREE.Math.lerp( this.momentum.x, 0, this.deltaTime / (2000 - (this.dragDamping*1999)) ),
966		THREE.Math.lerp( this.momentum.y, 0, this.deltaTime / (2000 - (this.dragDamping*1999)) )
967	);
968	
969	
970	if ( Math.abs(this.momentum.x) < 0.00005 ) {
971		this.momentum.x = 0;
972	}
973	if ( Math.abs(this.momentum.y) < 0.00005 ) {
974		this.momentum.y = 0;
975	}	
976	
977};
978
979
980// private
981// calculate velocity for momentum
982
983Earth.prototype.updatePointerVelocity = function() {
984
985	if ( this.dragging && this.dragMomentum && this.docMousePosition && this.lastDocMousePosition ) {
986		
987		var moveVelocity = this.docMousePosition.clone().sub(
988			this.lastDocMousePosition
989		).multiplyScalar( 0.00005 );
990		
991		var max_velocity_x = 0.002;
992		var max_velocity_y = 0.0015;
993		// limit velocity
994		if ( moveVelocity.x < -max_velocity_x ) moveVelocity.x = -max_velocity_x;
995		else if ( moveVelocity.x > max_velocity_x ) moveVelocity.x = max_velocity_x;
996		if ( moveVelocity.y < -max_velocity_y ) moveVelocity.y = -max_velocity_y;
997		else if ( moveVelocity.y > max_velocity_y ) moveVelocity.y = max_velocity_y;
998		
999		
1000		//this.mouseVelocity.lerp( moveVelocity, Math.min(1, this.deltaTime/50) );
1001		this.mouseVelocity.copy( moveVelocity );
1002		
1003	} else {
1004		
1005		this.mouseVelocity.set( 0, 0 );
1006		
1007	}
1008	
1009	this.lastDocMousePosition = ( this.docMousePosition ) ? this.docMousePosition.clone() : false;
1010	
1011};
1012
1013
1014// private
1015// handle mouse over/out events and cursors
1016
1017Earth.prototype.updatePointer = function() {
1018
1019	// mouse over / out
1020	
1021	var overObject = false;

1022	this.mouseOverEarth = false;
1023	
1024	
1025	if ( this.mouseOver && ! this.dragging ) {
1026	
1027		var intersects = this.raycast( this.mousePosition );
1028		var intersect_sphere = false;
1029		
1030		for ( var i = 0; i < intersects.length; i++ ) {
1031			
1032			var obj = intersects[ i ].object;
1033			
1034			if ( obj == this.sphere ) {
1035				this.mouseOverEarth = true;
1036				intersect_sphere = true;
1037			
1038			} else if ( ! overObject && obj.userData.marker && obj.userData.marker.hotspot && Earth.hasEvent( obj.userData.marker, ['click','mousedown','mouseup','mouseover','mouseout'] ) ) {
1039				
1040				if ( ! intersect_sphere || (intersects[ i ].object.userData.marker.isSprite && ! intersects[ i ].object.userData.marker.occluded) ) {
1041					overObject = intersects[ i ].object.userData.marker;
1042				}
1043				
1044			}
1045		}
1046		
1047	}
1048	
1049	
1050	if ( overObject ) {
1051		
1052		if ( this.mouseOverObject && this.mouseOverObject != overObject ) {
1053			this.mouseOverObject.dispatchEvent( { type: "mouseout" } );
1054		}
1055		
1056		this.mouseOverObject = overObject;
1057		this.mouseOverObject.dispatchEvent( { type: "mouseover" } ); 
1058		
1059	} else if ( this.mouseOverObject ) {
1060		
1061		this.mouseOverObject.dispatchEvent( { type: "mouseout" } );
1062		this.mouseOverObject = null;
1063		
1064	}
1065	
1066	
1067	if ( this.mouseOverObject && Earth.hasEvent( this.mouseOverObject, ['click'] ) ) {
1068		this.element.classList.add( 'earth-clickable' );
1069	} else {
1070		this.element.classList.remove( 'earth-clickable' );
1071	}
1072	
1073	
1074	if ( this.draggable && this.grabCursor && this.mouseOverEarth ) {
1075		this.element.classList.add( 'earth-draggable' );
1076	} else {
1077		this.element.classList.remove( 'earth-draggable' );
1078	}
1079	
1080};
1081
1082
1083
1084// PUBLIC
1085
1086Earth.prototype.hitTest = function( latlng ) {
1087	
1088	return this.hitTestMap( Earth.latLngToUv( latlng ) );
1089	
1090};
1091
1092// private
1093// hit test a uv position and return path id
1094
1095Earth.prototype.hitTestMap = function( uv ) {
1096	
1097	if ( ! this.mapSvg ) return '';
1098	
1099	if ( ! this.hitTester ) {
1100		this.hitTester = document.createElement( 'div' );
1101		document.body.appendChild( this.hitTester );
1102		this.hitTester.className = 'earth-hittest';
1103		this.hitTester.innerHTML = String( this.mapSvg ).replace(/\sid\s*=/gi, ' data-id=');  // escape IDs
1104	}
1105	
1106	var svgElement = this.hitTester.querySelector('svg');
1107	if ( ! svgElement ) return '';
1108	
1109	this.hitTester.style.display = 'block';
1110	
1111	var rect = svgElement.getBoundingClientRect();
1112	var elem = document.elementFromPoint( uv.x * rect.width, uv.y * rect.height );
1113	
1114	this.hitTester.style.display = 'none';
1115
1116	if ( elem && elem.dataset && elem.dataset.id ) {
1117		return elem.dataset.id;
1118	} else {
1119		return '';
1120	}
1121	
1122};
1123
1124// private
1125// removes hitTester if earth is destroyed or mapSvg is changed
1126
1127Earth.prototype.removeHitTester = function() {
1128	if ( this.hitTester ) {
1129		this.hitTester.remove();
1130		this.hitTester = null;
1131	}
1132};
1133
1134
1135// private
1136// raycast of mouse position
1137
1138Earth.prototype.raycast = function( mouse ) {
1139	
1140	this.raycaster.setFromCamera( Earth.normalizeRaycast(mouse), this.camera );
1141	return this.raycaster.intersectObjects( this.scene.children );
1142	
1143};
1144
1145
1146// PUBLIC
1147// call redrawMap if map properties have been changed
1148
1149Earth.prototype.redrawMap = function() {
1150	
1151	this.loadTexture();
1152	
1153};
1154
1155
1156// PUBLIC
1157// updates the map texture after drawing to the mapCanvas
1158
1159Earth.prototype.updateMap = function() {
1160	
1161	if ( this.mapTexture ) this.mapTexture.needsUpdate = true;
1162	
1163};
1164
1165
1166// private
1167// is svg?
1168
1169Earth.prototype.mapImageIsSvg = function( url ) {
1170	
1171	return String(url).toLowerCase().indexOf('.svg') != -1;
1172	
1173};
1174
1175
1176
1177// private
1178// load map texture
1179
1180Earth.prototype.loadTexture = function( useMapSvg, isDefaultMap ) {
1181	
1182	if ( useMapSvg ) { // svg map
1183		
1184		var svg = this.mapSvg;
1185		
1186		if ( isDefaultMap ) {
1187			var style = '<style type="text/css">';
1188			style += '#SEA { fill:'+ this.options.mapSeaColor +'; }';
1189			style += 'path { fill:'+ this.options.mapLandColor +'; ';
1190			style += 'stroke:'+ ( this.options.mapBorderColor ? this.options.mapBorderColor : this.options.mapLandColor ) +'; ';
1191			style += 'stroke-width:'+ this.options.mapBorderWidth +'; stroke-miterlimit:1; }';
1192			style += this.options.mapStyles;
1193			style += '</style>';
1194			svg = svg.replace( /(<svg[^>]+>)/i, '$1 ' + style );
1195		}
1196		
1197		this.mapImageElem = document.createElement("img");
1198		this.mapImageElem.setAttribute( "src", "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(svg))) );
1199		this.mapImageElem.onload = this.drawTexture.bind( this );
1200		

1201		
1202	} else if ( this.options.legacySupportIE11 && Earth.isIE11() && this.options.fallbackMapUrlIE11 ) { // IE fallback map image
1203	
1204		this.mapImageElem = document.createElement("img");
1205		this.mapImageElem.setAttribute( "src", this.options.fallbackMapUrlIE11 );
1206		this.mapImageElem.onload = this.drawTexture.bind( this );
1207		
1208		
1209	} else if ( this.options.mapImage && ! this.mapImageIsSvg( this.options.mapImage ) ) { // pixel image
1210	
1211		this.mapImageElem = document.createElement("img");
1212		this.mapImageElem.setAttribute( "src", this.options.mapImage );
1213		this.mapImageElem.onload = this.drawTexture.bind( this );
1214		
1215		
1216	} else if ( this.options.mapImage ) { // custom svg
1217	
1218		var thisEarth = this;
1219		var ajax = new XMLHttpRequest();
1220
1221		ajax.onreadystatechange = function() {
1222			if ( this.readyState == 4 ) {
1223				thisEarth.mapSvg = Earth.fixSvgNamespace( this.responseText );
1224				thisEarth.loadTexture( true, false );
1225			}
1226		};
1227		
1228		ajax.open("GET", this.options.mapImage, true);
1229		ajax.send();
1230	
1231	
1232	} else if ( Earth.mapSvg ) { // default svg
1233		
1234		this.mapSvg = Earth.fixSvgNamespace( Earth.mapSvg );
1235		this.loadTexture( true, true );
1236		
1237		
1238	} else {
1239		
1240		setTimeout( this.drawTexture.bind( this ), 1 );
1241		
1242		
1243	}
1244	
1245};
1246
1247
1248// private
1249// draw the map texture, called by loadTexture
1250
1251Earth.prototype.drawTexture = function() {
1252	
1253	if ( ! this.mapCanvas ) {
1254		this.mapCanvas = document.createElement( "canvas" );
1255		this.mapCanvas.width = Earth.textureSize[ this.quality ];
1256		this.mapCanvas.height = Earth.textureSize[ this.quality ] / 2;
1257		this.mapContext = this.mapCanvas.getContext("2d");
1258		
1259	} else { // already exits
1260		this.mapContext.clearRect(0, 0, this.mapCanvas.width, this.mapCanvas.height);
1261		
1262	}
1263	
1264	
1265	// draw map image
1266	
1267	if ( this.mapImageElem ) {
1268		this.mapContext.drawImage( this.mapImageElem, 0, 0, this.mapImageElem.width, this.mapImageElem.height, 0, 0, this.mapCanvas.width, this.mapCanvas.height );
1269	}
1270		
1271	this.dispatchEvent( { type: 'drawtexture', canvas: this.mapCanvas, context : this.mapContext } );
1272	
1273	
1274	if ( ! this.mapTexture ) {
1275		
1276		this.mapTexture = new THREE.CanvasTexture( this.mapCanvas );
1277		this.mapTexture.wrapS = THREE.RepeatWrapping; // this.mapTexture.wrapT = 
1278		this.mapTexture.anisotropy = Earth.anisotropy[ this.quality ];
1279		this.mapTexture.offset = new THREE.Vector2( -0.25, 0 );
1280	
1281		var earthMaterial = {
1282			map: this.mapTexture,
1283			shininess: this.shininess * 100,
1284			dithering : (this.light != 'none')
1285		};
1286		
1287		// inner earth
1288		if ( this.transparent ) {
1289			
1290			earthMaterial.transparent = true;
1291			earthMaterial.depthWrite = false;
1292
1293			this.innerSphere.material = new THREE.MeshBasicMaterial( {
1294				dithering : (this.light != 'none'),
1295				transparent : true,
1296				color : this.innerColor,
1297				opacity : this.innerOpacity,
1298				side: THREE.BackSide,
1299				depthWrite : false,
1300				map: this.mapTexture
1301			} );
1302
1303		}
1304
1305		this.sphere.material = new THREE.MeshPhongMaterial( earthMaterial );
1306	
1307	
1308	} else { // already exists
1309	
1310		this.mapTexture.needsUpdate = true;
1311		
1312	}
1313	
1314};
1315
1316
1317// private
1318// watch for bounding rect changes
1319
1320Earth.prototype.updateBounds = function() {
1321	
1322	this.bounds = this.element.getBoundingClientRect();
1323	
1324	this.outOfView = 	this.bounds.right < 0 || this.bounds.bottom < 0 ||
1325						this.bounds.left > window.innerWidth  || this.bounds.top > window.innerHeight;
1326						
1327	this.isVisible = this.bounds.width && this.bounds.height;
1328	
1329	
1330	if ( this.elementSize.x == this.bounds.width && this.elementSize.y == this.bounds.height ) return; // not resized
1331	
1332	this.elementSize.set( this.bounds.width, this.bounds.height );
1333	this.elementCenter.set( this.bounds.width / 2, this.bounds.height / 2 );
1334	this.containerScale = Math.min( this.elementSize.x, this.elementSize.y ) / 1000; // for overlay scaling
1335	
1336	this.camera.aspect = this.bounds.width / this.bounds.height;
1337	this.camera.updateProjectionMatrix();
1338	this.renderer.setSize( this.bounds.width, this.bounds.height );
1339	
1340	this.radius = this.getRadius();
1341	
1342};
1343
1344
1345// private
1346// main loop
1347
1348Earth.prototype.update = function() {
1349	
1350	if ( this.paused ) return;
1351	
1352	requestAnimationFrame( this.update.bind(this) );
1353	
1354	if ( ! this.ready ) return;
1355	
1356	this.deltaTime = Math.min( 100, this.clock.getDelta() * 1000 );
1357	
1358	this.updateBounds();
1359	this.updatePointerVelocity();
1360	this.updatePointer();
1361	this.updateMomentum();

1362	this.orbit.update();
1363
1364	/* >>> */
1365	this.updateAnimations();
1366	/* <<< */
1367
1368	this.dispatchEvent( { type: "update" } );
1369
1370
1371	if ( ! this.outOfView && this.isVisible ) {		
1372
1373		this.renderer.render( this.scene, this.camera );
1374		
1375		/* >>> */
1376		this.updateOccludables();
1377		/* <<< */
1378		
1379		this.updateOverlays();	
1380	
1381	}
1382	
1383};
1384
1385
1386
1387// PUBLIC
1388// create and add objects
1389
1390Earth.prototype.addMarker = function( options ) {
1391	return new Earth.Marker( options, this );
1392};
1393
1394/* >>> */
1395
1396Earth.prototype.addImage = function( options ) {
1397	return new Earth.Image( options, this );
1398};
1399
1400
1401Earth.prototype.addSprite = function( options ) {
1402	return new Earth.Sprite( options, this );
1403};
1404
1405
1406Earth.prototype.addPoints = function( options ) {
1407	return new Earth.Points( options, this );
1408};
1409
1410
1411Earth.prototype.addLine = function( options ) {
1412	return new Earth.Line( options, this );
1413};
1414
1415/* <<< */
1416
1417Earth.prototype.addOverlay = function( options ) {
1418	return new Earth.Overlay( options, this );
1419};
1420
1421
1422// private
1423// handle overlays
1424
1425Earth.prototype.updateOverlays = function() {
1426	
1427	var updateOrder = false;
1428	var camDistance = this.camera.position.length();
1429	
1430	for (var i=0; i < this.overlays.length; i++) {
1431		
1432		var overlay = this.overlays[i];
1433		
1434		
1435		updateOrder = true;
1436	
1437		// position
1438		overlay.updatePositions();
1439		
1440		if ( overlay.elementPosition.y < overlay.earth.elementSize.y / 2 ) {
1441			overlay.element.classList.add('earth-overlay-top');
1442		} else {
1443			overlay.element.classList.remove('earth-overlay-top');
1444		}
1445		
1446		if ( overlay.elementPosition.x < overlay.earth.elementSize.x / 2 ) {
1447			overlay.element.classList.add('earth-overlay-left');
1448		} else {
1449			overlay.element.classList.remove('earth-overlay-left');
1450		}
1451		
1452		// occlusion
1453		overlay.updateOcclusion();
1454		
1455		if ( overlay.occluded ) {
1456			overlay.element.classList.add('earth-occluded');
1457		} else {
1458			overlay.element.classList.remove('earth-occluded');
1459		}
1460		
1461		
1462		if ( ! overlay.visible ) continue;
1463		
1464		
1465		// scaling
1466		var scale = 1;
1467		
1468		if ( overlay.depthScale ) {
1469			scale *= Math.max( 0, 1 - overlay.depthScale + (camDistance-overlay.distance) / Earth.earthRadius * overlay.depthScale );
1470		}		
1471		if ( overlay.zoomScale ) {
1472			scale *= THREE.Math.lerp( 1, this.zoom, overlay.zoomScale );
1473		}
1474		if ( overlay.containerScale ) {
1475			scale *= THREE.Math.lerp( 1, this.containerScale, overlay.containerScale );
1476		}
1477		
1478		scale = Math.max(0, scale);
1479		var scaleTransform = ( scale!=1 ) ? ' scale('+ scale +')' : '';
1480		
1481		
1482		// apply transform
1483		overlay.element.style.transform = 'translate('+ overlay.elementPosition.x +'px, '+ overlay.elementPosition.y +'px)' + scaleTransform;
1484		
1485		
1486		if ( ! overlay.ready ) {
1487			overlay.ready = true;
1488			overlay.visible = true;
1489		}
1490	
1491	}
1492	
1493	
1494	if ( updateOrder ) {
1495	
1496		// sort by cam distance for z-index
1497		
1498		this.overlays.sort( function(a, b) {
1499			return b.distance - a.distance;
1500		} );
1501	
1502		for (var i=0; i < this.overlays.length; i++) {
1503			this.overlays[i].element.style.zIndex = (( this.overlays[i].occluded && this.overlays[i].occlude ) ? 10 : 1010) + i;
1504		}
1505		
1506	}
1507	
1508};
1509
1510
1511// private
1512// handle occlusion
1513
1514Earth.prototype.updateOccludables = function() {
1515	
1516	for ( var i=0; i < this.occludables.length; i++ ) {
1517		
1518		var occludable = this.occludables[i];
1519		
1520		occludable.updatePositions();
1521		occludable.updateOcclusion();
1522
1523	}
1524	
1525};
1526
1527
1528// private
1529// handle all animations on this earth
1530/* >>> */
1531
1532Earth.prototype.updateAnimations = function() {
1533	
1534	var complete_animations = [];
1535	
1536	for ( var i in this.animations ) {
1537		var ani = this.animations[i];
1538		
1539		if ( ani.paused ) continue;
1540		
1541		if ( ani.target.removed ) {
1542			complete_animations.push( ani );
1543			continue;
1544		}
1545		
1546		ani.time += this.deltaTime;
1547		var p = ani.time / ani.duration; // progress 0-1
1548		
1549		ani.step( Math.min( p, 1 ) );
1550		
1551		if ( p >= 1 ) { // end of animation
1552		
1553			if ( ani.loop ) {
1554				
1555				if ( ani.oscillate ) {
1556					ani.time = Math.max( 0, ani.duration - ani.time );
1557					var current = ani.to;
1558					ani.to = ani.from;
1559					ani.from = current;
1560				} else {
1561					ani.time = Math.max( 0, ani.duration - ani.time );
1562				}
1563				
1564				ani.dispatchEvents( true );
1565				
1566			} else {
1567				complete_animations.push( ani );
1568			}
1569			
1570		}
1571		
1572	}
1573	
1574	for ( var i in complete_animations ) {
1575		complete_animations[i].stop( true );
1576	}
1577	
1578};
1579
1580/* <<< */
1581
1582
1583
1584// PUBLIC
1585// animate earth location and zoom
1586// special options: zoom, approachAngle
1587// returns false or aniInstance
1588
1589Earth.prototype.goTo = function( location, options ) {
1590	
1591	if ( ! options ) options = {};
1592	
1593	if ( options.approachAngle ) {
1594	
1595		var toPos = Earth.latLngToWorld( location, Earth.earthRadius );
1596		var camPos = this.camera.position.clone().normalize().multiplyScalar( Earth.earthRadius );
1597		
1598		if ( THREE.Math.radToDeg( toPos.angleTo( camPos ) ) > options.approachAngle ) {
1599			
1600			for ( var i=1; i <= 32; i++ ) {
1601				
1602				var midPos = new THREE.Vector3().lerpVectors( camPos, toPos, i/32 ).normalize().multiplyScalar( Earth.earthRadius );
1603				
1604				if ( THREE.Math.radToDeg( toPos.angleTo( midPos ) ) <= options.approachAngle ) {
1605					
1606					location = Earth.worldToLatLng( midPos );
1607					break;
1608					
1609				}
1610				
1611			}
1612			
1613		} else {
1614		
1615			return false;

1616			
1617		}
1618		
1619	}
1620	
1621	
1622	// cancel previous animation
1623	
1624	if ( this.goAnimation ) {
1625		this.goAnimation.stop();
1626	}
1627	
1628	
1629	var to = Object.assign( {}, location );	
1630	
1631	// limit lat
1632	to.lat = Math.min( this.maxLat(), to.lat );
1633	to.lat = Math.max( this.minLat(), to.lat );
1634	
1635
1636	var ani = {
1637		_end : function() {
1638			this.goAnimation = null;
1639			if ( this.zoomAnimation ) this.zoomAnimation.stop();
1640			this.zoomAnimation = null;
1641		},
1642		lerpLatLng : true
1643	};
1644	
1645	Object.assign( ani, options );
1646	
1647	this.goAnimation = this.animate( 'location', to, ani );
1648	
1649	
1650	if ( options.zoom ) {
1651		
1652		this.zoomAnimation = this.animate( 'zoom', options.zoom, {
1653			duration : this.goAnimation.duration
1654		} );
1655		
1656	}
1657	
1658	return this.goAnimation;
1659	
1660};
1661
1662
1663
1664// PUBLIC
1665// get position in element container for a lat/lng location with optional earth offset
1666
1667Earth.prototype.getPoint = function( location, offset ) {
1668	
1669	if ( ! offset ) offset = 0;
1670	
1671	var worldPos = Earth.latLngToWorld( location, Earth.earthRadius + offset );
1672	
1673	return Earth.worldToElement( worldPos, this.elementSize, this.camera );	
1674	
1675};
1676
1677
1678
1679// PUBLIC
1680// get lat/lng location for a mouse/touch position
1681
1682Earth.prototype.getLocation = function( point ) {
1683	
1684	var mouse = Earth.normalizeMouse( this, point.x, point.y );
1685	
1686	this.raycaster.setFromCamera( Earth.normalizeRaycast(mouse), this.camera );
1687	var intersects = this.raycaster.intersectObjects( [this.sphere] );
1688	
1689	for ( var i = 0; i < intersects.length; i++ ) {
1690		
1691		var uv = intersects[ i ].uv;
1692		intersects[ i ].object.material.map.transformUv( uv );
1693		
1694		return Earth.uvToLatLng( uv );
1695		
1696	}
1697	
1698	return false;
1699	
1700};
1701
1702
1703
1704// PUBLIC
1705// get approx. earth radius in pixels
1706
1707Earth.prototype.getRadius = function() {
1708	
1709	return this.elementSize.y / 2 * 0.758 *
1710		Math.pow( this.zoom, 
1711			(this.zoom > 1) ? 1.158 : 
1712			THREE.Math.lerp( 1.01, 1.11, this.zoom )
1713		);
1714	
1715};
1716
1717
1718
1719// static const
1720
1721Earth.earthRadius = 8;
1722Earth.camDistance = 24;
1723Earth.textureSize = [ 0, 512, 1024, 2048, 4096, 8192, 16384 ];
1724Earth.shadowSize  = [ 0, 512,  512, 1024, 2048, 4096,  8192 ];
1725Earth.anisotropy = [ 1, 1, 2, 4, 8, 8, 16 ];
1726
1727Earth.defaultImage = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIzMiIgaGVpZ2h0PSIzMiIgdmlld0JveD0iMCAwIDMyIDMyIj48Y2lyY2xlIGZpbGw9IiNmZmYiIGN4PSIxNiIgY3k9IjE2IiByPSIxNiIvPjwvc3ZnPg';
1728Earth.spriteHotspot = 'data:image/svg+xml;base64,PHN2ZyB2ZXJzaW9uPSIxLjEiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHg9IjBweCIgeT0iMHB4IiB3aWR0aD0iNjRweCIgaGVpZ2h0PSI2NHB4IiB2aWV3Qm94PSIwIDAgNjQgNjQiIHN0eWxlPSJlbmFibGUtYmFja2dyb3VuZDpuZXcgMCAwIDY0IDY0OyIgeG1sOnNwYWNlPSJwcmVzZXJ2ZSI+PHBhdGggZmlsbD0iIzAwRkYwMCIgZD0iTTEsMXY2Mmg2MlYxSDF6IE02Miw2MkgyVjJoNjBWNjJ6Ii8+PC9zdmc+';
1729
1730Earth.invisibleMaterial = new THREE.MeshBasicMaterial( {visible: false} );
1731Earth.hotspotMaterial = new THREE.MeshBasicMaterial( {color: 0x00ff00, wireframe: true} );
1732
1733
1734Earth.up = new THREE.Vector3( 0, 1, 0 );
1735Earth.left = new THREE.Vector3( 1, 0, 0 );
1736Earth.back = new THREE.Vector3( 0, 0, 1 );
1737Earth.zero = new THREE.Vector3( 0, 0, 0 );
1738
1739Earth.zeroMomentum = new THREE.Vector2();
1740
1741Earth.maxClickDistance = 10;
1742
1743
1744// static vars
1745
1746Earth.capabilitiesChecked = false;
1747Earth.cssAdded = false;
1748Earth.meshesAdded = false;
1749
1750Earth.meshes = {};
1751Earth.textures = {};
1752
1753
1754// static functions
1755
1756
1757// private
1758// fix the corrpuption of the svg namespace with some webservers
1759
1760Earth.fixSvgNamespace = function( svg ) {
1761	return String(svg).replace('xmlns="https://www.w3.org/2000/svg"', 'xmlns="ht'+'tp://www.w3.org/2000/svg"');
1762};
1763
1764
1765// private
1766// lat/lng values to numbers
1767
1768Earth.formatLatLng = function( latlng ) {
1769	if ( typeof latlng != "object" ) {
1770		return { lat: 0, lng: 0 };
1771	} else {
1772		latlng.lat = Number(latlng.lat);
1773		latlng.lng = Number(latlng.lng);
1774		return latlng;
1775	}	
1776};
1777
1778
1779// private
1780// get a simple hash of a string
1781
1782Earth.hash = function( str ){
1783    var hash = 0;
1784    if (str.length == 0) return hash;
1785    for (var i = 0; i < str.length; i++) {
1786        hash = ((hash<<5)-hash) + str.charCodeAt(i);
1787        hash = hash & hash;
1788    }
1789    return hash;
1790};
1791
1792
1793// private
1794// load a texture or get it from textures array if it exists
1795
1796Earth.getTexture = function ( src, resolution, alphaOnly ) {
1797	
1798	// build a unique key of source and options
1799	var key = Earth.hash(src) + '#' + resolution + ((alphaOnly)?'#a':'');
1800	
1801	// return existing texture
1802	if ( Earth.textures[key] ) return Earth.textures[key];
1803	
1804	
1805	var canvas = document.createElement("canvas");
1806	canvas.width = resolution;
1807	canvas.height = resolution;
1808

1809	Earth.textures[key] = new THREE.CanvasTexture( canvas );
1810	Earth.textures[key].needsUpdate = false;
1811	
1812	
1813	var img = new Image();
1814
1815	img.onload = function () {
1816
1817		// scale to contain
1818
1819		var ratio = img.naturalHeight / img.naturalWidth;
1820		var x = 0, y = 0, w = canvas.width, h = canvas.height;
1821		
1822		if ( ratio < 1 ) { // landscape
1823			h = Math.round( w * ratio );
1824			y = Math.round( canvas.height / 2 - h / 2 );
1825		} else { // portrait
1826			w = Math.round( h * (1/ratio) );
1827			x = Math.round( canvas.width / 2 - w / 2 );
1828		}
1829		
1830
1831		var ctx = canvas.getContext("2d");
1832
1833		// base color with 1% alpha
1834		ctx.globalAlpha = 1/256;
1835		ctx.fillStyle = "#999999";
1836		ctx.fillRect( 0, 0, canvas.width, canvas.height);
1837		ctx.globalAlpha = 1;
1838
1839		// draw original image
1840		ctx.globalCompositeOperation = "source-over";
1841		ctx.drawImage( img, x, y, w, h );
1842		
1843		
1844		// only change colors, not alpha
1845		ctx.globalCompositeOperation = "source-atop";
1846		
1847		if ( alphaOnly ) { // tint white
1848		
1849			ctx.fillStyle = "white";
1850			ctx.fillRect( 0, 0, canvas.width, canvas.height );
1851		
1852		} else { // bleed colors
1853			
1854			var offset = [-1,-1, 0,-1, 1,-1, -1,0, 1,0, -1,1, 0,1, 1,1];
1855			var s = 2;  // thickness scale
1856			  
1857			// draw 8 images at offsets from the array scaled by s
1858			for (var i=0; i < offset.length; i += 2) ctx.drawImage(img, x + offset[i]*s, y + offset[i+1]*s, w, h);
1859
1860			// image at original position
1861			ctx.drawImage( img, x, y, w, h );
1862			
1863		}		
1864		
1865		Earth.textures[key].needsUpdate = true;
1866	  
1867	};
1868
1869	img.src = src;
1870	
1871	
1872	return Earth.textures[key];
1873
1874};
1875
1876
1877// private
1878// limit resolution/quality to system capabilities
1879
1880Earth.checkCapabilities = function( renderer ) {
1881	
1882	var maxTex = renderer.capabilities.maxTextureSize;
1883	var maxAni = renderer.capabilities.getMaxAnisotropy();
1884	
1885	for ( var i=0; i < Earth.textureSize.length; i++ ) {
1886		if ( Earth.textureSize[i] > maxTex ) Earth.textureSize[i] = maxTex;
1887		if ( Earth.shadowSize[i] > maxTex ) Earth.shadowSize[i] = maxTex;
1888		
1889		if ( Earth.anisotropy[i] > maxAni ) Earth.anisotropy[i] = maxAni;
1890	}
1891
1892	Earth.capabilitiesChecked = true;
1893	
1894};
1895
1896
1897// private
1898// register and dispatch custom load event when the script is loaded
1899
1900Earth.dispatchLoadEvent = function() {
1901	
1902	if ( typeof window.CustomEvent === "function" ) {
1903		var loadedEvent = new CustomEvent( "earthjsload" );	
1904	} else {
1905		var loadedEvent = document.createEvent( "CustomEvent" );
1906		loadedEvent.initCustomEvent( "earthjsload", false, false, undefined );
1907	}
1908	
1909	window.dispatchEvent( loadedEvent );
1910	
1911};
1912
1913
1914// private
1915// add default css from string
1916
1917Earth.addCss = function() {
1918
1919	Earth.styleElement = document.createElement('style');
1920
1921	if ( Earth.styleElement.styleSheet ) {
1922		Earth.styleElement.styleSheet.cssText = Earth.css;
1923	} else {
1924		Earth.styleElement.appendChild( document.createTextNode( Earth.css ) );
1925	}
1926	
1927	document.getElementsByTagName("head")[0].appendChild( Earth.styleElement );
1928
1929};
1930
1931
1932// PUBLIC
1933// parse meshes from obj file string
1934
1935Earth.addMesh = function( objString ) {
1936	 
1937	var lib = new Earth.ObjParser().parse( objString );
1938	
1939	lib.traverse( function ( child ) {
1940		
1941		if ( ! child.name ) return;
1942		
1943		Earth.meshes[ child.name.split('_')[0] ] = child;
1944		child.material = new THREE.MeshPhongMaterial( { color: 0xFF0000, shininess: 0.3, flatShading: false } );
1945		

1946	} );
1947	
1948};
1949
1950
1951// private
1952// dispose objects
1953
1954Earth.dispose = function( obj ) {
1955	
1956	while (obj.children.length > 0) { 
1957		Earth.dispose(obj.children[0]);
1958		obj.remove(obj.children[0]);
1959	}
1960	
1961	if (obj.geometry) obj.geometry.dispose();
1962	if (obj.material) obj.material.dispose();
1963	
1964};
1965
1966
1967// PUBLIC
1968// destroy earth to free memory
1969
1970Earth.prototype.destroy = function() {
1971	
1972	this.paused = true;
1973	
1974	Earth.dispose( this.scene );
1975	
1976	this.renderer.forceContextLoss();
1977	this.renderer.dispose();
1978	this.renderer.context = null;
1979	this.renderer.domElement.remove();
1980	this.renderer.domElement = null;
1981	
1982	this.orbit.dispose();
1983	
1984	this.removeHitTester();
1985	
1986	this.overlays = null;
1987	this.occludables = null;
1988	this.animations = null;
1989	this.element.earth = null;
1990	this.element = null;
1991	this.canvas = null;
1992
1993};
1994
1995
1996// PUBLIC
1997// check for webgl support
1998
1999Earth.isSupported = function( supportIE11 ) {
2000	
2001	try {
2002		
2003		if ( ! supportIE11 && Earth.isIE11() ) return false;
2004		
2005		var canvas = document.createElement( 'canvas' );
2006		return window.WebGLRenderingContext && ( canvas.getContext( 'webgl' ) || canvas.getContext( 'experimental-webgl' ) );
2007
2008	} catch ( e ) {
2009		
2010		return false;
2011
2012	}
2013	
2014};
2015
2016
2017// private
2018// check for IE11
2019
2020Earth.isIE11 = function( ) {
2021	return !! window.MSInputMethodContext && !! document.documentMode;	
2022};
2023
2024
2025// private
2026// get points of a 3d line
2027
2028Earth.getPathPoints = function( fromPos, toPos, subdevisions, offset, offsetFlow, offsetEasing ) {
2029	
2030	offset += Earth.earthRadius;	
2031	
2032	var points = [ fromPos, toPos ];
2033	
2034	for (var i=0; i < subdevisions; i++) {
2035		points = Earth.subdividePath( points, offset );
2036	}
2037	
2038	
2039	if ( offsetFlow ) {
2040		for (var i=0; i < points.length; i++) {
2041			points[i].multiplyScalar( 1 + Earth.Animation.Easing[ offsetEasing ]( i / (points.length-1) ) * offsetFlow/10 );
2042		}
2043	}
2044	
2045	return points;
2046	
2047};
2048
2049
2050// private
2051// subdivide a 3d line to smooth it
2052
2053Earth.subdividePath = function( points, offset ) {
2054
2055	if ( points.length < 2 ) return [];
2056
2057	var new_points = [];
2058	
2059	new_points.push( points[0] );
2060	
2061	// from point
2062	var fromPoint = points[0];
2063	
2064	for (var i=1; i < points.length; i++) {
2065		
2066		// to point
2067		toPoint = points[i];
2068		
2069		// mid point
2070		new_points.push(
2071			new THREE.Vector3().lerpVectors( fromPoint, toPoint, 0.5 ).normalize().multiplyScalar( offset )
2072		);
2073		
2074		new_points.push( toPoint );
2075		
2076		fromPoint = toPoint;
2077		
2078	}
2079	
2080	return new_points;
2081	
2082};
2083
2084
2085// private
2086// normalized mouse position relative to element center
2087
2088Earth.mouseCenterOffset = function( mouse, earth, radius ) {
2089	var relMouse = new THREE.Vector2( mouse.x - earth.bounds.left - earth.bounds.width/2 , mouse.y - earth.bounds.top - earth.bounds.height/2 );
2090	return Math.min( 1, relMouse.length() / radius );
2091};
2092
2093
2094// private
2095// raycasting helpers
2096
2097Earth.normalizeMouse = function( earth, x, y ) {
2098	return  new THREE.Vector2( ( x - earth.bounds.left ) / earth.bounds.width, ( y - earth.bounds.top ) / earth.bounds.height );
2099};
2100Earth.normalizeElement = function( v2, element ) {
2101	return new THREE.Vector2( v2.x / element.x, v2.y / element.y );
2102};
2103Earth.normalizeRaycast = function( v2 ) {
2104	return new THREE.Vector2( ( v2.x * 2 ) - 1, - ( v2.y * 2 ) + 1 );
2105};
2106
2107
2108// private
2109// position conversion
2110
2111Earth.latLngToWorld = function( location, radius ){
2112	
2113	var phi   = THREE.Math.degToRad( -location.lat + 90 );
2114	var theta = THREE.Math.degToRad( location.lng + 180 );
2115   
2116   return new THREE.Vector3().setFromSphericalCoords( radius, phi, theta );
2117   
2118};
2119Earth.worldToLatLng = function( pos ) {
2120	
2121	var s = new THREE.Spherical().setFromVector3 ( pos );
2122	   
2123	var loc = {
2124		lat: THREE.Math.radToDeg( -s.phi ) + 90,
2125		lng: THREE.Math.radToDeg( s.theta ) + 180
2126	};
2127	
2128	Earth.wrapLatLng( loc );
2129   
2130	return loc;
2131   
2132};
2133
2134
2135// private
2136// UV <-> LatLng
2137
2138Earth.uvToLatLng = function( uv ) {
2139	
2140	return {
2141		lat: (0.5 - uv.y) * 180,
2142		lng: (uv.x - 0.5) * 360
2143	};
2144	
2145};
2146Earth.latLngToUv = function( latlng ) {
2147	
2148	latlng = Earth.wrapLatLng(  Earth.formatLatLng( latlng ) );
2149	
2150	return new THREE.Vector2(
2151		1 - (latlng.lng / -360 + 0.5),
2152		0.5 + latlng.lat / -180
2153	);
2154	
2155};
2156
2157
2158// private
2159// position helpers
2160
2161Earth.wrapLatLng = function( latlng ) {
2162
2163	latlng.lat = Earth.wrap( latlng.lat, -90, 90 );
2164	latlng.lng = Earth.wrap( latlng.lng, -180, 180 );
2165	
2166	return latlng;
2167	
2168};
2169Earth.wrapLngForLerp = function( fromLng, toLng ) {
2170	
2171	if ( Math.abs( toLng - fromLng ) > 180 ) {
2172		toLng = ( toLng < 0 ) ? toLng + 360 : toLng - 360;
2173	}
2174	
2175	return toLng;
2176	
2177};
2178Earth.worldToElement = function( position, element, camera ) {
2179	
2180	var w = element.x / 2;
2181	var h = element.y / 2;
2182
2183	var pos = position.clone().project( camera );
2184	
2185	return new THREE.Vector2(
2186		( pos.x * w ) + w,
2187		- ( pos.y * h ) + h
2188	);
2189	
2190};
2191
2192
2193// private
2194// distance in world units for dashed lines
2195
2196Earth.getLineDistance = function( points ) {
2197	
2198	var distance = 0;
2199	var from = points[0];
2200	
2201	for ( var i = 1; i < points.length; i++ ) {
2202		var to = points[i];
2203		distance += from.distanceTo( to );
2204		from = to;
2205	} 
2206	
2207	return distance;
2208	
2209};
2210
2211
2212// private
2213// lerp angle for animation
2214
2215Earth.lerpAngle = function( fromA, toA, t ) {
2216    var fullA = Math.PI * 2;
2217    var a = (toA - fromA) % fullA;
2218    return fromA + ( 2 * a % fullA - a ) * t;
2219};
2220
2221
2222// private
2223// wrap number
2224
2225Earth.wrap = function( val, min, max ) {
2226	var range = max - min;
2227	return min + ( ( ( (val - min) % range ) + range ) % range );
2228};
2229
2230
2231// PUBLIC
2232// get distance in km
2233
2234Earth.getDistance = function( from, to ) {
2235	
2236	from =  Earth.formatLatLng( from );
2237	to =  Earth.formatLatLng( to );
2238	
2239	var degLat = THREE.Math.degToRad( to.lat - from.lat );
2240	var degLng = THREE.Math.degToRad( to.lng - from.lng );
2241	
2242	var a = Math.sin(degLat / 2) * Math.sin(degLat / 2) +
2243	Math.cos( THREE.Math.degToRad( from.lat ) ) * Math.cos( THREE.Math.degToRad( to.lat ) ) *
2244	Math.sin( degLng / 2 ) * Math.sin( degLng / 2 );
2245	
2246	var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
2247	
2248	return  6378.137 * c; // mean radius in km
2249	
2250};
2251
2252
2253// PUBLIC
2254// get angle between two latlng positions
2255
2256Earth.getAngle = function( from, to ) {
2257	
2258	from =  Earth.formatLatLng( from );
2259	to =  Earth.formatLatLng( to );
2260	
2261	var fromPos = Earth.latLngToWorld( from, Earth.earthRadius );
2262	var toPos = Earth.latLngToWorld( to, Earth.earthRadius );
2263	
2264	return THREE.Math.radToDeg( fromPos.angleTo( toPos ) );
2265	
2266};
2267
2268
2269// PUBLIC		lerp latlng location
2270// from			latlng

2271// to			latlng
2272// t			time 0-1
2273// lerpLatLng	lerp latlng values or 3d position
2274
2275Earth.lerp = function( from, to, t, lerpLatLng ) {
2276	
2277	from =  Earth.formatLatLng( from );
2278	to =  Earth.formatLatLng( to );
2279
2280	if ( lerpLatLng ) {
2281		
2282		return Earth.wrapLatLng( {
2283			lat: THREE.Math.lerp( from.lat, to.lat, t ),
2284			lng: THREE.Math.lerp( from.lng, Earth.wrapLngForLerp( from.lng, to.lng ), t )
2285		} );
2286		
2287	} else {
2288
2289		return Earth.worldToLatLng(
2290			Earth.latLngToWorld( from, Earth.earthRadius ).lerp( Earth.latLngToWorld( to, Earth.earthRadius ), t )
2291		);
2292	
2293	}
2294	
2295};
2296
2297
2298// private
2299// any event in types array registered?
2300
2301Earth.hasEvent = function( obj, types ) {
2302	
2303	if ( ! obj._listeners ) return false;
2304	
2305	for ( var i=0; i < types.length; i++ ) {
2306		if ( obj._listeners[ types[i] ] && obj._listeners[ types[i] ].length ) return true;
2307	}
2308	
2309	return false;
2310	
2311};
2312
2313
2314// private
2315// get mouse or touch client position
2316
2317Earth.getEventPosition = function( event ) {
2318	
2319	if ( event.type == 'touchstart' || event.type == 'touchmove' ) {
2320		return new THREE.Vector2( event.touches[0].clientX, event.touches[0].clientY );
2321	
2322	} else if ( event.type == 'touchend' ) {
2323		return new THREE.Vector2( event.changedTouches[0].clientX, event.changedTouches[0].clientY );
2324		
2325	} else {
2326		return new THREE.Vector2(  event.clientX, event.clientY );
2327		
2328	}
2329	
2330};
2331
2332
2333
2334/* MARKER */
2335
2336Earth.Marker = function( initOptions, thisEarth ) {
2337
2338	this.init( initOptions, thisEarth );
2339
2340};
2341
2342
2343// private
2344
2345Earth.Marker.prototype.init = function( initOptions, thisEarth ) {
2346	
2347	// default options
2348	
2349	var defaults = {
2350		
2351		isMarker : true,
2352		earth : thisEarth,
2353		
2354		location : { lat : 0, lng : 0 },
2355
2356		offset: 0,
2357		
2358		mesh: ["Pin", "Needle"],
2359		color: '#FF0000',
2360		color2: '#AAAAAA',
2361		color3: '#AAAAAA',
2362		color4: '#AAAAAA',
2363		color5: '#AAAAAA',
2364		color6: '#AAAAAA',
2365		color7: '#AAAAAA',
2366		color8: '#AAAAAA',
2367		
2368		scale : 1,
2369		scaleX : 1,
2370		scaleY : 1,
2371		scaleZ : 1,
2372		visible : true,
2373		
2374		hotspot : false,
2375		hotspotRadius : 0.5,
2376		hotspotHeight : 1.5,
2377
2378		align : true,
2379		rotationX : 0,
2380		rotationY : 0,
2381		rotationZ : 0,		
2382		lookAt : false,
2383		lookAngle: 0, // private
2384		
2385		shininess: 0.3,
2386		flatShading: false,
2387		castShadow: thisEarth.shadows,
2388		receiveShadow : false,
2389		transparent : ( typeof initOptions.opacity != 'undefined' ),
2390		
2391	};
2392	
2393	this.options = Object.assign(defaults, initOptions);
2394	
2395	
2396	this.createObject();
2397	
2398	this.addMeshes();
2399	
2400	
2401	// set props
2402	Object.assign( this, this.options );
2403
2404	this.ready = true;
2405	this.update();
2406	this.updateScale();
2407
2408	thisEarth.occludables.push( this );
2409	
2410	if ( this.options.transparent ) {
2411		this.addEventListener( 'occlusion', function() {
2412			for ( var i=0; i < this.object3d.children.length; i++ ) {
2413				this.object3d.children[i].renderOrder = ( this.occluded ) ? -4 : 0;
2414			}
2415		} );	
2416	}
2417	
2418	return this;
2419	
2420};
2421
2422
2423// private
2424// add container object and hotspot
2425
2426Earth.Marker.prototype.createObject = function() {
2427	
2428	if ( this.options.hotspot ) {
2429	
2430		if ( this.options.hotspotGeometry == 'sprite' ) { // sprite
2431			this.object3d = new THREE.Sprite( new THREE.SpriteMaterial( {
2432				map : (this.options.earth.showHotspots) ? Earth.getTexture( Earth.spriteHotspot, 64, false ) : null,
2433				opacity : (this.options.earth.showHotspots) ? 1 : 0,
2434			} ) );			
2435
2436		} else if ( this.options.hotspotGeometry == 'circle' ) { // circle
2437			var geometry = new THREE.CircleGeometry( this.options.hotspotRadius * 1.2, 8 );
2438			geometry.rotateX( THREE.Math.degToRad(-90) );
2439			geometry.translate( 0, 0.01, 0 );
2440
2441			this.object3d = new THREE.Mesh( geometry, (this.options.earth.showHotspots) ? Earth.hotspotMaterial : Earth.invisibleMaterial );
2442
2443		} else { // cylinder
2444			var geometry = new THREE.CylinderBufferGeometry( this.options.hotspotRadius, this.options.hotspotRadius*0.75, this.options.hotspotHeight, 5 );
2445			geometry.translate( 0, this.options.hotspotHeight/2, 0 );
2446			
2447			this.object3d = new THREE.Mesh( geometry, (this.options.earth.showHotspots) ? Earth.hotspotMaterial : Earth.invisibleMaterial );
2448			
2449		}
2450		
2451	
2452	} else {
2453
2454		this.object3d = new THREE.Object3D();
2455		
2456	}
2457	
2458	this.object3d.userData.marker = this;	
2459	this.options.earth.scene.add( this.object3d );
2460	
2461};
2462
2463
2464// private
2465// add geometry
2466
2467Earth.Marker.prototype.addMeshes = function() {
2468	
2469	if ( typeof this.options.mesh == "string" ) {
2470		var meshes = ( this.options.mesh ) ? [ this.options.mesh ] : [];
2471	} else {
2472		var meshes = this.options.mesh;
2473	}
2474	
2475	for ( var i = 0; i < meshes.length; i++ ) {
2476		
2477		var meshClone = Earth.meshes[ meshes[i] ].clone();
2478		meshClone.material = meshClone.material.clone();
2479		this.object3d.add( meshClone );
2480		
2481	}
2482	
2483};
2484
2485
2486Object.assign( Earth.Marker.prototype, Earth.ClassicEventDispatcher.prototype );
2487
2488
2489// PUBLIC
2490// properties
2491
2492Earth.sharedObjectProperties = {
2493	
2494	color: {
2495		get: function() {
2496			if ( ! this.object3d.children[0] ) return '#FFFFFF';
2497			return '#' + this.object3d.children[0].material.color.getHexString();
2498		},
2499		set: function( v ) {
2500			if ( ! this.object3d.children[0] ) return;
2501			this.object3d.children[0].material.color.set( v );
2502		}
2503	},
2504	
2505	opacity : {
2506		get: function() {
2507			if ( ! this.object3d.children[0] ) return 1;
2508			return this.object3d.children[0].material.opacity;
2509		},
2510		set: function( v ) {
2511			for ( var i=0; i < this.object3d.children.length; i++ ) {
2512				this.object3d.children[i].material.opacity = v;
2513			}
2514		}
2515	},
2516
2517	visible : {
2518		get: function() {
2519			return this.object3d.visible;
2520		},
2521		set: function( v ) {
2522			this.object3d.visible = v;
2523		}
2524	},
2525
2526	scale : {
2527		get: function() {
2528			return this.options.scale;
2529		},
2530		set: function( v ) {
2531			this.options.scale = v;
2532			if ( this.ready ) this.updateScale();
2533		}
2534	},
2535	scaleX : {
2536		get: function() {
2537			return this.options.scaleX;
2538		},
2539		set: function( v ) {
2540			this.options.scaleX = v;
2541			if ( this.ready ) this.updateScale();
2542		}
2543	},
2544	scaleY : {
2545		get: function() {
2546			return this.options.scaleY;
2547		},
2548		set: function( v ) {
2549			this.options.scaleY = v;
2550			if ( this.ready ) this.updateScale();
2551		}
2552	},
2553	scaleZ : {
2554		get: function() {
2555			return this.options.scaleZ;
2556		},
2557		set: function( v ) {
2558			this.options.scaleZ = v;
2559			if ( this.ready ) this.updateScale();
2560		}
2561	},
2562	
2563	align : {
2564		get: function() {
2565			return this.options.align;
2566		},
2567		set: function( v ) {
2568			this.options.align = v;
2569			if ( this.ready ) this.update();
2570		}
2571	},	
2572	rotationX : {
2573		get: function() {
2574			return this.options.rotationX;
2575		},
2576		set: function( v ) {
2577			this.options.rotationX = v;
2578			if ( this.ready ) this.update();
2579		}
2580	},
2581	rotationY : {
2582		get: function() {
2583			return this.options.rotationY;
2584		},
2585		set: function( v ) {
2586			this.options.rotationY = v;
2587			if ( this.ready ) this.update();
2588		}
2589	},
2590	rotationZ : {
2591		get: function() {
2592			return this.options.rotationZ;
2593		},
2594		set: function( v ) {
2595			this.options.rotationZ = v;
2596			if ( this.ready ) this.update();
2597		}
2598	},
2599	lookAt : {
2600		get: function() {
2601			return this.options.lookAt;
2602		},
2603		set: function( v ) {
2604			this.options.lookAt = (! v) ? false : Earth.formatLatLng(v);
2605			if ( this.ready ) this.update();
2606		}
2607	},
2608	lookAngle : {
2609		get: function() {
2610			return this.options.lookAngle;
2611		},
2612		set: function( v ) {
2613			this.options.lookAngle = v;
2614			if ( this.ready ) this.update( true );
2615		}
2616	},
2617	
2618	offset : {
2619		get: function() {
2620			return this.options.offset;
2621		},
2622		set: function( v ) {
2623			this.options.offset = v;
2624			if ( this.ready ) this.update();
2625		}
2626	},
2627	
2628	location : {
2629		get: function() {
2630			return this.options.location;
2631		},
2632		set: function( v ) {
2633			this.options.location = Earth.formatLatLng(v);
2634			if ( this.ready ) this.update();
2635		}
2636	}
2637	
2638};
2639
2640Object.defineProperties( Earth.Marker.prototype, Earth.sharedObjectProperties );
2641
2642Object.defineProperties( Earth.Marker.prototype, {
2643	
2644	color2: {
2645		get: function() {
2646			if ( ! this.object3d.children[1] ) return '#FFFFFF';
2647			return '#' + this.object3d.children[1].material.color.getHexString();
2648		},
2649		set: function( v ) {
2650			if ( ! this.object3d.children[1] ) return;
2651			this.object3d.children[1].material.color.set( v );
2652		}
2653	},
2654	color3: {
2655		get: function() {
2656			if ( ! this.object3d.children[2] ) return '#FFFFFF';
2657			return '#' + this.object3d.children[2].material.color.getHexString();
2658		},
2659		set: function( v ) {
2660			if ( ! this.object3d.children[2] ) return;
2661			this.object3d.children[2].material.color.set( v );
2662		}
2663	},
2664	color4: {
2665		get: function() {
2666			if ( ! this.object3d.children[3] ) return '#FFFFFF';
2667			return '#' + this.object3d.children[3].material.color.getHexString();
2668		},
2669		set: function( v ) {
2670			if ( ! this.object3d.children[3] ) return;
2671			this.object3d.children[3].material.color.set( v );
2672		}
2673	},
2674	color5: {
2675		get: function() {
2676			if ( ! this.object3d.children[4] ) return '#FFFFFF';
2677			return '#' + this.object3d.children[4].material.color.getHexString();
2678		},
2679		set: function( v ) {
2680			if ( ! this.object3d.children[4] ) return;
2681			this.object3d.children[4].material.color.set( v );
2682		}
2683	},
2684	color6: {
2685		get: function() {
2686			if ( ! this.object3d.children[5] ) return '#FFFFFF';
2687			return '#' + this.object3d.children[5].material.color.getHexString();
2688		},
2689		set: function( v ) {
2690			if ( ! this.object3d.children[5] ) return;
2691			this.object3d.children[5].material.color.set( v );
2692		}
2693	},
2694	color7: {
2695		get: function() {