@@ -287,7 +287,10 @@ with `swiftc`): it finds and checks `SPEED2.EXE`, offers full screen, opens the
 logs folder and manages saves (**Saves…**: the career profiles, backups, ZIP
 export and import; the current saves are backed up before an import replaces
 them; tests/save_manager.sh). **Settings…** (Cmd-,) holds the options on tabs:
-Original or HD graphics and the HUD on **Graphics**; on **Controls**, the game
+Original or HD graphics and the HUD on **Graphics**; on **Picture**, optional
+settings of the HD engine only (the PC version's colour tint, console gamma, edge
+smoothing, sharpening; `TINT` / `CONSOLEGAMMA` / `EDGEAA` / `SHARPEN`, all off by
+default; the Original engine ignores them); on **Controls**, the game
 controller on or off, its stick dead zone and the XtendedInput layout
 (`NFSU2_PAD` / `NFSU2_PAD_DEADZONE` / `NFSU2_XTINPUT`, which still win when set by
 hand); on **More**, **Make Copy…** builds a portable
 
@@ -83,6 +83,7 @@ enum Prefs {
         OriginalValue(\.wideHUD, false),
         OriginalValue(\.frameRate, 120),
         OriginalValue(\.fpsCounter, false),
+        OriginalValue(\.picture, PictureOptions.original),
     ]
 }
 
@@ -96,6 +97,40 @@ struct OriginalValue {
     }
 }
 
+/// Settings › Picture: optional picture settings of the HD engine, each passed to it as
+/// an environment variable (runtime/visual.c, runtime/picture.m; the original engine
+/// ignores them).  The first choice of every option is the original game and sets nothing.
+struct PictureOption {
+    let key: String                  // launcher default: the chosen index
+    let title: String
+    let description: String
+    let env: String
+    let choices: [(label: String, value: String)]
+}
+
+enum PictureOptions {
+    static let all: [PictureOption] = [
+        PictureOption(key: "LauncherColourTint", title: "Colour",
+                      description: "The yellow-green tint the PC version lays over the city. No tint keeps grey grey, Cool is a little bluer. The HUD and menus keep their colours.",
+                      env: "TINT",
+                      choices: [("As on PC (original)", ""), ("Less tint", "less"), ("No tint", "none"), ("Cool", "cool")]),
+        PictureOption(key: "LauncherGamma", title: "Gamma",
+                      description: "Console: the deeper, darker brightness curve of the Xbox 360 version.",
+                      env: "CONSOLEGAMMA",
+                      choices: [("As on PC (original)", ""), ("Console", "1")]),
+        PictureOption(key: "LauncherEdgeSmoothing", title: "Edge smoothing",
+                      description: "Softens the jagged outlines of cars, buildings, poles and wires. Textures and the HUD stay sharp.",
+                      env: "EDGEAA",
+                      choices: [("Off (original)", ""), ("On", "1")]),
+        PictureOption(key: "LauncherSharpening", title: "Sharpening",
+                      description: "Crisper textures in the city. The HUD is left alone.",
+                      env: "SHARPEN",
+                      choices: [("Off (original)", ""), ("Low", "50"), ("High", "100")]),
+    ]
+    /// Every option at its first choice: the original game.
+    static var original: [Int] { all.map { _ in 0 } }
+}
+
 enum Locator {
     static func exeIn(_ dir: URL) -> URL? {
         for n in SupportedExe.names {
 
@@ -29,6 +29,11 @@ final class LauncherModel: ObservableObject {
     @Published var stickDeadzone: Double { didSet { defaults.set(stickDeadzone, forKey: Prefs.stickDeadzone) } }
     private var setPad = false           // NFSU2_PAD / NFSU2_PAD_DEADZONE were set by us
     @Published var xtendedInput: Bool { didSet { defaults.set(xtendedInput, forKey: Prefs.xtendedInput) } }
+    /// Settings › Picture: PictureOptions.all[i] -> the chosen index (0 = the original game).
+    @Published var picture: [Int] { didSet { for (o, i) in zip(PictureOptions.all, picture) { defaults.set(i, forKey: o.key) } } }
+    /// Picture variables that were set by hand when the launcher started: those win.
+    private let pictureFromEnv = Set(PictureOptions.all.map { $0.env }
+                                         .filter { ProcessInfo.processInfo.environment[$0] != nil })
     private let xtendedInputFromEnv = ProcessInfo.processInfo.environment["NFSU2_XTINPUT"] != nil
     @Published var job: Job? = nil
     @Published var notice: String? = nil
@@ -66,6 +71,8 @@ final class LauncherModel: ObservableObject {
         controller = defaults.bool(forKey: Prefs.controller)
         stickDeadzone = min(0.5, max(0, defaults.double(forKey: Prefs.stickDeadzone)))
         xtendedInput = defaults.bool(forKey: Prefs.xtendedInput)
+        let d = defaults
+        picture = PictureOptions.all.map { o in min(max(d.integer(forKey: o.key), 0), o.choices.count - 1) }
     }
 
     /// runtime/xtinput.c has the North American v1.2 executable's addresses only.
@@ -156,6 +163,11 @@ final class LauncherModel: ObservableObject {
         }
         var e = engine
         if !hasEngine(e) { e = (e == .hd) ? .original : .hd }
+        // Picture options: HD engine only (the original engine ignores them anyway).
+        // Ours are set again on every Play; a variable set by hand still wins.
+        for (o, i) in zip(PictureOptions.all, picture) where !pictureFromEnv.contains(o.env) {
+            if e == .hd && i > 0 { setenv(o.env, o.choices[i].value, 1) } else { unsetenv(o.env) }
+        }
         let path = Paths.engine(loc.build, hd: e == .hd).path
         // A child process, not exec(): macOS attributes the child's file access to
         // this launcher (the "responsible" process), so folder permissions the
 
@@ -24,7 +24,7 @@ enum SettingsTab: String, CaseIterable {
     case graphics, picture, controls, online, game, mods, more
 
     /// The tabs that have rows, in this order.
-    static let shown: [SettingsTab] = [.graphics, .controls, .more]
+    static let shown: [SettingsTab] = [.graphics, .picture, .controls, .more]
 
     var title: String { rawValue.capitalized }
     var icon: String {          // SF Symbols available on macOS 11
@@ -118,6 +118,34 @@ struct GraphicsSettings: View {
     }
 }
 
+/// HD engine only: the original engine is the game's 2004 picture.
+struct PictureSettings: View {
+    @ObservedObject var model: LauncherModel
+    private var active: Bool { model.engine == .hd && model.hasEngine(.hd) }
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            Card("Picture") {
+                Text(!model.hasEngine(.hd)
+                     ? "These need the HD engine, which is not in this app."
+                     : active ? "HD engine only. (original) is the game as it was on PC."
+                              : "HD engine only: choose HD in Graphics to use them. The Original engine always shows the game as it was on PC.")
+                    .font(.system(size: 11)).foregroundColor(active ? Theme.dim : Theme.accent)
+                    .fixedSize(horizontal: false, vertical: true)
+                ForEach(0..<PictureOptions.all.count, id: \.self) { i in
+                    let o = PictureOptions.all[i]
+                    SettingRow(title: o.title, description: o.description) {
+                        Picker("", selection: $model.picture[i]) {
+                            ForEach(0..<o.choices.count, id: \.self) { k in Text(o.choices[k].label).tag(k) }
+                        }
+                        .pickerStyle(MenuPickerStyle()).labelsHidden().fixedSize()
+                    }
+                    .disabled(!active).opacity(active ? 1 : 0.5)
+                }
+            }
+        }
+    }
+}
+
 struct ControlsSettings: View {
     @ObservedObject var model: LauncherModel
     var body: some View {
@@ -191,9 +219,10 @@ struct SettingsView: View {
     @ViewBuilder private var page: some View {
         switch tab {
         case .graphics: GraphicsSettings(model: model)
+        case .picture: PictureSettings(model: model)
         case .controls: ControlsSettings(model: model)
         case .more: MoreSettings(model: model)
-        case .picture, .online, .game, .mods: EmptyView()      // no rows yet
+        case .online, .game, .mods: EmptyView()      // no rows yet
         }
     }
 
 
@@ -42,8 +42,8 @@ case "${BUILD:-eu}" in
   *)  echo "BUILD must be eu or na"; exit 1 ;;
 esac
 
-CSRC="mem dispatch genexec win32 win32_ext com debug res fileio overrides d3dx_hle vsemu enhance perflog wsfov gheap sndlead xpatch highfps xtinput"
-MSRC="metal audio bundle gamepad"
+CSRC="mem dispatch genexec win32 win32_ext com debug res fileio overrides d3dx_hle vsemu enhance perflog wsfov gheap sndlead xpatch highfps xtinput visual"
+MSRC="metal audio bundle gamepad picture"
 FW="-lm -framework Cocoa -framework Metal -framework QuartzCore -framework ImageIO -framework CoreGraphics -framework CoreServices -framework AudioToolbox -framework GameController -framework CoreText"
 SHARDS="$SOBJ/shard_*.o $SOBJ/fntab.o $SOBJ/stubs.o"
 
 
@@ -23,6 +23,12 @@ fi
 #   HD_GSEP=1 (G-buffer in a separate single-sampled pass), HD_MBFIX=1 (the scene stays
 #   multisampled during motion blur), HD_RT_FAR / HD_RT_BMIN (ray limits; off by default).
 #   Details: runtime/enhance.c, runtime/metal.m (sections of the same name)
+# Picture options, HD engine only (launcher Settings > Picture; unset = the original game):
+#   TINT=less|none|cool    the screen filter's yellow-green tint: half / none / none + cooler
+#   CONSOLEGAMMA=1         the Xbox 360 version's brightness curve
+#   EDGEAA=1               edge smoothing (post-process) of the 3D scene, not the HUD
+#   SHARPEN=1..100         contrast adaptive sharpening of the 3D scene, not the HUD
+#   Details: runtime/visual.c (TINT), runtime/picture.m (the others)
 # In game, Cmd+Shift+D: a PNG of that frame + the draw list (~/Library/Logs/NFSU2/
 #   or the PERFLOG directory).  Measurement recording while playing: tools/session.sh [hd].
 MODE="${1:-window}"
 
@@ -15,6 +15,7 @@
 #define GA_0x005BA11Du 0x005ba10du   /* function 005ba070 + 0xad */
 #define GA_0x005BA1DDu 0x005ba1cdu   /* function 005ba1b0 + 0x2d */
 #define GA_0x005BA559u 0x005ba549u   /* function 005ba4c0 + 0x99 */
+#define GA_0x005c6766u 0x005c6756u   /* function 005c6530 + 0x236 */
 #define GA_0x005c7ffeu 0x005c7feeu   /* function 005c7ed0 + 0x12e */
 #define GA_0x005c804eu 0x005c803eu   /* function 005c7ed0 + 0x17e */
 #define GA_0x005cbe54u 0x005cbe44u   /* function 005cbdd0 + 0x84 */
@@ -90,6 +91,7 @@
 #define GA_0x0086549cu 0x0086549cu   /* operand pair */
 #define GA_0x008654a4u 0x008654a4u   /* operand pair */
 #define GA_0x00865558u 0x00865558u   /* operand pair */
+#define GA_0x0086f8acu 0x0086f8acu   /* operand pair */
 #define GA_0x00870818u 0x00870818u   /* operand pair */
 #define GA_0x00890080u 0x00890080u   /* operand pair */
 #define GA_0x008a44ecu 0x008a44ecu   /* operand pair */
 
@@ -4028,9 +4028,21 @@ int com_call(CPU *c, uint32_t magic){
                 if (is_cube2)
                     metal_upload_texture_face(mid, level, (face2 < 6u) ? face2 : 0u, g_mem+buf,
                                               metal_level_pitch(w,level,fmt), w, h, fmt);
+#if NFS_ENHANCED
+                else {
+                    /* visual.c: TINT (HD engine) rewrites the screen filter's colour ramp on the way */
+                    const void *visual_tex_upload(uint32_t, const void *, uint32_t, uint32_t, uint32_t, uint32_t, void *, uint32_t);
+                    static uint8_t vtmp[1024];
+                    uint32_t pitch = metal_level_pitch(w,level,fmt);
+                    const void *src = level ? (const void *)(g_mem+buf)
+                                            : visual_tex_upload(self, g_mem+buf, w, h, fmt, pitch, vtmp, sizeof vtmp);
+                    metal_upload_texture(mid, level, src, pitch, w, h, fmt);
+                }
+#else
                 else
                     metal_upload_texture(mid, level, g_mem+buf,
                                          metal_level_pitch(w,level,fmt), w, h, fmt);
+#endif
             }
             if (ENVC("LOCKLOG") && w==640 && h==480){
                 static int nl=0;
@@ -4853,6 +4865,8 @@ void draw_stats_save(uint64_t *a, uint64_t *b){ g_ptype=a; g_stride=b; }
 void com_report(void){
     fprintf(stderr,"\n=== COM / D3D9 KATMANI ===\n");
     { void ws_report(void); ws_report(); }   /* wsfov.c */
+    { void visual_report(void); visual_report(); }   /* visual.c */
+    { void pic_report(void); pic_report(); }         /* picture.m */
     { void gamepad_report(void); gamepad_report(); }   /* gamepad.m */
     { void xpatch_report(void); xpatch_report(); }
     { void highfps_report(void); highfps_report(); }   /* LOCAL PATCH: highfps.c */
@@ -5064,3 +5078,4 @@ static void fill_caps(uint32_t p){
       MR32(p+0xC4)=vs; MR32(p+0xC8)=256; MR32(p+0xCC)=ps; }
     MRF32(p+0xD0)=8.0f; MR32(p+0xD4)=0x00000051;
 }
+
@@ -96,6 +96,7 @@ void guest_hook(CPU *c, uint32_t ip){
     { int ws_hook(CPU *, uint32_t); if (ws_hook(c, ip)) return; }   /* wsfov.c */
     { int sndlead_hook(CPU *, uint32_t); if (sndlead_hook(c, ip)) return; }   /* sndlead.c */
     { int highfps_hook(CPU *, uint32_t); if (highfps_hook(c, ip)) return; }   /* highfps.c */
+    { int visual_hook(CPU *, uint32_t); if (visual_hook(c, ip)) return; }   /* visual.c */
     if (ip == GA(0x0065ae35u)){
         uint32_t a1=MR32(c->esp+4u), a2=MR32(c->esp+8u), a3=MR32(c->esp+12u);
         if (!g_rec_esp0) g_rec_esp0 = c->esp;
 
@@ -592,6 +592,7 @@ static int gpuw_in(long f){
 static int abt_off(const char *name){
     return g_abt_cur_off && g_abt_name && !strcmp(g_abt_name, name);
 }
+int metal_abt_off(const char *name){ return abt_off(name); }   /* for the other runtime files */
 /* called at the start of encoding: mode (-1 = outside A/B, 0 = on, 1 = off);
  * *cnt = whether the frame's GPU time counts */
 static int abt_frame(long f, int *cnt){
@@ -4728,6 +4729,36 @@ static long scr_redirect_plan(int rb, id<MTLTexture> scr, unsigned *outT){
 #endif
 }
 
+/* ---- PICTURE OPTIONS (picture.m) -------------------------------------------
+ * EDGEAA / SHARPEN work on the 3D scene before the HUD: the frame's last draw
+ * to the screen that covers it completely and reads a render target of the
+ * screen's size is the copy of the finished scene (in a race: ps 22 after the
+ * post-process chain); the HUD comes after it.  That draw reads picture.m's
+ * output instead of the target; EDGEAA also reads the scene's depth (the
+ * implicit Z surface, still the scene's then).  A frame without such a draw
+ * (2D menus) is left alone.  CONSOLEGAMMA runs over the finished frame (end of encoding).
+ * ABTEST=PICTURE turns both off in the measurement's off slices.
+ * HD engine only: the original engine draws the game's picture as it was. */
+#if NFS_ENHANCED   /* HD engine only */
+int pic_pre_on(void);
+id<MTLTexture> pic_pre(id<MTLDevice>, id<MTLCommandBuffer>, id<MTLTexture>, id<MTLTexture>);
+static long pic_plan(int rb, id<MTLTexture> scr){
+    if (rb < 0 || !scr || !pic_pre_on() || abt_off("PICTURE")) return -1;
+    const MDraw *D = g_dbuf[rb];
+    for (long k = (long)g_dn[rb] - 1; k >= 0; k--){
+        const MDraw *x = &D[k];
+        if (x->target || x->is_clear || x->is_blit || x->is_up || !x->count) continue;
+        unsigned t = x->tex;
+        if (!t || t >= MAXTEX || !g_tex[t]) continue;
+        id<MTLTexture> T = g_tex[t];
+        if (T.textureType != MTLTextureType2D || !(T.usage & MTLTextureUsageRenderTarget) ||
+            T.width != scr.width || T.height != scr.height) continue;
+        if (draw_covers(x, scr.width, scr.height)) return k;
+    }
+    return -1;
+}
+#endif
+
 /* ---- HUD ANCHORING (HUDPOS=1) ---------------------------------------------
  * The game lays its HUD out for 640x480; on a wider screen HUDFIX squeezes it
  * into the centered 4:3 area (round gauges stay round).  With HUDPOS the
@@ -6891,6 +6922,10 @@ + (unsigned long long)_d1.tv_nsec - (unsigned long long)_d0.tv_nsec);
                         /* see POST-PROCESS CHAIN: fbrole[i] 1 = chain start, 2 = continuation */
                         static uint8_t fbrole[MAXD];
                         int nfb = rb >= 0 ? fb_plan(rb, fbrole, g_dn[rb]) : 0;
+#if NFS_ENHANCED
+                        long pic_at = pic_plan(rb, dtex);   /* see PICTURE OPTIONS */
+                        id<MTLTexture> pic_tex = nil;
+#endif
                         int fbv_pend = 0; unsigned fbv_s = 0, fbv_e = 0;   /* FBZINCIR=2: verification pending */
 #if NFS_ENHANCED
                         int hd_scene_open = 1;          /* main scene up to the first copy from the screen */
@@ -7247,6 +7282,16 @@ + (unsigned long long)_d1.tv_nsec - (unsigned long long)_d0.tv_nsec);
                                     }
                                     continue;
                                 }
+#if NFS_ENHANCED
+                                if ((long)i == pic_at){
+                                    /* PICTURE OPTIONS: the scene is complete, the copy to the screen follows */
+                                    if (enc){ int pe = hd_ms_end(enc, rb, i, c_ms, c_gb, c_att);
+                                              [enc endEncoding]; enc = nil;
+                                              if (pe) hd_ms_fallback(cb, dtex, pe); }
+                                    cur_t = 0xFFFFFFFFu; cur_z = 0xFFFFFFFFu;
+                                    pic_tex = pic_pre(g_dev, cb, g_tex[dr->tex], g_ztex[1]);   /* the scene's Z: the implicit surface */
+                                }
+#endif
                                 if (nfb && fbrole[i] == 1){
                                     unsigned e = i; while (e + 1 < g_dn[rb] && fbrole[e + 1] == 2) e++;
 #if NFS_ENHANCED
@@ -7656,6 +7701,9 @@ + (unsigned long long)_d1.tv_nsec - (unsigned long long)_d0.tv_nsec);
                                                          | MTLTextureUsageShaderRead   /* SSR reads depth */
 #endif
                                                          ;
+#if NFS_ENHANCED
+                                                if (pic_pre_on()) zd.usage |= MTLTextureUsageShaderRead;   /* EDGEAA: picture.m reads it */
+#endif
                                                 zd.storageMode = MTLStorageModePrivate;
                                                 g_ztex[zid] = zt = [g_dev newTextureWithDescriptor:zd];
                                                 atomic_store(&g_zlive[zid], 1);
@@ -7937,6 +7985,9 @@ + (unsigned long long)_d1.tv_nsec - (unsigned long long)_d0.tv_nsec);
                                       freed_use(tt, 0);
                                       id<MTLTexture> txn = (tt && tt < MAXTEX && g_tex[tt])
                                                            ? g_tex[tt] : g_white;
+#if NFS_ENHANCED
+                                      if (q4 == 0 && pic_tex && (long)i == pic_at){ txn = pic_tex; c_tex[0] = ~0u; }
+#endif
                                       [enc setFragmentTexture:txn atIndex:(NSUInteger)q4];
                                   } }
                                 atomic_fetch_add(&g_draw_n, 1ull);
@@ -7991,6 +8042,12 @@ + (unsigned long long)_d1.tv_nsec - (unsigned long long)_d0.tv_nsec);
                                 [cb renderCommandEncoderWithDescriptor:rp];
                             [e2 endEncoding];
                         }
+                        /* picture.m: CONSOLEGAMMA over the finished frame (HUD included);
+                         * ABTEST=PICTURE measures the picture passes' cost */
+#if NFS_ENHANCED
+                        { void pic_gamma(id<MTLDevice>, id<MTLCommandBuffer>, id<MTLTexture>);
+                          if (!abt_off("PICTURE")) pic_gamma(g_dev, cb, dtex); }
+#endif
                         /* PERFLOG counters must be taken BEFORE the buffer is GIVEN BACK to the game:
                          * afterwards the game thread zeroes and refills the same buffer.
                          * It used to be read after present; when the drawable wait got