@bis-toolkit/paa 1.0.0

package/README.md

@@ -0,0 +1,90 @@
+# @bis-toolkit/paa
+
+A library for reading PAA (Real Virtuality texture format) files.
+
+Part of the [BIS Toolkit TypeScript](../../README.md) monorepo.
+
+## Features
+
+- Read PAA files
+- Support for multiple texture formats (DXT1-5, RGBA variants, AI88)
+- Mipmap handling
+- Channel swizzling
+- Compression support (LZSS, LZO)
+- Format conversion utilities
+
+## Installation
+
+```bash
+npm install @bis-toolkit/paa
+```
+
+## Usage
+
+```typescript
+import { Paa } from '@bis-toolkit/paa';
+import * as fs from 'fs';
+
+// Read a PAA file
+const buffer = fs.readFileSync('texture.paa');
+const paa = new Paa();
+paa.read(buffer);
+
+// Get RGBA pixel data
+const pixelData = paa.getArgb32PixelData(buffer, 0); // mipLevel 0
+
+// Access properties
+console.log(`Type: ${paa.type}`);
+console.log(`Mipmaps: ${paa.mipmaps.length}`);
+console.log(`Has Alpha: ${paa.isAlpha}`);
+```
+
+## Supported Formats
+
+- DXT1, DXT2, DXT3, DXT4, DXT5
+- RGBA_5551
+- RGBA_4444
+- RGBA_8888
+- AI88
+
+## API
+
+### Reading PAA Files
+
+```typescript
+import { Paa } from 'bis-toolkit/paa';
+import * as fs from 'fs';
+
+const buffer = fs.readFileSync('texture.paa');
+const paa = new Paa();
+paa.read(buffer);
+
+// Get pixel data for specific mipmap level
+const pixelData = paa.getArgb32PixelData(buffer, 0);
+
+// Access mipmap information
+for (let i = 0; i < paa.mipmaps.length; i++) {
+    const mip = paa.mipmaps[i];
+    console.log(`Mipmap ${i}: ${mip.width}x${mip.height}`);
+}
+```
+
+### Channel Swizzling
+
+```typescript
+import { RgbaSwizzle, ChannelSwizzle, ChannelSwizzler } from '@bis-toolkit/paa';
+
+// Define custom channel mapping
+const swizzle = new RgbaSwizzle();
+swizzle.swizRed = ChannelSwizzle.Blue;
+swizzle.swizBlue = ChannelSwizzle.Red;
+swizzle.swizGreen = ChannelSwizzle.Green;
+swizzle.swizAlpha = ChannelSwizzle.One; // Force alpha to 255
+
+// Apply to RGBA data
+ChannelSwizzler.apply(rgbaData, swizzle);
+```
+
+## License
+
+GPLv3 © Alpine Labs - see [LICENSE](LICENSE).

package/dist/ChannelSwizzler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Channel swizzle operations
+ */
+export declare enum ChannelSwizzle {
+    Alpha = 0,
+    Red = 1,
+    Green = 2,
+    Blue = 3,
+    InvertedAlpha = 4,
+    InvertedRed = 5,
+    InvertedGreen = 6,
+    InvertedBlue = 7,
+    One = 8
+}
+/**
+ * RGBA swizzle configuration
+ */
+export declare class RgbaSwizzle {
+    swizBlue: ChannelSwizzle;
+    swizGreen: ChannelSwizzle;
+    swizRed: ChannelSwizzle;
+    swizAlpha: ChannelSwizzle;
+    static readonly Default: RgbaSwizzle;
+    equals(other: RgbaSwizzle): boolean;
+}
+/**
+ * Utility class for applying channel swizzling to RGBA data
+ */
+export declare class ChannelSwizzler {
+    static apply(rgbaData: Uint8Array, swizzle: RgbaSwizzle): void;
+    private static transformChannel;
+}

package/dist/FormatConverter.d.ts

@@ -0,0 +1,14 @@
+import { PaaType } from './PaaType';
+import { Palette } from './Palette';
+/**
+ * Pixel format conversion utilities
+ */
+export declare class PixelFormatConversion {
+    private static setColor;
+    static argb16ToArgb32(src: Buffer | Uint8Array): Uint8Array;
+    static argb1555ToArgb32(src: Buffer | Uint8Array): Uint8Array;
+    static ai88ToArgb32(src: Buffer | Uint8Array): Uint8Array;
+    static p8ToARGB32(src: Buffer | Uint8Array, palette: Palette): Uint8Array;
+    static dxtToRgba32(data: Buffer | Uint8Array, width: number, height: number, format: string, useAlpha?: boolean): Uint8Array;
+    static convertToARGB32(data: Buffer | Uint8Array, width: number, height: number, type: PaaType): Uint8Array;
+}

package/dist/Mipmap.d.ts

@@ -0,0 +1,20 @@
+import { PaaType } from './PaaType';
+import { BinaryReader } from '@bis-toolkit/utils';
+/**
+ * Represents a single mipmap level in a PAA texture
+ */
+export declare class Mipmap {
+    width: number;
+    height: number;
+    isLzss: boolean;
+    isLzo: boolean;
+    private dataOffset;
+    private dataSize;
+    private rawData;
+    private format;
+    constructor(format: PaaType);
+    constructor(width: number, height: number, data: Buffer | Uint8Array, format: PaaType);
+    read(br: BinaryReader): void;
+    getRawPixelData(buffer: Buffer | Uint8Array): Uint8Array;
+    getRgba32PixelData(buffer: Buffer | Uint8Array): Uint8Array;
+}

package/dist/Paa.d.ts

@@ -0,0 +1,27 @@
+import { PaaType } from './PaaType';
+import { PaaColor } from './PaaColor';
+import { Palette } from './Palette';
+import { Mipmap } from './Mipmap';
+import { RgbaSwizzle } from './ChannelSwizzler';
+/**
+ * Main PAA file reader/writer class
+ */
+export declare class Paa {
+    type: PaaType;
+    isAlpha: boolean;
+    isTransparent: boolean;
+    averageColor: PaaColor | null;
+    maxColor: PaaColor | null;
+    palette: Palette;
+    mipmaps: Mipmap[];
+    channelSwizzle: RgbaSwizzle;
+    private procedure;
+    /**
+     * Read a PAA file from a buffer
+     */
+    read(buffer: Buffer | Uint8Array): void;
+    /**
+     * Get ARGB32 pixel data for a specific mipmap level
+     */
+    getArgb32PixelData(buffer: Buffer | Uint8Array, mipLevel?: number): Uint8Array;
+}

package/dist/PaaColor.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Represents a color in PAA format (ARGB)
+ */
+export declare class PaaColor {
+    private _value;
+    constructor(value: number);
+    constructor(red: number, green: number, blue: number, alpha?: number);
+    get alpha(): number;
+    get red(): number;
+    get green(): number;
+    get blue(): number;
+    get color(): number;
+    private static colorToUint;
+    static fromFloat(red: number, green: number, blue: number, alpha: number): PaaColor;
+}

package/dist/PaaType.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PAA texture format types
+ */
+export declare enum PaaType {
+    DXT1 = 65281,
+    DXT2 = 65282,
+    DXT3 = 65283,
+    DXT4 = 65284,
+    DXT5 = 65285,
+    RGBA_5551 = 5461,
+    RGBA_4444 = 17476,
+    RGBA_8888 = 34952,
+    AI88 = 32896
+}

package/dist/Palette.d.ts

@@ -0,0 +1,9 @@
+import { PaaColor } from './PaaColor';
+import { BinaryReader } from '@bis-toolkit/utils';
+/**
+ * Represents a color palette for indexed PAA formats
+ */
+export declare class Palette {
+    colors: PaaColor[];
+    read(br: BinaryReader): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PAA (Bohemia Interactive texture format) library
+ */
+export { Paa } from './Paa';
+export { PaaType } from './PaaType';
+export { PaaColor } from './PaaColor';
+export { Palette } from './Palette';
+export { Mipmap } from './Mipmap';
+export { ChannelSwizzle, RgbaSwizzle, ChannelSwizzler } from './ChannelSwizzler';
+export { PixelFormatConversion } from './FormatConverter';
+export { BinaryReader, lzoDecompress, lzssDecompress, calculateChecksum } from '@bis-toolkit/utils';