rw-parser-ng 2.0.0

package/lib/src/renderware/ifp/IfpParser.js

@@ -0,0 +1,196 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IfpParser = void 0;
+var RwFile_1 = require("../RwFile");
+var IfpData_1 = require("./IfpData");
+var IfpParser = /** @class */ (function (_super) {
+    __extends(IfpParser, _super);
+    function IfpParser(buffer) {
+        return _super.call(this, buffer) || this;
+    }
+    IfpParser.prototype.parse = function () {
+        var fileSignature = this.readString(4);
+        this.setPosition(0);
+        var version;
+        if (fileSignature === 'ANP3') {
+            version = IfpData_1.IfpVersion.ANP3;
+            return this.readAnp3();
+        }
+        else if (fileSignature === 'ANPK') {
+            version = IfpData_1.IfpVersion.ANPK;
+            return this.readAnpk();
+        }
+        else {
+            version = IfpData_1.IfpVersion.UNSUPPORTED;
+            throw new Error('Unsupported IFP version');
+        }
+    };
+    IfpParser.prototype.readAnp3 = function () {
+        this.skip(4); // ANP3
+        var size = this.readUint32();
+        var name = this.readString(24);
+        var animationsCount = this.readUint32();
+        var animations = [];
+        for (var i = 0; i < animationsCount; i++) {
+            animations.push(this.readAnp3Animation());
+        }
+        return {
+            version: IfpData_1.IfpVersion.ANP3,
+            name: name,
+            animations: animations
+        };
+    };
+    IfpParser.prototype.readAnp3Animation = function () {
+        var name = this.readString(24);
+        var bonesCount = this.readUint32();
+        this.skip(4); // keyframes_size
+        this.skip(4); // unk
+        var bones = [];
+        for (var i = 0; i < bonesCount; i++) {
+            bones.push(this.readAnp3Bone());
+        }
+        return { name: name, bones: bones };
+    };
+    IfpParser.prototype.readAnp3Bone = function () {
+        var name = this.readString(24);
+        var keyframeTypeNum = this.readUint32();
+        var keyframesCount = this.readUint32();
+        var keyframeType = keyframeTypeNum === 4 ? 'KRT0' : 'KR00';
+        var boneId = this.readInt32();
+        var keyframes = [];
+        for (var i = 0; i < keyframesCount; i++) {
+            var qx = this.readInt16() / 4096.0;
+            var qy = this.readInt16() / 4096.0;
+            var qz = this.readInt16() / 4096.0;
+            var qw = this.readInt16() / 4096.0;
+            var time = this.readInt16();
+            var px = 0, py = 0, pz = 0;
+            if (keyframeType[2] === 'T') {
+                px = this.readInt16() / 1024.0;
+                py = this.readInt16() / 1024.0;
+                pz = this.readInt16() / 1024.0;
+            }
+            keyframes.push({
+                time: time,
+                position: { x: px, y: py, z: pz },
+                rotation: { w: qw, x: qx, y: qy, z: qz },
+                scale: { x: 1, y: 1, z: 1 }
+            });
+        }
+        return {
+            name: name,
+            keyframeType: keyframeType,
+            useBoneId: true,
+            boneId: boneId,
+            keyframes: keyframes
+        };
+    };
+    IfpParser.prototype.readAnpk = function () {
+        this.skip(4); // ANPK
+        var size = this.readUint32();
+        this.skip(4); // INFO
+        var infoLen = this.readUint32();
+        var animationsCount = this.readUint32();
+        var name = this.readString(infoLen - 4);
+        var nameAlignLen = (4 - infoLen % 4) % 4;
+        this.skip(nameAlignLen);
+        var animations = [];
+        for (var i = 0; i < animationsCount; i++) {
+            animations.push(this.readAnpkAnimation());
+        }
+        return {
+            version: IfpData_1.IfpVersion.ANPK,
+            name: name,
+            animations: animations
+        };
+    };
+    IfpParser.prototype.readAnpkAnimation = function () {
+        this.skip(4); // NAME
+        var nameLen = this.readUint32();
+        var name = this.readString(nameLen);
+        this.skip((4 - nameLen % 4) % 4);
+        this.skip(4); // DGAN
+        this.skip(4); // animation_size
+        this.skip(4); // INFO
+        this.skip(4); // unk_size
+        var bonesCount = this.readUint32();
+        this.skip(4); // unk
+        var bones = [];
+        for (var i = 0; i < bonesCount; i++) {
+            bones.push(this.readAnpkBone());
+        }
+        return { name: name, bones: bones };
+    };
+    IfpParser.prototype.readAnpkBone = function () {
+        this.skip(4); // CPAN
+        this.skip(4); // bone_len
+        this.skip(4); // ANIM
+        var animLen = this.readUint32();
+        var name = this.readString(28);
+        var keyframesCount = this.readUint32();
+        this.skip(8); // unk
+        var boneId = 0;
+        var useBoneId = animLen === 44;
+        if (useBoneId) {
+            boneId = this.readInt32();
+        }
+        else {
+            this.skip(8); // sibling_x, sibling_y
+        }
+        var keyframeType = 'K000';
+        var keyframes = [];
+        if (keyframesCount > 0) {
+            keyframeType = this.readString(4);
+            this.skip(4); // keyframes_len
+            for (var i = 0; i < keyframesCount; i++) {
+                var qx = this.readFloat();
+                var qy = this.readFloat();
+                var qz = this.readFloat();
+                var qw = this.readFloat();
+                var px = 0, py = 0, pz = 0;
+                if (keyframeType[2] === 'T') {
+                    px = this.readFloat();
+                    py = this.readFloat();
+                    pz = this.readFloat();
+                }
+                var sx = 1, sy = 1, sz = 1;
+                if (keyframeType[3] === 'S') {
+                    sx = this.readFloat();
+                    sy = this.readFloat();
+                    sz = this.readFloat();
+                }
+                var time = this.readFloat();
+                keyframes.push({
+                    time: time,
+                    position: { x: px, y: py, z: pz },
+                    rotation: { w: qw, x: qx, y: qy, z: qz },
+                    scale: { x: sx, y: sy, z: sz }
+                });
+            }
+        }
+        return {
+            name: name,
+            keyframeType: keyframeType,
+            useBoneId: useBoneId,
+            boneId: boneId,
+            keyframes: keyframes
+        };
+    };
+    return IfpParser;
+}(RwFile_1.RwFile));
+exports.IfpParser = IfpParser;

package/lib/src/renderware/txd/TxdParser.d.ts

@@ -0,0 +1,38 @@
+import { RwFile } from '../RwFile';
+export interface RwTxd {
+    textureDictionary: RwTextureDictionary;
+}
+export interface RwTextureDictionary {
+    textureCount: number;
+    textureNatives: RwTextureNative[];
+}
+export interface RwTextureNative {
+    platformId: number;
+    filterMode: number;
+    uAddressing: number;
+    vAddressing: number;
+    textureName: string;
+    maskName: string;
+    rasterFormat: number;
+    d3dFormat: string;
+    width: number;
+    height: number;
+    depth: number;
+    mipmapCount: number;
+    rasterType: number;
+    alpha: boolean;
+    cubeTexture: boolean;
+    autoMipMaps: boolean;
+    compressed: boolean;
+    mipmaps: number[][];
+}
+export declare class TxdParser extends RwFile {
+    constructor(stream: Buffer);
+    parse(): RwTxd;
+    readTextureDictionary(): RwTextureDictionary;
+    readTextureNative(): RwTextureNative;
+    readPalette(paletteType: number, depth: number): Uint8Array;
+    getBitmapWithPalette(paletteType: number, depth: number, hasAlpha: boolean, raster: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+    getBitmapWithDXT(dxtType: string, raster: Uint8Array, width: number, height: number): Uint8Array;
+    getBitmapWithRasterFormat(rasterFormat: number, raster: Uint8Array, width: number, height: number): Uint8Array;
+}

package/lib/src/renderware/txd/TxdParser.js

@@ -0,0 +1,185 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxdParser = void 0;
+var RwFile_1 = require("../RwFile");
+var ImageDecoder_1 = require("../utils/ImageDecoder");
+var ImageFormatEnums_1 = require("../utils/ImageFormatEnums");
+var TxdParser = /** @class */ (function (_super) {
+    __extends(TxdParser, _super);
+    function TxdParser(stream) {
+        return _super.call(this, stream) || this;
+    }
+    TxdParser.prototype.parse = function () {
+        return {
+            textureDictionary: this.readTextureDictionary(),
+        };
+    };
+    TxdParser.prototype.readTextureDictionary = function () {
+        this.readSectionHeader();
+        this.readSectionHeader();
+        var textureCount = this.readUint16();
+        this.skip(2);
+        var textureNatives = [];
+        for (var i = 0; i < textureCount; i++) {
+            var textureNative = this.readTextureNative();
+            textureNatives.push(textureNative);
+        }
+        // Skip unused extension
+        this.skip(this.readSectionHeader().sectionSize);
+        return { textureCount: textureCount, textureNatives: textureNatives };
+    };
+    TxdParser.prototype.readTextureNative = function () {
+        this.readSectionHeader();
+        this.readSectionHeader();
+        // TODO: Structure this part better
+        // Texture format
+        var platformId = this.readUint32();
+        var flags = this.readUint32();
+        var filterMode = (flags & 0xFF);
+        var uAddressing = (flags & 0xF00) >> 8;
+        var vAddressing = (flags & 0xF000) >> 12;
+        var textureName = this.readString(32);
+        var maskName = this.readString(32);
+        // Raster format
+        var rasterFormat = this.readUint32();
+        var d3dFormat = this.readString(4);
+        var width = this.readUint16();
+        var height = this.readUint16();
+        var depth = this.readUint8();
+        var mipmapCount = this.readUint8();
+        var rasterType = this.readUint8();
+        var compressionFlags = this.readUint8(); // Is "dxtType" for III/VC
+        // SA
+        var alpha = (compressionFlags & (1 << 0)) !== 0;
+        var cubeTexture = (compressionFlags & (1 << 1)) !== 0;
+        var autoMipMaps = (compressionFlags & (1 << 2)) !== 0;
+        var compressed = (compressionFlags & (1 << 3)) !== 0;
+        var paletteType = (rasterFormat >> 13) & 3;
+        var mipWidth = width;
+        var mipHeight = height;
+        var mipmaps = [];
+        var palette = (paletteType !== ImageFormatEnums_1.PaletteType.PALETTE_NONE ? this.readPalette(paletteType, depth) : new Uint8Array(0));
+        for (var i = 0; i < mipmapCount; i++) {
+            var rasterSize = this.readUint32();
+            var raster = this.read(rasterSize);
+            if (i == 0) {
+                // Raw RGBA presentation
+                var bitmap = void 0;
+                if (palette.length !== 0) {
+                    var rasterFormatsWithoutAlpha = [
+                        ImageFormatEnums_1.RasterFormat.RASTER_565,
+                        ImageFormatEnums_1.RasterFormat.RASTER_LUM,
+                        ImageFormatEnums_1.RasterFormat.RASTER_888,
+                        ImageFormatEnums_1.RasterFormat.RASTER_555
+                    ];
+                    var hasAlpha = ((platformId === ImageFormatEnums_1.PlatformType.D3D9 && alpha) || (platformId == ImageFormatEnums_1.PlatformType.D3D8 && !rasterFormatsWithoutAlpha.includes(rasterFormat)));
+                    bitmap = Array.from(this.getBitmapWithPalette(paletteType, depth, hasAlpha, raster, palette, width, height));
+                }
+                else if (platformId === ImageFormatEnums_1.PlatformType.D3D8 && compressionFlags !== 0) {
+                    bitmap = Array.from(this.getBitmapWithDXT('DXT' + compressionFlags, raster, width, height));
+                }
+                else if (platformId === ImageFormatEnums_1.PlatformType.D3D9 && compressed) {
+                    bitmap = Array.from(this.getBitmapWithDXT(d3dFormat, raster, width, height));
+                }
+                else {
+                    bitmap = Array.from(this.getBitmapWithRasterFormat(rasterFormat, raster, width, height));
+                }
+                mipmaps.push(bitmap);
+            }
+            mipWidth /= 2;
+            mipHeight /= 2;
+        }
+        // Skip extension
+        this.skip(this.readSectionHeader().sectionSize);
+        return {
+            platformId: platformId,
+            filterMode: filterMode,
+            uAddressing: uAddressing,
+            vAddressing: vAddressing,
+            textureName: textureName,
+            maskName: maskName,
+            rasterFormat: rasterFormat,
+            d3dFormat: d3dFormat,
+            width: width,
+            height: height,
+            depth: depth,
+            mipmapCount: mipmapCount,
+            rasterType: rasterType,
+            alpha: alpha,
+            cubeTexture: cubeTexture,
+            autoMipMaps: autoMipMaps,
+            compressed: compressed,
+            mipmaps: mipmaps,
+        };
+    };
+    TxdParser.prototype.readPalette = function (paletteType, depth) {
+        var size = (paletteType === ImageFormatEnums_1.PaletteType.PALETTE_8 ? 1024 : (depth === 4 ? 64 : 128));
+        return this.read(size);
+    };
+    TxdParser.prototype.getBitmapWithPalette = function (paletteType, depth, hasAlpha, raster, palette, width, height) {
+        if (paletteType !== ImageFormatEnums_1.PaletteType.PALETTE_8 && depth == 4) {
+            return (hasAlpha
+                ? ImageDecoder_1.ImageDecoder.pal4(raster, palette, width, height)
+                : ImageDecoder_1.ImageDecoder.pal4NoAlpha(raster, palette, width, height));
+        }
+        return (hasAlpha
+            ? ImageDecoder_1.ImageDecoder.pal8(raster, palette, width, height)
+            : ImageDecoder_1.ImageDecoder.pal8NoAlpha(raster, palette, width, height));
+    };
+    TxdParser.prototype.getBitmapWithDXT = function (dxtType, raster, width, height) {
+        switch (dxtType) {
+            case ImageFormatEnums_1.D3DFormat.D3D_DXT1:
+                return ImageDecoder_1.ImageDecoder.bc1(raster, width, height);
+            case ImageFormatEnums_1.D3DFormat.D3D_DXT2:
+                return ImageDecoder_1.ImageDecoder.bc2(raster, width, height, true);
+            case ImageFormatEnums_1.D3DFormat.D3D_DXT3:
+                return ImageDecoder_1.ImageDecoder.bc2(raster, width, height, false);
+            case ImageFormatEnums_1.D3DFormat.D3D_DXT4:
+                return ImageDecoder_1.ImageDecoder.bc3(raster, width, height, true);
+            case ImageFormatEnums_1.D3DFormat.D3D_DXT5:
+                return ImageDecoder_1.ImageDecoder.bc3(raster, width, height, false);
+            // LUM8_A8 has compressed flag
+            case ImageFormatEnums_1.D3DFormat.D3DFMT_A8L8:
+                return ImageDecoder_1.ImageDecoder.lum8a8(raster, width, height);
+            default:
+                return new Uint8Array(0);
+        }
+    };
+    TxdParser.prototype.getBitmapWithRasterFormat = function (rasterFormat, raster, width, height) {
+        switch (rasterFormat) {
+            case ImageFormatEnums_1.RasterFormat.RASTER_1555:
+                return ImageDecoder_1.ImageDecoder.bgra1555(raster, width, height);
+            case ImageFormatEnums_1.RasterFormat.RASTER_565:
+                return ImageDecoder_1.ImageDecoder.bgra565(raster, width, height);
+            case ImageFormatEnums_1.RasterFormat.RASTER_4444:
+                return ImageDecoder_1.ImageDecoder.bgra4444(raster, width, height);
+            case ImageFormatEnums_1.RasterFormat.RASTER_LUM:
+                return ImageDecoder_1.ImageDecoder.lum8(raster, width, height);
+            case ImageFormatEnums_1.RasterFormat.RASTER_8888:
+                return ImageDecoder_1.ImageDecoder.bgra8888(raster, width, height);
+            case ImageFormatEnums_1.RasterFormat.RASTER_888:
+                return ImageDecoder_1.ImageDecoder.bgra888(raster, width, height);
+            case ImageFormatEnums_1.RasterFormat.RASTER_555:
+                return ImageDecoder_1.ImageDecoder.bgra555(raster, width, height);
+            default:
+                return new Uint8Array(0);
+        }
+    };
+    return TxdParser;
+}(RwFile_1.RwFile));
+exports.TxdParser = TxdParser;

package/lib/src/renderware/utils/ImageDecoder.d.ts

@@ -0,0 +1,23 @@
+export declare class ImageDecoder {
+    static readUInt16LE(buf: Uint8Array, offset: number): number;
+    static readUInt32LE(buf: Uint8Array, offset: number): number;
+    static decode565(bits: number): [number, number, number];
+    static decode555(bits: number): [number, number, number];
+    static decode1555(bits: number): [number, number, number, number];
+    static decode4444(bits: number): [number, number, number, number];
+    static bc1(data: Uint8Array, width: number, height: number): Uint8Array;
+    static bc2(data: Uint8Array, width: number, height: number, premultiplied: boolean): Uint8Array;
+    static bc3(data: Uint8Array, width: number, height: number, premultiplied: boolean): Uint8Array;
+    static bgra1555(data: Uint8Array, width: number, height: number): Uint8Array;
+    static bgra4444(data: Uint8Array, width: number, height: number): Uint8Array;
+    static bgra555(data: Uint8Array, width: number, height: number): Uint8Array;
+    static bgra565(data: Uint8Array, width: number, height: number): Uint8Array;
+    static bgra888(data: Uint8Array, width: number, height: number): Uint8Array;
+    static bgra8888(data: Uint8Array, width: number, height: number): Uint8Array;
+    static lum8(data: Uint8Array, width: number, height: number): Uint8Array;
+    static lum8a8(data: Uint8Array, width: number, height: number): Uint8Array;
+    static pal4(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+    static pal4NoAlpha(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+    static pal8(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+    static pal8NoAlpha(data: Uint8Array, palette: Uint8Array, width: number, height: number): Uint8Array;
+}