# Pressure door for the vessel's docking gate, game-ready

A round, hinged, vault-style pressure door, after the user's four reference renders (2026-10-14): a thick round leaf
hung on a swing arm, a hinge housing with a canister and an embossed number, an accumulator tank and pipes on the wall,
a bumper tube round the frame, a floor plate with a recessed well and hazard stripes. It is meant for the M-Ship's
boarding gate (the works hall's port wall, where Anchorage's boarding bridge meets the ship, marker
`Boarding gate (port, Anchorage bridge)`). **Since 2026-10-15 it is in the ship** (`models/M_Ship_v2_interior_season2.blend`, in place of the kit's lattice gate,
with a hole cut through the hull: `models/vessel-interior/build/boarding_gate.py`, see that folder's README). **Not in
the Unreal project.**

Built in the live Blender through the MCP, by script. Nothing here is a boolean; every surface is quads except the caps
(triangle fans) and the flat caps and lettering (triangulated).

## Files
- `PressureDoor.blend` (Blender 5.2): the door, rigged. Collections: `PressureDoor` → `PD | static`, `PD | moving`,
  `PD | collision` (UCX hulls, excluded from the view layer); `Studio` (camera and lights, not exported).
- `fbx/SM_PressureDoor_<Part>.fbx`: one file per mesh at its own pivot, with its `UCX_` hulls.
  `fbx/PressureDoor_Assembled.fbx`: everything shut, for a quick look. `fbx/verify_report.json`: what a re-import gives.
- `PressureDoor_layout.json`: pivots, motion, timing, materials, in Unreal units.
- `textures/T_PD_Masks.png` (4096, baked: R occlusion, G edges, B crevices), `T_PD_Hazard_BaseColor.png` (seamless
  stripes), `T_PD_Screen_Emissive.png` (status screen, no lettering). The tiling sets are the Season 2 pack's own files,
  read in place from `../vessel-interior/textures/ModSci_Engineer/Textures` (**relative paths: keep the .blend here**).
- `previews/`: Cycles pictures (`PressureDoor_01..07`); `wip_*` are working shots.
- `build/`: `pd_lib.py` (geometry helpers), `pd_build.py` (the parts), `pd_rig.py`, `pd_check.py` (travel check),
  `pd_surfaces.py` (UVs, bake, materials), `pd_export.py` (UCX, FBX, layout), `pd_studio.py`, `pd_verify_fbx.py`.
  Run one in the open Blender with `exec(open(r"<path>").read())`; `pd_build.py` rebuilds every mesh in place.

## Scale, axes, size
1 unit = 1 m, Z up, floor at z = 0. The wall's front face is y = 0; the door opens toward −Y (the side the references
show). Seen from the front, +X is right; the hinge is on the right. In Unreal: **ue_cm = (x, −y, z) × 100** (the
project's FBX pair, as for the docking arm; the data is turned −90° about Z on export).

| | |
|---|---|
| clear opening | Ø 2.16 m (R 1.08), axis 1.28 m above the floor |
| coaming | the opening's bottom is 0.20 m up; a ribbed tread inside the frame at 0.25 m; a step on the back at 0.13 m. An Unreal character steps 0.45 m. A capsule of r 0.42, 1.92 m tall passes with 4 cm to spare |
| leaf | Ø 2.48 m, 0.36 m thick (0.82 m with arm and wheel); 4 cm above the floor all through its swing |
| frame | collar Ø 3.06 m, 0.66 m deep through a 0.30 m bulkhead |
| whole module | 5.70 m wide (x −2.30 to 3.40), 3.40 m high, floor plate 3.80 m deep |
| triangles | frame 24.2k, leaf 30.6k, housing 13.3k, bulkhead 7.8k, floor plate 5.8k, wheel 1.6k, bolt 0.3k (x6): about 85k |

## Parts and pivots
| Mesh | Pivot | Motion |
|---|---|---|
| `SM_PressureDoor_Frame` | world origin | static: collar, seat with rubber gasket, tunnel, back flange, six keepers, lock box, bumper tube, tread, back step |
| `SM_PressureDoor_Housing` | world origin | static: hinge housing, the two lugs and the pin, canister, control panel (screen, keypad, red and green lamps), number "01", bumper bar, tank, pipe and duct, conduits, back panel |
| `SM_PressureDoor_Bulkhead` | world origin | static: the wall plates with the round hole, rivets. Leave it out where the ship's wall already is |
| `SM_PressureDoor_FloorPlate` | world origin | static: tread plates (top at z = 0, 3 cm thick), the well with its accumulators, hazard band and the swing arc. Replaces the deck in front of the door, or leave it out |
| `SM_PressureDoor_Leaf` | hinge pin (1.62, −0.62, 1.28) | leaf + swing arm: **yaw +100° about Z** (Unreal −100°) |
| `SM_PressureDoor_Wheel` | (0, −0.765, 1.28), child of the leaf | hand wheel: **−90° about Y** (anticlockwise seen from the front) |
| `SM_PressureDoor_Bolt` ×6 | its tip; children of the leaf at 20, 70, 110, 160, 200, 340° | **slides 0.28 m along its local −X** (out of the keepers, into the leaf) |

The hinge pin stands in front of the leaf and outboard of it, so the leaf lifts straight out of its recess in the
collar; the arm's knuckle turns round the pin in a bore (5 mm clear) between the two lugs.

## Rig (Blender)
One slider: `PressureDoor_Root["open"]` (0 shut, 1 open). Wheel 0–0.20, bolts 0.12–0.32, swing 0.35–1.00, each eased.
Drivers are simple expressions (they run with Python auto-run off). The timeline plays it: shut at frame 1, open at 100,
shut again at 260, 30 fps; action `PressureDoor | OPEN_CLOSE`. Each moving part keeps `["closed_location"]`.
**To render a state, set the frame**: the timeline keys drive the slider during a render.

## Checked
`pd_check.py` turns the door through 101 steps and tests every moving part against every static mesh in world space
(triangle overlap) and measures the gaps: **no clash anywhere in the travel.** Smallest gaps: leaf to gasket 2 mm when
shut, pin in its bore 5 mm, bolt to keeper 5 mm, leaf to floor 4 cm. Two clashes found on the way and fixed: the arm's
end ran through the hinge pin, and the pin ran through a solid knuckle.

## Collision
`UCX_<mesh>_NN` convex hulls: 17 for the frame (16 ring segments round the opening and the back step), 4 for the leaf
(disc, wheel, arm, handle; in the leaf's frame, so they swing with it), 7 for the housing, 3 for the bulkhead (round
the opening; the frame's ring fills the corners), 1 for the floor plate. Wheel and bolts have none.

## Surfaces
**In the ship, since 2026-10-15, the surfaces are the realistic ones of `build/pd_look.py`** (the user: *"Do a more realistic
color and texture on it"*): Poly Haven's `blue_metal_plate` scan (CC0, 2K, `source_polyhaven/`, fetched by
`python -I build/pd_look.py --fetch`, manifest beside it) under everything painted, the baked masks on top (chips to bare
steel, crevice grime, dust on faces that look up, a thin enamel coat), brushed stainless for the bright steel, matte black
for the fittings; the painted parts in a dark grey metallic finish (*"Do it dark grey mettalic"*; `STYLES["gunmetal"]`,
the default, `"navy"` the scan's own colour). Run `pd_look.look()` in this file to give it the same look; the table below is the first version, which
this file still has.

Two UV layers on every mesh: `UVMap` (UV0, a unique unwrap into the shared mask atlas; the screens take their whole
texture) and `UV_Tile` (UV1, metres, box-projected, for the tiling sets).

| Material | What it is | Set | Tile |
|---|---|---|---|
| `M_PD_Paint` | pale steel-blue satin paint, as in the references | ScratchedMetal under the tint; a few chips on exposed edges | 0.90 m |
| `M_PD_Steel` | chrome-bright steel: handles, wheel, bolts, bands, screws | StainedSteel + scratch normal | 0.50 m |
| `M_PD_Dark` | graphite: tread, keypad, vents, lock windows | StainedSteel colour, ScratchedMetal roughness | 0.70 m |
| `M_PD_Rubber` | gasket | ScratchedMetal roughness | 0.40 m |
| `M_PD_RedPaint` | bands on the accumulators | ScratchedMetal under red | 0.60 m |
| `M_PD_Hazard` | floor stripes | `T_PD_Hazard_BaseColor` x ScratchedMetal | 0.40 m |
| `M_PD_Glass` | canister window | clear glass, smudges in the roughness | |
| `M_PD_Screen` | status screen | `T_PD_Screen_Emissive` | |
| `M_PD_LampRed`, `M_PD_LampGreen` | status lamps (the game can switch them) | emissive | |

Every material reads the mask atlas: a little shade in crevices and occlusion, wear only on exposed edges (the ship is
clean: no rust). The paint colour is one value; in Unreal make it a material-instance parameter. The edges are modelled
round (no bevel-normal bake). Pictures are Cycles.

## Not done / open
- In the ship since 2026-10-15 (`boarding_gate.py`): the frame, housing, leaf, wheel and bolts as they are; the bulkhead
  plate and the floor plate are not used there (the ship's wall and floor are), the frame's back step and the housing's
  panel on the wall's back are dropped (there is only the lining void behind the wall). Not in Unreal.
- The game has no door code: `PressureDoor_layout.json` describes the motion for whoever writes it.
- The stiffener bars on the leaf's back do not move with the bolts (they read as stiffeners, not linkage).