@zephyr3d/scene 0.1.0

package/dist/asset/loaders/gltf/gltf_loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf_loader.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/asset/loaders/gltf/helpers.js

@@ -0,0 +1,314 @@
+var ComponentType;
+(function(ComponentType) {
+    ComponentType[ComponentType["UNKNOWN"] = 0] = "UNKNOWN";
+    ComponentType[ComponentType["BYTE"] = 5120] = "BYTE";
+    ComponentType[ComponentType["UBYTE"] = 5121] = "UBYTE";
+    ComponentType[ComponentType["SHORT"] = 5122] = "SHORT";
+    ComponentType[ComponentType["USHORT"] = 5123] = "USHORT";
+    ComponentType[ComponentType["INT"] = 5124] = "INT";
+    ComponentType[ComponentType["UINT"] = 5125] = "UINT";
+    ComponentType[ComponentType["FLOAT"] = 5126 // GL.FLOAT
+    ] = "FLOAT";
+})(ComponentType || (ComponentType = {}));
+/** @internal */ class GLTFAccessor {
+    bufferView;
+    byteOffset;
+    componentType;
+    normalized;
+    count;
+    type;
+    max;
+    min;
+    sparse;
+    name;
+    _typedView;
+    _filteredView;
+    _normalizedFilteredView;
+    _normalizedTypedView;
+    constructor(accessorInfo){
+        this.bufferView = accessorInfo.bufferView;
+        this.byteOffset = accessorInfo.byteOffset ?? 0;
+        this.componentType = accessorInfo.componentType;
+        this.normalized = !!accessorInfo.normalized;
+        this.count = accessorInfo.count;
+        this.type = accessorInfo.type;
+        this.max = accessorInfo.max;
+        this.min = accessorInfo.min;
+        this.sparse = accessorInfo.sparse;
+        this.name = accessorInfo.name;
+        this._typedView = null;
+        this._filteredView = null;
+        this._normalizedFilteredView = null;
+        this._normalizedTypedView = null;
+    }
+    getTypedView(gltf) {
+        if (this._typedView) {
+            return this._typedView;
+        }
+        if (this.bufferView !== undefined) {
+            const bufferView = gltf.bufferViews[this.bufferView];
+            const buffer = gltf._loadedBuffers[bufferView.buffer];
+            const byteOffset = this.byteOffset + (bufferView.byteOffset ?? 0);
+            const componentSize = this.getComponentSize(this.componentType);
+            const componentCount = this.getComponentCount(this.type);
+            let arrayLength = 0;
+            if (bufferView.byteStride !== undefined && bufferView.byteStride !== 0) {
+                if (componentSize !== 0) {
+                    arrayLength = bufferView.byteStride / componentSize * (this.count - 1) + componentCount;
+                } else {
+                    console.warn("Invalid component type in accessor '" + (this.name ? this.name : '') + "'");
+                }
+            } else {
+                arrayLength = this.count * componentCount;
+            }
+            if (arrayLength * componentSize > buffer.byteLength - byteOffset) {
+                arrayLength = (buffer.byteLength - byteOffset) / componentSize;
+                console.warn("Count in accessor '" + (this.name ? this.name : '') + "' is too large.");
+            }
+            switch(this.componentType){
+                case 5120:
+                    this._typedView = new Int8Array(buffer, byteOffset, arrayLength);
+                    break;
+                case 5121:
+                    this._typedView = new Uint8Array(buffer, byteOffset, arrayLength);
+                    break;
+                case 5122:
+                    this._typedView = new Int16Array(buffer, byteOffset, arrayLength);
+                    break;
+                case 5123:
+                    this._typedView = new Uint16Array(buffer, byteOffset, arrayLength);
+                    break;
+                case 5124:
+                    this._typedView = new Int32Array(buffer, byteOffset, arrayLength);
+                    break;
+                case 5125:
+                    this._typedView = new Uint32Array(buffer, byteOffset, arrayLength);
+                    break;
+                case 5126:
+                    this._typedView = new Float32Array(buffer, byteOffset, arrayLength);
+                    break;
+            }
+        } else if (this.sparse !== undefined) {
+            this._typedView = this.createView();
+        }
+        if (!this._typedView) {
+            console.warn('Failed to convert buffer view to typed view!: ' + this.bufferView);
+        } else if (this.sparse !== undefined) {
+            this.applySparse(gltf, this._typedView);
+        }
+        return this._typedView;
+    }
+    // getNormalizedTypedView provides an alternative view to the accessors data,
+    // where quantized data is already normalized. This is useful if the data is not passed
+    // to vertexAttribPointer but used immediately (like e.g. animations)
+    getNormalizedTypedView(gltf) {
+        if (this._normalizedTypedView) {
+            return this._normalizedTypedView;
+        }
+        const typedView = this.getTypedView(gltf);
+        this._normalizedTypedView = this.normalized ? GLTFAccessor.dequantize(typedView, this.componentType) : typedView;
+        return this._normalizedTypedView;
+    }
+    // getDeinterlacedView provides a view to the accessors data in form of
+    // a TypedArray. In contrast to getTypedView, getDeinterlacedView deinterlaces
+    // data, i.e. stripping padding and unrelated components from the array. It then
+    // only contains the data of the accessor
+    getDeinterlacedView(gltf) {
+        if (this._filteredView) {
+            return this._filteredView;
+        }
+        const componentSize = this.getComponentSize(this.componentType);
+        const componentCount = this.getComponentCount(this.type);
+        const arrayLength = this.count * componentCount;
+        let func = 'getFloat32';
+        switch(this.componentType){
+            case 5120:
+                this._filteredView = new Int8Array(arrayLength);
+                func = 'getInt8';
+                break;
+            case 5121:
+                this._filteredView = new Uint8Array(arrayLength);
+                func = 'getUint8';
+                break;
+            case 5122:
+                this._filteredView = new Int16Array(arrayLength);
+                func = 'getInt16';
+                break;
+            case 5123:
+                this._filteredView = new Uint16Array(arrayLength);
+                func = 'getUint16';
+                break;
+            case 5124:
+                this._filteredView = new Int32Array(arrayLength);
+                func = 'getInt32';
+                break;
+            case 5125:
+                this._filteredView = new Uint32Array(arrayLength);
+                func = 'getUint32';
+                break;
+            case 5126:
+                this._filteredView = new Float32Array(arrayLength);
+                func = 'getFloat32';
+                break;
+            default:
+                return;
+        }
+        if (this.bufferView !== undefined) {
+            const bufferView = gltf.bufferViews[this.bufferView];
+            const buffer = gltf._loadedBuffers[bufferView.buffer];
+            const byteOffset = this.byteOffset + (bufferView.byteOffset ?? 0);
+            const stride = bufferView.byteStride !== undefined && bufferView.byteStride !== 0 ? bufferView.byteStride : componentCount * componentSize;
+            const dataView = new DataView(buffer, byteOffset, this.count * stride);
+            for(let i = 0; i < arrayLength; ++i){
+                const offset = Math.floor(i / componentCount) * stride + i % componentCount * componentSize;
+                this._filteredView[i] = dataView[func](offset, true);
+            }
+        } else if (this.sparse !== undefined) {
+            this._filteredView = this.createView();
+        }
+        if (this.sparse !== undefined) {
+            this.applySparse(gltf, this._filteredView);
+        }
+        return this._filteredView;
+    }
+    createView() {
+        const size = this.count * this.getComponentCount(this.type);
+        if (this.componentType == 5120) return new Int8Array(size);
+        if (this.componentType == 5121) return new Uint8Array(size);
+        if (this.componentType == 5122) return new Int16Array(size);
+        if (this.componentType == 5123) return new Uint16Array(size);
+        if (this.componentType == 5124) return new Int32Array(size);
+        if (this.componentType == 5125) return new Uint32Array(size);
+        if (this.componentType == 5126) return new Float32Array(size);
+        return undefined;
+    }
+    // getNormalizedDeinterlacedView provides an alternative view to the accessors data,
+    // where quantized data is already normalized. This is useful if the data is not passed
+    // to vertexAttribPointer but used immediately (like e.g. animations)
+    getNormalizedDeinterlacedView(gltf) {
+        if (this._normalizedFilteredView) {
+            return this._normalizedFilteredView;
+        }
+        const filteredView = this.getDeinterlacedView(gltf);
+        this._normalizedFilteredView = this.normalized ? GLTFAccessor.dequantize(filteredView, this.componentType) : filteredView;
+        return this._normalizedFilteredView;
+    }
+    applySparse(gltf, view) {
+        // Gather indices.
+        const indicesBufferView = gltf.bufferViews[this.sparse.indices.bufferView];
+        const indicesBuffer = gltf._loadedBuffers[indicesBufferView.buffer];
+        const indicesByteOffset = this.sparse.indices.byteOffset + (indicesBufferView.byteOffset ?? 0);
+        const indicesComponentSize = this.getComponentSize(this.sparse.indices.componentType);
+        let indicesComponentCount = 1;
+        if (indicesBufferView.byteStride !== undefined && indicesBufferView.byteStride !== 0) {
+            indicesComponentCount = indicesBufferView.byteStride / indicesComponentSize;
+        }
+        const indicesArrayLength = this.sparse.count * indicesComponentCount;
+        let indicesTypedView;
+        switch(this.sparse.indices.componentType){
+            case 5121:
+                indicesTypedView = new Uint8Array(indicesBuffer, indicesByteOffset, indicesArrayLength);
+                break;
+            case 5123:
+                indicesTypedView = new Uint16Array(indicesBuffer, indicesByteOffset, indicesArrayLength);
+                break;
+            case 5125:
+                indicesTypedView = new Uint32Array(indicesBuffer, indicesByteOffset, indicesArrayLength);
+                break;
+        }
+        // Gather values.
+        const valuesBufferView = gltf.bufferViews[this.sparse.values.bufferView];
+        const valuesBuffer = gltf._loadedBuffers[valuesBufferView.buffer];
+        const valuesByteOffset = this.sparse.values.byteOffset + (valuesBufferView.byteOffset ?? 0);
+        const valuesComponentSize = this.getComponentSize(this.componentType);
+        let valuesComponentCount = this.getComponentCount(this.type);
+        if (valuesBufferView.byteStride !== undefined && valuesBufferView.byteStride !== 0) {
+            valuesComponentCount = valuesBufferView.byteStride / valuesComponentSize;
+        }
+        const valuesArrayLength = this.sparse.count * valuesComponentCount;
+        let valuesTypedView;
+        switch(this.componentType){
+            case 5120:
+                valuesTypedView = new Int8Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+            case 5121:
+                valuesTypedView = new Uint8Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+            case 5122:
+                valuesTypedView = new Int16Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+            case 5123:
+                valuesTypedView = new Uint16Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+            case 5124:
+                valuesTypedView = new Int32Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+            case 5125:
+                valuesTypedView = new Uint32Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+            case 5126:
+                valuesTypedView = new Float32Array(valuesBuffer, valuesByteOffset, valuesArrayLength);
+                break;
+        }
+        // Overwrite values.
+        for(let i = 0; i < this.sparse.count; ++i){
+            for(let k = 0; k < valuesComponentCount; ++k){
+                view[indicesTypedView[i] * valuesComponentCount + k] = valuesTypedView[i * valuesComponentCount + k];
+            }
+        }
+    }
+    // dequantize can be used to perform the normalization from WebGL2 vertexAttribPointer explicitly
+    static dequantize(typedArray, componentType) {
+        switch(componentType){
+            case 5120:
+                return new Float32Array(typedArray).map((c)=>Math.max(c / 127.0, -1.0));
+            case 5121:
+                return new Float32Array(typedArray).map((c)=>c / 255.0);
+            case 5122:
+                return new Float32Array(typedArray).map((c)=>Math.max(c / 32767.0, -1.0));
+            case 5123:
+                return new Float32Array(typedArray).map((c)=>c / 65535.0);
+            default:
+                return typedArray;
+        }
+    }
+    getComponentCount(type) {
+        switch(type){
+            case 'SCALAR':
+                return 1;
+            case 'VEC2':
+                return 2;
+            case 'VEC3':
+                return 3;
+            case 'VEC4':
+                return 4;
+            case 'MAT2':
+                return 4;
+            case 'MAT3':
+                return 9;
+            case 'MAT4':
+                return 16;
+            default:
+                return 0;
+        }
+    }
+    getComponentSize(componentType) {
+        switch(componentType){
+            case 5120:
+            case 5121:
+                return 1;
+            case 5122:
+            case 5123:
+                return 2;
+            case 5124:
+            case 5125:
+            case 5126:
+                return 4;
+            default:
+                return 0;
+        }
+    }
+}
+
+export { ComponentType, GLTFAccessor };
+//# sourceMappingURL=helpers.js.map

package/dist/asset/loaders/gltf/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/asset/loaders/hdr/hdr.js

@@ -0,0 +1,175 @@
+import { AbstractTextureLoader } from '../loader.js';
+import { floatToHalf, packFloat3 } from '@zephyr3d/base';
+import { Application } from '../../../app.js';
+
+const _f16one = floatToHalf(1);
+/**
+ * The HDR texture loader
+ * @internal
+ */ class HDRLoader extends AbstractTextureLoader {
+    supportExtension(ext) {
+        return ext === '.hdr';
+    }
+    supportMIMEType(mimeType) {
+        return mimeType === 'image/hdr';
+    }
+    async load(assetManager, url, mimeType, data, srgb, samplerOptions, texture) {
+        let format;
+        for (const fmt of [
+            'rg11b10uf',
+            'rgba16f',
+            'rgba32f',
+            'rgba8unorm'
+        ]){
+            const info = Application.instance.device.getDeviceCaps().textureCaps.getTextureFormatInfo(fmt);
+            if (info && info.filterable && info.renderable) {
+                format = fmt;
+                break;
+            }
+        }
+        const textureData = await this.loadHDR(new Uint8Array(data), format);
+        const options = {
+            texture: texture,
+            samplerOptions
+        };
+        const tex = Application.instance.device.createTexture2D(format, textureData.width, textureData.height, options);
+        tex.update(textureData.dataFloat, 0, 0, textureData.width, textureData.height);
+        return tex;
+    }
+    _rgbeToFloat32(buffer) {
+        const length = buffer.byteLength >> 2;
+        const result = new Float32Array(length * 4);
+        for(let i = 0; i < length; i++){
+            const s = Math.pow(2, buffer[i * 4 + 3] - (128 + 8));
+            result[i * 4] = buffer[i * 4] * s;
+            result[i * 4 + 1] = buffer[i * 4 + 1] * s;
+            result[i * 4 + 2] = buffer[i * 4 + 2] * s;
+            result[i * 4 + 3] = 1;
+        }
+        return result;
+    }
+    _rgbeToFloat16(buffer) {
+        const length = buffer.byteLength >> 2;
+        const result = new Uint16Array(length * 4);
+        for(let i = 0; i < length; i++){
+            const s = Math.pow(2, buffer[i * 4 + 3] - (128 + 8));
+            result[i * 4 + 0] = floatToHalf(Math.max(-65504, Math.min(buffer[i * 4] * s, 65504)));
+            result[i * 4 + 1] = floatToHalf(Math.max(-65504, Math.min(buffer[i * 4 + 1] * s, 65504)));
+            result[i * 4 + 2] = floatToHalf(Math.max(-65504, Math.min(buffer[i * 4 + 2] * s, 65504)));
+            result[i * 4 + 3] = _f16one;
+        }
+        return result;
+    }
+    _rgbeToR11G11B10(buffer) {
+        const length = buffer.byteLength >> 2;
+        const result = new Uint32Array(length);
+        for(let i = 0; i < length; i++){
+            const s = Math.pow(2, buffer[i * 4 + 3] - (128 + 8));
+            const r = buffer[i * 4] * s;
+            const g = buffer[i * 4 + 1] * s;
+            const b = buffer[i * 4 + 2] * s;
+            result[i] = packFloat3(r, g, b);
+        }
+        return result;
+    }
+    /*
+    Decode: rgb = pow(6 * rgbm.rgb * rgbm.a, 2.2);
+   */ _rgbeToRGBM(buffer) {
+        const length = buffer.byteLength >> 2;
+        const result = new Uint8Array(length * 4);
+        for(let i = 0; i < length; i++){
+            const s = Math.pow(2, buffer[i * 4 + 3] - (128 + 8));
+            const r = Math.pow(buffer[i * 4] * s, 1 / 2.2);
+            const g = Math.pow(buffer[i * 4 + 1] * s, 1 / 2.2);
+            const b = Math.pow(buffer[i * 4 + 2] * s, 1 / 2.2);
+            const rgbMax = Math.max(r, g, b);
+            const M = Math.ceil(255 * rgbMax / 6) / 255;
+            const t = M * 6;
+            result[i * 4] = Math.ceil(255 * r / t);
+            result[i * 4 + 1] = Math.ceil(255 * g / t);
+            result[i * 4 + 2] = Math.ceil(255 * b / t);
+            result[i * 4 + 3] = Math.ceil(255 * Math.min(M, 1));
+        }
+        return result;
+    }
+    async loadHDR(buffer, dstFormat) {
+        let header = '';
+        let pos = 0;
+        const d8 = buffer;
+        let format = undefined;
+        // read header.
+        while(!header.match(/\n\n[^\n]+\n/g))header += String.fromCharCode(d8[pos++]);
+        // check format.
+        format = header.match(/FORMAT=(.*)$/m);
+        if (format.length < 2) {
+            return undefined;
+        }
+        format = format[1];
+        if (format != '32-bit_rle_rgbe') {
+            console.warn('unknown format : ' + format);
+            return null;
+        }
+        // parse resolution
+        let rez = header.split(/\n/).reverse();
+        if (rez.length < 2) {
+            return undefined;
+        }
+        rez = rez[1].split(' ');
+        if (rez.length < 4) {
+            return undefined;
+        }
+        const width = Number(rez[3]) * 1, height = Number(rez[1]) * 1;
+        // Create image.
+        const img = new Uint8Array(width * height * 4);
+        let ipos = 0;
+        // Read all scanlines
+        for(let j = 0; j < height; j++){
+            const scanline = [];
+            let rgbe = d8.slice(pos, pos += 4);
+            const isNewRLE = rgbe[0] == 2 && rgbe[1] == 2 && rgbe[2] == (width >> 8 & 0xFF) && rgbe[3] == (width & 0xFF);
+            if (isNewRLE && width >= 8 && width < 32768) {
+                for(let i = 0; i < 4; i++){
+                    let ptr = i * width;
+                    const ptr_end = (i + 1) * width;
+                    let buf = undefined;
+                    let count = undefined;
+                    while(ptr < ptr_end){
+                        buf = d8.slice(pos, pos += 2);
+                        if (buf[0] > 128) {
+                            count = buf[0] - 128;
+                            while(count-- > 0)scanline[ptr++] = buf[1];
+                        } else {
+                            count = buf[0] - 1;
+                            scanline[ptr++] = buf[1];
+                            while(count-- > 0)scanline[ptr++] = d8[pos++];
+                        }
+                    }
+                }
+                for(let i = 0; i < width; i++){
+                    img[ipos++] = scanline[i + 0 * width];
+                    img[ipos++] = scanline[i + 1 * width];
+                    img[ipos++] = scanline[i + 2 * width];
+                    img[ipos++] = scanline[i + 3 * width];
+                }
+            } else {
+                pos -= 4;
+                for(let i = 0; i < width; i++){
+                    rgbe = d8.slice(pos, pos += 4);
+                    img[ipos++] = rgbe[0];
+                    img[ipos++] = rgbe[1];
+                    img[ipos++] = rgbe[2];
+                    img[ipos++] = rgbe[3];
+                }
+            }
+        }
+        const imageFloatBuffer = dstFormat === 'rgba32f' ? this._rgbeToFloat32(img) : dstFormat === 'rgba16f' ? this._rgbeToFloat16(img) : dstFormat === 'rg11b10uf' ? this._rgbeToR11G11B10(img) : this._rgbeToRGBM(img);
+        return {
+            dataFloat: imageFloatBuffer,
+            width: width,
+            height: height
+        };
+    }
+}
+
+export { HDRLoader };
+//# sourceMappingURL=hdr.js.map

package/dist/asset/loaders/hdr/hdr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdr.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/asset/loaders/image/tga_Loader.js

@@ -0,0 +1,117 @@
+import { AbstractTextureLoader } from '../loader.js';
+import { Application } from '../../../app.js';
+
+/**
+ * TGA image loader
+ * @internal
+ */ class TGALoader extends AbstractTextureLoader {
+    supportExtension(ext) {
+        return ext === '.tga';
+    }
+    supportMIMEType(mimeType) {
+        return mimeType === 'image/tga';
+    }
+    parseTGA(content, sRGB, noMipmap, texture) {
+        const dataView = new DataView(content);
+        const p = [
+            0,
+            0,
+            0,
+            0
+        ];
+        do {
+            let skip = 0;
+            const idLength = dataView.getUint8(0);
+            skip += idLength;
+            const colorMapType = dataView.getUint8(1);
+            if (colorMapType !== 0 && colorMapType !== 1) {
+                break;
+            }
+            const dataTypeCode = dataView.getUint8(2);
+            if (dataTypeCode !== 2 && dataTypeCode !== 10) {
+                break;
+            }
+            const colorMapLength = dataView.getUint16(5, true);
+            skip += colorMapLength * colorMapType;
+            const width = dataView.getUint16(12, true);
+            const height = dataView.getUint16(14, true);
+            const bpp = dataView.getUint8(16);
+            if (bpp !== 16 && bpp !== 24 && bpp !== 32) {
+                break;
+            }
+            let dataOffset = 18 + skip;
+            const bytesPerPixel = bpp / 8;
+            const pixels = new Uint8Array(width * height * 4);
+            let n = 0;
+            while(n < width * height){
+                if (dataTypeCode === 2) {
+                    for(let i = 0; i < bytesPerPixel; i++){
+                        p[i] = dataView.getUint8(dataOffset++);
+                    }
+                    this.mergeBytes(pixels, n * 4, p, bytesPerPixel);
+                    n++;
+                } else {
+                    const t = dataView.getUint8(dataOffset++);
+                    for(let i = 0; i < bytesPerPixel; i++){
+                        p[i] = dataView.getUint8(dataOffset++);
+                    }
+                    const j = t & 0x7f;
+                    this.mergeBytes(pixels, n * 4, p, bytesPerPixel);
+                    n++;
+                    if (t & 0x80) {
+                        for(let i = 0; i < j; i++){
+                            this.mergeBytes(pixels, n * 4, p, bytesPerPixel);
+                            n++;
+                        }
+                    } else {
+                        for(let i = 0; i < j; i++){
+                            for(let k = 0; k < bytesPerPixel; k++){
+                                p[i] = dataView.getUint8(dataOffset++);
+                            }
+                            this.mergeBytes(pixels, n * 4, p, bytesPerPixel);
+                            n++;
+                        }
+                    }
+                }
+            }
+            const opt = {
+                texture
+            };
+            if (noMipmap) {
+                opt.samplerOptions = {
+                    mipFilter: 'none'
+                };
+            }
+            const tex = Application.instance.device.createTexture2D(sRGB ? 'rgba8unorm-srgb' : 'rgba8unorm', width, height, opt);
+            tex.update(pixels, 0, 0, width, height);
+            return tex;
+        }while (false)
+        throw new Error(`Unsupported TGA file format`);
+    }
+    mergeBytes(dest, offset, pixel, numBytes) {
+        if (numBytes === 4) {
+            dest[offset + 0] = pixel[2];
+            dest[offset + 1] = pixel[1];
+            dest[offset + 2] = pixel[0];
+            dest[offset + 3] = pixel[3];
+        } else if (numBytes === 3) {
+            dest[offset + 0] = pixel[2];
+            dest[offset + 1] = pixel[1];
+            dest[offset + 2] = pixel[0];
+            dest[offset + 3] = 255;
+        } else if (numBytes === 2) {
+            dest[offset + 0] = (pixel[1] & 0x7c) << 1;
+            dest[offset + 1] = (pixel[1] & 0x03) << 6 | (pixel[0] & 0xe0) >> 2;
+            dest[offset + 2] = (pixel[0] & 0x1f) << 3;
+            dest[offset + 3] = pixel[1] & 0x80;
+        }
+    }
+    async load(assetManager, filename, mimeType, data, srgb, samplerOptions, texture) {
+        return new Promise((resolve, reject)=>{
+            resolve(this.parseTGA(data, srgb, samplerOptions?.mipFilter === 'none', texture));
+        });
+    }
+}
+
+export { TGALoader };
+//# sourceMappingURL=tga_Loader.js.map

package/dist/asset/loaders/image/tga_Loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tga_Loader.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/asset/loaders/image/webimage_loader.js

@@ -0,0 +1,50 @@
+import { AbstractTextureLoader } from '../loader.js';
+import { Application } from '../../../app.js';
+
+/**
+ * Web image loader
+ * @internal
+ */ class WebImageLoader extends AbstractTextureLoader {
+    supportExtension(ext) {
+        return ext === '.jpg' || ext === '.jpeg' || ext === '.png';
+    }
+    supportMIMEType(mimeType) {
+        return mimeType === 'image/jpg' || mimeType === 'image/jpeg' || mimeType === 'image/png';
+    }
+    async load(assetManager, filename, mimeType, data, srgb, samplerOptions, texture) {
+        return new Promise((resolve, reject)=>{
+            if (!mimeType) {
+                reject('unknown image file type');
+            }
+            const src = URL.createObjectURL(new Blob([
+                data
+            ], {
+                type: mimeType
+            }));
+            const img = document.createElement('img');
+            img.src = src;
+            img.onload = function() {
+                createImageBitmap(img, {
+                    premultiplyAlpha: 'none'
+                }).then((bm)=>{
+                    const options = {
+                        texture: texture,
+                        samplerOptions
+                    };
+                    const tex = Application.instance.device.createTexture2DFromImage(bm, srgb, options);
+                    if (tex) {
+                        resolve(tex);
+                    } else {
+                        reject('create texture from image element failed');
+                    }
+                });
+            };
+            img.onerror = (err)=>{
+                reject(err);
+            };
+        });
+    }
+}
+
+export { WebImageLoader };
+//# sourceMappingURL=webimage_loader.js.map

package/dist/asset/loaders/image/webimage_loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webimage_loader.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}