The BMF format has no leading signature; it immediately starts with two strings, followed by six types of repeating groups.  The equivalent SKN format follows the same structure:

	string-skin-name
	string-texture-name
	count-of-bones
	string-bone-name ...
	count-of-faces
	<face> ...
	count-of-bone-bindings
	<binding> ...
	count-of-texture-points
	<texture-point> ...
	count-of-blending-weights
	<blending-weight> ...
	count-of-verticies
	<vertex> ...

The first string is the name of this skin.  Skin files are invariably named after the contained skin, so if the skin is named foo, it would be found in a file named foo.bmf or foo.skn. 

The second string is the default texture to apply to the mesh.  This default may be overridden (and often is, particularly for character skins).  If the texture is always overridden, the texture name is sometimes given as "x" or some other nonsensical name. 

A skin is rendered relative to one or more bones in a skeleton.  The list of bones names the bones that this skin will use as its basis; the count of bones gives the number of bones in the list.  Each bone is a string; it matches a bone named in the skeleton.  The order is significant; subsequent entries use an index into this list to refer to the bone.  Note that a skin need not surround the bone(s); it may well identify a volume that is offset from the bone.  Moreover, more than one skin may be applied to a given bone.  This is how a character can carry a chisel or wear a hat; one skin covers the character and the other provides the object. 

A face is a set of three vertices.  It simultaneously represents a triangular region of the surface being rendered and a triangular area in the texture being wrapped.  The count of faces gives the number of faces present. 

A bone binding associates a subset of the vertices with a bone.  The count of bone bindings gives the number of bone bindings present. 

A texture point is a 2D location within the texture image; it matches a corresponding raw vertex.  In other words, the texture point maps a 2D texture location to a 3D vertex; after the vertices are calculated and converted into a screen location, each triangular face of the texture is translated onto the screen.  The count of bone bindings gives the number of bone bindings present. 

A blending info is used when moving a shared vertex (that is, when deforming the mesh).  The count of blendings gives the number of blendings present.  There is one blending info for each blended vertex. 

A vertex entry has the position and normal values (for both raw and blended vertices).  The count of verticies gives the number of verticies present. 

The number of bone bindings is always exactly the same as the number of bones specified, and each bone is specified in a binding exactly once, in the same order.  Moreover, the number of vertices is always equal to the number of texture points plus the number of blendings.  (This is true of all known samples, supporting the speculation about how these elements fit together.) 

This means that the layout is more complex than it need be.  However, if we assume that the memory layout used by the game parallels the file format, then all of the verticies are located together, which allows graphics transformations to be pipelined in a more cache-friendly way. 

The redundancy of the bones and the bindings is a bit puzzling, but if we assume that this layout evolved from an earlier one that only allowed rigid meshes, then these could have been pre-existing elements. 

Most other formats contain very little redundancy, so it's quite possible there are some aspects of this format that are not yet understood.  Keep in mind that the assumptions made here could be wrong. 

A face consists of three integers.  Each integer is an index to a raw vertex in the list of vertices.  The SKN format lists these three integers on a single line:

	vertex-ix-1 vertex-ix-2 vertex-ix-3

The face vertices are listed in counter-clockwise order.  This can be used to determine the normal to the face (that is, the direction perpendicular to the face pointing outward), which is needed when rendering. 

Bone bindings attach a subset of the vertices to bones.  Each entry consists of five integers.  The SKN format lists these five integers on a single line:

	bone-ix raw-ix raw-cnt blend-ix blend-cnt

The bone index is an index into the list of bones, indicating to which bone the vertex is being bound. 

The raw vertex index is an index into the texture point section (below).  The raw vertex associated with that texture point is the first raw vertex to bind to the bone.  The raw vertex count says how many consecutive vertices are to be bound to the bone.  The vertex count is always positive; it is not known if it is possible to have a binding with only blended vertices. 

The blended vertex index is an index into the blending info section (below).  The blended vertex associated with that blending info is the first blended vertex to bind to the bone.  The blended vertex count says how many consecutive vertices to bind to the bone.  If the blended vertex count is zero, meaning that there are no blended vertices to bind to the bone, the blended vertex index is specified as -1. 

Both the raw index and the blended index start at zero in the first entry and subsequent active entries are incremented by the respective counts.  As such, the index and count values are redundant, and it's puzzling why both would need to be included. 

A texture point is a location in the texture being used to wrap the mesh.  There is one texture point for each raw vertex.  Each entry consists of two 32-bit floating point numbers.  The SKN format lists these two numbers on a single line:

	x-offset y-offset

The X and Y offsets are between zero and one.  They provide the grid location for a point within the associated texture. 

The vertex associated with this texture point is located in the vertex section (below).  The index for the vertex information is the same as the index to the texture point. 

The blending info identifies the raw index associated with a blended index (that is, the raw index that the blended index will deform) and provides the blending weight.  The SKN format has the same values on a single line, but note that the values are reversed:

	vertex-index weight

The weight is an integer that is used during blending.  Exactly how it works is unknown; hopefully, some expert on 3D graphics will elucidate it someday. 

The vertex index is an index to a raw vertex in the vertex section (below).  Although it would be possible for more than one blended vertex to refer to the same raw vertex, there are no cases where this occurs.  The mathematics of blending multiple verticies suggest that it is unlikely, since the required transformations are not associative, so the results would differ depending on the order in which blends were applied.  The limitation to at most one blending for a raw vertex is probably a restriction of the format. 

The vertex associated with this blending info is located in the vertex section (below).  Assuming that there are N raw vertices, the index for the vertex information is N plus the index to the blending info. 

This component consists of six 32-bit floating-point values.  The SKN format lists the values on one line:

	z-off y-off x-off z-norm y-norm x-norm

A vertex reflects an offset in 3D space and then normal orientation for the point (that is, which direction is "outside").  A mesh must have at least one face, so it follows that there must be at least three vertices. 

Three floating point numbers give the (x, y, z) value of the offset. 

Three more floating point numbers give the (x, y, z) value for the normal direction (that is, pointing most directly away from the inside). 

Vertices are divided into two segments.  The first segment corresponds one-for-one with the texture points.  The second segment corresponds one-for-one with the blendings. 

Each vertex is bound to exactly one bone, although the format allows a vertex to be bound to multiple bones (or not to be bound at all).  This is probably a restriction of the format.