3D Model File Format

Binary, little-endian static (single-frame) model format.

.3D files are static (single-frame) models. For the animated multi-frame variant, see 3DC.md.

Versions

Four versions exist: v2.6, v2.7, v4.0, v5.0. See GOG vs Original CD Differences for which directories contain which versions.

• v2.6 / v2.7 — Different header semantics and face data encoding from v4.0/v5.0.
• v5.0 — Adds Section4 (SubObject BVH).

Header (64 bytes)

v2.6/v2.7 Header Differences

The header is the same 64 bytes, but many fields have different semantics:

v2.6/v2.7 Frame Data Differences

The 16-byte frame data record has different field semantics:

v2.6/v2.7 Engine Header Handling

At load time, the software renderer copies the 64-byte header and then zeroes the offset fields 0x18, 0x1C, 0x30, 0x34, 0x38, and 0x3C. It reads the file sequentially using frame_data[0].normal_offset as the face data byte count and frame_data[0].reserved as the gap between face data and vertex data, rebuilding the section layout in memory. The raw offset fields in the file header are not used for data access.

v2.6/v2.7 Face Data Differences

Parsers must remap header fields before use. See External References for the remap logic.

Engine version gate: The shipped engine rejects files where the version byte (offset 0x01) is less than ASCII '4' (0x34). This means v2.6/v2.7 .3DC files on the game disc are not loaded at runtime — they are development-era leftovers. The engine only loads v4.0+ files. External parsers (DaveHumphrey, RGUnity, this project) support both versions for preservation completeness.

Section Layout

Sections appear in this order (offsets from header):

1. Face Data — at 0x40, num_faces variable-size records
2. Vertex Coordinates — num_vertices × 12 bytes
3. Face Normals — num_faces × 12 bytes
4. Frame Data — num_frames × 16-byte records
5. Section4 — SubObject BVH entries (when present)
6. Vertex-Normal Indirection Table — total_face_vertices × u32
7. Vertex Normals — num_vertices × 12 bytes

Frame Data

Located at offset_frame_data. Array of num_frames × 16-byte records.

For .3D files this is always a single entry pointing to the base geometry.

vertex_offset and normal_offset point to the base vertex coordinate and face normal sections (same values as header fields 0x30 and 0x34).

Face Data

Located at offset_face_data (0x40 in v4.0/v5.0; variable in v2.6/v2.7). Array of num_faces variable-size records.

v4.0 / v5.0 Face Record

Texture Decoding (v4.0 / v5.0)

Solid color (if texture_data_raw >> 20 == 0x0FFF):

• color_index = (texture_data_raw >> 8) & 0xFF
• tex_hi is always 0xFF for solid-color faces.

Textured (otherwise):

• Texture file ID (BCD-like encoding):

  tmp = (texture_data_raw >> 8) - 4000000
  ones     = (tmp / 250) % 40
  tens     = ((tmp - ones*250) / 1000) % 100
  hundreds = (tmp - ones*250 - tens*1000) / 4000
  texture_id = ones + tens + hundreds
  

  This yields the TEXBSI.### file number.

• Image sub-ID within that TEXBSI file:

  ones = (texture_data_raw & 0xFF) % 10
  tens = ((texture_data_raw & 0xFF) / 40) * 10
  image_id = ones + tens
  

v2.6 / v2.7 Face Record

Texture decode from texture_data (the u16 at offset 0x02):

• Solid color if (texture_data >> 7) < 2: color_index = texture_data & 0xFF
• Textured: texture_id = texture_data >> 7, image_id = texture_data & 0x7F

FaceVertex

UV coordinates are cumulative deltas in 4-bit fixed-point format: each vertex’s absolute U/V = previous vertex’s U/V + this delta. First vertex in the face starts from 0.

The raw i16 values are in 1/16th pixel precision. To convert to pixel-space texture coordinates, multiply by 1/16 (or divide by 16). To normalize to 0–1 UV range, divide by 16 × texture_width (U) and 16 × texture_height (V). This fixed-point scale applies identically to first-vertex values and subsequent deltas.

Face Vertex Count Distribution

Vertex Coordinates

Located at offset_vertex_coords. Array of num_vertices × 12 bytes.

v2.6/v2.7 animated .3DC files: The offset_vertex_coords header field does not point to valid vertex data. Instead, compute the vertex data offset from the first frame data entry:

face_data_end = offset_face_data + frame_data[0].normal_offset
vertex_offset = face_data_end + frame_data[0].reserved

frame_data[0].normal_offset is the face data byte count (verified across all 147 animated v2.6/v2.7 files). frame_data[0].reserved encodes the byte gap between face data and vertex data. In some files the gap is absent and vertex data begins directly at face_data_end; parsers should validate the primary offset and fall back (a raw coordinate magnitude threshold of 1 090 519 040 catches misplaced offsets while accepting all valid game coordinates). Static v2.6/v2.7 .3D files use offset_vertex_coords directly.

Each vertex is 3 × i32 (signed 32-bit integers), scaled by 1/256.0 to get world-space coordinates.

Face Normals

Located at offset_face_normals. Array of num_faces × 12 bytes.

Each normal is 3 × i32, scaled by 1/256.0. Per-face normals (one per face, not per vertex).

Vertex Normals

Located at offset_vertex_normals (header offset 0x2C). Array of num_vertices × 12 bytes.

Each entry is 3 × f32 (IEEE 754 single-precision). Per-vertex normals (unit vectors). Some entries may be NaN (bit pattern 0xFFC00000 for all three components), indicating no normal was computed for that vertex.

Vertex-Normal Indirection Table

Located at offset_normal_indices (header offset 0x28). Array of total_face_vertices × u32.

Each entry is a file offset pointing into the vertex-normal data section. Maps each face-vertex to its vertex normal, allowing faces that share a vertex to use different normals (for hard edges).

Shading Model Selection

Per-vertex shading is determined by the indirection table and vertex normal validity:

.3D files typically have the indirection table (per-face-vertex normal control). .3DC files always omit it (offset_normal_indices = 0) and fall back to direct vertex-index lookup.

Section4: SubObject BVH

Located at offset_section4 (header offset 0x1C). Contains section4_count variable-size entries. Present when offset and count are non-zero.

Each entry is a bounding-volume node with face references:

External References

• UESP: Mod:Model Files — community-maintained model-format notes and version behavior.
• uesp/redguard-3dfiletest Redguard3dFile.cpp — DaveHumphrey’s C++ parser, including v2.6/v2.7 header remap logic (ConvertHeader27).
• RGUnity/redguard-unity RG3DFile.cs — 3D model importer (face/texture decoding).