support tga format texture

build/three.js

@@ -14275,6 +14275,25 @@ THREE.CompressedTexture.prototype.clone = function () {
 
 };
 
+/**
+ * @author Daosheng Mu / https://github.com/DaoshengMu/
+ */
+
+THREE.TGATexture = function ( format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy ) {
+    
+    THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+};
+
+THREE.TGATexture.prototype = Object.create( THREE.Texture.prototype );
+
+THREE.TGATexture.prototype.clone = function() {
+    
+    var texture = new THREE.TGATexture();
+    
+    THREE.Texture.prototype.clone.all( this. texture );
+    
+    return texture;
+};
 /**
  * @author alteredq / http://alteredqualia.com/
  */
@@ -25157,7 +25176,11 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 				}
 
-			} else { // regular Texture (image, video, canvas)
+			} else if ( texture instanceof THREE.TGATexture ) {
+                               var tgaImg = texture.image;
+                               _gl.texImage2D( _gl.TEXTURE_2D, 0, glFormat, tgaImg.width, tgaImg.height, 0, glFormat, glType, tgaImg.data );
+                
+                        } else { // regular Texture (image, video, canvas)
 
 				// use manually created mipmaps if available
 				// if there are no manual mipmaps
@@ -26660,6 +26683,7 @@ THREE.GeometryUtils = {
 /**
  * @author alteredq / http://alteredqualia.com/
  * @author mrdoob / http://mrdoob.com/
+ * @author Daosheng Mu / https://github.com/DaoshengMu/
  */
 
 THREE.ImageUtils = {
@@ -26889,6 +26913,453 @@ 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 * 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.TGATexture();                
+                {
+                    var request = new XMLHttpRequest();
+
+                    request.open( 'GET', url, true );
+                    request.responseType = "arraybuffer";
+                    request.onload = function() {
+                        if ( this.status === 200 ) {
+                            var imageData = THREE.ImageUtils.decodeTGA( this.response );
+
+                            if ( imageData ) {
+                                texture.image = imageData;
+                                texture.sourceFile = url;
+                                texture.needsUpdate = true;
+                                
+                                return texture;
+                            }
+
+                        }
+                    };
+                    
+                    request.addEventListener( 'load', function ( event ) {
+
+                            if ( onLoad ) onLoad( texture );
+
+			}, false );
+                        
+                    request.addEventListener( 'error', function ( event ) {
+
+                            if ( onError ) onError( event );
+
+			}, false );
+                    
+                    request.send(null);
+                }
+              
+		texture.sourceFile = url;
+
+		return texture;
+        },
 
 	loadDDSTexture: function ( url, mapping, onLoad, onError ) {
 

src/extras/ImageUtils.js

@@ -1,6 +1,7 @@
 /**
  * @author alteredq / http://alteredqualia.com/
  * @author mrdoob / http://mrdoob.com/
+ * @author Daosheng Mu / https://github.com/DaoshengMu/
  */
 
 THREE.ImageUtils = {
@@ -230,6 +231,453 @@ 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 * 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.TGATexture();                
+                {
+                    var request = new XMLHttpRequest();
+
+                    request.open( 'GET', url, true );
+                    request.responseType = "arraybuffer";
+                    request.onload = function() {
+                        if ( this.status === 200 ) {
+                            var imageData = THREE.ImageUtils.decodeTGA( this.response );
+
+                            if ( imageData ) {
+                                texture.image = imageData;
+                                texture.sourceFile = url;
+                                texture.needsUpdate = true;
+                                
+                                return texture;
+                            }
+
+                        }
+                    };
+                    
+                    request.addEventListener( 'load', function ( event ) {
+
+                            if ( onLoad ) onLoad( texture );
+
+			}, false );
+                        
+                    request.addEventListener( 'error', function ( event ) {
+
+                            if ( onError ) onError( event );
+
+			}, false );
+                    
+                    request.send(null);
+                }
+              
+		texture.sourceFile = url;
+
+		return texture;
+        },
 
 	loadDDSTexture: function ( url, mapping, onLoad, onError ) {
 

src/renderers/WebGLRenderer.js

@@ -5546,7 +5546,11 @@ THREE.WebGLRenderer = function ( parameters ) {
 
 				}
 
-			} else { // regular Texture (image, video, canvas)
+			} else if ( texture instanceof THREE.TGATexture ) {
+                               var tgaImg = texture.image;
+                               _gl.texImage2D( _gl.TEXTURE_2D, 0, glFormat, tgaImg.width, tgaImg.height, 0, glFormat, glType, tgaImg.data );
+                
+                        } else { // regular Texture (image, video, canvas)
 
 				// use manually created mipmaps if available
 				// if there are no manual mipmaps

src/textures/TGATexture.js

@@ -0,0 +1,19 @@
+/**
+ * @author Daosheng Mu / https://github.com/DaoshengMu/
+ */
+
+THREE.TGATexture = function ( format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy ) {
+    
+    THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+};
+
+THREE.TGATexture.prototype = Object.create( THREE.Texture.prototype );
+
+THREE.TGATexture.prototype.clone = function() {
+    
+    var texture = new THREE.TGATexture();
+    
+    THREE.Texture.prototype.clone.all( this. texture );
+    
+    return texture;
+};

utils/build/includes/common.json

@@ -64,6 +64,7 @@
 	"src/materials/SpriteCanvasMaterial.js",
 	"src/textures/Texture.js",
 	"src/textures/CompressedTexture.js",
+        "src/textures/TGATexture.js",
 	"src/textures/DataTexture.js",
 	"src/objects/PointCloud.js",
 	"src/objects/Line.js",

utils/build/includes/webgl.json

@@ -55,6 +55,7 @@
 	"src/materials/SpriteMaterial.js",
 	"src/textures/Texture.js",
 	"src/textures/CompressedTexture.js",
+        "src/textures/TGATexture.js",
 	"src/textures/DataTexture.js",
 	"src/objects/PointCloud.js",
 	"src/objects/Line.js",