RenderWare Texture Dictionary (.txd)

Version: 1.0
Last Updated: 2025-02-17
Author(s): samarixum

The .txd (Texture Dictionary) format is a custom EA/RenderWare variant used by The Simpsons Game on PS3. While it carries the name from standard RenderWare texture containers, it uses bespoke markers and structure instead of canonical RW chunk headers. The format stores textures with various compression and swizzling schemes.

Endianness: Mixed (see details per section).
Character Encoding: UTF-8 for texture names.

Parsing Algorithm Overview

1. Verify file starts with magic marker: 16 00 00 00 (0x00000016 LE, or "TexDict" identifier)
2. Scan entire file linearly for segment markers:
   • SIG_BLOCK_START: 03 00 00 00 14 00 00 00 2D 00 02 1C
   • Texture Name Signature pairs with data
3. Extract texture names (null-terminated UTF-8, terminated by 00 00)
4. Locate metadata block (search for preamble 01 <format_code>)
5. Parse 16-byte metadata block
6. Extract and unswizzle/decompress pixel data
7. Export to standard image format (DDS)

File Header

Segment Markers

Texture Record Structure

Scanning algorithm: Locate the texture name signature (2D 00 02 1C 00 00 00 0A) in the file. When found, extract the texture name and locate its associated metadata.

Step 1: Texture Name Extraction

1. Find pattern: 2D 00 02 1C 00 00 00 0A (8 bytes)
2. Append 12 byte skip (usually zeros)
3. Read UTF-8 characters until double null terminator (00 00)
4. Sanitize string: remove non-alphanumeric chars except ._-
5. Validate: if empty after sanitization, use fallback name texture_at_0x<OFFSET>

Example: File contains 2D 00 02 1C 00 00 00 0A 00 00 00 00 00 00 00 00 00 00 00 00 48 65 6C 6C 6F 00 00
Extract: offset +20 bytes reads "Hello" (48 65 6C 6C 6F), then double null (00 00) terminates.

Step 2: Metadata Block Location and Parsing

1. After texture name, skip zeros until a non-zero byte is encountered
2. Search forward from this point for the preamble pattern: 01 <format_code>
   • If found at offset X, metadata block starts at X - 2
   • If not found, texture is malformed; skip it
3. Read exactly 16 bytes starting from (X - 2) as the metadata block

16-Byte Metadata Block (Little-Endian)

Validation Rules

• Width and Height must both be > 0. If both are 0, skip this texture (placeholder).
• Total Pixel Data Size must be > 0 and must not exceed remaining file/segment.
• Format Code must match the code from the preamble (byte 0x03 == byte at search location + 1).
• If any validation fails, mark texture as corrupted and skip.

Pixel Data Blob

Location: Immediately after the 16-byte metadata block (at offset metadata_block_start + 16).
Length: Total Pixel Data Size bytes (from metadata).

Format Codes

Morton Unswizzling (for Swizzled Formats)

Purpose: PS3 stores textures in Morton/Z-order to improve cache coherency. Data must be reordered to linear memory layout.

Morton Encoding Function (pseudo-code):

function morton_encode_2d(x, y) {
    // Interleave bits of x and y
    x = (x | (x << 8)) & 0x00FF00FF;
    x = (x | (x << 4)) & 0x0F0F0F0F;
    x = (x | (x << 2)) & 0x33333333;
    x = (x | (x << 1)) & 0x55555555;
    
    y = (y | (y << 8)) & 0x00FF00FF;
    y = (y | (y << 4)) & 0x0F0F0F0F;
    y = (y | (y << 2)) & 0x33333333;
    y = (y | (y << 1)) & 0x55555555;
    
    return x | (y << 1);
}
    

Unswizzling Algorithm:

1. Allocate output buffer: width * height * bytes_per_pixel
2. For each y from 0 to (height - 1):
   1. For each x from 0 to (width - 1):
      1. Compute morton_index = morton_encode_2d(x, y)
      2. Source offset = morton_index * bytes_per_pixel
      3. Dest offset = (y * width + x) * bytes_per_pixel
      4. Copy bytes_per_pixel bytes from source to dest
3. Return unswizzled buffer

Mipmaps

Current Implementation: The pixel data blob contains only the base mipmap level (highest resolution). Additional mipmap levels are not separately parsed or extracted.

DDS Export: If Mip Map Count > 0, set the DDSD_MIPMAPCOUNT flag in the DDS header to inform readers that mipmaps should exist (even though only base level is exported). This maintains compatibility with engines that expect mipmap headers.

DDS Export Helper

For DXT Formats (0x52, 0x53, 0x54):

• Create DDS magic: 44 44 53 20 ("DDS ")
• Set DDSD_LINEARSIZE flag (for compressed textures)
• Set FourCC to "DXT1", "DXT3", or "DXT5" accordingly
• Calculate linear size: (width/4) * (height/4) * block_size where block_size = 8 (DXT1) or 16 (DXT3/DXT5)

For RGBA Formats (0x86 after unswizzle):

• Create DDS header for uncompressed RGBA888
• Set pitch = width * 4
• No FourCC needed (use pixel format flags)

Complete Parsing Example (Pseudocode)

function parse_txd(file_data) {
    textures = []
    
    // Validate header
    if (read_u32_le(0) != 0x16) return []
    
    // Scan entire file for texture name signatures
    pos = 0
    while (pos < len(file_data)) {
        if (matches_pattern(file_data, pos, "2D 00 02 1C 00 00 00 0A")) {
            pos += 8
            pos += 12  // Skip known padding
            
            // Read texture name
            name_start = pos
            while (file_data[pos:pos+2] != "00 00") {
                pos += 1
            }
            name = sanitize(file_data[name_start:pos])
            pos += 2  // Skip terminator
            
            // Find metadata
            while (pos < len(file_data) && file_data[pos] == 0x00) {
                pos += 1
            }
            
            search_pos = pos
            while (search_pos < min(pos + 4096, len(file_data))) {
                if (file_data[search_pos] == 0x01) {
                    format_code = file_data[search_pos + 1]
                    meta_start = search_pos - 2
                    break
                }
                search_pos += 1
            }
            
            if (meta_start not found) continue  // Malformed
            
            // Parse metadata
            metadata = read_metadata_block(file_data, meta_start)
            width = metadata.width
            height = metadata.height
            fmt = metadata.format_code
            data_size = metadata.total_pixel_data_size
            
            if (width == 0 || height == 0) continue  // Placeholder
            
            // Extract pixel data
            pixel_data_start = meta_start + 16
            pixel_data = file_data[pixel_data_start : pixel_data_start + data_size]
            
            // Unswizzle if needed
            if (fmt == 0x86) {    // Swizzled BGRA
                pixel_data = unswizzle_morton(pixel_data, width, height, 4)
            } else if (fmt == 0x02) {  // Swizzled indexed
                pixel_data = unswizzle_morton(pixel_data, width, height, 1)
            }
            // For DXT formats (0x52/0x53/0x54), use as-is
            
            textures.append({
                name: name,
                width: width,
                height: height,
                format: fmt,
                data: pixel_data
            })
            
            pos = pixel_data_start + data_size
        } else {
            pos += 1
        }
    }
    
    return textures
}