Oblivion NIF: what is really in the archive¶
A census of all .nif files in Oblivion - Meshes.bsa. Measured 2026-09-24 with a one-off Python
script while preparing the plan: only the NIF headers were parsed, not the blocks themselves. For STAT
meshes it was reproduced by the project's code (T1.3a, the "STAT meshes" section below); the census of
the whole archive was not repeated in code.
Versions: the main one is 20.0.0.4, not 20.0.0.5¶
Before this census the whole plan, the documentation and the constant mesh_convert::NIF_VERSION_TES4 =
0x1400_0005 assumed 20.0.0.5. That is wrong.
| Version | Header string | Files | Share |
|---|---|---|---|
0x14000004 |
Gamebryo File Format, Version 20.0.0.4 |
7,282 | 90.7% |
0x0A020000 |
Gamebryo File Format, Version 10.2.0.0 |
490 | 6.1% |
0x14000005 |
Gamebryo File Format, Version 20.0.0.5 |
100 | 1.2% |
0x0A01006A |
… 10.1.0.106 |
82 | |
0x0A000100 |
NetImmerse File Format, Version 10.0.1.0 |
41 | |
0x0A000102 |
NetImmerse File Format, Version 10.0.1.2 |
23 | |
0x0A010065 |
… 10.1.0.101 |
8 | |
0x04000002 |
4.0.0.2 — already Morrowind's format | 4 | |
0x0303000D, 0x04020100 |
3.3.0.13, 4.2.1.0 | 1 + 1 | |
| total | 8,032 |
The 10.x files are not exotic and live in the same folders as the bulk: architecture (189 files of
10.2.0.0), dungeons (82 + 24), clutter (62 + 12), rocks (42), plants and others. How many of them
are used by STAT was not measured (T1.3a).
User versions in 20.0.0.x: (user_version, user_version_2) = (11, 11) in 5,885 files, (10, 11) in
1,497.
The 20.0.0.4/20.0.0.5 header — the layout that read all 7,382 files¶
Not a single failure. All numbers are little-endian.
header string up to and including '\n'
u32 version 0x14000004 or 0x14000005
u8 endianness 1 = little-endian
u32 user_version 10 or 11
u32 number of blocks
u32 user_version_2 11
3 × (u8 length + bytes) export info: author, process, process
u16 number of block types
N × (u32 length + bytes) block type names
u16 × number of blocks type index of each block
u32 number of groups (0 in the checked files)
There are no block sizes in the header (the size array appears only in 20.2.0.5). So a block of an unknown type cannot be skipped: without knowing its layout, the start of the next one cannot be found. The reader must know every type that occurs in a file, or the file cannot be read as a whole. Hence the order of work: first a census of types (this page, T1.3a), then a reader for exactly those.
Strings in 20.0.0.x are inline (u32 length + bytes); there is no string table yet (it appears in 20.1). Block references are an i32 index, −1 means "none".
Block types¶
112 types. The top ones by the number of files they occur in:
| Files | Blocks | Type | What to do with it |
|---|---|---|---|
| 7,281 | 24,021 | NiNode |
carried over |
| 7,250 | 28,957 | NiMaterialProperty |
carried over, fields by version |
| 7,234 | 28,292 | NiTexturingProperty |
carried over: base and glow slots, drop the rest |
| 7,234 | 29,203 | NiSourceTexture |
carried over, the path is rewritten (T1.6) |
| 6,475 | 38,372 | NiTriStripsData |
→ NiTriShapeData (T1.4) |
| 6,437 | 31,818 | NiTriStrips |
→ NiTriShape (T1.4) |
| 6,342 | 13,407 | NiStringExtraData |
parse; whether to carry depends on the content |
| 6,217 | 6,217 | BSXFlags |
drop (Oblivion engine flags) |
| 6,048 | 7,484 | bhkCollisionObject |
collision root (T1.7) |
| 5,988 | 29,939 | NiBinaryExtraData |
tangent space, drop |
| 4,578 | 4,659 | NiVertexColorProperty |
carried over |
| 4,246 | 4,299 | bhkNiTriStripsShape |
the main collision shape of statics — refers to a NiTriStripsData |
| 4,230 | 4,281 | bhkMoppBvTreeShape |
a wrapper, drop the MOPP code, take the nested shape |
| 3,834 | 5,493 | bhkRigidBody |
a body; no transform |
| 2,292 | 2,786 | bhkRigidBodyT |
a body with a transform (translation and rotation in havok units) |
| 1,205 | 1,977 | bhkConvexVerticesShape |
a convex hull — build triangles |
| 1,023 | 1,148 | NiAlphaProperty |
carried over |
| 923 | 1,958 | NiTriShape |
carried over |
| 923 | 1,956 | NiTriShapeData |
carried over |
| 726 | 1,590 | NiSkinInstance/NiSkinData/NiSkinPartition |
skinning — not statics, later |
| 605 | 1,360 | bhkBoxShape |
a primitive → 12 triangles |
| 605 | 609 | NiStencilProperty |
carried over (two-sidedness) |
| 393 | 6,411 | NiTransformInterpolator |
animation — not for M1 |
| 356 | NiControllerManager, NiControllerSequence, NiMultiTargetTransformController, NiDefaultAVObjectPalette, NiStringPalette |
animated objects — not for M1 | |
| 278 | 590 | bhkLimitedHingeConstraint |
constraints — drop |
| 198 | 1,132 | bhkCapsuleShape |
a primitive → triangles |
| 175 | 180 | bhkListShape |
a list of shapes, walk the children |
| 123 | 126 | NiZBufferProperty |
carried over |
| 114 | NiParticleSystem, NiPSys* |
particles — deliberately postponed | |
| 102 | 102 | NiSpecularProperty |
carried over |
| 93 | 332 | bhkConvexTransformShape |
a transform over a shape |
| 64 | 64 | BSFurnitureMarker |
furniture, phase 2 |
| 46 | 46 | bhkSphereShape |
a primitive → triangles |
| 41 | 138 | NiBillboardNode |
phase 2 |
| 39 | 39 | BSBound |
drop |
What is absent altogether: BSShaderPPLightingProperty and the other BSShader*. Those are Fallout
3 / New Vegas blocks (20.2.0.7). The earlier plan built T1.5 around them; in Oblivion the material is set
by the same NiMaterialProperty + NiTexturingProperty as in Morrowind, only the fields differ by
version. This makes T1.5 much simpler.
There is also no bhkPackedNiTriStripsShape, which was previously thought to be the main collision shape.
STAT meshes¶
Measured 2026-09-24 by the project's code: mesh_convert/tests/real_census.rs
(census_of_stat_meshes, 32 s in debug), the headers are parsed by mesh_convert::read::header. The
MODL of every STAT in Oblivion.esm + meshes\ → Oblivion - Meshes.bsa.
STAT in total |
6,014 |
with empty data / without MODL |
1 / 1 (the same record, 0008060C) |
mesh found in Oblivion - Meshes.bsa |
5,176 |
| mesh not found there | 836: 784 are in DLCShiveringIsles - Meshes.bsa (in this build Shivering Isles is merged into Oblivion.esm), 52 nowhere — test junk judging by the names (TestFireSorting, Rommprototype, Daedrictest…) |
| unique meshes in the main archive | 5,104 |
Versions over unique meshes:
| Version | Meshes |
|---|---|
| 20.0.0.4 | 4,712 (92.3%) |
| 10.2.0.0 | 327 |
| 10.1.0.106 | 31 |
| 10.0.1.0 / 10.0.1.2 / 10.1.0.101 | 17 / 6 / 8 |
| 4.0.0.2 | 3 |
STAT meshes have no 20.0.0.5 at all — only 20.0.0.4. The 10.x files are 389 of 5,104 = 7.6%,
below the "stop" threshold of the T1.3a card (10%): the reader targets one version family, and 10.x meshes
go to the unsupported list. The headers of all 4,712 files of 20.0.0.4 parse without errors. The add-on
archives did not take part in the block type census (only in the search for the 784 paths above).
Block types in the 4,712 readable meshes (meshes / blocks); the test prints the full list. The types of the M1 set are the first 15 rows:
| Meshes | Blocks | Type |
|---|---|---|
| 4,712 | 6,228 | NiNode |
| 4,712 | 23,700 | NiMaterialProperty |
| 4,708 | 23,336 | NiTexturingProperty |
| 4,708 | 23,573 | NiSourceTexture |
| 4,667 | 31,709 | NiTriStripsData |
| 4,661 | 25,548 | NiTriStrips |
| 4,484 | 4,484 | BSXFlags |
| 4,445 | 4,710 | bhkCollisionObject |
| 4,376 | 5,562 | NiStringExtraData |
| 4,282 | 24,124 | NiBinaryExtraData |
| 3,938 | 3,958 | bhkNiTriStripsShape |
| 3,928 | 3,948 | bhkMoppBvTreeShape |
| 3,625 | 3,660 | NiVertexColorProperty |
| 2,887 | 3,070 | bhkRigidBody |
| 1,571 | 1,640 | bhkRigidBodyT |
The most common outside the M1 set: NiAlphaProperty (495 meshes), bhkConvexVerticesShape (357),
NiStencilProperty (270), bhkBoxShape (146), animation (NiControllerManager and
NiTransformInterpolator, 54–67), NiTriShape/NiTriShapeData (61), NiSpecularProperty (58),
BSFurnitureMarker (39), skinning (26), NiPSys* particles (up to 20 meshes).
3,518 of 4,712 meshes (74.7%) consist only of the M1 set. Candidates for the slice (the M1 set,
exactly one NiTriStrips, a texture and a bhkCollisionObject) — 478.
The M1 slice: 10 meshes¶
Selection: candidates by number of blocks (fewer first), one per folder, then by the file's full folder. Paths are in the archive, lower case.
| EDID | Path | Blocks | user_version |
|---|---|---|---|
VinyardBarrelCartStopper |
meshes\clutter\vinyard\vinyardbarrelcartstopper.nif |
12 | 10/11 |
SkCastleFloor01 |
meshes\architecture\castle\skingrad\skcastlefloor01.nif |
13 | 10/11 |
RFRubbleHallsChunk01 |
meshes\dungeons\fortruins\dungeon\decorubble\rfrubblehallschunk01.nif |
13 | 11/11 |
OBCaveOutdoorPlug |
meshes\oblivion\caves\obcavedoorplug.nif |
13 | 10/11 |
JMRock01 |
meshes\rocks\jeralmountains\jmrock01.nif |
13 | 11/11 |
CypressKnee01 |
meshes\landscape\cypressknee01.nif |
14 | 10/11 |
RFHallNAgedDoor03 |
meshes\dungeons\fortruins\dungeon\doorsportcullis\rfnageddoor03.nif |
13 | 10/11 |
RFCastleRoofBeams02 |
meshes\dungeons\fortruins\exterior\castle\rfcastleroofbeams02.nif |
13 | 11/11 |
CoffinLid01 |
meshes\dungeons\misc\coffinlid01.nif |
13 | 10/11 |
kvatchBrokenGateHousing |
meshes\architecture\castle\kvatch\brokengatehousing.nif |
14 | 10/11 |
All are 20.0.0.4. The list is deterministic (sorted by number of blocks and path) but depends on the
version of Oblivion.esm; with a different build of the data the test picks different meshes.
What this census does not cover¶
- The layout of the blocks themselves: every field of every type for versions 20.0.0.4/20.0.0.5 — that
is T1.3, from the niftools
nif.xmland checked on real files. - DLC archives and 10.x files — their headers were not parsed here.
- Texture paths in
NiSourceTexture(with a folder or without) — needed for T1.6, to be measured in T1.3a.
20.0.0.4 block layouts (user_version 10/11, BSVER 11)¶
Confirmed 2026-09-24 by the test mesh_convert/tests/real_blocks.rs: 3,518 of 3,518 STAT
meshes (M1-set types only, version 20.0.0.4) are parsed by the mesh_convert::read code, with the cursor
after the last block and the footer exactly at the end of the file, 44 s in debug. Blocks parsed:
NiTriStripsData 25,189, NiTriStrips 19,859, NiBinaryExtraData 18,893, NiMaterialProperty 18,733,
NiTexturingProperty 18,467, NiSourceTexture 18,425, NiNode 3,791, NiStringExtraData 3,679,
bhkNiTriStripsShape 3,374, bhkCollisionObject 3,374, bhkMoppBvTreeShape 3,369, BSXFlags 3,367,
NiVertexColorProperty 2,848, bhkRigidBody 2,243, bhkRigidBodyT 1,131. All NiSourceTextures are
external (18,425 of 18,425), none are internal.
The source of the layouts is the niftools nif.xml (github.com/niftools/nifxml), checked against the
data. No differences between 20.0.0.4 and 20.0.0.5 were found — the second version does not occur in
STAT meshes at all, so 20.0.0.5 is not verified. Strings are u32 length + bytes, bool is 1
byte, a reference is i32 (−1 — none), little-endian byte order. Blocks follow each other with no
prefixes.
A trap in reading nif.xml: until="V" includes V. PS2 L and PS2 K in TexDesc are until
10.4.0.1, so in 20.0.0.4 they are absent; read by mistake, they shifted the whole file by four bytes,
and the reader failed on NiSourceTexture in 3,515 of 3,518 files. It was caught not by the parse but by
the "cursor at the end of the file" check.
Notation: ref — i32; [ref] — a u32 count and that many refs; str — u32 length + bytes.
Common parts¶
| Block | Fields in order |
|---|---|
NiObjectNET |
name: str, extra_data: [ref], controller: ref |
NiAVObject (+NiObjectNET) |
flags: u16, translation: f32×3, rotation: f32×9, scale: f32, properties: [ref], collision_object: ref |
NiAVObject has no velocity and no bounding volume (they are "until 4.2.2.0"). The reader does not
interpret the order of the rotation matrix's 9 numbers: in nif.xml the fields go m11 m21 m31 m12 …,
the labels differ between editions, so nine f32s are stored in file order. How T1.4 handles them — see
"Geometry conversion" below.
Blocks of the M1 set¶
| Block | Fields (after the common parts) |
|---|---|
NiNode (NiAVObject) |
children: [ref], effects: [ref] |
NiTriStrips (NiAVObject) |
data: ref, skin_instance: ref, has_shader: bool; if set — shader_name: str, shader_extra: i32 |
NiTriStripsData |
group_id: i32, num_vertices: u16, keep_flags: u8, compress_flags: u8, has_vertices: bool → vertices: f32×3 × N; data_flags: u16; has_normals: bool → normals: f32×3 × N, and with data_flags & 4096 also tangents and bitangents (f32×3 × N each); bound: f32×3 + f32; has_colors: bool → f32×4 × N; UV sets: data_flags & 63 of them, f32×2 × N each; consistency: u16; additional_data: ref; num_triangles: u16; num_strips: u16; lengths: u16 × num_strips; has_points: bool → u16 points by the lengths |
NiMaterialProperty (NiObjectNET) |
ambient, diffuse, specular, emissive: f32×3 each; glossiness: f32, alpha: f32. No flags, no emissive_mult |
NiVertexColorProperty (NiObjectNET) |
flags: u16, vertex_mode: u32, lighting_mode: u32 |
NiAlphaProperty (NiObjectNET) |
flags: u16 (AlphaFlags), threshold: u8. Added in T1.5 (it was not in the M1 set); checked: 3,872 of 3,872 meshes read to the last byte |
NiTexturingProperty (NiObjectNET) |
apply_mode: u32, texture_count: u32, slots base, dark, detail, gloss, glow: bool (+TexDesc); with count > 5 — bump: bool (+TexDesc, luma_scale, luma_offset: f32, matrix: f32×4); decals 0–3 — bool (+TexDesc), decal N with count > 6+N; num_shader_textures: u32 and per one bool (+TexDesc, map_id: u32). There is no flags field |
TexDesc |
source: ref, clamp_mode: u32, filter_mode: u32, uv_set: u32, has_transform: bool → translation f32×2, scale f32×2, rotation f32, method u32, center f32×2. No PS2 L/K |
NiSourceTexture (NiObjectNET) |
use_external: u8, file_name: str, pixel_data: ref (−1 for an external one), format_prefs: u32×3, is_static: u8, direct_render: bool |
NiStringExtraData |
name: str, string: str |
NiBinaryExtraData |
name: str, size: u32, bytes |
BSXFlags |
name: str, flags: u32 |
bhkCollisionObject |
target: ref, flags: u16, body: ref |
bhkRigidBody, bhkRigidBodyT |
one layout: shape: ref, havok_filter: u8 u8 u16 (layer, flags, group), 20 bytes of world info, 4 bytes of bhkEntityCInfo, then bhkRigidBodyCInfo550_660: 4 + filter (4) + 4 + 4 + 4 bytes, translation f32×4, rotation f32×4 (xyzw), 32 bytes of velocities, 48 bytes of inertia tensor, 16 bytes of center of mass, mass, two dampings, friction, restitution, three limits (f32), motion_system, deactivator, solver, quality_type (u8 each), 12 bytes; constraints: [ref], body_flags: u32 |
bhkMoppBvTreeShape |
shape: ref, 12 bytes, scale: f32, mopp_size: u32, mopp_offset: f32×4, mopp_size bytes of code |
bhkNiTriStripsShape |
material: u32, radius: f32, 20 bytes, grow_by: u32, scale: f32×4, strips_data: [ref], filters: [u8 u8 u16] (count — u32) |
Footer: a u32 number of roots, then that many refs.
The reader fails on any type outside this table: UnsupportedBlock { index, type_name }. Coverage — see
"Coverage (T1.3w)" at the end of the file.
Geometry conversion (T1.4): NiTriStrips → NiTriShape¶
Code: mesh_convert::geometry::convert. The output is a tes3::nif::NiStream (NIF 4.0.0.2) with
NiNode, NiTriShape, NiTriShapeData. Materials and textures (T1.5, T1.6) and collision (T1.7) are in
the sections below; at the time of T1.4 the output shapes had no properties.
Measured 2026-09-24 by the test mesh_convert/tests/real_convert.rs on 3,518 STAT meshes of the M1
set (60 s in debug; after T1.5 the same test runs on 3,872 meshes — the set plus NiAlphaProperty — and
gives 22,334 shapes, 14,561,206 triangles in strips, 7,145,040 degenerate, 7,416,166 in the output,
winding 99.96% of 8,764,250, niftest 0 failures):
| meshes converted, failures | 3,518, 0 |
shapes (NiTriShape) |
19,859 |
| triangles in strips, Σ(length − 2) | 13,379,560 |
| degenerate ones dropped | 6,574,547 (49.1%) |
| triangles in the output | 6,805,013 = 13,379,560 − 6,574,547 |
| the triangle count read back from the output files matches the counter | in all 3,518 |
niftest (OpenMW 0.51.0) on all output files |
0 Failed to read messages |
control: niftest on a truncated output file |
rejected (two error lines in its output) |
| winding: the face normal from the vertices agrees with the averaged vertex normal | 99.96% of 7,992,583 |
The winding check is independent of the conversion code: if the strip parity were lost, about half would agree. Half of the "degenerate" ones are not an error: Oblivion's strips are stitched with degenerate triangles, and they are redundant in a triangle list.
Strip → triangles rule. Triangle i of strip s is (s[i], s[i+1], s[i+2]); for odd i the first
two indices are swapped. A triangle with two equal indices is dropped, but the parity is counted by the
position in the strip, not by the number of remaining ones.
What is carried over: the NiNode hierarchy (name, flags, translation, rotation, scale, children),
and for shapes — vertices, normals, vertex colors, the first UV set, the bounding sphere. A shared
block referenced by two parents stays shared (one in the file, two references to it).
What is dropped and why:
| What | Why |
|---|---|
BSXFlags, NiStringExtraData, NiBinaryExtraData |
Oblivion engine data (flags, markers, tangents); Morrowind does not read them |
tangents and bitangents inside NiTriStripsData |
the vanilla engine does not use normal maps |
| UV sets from the second one on | Morrowind's NiTexturingProperty has one slot, it takes the first set |
| degenerate strip triangles | strip stitching; redundant in a triangle list |
bhkCollisionObject and everything after it |
carried at the root (T1.7), see below; not at the root — skipped |
| controllers, skinning references | not statics |
NiAVObject.properties |
carried over (T1.5): material, texturing, alpha, vertex colors; the reader does not read other property types yet |
Rotation. The nine f32s are copied without reordering: NiMatrix3 is serialised identically in
20.0.0.4 and 4.0.0.2, and tes3::nif reads and writes Mat3 byte for byte. The test
rotation_bytes_are_copied_verbatim only proves the bytes are preserved; that the semantics match is
not verified on an object with a known rotation (needs NifSkope or the engine: the owner checks).
Rotated nodes are not singled out in the M1 slice yet.
Limits:
* More than 65,535 triangles in one shape — ConvertError::TooManyTriangles (the counter field in
NiTriShapeData is u16). Never occurred in STAT meshes.
* A node name outside cp1252 is an error on writing, not a silent replacement. The reader reads names as
Latin-1 (byte → character U+00xx), so bytes 0x80–0x9F in a name would give a write error; names in
vanilla meshes are ASCII.
* A node or shape name starting with Collision (nine characters, case-insensitive) gets an ob_
prefix (mesh_convert::node_name): a root with such a name — CollisionBox01,
CollisionBoxStatic — crashes the Construction Set (tes3.md, "A node named
Collision…").
* The order of objects in the output is decided by tes3::nif (depth-first from the roots); the result
is byte-for-byte deterministic (the output_is_deterministic test).
Material (T1.5): 20.0.0.4 → 4.0.0.2 properties¶
Code: mesh_convert::material (mapping one block) and geometry (linking; shared blocks are converted
once). Oblivion has no BSShader*: the material is set by the same properties as in Morrowind, so it
is carried over rather than reinvented.
| Block | 20.0.0.4 → 4.0.0.2 |
|---|---|
NiMaterialProperty |
colors (ambient, diffuse, specular, emissive), glossiness → shine, alpha — as is. The source has no flags, the output gets 0 |
NiVertexColorProperty |
flags, vertex_mode, lighting_mode — as is (values outside 0–2 and 0–1 are an error) |
NiAlphaProperty |
flags masked with 0x1FFF (bits 13–15 — No Sorter, Clone Unique, Editor Alpha Threshold — exist only in Bethesda's 20.x), threshold → test_ref |
NiTexturingProperty |
the base and glow slots remain; apply_mode, clamp_mode, filter_mode — as is (filter 6 ANISOTROPIC → Trilerp: Morrowind has no such filter); the slot's texture_index (UV set) = 0. Dark, detail, gloss, bump, decal, shader slots and the UV transform (has_transform) are dropped and counted in Stats |
NiSourceTexture |
an external file, format_prefs → pixel_layout, use_mipmaps, alpha_format, is_static. Internal textures (pixels inside the NIF) are an error |
NiObjectNET of any property |
the name is carried; extra data and the controller are not |
The output NiTexturingProperty always has 7 slots (base, dark, detail, gloss, glow, bump, decal 0),
with only base and (if present) glow occupied. That vanilla Morrowind properties have exactly seven slots
is not verified (not compared against Morrowind.bsa meshes); the tes3::nif reader and niftest
accept any number.
A single UV set. Morrowind geometry has one, and all slots refer to it, so the output gets the set the
shape's base texture asks for (TexDesc.uv_set), not "the first". This difference did not show up in
the data: 0 of 22,334 shapes ask for a non-zero set, and in 0 shapes does glow use a different set
than base. The code handles such a case and is covered by a synthetic test.
Measured 2026-09-24 (mesh_convert/tests/real_convert.rs, 3,872 STAT meshes): 44,700 properties in
the output (shared blocks once per mesh), 20,390 NiSourceTextures; 0 texture slots dropped, 0 UV
transforms; niftest — 0 Failed to read messages.
Not verified: how the material looks in the game and in NifSkope; that the slot's
unknown_flag1/2 (0 by default in tes3::nif) do not affect the vanilla engine.
Textures (T1.6): names and the copy list¶
Code: mesh_convert::textures (target_of, TextureRegistry); a mesh's result is
Converted.textures: Vec<TextureCopy { source_path, target_name }>. The files are copied not by
mesh_convert but by a stage in back2mw (from the texture BSAs through tes4_read::bsa).
Naming scheme (part of output compatibility, like the ID scheme): the path relative to textures\,
lower case, \ → _, prefix ob_, the extension as in the source.
textures\architecture\anvil\anvilwall01.dds → ob_architecture_anvil_anvilwall01.dds. Input without a
leading textures\, with / and in any case gives the same name. Non-ASCII, an empty path, .. — an
error. A normal map (*_n.*) in a carried slot is an error (it must not be copied, and a reference
without a file must not be left); there are 0 such cases in the data.
The scheme is not injective: a_b\c.dds and a\b_c.dds both give ob_a_b_c.dds. The
TextureRegistry remembers which path a name belongs to, and a second, different path is
TextureError::Collision; no suffixes for separating them were invented. The registry is shared by the
whole run (convert_with), so it also finds collisions between textures of different meshes.
Measured 2026-09-24 (real_convert.rs, 3,872 STAT meshes): 20,390 texture references, 1,483
unique names, 0 collisions, the longest name is 74 characters. Textures missing from
Oblivion - Textures - Compressed.bsa: 4 (architecture\cheydinhal\cheydinhalstonewall.dds,
architecture\imperialcity\icinterior\ictowerrosette01.dds,
clutter\fightersguild\f_guildshieldbacking.dds, dungeons\sewers\sewerfloor02.dds) — the DLC archives
were not searched; for the copy stage this is a warning with the mesh path, not a failure.
Not verified (risks): whether the vanilla engine accepts a 74-character texture name (vanilla's bare
names are short); that a .dds extension in a NIF will be found (inferred from vanilla writing .tga
while the archive holds .dds — tes3.md); none of this has been checked in the game.
Collision (T1.7): bhk* → RootCollisionNode¶
Code: mesh_convert::collision::extract, the output is assembled in geometry. The chain for statics:
bhkCollisionObject → bhkRigidBody(T) → (bhkMoppBvTreeShape →) bhkNiTriStripsShape →
NiTriStripsData. Each NiTriStripsData of the shape gives one NiTriShape (vertices, triangles and the
bounding sphere only) under a RootCollisionNode, as the root's last child.
The vertex transformation rule: v' = R · (v × 7) + t × 7, where R and t are the body's rotation
(quaternion xyzw) and translation, only for bhkRigidBodyT; for a plain bhkRigidBody they are
not applied.
The ×7 multiplier was measured, not taken on faith. The test mesh_convert/tests/real_collision.rs
(2026-09-24, 3,872 STAT meshes) compares the extent of the collision with the extent of the visible
geometry in the output stream:
meshes with a RootCollisionNode |
3,522 of 3,872 |
| collision shapes / triangles | 5,546 / 1,291,726 |
meshes of the M1 slice (10 of 10) with a RootCollisionNode |
yes |
| meshes compared (visible geometry extent > 0 on all axes) | 3,462 |
| within 10% on all axes | 2,925 (84.5%) |
| the same if the vertices were not multiplied by 7 | 0 |
| median ratio on axes x / y / z | 1.000 / 1.000 / 1.000 |
Histogram of the collision/visible geometry ratio by axis (<0.5, 0.5–0.9, 0.9–1.1, 1.1–2, >2):
x — 86, 106, 3,310, 13, 7; y — 78, 135, 3,289, 12, 6; z — 150, 107, 3,205, 0, 2. In the remaining ~15% of
meshes the collision is noticeably smaller or larger than the visible geometry (simplified proxies and
the like); the reason was not investigated.
About the body's translation and rotation (the same data, an experiment with the translated flag
inverted):
- Plain
bhkRigidBody: in 2,495 of 2,532 bodies the translation/rotation field is non-zero (in the sample it holds the body's world position from the editor, tens to hundreds of units). If it is applied, the extent centers match in 632 meshes of 2,342; if not — in 2,013. Not applying it is correct. bhkRigidBodyT: 1,177 bodies, all with a non-zero translation or rotation, but in many of the order of 10⁻⁷ (judging by the first bodies printed — numerical noise; not counted over all). Extent centers match in 982 of 1,117 with the transformation and in 976 without. This is a weak check (only a few meshes differ): the extent does not depend on the translation, the center does, but a real translation is rare in T bodies. The transformation is applied by the definition ofbhkRigidBodyT; the data confirm it only weakly.
What is not carried over and what is written to the report (Stats):
bhkCollisionObjectnot at the root — 187 in 181 meshes — skipped: the node's position relative to the root requires accumulating transformations, and the meaning of the rotation matrix has not yet been checked on an object with a known rotation. The count isStats::collision_skipped.- 350 meshes without collision at the root (the overlap with the 181 meshes where collision is not at the
root was not counted). How vanilla Morrowind behaves with a mesh without a
RootCollisionNodeis not verified: OpenMW's research notes claim collision is taken from all visible geometry, but for vanilla this is not confirmed. No fallback is substituted silently. - Other collision shapes (
bhkConvexVerticesShape,bhkBoxShape, …) — done in T1.3w: they are read and turned into triangles, see the "Coverage" section at the end of the file. - The Havok material, layers, filters, the shape's
radius/grow_by,bhkMoppBvTreeShapeparameters. - Where in the root's child list the vanilla engine expects the
RootCollisionNodeis not verified (it is the last one now).
Coverage (T1.3w): what else is read and what is not¶
Measured 2026-09-24 (mesh_convert/tests/real_width.rs, every STAT with a MODL from
Oblivion.esm over the archives Oblivion - Meshes.bsa and DLCShiveringIsles - Meshes.bsa): 6,012
records, 52 meshes are in no archive, 5,888 unique meshes.
| meshes | |
|---|---|
converted (read to the last byte, niftest on the output — 0 failures) |
5,292 (89.9%) |
version 10.x (0x0a000100–0x0a020000): a different layout family |
392 |
| blocked by unsupported block types | 204 |
Versions among the meshes that are read: 20.0.0.4 — 4,712 meshes, 20.0.0.5 — 784 (by headers). From the Shivering Isles archive 733 meshes are converted on top of 4,559 from the main archive. The 20.0.0.4 and 20.0.0.5 layouts did not diverge on this data.
Added to the reader (layouts from nif.xml; the check is that all 1,373 meshes unblocked by these
types parse to the last byte; no discrepancies found):
| Block | Layout after NiObjectNET/the common parts |
What the converter does with it |
|---|---|---|
NiStencilProperty |
enabled: u8, function, ref, mask, fail, z_fail, pass, draw_mode: u32 each. No flags |
carried over (two-sidedness — draw_mode) |
NiSpecularProperty |
flags: u16 |
carried over |
BSFurnitureMarker |
name: str, n: u32, n × 16 bytes |
dropped (sitting points are not needed) |
bhkBoxShape |
material: u32, radius: f32, 8 bytes, half_extents: f32×3, 4 bytes |
a box: 8 vertices, 12 triangles |
bhkConvexVerticesShape |
material, radius, 24 bytes (two bhkWorldObjCInfoProperty), n: u32 + n × f32×4 vertices, m: u32 + m × f32×4 planes |
hull faces from the planes |
bhkCapsuleShape |
material, radius, 8 bytes, point 1, radius 1, point 2, radius 2 |
approximated by a mesh (12 segments) |
bhkSphereShape |
material, radius |
approximated by a mesh |
bhkPackedNiTriStripsShape |
n: u16, n × 12 bytes, 4, 4, radius, 4, scale: f32×4, a copy of the radius, a copy of the scale (16), data: ref |
vertices and triangles from the data |
hkPackedNiTriStripsData |
n: u32, n × 20 bytes (u16×3, welding, normal f32×3), m: u32, m × f32×3 |
a triangle list |
bhkListShape |
[ref], material, 24 bytes, k: u32, k × u32 |
each element is a separate output shape |
bhkConvexTransformShape, bhkTransformShape |
shape: ref, material, radius, 8 bytes, f32×16 |
the matrix is applied to the subtree |
HavokMaterial in these versions is a single u32. The 4×4 matrix is read column by column, the
translation is in the fourth column: the meaning is not verified on an object with a known
transformation (bhkConvexTransformShape is in 15 meshes).
What is not read (204 meshes; reasons, by the number of STAT meshes in which the type occurs):
| Group | Types (in how many STAT meshes, by the first measurement run) |
Fate |
|---|---|---|
| animation | NiTransformInterpolator (67), NiTextKeyExtraData (63), NiControllerManager (54), NiControllerSequence (54), NiMaterialColorController (48), NiPosData (49), NiTransformController (15), NiTextureTransformController (3) and interpolators |
phase 2 ("animated nodes") |
NiTriShape |
NiTriShape, NiTriShapeData (61); 26 meshes with skinning: NiSkinInstance, NiSkinData, NiSkinPartition |
phase 2; NiTriShape without skinning is the simplest next addition |
| particles | NiPSysBoxEmitter (13), NiPSysCylinderEmitter (11), NiParticleSystem and others |
not carried over (Morrowind has a different particle system) |
| other nodes | NiBillboardNode (14) |
phase 2 |
| physics | bhkSPCollisionObject (9), bhkSimpleShapePhantom (9), bhkLimitedHingeConstraint (4), bhkRagdollConstraint |
not for statics |
| other | NiZBufferProperty, NiDirectionalLight (4), NiAmbientLight (2), NiFogProperty (2), NiVisController (2) |
one at a time |
Which type blocks how many skipped STATs first is printed by back2mw all (the "skipped" summary): 363
meshes of 10.x, 94 — NiControllerManager, 52 — not in the archive, 37 — NiTriShape, 31 — 10.x of
another subversion, 18 — NiTransformController, 16 — bhkRagdollConstraint, 13 — NiBillboardNode,
11 — NiTextKeyExtraData, 9 — NiZBufferProperty (STAT records, not meshes).
Versions 10.x (392 meshes, 6.7% of unique meshes) are not read: a different layout family; no decision about them has been made (the T1.3a threshold of 10% is not exceeded, so by the plan they stay out of scope).
Not done in T1.3w: NiTriShape, NiZBufferProperty, NiBillboardNode and the like. The list is
based on measurement, not guesswork; the order of additions is by the number of meshes a type unblocks
on its own, descending (real_width.rs prints this table).
Coverage over all objects with a model (T2.3)¶
The census is mesh_convert/tests/real_width_models.rs: the meshes of all records with a model in
Oblivion.esm (20 types, as transform::MODEL_RECORDS); for each — the full set of unknown block types
from the header, a full parse and conversion.
| 2026-09-25 | before T2.3 | after T2.3 |
|---|---|---|
| Unique meshes | 8,035 | 8,035 |
| Not in the archives | 61 | 61 |
| Read completely | 6,656 | 7,707 |
| — of them converted | — | 7,507 (+200 with skinning — real_worn.rs) |
| Parse / conversion errors | — | 0 / 0 |
| Foreign version | 520 | 97 |
A full run back2mw all --plugin Oblivion.esm: meshes 7,248 → 8,127, niftest — 0 defects; world
objects written 3,191 → 4,302, STAT 5,442 → 5,884.
Animation and constraints: read and dropped (read/anim.rs)¶
Layouts — from nif.xml for 20.0.0.4/5 and BSVER 11, checked on real files (cursor at the end in all
7,707). Dropped:
- animation:
NiControllerManager,NiControllerSequence(ControlledBlock— 33 bytes: interpolator, controller, priority, string palette, five offsets),NiDefaultAVObjectPalette,NiStringPalette,NiTextKeyExtraData, controllers (NiMultiTargetTransformController,NiTransformController,NiMaterialColorController,NiTextureTransformController,NiAlphaController,NiVisController,NiFlipController,NiGeomMorpherControllerandNiMorphData), interpolators (a blendingNiBlendInterpolatorwith flag 1 has no elements), key data (KeyGroup: time + value, quadratic keys have two more values, TBC keys 12 more bytes; inNiBoolInterpolatorthe value is a byte 0/1/2, not abool). The mesh stays in the pose stored in the file; animation values are read for doors — "Doors: whatOpenmoves" below — and for creature clips, together with the B-spline blocks andNiBSBoneLODController, — "Creatures: skeleton and clips"; - havok constraints (
bhkConstraintCInfo16 bytes + its own): limited hinge 124, ragdoll 120, prismatic 140, hinge 80, spring 36 bytes; - phantoms:
bhkSimpleShapePhantomandbhkSPCollisionObject— triggers, not solid; no root collision is created from a phantom; - properties with no counterpart:
NiZBufferProperty(in 20.0.0.x one moreu32function),NiFogProperty,NiDitherProperty— dropped from property lists; - lights in a mesh:
NiDirectionalLight,NiAmbientLight,NiPointLight,NiSpotLight— dropped from a node's children (in Morrowind a light is aLIGHrecord).
NiBillboardNode is read as a NiNode (plus a u16 mode); turning to the camera is lost. An empty
reference (−1) among a node's children is not corruption: that is how nodes of animated meshes are built
(204 meshes).
NIF 10.2.0.0¶
490 files in the archives, user_version 10, BSVER 6…11 (6 — 172, 7 — 16, 8 — 45, 9 — 228, 11 — 29).
Differences from 20.0.0.4 in the blocks read — from nif.xml, checked on 402 model meshes (cursor at the
end in all):
| Where | 10.2.0.0 | 20.0.0.4 |
|---|---|---|
| Header | no endianness byte (it exists since 20.0.0.3) | present |
NiGeometryData |
no Additional Data (it exists since 20.0.0.4) |
present |
TexDesc |
PS2 L, PS2 K present (until 10.4.0.1) |
absent |
NiControllerSequence |
Phase present (until 10.4.0.1) |
absent |
NiGeomMorpherController |
unknown u32s only with BSVER > 9 |
present |
Morph in NiMorphData |
Legacy Weight with BSVER < 10 |
absent |
The version and BSVER live in the cursor (Cursor::version, Cursor::bsver).
Remaining coverage (T2.3b)¶
The same census (real_width_models.rs), 2026-09-26:
| after T2.3 | after T2.3b | |
|---|---|---|
| Readable by header | 7,877 | 7,971 |
| Parsed to the end and converted | 7,507 + 200 with skinning | 7,966 |
| — of them with skinning baked into the pose stored in the file | — | 206 (world objects — 40) |
| Parse / conversion errors | 0 / 0 | 5 / 0 |
| Foreign version | 97 | 3 (4.0.0.2 — markers in Morrowind's own format) |
| Not in the archives | 61 | 61 |
A full run back2mw all --plugin Oblivion.esm (2026-09-26): meshes 8,127 → 8,571, niftest — 0 defects;
STAT 5,884 → 6,063, world objects 4,302 → 4,582. SEWorld.esp: references 94,523 → 96,470, STATs not
placed 211 → 0.
Particles: read and dropped (read/particles.rs)¶
31 types: NiParticleSystem/NiMeshParticleSystem, data NiPSysData/NiMeshPSysData, emitters (box,
cylinder, sphere, mesh), modifiers (age, bounds, position, spawn, color, gravity, grow, rotation, drag,
wind, collider), NiPSysPlanarCollider, controllers. Layouts — from nif.xml; the cursor is at the end
in all 170 meshes they unlocked. A particle system among a node's children stays a "read and dropped"
block in the main parse; what becomes of it is in "Particles: conversion" below (before T2.7 all 553
systems of the census were dropped).
Version differences: in 10.x NiParticleInfo is 40 bytes (rotation axis until 10.4.0.1), in 20.0.0.x 28;
emitter radius variation since 10.4.0.1; particle rotation angles and axes since 20.0.0.4; rotation speeds
and half of the NiPSysRotationModifier fields since 20.0.0.2; NiPSysGravityModifier has no
World Aligned with BSVER ≤ 16.
Along the way: NiWireframeProperty, NiBooleanExtraData, NiIntegerExtraData, bhkBlendController,
bhkBlendCollisionObject (like a phantom — collision is not carried over), bhkMalleableConstraint (a
wrapper: common part, type, common part, the wrapped constraint's parameters, Tau, Damping) are
dropped; bhkMultiSphereShape becomes collision spheres, bhkConvexSweepShape its own shape without the
sweep, bhkMeshShape is read as bhkNiTriStripsShape.
Distortion: a shape with a normal map in the base slot¶
obgatemini01.nif (a small Oblivion gate) holds a "haze" — tubes with ObGateMiniWarpy_n.dds in the
base slot: Oblivion's shader uses it to distort what is behind the shape. Drawn as a texture it would give
a lilac tube. Such a node child is dropped (Stats::dropped_distortion); if it is the mesh root, the old
error "normal map in a carried slot" remains.
Skinning on world objects: baking into the pose stored in the file¶
40 world object meshes with skinning (flags, sails, arena spectators, Oblivion gates and tentacles, a
claw trap, endgame scenes) are converted by the ordinary convert_with: vertices are baked with
OpenMW's formula data · Σ weight · bone · inverse pose · v, where "bone" is the bone node's world pose
in the file and "data" is the overall transform of NiSkinData; the skin is dropped and the bones stay as
empty nodes (skin::bake_file_pose). Armor and clothing on the body are still handled by
convert_skinned with the Morrowind skeleton.
Why "data" and not the shape's inverse pose: in the flag shipflag01.nif the overall transform is a
−7.4 shift along X with an almost zero shape pose. With the shape's inverse pose the flag moved by 7.4;
with "data" it matched the written vertices to hundredths (the flag was exported in the bind pose). In the
tentacles of oblivionarchgate01.nif, "data" is the shape's inverse pose with swapped axes; after baking
the tentacles moved by ~330 along Y to their bones at the arch (bones at y ≈ ±48, the frame at y ≈ −3).
The arena spectators' arms came down from the T bind pose into the pose stored in the file. Of 60,741
vertices of the 40 meshes, 23,794 moved by more than 1: for them "just drop the skin" would be wrong.
Not verified in the game.
Old 10.x: 10.0.1.0, 10.0.1.2, 10.1.0.101, 10.1.0.106¶
94 model meshes (grass GRAS 24, mine lanterns, some statics). The cursor is at the end in 89;
differences — from nif.xml, checked on these files:
| Where | Difference |
|---|---|
| Header | no user version until 10.0.1.8; the Bethesda header: absent in 10.0.1.0, always present in 10.0.1.2 (BSVER 3), in 10.1.0.x — with user version 3…11 (BSVER 4, 5) |
| Before each block | a u32, always 0 (niflib reads it the same way); non-zero is an error |
NiGeometryData |
Group ID since 10.1.0.114, keep and compress flags since 10.1.0.0 |
NiTriStripsData, NiTriShapeData |
Has Points since 10.0.1.3, Has Triangles since 10.1.0.0 |
NiMaterialProperty, NiTexturingProperty, NiStencilProperty |
a u16 of flags until 10.0.1.2 |
TexDesc |
the texture transform since 10.1.0.0 |
NiSourceTexture |
the pixel reference of an external one since 10.1.0.0, Direct Render since 10.1.0.103 |
NiDynamicEffect (lights) |
nodes since 10.1.0.0, the switch flag since 10.1.0.106 |
| Controllers | Manager Controlled in 10.1.0.104…108; the interpolator since 10.1.0.104, before that a data reference |
NiQuatTransform |
three TRS Valid bytes until 10.1.0.109 |
NiBlendInterpolator |
until 10.1.0.109 — u16 sizes, 20-byte elements, i32 priorities |
NiControllerSequence |
in 10.1.0.106 the controlled block carries five strings itself rather than palette offsets; Play Backwards |
| havok | bhkWorldObject has a u32 after the shape until 10.0.1.2; bhkRigidBodyCInfo lacks the first 16 bytes and three velocity f32s until 10.1.0.0; the bhkNiTriStripsShape scale and the MOPP offset since 10.1.0.0 |
Not read (5 meshes, all 10.0.1.x with havok): floorplane01, oar01, handscythe01,
stonepedastellarge01, ungrdltraphingedoor. After the havok shape, where the zero u32 should be, lies
a field of the next block (2, 3, 0x80000000), although in other files of the same versions with havok it
is in place. nif.xml seems to describe these layouts inaccurately; guessing from the bytes for five
meshes was not worth it.
Particles: conversion (T2.7)¶
Particle systems are converted into Morrowind emitters (mesh_convert::particles; the output layout —
formats/tes3.md, "Particles"). The values are read in a second pass, read::psys::systems, over the
block offsets — like door animation; the main parse still reads them for their length only
("Particles: read and dropped" above).
Census (2026-10-02, test mesh_convert/tests/real_particles.rs)¶
Meshes of the records with a model in Oblivion.esm: 553 systems in 167 meshes (ACTI 109 meshes,
STAT 62, LIGH 13, MISC 11, DOOR 10, CONT, FLOR, SGST — one each).
| What | Numbers |
|---|---|
| emitter | box 253, mesh 135, cylinder 106, sphere 59 |
| emitter node | NiNode 416, NiBillboardNode 2, none (mesh emitter) 135 |
World Space |
yes 524, no 29 |
| modifiers | AgeDeath and Spawn — in all 553; colour 480, grow and fade 363, rotation 316, gravity planar 240 and point 177 (with turbulence 37), collider 44, drag 19 (15 more disabled), wind 6, parent velocity 2 |
| properties on the system | texture, alpha, material — in all; vertex colours 502, NiDitherProperty 38, NiZBufferProperty 29, specular 2 |
| pool | 2…14,000 particles |
| who sets the birth rate | the controller's own interpolator — 118; a manager sequence: Idle 98, SpecialIdle 93 (31 of them clamped), Forward 138, Equip 67, Left 38, Unequip 1 |
Birth rate. A NiPSysEmitterCtlr with flag 0x20 (436 systems: 0x0028 — 292, 0x002C — 144) has no
interpolator of its own: the rate sits in the controlled block of a NiControllerManager sequence that
points at this controller. The sequence tells what kind of effect it is: looping Idle and SpecialIdle
are played by the world on its own — these are permanent effects (fire, smoke, water mist); Forward,
Left, Equip, Unequip and clamped sequences are actions: a trap went off, a gate opened, a scripted
flash. At rest such systems have no particles.
Mapping (particles::plan, particles::build)¶
| Oblivion | Morrowind (NiParticleSystemController and modifiers) |
|---|---|
NiPSysEmitter: speed and variation, declination and variation, planar angle and variation |
speed, speed_variation, declination_angle, declination_variation, planar_angle, planar_angle_variation — as is |
| colour, particle radius | initial_color, initial_size and the data's particle_radius |
| life span and variation | lifespan, lifespan_variation |
| emitter node | its own empty NiNode "… Emitter" under the same parent as the system, in the world pose of the Oblivion node (in vanilla the emitter is a separate empty node too) |
| box | emitter_width / emitter_height / emitter_depth |
| cylinder, sphere | the circumscribed box — the shape is lost |
| mesh emitter (on a mesh surface) | a box around the source mesh in its frame; velocity "along normals" becomes along the emitter axis — a loss |
| birth rate | birth_rate, use_birth_rate; from keys — the mean over the window (the curve is lost); at most pool / life span |
| the window of the controller or of the sequence | start_time / stop_time and emit_start_time / emit_stop_time; loop → flags 0x0008, clamped → 0x000C |
NiPSysData pool |
number of vertices, sizes, particle entries |
World Space |
particle node flags 0x2A instead of 0xAA |
NiPSysGrowFadeModifier |
NiParticleGrowFade: grow, fade |
NiPSysGravityModifier |
NiGravity: type (0 planar, 1 point), decay; strength divided by 1.6 (the engine's correction per OpenMW); axis and point — from the gravity object's frame into the system's frame; turbulence is lost |
NiPSysRotationModifier |
NiParticleRotation; the particles are then NiRotatingParticles |
NiPSysColorModifier (NiColorData) |
NiParticleColorModifier with the same keys; vertex colours in the data |
NiPSysAgeDeathModifier with spawning + NiPSysSpawnModifier |
spawn_on_death, generations, percentage, multiplier, chaos |
| position, bounds, mesh update | nothing — the controller's own job |
| drag, wind, collider, parent velocity | nothing — a loss |
| the system's properties | texture, alpha, material; vertex colours and the rest are dropped; the particle node gets NiZBufferProperty 1 |
Not converted: systems whose rate is set only by an action sequence or a clamped one (a looping emitter
would burn forever, and Morrowind has nothing to start it on an event); systems without a birth rate;
mesh particles (NiMeshParticleSystem); a mesh emitter without geometry.
| Outcome for the 553 systems | |
|---|---|
| converted whole | 106 |
| converted with losses | 194: volume shape 104, mesh emitter 65, collider 27, turbulence 25, wind 6, rate curve 3, parent velocity 2, drag 1 |
| not converted | 253: event-triggered effect 237, no birth rate 13, mesh particles 2, mesh emitter without geometry 1 |
All 167 meshes serialise after conversion. A SEWorld run (2026-10-02): 143 emitters (83 with losses) in
54 meshes, 120 not converted; niftest clean on all 2,981 meshes; textures went up to 1,340 (from 1,316 —
the particle textures were added).
Doors: what Open moves (T2.6)¶
An Oblivion door opens with an animation inside the mesh, a Morrowind door — by rotating the reference
itself around the mesh origin (formats/tes3.md, "Doors"). To know where the leaf's hinge is, a door's
animation is read with its values — in a second pass, read::motion::sequences, over the block offsets
from read::parse_with_offsets; the main parse still reads it for its length only and drops it.
Layout¶
NiControllerManageron the root: the list ofNiControllerSequence—OpenandClosefor doors.NiControllerSequence: name, controlled blocks, weight, text keys, cycle type, frequency, (phase — up to 10.4.0.1), start and stop in seconds, manager, accumulation root name, string palette.- Controlled block — one per node. In 10.2.0.0 and 20.0.0.x it is 33 bytes: interpolator,
controller, priority (
u8), string palette and five offsets into it: node name, property type, controller type, two variables (an empty field is0xFFFF_FFFF). 10.1.0.106 has no palette: after the interpolator, controller, blend interpolator (a link and au16) and priority come five strings. Before 10.1.0.106 the block is different (a target name and a controller with data) — not read. NiTransformInterpolator: a pose — translation (3f32), quaternionw, x, y, z, scale (up to 10.1.0.109 three moreTRS Validbytes), a link toNiTransformData. A pose field that comes from the keys is filled with−f32::MAXby the exporter.NiTransformData: rotation keys — quaternions (time,w, x, y, z, 12 more bytes for TBC) or, for type 4, three groups of Euler angles X, Y, Z; then the translation and scale key groups. A door most often has a single group — Z angles.- Accumulation root and
… NonAccum. In most doors the leaf node is a pair:Xand its childX NonAccum. In the file the transform sits onXandX NonAccumis identity. In the keys it is the other way round:Xhas an identity pose, and the keys ofX NonAccumcarry the whole transform of the pair in the frame ofX's parent (forDoorLowerINT03the interpolator pose isX's translation, and the Z angles start at −π —X's rotation in the file). So the hinge is taken from the pose in the file (where the node stands) and the rotation axis from the difference of the end keys in the frame of the accumulation root's parent. Taking the interpolator pose as the node's translation doubles the offset: the Dementia door came out at (97.6, 5.8) instead of (48.8, 2.9).
Census (2026-10-02, test back2mw/tests/real_doors.rs, census_of_door_motion)¶
DOOR in Oblivion.esm — 501 records, 257 distinct meshes: 2 are missing from the archives, 1 cannot
be read (ungrdltraphingedoor.nif, 10.0.1.2 with havok), 254 are parsed (20.0.0.4 — 197, 20.0.0.5 —
36, 10.2.0.0 — 19, 10.1.0.106 and 10.0.1.2 — one each). A "leaf" is a node that Open turns by more
than 0.1 rad or slides by more than 4 units; a node under another moving node (a handle) is part of the
same leaf.
| Kind | Meshes | DOOR records |
References: teleport / ordinary | In SEWorld: teleport / ordinary |
|---|---|---|---|---|
no Open in the mesh |
158 | 320 | 3,938 / 657 | 446 / 7 |
| one leaf, hinge at the mesh origin | 30 | 60 | 43 / 519 | 16 / 23 |
| one leaf, hinge offset, no frame | 13 | 19 | 42 / 184 | 0 / 3 |
| one leaf and fixed geometry in the same mesh (a frame) | 9 | 24 | 129 / 288 | 0 / 27 |
| several leaves (double doors, gates) | 22 | 44 | 243 / 529 | 0 / 13 |
| sliding (portcullises, sliding doors, machinery doors) | 12 | 21 | 2 / 256 | 2 / 154 |
| tilting around a horizontal axis (display case lids) | 10 | 10 | 0 / 117 | 0 / 0 |
Of the 52 single-leaf meshes: clockwise seen from above (around −Z) — 34, counter-clockwise — 18; the
angle is 29°…120°; the hinge is up to 128.5 units away from the origin; Open lasts 0.67…8.6 s (1 s
in Morrowind); the pose in the file equals the first Open key in all of them — the file is stored
closed. One base serves both as an ordinary door and as a teleport (the references column). The 657
ordinary references to doors without Open are doors that do not open in Oblivion at all.
Conversion rule (mesh_convert::door, back2mw::pipeline::door_one)¶
- A
DOORrecord gets its own mesh (transform::paths::door_mesh_path), even if a static uses the same model. - One leaf on a vertical hinge, no frame, hinge offset — the mesh origin is moved to the hinge:
the root's children (geometry and
RootCollisionNode) are shifted by −(x, y) of the hinge, the height is left alone; every reference to such a door is shifted by the same vector, rotated and scaled like the reference (transform::exterior::reference_offset) — the door stays where it was. - Hinge already at the origin — the mesh as is.
- Frame in the mesh, several leaves, sliding, tilting — the mesh as is, in the pose stored in the file; Morrowind will turn the whole of it around the origin. The run's notes say how many such doors there are. What to do with them is not decided yet (T2.6c, T2.6d).
- Direction. Morrowind only turns a door clockwise; 18 of the 52 Oblivion leaves open counter-clockwise — those doors will open the other way. The mesh cannot fix that: in the world every point of a Morrowind door moves clockwise. The number is in the notes.
- The angle (always 90° in Morrowind), the duration, the overshoot and settling of
Openare lost.
A SEWorld run (2026-10-02, esmtool and niftest clean): 68 DOOR records — no Open 41, hinge at
the origin 8, hinge moved 1 (SEDemDoorAnim01, 3 references), frame in the mesh 8, several leaves 3,
sliding 7; opening counter-clockwise 9.
Creatures: skeleton and clips (T11.5b)¶
An Oblivion creature is not one mesh but a folder meshes\creatures\<folder>\: a skeleton (the
MODL of the CREA record), body parts (NIFZ) and one .kf file per action. To build a Morrowind
creature out of that (formats/tes3.md, "Creature model and animation") the reader reads skeletons
and clips in full; clip values come from a second pass, read::clip::clips, over block offsets, the
same way doors are read.
What the reader gained¶
BSBound(Block::BsBound) — the actor's extents on the skeleton root: a name (BBX), the centre and the half sizes of a box, 6f32. In Morrowind theBounding Boxnode plays that role.NiBSBoneLODController— skeleton levels of detail, read and dropped:NiTimeController, the current level, the number of levels, the number of node groups (a duplicate), then per level a list of bone references. The shape groups ofnif.xmlare absent from Bethesda files.- B-splines, read for their length by the main parse and with values by the second pass:
NiBSplineTransformInterpolator: start and stop (2f32), references toNiBSplineDataandNiBSplineBasisData, the pose (translation, quaternionw, x, y, z, scale), three control point offsets (u32: translation, rotation, scale;0xFFFF— no channel, it stays at the pose);NiBSplineCompTransformInterpolator: the same plus sixf32— the bias and multiplier of the compression for translation, rotation and scale; a number isi16 / 32767 × multiplier + bias;NiBSplineCompFloatInterpolator: start, stop, two references, a value, a point offset, a bias and a multiplier;NiBSplineData: a count off32and the values, a count ofi16and the values;NiBSplineBasisData: the number of control points (u32). A control point offset is the index of a number in the array, not of a point: a channel takespoints × 3(translation),× 4(rotation) or× 1(scale) consecutive numbers. The spline is cubic, with uniform knots, clamped to its ends; the parameter is(time − start) / (stop − start) × (points − 3)(clip::Spline::at, de Boor's algorithm).NiPSysEmitterDeclinationCtlr— the same layout asNiPSysEmitterDeclinationVarCtlr(thewraithskeleton).
Census (2026-10-02, the test mesh_convert/tests/real_creature_models.rs)¶
CREA records with a model — 909, in 42 folders; the skeleton is called skeleton.nif (899
records) or skeleton_lord.nif (10). Before the reader changes not a single skeleton was readable
(BSBound), nor 1,103 of the 1,213 clips (NiBSplineCompTransformInterpolator); now all 42
skeletons, all body parts and all clips are read.
| What | Numbers |
|---|---|
| skeleton | the root is Scene Root; BSBound in all 42; Bip01 is a child of the root and Bip01 NonAccum a child of Bip01 in 41 (the horse's accumulation root is Bip02); no geometry in 38, geometry in 4 (ghost, storm atronach, will-o-the-wisp, wraith) |
body parts (NIFZ) |
294 names per folder: 287 read, 7 missing from the archives; 171 skinned (NiSkinInstance), the rest are rigid and hang under a bone |
| clips | 1,213 .kf files, all 20.0.0.4; 1,215 sequences (one file holds three), 80,551 tracks; the records' own clips (KFFZ) — 65 names |
| track interpolators | NiBSplineCompTransformInterpolator 40,202, NiTransformInterpolator 36,451, NiFloatInterpolator 3,013, NiBSplineCompFloatInterpolator 526, NiBoolInterpolator 327, NiBSplineTransformInterpolator 30, NiPoint3Interpolator 2 |
| rotation | spline 39,694, from the pose 19,166, quaternion keys 11,440, Euler keys 6,383 |
| translation | from the pose 65,783, spline 7,637, keys 3,263 |
| scale | from the pose 72,980, keys 3,681, spline 22 |
| density of rotation splines | 15 points per second — 20,941, 10 — 11,535, 30 — 5,983, 25 — 1,148 |
| cycle | loop (0) — 600, clamp (2) — 615 |
| accumulation root | Bip01 1,193, Bip02 20, ZBip01 2 |
| frequency and start | frequency 1 and start 0 — in all 1,215 |
Clip name. The sequence name gives the action, the file name gives the stance: they match in 418
of 1,215. For the baliwog the Forward action lives in handtohandforward.kf, swimforward.kf
and swimhandtohandforward.kf; the file prefixes are handtohand, onehand, twohand, bow,
staff, swim and their combinations, a variant of an action is the tail of the sequence name
(AttackLeft_chop). There are 99 sequence names; the most frequent (number of files) — idle 93,
forward 84, fastforward 73, backward 71, turnleft/turnright 69, equip 58, unequip 57,
left/right 47, stagger 45, recoil 44, attackleftpower/attackrightpower 37, attackpower
36, attackforwardpower 35, attackright 32, attackleft 29, attackbackpower 26,
blockhit/blockidle 19, casttouch 16, castself 15, casttarget 13. death — only 4
clips: an Oblivion creature dies as a ragdoll, it has no death animation. There are no knockout
clips either (knockout, knockdown in Morrowind).
Marks (the sequence's NiTextKeyExtraData). In all 1,215 clips the first mark is start, the
last is end, and the time of the last equals the end of the clip. In between:
| Mark | Count | Meaning |
|---|---|---|
Enum: <slot> |
1,748 (and 9 misspelt Eum:) |
a creature sound of the CREA record by slot: Left, Right, BackLeft, BackRight (steps), Idle, Aware, Attack |
Hit |
402 | the moment of the blow or of the spell release |
m:L, m:R |
311 | a step (movement marks) |
Sound: <EDID> |
213 | a SOUN sound by name |
Blend: <n> |
190 | the length of the blend with the previous clip, frames |
a:L, a:R |
138 | a transition in an attack chain |
Attach, Detach |
61 / 57 | the weapon is taken in hand and put away (equip, unequip) |
Hold, Release |
3 / 3 | the bow is drawn, the arrow is gone |
-ObjRatio …, -GlobalRatio … |
33 | exporter compression settings, of no use to an engine |
Pose. The translation of the first frame of idle matches the translation of the skeleton bone
in 4,857 tracks of 5,192; the rotation — in 2,081 of 4,799 (in the rest idle does not start in the
bind pose). Going by the matches: the quaternion numbers are w, x, y, z, and the nine numbers of a
node rotation are stored by rows — Mat3::from_cols_array yields the transposed matrix (1,561
matches against 78).
Movement track. The actor's movement is carried by the accumulation root Bip01 itself, not by
Bip01 NonAccum: over a forward clip its translation leaves along +Y (80 clips of 84; in the
rest the root is Bip02/ZBip01 or the creature does not travel), fastforward — +Y (72),
backward — −Y (69), left — −X (44), right — +X (44). Bip01 NonAccum holds the height of the
pelvis and the sway. That is the same arrangement as in Morrowind (Bip01 is a child of the root
and leaves along +Y), so NonAccum does not have to be folded into Bip01 — the node stays an
ordinary bone. Speed = path / duration: the dog's forward is 120 units in 2 s (60 per second),
fastforward — 70; the goblin — 39 and 303.
Track targets outside the skeleton. A clip also moves nodes of body parts: Head:0,
Eyelid:0, LeftHandMorph:0 (morphs, through NiFloatInterpolator), PArray…, Idle…PCloud…
(particles). A Morrowind tape has no place for such tracks.
Body (T11.5c, mesh_convert::creature::build_body)¶
The skeleton and the NIFZ parts of a record are assembled into one Morrowind mesh (its shape —
formats/tes3.md, "Creature model and animation"); there is no animation in it yet.
- Skeleton — every node of the skeleton file under
Scene Root, with the same names, hierarchy and file pose. The output root is identity; the first bone under it is the accumulation root (Bip01,Bip02for the horse). Flags follow vanilla: root and accumulation root 0x000A, bones and shapes 0x0002. - Skin. A vertex is put into the pose of the skeleton: Σ weight · (bone in the skeleton) ·
(inverse bind of the bone from the part) · v — and written in the space of the accumulation root;
the shape is its child and it is the skin root too, the inverse bind of a bone in the output is
(bone)⁻¹ · root. The part file's own copy of the bones is not used. A part bone missing from the skeleton would give its weight to the nearest ancestor — Oblivion's data has none. - Rigid part (head, eyes, helmet, stinger) — a child of a bone, without skin. The bone is named
by a
NiStringExtraDatacalledPrnon the root of the part file (Prn=Bip01 Head), and the file itself is written in the space of that bone; a shape may carry its own scale (the bear's head — 71.1). If a node named like a bone stands above the shape (the shapes of the ghost and atronach skeletons themselves), that node is used. - Extents. The skeleton's
BSBound→ aBounding Boxnode with a box: the same centre and the same half sizes, identity axes, the node at the origin.
A run over all records (2026-10-02, the test mesh_convert/tests/real_creature_bodies.rs): the 909
records with a model give 229 different bodies (skeleton + set of parts; 59 goblins, 36
grummites, 20 zombies, 16 horses). All 229 are built, niftest — 0 rejects; 68.9 MB, 1,844,800
triangles, 127 textures.
| What | Numbers |
|---|---|
| bones | 15,147 over 229 bodies (25…107 per body) |
| skinned shapes | 1,166 |
| rigid shapes | by the Prn string — 427, under a node named like a bone — 221, without a bone — 0 |
| part bones outside the skeleton, vertices without weights | 0 and 0 |
| accumulation root | Bip01 — 213 bodies, Bip02 — 16 |
Bounding Box |
in all 229 |
| parts missing from the archives | 7 (the body is built without them) |
| bodies without a single shape | 3 — records without NIFZ (dog, grummite, xivilai) |
Check against the extents: after skin deformation in the file pose the mesh height is 0.85…1.2 of
the BSBound height in 192 bodies of 226 (zombie 126 against 130, lich 129 against 128, frost
atronach 205 against 202); the bottom of the mesh is at 1 for the goblin and at 0 for the horse and
the zombie. For the other 34 (bear, daedroth, hunger) the pose of the skeleton file is not a stance:
a quadruped is put on its legs by the animation, and the check against the extents for them comes
after the tape (T11.5d). In width the mesh is 2–3 times wider than the extents for every biped: the
bind pose has the arms spread.
Not verified in game or in NifSkope.
Tape (T11.5d, mesh_convert::creature::tape)¶
The clips of a folder are assembled into one Morrowind tape, the tape is hung on the body
(tape::animate), and the full mesh yields the pair x<name>.nif + x<name>.kf
(tape::split_pair) — three files, like a vanilla creature (formats/tes3.md, "Creature model and
animation").
- Which clip becomes which group. The table
data/creature_groups.tsv: a Morrowind group, its kind (which marks it gets), the Oblivion action with fallbacks and the stances in order of preference. An action is a sequence name, exact or with a variant tail (AttackLeft_Cross,Idle_HandtoHand); a stance is the prefix of the file name. The owner's decision: thehandtohandstance, and without it the file with no prefix. Fallbacks: for blows and the reaction to a blow — clips of weapon stances and spell gestures (the lich strikes only with a staff, the ghost only casts), for every group — swimming (a fish has nothing else to move with, and Morrowind creatures have no swimming groups). Groups with the same clip share one stretch of the tape (IdleandIdle2, as in the vanilla guar), but at most five per stretch: that is how many the engine keeps open at once (tes3.md, "Creature model and animation"). - Keys. Clips stand one after another, one step apart; every track — keys, Euler angles or a
spline — is sampled with a step of 1/15 s (the owner's decision: as in vanilla) into linear
rotation, translation and scale keys; a key equal to both neighbours is dropped. Values are local
bone transforms, as in Oblivion. A bone without a track in a clip stands in the skeleton pose. NIF
Euler angles are rotations about X, then Y, then Z (
Rz·Ry·Rx): on the first frame ofidlethis order matched the skeleton pose in 164 tracks, the reverse one in none. - Marks.
Start/Loop Start/Loop Stop/Stopfor loops,Start/Stopfor one-shots,Start/Hit/Stopfor blows (the clip'sHitmark; without it — the middle),Self|Touch|Target+Start/Release/StopforSpellCast. The clip'sEnum: <slot>marks becomeSoundGen: Left|Right|Moan|Roarbydata/creature_marks.tsv.Sound: <EDID>marks are not carried over (in Morrowind a creature's sound is set bySNDGper kind, not by name). - Turning. In vanilla creatures the accumulation root does not rotate over a
TurnLeft/TurnRightloop (26 of 26 withBip01): the engine turns the actor. So in turn groups the rotation of the accumulation root is frozen at the first frame of the clip. - The accumulation root. A census of the tapes of 33 vanilla creatures with
Bip01(2026-10-02): every group starts with the root at one and the same spot (walking 31 of 31, running 30 of 31, attacks 94 of 96, hit reaction 57 of 61), and in attacks the root stands still (88 of 96; hit reaction 51 of 61, turns 32 of 33). Oblivion clips are different: a clip starts wherever it likes (the dog's run — 30 units ahead), and an attack's lunge and a recoil are written as root travel (55 and 44 units for the dog) — in Oblivion the engine itself turns it into the actor's movement. On the tape the root's travel over the ground in every stretch is counted from the spot where the root stands in the first frame ofIdle, and in the kindsattack,cast-…,turnandstill(hit reaction) the root stays at it: the lunge and the recoil are not carried over. Inloopandoncethe root's travel remains the creature's path (walking, running,Knockdown— in vanilla the root travels there too, 23 of 32). - Closing a loop. In vanilla the pose at
Loop Stopequals the pose atLoop Start(they differ by 0.04…0.07°), in Oblivion clips it does not: for the dog walking 5.5°, running 3.3°, turns 3…4° (the splines are compressed with losses). The last 0.2 s of a loop (at most half the clip) are brought to the starting pose; the root's path over the ground is not closed. - Death (the owner's decision). There is no clip, the group is built: from the first frame of
Idlethe body tips over onto its side in a second — a 90° rotation about the lengthwise axis running along the ground at the edge of the body; the edge is measured on the mesh in theIdleframe (theBSBoundextents are narrower than a body with its legs apart — the corpse would sink into the ground). The same stretch, as in the vanilla guar, holdsKnockout(its loop is the lying body),DeathKnockDownandDeathKnockOut; over the next second the creature gets up — the end ofKnockout. At 0.2 s of the fall —SoundGen: Scream. - What is not carried over. The records' own idles (
KFFZ) and thespecial…clips: there is one tape per folder, and those differ per record. Weapon stances as separate sets. Morph and particle tracks (Head:0,PArray…) — 1,589 over the 41 tapes. Blocking, dodging, jumping.
A run over the folders (2026-10-02, the test mesh_convert/tests/real_creature_tapes.rs): 41 folders
with a body (the will-o-the-wisp has no parts), 427 of the 1,202 clips went into tapes. niftest
accepts all three files of every folder — 123 files, 0 rejects; 550 thousand keys, 44.4 MB in all.
| What | Numbers |
|---|---|
| tape | 10.9…29.2 s, 23…104 tracks |
| groups (in how many of the 41 tapes) | Idle, Idle2…Idle5 (all on the Idle stretch: idles 2…5 are requested by the wander package), Attack1–Attack3, TurnLeft, TurnRight, Death1, Knockout, DeathKnockDown, DeathKnockOut — 41; WalkForward, RunForward, Hit1, Knockdown — 40 (Mehrunes Dagon has none); SpellCast — 23 |
| path | over the loop of WalkForward and RunForward the accumulation root leaves along +Y in all 40; the dog 56 and 380 units per second, the goblin 39 and 303, the horse 87 and 562 |
| turning | the accumulation root does not rotate over the TurnLeft loop in all 41 |
| pair | x<name>.kf: a NiSequenceStreamHelper root, marks, bone names as strings, controllers with an empty target, as many strings as controllers — 41; x<name>.nif: no controllers or marks, as many nodes and shapes — 41 |
| stance | the body in the first frame of Idle: a height of 0.75…1.35 of the BSBound height and the bottom at the ground — 36 of 41; quadrupeds stand on their legs (bear 54×118×69 with extents 33×121×61, horse 61×187×142 with 72×220×155). The other 5: the ghost, the wraith and the imp hover (bottom at 33 and 136), the mud crab's and the fish's meshes are larger than the box |
| death | after Death1 the body lies on its side (width and height swapped) with the bottom at the ground — 41 of 41 |
The way of checking is itself checked against vanilla: the guar r\guar.nif, put into the first
frame of its own Idle by the same test code, comes out 158 high against a box of 160 and stands on
the ground (bottom −2).
Not verified in game: whether the engine plays our groups; whether idles on the Idle stretch
are enough for it; what the fall looks like; whether the creature twitches at the seams between
clips. Models go into plugins since T11.5e (formats/tes4.md, "Creatures with their own model").
Skinning (T9.2b)¶
Three blocks, the 20.0.0.4 layout from nif.xml, checked on all 551 worn meshes of ARMO/CLOT in
Oblivion.esm (cursor at the end of the file in each, the test mesh_convert/tests/real_worn.rs):
NiSkinInstance: a data reference, a partition reference (since 10.1.0.101), the skeleton root, a u32 bone count and bone references.NiSkinData: a transform (rotation of 9 f32, translation, scale), a u32 bone count, a u8 "has weights" (the partition reference no longer exists in 20.0.0.4), and per bone — a transform, a sphere (center, radius), a u16 number of weights and pairs (u16 vertex, f32 weight).NiSkinPartition: partitioning for hardware skinning — Morrowind does not know it, and its weights duplicateNiSkinData; it is read in full so as not to drift, and dropped.
An Oblivion armor mesh carries its own copy of the bones it needs (a cuirass — 21 NiNodes), so the
Oblivion bone poses are taken from the mesh itself, not from skeleton.nif (which has ragdoll blocks the
reader does not know).
Bones in the skinning of 449 meshes (number of shapes): most often Clavicle (612/620), Spine2 (603),
UpperArmTwist (496/501), Pelvis (489). Bones Morrowind does not have — 30 kinds: the twists
ForearmTwist/UpperArmTwist, Neck1, the phalanges Finger02/Finger12/Finger22/Finger3*/
Finger4*, Toe0. Their weight goes to the nearest ancestor present in the Morrowind skeleton — by the
mesh's own hierarchy.
Bones as a flat list. Mod meshes exported from Blender write bones not as a tree but as a list of
Scene Root's children (sasha136667\er\black knife set\black knife a.nif: 26 bones, no Bip01 node,
2026-09-25). For such a twist the only ancestor is the root, and its weight went to Bip01: the
pauldrons were not moved to Morrowind's shoulder (they stayed at Oblivion's height, lower) and did not
follow the arm. So climbing up to the root is not accepted as an answer: a Biped bone without an ancestor
takes the Morrowind bone by name prefix (UpperArmTwist → UpperArm, Neck1 → Neck), and if there is
no prefix (Toe0) — the nearest joint on the same side (mesh_convert::skin::biped_fallback). After the
fix the pauldrons of this mesh sit on L/R UpperArm at a height of 108–123, with Morrowind's shoulder
joint at 112. Not verified in the game.
Conversion — mesh_convert::skin::convert_skinned; the convention and the skeleton — tes3.md,
"Skinning". Nodes with an empty reference (−1) in their child list occur (Dark Brotherhood helmets) and
are skipped.