Moved ImageUtils.loadTGATexture to examples/TGALoader.

examples/js/loaders/DDSLoader.js

@@ -13,7 +13,6 @@ THREE.DDSLoader.prototype = {
 		var scope = this;
 
 		var images = [];
-		images.loadCount = 0;
 
 		var texture = new THREE.CompressedTexture();
 		texture.image = images;

examples/js/loaders/TGALoader.js

@@ -0,0 +1,437 @@
+/*
+ * @author Daosheng Mu / https://github.com/DaoshengMu/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.TGALoader = function () {};
+
+THREE.TGALoader.prototype = {
+
+	constructor: THREE.TGALoader,
+
+	load: function ( url, onLoad, onError ) {
+		
+		var scope = this;
+		
+		var texture = new THREE.DataTexture();
+
+		var loader = new THREE.XHRLoader();
+		loader.setResponseType( 'arraybuffer' );
+		loader.load( url, function ( buffer ) {
+
+			texture.image = scope.parse( buffer );
+			texture.needsUpdate = true;
+
+			if ( onLoad ) onLoad( texture );
+
+		} );
+
+		return texture;
+
+	},
+
+	// reference from vthibault, https://github.com/vthibault/roBrowser/blob/master/src/Loaders/Targa.js
+	parse: function ( buffer ) {
+			   
+		// TGA Constants
+		var TGA_TYPE_NO_DATA = 0,
+		TGA_TYPE_INDEXED = 1,
+		TGA_TYPE_RGB = 2,
+		TGA_TYPE_GREY = 3,
+		TGA_TYPE_RLE_INDEXED = 9,
+		TGA_TYPE_RLE_RGB = 10,
+		TGA_TYPE_RLE_GREY = 11,
+
+		TGA_ORIGIN_MASK = 0x30,
+		TGA_ORIGIN_SHIFT = 0x04,
+		TGA_ORIGIN_BL = 0x00,
+		TGA_ORIGIN_BR = 0x01,
+		TGA_ORIGIN_UL = 0x02,
+		TGA_ORIGIN_UR = 0x03;
+
+		
+		if ( buffer.length < 19 )
+			console.error( 'ImageUtils::decodeTGA()- Not enough data to contain header.' );
+		
+		var content = new Uint8Array( buffer ),
+			offset = 0,
+			header = {
+			  id_length: content[ offset++ ], 
+			  colormap_type: content[ offset++ ],
+			  image_type:      content[offset++],
+			  colormap_index:  content[offset++] | content[offset++] << 8,
+			  colormap_length: content[offset++] | content[offset++] << 8,
+			  colormap_size:   content[offset++],
+
+			  origin: [
+						content[offset++] | content[offset++] << 8,
+						content[offset++] | content[offset++] << 8
+				],
+				width:      content[offset++] | content[offset++] << 8,
+				height:     content[offset++] | content[offset++] << 8,
+				pixel_size: content[offset++],
+				flags:      content[offset++]
+			};
+				
+		function tgaCheckHeader( header ) {
+			switch( header.image_type ) {
+				// Check indexed type
+			case TGA_TYPE_INDEXED:
+			case TGA_TYPE_RLE_INDEXED:
+				if ( header.colormap_length > 256 || header.colormap_size !== 24 || header.colormap_type !== 1) {
+					console.error('Targa::tgaCheckHeader() - Invalid type colormap data for indexed type');
+				}
+				break;
+
+			// Check colormap type
+			case TGA_TYPE_RGB:
+			case TGA_TYPE_GREY:
+			case TGA_TYPE_RLE_RGB:
+			case TGA_TYPE_RLE_GREY:
+				if (header.colormap_type) {
+					console.error('ImageUtils::tgaCheckHeader() - Invalid type colormap data for colormap type');
+				}
+				break;
+
+			// What the need of a file without data ?
+			case TGA_TYPE_NO_DATA:
+				console.error('ImageUtils::tgaCheckHeader() - No data');
+
+			// Invalid type ?
+			default:
+				console.error('ImageUtils::tgaCheckHeader() - Invalid type " '+ header.image_type + '"');
+			}
+
+			// Check image width and height
+			if ( header.width <= 0 || header.height <=0 ) {
+				console.error( 'ImageUtils::tgaCheckHeader() - Invalid image size' );
+			}
+
+			// Check image pixel size 
+			if (header.pixel_size !== 8  &&
+				header.pixel_size !== 16 &&
+				header.pixel_size !== 24 &&
+				header.pixel_size !== 32) {
+				console.error('ImageUtils::tgaCheckHeader() - Invalid pixel size "' + header.pixel_size + '"');
+			}
+		}
+
+		// Check tga if it is valid format
+		tgaCheckHeader( header );
+
+		if ( header.id_length + offset > buffer.length ) {
+			console.error('ImageUtils::load() - No data');
+		}
+
+		// Skip the needn't data
+		offset += header.id_length;
+
+		// Get targa information about RLE compression and palette
+		var use_rle = false, 
+			use_pal = false, 
+			use_grey = false;
+	
+		switch ( header.image_type ) {
+			case TGA_TYPE_RLE_INDEXED:
+				use_rle = true;
+				use_pal = true;
+				break;
+
+			case TGA_TYPE_INDEXED:
+				use_pal = true;
+				break;
+				
+			case TGA_TYPE_RLE_RGB:
+				use_rle = true;
+				break;
+
+			case TGA_TYPE_RGB:
+				break;
+
+			case TGA_TYPE_RLE_GREY:
+				use_rle = true;
+				use_grey = true;
+				break;
+
+			case TGA_TYPE_GREY:
+				use_grey = true;
+				break;
+		}
+		
+		// Parse tga image buffer
+		function tgaParse( use_rle, use_pal, header, offset, data ) {
+			
+			var pixel_data,
+				pixel_size,
+				pixel_total,
+				palettes;
+		
+				pixel_size = header.pixel_size >> 3;
+				pixel_total = header.width * header.height * pixel_size;
+				
+			 // Read palettes
+			 if ( use_pal ) {
+				 palettes = data.subarray( offset, offset += header.colormap_length * ( header.colormap_size >> 3 ) );
+			 }
+			 
+			 // Read RLE
+			 if ( use_rle ) {
+				 pixel_data = new Uint8Array(pixel_total);
+				 
+				var c, count, i;
+				var shift = 0;
+				var pixels = new Uint8Array(pixel_size);
+
+				while (shift < pixel_total) {
+					c     = data[offset++];
+					count = (c & 0x7f) + 1;
+
+					// RLE pixels.
+					if (c & 0x80) {
+						// Bind pixel tmp array
+						for (i = 0; i < pixel_size; ++i) {
+								pixels[i] = data[offset++];
+						}
+
+						// Copy pixel array
+						for (i = 0; i < count; ++i) {
+								pixel_data.set(pixels, shift + i * pixel_size);
+						}
+
+						shift += pixel_size * count;
+					}
+
+					// Raw pixels.
+					else {
+						count *= pixel_size;
+						for (i = 0; i < count; ++i) {
+								pixel_data[shift + i] = data[offset++];
+						}
+					   shift += count;
+					}
+				}
+			 }
+			 // RAW Pixels
+			 else {
+				pixel_data = data.subarray(
+					 offset, offset += (use_pal ? header.width * header.height : pixel_total)
+				);
+			 }
+			
+			 return { 
+				pixel_data: pixel_data, 
+				palettes: palettes 
+			 };
+		}
+		
+	function tgaGetImageData8bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end
+								, image, palettes ) {
+	var colormap = palettes;		
+	var color, i = 0, x, y;
+			var width = header.width;
+			
+	for (y = y_start; y !== y_end; y += y_step) {
+				for (x = x_start; x !== x_end; x += x_step, i++) {
+					color = image[i];
+					imageData[(x + width * y) * 4 + 3] = 255;
+					imageData[(x + width * y) * 4 + 2] = colormap[(color * 3) + 0];
+					imageData[(x + width * y) * 4 + 1] = colormap[(color * 3) + 1];
+					imageData[(x + width * y) * 4 + 0] = colormap[(color * 3) + 2];
+				}
+	}
+
+	return imageData;
+	};
+
+	function tgaGetImageData16bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end
+									, image) {
+			var color, i = 0, x, y;
+			var width = header.width;
+
+			for (y = y_start; y !== y_end; y += y_step) {
+				for (x = x_start; x !== x_end; x += x_step, i += 2) {
+					color = image[i + 0] + (image[i + 1] << 8); // Inversed ?
+					imageData[(x + width * y) * 4 + 0] = (color & 0x7C00) >> 7;
+					imageData[(x + width * y) * 4 + 1] = (color & 0x03E0) >> 2;
+					imageData[(x + width * y) * 4 + 2] = (color & 0x001F) >> 3;
+					imageData[(x + width * y) * 4 + 3] = (color & 0x8000) ? 0 : 255;
+				}
+			}
+
+			return imageData;
+	};
+
+	function tgaGetImageData24bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
+			var i = 0, x, y;
+			var width = header.width;
+
+			for (y = y_start; y !== y_end; y += y_step) {
+				for (x = x_start; x !== x_end; x += x_step, i += 3) {
+					imageData[(x + width * y) * 4 + 3] = 255;
+					imageData[(x + width * y) * 4 + 2] = image[i + 0];
+					imageData[(x + width * y) * 4 + 1] = image[i + 1];
+					imageData[(x + width * y) * 4 + 0] = image[i + 2];
+				}
+			}
+
+			return imageData;
+	};
+	
+	function tgaGetImageData32bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {		
+			var i = 0, x, y;
+			var width = header.width;
+
+			for (y = y_start; y !== y_end; y += y_step) {
+				for (x = x_start; x !== x_end; x += x_step, i += 4) {
+					imageData[(x + width * y) * 4 + 2] = image[i + 0];
+					imageData[(x + width * y) * 4 + 1] = image[i + 1];
+					imageData[(x + width * y) * 4 + 0] = image[i + 2];
+					imageData[(x + width * y) * 4 + 3] = image[i + 3];
+				}
+			}
+
+			return imageData;
+	};
+
+	function tgaGetImageDataGrey8bits( imageData, y_start, y_step, y_end, x_start, x_step, x_end, image ) {
+			var color, i = 0, x, y;
+			var width = header.width;
+
+			for (y = y_start; y !== y_end; y += y_step) {
+				for (x = x_start; x !== x_end; x += x_step, i++) {
+					color = image[i];
+					imageData[(x + width * y) * 4 + 0] = color;
+					imageData[(x + width * y) * 4 + 1] = color;
+					imageData[(x + width * y) * 4 + 2] = color;
+					imageData[(x + width * y) * 4 + 3] = 255;
+				}
+			}
+
+			return imageData;
+	};
+
+	function tgaGetImageDataGrey16bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {		
+			var i = 0, x, y;
+			var width = header.width;
+
+			for (y = y_start; y !== y_end; y += y_step) {
+				for (x = x_start; x !== x_end; x += x_step, i += 2) {
+					imageData[(x + width * y) * 4 + 0] = image[i + 0];
+					imageData[(x + width * y) * 4 + 1] = image[i + 0];
+					imageData[(x + width * y) * 4 + 2] = image[i + 0];
+					imageData[(x + width * y) * 4 + 3] = image[i + 1];
+				}
+			}
+
+			return imageData;
+	};
+	
+		function getTgaRGBA( width, height, image, palette ) {
+			var x_start,
+				y_start,
+				x_step,
+				y_step,
+				x_end,
+				y_end,                    
+				data = new Uint8Array(width * height * 4);
+				
+				switch( (header.flags & TGA_ORIGIN_MASK) >> TGA_ORIGIN_SHIFT ) {
+					default:
+					case TGA_ORIGIN_UL:
+						x_start = 0;
+						x_step = 1;
+						x_end = width;
+						y_start = 0;
+						y_step = 1;
+						y_end = height;
+						break;
+						
+					case TGA_ORIGIN_BL:
+						x_start = 0;
+						x_step = 1;
+						x_end = width;
+						y_start = height - 1;
+						y_step = -1;
+						y_end = -1;
+						break;
+						
+					case TGA_ORIGIN_UR:
+						x_start = width - 1;
+						x_step = -1;
+						x_end = -1;
+						y_start = 0;
+						y_step = 1;
+						y_end = height;
+						break;
+						
+					case TGA_ORIGIN_BR:
+						x_start = width - 1;
+						x_step = -1;
+						x_end = -1;
+						y_start = height - 1;
+						y_step = -1;
+						y_end = -1;
+						break;
+				}
+				
+				
+			if ( use_grey ) {
+				
+				switch( header.pixel_size )
+				{
+					case 8:
+						tgaGetImageDataGrey8bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
+						break;
+					case 16:
+						tgaGetImageDataGrey16bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
+						break;
+					default:
+						console.error( 'ImageUtils::getTgaRGBA() - not support this format' );
+						break;
+				}
+				
+			}
+			else {
+				
+				switch( header.pixel_size )
+				{
+					case 8:
+						tgaGetImageData8bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image, palette );
+						break;
+						
+					case 16:
+						tgaGetImageData16bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
+						break;
+						
+					case 24:
+						tgaGetImageData24bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
+						break;
+
+					case 32:
+						tgaGetImageData32bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
+						break;
+						
+					default:
+						console.error( 'ImageUtils::getTgaRGBA() - not support this format' );
+						break;  
+				}
+			}
+			// Load image data according to specific method
+		   // var func = 'tgaGetImageData' + (use_grey ? 'Grey' : '') + (header.pixel_size) + 'bits';
+			//func(data, y_start, y_step, y_end, x_start, x_step, x_end, width, image, palette );
+			return data;
+		}
+		
+		var result = tgaParse( use_rle, use_pal, header, offset, content );
+		var rgbaData = getTgaRGBA( header.width, header.height, result.pixel_data, result.palettes );
+	   
+		
+		return {
+			width: header.width,
+			height: header.height,
+			data: rgbaData
+		};
+
+	}
+
+};

examples/webgl_materials_texture_tga.html

@@ -31,6 +31,8 @@
 				<a href="http://threejs.org" target="_blank">three.js</a> - tga texture example
 		</div>
 		<script src="../build/three.min.js"></script>
+		<script src="js/loaders/TGALoader.js"></script>
+
 		<script src="js/Detector.js"></script>
 		<script src="js/libs/stats.min.js"></script>
 		
@@ -69,8 +71,10 @@
 				light.position.set( 1, 1, 1 );
 				scene.add( light );
 				
+				var loader = new THREE.TGALoader();
+
 				// add box 1 - grey8 texture
-				var texture1 = THREE.ImageUtils.loadTGATexture( "textures/crate_grey8.tga" );
+				var texture1 = loader.load( 'textures/crate_grey8.tga' );
 				var material1 = new THREE.MeshPhongMaterial( { color: 0xffffff, map: texture1 } );
 				
 				var geometry = new THREE.BoxGeometry( 50, 50, 50 );
@@ -81,7 +85,7 @@
 				scene.add( mesh1 );
 				
 				// add box 2 - tga texture
-				var texture2 = THREE.ImageUtils.loadTGATexture( "textures/crate_color8.tga" );
+				var texture2 = loader.load( 'textures/crate_color8.tga' );
 				var material2 = new THREE.MeshPhongMaterial( { color: 0xffffff, map: texture2 } );
 					   
 				var mesh2 = new THREE.Mesh( geometry, material2 );

src/extras/ImageUtils.js

@@ -72,436 +72,6 @@ THREE.ImageUtils = {
 		return texture;
 
 	},
-                
-        
-        // reference from vthibault, https://github.com/vthibault/roBrowser/blob/master/src/Loaders/Targa.js
-        decodeTGA: function ( arrayBuffer ) {
-                   
-            // TGA Constants
-            var TGA_TYPE_NO_DATA = 0,
-            TGA_TYPE_INDEXED = 1,
-            TGA_TYPE_RGB = 2,
-            TGA_TYPE_GREY = 3,
-            TGA_TYPE_RLE_INDEXED = 9,
-            TGA_TYPE_RLE_RGB = 10,
-            TGA_TYPE_RLE_GREY = 11,
-
-            TGA_ORIGIN_MASK = 0x30,
-            TGA_ORIGIN_SHIFT = 0x04,
-            TGA_ORIGIN_BL = 0x00,
-            TGA_ORIGIN_BR = 0x01,
-            TGA_ORIGIN_UL = 0x02,
-            TGA_ORIGIN_UR = 0x03;
-    
-            
-            if ( arrayBuffer.length < 19 )
-                console.error( 'ImageUtils::decodeTGA()- Not enough data to contain header.' );
-            
-            var content = new Uint8Array( arrayBuffer ),
-                offset = 0,
-                header = {
-                  id_length: content[ offset++ ], 
-                  colormap_type: content[ offset++ ],
-                  image_type:      content[offset++],
-                  colormap_index:  content[offset++] | content[offset++] << 8,
-                  colormap_length: content[offset++] | content[offset++] << 8,
-                  colormap_size:   content[offset++],
-
-                  origin: [
-                            content[offset++] | content[offset++] << 8,
-                            content[offset++] | content[offset++] << 8
-                    ],
-                    width:      content[offset++] | content[offset++] << 8,
-                    height:     content[offset++] | content[offset++] << 8,
-                    pixel_size: content[offset++],
-                    flags:      content[offset++]
-                };
-                    
-            function tgaCheckHeader( header ) {
-                switch( header.image_type ) {
-                    // Check indexed type
-                case TGA_TYPE_INDEXED:
-                case TGA_TYPE_RLE_INDEXED:
-                    if ( header.colormap_length > 256 || header.colormap_size !== 24 || header.colormap_type !== 1) {
-                        console.error('Targa::tgaCheckHeader() - Invalid type colormap data for indexed type');
-                    }
-                    break;
-
-                // Check colormap type
-                case TGA_TYPE_RGB:
-                case TGA_TYPE_GREY:
-                case TGA_TYPE_RLE_RGB:
-                case TGA_TYPE_RLE_GREY:
-                    if (header.colormap_type) {
-                        console.error('ImageUtils::tgaCheckHeader() - Invalid type colormap data for colormap type');
-                    }
-                    break;
-
-                // What the need of a file without data ?
-                case TGA_TYPE_NO_DATA:
-                    console.error('ImageUtils::tgaCheckHeader() - No data');
-
-                // Invalid type ?
-                default:
-                    console.error('ImageUtils::tgaCheckHeader() - Invalid type " '+ header.image_type + '"');
-                }
-
-                // Check image width and height
-                if ( header.width <= 0 || header.height <=0 ) {
-                    console.error( 'ImageUtils::tgaCheckHeader() - Invalid image size' );
-                }
-
-                // Check image pixel size 
-                if (header.pixel_size !== 8  &&
-                    header.pixel_size !== 16 &&
-                    header.pixel_size !== 24 &&
-                    header.pixel_size !== 32) {
-                    console.error('ImageUtils::tgaCheckHeader() - Invalid pixel size "' + header.pixel_size + '"');
-                }
-            }
-
-            // Check tga if it is valid format
-            tgaCheckHeader( header );
-
-            if ( header.id_length + offset > arrayBuffer.length ) {
-                console.error('ImageUtils::load() - No data');
-            }
-
-            // Skip the needn't data
-            offset += header.id_length;
-
-            // Get targa information about RLE compression and palette
-            var use_rle = false, 
-                use_pal = false, 
-                use_grey = false;
-        
-            switch ( header.image_type ) {
-                case TGA_TYPE_RLE_INDEXED:
-                    use_rle = true;
-                    use_pal = true;
-                    break;
-
-                case TGA_TYPE_INDEXED:
-                    use_pal = true;
-                    break;
-                    
-                case TGA_TYPE_RLE_RGB:
-                    use_rle = true;
-                    break;
-
-                case TGA_TYPE_RGB:
-                    break;
-
-                case TGA_TYPE_RLE_GREY:
-                    use_rle = true;
-                    use_grey = true;
-                    break;
-
-                case TGA_TYPE_GREY:
-                    use_grey = true;
-                    break;
-            }
-            
-            // Parse tga image buffer
-            function tgaParse( use_rle, use_pal, header, offset, data ) {
-                
-                var pixel_data,
-                    pixel_size,
-                    pixel_total,
-                    palettes;
-            
-                    pixel_size = header.pixel_size >> 3;
-                    pixel_total = header.width * header.height * pixel_size;
-                    
-                 // Read palettes
-                 if ( use_pal ) {
-                     palettes = data.subarray( offset, offset += header.colormap_length * ( header.colormap_size >> 3 ) );
-                 }
-                 
-                 // Read RLE
-                 if ( use_rle ) {
-                     pixel_data = new Uint8Array(pixel_total);
-                     
-                    var c, count, i;
-                    var shift = 0;
-                    var pixels = new Uint8Array(pixel_size);
-
-                    while (shift < pixel_total) {
-                        c     = data[offset++];
-                        count = (c & 0x7f) + 1;
-
-                        // RLE pixels.
-                        if (c & 0x80) {
-                            // Bind pixel tmp array
-                            for (i = 0; i < pixel_size; ++i) {
-                                    pixels[i] = data[offset++];
-                            }
-
-                            // Copy pixel array
-                            for (i = 0; i < count; ++i) {
-                                    pixel_data.set(pixels, shift + i * pixel_size);
-                            }
-
-                            shift += pixel_size * count;
-                        }
-
-                        // Raw pixels.
-                        else {
-                            count *= pixel_size;
-                            for (i = 0; i < count; ++i) {
-                                    pixel_data[shift + i] = data[offset++];
-                            }
-                           shift += count;
-                        }
-                    }
-                 }
-                 // RAW Pixels
-                 else {
-                    pixel_data = data.subarray(
-                         offset, offset += (use_pal ? header.width * header.height : pixel_total)
-                    );
-                 }
-                
-                 return { 
-                    pixel_data: pixel_data, 
-                    palettes: palettes 
-                 };
-            }
-            
-	    function tgaGetImageData8bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end
-                                    , image, palettes ) {
-		var colormap = palettes;		
-		var color, i = 0, x, y;
-                var width = header.width;
-                
-		for (y = y_start; y !== y_end; y += y_step) {
-                    for (x = x_start; x !== x_end; x += x_step, i++) {
-                        color = image[i];
-                        imageData[(x + width * y) * 4 + 3] = 255;
-                        imageData[(x + width * y) * 4 + 2] = colormap[(color * 3) + 0];
-                        imageData[(x + width * y) * 4 + 1] = colormap[(color * 3) + 1];
-                        imageData[(x + width * y) * 4 + 0] = colormap[(color * 3) + 2];
-                    }
-		}
-
-		return imageData;
-	    };
-
-	    function tgaGetImageData16bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end
-                                        , image) {
-                var color, i = 0, x, y;
-                var width = header.width;
-
-                for (y = y_start; y !== y_end; y += y_step) {
-                    for (x = x_start; x !== x_end; x += x_step, i += 2) {
-                        color = image[i + 0] + (image[i + 1] << 8); // Inversed ?
-                        imageData[(x + width * y) * 4 + 0] = (color & 0x7C00) >> 7;
-                        imageData[(x + width * y) * 4 + 1] = (color & 0x03E0) >> 2;
-                        imageData[(x + width * y) * 4 + 2] = (color & 0x001F) >> 3;
-                        imageData[(x + width * y) * 4 + 3] = (color & 0x8000) ? 0 : 255;
-                    }
-                }
-
-                return imageData;
-	    };
-
-	    function tgaGetImageData24bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {
-                var i = 0, x, y;
-                var width = header.width;
-
-                for (y = y_start; y !== y_end; y += y_step) {
-                    for (x = x_start; x !== x_end; x += x_step, i += 3) {
-                        imageData[(x + width * y) * 4 + 3] = 255;
-                        imageData[(x + width * y) * 4 + 2] = image[i + 0];
-                        imageData[(x + width * y) * 4 + 1] = image[i + 1];
-                        imageData[(x + width * y) * 4 + 0] = image[i + 2];
-                    }
-                }
-
-                return imageData;
-	    };
-        
-	    function tgaGetImageData32bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {		
-                var i = 0, x, y;
-                var width = header.width;
-
-                for (y = y_start; y !== y_end; y += y_step) {
-                    for (x = x_start; x !== x_end; x += x_step, i += 4) {
-                        imageData[(x + width * y) * 4 + 2] = image[i + 0];
-                        imageData[(x + width * y) * 4 + 1] = image[i + 1];
-                        imageData[(x + width * y) * 4 + 0] = image[i + 2];
-                        imageData[(x + width * y) * 4 + 3] = image[i + 3];
-                    }
-                }
-
-                return imageData;
-	    };
-
-	    function tgaGetImageDataGrey8bits( imageData, y_start, y_step, y_end, x_start, x_step, x_end, image ) {
-                var color, i = 0, x, y;
-                var width = header.width;
-
-                for (y = y_start; y !== y_end; y += y_step) {
-                    for (x = x_start; x !== x_end; x += x_step, i++) {
-                        color = image[i];
-                        imageData[(x + width * y) * 4 + 0] = color;
-                        imageData[(x + width * y) * 4 + 1] = color;
-                        imageData[(x + width * y) * 4 + 2] = color;
-                        imageData[(x + width * y) * 4 + 3] = 255;
-                    }
-                }
-
-                return imageData;
-	    };
-
-	    function tgaGetImageDataGrey16bits(imageData, y_start, y_step, y_end, x_start, x_step, x_end, image) {		
-                var i = 0, x, y;
-                var width = header.width;
-
-                for (y = y_start; y !== y_end; y += y_step) {
-                    for (x = x_start; x !== x_end; x += x_step, i += 2) {
-                        imageData[(x + width * y) * 4 + 0] = image[i + 0];
-                        imageData[(x + width * y) * 4 + 1] = image[i + 0];
-                        imageData[(x + width * y) * 4 + 2] = image[i + 0];
-                        imageData[(x + width * y) * 4 + 3] = image[i + 1];
-                    }
-                }
-
-                return imageData;
-	    };
-        
-            function getTgaRGBA( width, height, image, palette ) {
-                var x_start,
-                    y_start,
-                    x_step,
-                    y_step,
-                    x_end,
-                    y_end,                    
-                    data = new Uint8Array(width * height * 4);
-                    
-                    switch( (header.flags & TGA_ORIGIN_MASK) >> TGA_ORIGIN_SHIFT ) {
-                        default:
-                        case TGA_ORIGIN_UL:
-                            x_start = 0;
-                            x_step = 1;
-                            x_end = width;
-                            y_start = 0;
-                            y_step = 1;
-                            y_end = height;
-                            break;
-                            
-                        case TGA_ORIGIN_BL:
-                            x_start = 0;
-                            x_step = 1;
-                            x_end = width;
-                            y_start = height - 1;
-                            y_step = -1;
-                            y_end = -1;
-                            break;
-                            
-                        case TGA_ORIGIN_UR:
-                            x_start = width - 1;
-                            x_step = -1;
-                            x_end = -1;
-                            y_start = 0;
-                            y_step = 1;
-                            y_end = height;
-                            break;
-                            
-                        case TGA_ORIGIN_BR:
-                            x_start = width - 1;
-                            x_step = -1;
-                            x_end = -1;
-                            y_start = height - 1;
-                            y_step = -1;
-                            y_end = -1;
-                            break;
-                    }
-                    
-                    
-                if ( use_grey ) {
-                    
-                    switch( header.pixel_size )
-                    {
-                        case 8:
-                            tgaGetImageDataGrey8bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
-                            break;
-                        case 16:
-                            tgaGetImageDataGrey16bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
-                            break;
-                        default:
-                            console.error( 'ImageUtils::getTgaRGBA() - not support this format' );
-                            break;
-                    }
-                    
-                }
-                else {
-                    
-                    switch( header.pixel_size )
-                    {
-                        case 8:
-                            tgaGetImageData8bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image, palette );
-                            break;
-                            
-                        case 16:
-                            tgaGetImageData16bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
-                            break;
-                            
-                        case 24:
-                            tgaGetImageData24bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
-                            break;
-
-                        case 32:
-                            tgaGetImageData32bits( data, y_start, y_step, y_end, x_start, x_step, x_end, image );
-                            break;
-                            
-                        default:
-                            console.error( 'ImageUtils::getTgaRGBA() - not support this format' );
-                            break;  
-                    }
-                }
-                // Load image data according to specific method
-               // var func = 'tgaGetImageData' + (use_grey ? 'Grey' : '') + (header.pixel_size) + 'bits';
-                //func(data, y_start, y_step, y_end, x_start, x_step, x_end, width, image, palette );
-                return data;
-            }
-            
-            var result = tgaParse( use_rle, use_pal, header, offset, content );
-            var rgbaData = getTgaRGBA( header.width, header.height, result.pixel_data, result.palettes );
-           
-            
-            return {
-                width: header.width,
-                height: header.height,
-                data: rgbaData
-            };
-        },
-
-        loadTGATexture: function ( url, mapping, onLoad, onError ) {
-               
-            var texture = new THREE.DataTexture();
-
-            var loader = new THREE.XHRLoader();
-            loader.setResponseType( 'arraybuffer' );
-            loader.load( url, function ( buffer ) {
-
-                var imageData = THREE.ImageUtils.decodeTGA( buffer );
-
-                if ( imageData ) {
-                    texture.image = imageData;
-                    texture.sourceFile = url;
-                    texture.needsUpdate = true;
-
-                    if ( onLoad ) onLoad( texture );
-				}            	
-
-            } );
-	              
-			texture.sourceFile = url;
-
-			return texture;
-
-	    },
 
 	getNormalMap: function ( image, depth ) {