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.

Glide version gate: The Glide loader rejects model versions below v4.0. This gate belongs to RGFX.EXE; it does not describe the software engine’s v2.6/v2.7 asset path. External parsers support both model generations.

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

For v4.0/v5.0, located at offset_frame_data as an array of num_frames × 16-byte records. Software animations instead use the v2.6/v2.7 animation directory.

For v4.0/v5.0 .3D files this is a single entry pointing to the base geometry. The v2.7 static files store a zero frame count; that value does not make the static geometry empty.

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 accumulated coordinate does not wrap to 16 bits. The renderer converts each signed delta to pixel-space float before accumulation, then applies the texture descriptor scale. A signed 32-bit fixed-point sum represents every possible face exactly.

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.

Vertex Coordinates

Located at offset_vertex_coords. Array of num_vertices × 12 bytes.

v2.6/v2.7 animated .3DC files: Read positions from the software animation directory, not from a guessed offset after the faces. Compressed frames add shifted deltas to the directory’s reference frame. See software animation data. Static v2.6/v2.7 .3D files use offset_vertex_coords directly.

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). The indirection table determines the required normal records; its largest referenced index can exceed num_vertices - 1. Each record occupies 12 bytes. Without an indirection table, normals use direct vertex indexing and there are num_vertices records.

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:

For glTF export, vertex normals whose squared length is zero, subnormal or non-finite also fall back to the authored face normal. This prevents invalid normalization in renderers.

.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 followed by an ordered face-reference list. The fixed header is 18 bytes in v4.0 and 30 bytes in v5.0. The three extent floats exist only in v5.0; reading them in v4.0 consumes face references instead.

Runtime centers and radii are floating-point values obtained by dividing the stored integers by 256. The v5.0 extent factors remain unchanged. Runtime face indices are the stored indices divided by four, in the same order. The five nodes of ISLAND.ROB model HBBLD04 contain 26 ordered face references.

Each six-byte reference contains a u32 absolute file offset to the face record and a u16 face index multiplied by four. Both identify the same face in the model’s original face table. The next node begins immediately after the last reference; there is no padding between nodes.

The installed ROB archives contain 3,820 embedded models with these lists: 260 v4.0 and 3,560 v5.0 models, with 22,931 nodes and 222,322 references. Every reference’s file offset agrees with its divided-by-four face index. Lists can repeat a face across nodes: 105 models have repeated references. They need not cover every rendered face: nine palm-tree models omit faces. Preserve the lists and their order rather than reconstructing them from all rendered faces.

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).