elation-engine 0.9.113 → 0.9.115

package/scripts/external/three-old/CubemapToEquirectangular.js

@@ -0,0 +1,188 @@
+;(function() {
+
+	"use strict";
+
+	var root = this
+
+	var has_require = typeof require !== 'undefined'
+
+	var THREE = root.THREE || has_require && require('three')
+	if( !THREE )
+		throw new Error( 'CubemapToEquirectangular requires three.js' )
+
+  var vertexShader = [
+    "attribute vec3 position; ",
+    "attribute vec2 uv; ",
+
+    "uniform mat4 projectionMatrix; ",
+    "uniform mat4 modelViewMatrix; ",
+
+    "varying vec2 vUv; ",
+
+    "void main()  { ",
+
+    "	vUv = vec2( 1.- uv.x, uv.y ); ",
+    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 ); ",
+
+    "} ",
+    ].join('\n');
+  var fragmentShader = [
+    "precision mediump float; ",
+
+    "uniform samplerCube map; ",
+
+    "varying vec2 vUv; ",
+
+    "#define M_PI 3.1415926535897932384626433832795 ",
+
+    "void main()  { ",
+
+    "	vec2 uv = vUv; ",
+
+    "	float longitude = uv.x * 2. * M_PI - M_PI + M_PI / 2.; ",
+    "	float latitude = uv.y * M_PI; ",
+
+    "	vec3 dir = vec3( ",
+    "		- sin( longitude ) * sin( latitude ), ",
+    "		cos( latitude ), ",
+    "		- cos( longitude ) * sin( latitude ) ",
+    "	); ",
+    "	normalize( dir ); ",
+
+    "	gl_FragColor = vec4( textureCube( map, dir ).rgb, 1. ); ",
+
+    "} ",
+  ].join('\n');
+
+function CubemapToEquirectangular( renderer, provideCubeCamera ) {
+
+	this.width = 1;
+	this.height = 1;
+
+	this.renderer = renderer;
+
+	this.material = new THREE.RawShaderMaterial( {
+		uniforms: {
+			map: { type: 't', value: null }
+		},
+		vertexShader: vertexShader,
+		fragmentShader: fragmentShader,
+		side: THREE.DoubleSide
+	} );
+
+	this.scene = new THREE.Scene();
+	this.quad = new THREE.Mesh(
+		new THREE.PlaneBufferGeometry( 1, 1 ),
+		this.material
+	);
+	this.scene.add( this.quad );
+	this.camera = new THREE.OrthographicCamera( 1 / - 2, 1 / 2, 1 / 2, 1 / - 2, -10000, 10000 );
+
+	this.canvas = document.createElement( 'canvas' );
+	this.ctx = this.canvas.getContext( '2d' );
+
+	this.cubeCamera = null;
+	this.attachedCamera = null;
+
+	this.setSize( 4096, 2048 );
+
+	var gl = this.renderer.getContext();
+	this.cubeMapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE )
+
+	if( provideCubeCamera ) {
+		this.getCubeCamera( 2048 )
+	}
+
+}
+
+CubemapToEquirectangular.prototype.setSize = function( width, height ) {
+
+	this.width = width;
+	this.height = height;
+
+	this.quad.scale.set( this.width, this.height, 1 );
+
+	this.camera.left = this.width / - 2;
+	this.camera.right = this.width / 2;
+	this.camera.top = this.height / 2;
+	this.camera.bottom = this.height / - 2;
+
+	this.camera.updateProjectionMatrix();
+
+	this.output = new THREE.WebGLRenderTarget( this.width, this.height, {
+		minFilter: THREE.LinearFilter,
+		magFilter: THREE.LinearFilter,
+		wrapS: THREE.ClampToEdgeWrapping,
+		wrapT: THREE.ClampToEdgeWrapping,
+		format: THREE.RGBAFormat,
+		type: THREE.UnsignedByteType
+	});
+
+	this.canvas.width = this.width;
+	this.canvas.height = this.height;
+
+}
+
+CubemapToEquirectangular.prototype.getCubeCamera = function( size ) {
+
+	this.cubeCamera = new THREE.CubeCamera( .1, 1000, Math.min( this.cubeMapSize, size ) );
+	return this.cubeCamera;
+
+}
+
+CubemapToEquirectangular.prototype.attachCubeCamera = function( camera ) {
+
+	this.getCubeCamera();
+	this.attachedCamera = camera;
+
+}
+
+CubemapToEquirectangular.prototype.convert = function( cubeCamera, type ) {
+
+	this.quad.material.uniforms.map.value = cubeCamera.renderTarget.texture;
+	this.renderer.render( this.scene, this.camera, this.output, true );
+
+	var pixels = new Uint8Array( 4 * this.width * this.height );
+	this.renderer.readRenderTargetPixels( this.output, 0, 0, this.width, this.height, pixels );
+
+	var imageData = new ImageData( new Uint8ClampedArray( pixels ), this.width, this.height );
+
+	this.ctx.putImageData( imageData, 0, 0 );
+
+  var type = type || 'image/png';
+
+  var promise = new Promise(function(resolve, reject) {
+    /*
+		this.canvas.toBlob( function( blob ) {
+			var url = URL.createObjectURL(blob);
+		}, type );
+		*/
+		var base64 = this.canvas.toDataURL(type);
+		resolve(base64);
+	}.bind(this));	
+  return promise;
+}
+
+CubemapToEquirectangular.prototype.update = function( camera, scene ) {
+
+	var autoClear = this.renderer.autoClear;
+	this.renderer.autoClear = true;
+	this.cubeCamera.position.copy( camera.position );
+	this.cubeCamera.updateCubeMap( this.renderer, scene );
+	this.renderer.autoClear = autoClear;
+
+	this.convert( this.cubeCamera );
+
+}
+
+if( typeof exports !== 'undefined' ) {
+	if( typeof module !== 'undefined' && module.exports ) {
+		exports = module.exports = CubemapToEquirectangular
+	}
+	exports.CubemapToEquirectangular = CubemapToEquirectangular
+}
+else {
+	root.CubemapToEquirectangular = CubemapToEquirectangular
+}
+
+}).call(this);

package/scripts/external/three-old/DDSLoader.js

@@ -0,0 +1,269 @@
+/*
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.DDSLoader = function () {
+
+	this._parser = THREE.DDSLoader.parse;
+
+};
+
+THREE.DDSLoader.prototype = Object.create( THREE.CompressedTextureLoader.prototype );
+THREE.DDSLoader.prototype.constructor = THREE.DDSLoader;
+
+THREE.DDSLoader.parse = function ( buffer, loadMipmaps ) {
+
+	var dds = { mipmaps: [], width: 0, height: 0, format: null, mipmapCount: 1 };
+
+	// Adapted from @toji's DDS utils
+	// https://github.com/toji/webgl-texture-utils/blob/master/texture-util/dds.js
+
+	// All values and structures referenced from:
+	// http://msdn.microsoft.com/en-us/library/bb943991.aspx/
+
+	var DDS_MAGIC = 0x20534444;
+
+	var DDSD_CAPS = 0x1,
+		DDSD_HEIGHT = 0x2,
+		DDSD_WIDTH = 0x4,
+		DDSD_PITCH = 0x8,
+		DDSD_PIXELFORMAT = 0x1000,
+		DDSD_MIPMAPCOUNT = 0x20000,
+		DDSD_LINEARSIZE = 0x80000,
+		DDSD_DEPTH = 0x800000;
+
+	var DDSCAPS_COMPLEX = 0x8,
+		DDSCAPS_MIPMAP = 0x400000,
+		DDSCAPS_TEXTURE = 0x1000;
+
+	var DDSCAPS2_CUBEMAP = 0x200,
+		DDSCAPS2_CUBEMAP_POSITIVEX = 0x400,
+		DDSCAPS2_CUBEMAP_NEGATIVEX = 0x800,
+		DDSCAPS2_CUBEMAP_POSITIVEY = 0x1000,
+		DDSCAPS2_CUBEMAP_NEGATIVEY = 0x2000,
+		DDSCAPS2_CUBEMAP_POSITIVEZ = 0x4000,
+		DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x8000,
+		DDSCAPS2_VOLUME = 0x200000;
+
+	var DDPF_ALPHAPIXELS = 0x1,
+		DDPF_ALPHA = 0x2,
+		DDPF_FOURCC = 0x4,
+		DDPF_RGB = 0x40,
+		DDPF_YUV = 0x200,
+		DDPF_LUMINANCE = 0x20000;
+
+	function fourCCToInt32( value ) {
+
+		return value.charCodeAt( 0 ) +
+			( value.charCodeAt( 1 ) << 8 ) +
+			( value.charCodeAt( 2 ) << 16 ) +
+			( value.charCodeAt( 3 ) << 24 );
+
+	}
+
+	function int32ToFourCC( value ) {
+
+		return String.fromCharCode(
+			value & 0xff,
+			( value >> 8 ) & 0xff,
+			( value >> 16 ) & 0xff,
+			( value >> 24 ) & 0xff
+		);
+
+	}
+
+	function loadARGBMip( buffer, dataOffset, width, height ) {
+
+		var dataLength = width * height * 4;
+		var srcBuffer = new Uint8Array( buffer, dataOffset, dataLength );
+		var byteArray = new Uint8Array( dataLength );
+		var dst = 0;
+		var src = 0;
+		for ( var y = 0; y < height; y ++ ) {
+
+			for ( var x = 0; x < width; x ++ ) {
+
+				var b = srcBuffer[ src ]; src ++;
+				var g = srcBuffer[ src ]; src ++;
+				var r = srcBuffer[ src ]; src ++;
+				var a = srcBuffer[ src ]; src ++;
+				byteArray[ dst ] = r; dst ++;	//r
+				byteArray[ dst ] = g; dst ++;	//g
+				byteArray[ dst ] = b; dst ++;	//b
+				byteArray[ dst ] = a; dst ++;	//a
+
+			}
+
+		}
+		return byteArray;
+
+	}
+
+	var FOURCC_DXT1 = fourCCToInt32( "DXT1" );
+	var FOURCC_DXT3 = fourCCToInt32( "DXT3" );
+	var FOURCC_DXT5 = fourCCToInt32( "DXT5" );
+	var FOURCC_ETC1 = fourCCToInt32( "ETC1" );
+
+	var headerLengthInt = 31; // The header length in 32 bit ints
+
+	// Offsets into the header array
+
+	var off_magic = 0;
+
+	var off_size = 1;
+	var off_flags = 2;
+	var off_height = 3;
+	var off_width = 4;
+
+	var off_mipmapCount = 7;
+
+	var off_pfFlags = 20;
+	var off_pfFourCC = 21;
+	var off_RGBBitCount = 22;
+	var off_RBitMask = 23;
+	var off_GBitMask = 24;
+	var off_BBitMask = 25;
+	var off_ABitMask = 26;
+
+	var off_caps = 27;
+	var off_caps2 = 28;
+	var off_caps3 = 29;
+	var off_caps4 = 30;
+
+	// Parse header
+
+	var header = new Int32Array( buffer, 0, headerLengthInt );
+
+	if ( header[ off_magic ] !== DDS_MAGIC ) {
+
+		console.error( 'THREE.DDSLoader.parse: Invalid magic number in DDS header.' );
+		return dds;
+
+	}
+
+	if ( ! header[ off_pfFlags ] & DDPF_FOURCC ) {
+
+		console.error( 'THREE.DDSLoader.parse: Unsupported format, must contain a FourCC code.' );
+		return dds;
+
+	}
+
+	var blockBytes;
+
+	var fourCC = header[ off_pfFourCC ];
+
+	var isRGBAUncompressed = false;
+
+	switch ( fourCC ) {
+
+		case FOURCC_DXT1:
+
+			blockBytes = 8;
+			dds.format = THREE.RGB_S3TC_DXT1_Format;
+			break;
+
+		case FOURCC_DXT3:
+
+			blockBytes = 16;
+			dds.format = THREE.RGBA_S3TC_DXT3_Format;
+			break;
+
+		case FOURCC_DXT5:
+
+			blockBytes = 16;
+			dds.format = THREE.RGBA_S3TC_DXT5_Format;
+			break;
+
+		case FOURCC_ETC1:
+
+			blockBytes = 8;
+			dds.format = THREE.RGB_ETC1_Format;
+			break;
+
+		default:
+
+			if ( header[ off_RGBBitCount ] === 32
+				&& header[ off_RBitMask ] & 0xff0000
+				&& header[ off_GBitMask ] & 0xff00
+				&& header[ off_BBitMask ] & 0xff
+				&& header[ off_ABitMask ] & 0xff000000  ) {
+
+				isRGBAUncompressed = true;
+				blockBytes = 64;
+				dds.format = THREE.RGBAFormat;
+
+			} else {
+
+				console.error( 'THREE.DDSLoader.parse: Unsupported FourCC code ', int32ToFourCC( fourCC ) );
+				return dds;
+
+			}
+	}
+
+	dds.mipmapCount = 1;
+
+	if ( header[ off_flags ] & DDSD_MIPMAPCOUNT && loadMipmaps !== false ) {
+
+		dds.mipmapCount = Math.max( 1, header[ off_mipmapCount ] );
+
+	}
+
+	var caps2 = header[ off_caps2 ];
+	dds.isCubemap = caps2 & DDSCAPS2_CUBEMAP ? true : false;
+	if ( dds.isCubemap && (
+		! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEX ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEX ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEY ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEY ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_POSITIVEZ ) ||
+		! ( caps2 & DDSCAPS2_CUBEMAP_NEGATIVEZ )
+		) ) {
+
+		console.error( 'THREE.DDSLoader.parse: Incomplete cubemap faces' );
+		return dds;
+
+	}
+
+	dds.width = header[ off_width ];
+	dds.height = header[ off_height ];
+
+	var dataOffset = header[ off_size ] + 4;
+
+	// Extract mipmaps buffers
+
+	var faces = dds.isCubemap ? 6 : 1;
+
+	for ( var face = 0; face < faces; face ++ ) {
+
+		var width = dds.width;
+		var height = dds.height;
+
+		for ( var i = 0; i < dds.mipmapCount; i ++ ) {
+
+			if ( isRGBAUncompressed ) {
+
+				var byteArray = loadARGBMip( buffer, dataOffset, width, height );
+				var dataLength = byteArray.length;
+
+			} else {
+
+				var dataLength = Math.max( 4, width ) / 4 * Math.max( 4, height ) / 4 * blockBytes;
+				var byteArray = new Uint8Array( buffer, dataOffset, dataLength );
+
+			}
+
+			var mipmap = { "data": byteArray, "width": width, "height": height };
+			dds.mipmaps.push( mipmap );
+
+			dataOffset += dataLength;
+
+			width = Math.max( width >> 1, 1 );
+			height = Math.max( height >> 1, 1 );
+
+		}
+
+	}
+
+	return dds;
+
+};