# Cockpits and HUD artwork

The [cockpit browser](cockpits/index.html) provides inside-model inspection views for the Eurofighter, F-22 and F-117, the captured bitmap overlays, and all frames from the native instrument sprite banks. Palettes remain selectable. Aircraft camera controls let us inspect other parts of the authored cockpit; these are inspection controls, not a running flight simulation.

## Aircraft model programs

The air-to-air refuelling cockpit shapes `cptefa_f.3`, `cptf22_f.3` and `cptf17_f.3` are loaded by [0x7d5c0](code/index.html#7d5c0). The ordinary virtual cockpit models are `cpt_efa`, `cpt_f22` and `cpt_f17`; separate `back_*` models provide rear cockpit artwork. Comparison with the original game identifies the `*_f` group as the air-to-air refuelling mode, rather than the general forward cockpit as previously labelled. They contain genuine polygon geometry, canopy frames and textured instruments, rather than a single flat cockpit bitmap. Their panel programs reuse much of the same atlas artwork, with different surrounding airframes.

The inspection camera starts at model-space zero, using a 128-pixel projection scale on a 320×200 canvas. It clips geometry crossing the camera's near plane and follows the model program's drawing order. Colours and texture binding come from the original assets. Native flight-camera offsets, cockpit lighting, damage effects and live instrument readouts are not reconstructed by the inside-model view; the optional controlled HUD captures are described below. The model browser links remain available for an external view of each entire assembly.

## Static screens in the virtual cockpit

In the original game, the virtual cockpit's MFD faces show static mock display artwork. Those pictures are present in the original cockpit textures; they are not placeholders invented by the viewer or missing live display rendering. The faithful reconstruction should retain them.

Live instrument/display drawing is a separate rendering path. The optional instrument capture in this browser is an inspection overlay showing recovered screen-space calls; it should not be taken as evidence that the original projects live MFDs onto the virtual cockpit's screen polygons.

Updating those screen faces with real radar, navigation, targeting and instrument output is a candidate feature for a later enhanced/redux version. That would be a deliberate improvement over the original virtual cockpit, rather than restoration of omitted behaviour.

### Early slideshow screenshots

The [TFX preview bundled with Jurassic Park](jurassic-park-preview/index.html) preserves an earlier cockpit layout. Its Eurofighter views in [SCREEN17](jurassic-park-preview/images/SCREEN17.png) and [SCREEN37](jurassic-park-preview/images/SCREEN37.png) show weapon information on the **right MFD**, including the refuelling-view layout identified during review; the reference cockpit artwork places its static weapons/loadout display on the **left**. Other preview views, such as [SCREEN30](jurassic-park-preview/images/SCREEN30.png) and [SCREEN44](jurassic-park-preview/images/SCREEN44.png), have blank MFD faces. The pictures carry 6 October 1993 file timestamps and provide visual evidence of cockpit art/layout iteration. Their [source hashes and observations](jurassic-park-preview/manifest.json) are retained with the preview.

## Compiled VGA overlays

Six archive resources contain x86 drawing code. Executing them in isolation yields **five distinct programs**: `dat/a.bin` is byte-identical to `dat/cockpit.bin`, so it shares that extraction rather than producing another copy.

| Resource | Identification | Covered pixels in the unshifted capture |
| --- | --- | ---: |
| `dat/infcock.hud` | `infcock` canopy and upper instrument panel | 12,687 |
| `dat/cockpit.bin`, alias `dat/a.bin` | Related canopy prototype | 12,687 |
| `dat/misshud.hud` | Missile-tracking overlay | 2,331 |
| `dat/cockmap.bin` | Cockpit-map frame and four crosshairs | 28,006 |

The `infcock.hud` and `infcock.hdd` resources are physically present in the main TFX archive in all five retained CD/floppy installations, including the November 1993 floppy release. TFX’s executable explicitly references both filenames. The `inf` prefix suggests a relationship to Inferno, but it does not establish that this artwork was used in the released Inferno game: ordinary TFX environment files also select an `inferno` rendering setting, and the executable retains an Inferno-named mouse-driver error. Neither cockpit resource has an identical decoded payload in the December CD’s separate 60-entry Inferno demo archive. The browser therefore keeps the native `infcock` name without assigning the artwork conclusively to either game.

`cockmap.bin` was previously unnamed. Its filename is established by the loader at [0x86a60](code/index.html#86a60), with resource identifier `9e09d5da`. The generic HUD viewport routine at [0x74104](code/index.html#74104) passes a VGA segment, horizontal offset in plane bytes, and a vertical offset in rows × 80 to its selected overlay. The canopy programs use position-independent entry code and column-entry tables; the missile/map programs directly issue VGA map masks and pixel writes.

[decode_cockpits.py](../tools/decode_cockpits.py) executes these original programs in Unicorn. A VGA write hook records each plane's colour and coverage separately. This preserves an important distinction: **an untouched pixel is transparent in the extracted layer, while an explicitly drawn black pixel is opaque**. Palette colourisation happens afterwards. The native captures also exercise both canopy programs at horizontal offsets −8/+8 and a 28-row vertical offset; all eleven captures return normally without writes outside the emulated framebuffer. Their hashes and masks are in [native-checks.json](cockpits/native-checks.json).

## Companion bitmap and instruments

`dat/infcock.hdd` contains **17,600 bytes: four raw planes forming a 320×55 lower panel**. The uploader at [0x74060](code/index.html#74060) copies the planes separately. The browser can align this panel below the unshifted `infcock` canopy at Y = 145 for inspection; the complete moving-viewport composition and clipping are not simulated. The standalone lower-panel image and original source remain accessible. `misshud.hdd` is a five-byte companion (`70 0d 0a 0d 0a`), not another bitmap of the same layout.

The HUD initialiser at [0x7dc7c](code/index.html#7dc7c) establishes these sprite names directly:

`ladnums`, `warlites`, `warlite2`, `disp3`, `disp32`, `targcros`, `disp2`, `compdisp`, `newhud2`, `nwsg`, `aoasprs`, `pitfont`, `autolite`, `disp12`, `englite`.

These cover number/font glyphs, status and warning lamps, aiming marks, display backgrounds and engine/angle indicators. Previously unnamed banks now carry their recovered filenames in the media browser. The cockpit page exposes every stored frame with its original proportions. Its optional instrument layer uses the native layout captures described below. The same initialiser loads `dat/fwsalt.dat` and `dat/fwshdg.dat`, which use the ordinary sprite format despite their `.dat` suffixes. They are now named and included in the instrument artwork list: one 16×199 vertical strip and one 272×9 horizontal strip. Native helpers ending at `0x80ff9` and `0x8116c` clip and draw them, with the latter deriving strip position from a heading word. The captures do not yet exercise every flight-dependent ladder placement.

## Retained Inferno cockpit

A sixth drawing-code resource, identifier **`505f470c`**, contains the **Inferno cockpit artwork**, identified by comparison with the original game. The browser previously called it a “16-bit canopy prototype”; the 16-bit part describes the retained program, but “prototype” was not an established identification. This is separate from the `infcock` pair discussed above. Identification of the artwork does not establish that these exact compiled bytes were used in the released Inferno executable.

The program uses a 16-bit far call rather than the 32-bit entry used by the other overlays. Native execution recovers a fifth distinct overlay with **8,031 covered pixels**, occupying rows 79–117. Its [canopy PNG](cockpits/505f470c.png) retains the small text baked into the artwork. `dat/col.com` remains a filename-hash candidate, not an established runtime binding. The related 26,240-byte resource **`5160400c`** is the **lower section of that same Inferno cockpit**, stored as a four-plane 320×82 bitmap. Its [preview](cockpits/inferno-lower-section.png) starts at screen row 118 and continues through row 199; the straight upper cut is the boundary between the two resources, not a separate instrument panel. Selecting either Inferno section in the browser shows both together by default; uncheck the companion section to inspect the selected resource alone. The browser labels both as Inferno artwork while keeping the possible `dat/col.hdd` filename and runtime composition unconfirmed. Eleven isolated overlay captures return normally, including the other overlays' pan/vertical-offset cases.

### Palette inspection

The **original palette binding remains unidentified**. Neither the drawing code nor the lower bitmap stores RGB values: they write palette indices, which acquire their colours from a separately loaded VGA palette. In particular, both include large areas of index 14; ordinary TFX terrain palettes turn that into an obvious mustard-coloured fill. The captured write mask treats those explicitly drawn pixels as opaque; the viewer does not invent a transparent colour key for them.

The cockpit palette picker now includes **all 101 standalone palettes** extracted from the main archive: the 79 named palettes already available through the model dataset, plus 22 additional resources previously omitted from this picker. They are grouped as **Named TFX palettes** and **Additional archive palettes**, with identifiers retained for unnamed entries. Several produce substantially different cockpit colours, but appearance alone is not evidence of the original binding. No palette is automatically labelled or selected as the Inferno original.

The intact December 1993 Inferno preview archive contains animations and IFF pictures with their own palettes; inspection found no exact counterpart for this overlay or its lower bitmap. Its per-presentation palettes do not establish a cockpit palette binding. The PNGs linked above retain the previous TFX-palette colourisation for inspection; select another palette in the browser and use **Preview PNG** to export that version. Determining the released game's palette would require a binding or matching asset from the full Inferno data, rather than choosing a plausible colour scheme here.

### Warm palettes `87fc7669`, `ad08b055` and `5d87200a`

These three additional palette resources remain **unidentified by use**. None is named by the captured palette loads for the 33 successfully parsed TFX environments, and none exactly matches another retained media resource's complete palette. The only current filename candidates for `5d87200a` (`anim/ljn.lap`, `cmb/rar.lbm`) are ambiguous hash matches, not proof of either filename or purpose. Their warm orange/brown/red ramps distinguish them from many TFX flight palettes, but do not establish an Inferno association. Original-game visual comparison rules all three out as direct matches for this cockpit.

They are nevertheless related at the data level: `87fc7669` and `ad08b055` have **144 of 256 RGB entries identical**; `ad08b055` and `5d87200a` share **97**; `87fc7669` and `5d87200a` share **53**. The first pair preserves its red and purple families while changing substantial brown and metallic ramps. The second pair preserves most of the cockpit's metallic indices but changes its 128–143 ramp and several other entries. These are observations about their content, not recovered scene names or runtime roles. Source hashes and exact comparisons are retained in [palette-investigation.json](cockpits/palette-investigation.json).

There is **no index offset in the cockpit capture or browser mapping**: an original drawing write of index 133 selects entry 133 of the chosen palette. The 16-bit entry takes a destination segment and horizontal/vertical plane-byte offsets, with no colour-offset argument. For example, resource byte `0x35` directly writes colour `0x60` (96) to the framebuffer; byte `0x5f` writes `0x5b` (91). Browser checks compare every covered overlay pixel with that direct mapping, including these three palettes. An original game's separately assembled palette or additional colour translation is possible, but no such binding has been recovered for this retained 16-bit resource; applying an offset merely to make a palette look plausible would not establish the original colours.

## Native instrument layout and embedded text

The native HUD composer [0x803e8](code/index.html#803e8) and its MFD dispatchers have been exercised in **25 synthetic-telemetry cases**, recording **1,121** ordered drawing calls and capturing their actual VGA pixels. A [contact sheet](cockpits/hud-native/contact-sheet.png) colourises them with the Yugoslav palette for inspection. The cockpit viewer offers 24 cases; the extra +8/+28-pixel diagnostic remains in the records. The captures cover all nine outer-MFD modes in both positions, plus horizontal radar, beyond-visual-range radar and the moving map.

Outer pages are weapons, engine/fuel gauges, flight data, fuel, system warnings, the aircraft systems schematic, FLIR/DLIR camera, ground-target data bank and flight controls. The engine/fuel page is not an artificial horizon. [hud-layout.json](cockpits/hud-layout.json) records every supplied input, resource load, call, pixel hash and omitted helper; [the native checks](../tools/check_hud_displays.py) independently compare 31 monochrome bitmaps as well as the full capture files.

These are executions of original drawing code with supplied telemetry and a minimal planar VGA harness. Target coordinates and formatting inputs are declared synthetic. Embedded 3D camera/world rendering at `0x880e4` is omitted where listed; it needs a live scene. The viewer recolours the captured palette indices using the selected palette, without replacing the virtual cockpit's original static MFD texture artwork. This is substantially more than a layout mock-up, but is not a complete live flight frame.

The small HUD text does not come from a separate font file: **51 monochrome 8×6 glyphs** are embedded in `TFX.DAT`, with character and advance tables. All glyph masks match the native VGA blitter. Spaces advance three pixels; other characters use the native `character & 63` mapping and per-glyph width. [hud-font.json](cockpits/hud-font.json) preserves those tables and [the atlas](cockpits/hud-font.png).

The **29-entry viewport table** at file `0xf3844` has 20-byte records containing a callback pointer, an unnamed word, panel/overlay filename pointers and handles, and the viewport bottom. Its bindings include `infcock.hdd/hud` and `misshud.hdd/hud`; the complete relocated table is exposed below the cockpit viewer. No aircraft/camera name is assigned to an index until its selecting caller is established. Native table loading/composition/upload routines are `0x742a0`, `0x74104` and `0x74060` respectively.