Status: 2026-10-22. Lockout and Ascension convert through the same
command as the Halo 1 maps and start from MULTIPLAYER (mjolnir_auto host LOK slayer private, host ASC ctf private): their own worlds, the Spartan
standing in the BSP, the pickups resting where Halo 2 put them, every
material applied. Lockout was played by a person on 2026-10-21; the glass,
snow and sky they found wrong are fixed (reflecting tinted glass, the
chambers' gas behind it, snow where Halo 2 puts it, cloud banks in place of
flat white planes). Ascension was compared side by side with MCC on
2026-10-22: its turning antennas and storm sky match. The Halo 1 pipeline is unchanged; its outputs for Chill
Out and TST are byte-identical before and after the Halo 2 work.
MCC's Halo 2 multiplayer maps (halo2/h2_maps_win64_dx11/*.map) become
standalone Campaign Evolved maps the way classic CE maps do
(ce_map_conversion.md): their own collision, render
geometry, materials and lightmaps, player starts, pickups and markers, under
the Megalo engine.
export HCE_PAKS=".../Halo Campaign Evolved/Meteorite/Content/Paks"
MCC=".../Halo The Master Chief Collection/halo2/h2_maps_win64_dx11"
tools/level/convert_ce_map.sh "$MCC/lockout.map" LOK out/lok --install
shared.map and textures.dat must sit beside the map (they do in an
install): every weapon, vehicle and most shaders live in shared.map, every
bitmap's pixels in textures.dat.
Which game a map is from
mjolnir cache info <map> reads the header and names the game, the build and
the tool that stages it (h2_cache_format.md, "Telling the
games apart"). convert_ce_map.sh asks it first:
| map | stager |
|---|---|
| Halo 1 PC or Custom Edition (version 7, 609) | halo2ue (HalcyonRing), unchanged |
| Halo 2 MCC (version 13, game index 1) | mjolnir cache stage (crates/blam-cache) |
| Halo 1 MCC, Halo 3, ODST, Reach, Halo 4, H2A | refused, by name, before anything runs |
The staging's manifest.json says which game it came from (source:
halo_ce or halo2_mcc), and the few steps that are CE's alone branch on it:
ce_fog.py and ce_sounds.py (they read the CE .map itself), the
lightmap solver (CE's radiosity: LIGHTMAP_SCALE defaults to 0, keeping Halo
2's own pages) and the foliage (CE detail maps: FOLIAGE defaults to 0).
gen_ce_level.py takes its tag map (defs/level/h2-tag-map.json), menu name
and description from the same field.
What staging does differently
mjolnir cache stage writes the files halo2ue writes for Halo 1, in the same
units and axes, so every later step reads them unchanged:
-
Collision. Halo 2's 16-bit tables are widened into the CE element layout (
collision_0.bin,layout: "ce_pc_v7"). Instanced geometry, which CE never had, is placed in world space (scale, forward/left/up, position), each polygon fan-split into standalone two-sided triangles that keep their material and flags, and appended as thescenery_surfacestail CE scenery uses;merge_ce_collision.pyadds the props after it. Lockout: 3,162 BSP surfaces, 75 instances (7,312 triangles), 15 crates (840), more than one 16-bit tree holds, solevel collisionputs the tail behind an instance of its own (as Timberland's trees). -
Surface materials. A Halo 2 shader names a global material (
hard_terrain_concrete), not a CE material type; staging maps it onto the 29 the game ships: the same name, else an alias (concrete is stone,energyisenergy_hologram), else the name shortened a word at a time and tried again the same way (hard_metal_thin_hum_gratingtohard_metal_thin), elsedefault_material. Each substitution is printed. -
Render geometry. Clusters and instanced geometry go into one
bsp_0.gltf, a primitive per (shader, lightmap page), with each cluster's and instance's page from the lightmap tag and Halo 2's lightmap coordinates. Halo 2's triangles already wind counter-clockwise, so their order is kept (CE's are flipped). -
Shaders. MCC keeps no shader parameter names; each template's bitmap slots and tiling are read in the template's order (
h2::render::template), and what the compiled shaders do was read back from the DXBC in the shader pass tags (h2_cache_format.md). Opaque shaders become environment-master summaries (base, detail, second detail blended by the base's alpha where it is high, the reverse of CE's, bump, self-illumination; alpha tested for the alpha-test templates. The single-pass ones' compiled lightmap pass discards where the bump map's alpha rounds to 0: Zanzibar's palm fronds, beach bushes and tree foliage keep their outline only there, so their base map is staged with the bump map's alpha as<stem>__cut.png. The othertex_bump_alpha_test*shaders keep the outline in the base's alpha, the bump map's, or both (of the 26 stagings' fourteen: grates on Zanzibar and Foundation in the base; the temple vines on Sanctuary and Warlock, Derelict's vines, Headlong's girders, Midship's torn pillars and Terminal's generator in the bump map; Lockout's grate in both), so<stem>__cut.pngtakes the product of the two. Cut on the base alone, the bump-map ones drew as black quads, 2026-11-21 playtest).tex_bump_plasma_one_channel_illum(Zanzibar's fusion coil cores) is a lit base and detail plus the plasma pass's glow from bitmap 3: red times a band of its alpha around pixel constant 2's, plus green and blue each times a pink pixel constant. It becomes CE's three-channel self-illumination (<stem>__glow.png: green, blue, and red x the band baked at the shader's level, tinted by pixel constants 3, 4 and 5; a colour image in one channel drew white). Read as a detail map, its magenta channels drew a pink and black grid.overlay(Zanzibar's Camp Froman sign, the military crates' stencils) is 2 x base x tint, drawn as a double multiply. On Zanzibar the multiply master draws nothing in the after-DOF translucency pass (a black multiply on the sign stayed invisible, and appeared withr.SeparateTranslucency 0; the same black multiply draws on Chill Out's glass, cause not found), so the multiply is baked into an alpha-blended copy,<stem>__overlay.png: black at 1 - m where the overlay darkens the frame by m (exact), clear at neutral grey and where it brightens: no blend brightens whatever lies under it, and as its hue at (m - 1) / 2 a crack map's near-grey laid a pale sheet over Sanctuary's dark ceilings.water_edge_blend(Zanzibar's flat plane at sea level) writes its map's alpha into the frame's alpha only, a mask the water fades by; its geometry is left out (drawn opaque without a map, it was a big white patch on the beach). Water (water_pool,water_pool_cube: Beaver Creek's creek, Coagulation's cave pool, Sanctuary's streams) mixes the rippled frame behind with its reflection map by a fresnel term (its fresnel map's alpha: 0 looking straight down, 0.72 at a grazing angle). It goes in as CE's own water (swat, M_CE_Water): the reflection (a cube, or a 2D reflection map on all six faces) along the normal rippled by its ripple map (bitmap 0, a normal map as CE's ripples are, in two scrolling layers), added into the frame, weighted from 0 straight down to 0.72 at the edge (flag 0 over the master's white base). Drawn as a chicago cube blended over the frame, Beaver Creek's creek was an unmoving glossy picture of its reflection map. Waterfalls (waves) are min(1, mask x A + mask x B) x C, each scrolling: CE's four-stage chain as (A + B) x mask x C.tex_bump_illum_3_channel(Backwash's blue lights) has a grey detail before its base, and its glow map's channels tinted by pixel constants 4, 6 and 7 as CE's three self-illumination colours. An alpha-tested template that cuts out on its bump map keeps a placeholder base (Backwash's canopy, color_black), taken to the bump map's size.tex_detail_blend(Sanctuary's ground, the Mombasa trees) is a base and two details blended by its alpha, the details' scales in vertex constants 2 and 3;tex_illumandtex_illum_bloom(Backwash's fungus, Triplicate's lights) a base, a detail and a glow map;decal_simple(Street Sweeper's road stripes, Headlong's signs) its one map alpha blended. A template with no slot layout falls back to the shader's runtime diffuse map, drawn opaque, which is how these lost their details, glow and cut-outs. Halo 2 tiles each map by a u and a v scale, and many are uneven (the palm bark's detail and bump 2 x 12, the beach's sand 128 x 64); CE's environment shader takes one scale per map. The base map's tiling is in the UVs; a detail or bump map tiled unevenly relative to it is staged as a copy repeated to the ratio (<stem>__x<nu>y<nv>.png, at most 16 a side) and drawn at the smaller scale. Read as u alone, the palm's detail was stretched six times along the trunk. -
Decals. The scenario's decals (Zanzibar's 40 caution, safety and warning signs, the CAUTION over the beach gate) go to the placement's
decalswith their bitmap, radius and the bitmap's aspect. tools/level/gen_ce_level.py lays each as a quad on the nearest surface within 3 m, by true distance over every triangle whose bounds come that close (by centre, the flywheel room's sign missed its big wall triangle and went onto a slanted face, tilted and half buried), its longer side twice the radius, drawn with the transparent alpha master over the cooked bitmap; tools/level/ce_material_spec.py cooks the bitmaps with the map's. By layer: lit alpha blend (0, 1) as it is; multiply (3) and double multiply (2: bullet holes, scorches, Desolation's and Warlock's team emblems) with the multiply baked into an alpha-blended copy (<stem>__mul<gain>.png, as the overlays, times the bitmap's alpha); max (4) and add (5) on the additive master. Drawn as plain alpha, the rust decals were orange blobs and the emblems solid bars. Glass (one_alpha_env) becomes CE's glass shader: the base map tinted by the albedo and facing tints, blended by its alpha, unlit, and the environment cube map reflected through the specular mask with the environment tint; the cube's six faces are staged in D3D order. The two-layer glass (two_alpha_env_illum: Turf's storefront and stairwell doors, Triplicate's glass rails, the medical tent's panels) has the same slots and pixel constants, a second glass layer in slot 4, and goes in the same way;two_alpha_env_detail(the Forerunner "invisible" glass) has only placeholders and draws nothing. Read through the transparent catch-all, slot 0's reflection cube was drawn as a picture: Turf's stairwell door was an opaque dark sheet with nothing behind it to stop a player.tex_bump_env_alpha_test_combinedcuts out on the base's alpha times bitmap 1's (Turf's damaged stucco: a solid door base, the splintered boards inbase_stucco1_damaged_01_alpha; the chainlink fence keeps its holes in the base, alpha_white in slot 1). Change colours (tex_bump_one_change_color: Turf's panel trucks and crates) are base x lerp(1, the object's colour, bitmap 2) in the compiled lightmap pass; the mask goes in as CE's shader_model multipurpose alpha (<stem>__mp.png) and each prop placement carries its object's colour permutations (obje +0xAC) aschange_colors, Halo 2's weights (shares: the truck's off-white 0.4, red 0.2, tan 0.2) summed into CE's running cut-offs, so tools/level/merge_ce_scene.py draws one per placement into the object lighting page as it does for CE scenery; a placement's own colours (active bits at +0x38, ARGB at +0x3C) win. Read without the mask, every truck drew its untinted off-white base. Self-illumination (tex_bump_illumand its kin) is a pass of its own,default_self_illumination: saturate(glow map x pass constant 1), added over the lit surface, not lit with it (Turf's light fixtures are black where they glow). The template's remapping table names the pixel constant (2 for tex_bump_illum, 0 for tex_bump_illum_no_specular); an animated parameter on descriptor 0x81 drives it instead, a periodic colour function going in as its wave between its darkest and brightest non-zero colour (the storefront signs jitter between 0.46 and 0.5). The environment master adds it after the fog whenSelfIllumAddis set. The "two plus two" shaders (the sky's cloud banks, the containment gas) are mask x layer x layer, tiled and scrolling as the shader animates them, alpha blended; the plasma shaders (plasma_alpha: Zanzibar's flywheel lightning, the teleporter beams, Lockout's grav lifts) draw withM_H2_PlasmaAlpha(unreal/MJOLNIRMaterials/Scripts/build_h2_materials.py,/Game/MJOLNIR/H2, chunk 981 beside the runtime pack), the compiled shader as it is: noise A's blue and noise B's red, each scrolling, banded into a sharp ridge where they meet and twice more inside it, coloured between pixel constants 1 and 0 by the second band plus 3 on the innermost, faded by the mask's alpha, added. The staging keeps a chicago approximation beside it (h2_plasmain the shader summary; without the master, noise x noise x mask in the bands' mean colour drew soft clouds). All of these draw in the translucent mesh. Opaqueenvtemplates (thetex_bump_envfamily) reflect their cube map as Halo 2's lightmap pass does: the cube along the reflected eye vector, times a colour and a brightness each between the glancing and the facing value, masked by the albedo's alpha and dimmed with the light, added to the lit surface. The cube is whichever of the shader's bitmaps is one; the template's black placeholder cube reflects nothing. 22 of the 24 maps have such surfaces (Lockout only its grav pads; Ascension its Forerunner windows and panels). -
Sky layers. Besides the alpha and "two plus two" layers, Ascension's sky uses two more templates, read back from their compiled shaders: the cloud cover (
sky_two_alpha_clouds: a cloud map tiled 8x and scrolling, times a cover mask, colour and alpha, alpha blended) and the sun shafts (sky_one_add_illum_detail: a mask's colour times its alpha, times a scrolling detail, tinted, added). Drawn as one map each, the cloud map covered the whole dome in flat grey and the shafts were white wedges. Additive clouds (two_add_clouds,sky_two_add_clouds: Tombstone's sky dome, Gemini's sky, the recharge stations' glow) are min(1, 2 x bitmap 0 x bitmap 1), faded by pixel constant 0's alpha: CE's double multiply, or bitmap 0 alone where bitmap 1 is default_multiplicative (50% grey). The Covenant holo panels (two_add_detail_masked: Midship, Desolation, Gemini) compile to the same product of the panel map and a static map, plus a readout tiled 4 x through the panel's alpha; they go in as the clouds do, without the readout. Drawn from the static alone, they were solid white blocks. Lightning (Colossus, Triplicate) has that alpha at 0 and flashes by an animation the conversion doesn't carry, so it isn't drawn. The fusion coils' bloom (two_add_env_illum) is bitmap 3 tinted by pixel constant 3, added; the storm layers and horizon gradients (sky_one_alpha_env_clamped, Colossus, Containment) takeone_alpha_env's slots. Read with the catch-all additive slots (bitmap 1), these drew nothing or only their mask.add_illum_detail(Gemini's hologram halo: a ring map through scrolling scanlines) andone_add_illum_detail(the light volumes of Gemini, Containment and Waterworks) are the sun shafts' template outside the sky, drawn the same way; the facing colour's alpha (vertex constant 6.w: 1 on the sun shafts, 0.15 on Gemini's white volumes) scales the tint, andadd_illum_detail, whose five constants are only the maps' transforms, has no facing colour. Drawn from bitmap 1 alone, the halo was a solid grey ring of scanlines. These and the holo template fade by view angle: the vertex colour's alpha runs from a glancing alpha to a facing one by N.V (constants 7.w and 6.w; the holo template's 11.w and 10.w), so where the facing alpha is higher a volume seen edge-on vanishes. That goes in as CE'sframebuffer_fade_mode2 (|N.V|); without it Desolation's light shafts (a holo-template volume with a white mask) were solid white slabs. A transparent template's textures, transforms and scrolls are read the way halo2.dll reads them: a constant's descriptor names its texture slot (bits 10-12) and row (bits 5-9: 14 and 15, the 2D affine rows), the template's remapping table names each slot's bitmap, and an overlay's function is evaluated as the engine's evaluator does (identity, transition, periodic slide, linear with its own slope; the engine adds the translation, as CE's masters add their animation). -
Sky. The sky's lights (yaw, pitch, colour, power, diameter, whether the lightmaps used them), outdoor ambient and atmospheric fog go to the placement as halo2ue puts a CE sky's, so the level's sun, sky light and fog follow them. Halo 2 stores the ambient as a colour alone; it goes in at CE's usual power, 0.2 (at 1, Ascension's lit the player and weapons 3.8 times too bright). Lockout's light lit nothing (its radiosity flags are clear; the sky model lit the lightmaps), so its sun comes from the lightmaps' incident directions, as for a CE map without one. Halo 2's atmospheric fog covers the sky as well: one at full density (Backwash's swamp, opaque at 20 world units) also gives the level
sky_fog, so everything past the opaque distance, the black sky dome included, is the fog's colour (gen_ce_level.pysky_and_weather; Backwash's sky drew black above the fog). -
Placements. Halo 2 spawns every multiplayer pickup and vehicle through netgame equipment (item and vehicle collections): each becomes halo2ue's
netgame_equipmentorvehicleentry naming the collection's item. Netgame flags take CE's names where CE has the thing (CtfFlag,OddballSpawn,HillFlagwith its hill index,TeleportFrom/TeleportTopaired by identifier); assault, territories and headhunter keep names the tag map leaves out. Halo 2 spawns by influence, so its player starts carry no CTF side (Lockout's are all team 0); each start takes the side of the nearer CTF flag spawn, so a CTF game has red and blue spawns. A start (0x34 bytes) lists four game types at0x14(CE's numbers, plus 6 Headhunter, 7 Juggernaut and 8 Territories) and a spawn type for each at0x1C(0 both, 1 initial spawn only, 2 respawn only), staged asgame_typesandspawn_types. A start that lists no game type serves every one: Containment, Relic, Sanctuary and Warlock list none on any start, and Terminal's 88 untyped starts stand beside 61 All games ones. The level generator places them by game type (ce_map_conversion.md, "Spawn sets"); spawn types are not used yet. Props are scenery and crates (bloc), staged with their render and collision models. A prop with no collision model collides in Halo 2 by its physics model's solid shapes alone (the boxes, polyhedra and pills whose material is not a phantom's): Burial Mounds' and Elongation's and Gemini's invisible boxes, Zanzibar's beach bushes. The stage writes those as its collision (crate::h2::phantom::solid_triangles, each shape's planes closed into a triangle mesh; a pill as the box round it). The surfaces are in the built level (Elongation gains 96), but no difference has been shown in play: dropped on Elongation's first box a player lands on a real surface 0.2 world units above its top, with or without it. A prop with both keeps its collision model, which is what projectiles hit in Halo 2. Game-type props (the CTF and territory flag bases) are left out: the level's own CTF stands replace them. -
Planar fog. A BSP's fog plane (Ascension's cloud deck, Lockout's haze below the map, the water of Dune, Needle and Zanzibar) goes to
fog.jsonasce_fog.pywrites a CE map's, so the masters fog what lies below the plane by its depth under it and its distance, as CE's planar fog does. Halo 2 draws planar fog per surface only (every opaque template'sfog_planarpass; no fog-plane mesh, no full-screen pass), so that is all there is to it. The cloud sea MCC shows under Ascension's island, wisps drifting through it, is not fog: it is a transparent cloud plane in the BSP 12.6 wu under the fog plane (ascension_clouds, atwo_alpha_cloudsshader), a static disk of cloud puffs times a cloud tile scrolled over it, drawn unfogged over the sky's lower half. Drawn as one static grey map, it was the flat pale plane the rocks stood in. Halo 2's transparent templates other than glass have no fog in their compiled shaders, so they go infogged: falseand the material spec leaves their fog out. Where the view passes below the plane and finds no surface, MCC draws the fog's colour (its fog pass lays a depth copy for the engine's full-screen fog shaders): the rocks' fogged lower ends vanish into it, where ours stood out against the sky's dark lower edge. A level plane gets that as the loader's height fog at the plane, in the fog's colour, starting 1.5 km out past the cloud plane (gen_ce_level.h2_fog_fill,environment.haze). The plane names its fog through the scenario's planar fog palette; Beaver Creek's names an entry the scenario does not have and gets none. -
Machines. A gear whose device animation turns its one node about one fixed axis is placed like scenery, with its turn: the axis and the keys of its
device:positionanimation as (seconds, degrees) over its position transition time, read bycrate::h2::animation(the keyframe codecs 4-7, and codec 3, which stores every frame). That covers Ascension's three antennas (the big arms that swing around the central pillar every 40 s, about +Z), Zanzibar's big wheel, its blades and three flywheels (+Y; two flywheels are placed tilted) and Foundation's two fans.merge_ce_scene.py --machineswrites each such placement as a mesh of its own (scene_machine_<k>.gltf, built asSM_<code>_Machine<k>; its transparent parts, such as the flywheels' lightning, asscene_machine_<k>t.gltf, since a rewritten mesh enters the translucency pass by its slot 0) with its pivot, keys and, when the axis is not the world's +Z, the axis in Unreal's axes beside it (.motion.json); the level's decor entry carries them asmotion, and MJOLNIRLevelLoader turns the actor about the pivot. Every other machine's motion (doors, lifts, Triplicate's train, Backwash's monitor) is left out as before, listed in staging's notes: still, a closed gate or a parked train would block a way Halo 2 opens. A lift's push does not need its motion; see the next item. -
Lifts, jump pads and vents. Halo 2 pushes through physics model phantoms (
crate::h2::phantom): shapes nothing collides with, each with a phantom type (accelerations and top speeds along a render model marker's forward, towards its axis and towards its point, and whether it holds off gravity). The stage writes every placed object's phantoms that push players to placement.jsonlifts(object space, whether or not the prop is drawn),gen_ce_level.pyputs them in the level file in Unreal space (lifts: planes or a pill, a bounding sphere, the marker, the pushes in cm). MJOLNIRLevelLoader'slifts.luahands them, in the simulation's units, to MJOLNIRLobby's DLL once a map, and the DLL sets the velocity of a player inside one through(object_set_velocity (player_get N) ...)on every simulation tick (native/lobby/lifts_runtime.h, re/lift_push.md). Each game pushes its own players only: a joiner's motion is its own game's, and a push the host sends a joiner's unit does nothing (two PCs, 2026-10-25). Maps with player lifts: Lockout, Midship, Cyclotron (Ivory Tower), Colossus, Coagulation, Headlong, High Plains (Tombstone, hvac), Backwash, Foundation, Warlock, Derelict (Desolation), Dune (Relic, watchtowers), Ascension and Gemini (jump pads).liftsis a key only the loader reads, so a published pack gets them without a rebake:tools/level/add_lifts.pystages the map, adds the block to the pack's level file and packs the next version, and checks nothing else changed (the bots stay as baked). Those 14 maps shipped this way at 1.3.0 on 2026-11-04, with the gaps in testing listed indocs/h2_lifts_release.md. The other 11 maps have no phantom that pushes players and stay at 1.2.0. -
Moving collision. The simulation does all collision, never reads Unreal geometry, and its structure BSP cannot move: an arm's collision baked at rest stood where the arm only sometimes is. Rewriting a live object's transform moves the object but not its Havok body; a device machine moves its collision with its animation. So each turning part becomes a machine of the simulation's own (
tools/level/h2_machines.py, run byconvert_ce_map.sh), five tags cloned from B40's elevator, whose nodes and Havok layouts agree, each a containerpakchunk986-MJOLNIRMACH-<CODE>-<k><g>underobjects\mjolnir\<code>\:- an animation graph whose one resource member turns the root by the part's keys, every frame with codec 3 (the shipped turning props' own; its header is Halo 2's), beside the static pose, node flags, an uncompressed copy and object-space frames the resource carries;
- a collision model holding the part's own Halo 2 collision BSP, which
staging writes as
collision/<part>.bsp.jsonandmjolnir level machine-collisionpacks with its Havok MOPP. Bipeds meet a machine's collision model, not its physics model's shapes: a player dropped on an arm built of physics boxes alone fell through it; - a physics model of boxes over the part's triangles, for what moves through Havok (the elevator's lift phantom goes with it);
- a model, and a gear machine whose "position transition time" is the rate 1 / period (the engine reads it as a rate: 40 ran the antennas 40 times a second, aliased into a seven-second wobble). The engine shows a gear at frame position x N, held at the last frame (Halo 2 used N - 1), so frame f is the angle at f / N of the turn, one every 0.1 s: with Halo 2's five frames Zanzibar's wheel turned a full circle in 24 s of its 30 and stood still for 6.
The generator places each machine where its part is, with its full rotation (
blam.objects, groupmachines), and gives the part's meshmotion.follow; the merge leaves the part's collision out of the BSP (merge_ce_collision.py --sim-machines). The machine draws through the elevator's Blueprint, whose turning part follows the root; the loader hides that part's mesh, attaches the Halo 2 mesh to it, and fits the turn's phase (the simulation starts its gears about 25 s off the world clock) for the sounds. Checked on Ascension: a player dropped on an arm stands on it and is carried round as it turns. -
Props that move and break. A crate (
bloc) whose physics model has a rigid body that is neither keyframed nor fixed moves in Halo 2; one with constraints (Zanzibar's hanging lights, crane, awnings) is held and stays still.crate::h2::propsreads it from the tags and the stage writes it onto the placement:h2_physics(mass, motion type, bodies, constraints),h2_damage(the model's damage info, 0x60: vitality and every instant response with its effect, damage effect, and the sounds and decals the effect references, the sounds staged as one-shots) andh2_functions.tools/level/h2_physics_props.pyturns every movable type into crate tags (a physics shape of the model's box, mass from Halo 2's, and a death response when Halo 2's kills it: the fusion coil's 15 vitality), takes the props out of the merged meshes and builds their meshes; the level loader (props.lua) dresses each crate as the prop placed nearest where it first appears, so every type shares one crate actor class. Zanzibar: 11 types over 55 placements. A dying prop plays our fuel-rod explosion and fire, a plasma scorch and Halo 2's own death sound (sound\visual_effects\fusion_coil_destroyed, 13 variants; this game's Wwise events cannot be posted from a mod), and stays, burnt. A coil's core (tex_bump_plasma_one_channel_illum) is a one-channel mask lit by a colour running from its damaged pink-red (pixel constant 3) to its healthy orange with the object'shealthfunction; read as a picture its green channel drew the coils green. A prop'soverlaystencil (the crates' MKT1 EMERGENCY FOOD) is drawn as masked paint on the prop: the level's darkening copy loses text that brightens. A door (machine type 1: Zanzibar's house gate) opens from its control (the keypad, staged as actrlplacement; the two share position group 0).crate::h2::doorreads its render model's nodes (0x48, 0x60 each: parent 0x04, default translation 0x0C, rotation 0x18) and decodesdevice:positionfor every node: keyframe codec 6, four turning and ten sliding nodes named by the three node bit fields that end the frame data, their frame info in node order (read last node first the gate's doors stayed shut while its bars slid across), sliding keys offsets added to the default translation. A vertex's node is its rigid-boned vertex's index byte through the section's node map (resource locator 0x68), staged as_NODE. h2_physics_props.py splits the door into a mesh a node (doors.json). The simulation opens it and Unreal moves it: every node with a collision BSP (stagedh2_door.collision, one BSP a node; the gate's 14, its frame and four ramps among them) becomes a device machine with tags of its own (h2_door_machines.py: animation, collision, physics, model and machine, written into the layout of B40's elevator family). Its root follows the node exactly, turning and sliding at once (h2_machines.pose_resource: codec 3 with the root's rotation and translation both animated, so a ramp swinging about its hinge is one machine); its collision is the node's own BSP, its physics boxes cover the BSP's triangles. Each machine stands on a grid about the door's origin, 0.05 wu (15 cm) apart, every machine of a map on a cell of its own.Each placed machine draws its own part. Its machine tag (one a placement; the animation, collision, physics and model tags are shared) names an actor of its own (
--asset-reference): B40's elevator Blueprint cloned bywrite_actors(crates/ue-asset/examples/ vehicle_actor.rs, which renames the package, its generated class and default object) into/Game/MJOLNIR/Maps/<CODE>/Machines/ BP_<CODE>_Machine<n>, all inpakchunk987-MJOLNIRACT-<CODE>_P. The Blueprint's mesh list (BlamMeshSynchronizationComponentRuntimeRegions {default}.Permutations{default}.StaticMeshes, which held the elevator floor on boneplatform) names the node's part meshes instead, each on boneRoot(the simulation's root node, boneselevator_world,Root,Platform) at its rest offset from the actor, turned by the placement's yaw. So Unreal draws and moves the part with no elevator to hide and no script attaching anything; the part meshes are not spawned as decor (the level'sdoorsparts carry their mesh and materials instead). The loader (doors.lua) only finds each machine's actor by its class (one scan of the Blam object actors); it hides the keypad's switch panel's components (the actor's own hidden flag is reset by the game) and watches one machine at 4 Hz (10 Hz while moving) only for Halo 2's sounds.The parts' materials are cooked, as the custom vehicles' are (machine_instances.py): when the map's cook runs, build_terrain_meshes.py gives each part mesh real slots (
mesh_rewrite --asset-imports) naming a material instance per slot,<root>/MachineMaterials/MI_<mesh>_n<slot>, of the slot's prop_lit material; ce_vehicle_instances_editor.py makes them after build_ce_level.py and the cook ships them in the map's chunk, andmachine_instances.py checkreads every one back (in the chunk, no static permutation, its textures cooked beside it). The level's parts then carry no materials, so nothing is dressed at spawn. The Blueprint's ownMaterialOverridescannot do it: they match slots by name, and a mesh rewritten from the engine's cube keeps the cube's one slot (WorldGridMaterial) unless--asset-importswrites its own. Without a cook (CE_COOK=0), and on a level built before this, the loader dresses the parts once a world, as before.An upgraded map (upgrade_ce_map.py) does the same from its own stages.
h2_physics_props.py --instance-root /Game/MJOLNIR/MachineParts/<landscape>builds the turning parts and the door parts naming instances in that folder and lists them in<scene>/machine_instances.json. The editor stage finishes each entry as assemble finished a part the loader dressed (the redrawn textures,detail_fill:machine_parts_plan, the same two helpers) and makes the instances after the landscape world, under a label of the folder's own (PAL_MJOLNIR_<landscape>Parts, the landscape's chunk, not recursive: the landscape's own labels are, and would take the masters into the chunk). The cook stage runsmachine_instances.py checkon the chunk (the conversion's cook container named for the textures it carries), and assemble leaves those gears without materials. Zanzibar: 21 slots, each equal to what the loader set before, checked entry by entry; in game all 21 drawMI_ZAN_*instances, in a second match on the map too.The cook stage also refreshes the map's own cook container (
refresh_map_cook): textures imported into the map's folder after its conversion cooked (the door parts' and the props' stencils, by h2_physics_props.py) are in this cook's chunk, not in the conversion's container the install took, and Zanzibar's gate had drawn textured only beside a test container installed by hand. When the staged chunk holds everything the conversion's does and more, a copy in the work folder becomes the map'sMJOLNIRCOOK-<CODE>. Run the stages withHCE_PAKS,MJOLNIRandEXAMPLESset (release builds): the bake's defaults are the debug examples, which may be older than the level schema.The map's own tag containers (its machines and control, their actors, the gears' and the movable props' crate tags) are one list, machine_containers.py, read by the install stage and by both pack tools (pack_local_map.py, pack_remastered.py), so a pack carries what the tested install did. The tags go in the pack folder's
machines/, named-MJOLNIRMACH-<CODE>-...(a prop's-MJOLNIRMACH-<CODE>-PROP-<leaf>-<g>), wheremjolnir map packtakes a map's tags from; the actors' containers end-<CODE>_Pbeside the map's own. Before this the packs carried none of them and the props' tags were in the game only as local builds installed by hand. Zanzibar: 123 containers, every one in a test pack (not signed, not published), and the map played from the pipeline's install alone with its 14 gate machines, 8 gears and 55 props. Two copies of the game (tools/remote/instances.mjs) agreed: every slot cooked and every prop present in both, and the gate opened by the host stood open in the client's own simulation and its own view.A placement's own flags go with it (scenario machine +0x38 device flags, +0x3C machine flags; the simulation's bits are Halo 2's). Containment's base gates are door-type machines (type 0) with no activation radius, so the simulation's door logic opens one for any unit within its bounding radius and shuts it after its open time. Halo 2 places them with machine flag 1, "does not operate automatically", so only their switches move them. Without that flag they stood open (2026-11-15). Zanzibar's gate parts are platforms (type 1), placed with no flags. Before, the fields were whatever B40 placement each map cloned (the one nearest its origin), and some of those are "initially open", "position reversed" or "does not close automatically". Of the Halo 2 machines, only Containment's carry a flag (
h2_machine_placements <map>lists them); Gemini's, Triplicate's, Colossus's and Backwash's doors carry none and open for a unit nearby, as in Halo 2. Dressing state belongs to the world: a second match on the same map has the same world name and new actors, and parts kept from the first came back as bare grid (fixed 2026-11-15).The keypad gets B40's switch panel; machines and switch share one device group (
zan_group0, Halo 2's position group 0, baked into the scenario), so a player pressing the keypad opens the gate, collision and all, for everyone in the match. The install stage installs every machine's containers (machine_containers.py).device_group_set none zan_group0 1opens it from the console.Every machine that moves in parts is staged the same way, whatever its type. Staging tries a one-node gear first (
gear_turn); any other machine whosedevice:positiondecodes (keyframe codecs 4-7, and codec 3, which stores every frame) is staged ash2_doorwith its own behaviour (machine: type 0x11C, flags 0x11E, door open time 0x120, automatic activation radius 0x118). A machine with no animation never moves and is staged as scenery with its collision (Dune's watchtowers).h2_machine_census <maps>lists every machine and whether it decodes. In MCC that is Containment's base gates, shields and switches, Gemini's High Charity doors and gravity columns, Triplicate's garage gates and train, Cyclotron's elevator, Waterworks' crusher, Backwash's monitor and Dune's collapsing teleporters; all seven maps build their machines (h2_door_machines.py). The rules, from the tags:- one machine a collision BSP, and one a node that moves without collision (no collision or physics model: Dune's teleporter legs);
- the machine tag's type is Halo 2's: a door (0) opens by itself within its activation radius (proven on Zanzibar with Triplicate's garage gate: a Ghost parked inside its 5 wu opened it, as Halo 2 does), a gear (2) runs round by itself (Triplicate's train: all six parts' positions agree, 0.732 then 0.936 three seconds later), a platform (1) goes where its device group sends it;
- a placement's machines stand on a 15 cm grid about its origin, so a door's parts measure its radius from nearly one point, every machine of the map on a cell of its own (Triplicate's train and its deathball are placed 3 cm apart; on shared cells the loader bound one actor twice and an elevator mesh rode the train's nose). The loader claims each actor once, nearest first;
- a machine tag is built once and placed per placement (Triplicate's three garage gates);
- Halo 2's position group number is the device group
(
<code>_group<n>), shared by every machine and control of that number (Containment's gate and its switch), each control placed once.
A fresh conversion (
convert_ce_map.sh) does the same as the upgrade pipeline: afterlevel collision,h2_door_machines.py <staging> <CODE> <out>/machines --transform <name>.sbsp.transform.jsonbuilds every placement's machines (positions moved with the map) and writesdoors.json;merge_ce_scene.py --doorstakes the machines out of the static scene as a mesh a node (scene_machine_d<k>n<node>.gltfwith a.door.jsonnaming its staging entry and node, which build_terrain_meshes.py turns into a decor id);gen_ce_level.py --doorsadds the machines, controls and device groups to the scenario and the level'sdoorsfor the loader (level bakekeepsdoorsas opaque, as it keepslifts). The machine containers sit with h2_machines.py's in<out>/machinesand install with them. Triplicate (TRI, 2026-11-15): seven placements, 20 machines, 18 part meshes, all bound and attached; a garage gate rolled up when the player was teleported into its 5 wu radius. Halo 1 conversions (Chill Out) and Halo 2 maps without such machines (Lockout) merge byte-identically. The published Containment, Gemini, Waterworks, Backwash and Foundation will gain their machines the next time they are converted.A moving part is lit by Unreal (prop_lit.py's M_CE_PropLit, both pipelines): lit by the light baked where it was placed, Triplicate's trains, parked in a dark tunnel, drew black through the station. The trains themselves run as the tag says: a 15 s loop, moving for about 5 s, 427 m at up to about 107 m/s. (A reading that looked frozen was the train parked at the end of its run for the other two thirds of the loop.)
The game hides the actors of machines the player cannot see (
bHidden, the skeleton not rendered) and gives them no pose until the player can; then it poses them at once where the simulation has them (Zanzibar, 2026-11-15: all fourteen gate machines hidden with the player at spawn, the gate opened, nothing moved; the player teleported to the gate, all fourteen shown and every part open). FlyCam does not count as the player's view: a part that stands still in a FlyCam shot while the player is elsewhere is this culling, not a fault. Judge machines from the player's own view. (This explains every "stuck" ramp, bar and "frozen" train reading earlier that day; un-hiding an actor by hand does not pose it, the game's own visibility does.) It is distance culling, as for every Blam object, judged by the object's bounding radius: with the player 20 wu from the gate none of its machines hid, at 35 wu 11 of 14, from 45 wu all. Since the parts are the actors' own meshes now, a culled part is not drawn, as a culled crate or weapon is not; Halo 2 culls the gate as one object (bounding radius 2.56 wu, object +0x04, offset +0x08), so every machine of a placement takes the placement's largest reach as its radius and the parts go and come together. Gears (h2_machines.py) were never hidden within 75 m of the player.Two copies on PC 1 (tools/remote/instances.mjs up 2, one simulation): each found and dressed all fourteen actors; the gate opened from the host's console showed open on the client; each copy culls by its own player, and each showed every part open once its player was at the gate. Opaque shaders that scroll their base map are staged as
base_scroll(Zanzibar's rotating_metal, the drum under the spindle grates: one repeat in u every 2 s); theh2_stagingmap setting applies it to the level's slots as CE's environment scroll (BaseUAnim). Turning machines are lit by Unreal (their object page drew black, and a black flywheel turning read as one standing still); one riding a simulation machine whose Unreal part stops updating (the big wheel and blades: the simulation's position advances, the game stops copying its pose) leaves the part after 2 s and turns by the clock. -
Teleporters. Halo 2's teleporter scenery (Ascension's
2way_teleporterbases) is placed like any other prop: the generator's working pads on the teleporter flags draw nothing. Its beam is aplasma_alphashader, its glow aone_add_illum(the base map times pixel constant 0, added). The bases have no collision model. -
Sound. Halo 2's samples are not in the maps but in headerless
sounds_*.datfiles beside them (Opus and Xbox ADPCM;docs/h2_cache_format.md, "Sound").crate::h2::soundstages them asce_sounds.pystages a CE map's,staging/sounds_out(sounds.jsonand its files), whichconvert_ce_map.shimports withbuild_ce_sounds.pyand the generator plays: the BSP clusters' background loops (2D), the sound scenery and the loops placed objects carry (3D, at the object's origin), and the one-shots a turning machine's animation raises (Ascension's 12 antenna cues, at their frames). Opus packets go into an Ogg Opus file as they are, which the editor imports (Ascension'santenna1came in at its tag's 2.240 s); ADPCM is decoded to WAV. A sound's playback gain (dB) and random pitch bounds (cents) become the entry'sgainandpitch(Ascension's humming light plays 5 semitones down); a loop's distance bounds come from itslsnd(most loop samples carry none) unless the sound scenery overrides them. Halo 2 adds its sound class's gain to the sound's own (halo2.dll 0x6e5bd0: the class's upper gain bound and the sound's scale bound at scale 1; -7 dB for the ambient classes, -11 dB for machinery), so the entry'sgaincarries it. The class also caps how many of one sound play at once ("max sounds per tag", 4 for these classes), which becomes the emitter'smax: the loader gives each such sound a concurrency group that keeps the nearest playing (Elongation places its belt hum 100 times with two tracks; all 200 played, at the tag's gain, with every cluster's background on top). A background loop belongs to BSP clusters:zonesare the clusters' bounds with the set of loops each plays, and the loader fades to the set of the box the camera is in or nearest to, the smallest when boxes overlap (the clusters themselves are not boxes). An attachment scaled by an object function (the jump pads' launch loop,phantom_power) is left out: it sounds only while the object drives it. -
Lightmaps. Halo 2 keeps its pages at half their light and doubles them in the shader; the CE masters take a page as it is, so the pages are staged doubled (clamped). Without that Lockout's interiors were nearly black. Its 65 small pages would each bake at 2,048 under lightmap_bake's default 16x, so Halo 2 maps bake at most 4x (
BAKE_ARGSdefault). -
Render models (the sky, props) store positions and texture coordinates in -1..1 across the model's compression bounds; read raw, Lockout's sky was a 3 m knot at the origin and drew nothing.
-
Weapons the game lacks take the nearest role (
defs/level/h2-tag-map.json): the battle rifle the assault rifle, the brute shot the fuel rod gun, the carbine, brute plasma rifle and sentinel beam the plasma rifle.
Specular
A Halo 2 template's postprocess definition (stem +0x58) lists its passes,
each pass's implementations and what each implementation feeds its shaders
(specular_constants in render.rs reads it; the example
h2_template_blocks prints it). Most opaque templates draw
default_light_combined_tangentspace_specular_sphere. Its vertex shader
passes vertex registers 10 and 11, fed from two of the shader's vertex
constants, to the pixel shader, which adds sat(R.L)^8 x the light x
lerp(register 11, register 10, sat(N.L)) through the frame's alpha (R the
view reflected about the bumped normal, L the light's direction). The
template's lightmap pass wrote that alpha first:
- min(1, 2 x base alpha x the light) for
lightmap_tex_detailand nearly every other lightmap pass (tex, the detail blends, two and three detail, illum, shiny, tiling, change colour, honor guard), so the base map's alpha is a specular mask; - 0 for the env passes,
detail_overlayanddetail_no_specular: those surfaces never shine, whatever their passes; - the cut-out or other terms for the alpha-tested passes. Only
alpha_test_no_bump's (the cut-out, which is the base alpha) matches what staging writes; the others are left without.
That is CE's lightmap specular (SpecLightmap: the lobe from the
lightmap's incident direction, masked by the base map's alpha), its colour
going from parallel to perpendicular by N.V rather than N.L: perpendicular
takes register 10's constant, parallel register 11's. A template that cuts
out on another map's alpha has the cut staged in the base's alpha, so it
would shine all over; it gets none. Nor does a base map with no authored
mask (alpha 1 everywhere): 157 of 552 specular shaders on the 25 maps,
Coagulation's cliffs, Turf's stucco garage doors, Backwash's tree trunks,
shone all over like plastic where Halo 2's surfaces read flat; the shaders
with an authored mask (Turf's brushed door frames) keep it. Turf's door frames and posts
(metal_grey_dark on matte_grey, brushed streaks in the alpha: vertex
constants 7 and 8, 1.0 and 0.75 grey) drew flat grey without it. Placed objects (lit from the object lighting
page) are left without: they have no incident direction per texel, so a
flat face took one and saturated white (Turf's dumpster). 25
templates take it, 61% of the multiplayer maps' triangles
(docs/h2_shader_census.md).
Decorators
Halo 2 scatters grass, rocks, debris, litter and decals from its scenario's
decorator sets (DECR) over each structure BSP (crates/blam-cache/src/h2/decorator.rs;
the example h2_decorators prints a map's). The BSP's decorators block
(+0x234) is an octree of 8-unit cells around a centre (cells per side x 8
units across); each leaf names groups, and a group a run of placements in a
raw cache block, six words each. MCC's halo2.dll decodes them (0x979eeb;
no tag carries the finished geometry, so the decode was read from there):
- position: the leaf cell's corner + (bits 0-9 x 8/1023, bits 10-19 x 8/1023, bits 20-31 x 8/4095) world units;
- internal word: bits 0-2 the class, 3-8 the permutation, 9-12 the yaw (v/15 of a turn), 13-15 the tint blend, 16-19 the scale (v/15 across the permutation's range), 20-31 an up vector the "align to normal" permutations turn to: the yaw then turns from Halo 2's own perpendicular to it (0x6fcf30: the smallest component zeroed, the other two swapped, one negated), and any other perpendicular turns every aligned piece by a fixed angle (Turf's cans lay 180 degrees round);
- tint and lightmap colours, two light directions.
On Zanzibar, Turf and Beaver Creek the decoded placements lie on the BSP's
surface (median 0.1 units). The 20 maps with decorators hold 38,600:
31,000 models, 6,300 floating decals and 1,300 camera-facing sprites
(Zanzibar's, all). A group's own type byte disagrees with its class's on
Turf, so the class's (DECR class +0x04) decides.
DXT1 bitmaps decode with their one-bit alpha (a three-colour block's index 3 is transparent black, as D3D samples it). Read opaque, the debris atlas drew each piece in a black box where Halo 2 cuts it out; elsewhere one to five textures a map gain transparent texels (Coagulation's light bands, Ascension's light strips, Zanzibar's hazard strips).
Model decorators are staged as scenery: each set's model
(models/<set>__decorator<k>.gltf, its run of the set's indices, double
sided, decorator_tex cut out on its base map's alpha), one placement entry
each with its rotation as basis (forward, left, up) and scale, which
merge_ce_scene.py places like any object, and its light.
Every decorator is lit and coloured as Halo 2 colours its vertices
(halo2.dll 0x7fa1d0): the permutation's tint 1 to tint 2 by the
placement's blend, times the placement's tint by the base map tint
percentage; times its light, the placement's lightmap colour by the
lightmap tint percentage, grey (0.5) for the rest. The decorator pixel
shaders draw 2 x texture x that colour. A model's entry carries the doubled
product as light; a decal's or sprite's vertices already hold the product
(their stored colour equals it on Turf and Coagulation to 8-bit rounding),
doubled into the mesh's _LIGHT. merge_ce_scene.py lights each from that
in place of the ground under it: one object page block a distinct colour
(in 32nds), the incident direction along the normal so it draws flat, as
Halo 2's does.
Decal decorators need no decode: the map stores them as geometry. Each
cache block carries decal vertices (locator 0x08: 0x20 each, position,
texture coordinate, a second coordinate, colour) and indices (0x10), 4
vertices and 6 indices a placement over its group's run (+0x0C vertex
start and count, +0x10 index start and count); halo2.dll draws them as
they are (0x9795c0). Their coordinates already point into the decal
bitmap's atlas. decorator::decals reads them; staging writes one mesh a
group and shader (models/<set>__decals<group>_<shader>.gltf, at the
quads' centre): decorator_decal_paint alpha blended,
decorator_decal_paint_multiply (stains, blast scorches) multiplying the
frame by the map where its alpha covers, baked into an alpha blend as the
overlay's is. Turf's 322 (posters, rubble, stains) draw in game. A group's
own type byte calls Turf's posters and rubble models; their class and
their decal vertices say decals.
The axis-rotating sprites (grass: Coagulation's 14,362, Relic's, Beaver
Creek's, Containment's) are stored the same way, in the block's sprite
vertices (locator 0x48: 0x30 each, base position, the corner's offset
across and along the axis, the axis, texture coordinate, colour) and
sprite indices (0x50), 4 and 6 a placement. Halo 2 turns each about its
axis to face the camera, and so does ours: each comes out as one card in
its rest pose (across Halo 2's perpendicular to the axis turned by the
placement's yaw) on M_H2_Billboard
(unreal/MJOLNIRMaterials/Scripts/build_h2_materials.py, chunk 981), the
masked two-sided environment master with a World Position Offset that
turns it. The vertex normal is the axis (the card draws flat lit, so it
needs no face normal), and two extra UV channels carry, in Unreal
centimetres, the way from the vertex to its base point on the axis
(TEXCOORD_2 x, y and TEXCOORD_3 x) and its offset across (TEXCOORD_3 y):
_BILLBOARD in the staged mesh, converted by merge_ce_scene.py, written by
mesh_rewrite as channels 2 and 3 when a mesh has them. A runtime pack
without the master draws the cards unturned (the level loader falls back
to M_CE_EnvironmentMaskedTwoSided). A group
draws from the sprite buffer when its block has one and its type says
quad, or it has no decal buffer. Zanzibar's "screen-facing quads" (group
type 3) are foliage_earth models by their class, and are placed as models.
merge_ce_scene.py merges every decorator primitive of a material into
one: each glTF primitive becomes a section of the terrain mesh, drawn in
every pass, and Coagulation's 2,639 pieces as their own sections drew
14,808 draws a frame (1,623 merged). Measured on PC 1 (RTX 5090, 3840x2160,
Epic, mjolnir_bench at a held view over the grass, 2026-11-11):
Coagulation without decorators 9.21 ms (GPU 6.53); with them as sections
10.34 ms; merged 9.63 to 9.84 ms (GPU 7.02), so the decorators cost about
0.5 ms, on the GPU. Their World Position Offset costs nothing measurable
(off: same frame, GPU -0.2 ms). All three were benched in sessions in PC 1's
slower state (the game thread on its V-Cache cores, by the 9 ms baseline;
docs/performance.md, "Reading the numbers"); a control in the faster state
read 7.80 ms.
Breakable glass
Halo 2's glass (Turf's stairwell doors) is solid until shot, meleed or hit hard, then breaks and lets players through, as in Halo 2.
- Collision.
mjolnir level collision(Halo 2 sources only) makes the glass breakable surfaces of the sim's own kind (blam_sbsp::convert::rebuild_breakable): each polygon is a pane (its front and back), each connected sheet a set, closed at its edges so the sim's flood fill never reads a missing surface.brittle_glasstakes thebrittle_glass_reinforcedmaterial: plainglobals\glassbreaks at any touch, so walking into it broke it. - Drawing. The sheets go beside the BSP (
<map>.sbsp.breakables.json, world units);tools/level/split_breakable_glass.pymoves each sheet's transparent triangles into mesh slots of their own, and the level entry lists them (breakables: sheet, box in cm, slots). The level loader hooks the game's break effect (BP_BaseBreakableSurfaceEffect_C:Spawn, which names the point it broke at): the sheet there loses its slots (M_CE_Hidden) and throws glass chips (NS_Impact_Glass_Lrgwithout its crack decal, over a 3 x 3 grid). A sheet stays broken until the map loads again. - Not done: the break's sound (the game's
HaloAudioSoundhas no script call to play it), and glass in the structure BSP itself (the world shell's packing drops the breakable bit; Turf's is all instanced geometry).
How the open items were closed
- A prop's collision on a child node (Zanzibar's crane and hinged lights,
Derelict's trees) is placed by the render model's rest pose; a scaled
placement (Zanzibar's bushes at 2x to 4x) gets a copy of the model and
collision with the scale baked in (
<name>_x2__scen.gltf). - Every instance's incident light direction, and the light of vertex-lit instanced geometry (Lockout's 26 light fixtures), come from Halo 2's lightmap vertex buckets. A vertex-lit instance draws its vertices' mean light from a texel of its own on a page after the last (the CE masters sample light through lightmap coordinates, so per-vertex colour has no slot); the incident direction still varies per vertex.
- Cube maps and the scrolling shader animations (cloud banks, gas, grav lifts) are converted; see Shaders above.
Not yet done
- Only BSP 0 is converted (every multiplayer map has one).
- Placed object models take each region's first permutation at its most detailed level.
- Specular's colour blends by the view (N.V) where Halo 2's blends by the
light (N.L), and alpha-tested templates other than
tex_alpha_testhave none (see Specular). - The sun shafts' fade towards edge-on (the vertex colour going from the facing colour to black as (N.V)^2) has no CE chicago equivalent; they draw at their facing colour.
- An env reflection's colour is one hue (the mean of the facing and glancing colours) baked into a copy of the cube, and its facing-to-glancing blend uses CE's squared view term rather than Halo 2's linear one.
plasma_alpha's fade comes from its vertex shader (transparent_generic_reflection), not read back: M_H2_PlasmaAlpha takes it as the facing term |N.V|, weighted by pixel constant 2's alpha as the pixel shader weights it. The level needs chunk 981 (pakchunk981-MJOLNIRH2-Windows) installed: without it the level loader finds no parent for the plasma's slots ("parent material not found").- The loops' detail sounds (Ascension's thunder and wind gusts, at random
periods and directions) are staged in
sounds.jsonbut not played; a loop attached to a marker plays at the object's origin. - On maps other than Lockout, CTF sides and vehicle teams come from the nearer CTF flag and vehicle game types from Halo 2's; Lockout and Ascension have been started, Ascension only by a test camera.
- Install the way a local test map is installed (
level bake --install-testand the map's 985/986 containers):--installalso copies this project's material cook over chunk 988, which on a box with the hub's runtime replaces the runtime's masters. - All 24 multiplayer maps stage; Lockout, Ascension and Zanzibar have been converted end to end and started.
Remasters
A converted Halo 2 map goes through the same pipeline as the CE remasters
(tools/level/upgrade_ce_map.py, configured in
tools/level/ce_upgrade_maps.json). Coagulation (COA) is the first, built
2026-11-12 and seen in game on PC 1 as local builds; it is not published.
Convert from the .map itself, not from a staging folder elsewhere: the
pipeline reads the staging beside the conversion (<conversion>/staging),
and the level takes the map's name.
- Stages: land, foliage, swap, editor, cook, bake, assemble, install.
collisionis skipped, so the bake uses the conversion's own BSP with its glass and physics-model surfaces; a swapped tree keeps Halo 2's collision. - Ground and cliffs by name. Halo 2's detail bitmaps are not named
detail_grassordetail_cliff, so the config names them:shaders,cliff_shaders(Coagulation's boulders,coag_rocks, among them, which draws them in the game's rock) anddetails(ground_dirt_pebbleas sand,coag_grassas grass: the base map's alpha then says where each grows, as on a CE map). - A look of its own. A landscape with no
MAP_LOOKSentry inbuild_landscape.pygets Death Island's beach. Coagulation (LCO) takes Blood Gulch's: packed earth, stones on soil, its cliff mix. - A pond is not a sea (
"sea": false). The pipeline and the loader take any water mesh for the sea. Coagulation's pool by the cave sits 7 m up: grass grew only above it, so 1.8 of 2.2 million clumps stood on the plateau and none in the valley, and the valley floor drew as a beach (sand, ripples, shells). foliage_ceiling(cm): nothing is scattered on ground above it. Coagulation's plateau, 50 to 107 m up and out of sight, is left bare; the valley keeps about 290,000 clumps, Blood Gulch's count.- Light. The conversion's sun stood at 28 degrees and the cliffs shaded
the valley floor; the config raises it to 55, turns the baked sun mask
off (
sun_mask: false, as Blood Gulch) and setssun.lightmap_sunto [0.35, 0.62]: Halo 2's ground lightmap is a lavender 0.6 where CE's sunlit ground is 1.0. Blood Gulch's skylight, exposure and clouds, andhaze: "ce"(a Halo 2 slot carries its fog as a CE one does). - Halo 2's grass sprites are hidden (
hide_materials: ["M_H2_Billboard"]): the scattered grass replaces them. A decorator placement is ground cover, not scenery the grass keeps clear of or a boulder to swap (decoratorinplacement.json): Coagulation's 218 decal fields cleared 20 m circles of grass until the scatter skipped them. - Trees. Coagulation's trees are instanced BSP geometry, which
placement.jsonnever names.mjolnir cache stagewrites every instance's name, frame, shaders and bounds tobsp/instances.json, andinstance_swap: {"redcedar": "tree_pine"}hastools/level/instance_scenery.pyturn the instances with such a shader into scenery entries for the swap: its three red cedars stand as A30's pines, sized to each cedar's height, their Halo 2 slots hidden. - Chunk 1001. Halo 2 remasters take numbers from 1001 up (docs/chunk_numbering.md). The landscape container's library holds the same two shader maps as every CE remaster's, so a textured landscape on a machine with a CE remaster installed does not prove library 1001 opened.
- Desert biome (
"biome": "desert"). Coagulation's dirt and cliff feet are dressed from the game's dry-country plants and Poly Haven's Namaqualand pack (flowers, succulents, granite stones) instead of the beach's shells and driftwood: docs/remaster_asset_inventory.md. The pack cooks into the map's landscape container, so the map needs it in the editor project and a credit when published. - Zanzibar (
ZAN, chunk 1002,"biome": "coast"). A Fluid Flux coast at the fog plane's height, since the conversion has no water surface; sea life on the bed, sea campion, small palms at the walls' feet and the beach bushes as young palms. Its ground shaders list grass before sand, the reverse of CE: the bake and the mesh ground slots turn that over (docs/remaster_asset_inventory.md). - Containment (
CNT, chunk 1003, landscapeLCN,"biome": "snow", 2026-11-16). Ice Fields' and Sidewinder's snow: B40's glacial rock on the cliffs (containment_cliff_aand the boulders'containment_rock_medium), Sidewinder's ground look, snowy stones and rubble scattered, the game's falling snow kept out of the bases (11,755 roof cells). Its terrain shader is not a blend, so it would have baked as one flat snow; withreal_basethe ground keeps its base map's own colour, which paints the tyre tracks and the dirt by the bases. Its bases are Forerunner, so the Forerunner plate stays on their metal (nostructure_metal: false). Swap and collision are skipped: its scenery is 8 brambles and twig decals (the twigs areM_H2_Billboard, hidden). Its gates and switches come from the conversion's own machines, as a fresh conversion places them; the install takes their actors (pakchunk987-MJOLNIRACT) from the conversion'smachinesfolder (tools/level/machine_containers.py). In game, solo and in two networked copies: all 8 machines start shut, a switch group opens its own gate in both simulations, and the 8 part slots draw their cooked instances. - Ascension (
ASC, chunk 1004, landscapeLAS,"biome": "desert", 2026-11-16). Its ground is a blend of bare slate and pale sandstone paths, so both detail maps aresand(stones and dry plants): taking the slate for grass grew 2.3 million clumps on bare rock. Grass stays on the cliffs' up-facing faces, where the cliff master draws its turf, which greens the rock pillars' tops. Blood Gulch's look, as Coagulation's. Reconverted first (ASC_flags) so its machines carry their own placement flags. Its three antennas are the conversion's turning machines, cooked. In game, solo and in two networked copies: the antennas turn in step and draw their cooked instances; a frame takes a median 11 ms at 4K. A ground with no grass class had crashed the scatter where a cliff's turf met it (scatter_foliage.py). - Cladding only within reach. Ascension first loaded in 4.2 s solo and
7.3 s on a client (the hub copy: 0.7 and 2.3 s). The loader dresses each
cladding rock, a mesh actor, with its group's material, and Ascension had
120,427 of them: its pillars fall 150 m under the lowest spawn, and their
walls took 80,000. The scatter now puts no rock more than 30 m under the
map's lowest player spawn (
--clad-floor, upgrade_ce_map.py's CLAD_BELOW_SPAWNS), which of all the remasters trims only Ascension and Gephyrophobia's chasm (3,905). Ascension: 40,390 rocks, 2.3 s solo, 3.5 s on a client. The loader's log now lists the queued jobs' time by kind (load timing: queued jobs:). - Structure surfaces (
structure_surfaces). Zanzibar's concrete and steel draw in Poly Haven PBR surfaces through the cliffs' master, each wall's Halo 2 base map kept as its colour and its lightmap as shade (docs/remaster_asset_inventory.md). The surfaces cook into the runtime container, so they too need a runtime release. - Still CE-runtime bound. The cliffs' tessellated meshes cook into the trial masters' container (983), as for the CE remasters, and Halo 2's masters are in 981: publishing a Halo 2 remaster needs a runtime release with both.
- Measured on PC 1 at 4K, standing in the grass: 13.9 ms a frame, 2.5 ms of it the foliage.
- Not done: the pines against Halo 2's cedar collision is unchecked; no
side-by-side from fixed cameras;
instance_swapreplaces the conversion's own scenery list for the swap, so a map with both kinds swaps only its instances.