Coulson S-61N (N261CG) corresponding source - GTLA, 2026-09-20

This is the source for the helicopter model GTLA shows for N261CG, the Coulson
S-61N that flies as County Fire tanker 61. It holds what you need to build the
published model again, and to change it.

WHERE IT COMES FROM. The model is adapted from the FlightGear UK (FGUK)
Westland Sea King:
https://sites.google.com/view/fgukhangar/flightgear-uk-home-page/hangar/rotary-wing/sea-king
Its authors, as named in har3-set.xml and hc4-set.xml: Simon Lister, MVDP (3D),
Oliver Thurau (FDM and animations), Stuart C (FDM) and Garry Brown (paint).
We downloaded the FGUK archive on 2026-09-18 (SHA-256
be6b2b1dca57c258caae8c350aba2f4cc2712366459a8cceae3e137f0aa66a38);
outputs/N261CG-S61N/source-provenance.json records where from.

LICENCE. The Sea King's set files declare it "GPL v2" and name no later
version. GTLA's adaptation (the geometry changes, the livery and the rotor
animation) is distributed on the same terms: the GNU General Public License,
version 2 only. The FGUK archive carries no licence text of its own, so COPYING
is the verbatim GPL version 2 text as published by the Free Software
Foundation. No warranty. Names, registrations and operator titles identify the
aircraft shown and imply no endorsement.

WHAT THE BUILD READS FROM UPSTREAM. Six AC3D mesh files, included unchanged
under outputs/N261CG-S61N/source/fguk/Westland_SeaKing/Models/:
  har3.ac                        the Sea King HAR.3 body
  hcbits.ac                      HC.4 landing gear parts
  MainRotor/mainrotor.ac         main rotor hub and mast
  MainRotor/blade.ac             main blade roots, cuffs and links
  TailRotor/tailrotor_head.ac    tail rotor hub
  TailRotor/tailrotor_blade.ac   tail blade roots and links
ac_reader.py reads them as plain data. No FlightGear script is run and no FGUK
image is used: the paint comes from our two livery images and flat colours.
har3-set.xml and hc4-set.xml are included because they name the authors and
the licence. The rest of the FGUK aircraft (flight model, scripts, sounds,
cockpit, textures) is flight-simulator material this conversion never reads;
it is available from the FGUK page above.

LAYOUT. Paths are the ones the scripts expect, from this archive's root:
  outputs/N261CG-S61N/source/fguk/...    the upstream files above
  outputs/N261CG-S61N/ac_reader.py       reads AC3D files as data
  outputs/N261CG-S61N/texture.py         draws the two livery images
  outputs/N261CG-S61N/build.py           Blender: imports the Sea King parts,
                                         turns them into the S-61N, paints it
                                         and writes exports/raw.glb
  outputs/N261CG-S61N/finalize.mjs       adds the rotor and beacon animation,
                                         compresses, validates, and writes the
                                         standard and mobile files
  outputs/N261CG-S61N/verify.mjs         checks blades, pivots and animation
  outputs/N261CG-S61N/package-source.py  the script that made this archive
  outputs/N261CG-S61N/README.md          the builder's notes, written while
                                         the model was still under review
  outputs/N261CG-S61N/aircraft/N261CG/   config.json, wiring.json (see
                                         PACKED SETTINGS FILES below),
                                         geometry-build.json, the FAA registry
                                         record, and textures/port.png and
                                         starboard.png, the livery we drew
  package.json                           the Node packages and versions used

REBUILD. You need Blender 5.2, Python 3 with Pillow, and Node 22 or later.
From this archive's root:
  npm install
  python3 outputs/N261CG-S61N/texture.py      (optional: redraws the livery)
  blender --background --factory-startup --python outputs/N261CG-S61N/build.py
  node outputs/N261CG-S61N/finalize.mjs N261CG
  node outputs/N261CG-S61N/verify.mjs
build.py writes aircraft/N261CG/exports/raw.glb, a Blender file
(aircraft/N261CG/N261CG.blend), geometry-build.json and three review pictures.
finalize.mjs writes exports/N261CG-standard.glb and exports/N261CG-mobile.glb
and records their checksums in config.json. verify.mjs checks them.

THE CHANGES FROM A SEA KING ARE ALL IN build.py. The engine deck and mast move
2.5 m aft and the main gear 3.4 m; the military parts (radome, rescue winch,
sponsons, six-blade tail rotor, blur discs) are left out; civil cabin windows,
five new main blades, a five-blade tail rotor, open gear struts, the belly
tank, hose and beacon are added. All of it is code, with no hand edits.

WHY THERE IS NO BLENDER FILE. build.py starts from an empty scene and saves
N261CG.blend as one of its outputs; nothing in the build reads it back. It
holds nothing that build.py and the files here do not make, so build.py is the
form to edit, and the .blend is left out.

CHECKED. On 2026-09-20 we unpacked this archive into an empty folder, with
no Blender file anywhere, and rebuilt from it alone (Blender 5.2.0, Pillow
12.3, Node 24). texture.py redrew both livery images byte for byte. In the
rebuilt standard and mobile files every mesh, texture and animation matched
the published copies byte for byte except one: the small red beacon light on
the tail. Its 224 triangles came out the same, but Blender listed them in a
different order, so its compressed bytes differ. Blender does that on its own
from run to run: two rebuilds on the same machine from the same files differed
from each other in the same place. Run on our own 2026-09-18 Blender export,
finalize.mjs reproduces the published files byte for byte (before stamping).

FONTS. texture.py uses three macOS fonts from /System/Library/Fonts/Supplemental/
(Arial Bold, Arial Bold Italic and Times New Roman Bold). They are proprietary
and not included. Use any font you have in their place, or skip texture.py and
build with the livery images already in aircraft/N261CG/textures/.

FAA RECORD. build.py and finalize.mjs check the saved FAA registry record for
N261CG by SHA-256 before they run, so it is included.

PACKED SETTINGS FILES. config.json and wiring.json here are copies of our own
with our internal review notes taken out: the record of the go-ahead to commit
the files, the flag that recorded whether public use had been approved, the
review-stage build status, the review notes about approval and deployment (one
note, that there is no HD file, is kept without its approval remark), and a
note of who asked for the main rotor's finish. Those notes were about our
review, not the model. None of the scripts here reads them, and
package-source.py refuses to pack if one ever does, so the build works exactly
as before. Every setting the scripts read is the same as in our build inputs,
and our build inputs themselves are unchanged.

NOT INCLUDED: reference photographs and saved web pages, the proprietary
fonts, the Blender file (see above), raw and rollback exports, the downloaded
FGUK archive itself (the six files the build uses are included unchanged),
review pictures, logs, and the parts of the FlightGear aircraft this
conversion never reads.

PUBLISHED FILES. The finished models are not repeated here. They are served at
  https://gtla.live/models/n261cg-s61n.glb          standard
  https://gtla.live/models/mobile/n261cg-s61n.glb   phones
There is no HD file for this aircraft. SHA256SUMS-published.txt lists the
checksums of the files as served. Those copies carry an attribution and
provenance stamp in the JSON part of the file only.
MODEL-BIN-CHUNK-SHA256.txt lists the checksum of each file's binary part (the
geometry, textures and animation), which the stamp never changes. A rebuild
matches everything in it except the beacon light's triangle order (see
CHECKED), so compare mesh by mesh rather than expecting the same checksum.

SHA256SUMS lists every other file in this archive.
