text: var THREE = require("../three.js");
  var utils = require("../utils/utils.js");
  var Objects = require('./objects.js');
  
  function line(obj){
  
  	obj = utils._validate(obj, Objects.prototype._defaults.line);
  
  	// Geometry
      var straightProject = utils.lnglatsToWorld(obj.geometry);
  	var normalized = utils.normalizeVertices(straightProject);
      var flattenedArray = utils.flattenVectors(normalized.vertices);
  	console.log('line', normalized.vertices)
  
  	var geometry = new THREE.LineGeometry();
  	geometry.setPositions( flattenedArray );
  	// geometry.setColors( colors );
  
  	// Material
  	matLine = new THREE.LineMaterial( {
  		color: obj.color,
  		linewidth: obj.width, // in pixels
  		dashed: false,
  		opacity: obj.opacity
  	} );
  	
  	matLine.resolution.set( window.innerWidth, window.innerHeight );
  	matLine.isMaterial = true;
  	matLine.transparent = true;
  	matLine.depthWrite = false;
  
  	// Mesh
  	line = new THREE.Line2( geometry, matLine );
  	line.position.copy(normalized.position)
  	line.computeLineDistances();
  
  	return line
  }
  
  module.exports = exports = line;
  
  
  
  /**
   * custom line shader by WestLangley, sourced from https://github.com/mrdoob/three.js/tree/master/examples/js/lines
   *
   */
  
  THREE.LineSegmentsGeometry = function () {
  
  	THREE.InstancedBufferGeometry.call( this );
  
  	this.type = 'LineSegmentsGeometry';
  
  	var plane = new THREE.BufferGeometry();
  
  	var positions = [ - 1, 2, 0, 1, 2, 0, - 1, 1, 0, 1, 1, 0, - 1, 0, 0, 1, 0, 0, - 1, - 1, 0, 1, - 1, 0 ];
  	var uvs = [ 0, 1, 1, 1, 0, .5, 1, .5, 0, .5, 1, .5, 0, 0, 1, 0 ];
  	var index = [ 0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5 ];
  
  	this.setIndex( index );
  	this.addAttribute( 'position', new THREE.Float32BufferAttribute( positions, 3 ) );
  	this.addAttribute( 'uv', new THREE.Float32BufferAttribute( uvs, 2 ) );
  
  };
  
  THREE.LineSegmentsGeometry.prototype = Object.assign( Object.create( THREE.InstancedBufferGeometry.prototype ), {
  
  	constructor: THREE.LineSegmentsGeometry,
  
  	isLineSegmentsGeometry: true,
  
  	applyMatrix: function ( matrix ) {
  
  		var start = this.attributes.instanceStart;
  		var end = this.attributes.instanceEnd;
  
  		if ( start !== undefined ) {
  
  			matrix.applyToBufferAttribute( start );
  
  			matrix.applyToBufferAttribute( end );
  
  			start.data.needsUpdate = true;
  
  		}
  
  		if ( this.boundingBox !== null ) {
  
  			this.computeBoundingBox();
  
  		}
  
  		if ( this.boundingSphere !== null ) {
  
  			this.computeBoundingSphere();
  
  		}
  
  		return this;
  
  	},
  
  	setPositions: function ( array ) {
  
  		var lineSegments;
  
  		if ( array instanceof Float32Array ) {
  
  			lineSegments = array;
  
  		} else if ( Array.isArray( array ) ) {
  
  			lineSegments = new Float32Array( array );
  
  		}
  
  		var instanceBuffer = new THREE.InstancedInterleavedBuffer( lineSegments, 6, 1 ); // xyz, xyz
  
  		this.addAttribute( 'instanceStart', new THREE.InterleavedBufferAttribute( instanceBuffer, 3, 0 ) ); // xyz
  		this.addAttribute( 'instanceEnd', new THREE.InterleavedBufferAttribute( instanceBuffer, 3, 3 ) ); // xyz
  
  		//
  
  		this.computeBoundingBox();
  		this.computeBoundingSphere();
  
  		return this;
  
  	},
  
  	setColors: function ( array ) {
  
  		var colors;
  
  		if ( array instanceof Float32Array ) {
  
  			colors = array;
  
  		} else if ( Array.isArray( array ) ) {
  
  			colors = new Float32Array( array );
  
  		}
  
  		var instanceColorBuffer = new THREE.InstancedInterleavedBuffer( colors, 6, 1 ); // rgb, rgb
  
  		this.addAttribute( 'instanceColorStart', new THREE.InterleavedBufferAttribute( instanceColorBuffer, 3, 0 ) ); // rgb
  		this.addAttribute( 'instanceColorEnd', new THREE.InterleavedBufferAttribute( instanceColorBuffer, 3, 3 ) ); // rgb
  
  		return this;
  
  	},
  
  	fromWireframeGeometry: function ( geometry ) {
  
  		this.setPositions( geometry.attributes.position.array );
  
  		return this;
  
  	},
  
  	fromEdgesGeometry: function ( geometry ) {
  
  		this.setPositions( geometry.attributes.position.array );
  
  		return this;
  
  	},
  
  	fromMesh: function ( mesh ) {
  
  		this.fromWireframeGeometry( new THREE.WireframeGeometry( mesh.geometry ) );
  
  		// set colors, maybe
  
  		return this;
  
  	},
  
  	fromLineSegements: function ( lineSegments ) {
  
  		var geometry = lineSegments.geometry;
  
  		if ( geometry.isGeometry ) {
  
  			this.setPositions( geometry.vertices );
  
  		} else if ( geometry.isBufferGeometry ) {
  
  			this.setPositions( geometry.position.array ); // assumes non-indexed
  
  		}
  
  		// set colors, maybe
  
  		return this;
  
  	},
  
  	computeBoundingBox: function () {
  
  		var box = new THREE.Box3();
  
  		return function computeBoundingBox() {
  
  			if ( this.boundingBox === null ) {
  
  				this.boundingBox = new THREE.Box3();
  
  			}
  
  			var start = this.attributes.instanceStart;
  			var end = this.attributes.instanceEnd;
  
  			if ( start !== undefined && end !== undefined ) {
  
  				this.boundingBox.setFromBufferAttribute( start );
  
  				box.setFromBufferAttribute( end );
  
  				this.boundingBox.union( box );
  
  			}
  
  		};
  
  	}(),
  
  	computeBoundingSphere: function () {
  
  		var vector = new THREE.Vector3();
  
  		return function computeBoundingSphere() {
  
  			if ( this.boundingSphere === null ) {
  
  				this.boundingSphere = new THREE.Sphere();
  
  			}
  
  			if ( this.boundingBox === null ) {
  
  				this.computeBoundingBox();
  
  			}
  
  			var start = this.attributes.instanceStart;
  			var end = this.attributes.instanceEnd;
  
  			if ( start !== undefined && end !== undefined ) {
  
  				var center = this.boundingSphere.center;
  
  				this.boundingBox.getCenter( center );
  
  				var maxRadiusSq = 0;
  
  				for ( var i = 0, il = start.count; i < il; i ++ ) {
  
  					vector.fromBufferAttribute( start, i );
  					maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) );
  
  					vector.fromBufferAttribute( end, i );
  					maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) );
  
  				}
  
  				this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
  
  				if ( isNaN( this.boundingSphere.radius ) ) {
  
  					console.error( 'THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.', this );
  
  				}
  
  			}
  
  		};
  
  	}(),
  
  	toJSON: function () {
  
  		// todo
  
  	},
  
  	clone: function () {
  
  		// todo
  
  	},
  
  	copy: function ( source ) {
  
  		// todo
  
  		return this;
  
  	}
  
  } );
  
  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   */
  
  THREE.LineGeometry = function () {
  
  	THREE.LineSegmentsGeometry.call( this );
  
  	this.type = 'LineGeometry';
  
  };
  
  THREE.LineGeometry.prototype = Object.assign( Object.create( THREE.LineSegmentsGeometry.prototype ), {
  
  	constructor: THREE.LineGeometry,
  
  	isLineGeometry: true,
  
  	setPositions: function ( array ) {
  
  		// converts [ x1, y1, z1,  x2, y2, z2, ... ] to pairs format
  
  		var length = array.length - 3;
  		var points = new Float32Array( 2 * length );
  
  		for ( var i = 0; i < length; i += 3 ) {
  
  			points[ 2 * i ] = array[ i ];
  			points[ 2 * i + 1 ] = array[ i + 1 ];
  			points[ 2 * i + 2 ] = array[ i + 2 ];
  
  			points[ 2 * i + 3 ] = array[ i + 3 ];
  			points[ 2 * i + 4 ] = array[ i + 4 ];
  			points[ 2 * i + 5 ] = array[ i + 5 ];
  
  		}
  
  		THREE.LineSegmentsGeometry.prototype.setPositions.call( this, points );
  
  		return this;
  
  	},
  
  	setColors: function ( array ) {
  
  		// converts [ r1, g1, b1,  r2, g2, b2, ... ] to pairs format
  
  		var length = array.length - 3;
  		var colors = new Float32Array( 2 * length );
  
  		for ( var i = 0; i < length; i += 3 ) {
  
  			colors[ 2 * i ] = array[ i ];
  			colors[ 2 * i + 1 ] = array[ i + 1 ];
  			colors[ 2 * i + 2 ] = array[ i + 2 ];
  
  			colors[ 2 * i + 3 ] = array[ i + 3 ];
  			colors[ 2 * i + 4 ] = array[ i + 4 ];
  			colors[ 2 * i + 5 ] = array[ i + 5 ];
  
  		}
  
  		THREE.LineSegmentsGeometry.prototype.setColors.call( this, colors );
  
  		return this;
  
  	},
  
  	fromLine: function ( line ) {
  
  		var geometry = line.geometry;
  
  		if ( geometry.isGeometry ) {
  
  			this.setPositions( geometry.vertices );
  
  		} else if ( geometry.isBufferGeometry ) {
  
  			this.setPositions( geometry.position.array ); // assumes non-indexed
  
  		}
  
  		// set colors, maybe
  
  		return this;
  
  	},
  
  	copy: function ( source ) {
  
  		// todo
  
  		return this;
  
  	}
  
  } );
  
  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   */
  
  THREE.WireframeGeometry2 = function ( geometry ) {
  
  	THREE.LineSegmentsGeometry.call( this );
  
  	this.type = 'WireframeGeometry2';
  
  	this.fromWireframeGeometry( new THREE.WireframeGeometry( geometry ) );
  
  	// set colors, maybe
  
  };
  
  THREE.WireframeGeometry2.prototype = Object.assign( Object.create( THREE.LineSegmentsGeometry.prototype ), {
  
  	constructor: THREE.WireframeGeometry2,
  
  	isWireframeGeometry2: true,
  
  	copy: function ( source ) {
  
  		// todo
  
  		return this;
  
  	}
  
  } );
  
  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   * parameters = {
   *  color: <hex>,
   *  linewidth: <float>,
   *  dashed: <boolean>,
   *  dashScale: <float>,
   *  dashSize: <float>,
   *  gapSize: <float>,
   *  resolution: <Vector2>, // to be set by renderer
   * }
   */
  
  THREE.UniformsLib.line = {
  
  	linewidth: { value: 1 },
  	resolution: { value: new THREE.Vector2( 1, 1 ) },
  	dashScale: { value: 1 },
  	dashSize: { value: 1 },
  	gapSize: { value: 1 } // todo FIX - maybe change to totalSize
  
  };
  
  THREE.ShaderLib[ 'line' ] = {
  
  	uniforms: THREE.UniformsUtils.merge( [
  		THREE.UniformsLib.common,
  		THREE.UniformsLib.fog,
  		THREE.UniformsLib.line
  	] ),
  
  	vertexShader:
  		`
  		#include <common>
  		#include <color_pars_vertex>
  		#include <fog_pars_vertex>
  		#include <logdepthbuf_pars_vertex>
  		#include <clipping_planes_pars_vertex>
  
  		uniform float linewidth;
  		uniform vec2 resolution;
  
  		attribute vec3 instanceStart;
  		attribute vec3 instanceEnd;
  
  		attribute vec3 instanceColorStart;
  		attribute vec3 instanceColorEnd;
  
  		varying vec2 vUv;
  
  		#ifdef USE_DASH
  
  			uniform float dashScale;
  			attribute float instanceDistanceStart;
  			attribute float instanceDistanceEnd;
  			varying float vLineDistance;
  
  		#endif
  
  		void trimSegment( const in vec4 start, inout vec4 end ) {
  
  			// trim end segment so it terminates between the camera plane and the near plane
  
  			// conservative estimate of the near plane
  			float a = projectionMatrix[ 2 ][ 2 ]; // 3nd entry in 3th column
  			float b = projectionMatrix[ 3 ][ 2 ]; // 3nd entry in 4th column
  			float nearEstimate = - 0.5 * b / a;
  
  			float alpha = ( nearEstimate - start.z ) / ( end.z - start.z );
  
  			end.xyz = mix( start.xyz, end.xyz, alpha );
  
  		}
  
  		void main() {
  
  			#ifdef USE_COLOR
  
  				vColor.xyz = ( position.y < 0.5 ) ? instanceColorStart : instanceColorEnd;
  
  			#endif
  
  			#ifdef USE_DASH
  
  				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
  
  			#endif
  
  			float aspect = resolution.x / resolution.y;
  
  			vUv = uv;
  
  			// camera space
  			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
  			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
  
  			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
  			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
  			// but we need to perform ndc-space calculations in the shader, so we must address this issue directly
  			// perhaps there is a more elegant solution -- WestLangley
  
  			bool perspective = ( projectionMatrix[ 2 ][ 3 ] == - 1.0 ); // 4th entry in the 3rd column
  
  			if ( perspective ) {
  
  				if ( start.z < 0.0 && end.z >= 0.0 ) {
  
  					trimSegment( start, end );
  
  				} else if ( end.z < 0.0 && start.z >= 0.0 ) {
  
  					trimSegment( end, start );
  
  				}
  
  			}
  
  			// clip space
  			vec4 clipStart = projectionMatrix * start;
  			vec4 clipEnd = projectionMatrix * end;
  
  			// ndc space
  			vec2 ndcStart = clipStart.xy / clipStart.w;
  			vec2 ndcEnd = clipEnd.xy / clipEnd.w;
  
  			// direction
  			vec2 dir = ndcEnd - ndcStart;
  
  			// account for clip-space aspect ratio
  			dir.x *= aspect;
  			dir = normalize( dir );
  
  			// perpendicular to dir
  			vec2 offset = vec2( dir.y, - dir.x );
  
  			// undo aspect ratio adjustment
  			dir.x /= aspect;
  			offset.x /= aspect;
  
  			// sign flip
  			if ( position.x < 0.0 ) offset *= - 1.0;
  
  			// endcaps
  			if ( position.y < 0.0 ) {
  
  				offset += - dir;
  
  			} else if ( position.y > 1.0 ) {
  
  				offset += dir;
  
  			}
  
  			// adjust for linewidth
  			offset *= linewidth;
  
  			// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
  			offset /= resolution.y;
  
  			// select end
  			vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
  
  			// back to clip space
  			offset *= clip.w;
  
  			clip.xy += offset;
  
  			gl_Position = clip;
  
  			#include <logdepthbuf_vertex>
  
  			#include <worldpos_vertex>
  			#include <clipping_planes_vertex>
  			#include <fog_vertex>
  
  		}
  		`,
  
  	fragmentShader:
  		`
  		uniform vec3 diffuse;
  		uniform float opacity;
  
  		#ifdef USE_DASH
  
  			uniform float dashSize;
  			uniform float gapSize;
  
  		#endif
  
  		varying float vLineDistance;
  
  		#include <common>
  		#include <color_pars_fragment>
  		#include <fog_pars_fragment>
  		#include <logdepthbuf_pars_fragment>
  		#include <clipping_planes_pars_fragment>
  
  		varying vec2 vUv;
  
  		void main() {
  
  			#include <clipping_planes_fragment>
  
  			#ifdef USE_DASH
  
  				if ( vUv.y < 0.5 || vUv.y > 0.5 ) discard; // discard endcaps
  
  				if ( mod( vLineDistance, dashSize + gapSize ) > dashSize ) discard; // todo - FIX
  
  			#endif
  
  			if ( vUv.y < 0.5 || vUv.y > 0.5 ) {
  
  				float a = vUv.x - 0.5;
  				float b = vUv.y - 0.5;
  				float len2 = a * a + b * b;
  
  				if ( len2 > 0.25 ) discard;
  
  			}
  
  			vec4 diffuseColor = vec4( diffuse, opacity );
  
  			#include <logdepthbuf_fragment>
  			#include <color_fragment>
  
  			gl_FragColor = vec4( diffuseColor.rgb, opacity );
  
  			#include <premultiplied_alpha_fragment>
  			#include <tonemapping_fragment>
  			#include <encodings_fragment>
  			#include <fog_fragment>
  
  		}
  		`
  };
  
  THREE.LineMaterial = function ( parameters ) {
  
  	var lineUniforms = THREE.UniformsUtils.clone( THREE.ShaderLib[ 'line' ].uniforms );
  	lineUniforms.opacity.value = parameters.opacity;
  
  	THREE.ShaderMaterial.call( this, {
  
  		type: 'LineMaterial',
  
  		uniforms: lineUniforms,
  
  		vertexShader: THREE.ShaderLib[ 'line' ].vertexShader,
  		fragmentShader: THREE.ShaderLib[ 'line' ].fragmentShader
  
  	} );
  
  	this.dashed = false;
  
  	Object.defineProperties( this, {
  
  		color: {
  
  			enumerable: true,
  
  			get: function () {
  
  				return this.uniforms.diffuse.value;
  
  			},
  
  			set: function ( value ) {
  
  				this.uniforms.diffuse.value = value;
  
  			}
  
  		},
  
  		linewidth: {
  
  			enumerable: true,
  
  			get: function () {
  
  				return this.uniforms.linewidth.value;
  
  			},
  
  			set: function ( value ) {
  
  				this.uniforms.linewidth.value = value;
  
  			}
  
  		},
  
  		dashScale: {
  
  			enumerable: true,
  
  			get: function () {
  
  				return this.uniforms.dashScale.value;
  
  			},
  
  			set: function ( value ) {
  
  				this.uniforms.dashScale.value = value;
  
  			}
  
  		},
  
  		dashSize: {
  
  			enumerable: true,
  
  			get: function () {
  
  				return this.uniforms.dashSize.value;
  
  			},
  
  			set: function ( value ) {
  
  				this.uniforms.dashSize.value = value;
  
  			}
  
  		},
  
  		gapSize: {
  
  			enumerable: true,
  
  			get: function () {
  
  				return this.uniforms.gapSize.value;
  
  			},
  
  			set: function ( value ) {
  
  				this.uniforms.gapSize.value = value;
  
  			}
  
  		},
  
  		resolution: {
  
  			enumerable: true,
  
  			get: function () {
  
  				return this.uniforms.resolution.value;
  
  			},
  
  			set: function ( value ) {
  
  				this.uniforms.resolution.value.copy( value );
  
  			}
  
  		}
  
  	} );
  
  	this.setValues( parameters );
  
  };
  
  THREE.LineMaterial.prototype = Object.create( THREE.ShaderMaterial.prototype );
  THREE.LineMaterial.prototype.constructor = THREE.LineMaterial;
  
  THREE.LineMaterial.prototype.isLineMaterial = true;
  
  THREE.LineMaterial.prototype.copy = function ( source ) {
  
  	THREE.ShaderMaterial.prototype.copy.call( this, source );
  
  	this.color.copy( source.color );
  
  	this.linewidth = source.linewidth;
  
  	this.resolution = source.resolution;
  
  	// todo
  
  	return this;
  
  };
  
  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   */
  
  THREE.LineSegments2 = function ( geometry, material ) {
  
  	THREE.Mesh.call( this );
  
  	this.type = 'LineSegments2';
  
  	this.geometry = geometry !== undefined ? geometry : new THREE.LineSegmentsGeometry();
  	this.material = material !== undefined ? material : new THREE.LineMaterial( { color: Math.random() * 0xffffff } );
  
  };
  
  THREE.LineSegments2.prototype = Object.assign( Object.create( THREE.Mesh.prototype ), {
  
  	constructor: THREE.LineSegments2,
  
  	isLineSegments2: true,
  
  	computeLineDistances: ( function () { // for backwards-compatability, but could be a method of LineSegmentsGeometry...
  
  		var start = new THREE.Vector3();
  		var end = new THREE.Vector3();
  
  		return function computeLineDistances() {
  
  			var geometry = this.geometry;
  
  			var instanceStart = geometry.attributes.instanceStart;
  			var instanceEnd = geometry.attributes.instanceEnd;
  			var lineDistances = new Float32Array( 2 * instanceStart.data.count );
  
  			for ( var i = 0, j = 0, l = instanceStart.data.count; i < l; i ++, j += 2 ) {
  
  				start.fromBufferAttribute( instanceStart, i );
  				end.fromBufferAttribute( instanceEnd, i );
  
  				lineDistances[ j ] = ( j === 0 ) ? 0 : lineDistances[ j - 1 ];
  				lineDistances[ j + 1 ] = lineDistances[ j ] + start.distanceTo( end );
  
  			}
  
  			var instanceDistanceBuffer = new THREE.InstancedInterleavedBuffer( lineDistances, 2, 1 ); // d0, d1
  
  			geometry.addAttribute( 'instanceDistanceStart', new THREE.InterleavedBufferAttribute( instanceDistanceBuffer, 1, 0 ) ); // d0
  			geometry.addAttribute( 'instanceDistanceEnd', new THREE.InterleavedBufferAttribute( instanceDistanceBuffer, 1, 1 ) ); // d1
  
  			return this;
  
  		};
  
  	}() ),
  
  	copy: function ( source ) {
  
  		// todo
  
  		return this;
  
  	}
  
  } );
  
  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   */
  
  THREE.Line2 = function ( geometry, material ) {
  
  	THREE.LineSegments2.call( this );
  
  	this.type = 'Line2';
  
  	this.geometry = geometry !== undefined ? geometry : new THREE.LineGeometry();
  	this.material = material !== undefined ? material : new THREE.LineMaterial( { color: Math.random() * 0xffffff } );
  
  };
  
  THREE.Line2.prototype = Object.assign( Object.create( THREE.LineSegments2.prototype ), {
  
  	constructor: THREE.Line2,
  
  	isLine2: true,
  
  	copy: function ( source ) {
  
  		// todo
  
  		return this;
  
  	}
  
  } );
  
  /**
   * @author WestLangley / http://github.com/WestLangley
   *
   */
  
  THREE.Wireframe = function ( geometry, material ) {
  
  	THREE.Mesh.call( this );
  
  	this.type = 'Wireframe';
  
  	this.geometry = geometry !== undefined ? geometry : new THREE.LineSegmentsGeometry();
  	this.material = material !== undefined ? material : new THREE.LineMaterial( { color: Math.random() * 0xffffff } );
  
  };
  
  THREE.Wireframe.prototype = Object.assign( Object.create( THREE.Mesh.prototype ), {
  
  	constructor: THREE.Wireframe,
  
  	isWireframe: true,
  
  	computeLineDistances: ( function () { // for backwards-compatability, but could be a method of LineSegmentsGeometry...
  
  		var start = new THREE.Vector3();
  		var end = new THREE.Vector3();
  
  		return function computeLineDistances() {
  
  			var geometry = this.geometry;
  
  			var instanceStart = geometry.attributes.instanceStart;
  			var instanceEnd = geometry.attributes.instanceEnd;
  			var lineDistances = new Float32Array( 2 * instanceStart.data.count );
  
  			for ( var i = 0, j = 0, l = instanceStart.data.count; i < l; i ++, j += 2 ) {
  
  				start.fromBufferAttribute( instanceStart, i );
  				end.fromBufferAttribute( instanceEnd, i );
  
  				lineDistances[ j ] = ( j === 0 ) ? 0 : lineDistances[ j - 1 ];
  				lineDistances[ j + 1 ] = lineDistances[ j ] + start.distanceTo( end );
  
  			}
  
  			var instanceDistanceBuffer = new THREE.InstancedInterleavedBuffer( lineDistances, 2, 1 ); // d0, d1
  
  			geometry.addAttribute( 'instanceDistanceStart', new THREE.InterleavedBufferAttribute( instanceDistanceBuffer, 1, 0 ) ); // d0
  			geometry.addAttribute( 'instanceDistanceEnd', new THREE.InterleavedBufferAttribute( instanceDistanceBuffer, 1, 1 ) ); // d1
  
  			return this;
  
  		};
  
  	}() ),
  
  	copy: function ( source ) {
  
  		// todo
  
  		return this;
  
  	}
  
  } );
  