How Kenshi builds characters

1 The whole pipeline

Everything that makes a Kenshi face or body passes through these stages. Each one is a function in kenshi_x64.exe that was decompiled and re-implemented. The addresses are on the method page.

2 Base assets

Each race and gender has one skinned mesh with the head built in. The morph targets (OGRE "poses") are stored in the mesh and only touch head vertices. All 30 races share the same two 30-bone 3ds Max Biped skeletons (Bip01 …, no face bones). That's why body proportions and posture work identically for a human, a Shek, a Hive drone or a skeleton robot.

3 Sliders and what they drive

AppearanceManager::loadEditorXMLData reads each <Config gender> and <Category> and sorts the entries into three kinds:

Missing attributes get defaults: mid = the rounded midpoint, and random_variation = 40 % of the range (GLOBAL CONSTANTS appearance random deviation percentage = 0.4). Many morph sliders don't centre on 0. For example, Greenlander male Eyes height runs from −150 to 100 with mid −25.

// DataRangePose: slider value v (an integer percentage) → pose weights
if no opposite:  w[target]   = v × 0.01            // may be negative: the offset is subtracted
else:            w[target]   = max(v, 0)  × 0.01
                 w[opposite] = max(−v, 0) × 0.01

4 Morphs are baked, not animated

When a character spawns, AppearanceManager::createMorphedMesh clones the base mesh and calls Ogre::Mesh::softwareVertexPoseBlend(w, offsets) once per non-zero pose. That adds w × offset to every vertex in the pose. Then it deletes the poses and switches the entity to the copy. Nothing is morphed per frame.

The live editor works on an unbaked _CHAREDIT_ copy and applies the difference (new − old) each time a slider moves.

5 Bone sizes: the body sliders

Kenshi's OGRE fork adds two fields to every bone, and AppearanceHuman::updateProportions sets both on all 30 bones in one pass:

derivedScale(b) = boneSize(b) ⊙ localScale(b)

derivedPos(b) = derivedPos(p) + orient(p)·(size(p).y × posSize(b) ⊙ localPos(b))

The function also folds in two physique factors that grow with the character's stats: muscle (up to ×1.27 on arms and legs) and thinness (down to ×0.4 on breasts). Both are 0 for a new character. An excerpt, all in float32:

hgt  = Height/100        fr = Frame/100        leg = Leg length/100
size(Pelvis)   = (hips·fr, hgt, hips·fr)
size(Spine2)   = (((chest−1)·0.45+1)·fr, hgt, ((chest−1)·0.9+1)·fr)
size(UpperArm) = (ab·fr, hgt, ((ab−1)·1.5+1)·fr)        ab = Arm bulk/100 · lerp(thin,1,0.7) · lerp(muscle,1,1.27)
pos(UpperArm)  = (Shoulders/100 · s2x, 1, 1)            ← the chest pushes the shoulders out
size(Neck)     = (Neck width·s60·m13·fr, Neck length, Neck·s70·fr) / 100
size(Head)     = (headFr·hs·Head shape/100, hs, headFr·hs)   headFr = (fr−1)·0.25+1

6 Posture is an animation frame

Posture, Shoulder set and Neck position aren't scales. AppearanceHuman::setPosture enables one skeleton animation per slider at weight 1 and parks it at time = length × value / 100:

Each clip has a track on all 30 bones. The key at 0.033 s is the identity. OGRE applies a track by adding its translation and post-multiplying its rotation, with keys interpolated linearly (nlerp). It's a neat trick: artists author a posture range as an animation, and a slider scrubs through it.

7 Skin, head textures and the shader

Everything about the surface happens in one pixel shader, character.hlsl: main_fs:

body  = tex(diffuse, uv) + tex(headDiffuse, uv + (0,1))       // head island added on
mask  = tex(mask, uv).r  + tex(headMask, uv + (0,1)).r         // r = skin (eyes and underwear excluded)
body.rgb *= 1 − (1 − skinTone) · mask                           // skin tinting
body.rgb  = lerp(body.rgb, hairColour · hairTex, hairAlpha)     // painted hair
body.rgb  = lerp(body.rgb, hairColour · beardValue, beardValue) // stubble
glow      = headMask.g                                          // Scorchlander eyes

The skin tone is a 1-D ramp. The slider runs from 0 to (stops − 1) × 10, and every 10 units is one colour stop, linearly interpolated (DataRangeVector::getValue).

Hair colour

Hair colour is HSB, stored as three 0–100 floats. It's shared by the painted hair layer and the hair mesh. The randomiser picks one of the race's weighted presets and converts it from ARGB:

8 Hair and beards

An ATTACHMENT record (slot 2 = hair, 13 = beard) has up to two parts:

9 Randomisation and NPC faces

All randomness is MSVCR100's rand(), an LCG (s = s·214013 + 2531011, 15-bit output). U(−1,1) = rand01()·2 − 1, and every randomised slider gets round(mid + variation × deviation × U).

At spawn a generic NPC gets morph index = int(rand01() × morph num), which is 0–4 for humans. When its body is built, the game forms a mesh name, and only if no mesh of that name exists yet does it seed the generator with that name and roll the face:

name = race.stringID + "_" + ⌊weirdness × 10⌋ + "_" + ("Male"|"Female") + morphIndex
       e.g.  17-gamedata.quack_5_Male3
srand(FNV1a_32(name));  randomPoses(app, weirdness)  →  bake  →  cache under name

10 How much variety

11 Quirks and limitations

1. Normals ignore morphs. Strong morphs keep the base mesh's lighting.
2. Five faces per NPC type. The face pool is tiny and fixed by the name hash. Variety comes from other channels.
3. The fixed-appearance mesh cache uses a truncated hash. NPCs with a .bod2 outside the player faction share meshes by a hash of each weight cast to an integer. Typical weights (|w| < 1) all hash to 0, so whichever such NPC is built first can define the face for others in that session.
4. NPC skin is uniform over the whole ramp, while the editor's Randomise stays within ±40 % of the middle.
5. Jaw is a bone slider for men and a morph pair for women.
6. Robot races (Skeleton, P4 Unit, Screamer, Soldierbot) reuse editor_data_human.xml, but their meshes have no poses, so 17 face sliders do nothing.
7. Wrong asset paths still work. Several HEAD records point at the wrong folders, and OGRE resolves textures by name anyway.
8. Grouped morph sliders ignore deviation, although no vanilla human file uses random_group on poses.