//This file is the first one when creating minified build

//and is used to set certain flags that are needed

//for the concatenated build.

var IS_CONCAT_BUILD = true;

/** @define {string} */

var BUILD_LMV_WORKER_URL = "lmvworker.js";

var LMV_WORKER_URL = BUILD_LMV_WORKER_URL;

var ENABLE_DEBUG = false;

var ENABLE_TRACE = false;

var ENABLE_INLINE_WORKER = true;

/**

* Create namespace

* @param {string} s - namespace (e.g. 'Autodesk.Viewing')

* @return {Object} namespace

*/

var AutodeskNamespace = function (s) {

var ns = typeof window !== "undefined" && window !== null ? window : self;

var parts = s.split('.');

for (var i = 0; i < parts.length; ++i) {

ns[parts[i]] = ns[parts[i]] || {};

ns = ns[parts[i]];

}

return ns;

};

// Define the most often used ones

AutodeskNamespace("Autodesk.Viewing.Private");

AutodeskNamespace("Autodesk.Viewing.Extensions");

AutodeskNamespace("Autodesk.Viewing.Shaders");

AutodeskNamespace('Autodesk.Viewing.UI');

AutodeskNamespace('Autodesk.LMVTK');

var _isIE11 = !!navigator.userAgent.match(/Trident\/7\./);

// fix IE events

if(typeof window !== "undefined" && _isIE11){

(function () {

function CustomEvent ( event, params ) {

params = params || { bubbles: false, cancelable: false, detail: undefined };

var evt = document.createEvent( 'CustomEvent' );

evt.initCustomEvent( event, params.bubbles, params.cancelable, params.detail );

return evt;

};

CustomEvent.prototype = window.CustomEvent.prototype;

window.CustomEvent = CustomEvent;

})();

}

// IE does not implement ArrayBuffer slice. Handy!

if (!ArrayBuffer.prototype.slice) {

ArrayBuffer.prototype.slice = function(start, end) {

// Normalize start/end values

if (!end || end > this.byteLength) {

end = this.byteLength;

}

else if (end < 0) {

end = this.byteLength + end;

if (end < 0) end = 0;

}

if (start < 0) {

start = this.byteLength + start;

if (start < 0) start = 0;

}

if (end <= start) {

return new ArrayBuffer();

}

// Bytewise copy- this will not be fast, but what choice do we have?

var len = end - start;

var view = new Uint8Array(this, start, len);

var out = new Uint8Array(len);

for (var i = 0; i < len; i++) {

out[i] = view[i];

}

return out.buffer;

}

}

//The BlobBuilder object

if (typeof window !== "undefined")

window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;

// Launch full screen on the given element with the available method

function launchFullscreen(element, options) {

if (element.requestFullscreen) {

element.requestFullscreen(options);

} else if (element.mozRequestFullScreen) {

element.mozRequestFullScreen(options);

} else if (element.webkitRequestFullscreen) {

element.webkitRequestFullscreen(options);

} else if (element.msRequestFullscreen) {

element.msRequestFullscreen(options);

}

}

// Exit full screen with the available method

function exitFullscreen() {

if (document.exitFullscreen) {

document.exitFullscreen();

} else if (document.mozCancelFullScreen) {

document.mozCancelFullScreen();

} else if (document.webkitExitFullscreen) {

document.webkitExitFullscreen();

} else if (document.msExitFullscreen) {

document.msExitFullscreen();

}

}

// Determines if the browser is in full screen

function inFullscreen(){

// Special case for Ms-Edge that has webkitIsFullScreen with correct value

// and fullscreenEnabled with wrong value (thanks MS)

if ("webkitIsFullScreen" in document) return document.webkitIsFullScreen;

return !!(document.mozFullScreenElement ||

document.msFullscreenElement ||

document.fullscreenEnabled || // Check last-ish because it is true in Ms-Edge

document.querySelector(".viewer-fill-browser")); // Fallback for iPad

}

function fullscreenElement() {

return document.fullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || document.msFullscreenElement;

}

function isFullscreenAvailable(element) {

return element.requestFullscreen || element.mozRequestFullScreen || element.webkitRequestFullscreen || element.msRequestFullscreen;

}

// Get the version of the android device through user agent.

// Return the version string of android device, e.g. 4.4, 5.0...

function getAndroidVersion(ua) {

var ua = ua || navigator.userAgent;

var match = ua.match(/Android\s([0-9\.]*)/);

return match ? match[1] : false;

};

// Determine if this is a touch or notouch device.

function isTouchDevice() {

/*

// Temporarily disable touch support through hammer on Android 5, to debug

// some specific gesture issue with Chromium WebView when loading viewer3D.js.

if (parseInt(getAndroidVersion()) == 5) {

return false;

}

*/

return ('ontouchstart' in window);

}

function isIOSDevice() {

return /ip(ad|hone|od)/.test(navigator.userAgent.toLowerCase());

}

function isAndroidDevice() {

return (navigator.userAgent.toLowerCase().indexOf('android') !== -1);

}

function isMobileDevice() {

return isIOSDevice() || isAndroidDevice();

}

function isSafari() {

var _ua = navigator.userAgent.toLowerCase();

return (_ua.indexOf("safari") !== -1) && (_ua.indexOf("chrome") === -1);

}

var rescueFromPolymer = (function() {

if (isSafari()) {

return function(object) {

if (!window.Polymer)

return object;

for (var p in object) {

if (p.indexOf("__impl") !== -1) {

return object[p];

}

}

return object;

};

} else {

return function(o) { return o; };

}

})();

/**

* Detects if WebGL is enabled.

*

* @return { number } -1 for not Supported,

* 0 for disabled

* 1 for enabled

*/

function detectWebGL()

{

// Check for the webgl rendering context

if ( !! window.WebGLRenderingContext) {

var canvas = document.createElement("canvas"),

names = ["webgl", "experimental-webgl", "moz-webgl", "webkit-3d"],

context = false;

for (var i = 0; i < 4; i++) {

try {

context = canvas.getContext(names[i]);

context = rescueFromPolymer(context);

if (context && typeof context.getParameter === "function") {

// WebGL is enabled.

//

return 1;

}

} catch (e) {}

}

// WebGL is supported, but disabled.

//

return 0;

}

// WebGL not supported.

//

return -1;

};

// Convert touchstart event to click to remove the delay between the touch and

// the click event which is sent after touchstart with about 300ms deley.

// Should be used in UI elements on touch devices.

function touchStartToClick(e) {

e.preventDefault(); // Stops the firing of delayed click event.

e.stopPropagation();

e.target.click(); // Maps to immediate click.

}

//Safari doesn't have the Performance object

//We only need the now() function, so that's easy to emulate.

(function() {

var global = typeof window !== "undefined" && window !== null ? window : self;

if (!global.performance)

global.performance = Date;

})();

/**

* @author mrdoob / http://mrdoob.com/

* @author *kile / http://kile.stravaganza.org/

* @author philogb / http://blog.thejit.org/

* @author mikael emtinger / http://gomo.se/

* @author egraether / http://egraether.com/

* @author WestLangley / http://github.com/WestLangley

*/

/* Pruned version of THREE.Vector3, for use in the LMV web worker */

LmvVector3 = function ( x, y, z ) {

this.x = x || 0;

this.y = y || 0;

this.z = z || 0;

};

LmvVector3.prototype = {

constructor: LmvVector3,

set: function ( x, y, z ) {

this.x = x;

this.y = y;

this.z = z;

return this;

},

setX: function ( x ) {

this.x = x;

return this;

},

setY: function ( y ) {

this.y = y;

return this;

},

setZ: function ( z ) {

this.z = z;

return this;

},

setComponent: function ( index, value ) {

switch ( index ) {

case 0: this.x = value; break;

case 1: this.y = value; break;

case 2: this.z = value; break;

default: throw new Error( 'index is out of range: ' + index );

}

},

getComponent: function ( index ) {

switch ( index ) {

case 0: return this.x;

case 1: return this.y;

case 2: return this.z;

default: throw new Error( 'index is out of range: ' + index );

}

},

clone: function () {

return new this.constructor( this.x, this.y, this.z );

},

copy: function ( v ) {

this.x = v.x;

this.y = v.y;

this.z = v.z;

return this;

},

add: function ( v, w ) {

if ( w !== undefined ) {

console.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );

return this.addVectors( v, w );

}

this.x += v.x;

this.y += v.y;

this.z += v.z;

return this;

},

addScalar: function ( s ) {

this.x += s;

this.y += s;

this.z += s;

return this;

},

addVectors: function ( a, b ) {

this.x = a.x + b.x;

this.y = a.y + b.y;

this.z = a.z + b.z;

return this;

},

addScaledVector: function ( v, s ) {

this.x += v.x * s;

this.y += v.y * s;

this.z += v.z * s;

return this;

},

sub: function ( v, w ) {

if ( w !== undefined ) {

console.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );

return this.subVectors( v, w );

}

this.x -= v.x;

this.y -= v.y;

this.z -= v.z;

return this;

},

subScalar: function ( s ) {

this.x -= s;

this.y -= s;

this.z -= s;

return this;

},

subVectors: function ( a, b ) {

this.x = a.x - b.x;

this.y = a.y - b.y;

this.z = a.z - b.z;

return this;

},

multiply: function ( v, w ) {

if ( w !== undefined ) {

console.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );

return this.multiplyVectors( v, w );

}

this.x *= v.x;

this.y *= v.y;

this.z *= v.z;

return this;

},

multiplyScalar: function ( scalar ) {

this.x *= scalar;

this.y *= scalar;

this.z *= scalar;

return this;

},

multiplyVectors: function ( a, b ) {

this.x = a.x * b.x;

this.y = a.y * b.y;

this.z = a.z * b.z;

return this;

},

applyMatrix3: function ( m ) {

var x = this.x;

var y = this.y;

var z = this.z;

var e = m.elements;

this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;

this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;

this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;

return this;

},

applyMatrix4: function ( m ) {

// input: THREE.Matrix4 affine matrix

var x = this.x, y = this.y, z = this.z;

var e = m.elements;

this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ];

this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ];

this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ];

return this;

},

applyProjection: function ( m ) {

// input: THREE.Matrix4 projection matrix

var x = this.x, y = this.y, z = this.z;

var e = m.elements;

var d = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] ); // perspective divide

this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * d;

this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * d;

this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * d;

return this;

},

applyQuaternion: function ( q ) {

var x = this.x;

var y = this.y;

var z = this.z;

var qx = q.x;

var qy = q.y;

var qz = q.z;

var qw = q.w;

// calculate quat * vector

var ix = qw * x + qy * z - qz * y;

var iy = qw * y + qz * x - qx * z;

var iz = qw * z + qx * y - qy * x;

var iw = - qx * x - qy * y - qz * z;

// calculate result * inverse quat

this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;

this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;

this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;

return this;

},

transformDirection: function ( m ) {

// input: THREE.Matrix4 affine matrix

// vector interpreted as a direction

var x = this.x, y = this.y, z = this.z;

var e = m.elements;

this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;

this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;

this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;

this.normalize();

return this;

},

divide: function ( v ) {

this.x /= v.x;

this.y /= v.y;

this.z /= v.z;

return this;

},

divideScalar: function ( scalar ) {

if ( scalar !== 0 ) {

var invScalar = 1 / scalar;

this.x *= invScalar;

this.y *= invScalar;

this.z *= invScalar;

} else {

this.x = 0;

this.y = 0;

this.z = 0;

}

return this;

},

min: function ( v ) {

if ( this.x > v.x ) {

this.x = v.x;

}

if ( this.y > v.y ) {

this.y = v.y;

}

if ( this.z > v.z ) {

this.z = v.z;

}

return this;

},

max: function ( v ) {

if ( this.x < v.x ) {

this.x = v.x;

}

if ( this.y < v.y ) {

this.y = v.y;

}

if ( this.z < v.z ) {

this.z = v.z;

}

return this;

},

clamp: function ( min, max ) {

// This function assumes min < max, if this assumption isn't true it will not operate correctly

if ( this.x < min.x ) {

this.x = min.x;

} else if ( this.x > max.x ) {

this.x = max.x;

}

if ( this.y < min.y ) {

this.y = min.y;

} else if ( this.y > max.y ) {

this.y = max.y;

}

if ( this.z < min.z ) {

this.z = min.z;

} else if ( this.z > max.z ) {

this.z = max.z;

}

return this;

},

clampScalar: function () {

var min, max;

return function clampScalar( minVal, maxVal ) {

if ( min === undefined ) {

min = new LmvVector3();

max = new LmvVector3();

}

min.set( minVal, minVal, minVal );

max.set( maxVal, maxVal, maxVal );

return this.clamp( min, max );

};

}(),

floor: function () {

this.x = Math.floor( this.x );

this.y = Math.floor( this.y );

this.z = Math.floor( this.z );

return this;

},

ceil: function () {

this.x = Math.ceil( this.x );

this.y = Math.ceil( this.y );

this.z = Math.ceil( this.z );

return this;

},

round: function () {

this.x = Math.round( this.x );

this.y = Math.round( this.y );

this.z = Math.round( this.z );

return this;

},

roundToZero: function () {

this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );

this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );

this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );

return this;

},

negate: function () {

this.x = - this.x;

this.y = - this.y;

this.z = - this.z;

return this;

},

dot: function ( v ) {

return this.x * v.x + this.y * v.y + this.z * v.z;

},

lengthSq: function () {

return this.x * this.x + this.y * this.y + this.z * this.z;

},

length: function () {

return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );

},

lengthManhattan: function () {

return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );

},

normalize: function () {

return this.divideScalar( this.length() );

},

setLength: function ( l ) {

var oldLength = this.length();

if ( oldLength !== 0 && l !== oldLength ) {

this.multiplyScalar( l / oldLength );

}

return this;

},

lerp: function ( v, alpha ) {

this.x += ( v.x - this.x ) * alpha;

this.y += ( v.y - this.y ) * alpha;

this.z += ( v.z - this.z ) * alpha;

return this;

},

lerpVectors: function ( v1, v2, alpha ) {

this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );

return this;

},

cross: function ( v, w ) {

if ( w !== undefined ) {

console.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );

return this.crossVectors( v, w );

}

var x = this.x, y = this.y, z = this.z;

this.x = y * v.z - z * v.y;

this.y = z * v.x - x * v.z;

this.z = x * v.y - y * v.x;

return this;

},

crossVectors: function ( a, b ) {

var ax = a.x, ay = a.y, az = a.z;

var bx = b.x, by = b.y, bz = b.z;

this.x = ay * bz - az * by;

this.y = az * bx - ax * bz;

this.z = ax * by - ay * bx;

return this;

},

projectOnVector: function () {

var v1, dot;

return function projectOnVector( vector ) {

if ( v1 === undefined ) v1 = new LmvVector3();

v1.copy( vector ).normalize();

dot = this.dot( v1 );

return this.copy( v1 ).multiplyScalar( dot );

};

}(),

projectOnPlane: function () {

var v1;

return function projectOnPlane( planeNormal ) {

if ( v1 === undefined ) v1 = new LmvVector3();

v1.copy( this ).projectOnVector( planeNormal );

return this.sub( v1 );

}

}(),

reflect: function () {

// reflect incident vector off plane orthogonal to normal

// normal is assumed to have unit length

var v1;

return function reflect( normal ) {

if ( v1 === undefined ) v1 = new LmvVector3();

return this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );

}

}(),

distanceTo: function ( v ) {

return Math.sqrt( this.distanceToSquared( v ) );

},

distanceToSquared: function ( v ) {

var dx = this.x - v.x;

var dy = this.y - v.y;

var dz = this.z - v.z;

return dx * dx + dy * dy + dz * dz;

},

setEulerFromRotationMatrix: function ( m, order ) {

console.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' );

},

setEulerFromQuaternion: function ( q, order ) {

console.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' );

},

getPositionFromMatrix: function ( m ) {

console.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' );

return this.setFromMatrixPosition( m );

},

getScaleFromMatrix: function ( m ) {

console.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' );

return this.setFromMatrixScale( m );

},

getColumnFromMatrix: function ( index, matrix ) {

console.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' );

return this.setFromMatrixColumn( index, matrix );

},

setFromMatrixPosition: function ( m ) {

this.x = m.elements[ 12 ];

this.y = m.elements[ 13 ];

this.z = m.elements[ 14 ];

return this;

},

setFromMatrixScale: function ( m ) {

var sx = this.set( m.elements[ 0 ], m.elements[ 1 ], m.elements[ 2 ] ).length();

var sy = this.set( m.elements[ 4 ], m.elements[ 5 ], m.elements[ 6 ] ).length();

var sz = this.set( m.elements[ 8 ], m.elements[ 9 ], m.elements[ 10 ] ).length();

this.x = sx;

this.y = sy;

this.z = sz;

return this;

},

setFromMatrixColumn: function ( index, matrix ) {

var offset = index * 4;

var me = matrix.elements;

this.x = me[ offset ];

this.y = me[ offset + 1 ];

this.z = me[ offset + 2 ];

return this;