FLVER2 models
FLVER2 stores a model’s meshes, material references, transform nodes, attachment points and vertex layouts. Meshes refer to face sets and vertex buffers by index; materials refer to external definitions and texture paths. Sourced · SoulsFormatsNEXT
A strict reader that checks every table bound, every zero field and the coverage of the data block reads all 14,459 Sekiro and all 22,169 Elden Ring models, the 119 SpeedTree ones included. Proven · every FLVER of both archive sets
Whole-install comparisons cover 14,459 Sekiro FLVER records and 22,169 Elden Ring records. The independent reader accepts all 14,459 Sekiro models and 22,050 Elden Ring models; it refuses the other 119 Elden Ring models, all SpeedTree. One Sekiro archive entry fails before model inspection; Elden Ring has no such archive refusal. The structural layouts below apply to the accepted models, with SpeedTree checked separately by executing its vertex programs. Proven · whole-install reference population
The comparison accounts separately for the different interpretations of vertex formats; agreement after reinterpreting the same stored bytes does not prove the reference reader’s shader-input semantics. Observed
Header and table order
Section titled “Header and table order”The PC header is 128 bytes, little-endian, with FLVER\0L\0 at its start. The metadata tables follow in the order
dummy, material, node, mesh, face set, vertex buffer, buffer layout and texture. Proven · whole-install reference population
The reference-readable FLVER records have the following version populations. The 119 SpeedTree files refused by the reference are excluded from this version table. Proven · whole-install reference population
| Version | Sekiro files | Elden Ring files | Confidence |
|---|---|---|---|
0x20013 |
1 | 1 | Proven |
0x20014 |
2 | 2 | Proven |
0x20016 |
14 | 0 | Proven |
0x2001A |
14,442 | 22,047 | Proven |
Little-endian; offsets are file-relative unless stated otherwise.
| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 6 | char = FLVER\0 | magic | Proven | |
| 0x6 | 2 | char = L\0 | byte order | Proven | |
| 0x8 | 4 | u32 | version | Proven | |
| 0xC | 4 | u32 | data offset | Proven | |
| 0x10 | 4 | u32 | data length | Proven | |
| 0x14 | 4 | u32 | dummy count | Proven | |
| 0x18 | 4 | u32 | material count | Proven | |
| 0x1C | 4 | u32 | node count | Proven | |
| 0x20 | 4 | u32 | mesh count | Proven | |
| 0x24 | 4 | u32 | vertex buffer count | Proven | |
| 0x28 | 12 | float3 | minimum bounds | Observed | see Header bounds |
| 0x34 | 12 | float3 | maximum bounds | Observed | see Header bounds |
| 0x40 | 4 | u32 | nondegenerate non-motion-blur face count | Observed | see Face counts in the header |
| 0x44 | 4 | u32 | total face count | Observed | see Face counts in the header |
| 0x48 | 1 | u8 | default index width in bits | Proven | |
| 0x49 | 1 | bool = 1 | UTF-16 strings | Proven | |
| 0x4A | 1 | u8 | unknown 4A | Unknown | |
| 0x4B | 1 | u8 | unknown 4B | Unknown | Zero in the checked PC files. |
| 0x4C | 4 | u32 | unknown 4C | Unknown | |
| 0x50 | 4 | u32 | face set count | Proven | |
| 0x54 | 4 | u32 | buffer layout count | Proven | |
| 0x58 | 4 | u32 | texture count | Proven | |
| 0x5C | 2 | bytes | unknown 5C and 5D | Unknown | |
| 0x5E | 10 | bytes = 0 | reserved | Proven | |
| 0x68 | 2 | u16 | unknown 68 | Unknown | 5 on SpeedTree files. |
| 0x6A | 2 | u16 | special modifier | Proven | 0x8000 identifies SpeedTree in Elden Ring. |
| 0x6C | 20 | bytes = 0 | reserved | Proven |
For version 0x2001A, a 32-byte skeleton-set descriptor follows the texture table; the two tables it points to
contain 16-byte records. SoulsFormatsNEXT calls them base and all skeletons. Sourced · SoulsFormatsNEXT
Elden Ring files may have zero padding from the end of the declared data block to the next 2,048-byte boundary. Observed · Elden Ring
Header bytes without a known meaning
Section titled “Header bytes without a known meaning”On every FLVER of the Sekiro install (14,459 files, read at their fixed offsets), the bytes the header table leaves
unknown hold few values. The default index width at 0x48 is 0 in every file, so the face sets state every index width
themselves. Proven · Sekiro · every FLVER of the install 0x4A, the u32 at 0x4C and 0x5C are 0 in every file.
Proven · Sekiro · every FLVER of the install 0x5D is 2 in each of the 14,442 version 0x2001A files and 0 in the
17 of earlier versions. Proven · Sekiro · every FLVER of the install The u16 at 0x68 is 4 in every file but the
one of version 0x20013, where it is 0. Proven · Sekiro · every FLVER of the install What 0x5D and 0x68 select
is not known. Unknown
Elden Ring’s install (22,169 FLVERs, 119 of them SpeedTree models of version 0x20014) holds the same values for
the same versions, the SpeedTree models apart.
Proven · Elden Ring · every FLVER of the install The default index width at 0x48 is 0 in every file but the
SpeedTree models, where it is 16. Proven · Elden Ring · every FLVER of the install 0x5D is 2 in each of the
22,047 version 0x2001A files and 0 in the 3 of earlier versions and in the SpeedTree models.
Proven · Elden Ring · every FLVER of the install The u16 at 0x68 is 4 in the version 0x2001A and 0x20014
files, 0 in the one of version 0x20013, and 5 in the SpeedTree models. Proven · Elden Ring · every FLVER of the install
Header bounds
Section titled “Header bounds”The two header bounds are the box of every vertex of every mesh, static vertices posed by their node as described under scale in the hierarchy, whether or not a face set uses the vertex. This holds within 0.1% of the box’s largest bound plus one metre for 13,040 of the 13,054 Sekiro models and all 21,174 Elden Ring models that have no scaled node, and for the models with scaled nodes in the way the section there states; 22 Sekiro and 3 Elden Ring models match neither way. Observed
Meshes and buffers
Section titled “Meshes and buffers”| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 1 | bool | dynamic | Proven | |
| 0x1 | 3 | bytes = 0 | reserved | Proven | |
| 0x4 | 4 | u32 | material index | Proven | |
| 0x8 | 8 | bytes = 0 | reserved | Proven | |
| 0x10 | 4 | i32 | node index | Proven | |
| 0x14 | 4 | u32 | bone palette count | Proven | |
| 0x18 | 4 | u32 | bounds offset | Proven | |
| 0x1C | 4 | u32 | bone palette offset | Proven | |
| 0x20 | 4 | u32 | face set reference count | Proven | |
| 0x24 | 4 | u32 | face set references offset | Proven | |
| 0x28 | 4 | u32 | vertex buffer reference count | Proven | |
| 0x2C | 4 | u32 | vertex buffer references offset | Proven |
References and bone palette entries are 32-bit indices. Multiple buffers of one mesh carry attributes for the same vertex count. Observed Empty meshes with no face sets or buffers occur in Elden Ring, with bounds containing negative infinity and NaN; these bounds do not describe drawable geometry. Observed · Elden Ring
| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 4 | u32 | buffer ordinal within mesh | Proven | |
| 0x4 | 4 | u32 | layout index | Proven | |
| 0x8 | 4 | u32 | vertex stride | Proven | |
| 0xC | 4 | u32 | vertex count | Proven | |
| 0x10 | 8 | bytes = 0 | reserved | Proven | |
| 0x18 | 4 | u32 | buffer byte length | Proven | |
| 0x1C | 4 | u32 | buffer offset | Proven | Relative to the header data offset. |
The data block on the GPU
Section titled “The data block on the GPU”only in Sekiro Sekiro uploads a model’s data block (the header’s data offset and length) as one immutable GPU buffer, as stored, and binds it as both the index buffer, at offset 0, and each vertex buffer, at the buffer’s offset: the contents of 129 of the 238 vertex, index and shader-resource buffers a frame at the Ashina Castle gate uses are byte for byte the data blocks of map, object, character and part FLVERs, and every indexed draw of those buffers (1,063 in that frame, 5,357 in five frames) starts at a face set’s first index and draws that whole face set. Observed · Sekiro · five captured frames A face set’s indices therefore reach the GPU as stored, relative to its mesh’s vertex buffer. Observed · Sekiro The skinned meshes are the exception for their vertex streams, not their indices: see skinning. Observed · Sekiro
only in Elden Ring Elden Ring uploads a model’s data block as stored too, into a buffer of the block’s length rounded up to a multiple of 256 bytes, and binds the index buffer at offset 0 over the block’s length and each vertex buffer at its offset for its length. In one frame, 176 of the 251 buffers the frame used hold FLVER bytes found this way: in 165 of them the index binding’s range is the whole data block of an asset, part, character or map FLVER, each in a buffer exactly the block rounded up to 256 bytes, and the vertex ranges are the file’s vertex buffers. Observed[one captured frame, the keys of the bound ranges against those of every FLVER of the asset, part, character, m60 and m10 map binders]{games=“elden-ring”} Because of the padding, the buffer’s contents as a whole are never the block’s bytes, unlike Sekiro’s; a bound range is. Observed · Elden Ring
Face sets
Section titled “Face sets”| Offset | Size | Type | Field | Confidence | Notes |
|---|---|---|---|---|---|
| 0x0 | 4 | u32 | flags | Proven | |
| 0x4 | 1 | bool | triangle strip | Proven | |
| 0x5 | 1 | bool | cull backfaces | Observed | Sekiro draws a face set with it set with back-face culling and one without it with culling off |
| 0x6 | 2 | i16 | unknown 06 | Unknown | 1 on 85,996 of Sekiro's 110,365 face sets and 149,048 of Elden Ring's 277,113; up to 371 and 285 elsewhere |
| 0x8 | 4 | u32 | index count | Proven | |
| 0xC | 4 | u32 | indices offset | Proven | Relative to the header data offset. |
| 0x10 | 4 | u32 | index byte length | Proven | |
| 0x14 | 4 | u32 = 0 | reserved | Proven | |
| 0x18 | 4 | u32 | index width in bits | Proven | 16 or 32 on every face set of both installs; zero would inherit the header width |
| 0x1C | 4 | u32 = 0 | reserved | Proven |
| Flag or expression | Meaning | Confidence |
|---|---|---|
(flags >> 24) & 7 |
LOD level; Elden Ring also uses levels 3 and 4 for far stand-ins | Observed |
0x01000000, 0x02000000, 0x04000000 |
SoulsFormatsNEXT names the individual bits LodLevel1, LodLevel2 and LodLevelEx | Sourced · SoulsFormatsNEXT |
0x40000000 |
Edge-compressed indices | Sourced · SoulsFormatsNEXT |
0x80000000 |
Motion-blur face set | Sourced · SoulsFormatsNEXT |
(flags & 0x87000000) == 0 |
Neither a coarser LOD nor a motion-blur set | Observed |
Face sets are index lists of 16 or 32 bits: 110,157 Sekiro and 276,754 Elden Ring sets are 16-bit and 208 and 359 are
32-bit. No face set of either install is a triangle strip (the strip byte is 0 on all 110,365 and 277,113), so none
contains a restart marker (0xFFFF in a 16-bit set, 0xFFFFFFFF in a 32-bit one), every index count is a multiple of
three, and the value 0xFFFF in a 32-bit set (519 times in 177 Sekiro sets, 1,047 times in 356 Elden Ring sets) is an
ordinary vertex index. Proven · every face set of both archive sets The two reserved words at 20 and 28 are zero in every
face set. Proven · every face set of both archive sets
Which face set is the mesh
Section titled “Which face set is the mesh”Every mesh of both installs that has any face set with neither a coarser-LOD bit nor the motion-blur bit has exactly one, and it is the mesh’s first face set (43,312 of Sekiro’s 44,974 meshes and 83,740 of Elden Ring’s 89,029). The other meshes hold only coarser-LOD face sets (1,662 in Sekiro, 5,279 in Elden Ring, plus 10 Elden Ring meshes with no face set): separate meshes that exist for a distant level, so reading a mesh’s first face set as its LOD0 takes their coarse geometry for a finished mesh. Proven · every mesh of both installs The cull-backfaces byte is equal across all face sets of a mesh in every mesh of both installs, motion-blur and coarser-LOD sets included. Proven · every mesh of both installs It is not decided by the material: in Sekiro the byte takes both values among meshes of one material class, and among meshes that share one material, so a mesh’s sidedness comes from its own face sets. Observed · Sekiro
Which level is drawn
Section titled “Which level is drawn”only in Elden Ring A placed model draws one LOD level at a time, chosen per view each frame from its PartsDrawParam row,
the same row its texture level reads. The row holds a border
B and a play distance P for each of the five boundaries between levels 0 and 5 (lv01 at offsets 0 and 4, lv12 at
8 and 12, lv23 at 16 and 20, lv34 at 24 and 28, lv45 at 32 and 36), and s scales every border: the entry of row
lodType (the row’s byte at 80, rows 0 to 10) of LoadBalancerDrawDistScaleParam at the load balancer’s current
level (below 21), 1.0 where the row is missing (texture borders take rows 100 to 110 instead). The view distance d is
the eye’s distance to the model’s world box times a factor of the view. Observed · Elden Ring · read from the executable’s code
The function that fills the scales takes another param index only when a check returns anything but 1, and the check
returns a word it sets to 1 when it finds 0, which no other code or data of the executable refers to; that index is also past the
end of the game’s table of param names, so LoadBalancerNewDrawDistScaleParam_win64 is not read for these scales.
Observed · Elden Ring · read from the executable’s code and its references Which level of the scale param
applies is the load balancer’s state while the game runs; for each of the 679 placements of m60_42_36_00, the row
of its LOD type holds one scale at every level or is absent, so its borders do not depend on that state. Observed · Elden Ring · one area read
That factor sits in the view at the same place relative to the eye as the texture switch’s field-of-view factor, so it
is tan(fovY / 2) / tan(21.5°). Inferred · Elden Ring Frames of the running game fit a factor of 1.0 better than this (below).
- When bit 0 of the row’s word at 48 (
enableCrossFade) is set, the level is the largestkfrom 0 to 5 withd >= s × B + Pfor the boundary below it, and betweens × Bands × B + Pthe model is faded toward the next level by(d − s × B) / P. No earlier level is involved. Observed · Elden Ring · read from the executable’s code - Otherwise the level moves with hysteresis from the one remembered: the boundary above the current level is crossed at
s × B + P, the boundary below it ats × B − P, and every other boundary ats × B; the play distance is not scaled. From level 4 thelv01border is compared unscaled. The level remembered between frames is its low two bits (the model’s flag word, bits 5 and 6), kept for the main view only, so a model at level 4 or 5 is next evaluated from level 0 or 1. Observed · Elden Ring · read from the executable’s code - Shadow views add the row’s signed byte at 81 (
shadowDrawLodOffset) to the level, floored at 0, and measure their own distance; four view kinds take a fixed distance from a table instead. Observed · Elden Ring · read from the executable’s code
In nine frames at the Stormveil gate, the cross-fade is seen as two draws of the same meshes of one instance, with complementary
fade alphas (distance opacity): 44 of 44 pairs of
face sets add to 1, mostly with the larger alpha on the coarser set, and a model’s instances are split into one draw per
face set. Observed · Elden Ring · six frames The frames hold no place where the row’s borders are known, so the d >= s × B + P
test is not compared with them.
The level is handed to each mesh of the model as it is drawn; that a mesh then draws its face sets of that LOD level
((flags >> 24) & 7) is the reading of the face-set flags, not followed in the code. Inferred · Elden Ring The frames below show it.
only in Sekiro Sekiro draws one face set of one level per mesh draw. Over the 5,357 model draws of five frames at the Ashina Castle gate, 3,086 draw a level 0 face set, 1,140 level 1 and 1,131 level 2, and none draws a motion-blur face set, though 1,380 of the drawn meshes hold one. Observed · Sekiro · five captured frames What picks Sekiro’s level per draw was not read.
only in Elden Ring In four frames of the running game at the Stormveil gate (2,734, 1,979, 2,562 and 1,850 indexed draws,
9,125 in all), every indexed draw binds the index buffer over a model’s data block and draws exactly one face set: its start
index, index count and index width equal those of one face set of one FLVER, found by the keys of the bound ranges against
every FLVER of the asset, part, character, m60 and m10 map binders. Observed · Elden Ring · four captured frames, every indexed draw
Of the 9,125, 8,446 draw a level 0 face set, 247 level 1, 420 level 2 and 12 level 3; none draws a motion-blur face set or a
level 4 or 5 one. Observed · Elden Ring · four captured frames
Whether the level drawn is the one the row gives was tested on the 494 main-view G-buffer draws of assets that place one
instance, with the instance’s world matrix and the camera read from the draw’s constants and the distance taken from the eye
to the FLVER header’s box posed by the instance matrix. With the border B and play P of the asset’s row
(AssetEnvironmentGeometryParam row ggg × 1000 + mmm, its refDrawParamId) and s of 1.0 (rows 0 to 10 of the scale param
hold 1.0 at all 21 levels), 470 of the draws are of a level the rule allows at that distance (inside a cross-fade band either
neighbouring level, for a hysteresis row the band B ± P). Observed · Elden Ring · four captured frames, 494 single-instance draws
Nine more draw level 0 of a model whose face sets are all level 0 where the rule gives level 2: a model with no face set of
the level draws the coarsest one it has. Observed · Elden Ring Of the 15 that differ, eight are level 0 draws 0.1 to
0.9 m past the end of a cross-fade band with a fade alpha of 0.05 to 0.46 still on (the header box is not the placed model’s
box), and seven are not explained: six draws of AEG030_578 at level 1, 72 to 75 m away where its row’s borders are 10 and
40 m, and one of AEG004_133. Observed · Elden Ring The distance factor that fits is 1.0: from 0.85 to 1.13 the draws in range
number 446, 455, 459, 478 (0.98), 470 (1.0), 467, 463, 452 and 443, and 1.13 is what tan(fovY / 2) / tan(21.5°) gives for
the frames’ projection (P11 2.246, a vertical field of view of 48.3°). Observed · Elden Ring So the view factor is not that
formula taken from the frame’s projection matrix, and what it is is not settled. Observed · Elden Ring
A model in a cross-fade band is drawn at both neighbouring levels: the level 0 and level 1 face sets of one instance are
separate draws whose instance ditherFadeAlpha values add to 1 (0.7585 and 0.2414, 0.0543 and 0.9456, 0.4645 and 0.5354, the
three instances found in a band, all of rows with enableCrossFade); every other draw has alpha 1.
Observed · Elden Ring · four captured frames A mesh draws only a face set of the instance’s level: of the 1,230 pairs of a
placed model drawn at one level and one of its meshes, 730 of the 1,188 whose mesh holds a face set of that level are drawn at
it (the other 458 are not drawn in any pass counted, which hidden or culled parts also explain), and none of the 42 whose mesh
lacks one is drawn at another level. Observed · Elden Ring · four captured frames, placed models with one instance
The tested draws place one instance, with the model’s header box; draws of several instances (a batch shares one level) were not tested, and the factor that fits the frames (1.0) differs from the one the field of view of their projection gives (1.13). Seven single-instance draws follow no row.
Face counts in the header
Section titled “Face counts in the header”The total face count (offset 68) equals the number of triangles in all of a model’s face sets, degenerate and motion-blur
ones included, in all 14,459 Sekiro models and in 22,048 of Elden Ring’s 22,169. Proven · Sekiro The other 121
Elden Ring models, all version 0x20014 (the 119 SpeedTree models, FC_M_0000_M and FG_A_0000_M), count only face sets
with no LOD bit (0x7F000000) set in 120 of them. Observed · Elden Ring The version does not mark a SpeedTree model:
FC_M_0000_M and FG_A_0000_M have it without the header word 0x8000 at 0x6A, which is what the 119 SpeedTree models
share. Observed · Elden Ring The count at offset 64 equals the number of non-degenerate triangles in the face
sets without the motion-blur bit in 14,358 Sekiro models and 21,771 of the 22,048 Elden Ring models that count all
sets; in the rest, which include _S.flver models, it differs and can exceed the triangles present.
Observed
Sekiro’s c1010 meshes have LOD0, LOD1 and LOD2 face sets, each with a motion-blur twin (flags 0, 0x01000000
and 0x02000000, each also with 0x80000000), and no strips. Observed · Sekiro
No shipped model uses strips, so this rule is unexercised by the installs. For strips, 0xFFFF restarts the strip and resets parity. Degenerate triples emit no triangle but still advance
parity; odd triples reverse the index order. Whole-install comparisons include the resulting index ordering.
Proven · whole-install reference population
Winding and culling
Section titled “Winding and culling”In the left-handed source frame, a triangle (a,b,c) faces away from cross(b−a, c−a): its front is on the
side opposite that vector. All 26,286 Sekiro LOD0 face sets that cull back faces wind this way; face sets of
M[Shadow] shadow-proxy materials wind the other way. Observed · Sekiro Reflecting Z into the right-handed
frame (see coordinate frames) therefore makes the front the counter-clockwise
side without reordering indices. Inferred
About 8,200 non-shadow Sekiro meshes, 19.4 million triangles, have face sets with the cull-backfaces flag clear;
they include roofs, walls and the AMSN_light_e light geometry. The game draws them two-sided: in the G-buffer pass
of five frames at the Ashina Castle gate, the 692 draws of face sets with the flag clear have culling off and the 2,391
with it set cull back faces, with no exception. Observed · Sekiro · five captured frames The shadow-map passes
follow the flag too, except for 95 draws of face sets with it set that are drawn without culling. Observed[five captured
frames]{games=“sekiro”}
Order of the file
Section titled “Order of the file”After the header and the tables, the file continues in this order, each section starting at a multiple of 16 bytes: for
version 0x2001A, the skeleton set’s two lists of 16-byte records (they follow the descriptor at once); the vertex layouts’
members (20 bytes each); the meshes’ bounds (six floats, nine in version 0x2001A); the bone palettes; the lists of face
set indices of each mesh; the lists of vertex buffer indices of each mesh; the material extension (GX) area; the strings,
each material’s name and definition path followed by its textures’ paths and slot names, then the bones’ names; and the
data block. Proven · every FLVER of both installs The face set table and the vertex buffer table list the meshes’ face sets
and buffers in mesh order, so each mesh’s lists are consecutive runs of indices (all 14,459 Sekiro and 22,169 Elden Ring
files). Proven A mesh without a bone palette points its palette offset at the start of the palette section; 44,972 of
Sekiro’s 44,974 meshes and 89,027 of Elden Ring’s 89,029 have none. Proven The bounds offset is 0 for 2 Sekiro and 969
Elden Ring meshes. Proven In the data block each mesh’s face set indices come first and then its vertex buffers, each
starting at a multiple of 16 bytes (the SpeedTree models reverse the order, see below); the block ends at a multiple of 16
too. Proven
The skeleton set’s first list is the model’s bone tree (parent, first child, next and previous sibling, and the bone’s own
index) in every one of the 14,442 Sekiro and 22,047 Elden Ring files of version 0x2001A; the second list is the same in
13,399 and 18,276 of them and a reordering of the bones in the others. Proven The GX area runs from the end of the buffer
index lists to the first string. Its lists are the GX items of the materials followed by a terminator, with the id
0x7fffffff, the word 100 and the length 12 (25,109 lists in Sekiro, 32,208 in Elden Ring); several materials share one
list in 4,898 Sekiro and 11,705 Elden Ring files, and 5,115 Sekiro and 20 Elden Ring files hold lists that no material
names. Proven The header bounds and face counts, the meshes’ bounds and the face sets’ index widths are stored values
that cannot be derived from the vertices in every file (see above); a face set states the width of its indices (16 or 32)
whether or not the header states one. Proven
SpeedTree models
Section titled “SpeedTree models”The 119 Elden Ring SpeedTree models differ from the layout above in four places: each texture path is followed by one more zero unit (so a path string ends in two zero units), the data block starts at the next multiple of 2,048 bytes after the strings, each mesh’s vertex buffers precede its face sets, and the file is padded with zeros to a multiple of 2,048 bytes. Their header word at 0x48 is 16 and the one at 0x68 is 5, which also makes the GX terminators state their length without the 12 bytes of their header (684 lists, length 0). Proven · Elden Ring A writer that follows the order and the rules above rebuilds all 14,064 distinct Sekiro and 20,557 distinct Elden Ring files byte for byte from their parsed tables, vertex buffers and indices. Proven · an independent writer over every FLVER of both installs Every vertex buffer of every distinct file (45,371 in Sekiro’s, 83,004 in Elden Ring’s, and 967 in the SpeedTree models) is rebuilt from the decoded attributes of vertex formats to the same bytes: each 8- and 16-bit encoding is inverted exactly by rounding, which holds for every stored value. Proven
Material and texture records are described under FLVER material bindings; nodes and attachment points under nodes and skinning.
The one entry rejected before nested-model inspection is outside the model census. Its unread payload cannot establish whether it contains additional FLVER records or other resources. Unknown · Sekiro