FLVER nodes and skinning
FLVER nodes describe a transform hierarchy. Meshes can follow a node rigidly or carry weighted bone indices; dummy points identify attachment locations independently of the drawable meshes. Sourced · SoulsFormatsNEXT
The FLVER record layouts below are checked in the whole-install model population: 14,459 Sekiro files and 22,050 reference-readable Elden Ring files. The reference refuses another 119 Elden Ring SpeedTree files; those have a separate stream check. One Sekiro archive entry fails before model inspection and is excluded. Proven · whole-install reference population
| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 12 | float3 | translation | Proven | |
| 0xC | 4 | u32 | name offset | Proven | |
| 0x10 | 12 | float3 | Euler rotation | Proven | |
| 0x1C | 2 | i16 | parent index | Proven | |
| 0x1E | 2 | i16 | first child index | Proven | |
| 0x20 | 12 | float3 | scale | Proven | |
| 0x2C | 2 | i16 | next sibling index | Proven | |
| 0x2E | 2 | i16 | previous sibling index | Proven | |
| 0x30 | 12 | float3 | minimum bounds | Proven | Either a box or the inverted sentinel |
| 0x3C | 4 | u32 | node flags | Sourced | Only the low four bits are used; bits 4 and 8 are unexplained |
| 0x40 | 12 | float3 | maximum bounds | Proven | Either a box or the inverted sentinel |
| 0x4C | 52 | bytes = 0 | reserved | Proven |
In every node of both installs (129,270 in Sekiro’s 14,459 models, 535,503 in Elden Ring’s 22,169), following the next-sibling
indices from a node’s first child index visits exactly the nodes whose parent index is that node, and the
previous-sibling index undoes the next-sibling one. Proven · every node of both installs The first child is the lowest-index
child in all but 75 Sekiro and 37 Elden Ring nodes, and siblings are not otherwise in index order. Proven · every node of both installs
The two bounds are either a box (minimum not above maximum on every axis: 66,485 Sekiro and 139,011 Elden Ring nodes) or
the inverted sentinel, minimum +3.4028235e38 and maximum -3.4028235e38 on every axis, of a node with no bound vertices
(62,785 and 396,492); no node has anything else. Proven · every node of both installs The flags word takes only the values
0, 1, 2, 4, 6, 8, 10, 12 and 14 in both games, so only its low four bits are used. Proven · every node of both installs
Bit 1 is set only on nodes that have no children and that no mesh and no dummy point names: all 50,370 Sekiro and
363,132 Elden Ring nodes with it set. Proven · every node of both installs Bit 2 is set only on nodes a dummy point names
as parent or attach bone in Elden Ring (all 24,493 nodes with it; 771 named nodes lack it), and in Sekiro on 8,377 named
nodes and 1,964 unnamed ones (27 named nodes lack it). Proven · every node of both installs What bits 4 and 8 select is
not explained by a node being a mesh’s default bone or by its name. Unknown
The community reader constructs the local transform, in row-vector notation, as
Scale * RotationX * RotationZ * RotationY * Translation. A parent index of -1 marks a root.
Sourced · SoulsFormatsNEXT
Skeleton mappings
Section titled “Skeleton mappings”For FLVER version 0x2001A, the skeleton set after the texture table maps hierarchy entries back to nodes.
The community reader calls the two lists BaseSkeleton and AllSkeletons; the latter includes control and ragdoll
hierarchies. Sourced · SoulsFormatsNEXT
| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 2 | i16 | base skeleton count | Sourced | |
| 0x2 | 2 | i16 | all skeletons count | Sourced | |
| 0x4 | 4 | u32 | base skeleton offset | Sourced | |
| 0x8 | 4 | u32 | all skeletons offset | Sourced | |
| 0xC | 20 | bytes = 0 | reserved | Proven |
| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 2 | i16 | parent index | Sourced | |
| 0x2 | 2 | i16 | first child index | Sourced | |
| 0x4 | 2 | i16 | next sibling index | Sourced | |
| 0x6 | 2 | i16 | previous sibling index | Sourced | |
| 0x8 | 4 | i32 | node index | Sourced | |
| 0xC | 4 | u32 = 0 | reserved | Proven |
Scale in the hierarchy
Section titled “Scale in the hierarchy”A node’s world transform is its parent’s world transform composed with its own local transform, scale included, so a scaled node scales the translations of its descendants and the vertices and dummy points they carry. The vertex extents the file stores in its header (offset 40, see FLVER) show it: posing every vertex of a model through this full product of affine maps reproduces the stored bounds within 0.1% in 14,250 of the 14,272 Sekiro models that hold vertices and in 21,935 of the 21,938 Elden Ring models that do (119 SpeedTree models, whose bounds are the instance’s, and 112 models without vertices are left out). Observed The community importer’s rule, in which a node’s translation is its parent’s translation plus the parent’s scale-free rotation of the local translation and a node’s own scale applies only to what the node carries, Sourced · soulstruct-blender gives the same positions wherever no ancestor is scaled and different ones below a scaled ancestor. Sekiro has 158 models and Elden Ring 9 with static vertices on such a node (2,248 nodes and 478,300 vertices in Sekiro, 33 nodes and 18,229 vertices in Elden Ring); the full product matches the stored bounds in all 167, the importer’s rule in 9 of the 158 Sekiro models and 1 of the 9 Elden Ring models (where the vertices it moves do not change the box). Observed
Scaled nodes: Sekiro has 10,713 nodes with a scale component off 1 by more than 0.001 in 1,220 of its 14,459 models (7,078 roots, 3,635 others; 3,507 with unequal components), and Elden Ring 5,901 in 778 of its 22,169 (4,943 roots, 958 others; 2,291 unequal). Proven · every node of both installs A node has a scaled strict ancestor, so that the two rules place what it carries differently, on 2,337 Sekiro nodes and 806 Elden Ring nodes. Proven · every node of both installs No node of either install has a negative scale component (129,270 Sekiro and 535,503 Elden Ring nodes), so no node mirrors what it carries. Proven · every node of both installs 544 Elden Ring nodes in 272 models have a zero component; none carries a vertex or a dummy point, and the 88,340 and 20,268 dummy points of the installs name none as parent or attach node. Proven · every node and dummy point of both installs
Rigid and dynamic data
Section titled “Rigid and dynamic data”Static vertices with a stored normal W use that integer to identify their rigid bone, at implicit weight one. Where the layout stores no normal W, the mesh’s NodeIndex supplies the bone instead. Dynamic vertices are stored in model bind space. Observed
In Ashina Castle, map pieces’ bones are identity, so their vertices need no bone transform. Objects’ rigid bones
are not: the cannon cart o114670, for example, has a bone scale of 0.00937, and its vertices are stored in that
bone’s space. Observed · Sekiro The vertex’s position is usable only after the bone’s world transform
(the node’s local transform, composed up through its parents) is applied; read raw, the cannon mesh is about 400 m
long and stacked straw bags sit at the model origin. Observed · Sekiro
Across Ashina Outskirts (m11_00), Ashina Castle (m11_01) and Ashina Reservoir (m11_02), no map-piece vertex is
bound to a non-identity bone, while many object placements are of models that have such vertices:
Observed · Sekiro
| Map | Object placements whose model has vertices on a non-identity bone | Confidence |
|---|---|---|
m11_00 Ashina Outskirts |
683 of 1,453 | Observed · Sekiro |
m11_01 Ashina Castle |
776 of 1,613 | Observed · Sekiro |
m11_02 Ashina Reservoir |
374 of 773 | Observed · Sekiro |
An empty mesh bone palette means that vertex indices name skeleton joints directly; a nonempty palette supplies
the local-to-skeleton mapping. Observed Elden Ring’s c3000 model has 368 nodes and 49 meshes with empty palettes;
its largest joint index with nonzero weight is 101. Observed · Elden Ring
Sekiro’s c1010 has 400 nodes and 81 meshes, all dynamic with empty palettes; its highest used index is 109.
The five equipment parts of the Another’s Memory: Ashina costume also have empty palettes. Observed · Sekiro
Twenty captured c3000 skinned draws bind a 12,288-byte joint buffer: 256 affine matrices of 48 bytes, despite the shader declaring only six rows. Reflection’s declared array extent is therefore not the bound palette size. Observed · Elden Ring
Explicit stored weights need not sum to one. The inspected Sekiro c1010 model has byte-quantized weights
summing to 253/255 or 252/255 on 31,544 of its 140,330 vertices; those sums are stored data, not evidence of a decoding error.
Observed · Sekiro
Smithbox leaves a static mesh as stored when neither a normal W nor a valid NodeIndex supplies a bone. Sourced · Smithbox The corresponding game behaviour is not established. Unknown
Skinned vertex streams at run time
Section titled “Skinned vertex streams at run time”only in Sekiro Sekiro draws most meshes from the FLVER’s own vertex buffers, but replaces the position streams of the
deformed ones with buffers it writes on the CPU. In five frames at the Ashina Castle gate, the player’s face
(FC_M_0200, 4 meshes) and body (BD_M_9040, 17 meshes) meshes, which have three vertex buffers, are drawn with the
file’s second buffer (bone indices, weights, colour and UVs) and, in place of the first and third, two buffers of
20 bytes a vertex (position, normal, tangent; the file’s first and third buffers have that layout, and the third is a
byte-for-byte copy of the first). Observed · Sekiro · five captured frames The two are dynamic buffers created
once and written whole, one of the two each frame, alternately, by Map with discard on the deferred contexts that run
before any draw. Observed · Sekiro · five captured frames Their positions are still in model bind space, not
skinned: they differ from the file’s by up to 0.18 units on the face and 0.19 on the body, and the two buffers of a mesh
differ from each other by 0.0002 to 0.0053 units. Observed · Sekiro · four captured frames (The fifth capture’s copy of
the buffer not written in its frame was taken at a later point and is marked so by the capture, so its contents are left
out.) The game therefore
deforms these meshes on the CPU (facial expression and body shape, by where they differ) before skinning them on the
GPU. Inferred · Sekiro The objects o113100, o113110 and o113120, whose meshes have two vertex buffers, have their first
buffer replaced in the same way, by one buffer written each frame, and move by up to 3 units from the stored positions.
Observed · Sekiro · five captured frames The other three-buffer meshes (the Sculptor c1010) are drawn from the file’s three buffers.
Observed · Sekiro · one captured frame
The motion-vector pass’s vertex program skins the first stream (POSITION0) with the object matrices at register 5
(cbObjMatrix) and the first view-projection of cbMatrixWVP, and the third (POSITION1) with register 6
(cbPrevObjMatrix) and the second, so the third stream is meant as the previous frame’s positions.
Observed · Sekiro · the DXBC of that program Yet in 282 of the 315 draws of these 21 meshes in the five frames’
shadow-map, G-buffer and motion-vector passes, the buffer bound at the third slot is the one the frame has just written,
and the one at the first slot the one the frame before wrote; the motion-vector pass binds them so in all five frames. The exceptions are the G-buffer pass of 12 body
meshes in one frame and the shadow pass of all 21 in another, which bind them the other way round.
Observed · Sekiro · five captured frames
The buffer a frame writes holds the newer positions. In one captured Sekiro frame, for each of 27 written position
buffers the other buffer of its pair was compared with the written buffer’s contents at the start of the frame and with
the bytes written during the frame: in 21 pairs the other buffer lies between the two, at a median 0.45 to 0.59 of the
way from the start contents to the written bytes, with 99.7 to 100 % of the displaced vertices between 0.1 and 0.9; the
remaining 6 pairs are 57-vertex buffers whose two members are 6.8 units apart. So the pair alternates, one buffer holding
the previous frame’s deformation and the other the frame before that, and each frame overwrites the older one.
Observed · Sekiro · one captured frame, 27 pairs Which slot the written buffer is bound to varies with the
command list: in the 24 recorded list instances of one frame, 18 bind the written buffer as the previous-frame stream
(POSITION1) and 6 as the current stream, so a draw’s POSITION1 is not by itself the older buffer.
Observed · Sekiro · one captured frame
only in Elden Ring Elden Ring’s cloth meshes use the same two-stream layout, with a current and a previous position
vertex buffer. In ten captured frames, 190 cloth draws bind a pair of which the frame copied new positions into one
buffer, from the upload ring, with a GPU buffer copy; all 190 bind the copied buffer at POSITION0, and 9 further
draws use a pair no copy touched. The copied slice differs from the two buffers’ contents at the start of the frame by
at most 0.0022 units (mean 0.0004 against the older buffer), so the stream written in the frame is the newer one.
Observed · Elden Ring · ten captured frames
Within a frame the buffer written holds the newest positions, and the other buffer holds the position of one frame earlier. That the roles alternate every frame, rather than a buffer staying “current” until some other condition flips the binding, needs two consecutive frames of the same object, and each capture covers a single frame. Unknown
Dummy attachment points
Section titled “Dummy attachment points”| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 12 | float3 | position | Sourced | |
| 0xC | 4 | bytes | colour bytes | Proven | Alpha, red, green, blue: byte 12 is 255 on every dummy point |
| 0x10 | 12 | float3 | forward vector | Sourced | |
| 0x1C | 2 | i16 | reference ID | Sourced | |
| 0x1E | 2 | i16 | parent bone | Sourced | |
| 0x20 | 12 | float3 | upward vector | Sourced | |
| 0x2C | 2 | i16 | attach bone | Sourced | |
| 0x2E | 1 | bool | unknown flag | Unknown | |
| 0x2F | 1 | bool | use upward vector | Sourced | |
| 0x30 | 4 | i32 | unknown 30 | Unknown | |
| 0x34 | 4 | i32 | unknown 34 | Unknown | |
| 0x38 | 8 | bytes = 0 | reserved | Proven |
The four colour bytes have the alpha channel first (ARGB): the first byte is 255 on all 20,268 Sekiro and 88,340 Elden Ring
dummy points, and the other three are 255 (white) on all but 34 Sekiro and 3,239 Elden Ring points, which are grey (128)
or a colour with the red and green bytes zero and the blue 208. Proven · every dummy point of both installs The unknown
flag at 46 is 1 when the attach bone is set and 0 when it is -1 on 86,081 of Elden Ring’s 88,340 dummy points and 20,232 of
Sekiro’s 20,268 (it is 0 with an attach bone on 2,157 and 8, and 1 without one on 102 and 28). Proven · every dummy point of both installs
In a model of more than one bone the flag is 1 exactly when the attach bone is set, on 86,033 of Elden Ring’s 86,135 dummy
points of such models and 20,108 of Sekiro’s 20,136; the exceptions are all 1 with no attach bone (102 in 30 Elden Ring
models, 28 in 7 Sekiro models), and their parent bones are named for dummies (dmy_poly, dummy, Dmy_...).
Proven · every dummy point of both installs Every dummy point that is 0 with an attach bone is in a model of a single bone,
where the attach bone is bone 0 and so is the parent bone: there the flag is 1 on 34 and 0 on 8 of Sekiro’s 42 dummy points
with an attach bone, 1 on 29 and 0 on 2,157 of Elden Ring’s 2,186, and 0 on all 90 and 19 without one.
Proven · every dummy point of both installs
The use-upward flag at 47 is 1 on all of them. Proven · every dummy point of both installs
Placing and orienting a dummy point
Section titled “Placing and orienting a dummy point”A dummy point’s position and direction vectors are in its parent node’s space, so they follow the parent’s world
matrix, scale included. Inferred The two scale rules above place a dummy point differently only when the parent has a
scaled strict ancestor: 16 of Sekiro’s 20,268 dummy points (in four object models’ 8 files) and 2 of Elden Ring’s 88,340.
Proven · every dummy point of both installs A scale on the parent itself moves a point the same way under both rules
(885 Sekiro and 10 Elden Ring dummy points have a scaled parent). Proven · every dummy point of both installs
Sekiro’s object o005380 embeds the model o000100 (a pouch, 0.357 m high, dummy points with reference IDs 90 and 170
at 0.266 m and 0.766 m) as a node scaled 0.8 under a root scaled 1.25. Under the full product the pouch’s vertices and
its two points reproduce o000100 itself, its own size and the points’ heights; with the parent’s own scale only the
pouch shrinks to 0.285 m while the points stay put. In the sibling objects o005390, o005391 and o005392 (pouch
node 0.64 under 1.25) the full product scales the points with the pouch (to 0.213 m and 0.613 m, the pouch 0.265 m high),
and the other rule leaves the first point at 0.266 m, above a pouch 0.212 m high that contains it in o000100.
Observed · Sekiro
The use-upward-vector byte is 1 on all 20,268 Sekiro and 88,340 Elden Ring dummy points, so every point stores both a forward and an upward vector. Proven · every dummy point of both installs The forward vector points along -Z on 11,458 Sekiro points (56.5%) and 46,718 Elden Ring points (52.9%) and along +Z on 3,372 (16.6%) and 2,228 (2.5%); the upward vector is +Y on most of them, and the rest are oblique or on other axes. Observed The two vectors are not always perpendicular: 164 Sekiro and 4,216 Elden Ring points have |cos| above 0.01, up to 0.70, with parents that are not scaled in the cases examined. Observed Which local axis of a socket a consumer takes as the forward direction is not stored. Unknown
The reference ID identifies the point to scripts and effects; its meaning is external to FLVER. The parent bone supplies the initial transform, while the attach bone is the bone the point follows physically, according to the reference reader. Sourced · SoulsFormatsNEXT
The file population includes static meshes without a usable bone reference. Viewer behaviour is documented above, but it does not establish the game’s transform or visibility rule. Unknown