Added foveated rendering for the Quest

- Eyes render under a VK_EXT_fragment_density_map: full rate around each eye's forward direction,
  2x2 then 4x4 pixel blocks towards the edges ([vr] foveation = off|low|medium|high, default off).
  XR_FB_foveation cannot help here: the runtime's maps only shape passes drawing into its
  swapchain, and the eyes reach it through a copy.
- aurora-main/patches/dawn/aurora_fdm.inc: Dawn enables the extension only on request and for
  dynamic rendering, flags every render pipeline, and chains an immutable RG8 map into any pass
  whose first color attachment is a view bound to one (ABI: include/aurora/dawn_fdm_abi.h).
- android/Build-QuestDawn.ps1 builds the pinned Dawn revision with those patches for arm64
  (dawn-build CI flags, protobuf off) into a cached package; Build-Quest.ps1 links it
  (-StockDawn opts out) and AuroraDawnProvider.cmake enables the ABI from its manifest.
- lib/gfx/foveation.hpp generates the maps (32 px per texel, densities 255/127/63); an eye is
  foveated only when single_pass_eyes draws it in one render pass. Menus never are.
- Live level from the headset panel's VR tab and the launcher; the launch decides whether the
  device has maps. debug.wiicompiled.foveation and debug.wiicompiled.fdm for A/B.
- Tests: Foveation cases in gx_fifo_tests, mkw_vr_config_tests. Docs: OPENXR.md, quest-port.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

runtime/include/runtime_config.h

@@ -87,6 +87,7 @@ struct RuntimeUserConfig {
     std::optional<float> vrWheelTrackingGrace;
     std::optional<bool> vrWheelHaptics;
     std::optional<std::string> vrPerformanceLevel;
+    std::optional<std::string> vrFoveation;
     std::optional<std::string> vrRecenterKey;
     std::optional<float> vrLeanBackDegrees;
     // F10 > Diagnostics: OpenXR pacing and presentation logging in console.log.
@@ -247,6 +248,24 @@ inline bool IsSupportedVrPerformanceLevel(std::string_view value) {
     return value == "default" || value == "power_savings" || value == "sustained_low" ||
            value == "sustained_high" || value == "boost";
 }
+// Fixed foveated rendering of the immersive eyes on the Quest, in the order of
+// aurora_set_stereo_foveation's levels: the periphery is shaded in 2x2, then
+// 4x4 pixel blocks, the higher the level the closer to the centre. Whether the
+// GPU device gets fragment density maps at all is decided at launch, so going
+// from "off" to a level takes a restart; between levels and back to "off" it is
+// live.
+inline constexpr const char* kVrFoveationDefault = "off";
+inline constexpr std::array<std::string_view, 4> kVrFoveationLevels{"off", "low", "medium", "high"};
+
+inline bool IsSupportedVrFoveation(std::string_view value) {
+    return std::find(kVrFoveationLevels.begin(), kVrFoveationLevels.end(), value) != kVrFoveationLevels.end();
+}
+
+// The level aurora_set_stereo_foveation takes; anything unknown is off.
+inline uint32_t VrFoveationLevelIndex(std::string_view value) {
+    const auto it = std::find(kVrFoveationLevels.begin(), kVrFoveationLevels.end(), value);
+    return it == kVrFoveationLevels.end() ? 0u : static_cast<uint32_t>(it - kVrFoveationLevels.begin());
+}
 // What the desktop window shows while the headset is running: "normal" leaves
 // the ordinary desktop view alone, "both", "left" and "right" mirror the
 // headset's eyes, and "none" blacks the window out. Matches
@@ -801,6 +820,10 @@ inline RuntimeUserConfig ParseConfigDocument(const toml::value& document) {
         value && IsSupportedVrPerformanceLevel(*value)) {
         config.vrPerformanceLevel = *value;
     }
+    if (auto value = FindConfigValue<std::string>(document, "vr", "foveation");
+        value && IsSupportedVrFoveation(*value)) {
+        config.vrFoveation = *value;
+    }
     if (auto value = FindConfigValue<std::string>(document, "vr", "mirror_view");
         value && IsSupportedVrMirrorView(*value)) {
         config.vrMirrorView = *value;
@@ -1189,6 +1212,14 @@ inline bool SetVrPerformanceLevel(std::string value) {
     return WriteSetting("vr", "performance_level", FormatString(value));
 }
 
+inline bool SetVrFoveation(std::string value) {
+    if (!IsSupportedVrFoveation(value)) {
+        return false;
+    }
+    Mutable().vrFoveation = value;
+    return WriteSetting("vr", "foveation", FormatString(value));
+}
+
 inline bool SetVrFirstPersonSeat(std::string value) {
     if (!IsSupportedVrFirstPersonSeat(value)) {
         return false;
@@ -1641,6 +1672,11 @@ inline std::string VrPerformanceLevel(std::string fallback = kVrPerformanceLevel
     return value && IsSupportedVrPerformanceLevel(*value) ? *value : std::move(fallback);
 }
 
+inline std::string VrFoveation(std::string fallback = kVrFoveationDefault) {
+    const auto& value = Get().vrFoveation;
+    return value && IsSupportedVrFoveation(*value) ? *value : std::move(fallback);
+}
+
 inline int32_t VrFirstPersonHiddenModel(int32_t fallback = kVrFirstPersonHiddenModelDefault) {
     return std::clamp(Get().vrFirstPersonHiddenModel.value_or(fallback), -1, 31);
 }