@@ -288,8 +288,9 @@ 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
-controller on or off and its stick dead zone (`NFSU2_PAD` / `NFSU2_PAD_DEADZONE`,
-which still win when set by hand); on **More**, **Make Copy…** builds a portable
+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
 app with the game files inside (APFS clones, seconds on the same disk), so nobody
 needs `pack.sh --embed` or a terminal for that.
 **Restore Original Game** sets every option back to the original, unmodified
@@ -366,6 +367,16 @@ No. Only Apple Silicon is targeted and tested.
 There is no wheel support and no online play.
 See [Known limitations](#known-limitations).
 
+**Can the controller work like it does with the XtendedInput mod on Windows?**
+Yes, with the North American v1.2 executable: in **Settings… › Controls**, with the
+controller on, switch on **XtendedInput layout**. The triggers are then separate analog throttle (RT) and
+brake (LT), and every button, in races and in the menus, does what it does with
+[NFSU-XtendedInput](https://github.com/xan1242/NFSU-XtendedInput)
+(`runtime/xtinput.c` is a port of its NFSU2 code, MIT licence). The game
+folder's `scripts/NFSU_XtendedInput.ini` is used if there is one, as in a Windows
+install with the mod; otherwise the mod's stock settings. Without the switch the
+pad is a DirectInput gamepad, bound in the game's own controller options.
+
 **How is this different from other NFSU2 projects?**
 
 | Project | Approach | Platforms |
 
@@ -64,9 +64,10 @@ enum Prefs {
     // Shared with the engine (same bundle id, same defaults domain).
     static let gameFolder = "OyunDizini"          // name kept for existing installs
     static let fullscreen = "NFSUFullScreen"
-    // Launcher only; passed to the engine as NFSU2_PAD / NFSU2_PAD_DEADZONE.
+    // Launcher only; passed to the engine as NFSU2_PAD / NFSU2_PAD_DEADZONE / NFSU2_XTINPUT.
     static let controller = "LauncherController"
     static let stickDeadzone = "LauncherStickDeadzone"
+    static let xtendedInput = "LauncherXtendedInput"
     // Launcher only.
     static let engine = "LauncherEngine"           // "original" | "hd"
     static let showAtStartup = "LauncherShowAtStartup"
 
@@ -28,6 +28,8 @@ final class LauncherModel: ObservableObject {
     @Published var controller: Bool { didSet { defaults.set(controller, forKey: Prefs.controller) } }
     @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) } }
+    private let xtendedInputFromEnv = ProcessInfo.processInfo.environment["NFSU2_XTINPUT"] != nil
     @Published var job: Job? = nil
     @Published var notice: String? = nil
 
@@ -63,8 +65,12 @@ final class LauncherModel: ObservableObject {
         fpsCounter = defaults.bool(forKey: Prefs.fpsCounter)
         controller = defaults.bool(forKey: Prefs.controller)
         stickDeadzone = min(0.5, max(0, defaults.double(forKey: Prefs.stickDeadzone)))
+        xtendedInput = defaults.bool(forKey: Prefs.xtendedInput)
     }
 
+    /// runtime/xtinput.c has the North American v1.2 executable's addresses only.
+    var canUseXtendedInput: Bool { location?.build?.engineSuffix == "-na" }
+
     var location: GameLocation? {
         switch game {
         case .ready(let l), .unsupported(let l, _): return l
@@ -143,6 +149,11 @@ final class LauncherModel: ObservableObject {
             setenv("NFSU2_PAD_DEADZONE", String(format: "%.2f", stickDeadzone), 1)
             setPad = true
         }
+        // XtendedInput layout (runtime/xtinput.c); only with the controller on.
+        if !xtendedInputFromEnv {
+            let padOn = getenv("NFSU2_PAD").map { String(cString: $0) != "0" } ?? true
+            setenv("NFSU2_XTINPUT", padOn && xtendedInput && canUseXtendedInput ? "1" : "0", 1)
+        }
         var e = engine
         if !hasEngine(e) { e = (e == .hd) ? .original : .hd }
         let path = Paths.engine(loc.build, hd: e == .hd).path
 
@@ -136,6 +136,13 @@ struct ControlsSettings: View {
                     }
                 }
                 .disabled(!model.controller).opacity(model.controller ? 1 : 0.5)
+                SettingRow(title: "XtendedInput layout",
+                           description: model.canUseXtendedInput
+                               ? "RT accelerates, LT brakes, every button as in the NFSU-XtendedInput mod, set in scripts/NFSU_XtendedInput.ini in the game folder if there is one. Off: buttons are set in the game's Controls menu."
+                               : "Needs the North American v1.2 SPEED2.EXE.",
+                           isOn: $model.xtendedInput)
+                .disabled(!model.controller || !model.canUseXtendedInput)
+                .opacity(model.controller && model.canUseXtendedInput ? 1 : 0.5)
             }
         }
     }
 
@@ -42,7 +42,7 @@ 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"
+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"
 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"
 
@@ -4343,7 +4343,8 @@ int com_call(CPU *c, uint32_t magic){
              * REALLY call the callback: report a keyboard and a mouse. */
             uint32_t devtype=A(c,1), cb=A(c,2), ref=A(c,3);
             if (cb && devtype == 4u){                 /* DI8DEVCLASS_GAMECTRL: the host pad */
-                if (gamepad_present()){
+                int xtinput_active(void);         /* runtime/xtinput.c reads the pad itself */
+                if (!xtinput_active() && gamepad_present()){
                     uint32_t args[2] = { make_devinst(3), ref };
                     call_guest(c, cb, 2, args);
                     fprintf(stderr,"  [DI] game pad offered to the game: %s\n", gamepad_name());
@@ -4745,6 +4746,7 @@ void com_report(void){
     { void gamepad_report(void); gamepad_report(); }   /* gamepad.m */
     { void xpatch_report(void); xpatch_report(); }
     { void highfps_report(void); highfps_report(); }   /* LOCAL PATCH: highfps.c */
+    { void xtinput_report(void); xtinput_report(); }   /* xtinput.c */
     if (g_aspfix != 1.f)
         { fprintf(stderr,"  widescreen       : aspfix %.4f, %lu perspective / %lu orthographic draws\n",
                   g_aspfix, g_asp_persp, g_asp_ortho);
 
@@ -92,6 +92,13 @@ int fileio_game_file_exists(const char *win){
     return resolve_in(g_root, win, p, sizeof p) && stat(p, &st) == 0 && S_ISREG(st.st_mode);
 }
 
+/* Host path of a file in the game folder (Windows-style path, case-insensitive);
+ * 0 if it isn't there. */
+int fileio_game_path(const char *win, char *out, size_t outsz){
+    struct stat st;
+    return resolve_in(g_root, win, out, outsz) && stat(out, &st) == 0 && S_ISREG(st.st_mode);
+}
+
 /* --- write root (save layer) ---------------------------------------------
  * The game writes its saves and profiles into its OWN folder ("C:\NFSU2\NFS
  * Underground 2\<name>\<name>").  Writing there deletes the saves when a new
 
@@ -18,6 +18,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <os/lock.h>
 
 int  gamepad_present(void);
 void gamepad_fill(unsigned char *dst);
@@ -57,11 +58,65 @@ static void parse_fake(const char *s){
     return nil;
 }
 
+/* XInput snapshot for gamepad_xinput_state.  The controller's value-changed handler
+ * fills it on a queue of its own and the game thread only copies it: GameController
+ * calls made from the game thread (+controllers in particular) wait for the main
+ * thread, which is busy presenting frames, and stalled the game and its audio. */
+typedef struct { uint16_t buttons; uint8_t trig[2]; int16_t sticks[4]; int connected; } XSnap;
+static os_unfair_lock    g_xs_lock = OS_UNFAIR_LOCK_INIT;
+static XSnap             g_xs;
+static GCController     *g_xs_ctl = nil;          /* main thread only */
+static dispatch_queue_t  g_xs_queue;
+
+static void xs_snapshot(GCExtendedGamepad *g){
+    static const uint16_t xbit[14] = { 0x1000, 0x2000, 0x4000, 0x8000, 0x0100, 0x0200,
+        0x0020, 0x0010, 0x0040, 0x0080, 0x0001, 0x0002, 0x0004, 0x0008 };
+    #define S16(v) ((int16_t)lroundf(fmaxf(-1.f, fminf(1.f, (v))) * 32767.f))
+    #define U8(v)  ((uint8_t)lroundf(fmaxf(0.f, fminf(1.f, (v))) * 255.f))
+    XSnap s = { 0 };
+    s.connected = 1;
+    s.sticks[0] = S16(g.leftThumbstick.xAxis.value);   s.sticks[1] = S16(g.leftThumbstick.yAxis.value);
+    s.sticks[2] = S16(g.rightThumbstick.xAxis.value);  s.sticks[3] = S16(g.rightThumbstick.yAxis.value);
+    s.trig[0] = U8(g.leftTrigger.value);  s.trig[1] = U8(g.rightTrigger.value);
+    GCControllerButtonInput *bs[14] = { g.buttonA, g.buttonB, g.buttonX, g.buttonY,
+        g.leftShoulder, g.rightShoulder, g.buttonOptions, g.buttonMenu,
+        g.leftThumbstickButton, g.rightThumbstickButton,
+        g.dpad.up, g.dpad.down, g.dpad.left, g.dpad.right };
+    for (int i = 0; i < 14; i++) if (bs[i] && bs[i].pressed) s.buttons |= xbit[i];
+    #undef S16
+    #undef U8
+    os_unfair_lock_lock(&g_xs_lock); g_xs = s; os_unfair_lock_unlock(&g_xs_lock);
+}
+
+static void xs_attach(GCController *c){              /* main thread */
+    GCExtendedGamepad *g = c.extendedGamepad;
+    if (!g || g_xs_ctl) return;
+    g_xs_ctl = c;
+    { const char *n = c.vendorName.UTF8String; if (n && *n) snprintf(g_name, sizeof g_name, "%s", n); }
+    g_seen = 1;
+    c.handlerQueue = g_xs_queue;
+    g.valueChangedHandler = ^(GCExtendedGamepad *gp, GCControllerElement *el){ (void)el; xs_snapshot(gp); };
+    dispatch_async(g_xs_queue, ^{ xs_snapshot(g); });
+    fprintf(stderr, "[pad] reading %s (%s) for XtendedInput controls\n",
+            c.vendorName.UTF8String ?: "controller", c.productCategory.UTF8String ?: "?");
+}
+
+static void xs_detach(GCController *c){              /* main thread */
+    if (c != g_xs_ctl) return;
+    c.extendedGamepad.valueChangedHandler = nil;
+    g_xs_ctl = nil;
+    dispatch_async(g_xs_queue, ^{                    /* after any snapshot still queued */
+        os_unfair_lock_lock(&g_xs_lock); memset(&g_xs, 0, sizeof g_xs); os_unfair_lock_unlock(&g_xs_lock);
+    });
+    for (GCController *o in [GCController controllers]) if (o != c && o.extendedGamepad){ xs_attach(o); break; }
+}
+
 void gamepad_install(void){
     const char *e = getenv("NFSU2_PAD");
     if (e && !strcmp(e, "0")){ g_pad_off = 1; return; }
     if ((e = getenv("NFSU2_PAD_DEADZONE"))) g_dead = (float)atof(e);
     if ((e = getenv("NFSU2_PAD_FAKE"))){ g_fake = 1; parse_fake(e); snprintf(g_name, sizeof g_name, "Fake Pad"); }
+    g_xs_queue = dispatch_queue_create("nfsu2.pad", DISPATCH_QUEUE_SERIAL);
     @autoreleasepool {
         if (@available(macOS 11.3, *))
             GCController.shouldMonitorBackgroundEvents = YES;
@@ -70,12 +125,16 @@ void gamepad_install(void){
             usingBlock:^(NSNotification *n){
                 GCController *c = n.object;
                 fprintf(stderr, "[pad] connected: %s\n", c.vendorName.UTF8String ?: "controller");
+                xs_attach(c);
             }];
         [[NSNotificationCenter defaultCenter]
             addObserverForName:GCControllerDidDisconnectNotification object:nil queue:nil
             usingBlock:^(NSNotification *n){
                 fprintf(stderr, "[pad] disconnected\n");
+                xs_detach(n.object);
             }];
+        dispatch_async(dispatch_get_main_queue(), ^{   /* pads connected before the start */
+            GCController *c = pick(); if (c) xs_attach(c); });
     }
 }
 
@@ -150,9 +209,46 @@ void gamepad_fill(unsigned char *dst){
     for (int i = 0; i < 10; i++) if (bs[i] && bs[i].pressed){ btn[i] = 0x80; g_pressed++; }
 }
 
+/* XInput view of the pad for runtime/xtinput.c (XINPUT_GAMEPAD: wButtons bits, triggers
+ * 0..255, sticks -32768..32767 with up = positive).  No dead zone: the caller applies its
+ * own.  Returns 0 (and a neutral state) when no pad is connected.  Only copies the
+ * snapshot above, so it never waits on GameController.
+ * NFSU2_PAD_FAKE maps X/Y -> left stick, RX/RY -> right stick (DirectInput sense,
+ * forward = negative), Z -> LT, RZ -> RT, B0..B9 -> A B X Y LB RB Back Start LS RS,
+ * POV -> d-pad. */
+int gamepad_xinput_state(uint16_t *buttons, uint8_t trig[2], int16_t sticks[4]){
+    *buttons = 0; trig[0] = trig[1] = 0;
+    for (int i = 0; i < 4; i++) sticks[i] = 0;
+    if (g_pad_off) return 0;
+    static const uint16_t xbit[10] = { 0x1000, 0x2000, 0x4000, 0x8000, 0x0100, 0x0200,
+                                       0x0020, 0x0010, 0x0040, 0x0080 };
+    #define S16(v) ((int16_t)lroundf(fmaxf(-1.f, fminf(1.f, (v))) * 32767.f))
+    #define U8(v)  ((uint8_t)lroundf(fmaxf(0.f, fminf(1.f, (v))) * 255.f))
+    if (g_fake){
+        sticks[0] = S16(g_fake_ax[0]);  sticks[1] = S16(-g_fake_ax[1]);
+        sticks[2] = S16(g_fake_ax[3]);  sticks[3] = S16(-g_fake_ax[4]);
+        trig[0] = U8(fabsf(g_fake_ax[2]));  trig[1] = U8(fabsf(g_fake_ax[5]));
+        for (int i = 0; i < 10; i++) if (g_fake_btn[i]) *buttons |= xbit[i];
+        switch (g_fake_pov){                     /* d-pad: up 1, down 2, left 4, right 8 */
+        case 0: *buttons |= 1; break;      case 4500: *buttons |= 1|8; break;
+        case 9000: *buttons |= 8; break;   case 13500: *buttons |= 2|8; break;
+        case 18000: *buttons |= 2; break;  case 22500: *buttons |= 2|4; break;
+        case 27000: *buttons |= 4; break;  case 31500: *buttons |= 1|4; break;
+        default: break; }
+        return 1;
+    }
+    #undef S16
+    #undef U8
+    os_unfair_lock_lock(&g_xs_lock); XSnap s = g_xs; os_unfair_lock_unlock(&g_xs_lock);
+    g_polls++;
+    *buttons = s.buttons; trig[0] = s.trig[0]; trig[1] = s.trig[1];
+    for (int i = 0; i < 4; i++) sticks[i] = s.sticks[i];
+    return s.connected;
+}
+
 void gamepad_report(void){
     if (g_pad_off) return;
     fprintf(stderr, "[pad] %s: %s, %llu state polls, %llu button-presses seen\n",
-            g_fake ? "fake" : "GameController", g_ctl || g_fake ? g_name : "no controller",
+            g_fake ? "fake" : "GameController", g_ctl || g_fake || g_seen ? g_name : "no controller",
             g_polls, g_pressed);
 }
Original file line number	Diff line number	Diff line change
`@@ -136,6 +136,13 @@ struct ControlsSettings: View {`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`	`.disabled(!model.controller).opacity(model.controller ? 1 : 0.5)`
	`139`	`+ SettingRow(title: "XtendedInput layout",`
	`140`	`+ description: model.canUseXtendedInput`
	`141`	`+ ? "RT accelerates, LT brakes, every button as in the NFSU-XtendedInput mod, set in scripts/NFSU_XtendedInput.ini in the game folder if there is one. Off: buttons are set in the game's Controls menu."`
	`142`	`+ : "Needs the North American v1.2 SPEED2.EXE.",`
	`143`	`+ isOn: $model.xtendedInput)`
	`144`	`+ .disabled(!model.controller \|\| !model.canUseXtendedInput)`
	`145`	`+ .opacity(model.controller && model.canUseXtendedInput ? 1 : 0.5)`
`139`	`146`	`}`
`140`	`147`	`}`
`141`	`148`	`}`