diff --git a/libs/three_loaders/TGALoader.js b/libs/three_loaders/TGALoader.js new file mode 100644 index 0000000..978630e --- /dev/null +++ b/libs/three_loaders/TGALoader.js @@ -0,0 +1,487 @@ +( function () { + + class TGALoader extends THREE.DataTextureLoader { + + constructor( manager ) { + + super( manager ); + + } + + parse( buffer ) { + + // reference from vthibault, https://github.com/vthibault/roBrowser/blob/master/src/Loaders/Targa.js + 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( 'THREE.TGALoader: 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( 'THREE.TGALoader: Invalid type colormap data for colormap type.' ); + + } + + break; + // What the need of a file without data ? + + case TGA_TYPE_NO_DATA: + console.error( 'THREE.TGALoader: No data.' ); + // Invalid type ? + + default: + console.error( 'THREE.TGALoader: Invalid type "%s".', header.image_type ); + + } // check image width and height + + + if ( header.width <= 0 || header.height <= 0 ) { + + console.error( 'THREE.TGALoader: 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( 'THREE.TGALoader: Invalid pixel size "%s".', header.pixel_size ); + + } + + } // parse tga image buffer + + + function tgaParse( use_rle, use_pal, header, offset, data ) { + + let pixel_data, palettes; + const pixel_size = header.pixel_size >> 3; + const 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 ); + let c, count, i; + let shift = 0; + const 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; + + } else { + + // raw pixels + count *= pixel_size; + + for ( i = 0; i < count; ++ i ) { + + pixel_data[ shift + i ] = data[ offset ++ ]; + + } + + shift += count; + + } + + } + + } else { + + // raw pixels + 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 ) { + + const colormap = palettes; + let color, + i = 0, + x, + y; + const 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 ) { + + let color, + i = 0, + x, + y; + const 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 ) { + + let i = 0, + x, + y; + const 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 ) { + + let i = 0, + x, + y; + const 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 ) { + + let color, + i = 0, + x, + y; + const 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 ) { + + let i = 0, + x, + y; + const 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( data, width, height, image, palette ) { + + let x_start, y_start, x_step, y_step, x_end, y_end; + + 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( 'THREE.TGALoader: Format not supported.' ); + 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( 'THREE.TGALoader: Format not supported.' ); + break; + + } + + } // Load image data according to specific method + // let 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; + + } // TGA constants + + + const 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( 'THREE.TGALoader: Not enough data to contain header.' ); + let offset = 0; + const content = new Uint8Array( buffer ), + 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 ++ ] + }; // check tga if it is valid format + + tgaCheckHeader( header ); + + if ( header.id_length + offset > buffer.length ) { + + console.error( 'THREE.TGALoader: No data.' ); + + } // skip the needn't data + + + offset += header.id_length; // get targa information about RLE compression and palette + + let 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; + + } // + + + const imageData = new Uint8Array( header.width * header.height * 4 ); + const result = tgaParse( use_rle, use_pal, header, offset, content ); + getTgaRGBA( imageData, header.width, header.height, result.pixel_data, result.palettes ); + return { + data: imageData, + width: header.width, + height: header.height, + flipY: true, + generateMipmaps: true, + minFilter: THREE.LinearMipmapLinearFilter + }; + + } + + } + + THREE.TGALoader = TGALoader; + +} )(); diff --git a/source/threejs/threeimporter.js b/source/threejs/threeimporter.js index 4a2ab00..e580ae4 100644 --- a/source/threejs/threeimporter.js +++ b/source/threejs/threeimporter.js @@ -68,13 +68,18 @@ OV.ThreeImporter = class extends OV.ImporterBase GetExternalLibraries () { + let libraries = [ + 'three_loaders/TGALoader.js' + ]; if (this.extension === 'fbx') { - return [ + libraries.push ( 'three_loaders/fflate.min.js', 'three_loaders/FBXLoader.js' - ]; + ); + } else { + return null; } - return null; + return libraries; } CreateLoader (manager) @@ -95,6 +100,8 @@ OV.ThreeImporter = class extends OV.ImporterBase this.OnThreeObjectsLoaded (loadedScene, externalFileNames, onFinish); } }); + // TODO + loadingManager.addHandler (/\.tga$/i, new THREE.TGALoader (loadingManager)); const mainFileUrl = OV.CreateObjectUrl (fileContent); loadingManager.setURLModifier ((url) => { @@ -151,11 +158,26 @@ OV.ThreeImporter = class extends OV.ImporterBase function CreateTexture (threeMap, externalFileNames) { + function GetDataUrl (img) + { + if (img.data !== undefined && img.data !== null) { + let imageData = new ImageData (img.width, img.height); + let imageSize = img.width * img.height * 4; + for (let i = 0; i < imageSize; i++) { + imageData.data[i] = img.data[i]; + } + return THREE.ImageUtils.getDataURL (imageData); + } else { + return THREE.ImageUtils.getDataURL (threeMap.image); + } + } + if (threeMap.image === undefined || threeMap.image === null) { return null; } + try { - const dataUrl = THREE.ImageUtils.getDataURL (threeMap.image); + const dataUrl = GetDataUrl (threeMap.image); const base64Buffer = OV.Base64DataURIToArrayBuffer (dataUrl); let texture = new OV.TextureMap (); let textureName = externalFileNames[threeMap.image.src]; @@ -163,7 +185,7 @@ OV.ThreeImporter = class extends OV.ImporterBase textureName = 'Embedded_' + threeMap.id.toString () + '.' + OV.GetFileExtensionFromMimeType (base64Buffer.mimeType); } texture.name = textureName; - texture.url = threeMap.image.src; + texture.url = dataUrl; texture.buffer = base64Buffer.buffer; // TODO: texture offset, rotation, scale return texture; @@ -220,9 +242,7 @@ OV.ThreeImporter = class extends OV.ImporterBase } for (let i = 0; i < child.geometry.groups.length; i++) { let group = child.geometry.groups[i]; - console.log (group); - for (let j = group.start; j < group.start + group.count; j++) { - console.log (j); + for (let j = group.start / 3; j < group.start / 3 + group.count / 3; j++) { let triangle = mesh.GetTriangle (j); triangle.SetMaterial (materialIndices[group.materialIndex]); }