Rye/testing

.github/workflows/build.yaml

@@ -169,11 +169,11 @@ jobs:
         include:
           # Linux on arm64: NEON is a first-class target, and this is the
           # one row where GCC compiles the SIMD layer for it.
-          - runner: ubuntu-24.04-arm
+          - runner: ubuntu-26.04-arm
             configuration: release
             arch: arm64
             build_variant: Viewer
-          - runner: ubuntu-24.04-arm
+          - runner: ubuntu-26.04-arm
             configuration: release
             arch: arm64
             build_variant: Tests
@@ -209,7 +209,7 @@ jobs:
       # Linux runner gets one from Mesa's llvmpipe through SDL's offscreen
       # driver; the Windows runner has no GPU driver, and macOS is unproven,
       # so they build those suites and register them disabled.
-      AL_ENABLE_GL_TESTS: ${{ runner.os == 'Linux' }}
+      AL_ENABLE_GL_TESTS: ${{ startsWith(matrix.runner, 'ubuntu-') }}
       LIBGL_ALWAYS_SOFTWARE: 1
       # Build Config
       BUILD_ARCH: ${{ matrix.arch }}
@@ -232,8 +232,8 @@ jobs:
       # vcpkg Setup
       VCPKG_ROOT: ${{ github.workspace }}/vcpkg
       VCPKG_USERNAME: ${{ github.repository_owner }}
-      VCPKG_FEED_URL: https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json
-      VCPKG_BINARY_SOURCES: "clear;nuget,https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json,readwrite"
+      # VCPKG_FEED_URL: https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json
+      VCPKG_BINARY_SOURCES: "clear;default,readwrite"
     steps:
       - name: Linux Dependency Install and Disk Cleanup
         if: runner.os == 'Linux'
@@ -303,33 +303,63 @@ jobs:
         run: |
           ./vcpkg/bootstrap-vcpkg.sh
 
-      - name: Set up vcpkg nuget caching
-        shell: bash
-        run: |
-          if [[ "$RUNNER_OS" == "Windows" ]]
-          then
-            $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
-              sources add \
-              -Source "${{ env.VCPKG_FEED_URL }}" \
-              -StorePasswordInClearText \
-              -Name GitHubPackages \
-              -UserName "${{ env.VCPKG_USERNAME }}" \
-              -Password "${{ secrets.GITHUB_TOKEN }}"
-            $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
-              setapikey "${{ secrets.GITHUB_TOKEN }}" \
-              -Source "${{ env.VCPKG_FEED_URL }}"
-          else
-            mono $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
-              sources add \
-              -Source "${{ env.VCPKG_FEED_URL }}" \
-              -StorePasswordInClearText \
-              -Name GitHubPackages \
-              -UserName "${{ env.VCPKG_USERNAME }}" \
-              -Password "${{ secrets.GITHUB_TOKEN }}"
-            mono $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
-              setapikey "${{ secrets.GITHUB_TOKEN }}" \
-              -Source "${{ env.VCPKG_FEED_URL }}"
-          fi
+      - name: Install AWS CLI on macOS
+        if: >-
+          vars.VCPKG_R2_ENABLED == 'true' && runner.os == 'macOS' &&
+          ((github.ref_protected && github.event_name != 'pull_request') ||
+           (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == github.repository))
+        run: brew install awscli
+
+      - name: Configure R2 binary cache for trusted builds
+        if: vars.VCPKG_R2_ENABLED == 'true' && github.ref_protected && github.event_name != 'pull_request'
+        env:
+          R2_CACHE_MODE: readwrite
+          R2_ENDPOINT_URL: ${{ vars.VCPKG_R2_ENDPOINT_URL }}
+          R2_BUCKET: ${{ vars.VCPKG_R2_BUCKET }}
+          R2_ACCESS_KEY_ID: ${{ secrets.VCPKG_R2_ACCESS_KEY_ID }}
+          R2_SECRET_ACCESS_KEY: ${{ secrets.VCPKG_R2_SECRET_ACCESS_KEY }}
+        run: python scripts/vcpkg/configure_r2_cache.py
+
+      - name: Configure R2 binary cache for same-repository PRs
+        if: >-
+          vars.VCPKG_R2_ENABLED == 'true' && github.event_name == 'pull_request' &&
+          github.event.pull_request.head.repo.full_name == github.repository
+        env:
+          # Temporary cache population test; restore read mode and reader secrets afterward.
+          R2_CACHE_MODE: readwrite
+          R2_ENDPOINT_URL: ${{ vars.VCPKG_R2_ENDPOINT_URL }}
+          R2_BUCKET: ${{ vars.VCPKG_R2_BUCKET }}
+          R2_ACCESS_KEY_ID: ${{ secrets.VCPKG_R2_ACCESS_KEY_ID }}
+          R2_SECRET_ACCESS_KEY: ${{ secrets.VCPKG_R2_SECRET_ACCESS_KEY }}
+        run: python scripts/vcpkg/configure_r2_cache.py
+
+      # - name: Set up vcpkg nuget caching
+      #   shell: bash
+      #   run: |
+      #     if [[ "$RUNNER_OS" == "Windows" ]]
+      #     then
+      #       $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
+      #         sources add \
+      #         -Source "${{ env.VCPKG_FEED_URL }}" \
+      #         -StorePasswordInClearText \
+      #         -Name GitHubPackages \
+      #         -UserName "${{ env.VCPKG_USERNAME }}" \
+      #         -Password "${{ secrets.GITHUB_TOKEN }}"
+      #       $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
+      #         setapikey "${{ secrets.GITHUB_TOKEN }}" \
+      #         -Source "${{ env.VCPKG_FEED_URL }}"
+      #     else
+      #       mono $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
+      #         sources add \
+      #         -Source "${{ env.VCPKG_FEED_URL }}" \
+      #         -StorePasswordInClearText \
+      #         -Name GitHubPackages \
+      #         -UserName "${{ env.VCPKG_USERNAME }}" \
+      #         -Password "${{ secrets.GITHUB_TOKEN }}"
+      #       mono $(${VCPKG_ROOT}/vcpkg fetch nuget | tail -n 1) \
+      #         setapikey "${{ secrets.GITHUB_TOKEN }}" \
+      #         -Source "${{ env.VCPKG_FEED_URL }}"
+      #     fi
 
       - name: Cache Rust Dependencies
         uses: actions/cache@v6
@@ -361,17 +391,17 @@ jobs:
           SIGNING=()
           case "$RUNNER_OS" in
             Windows)
-              cmake_preset_name="vs2026$cmake_preset_postfix"
+              cmake_preset_name="vs2026${cmake_preset_postfix}-fullopt"
               build_directory="build-Windows-$cmake_preset_name"
               vcpkg_triplet="x64-windows-alchemy-avx2-release"
               ;;
             macOS)
-              cmake_preset_name="ninja$cmake_preset_postfix-$BUILD_ARCH"
+              cmake_preset_name="ninja${cmake_preset_postfix}-fullopt-$BUILD_ARCH"
               build_directory="build-Darwin-$cmake_preset_name"
               vcpkg_triplet="$BUILD_ARCH-osx-alchemy-release"
               ;;
             Linux)
-              cmake_preset_name="ninja$cmake_preset_postfix"
+              cmake_preset_name="ninja${cmake_preset_postfix}-fullopt"
               build_directory="build-Linux-$cmake_preset_name"
               if [[ "$BUILD_ARCH" == "arm64" ]]
               then

doc/ARCHITECTURE.md

@@ -88,8 +88,10 @@ The deferred rendering pipeline is orchestrated by `LLPipeline` (`indra/newview/
 2. **Shadows** (`renderGeomShadow()`) — 4 sun shadow cascades + 2 spot light shadow maps
 3. **Deferred Lighting** (`renderDeferredLighting()`) — Sun, point lights (up to 16 batched), spot lights, with reflection probe influence
 4. **Post-Deferred** (`renderGeomPostDeferred()`) — Alpha, water, atmospheric haze
-5. **Post-Processing** — Luminance/exposure, bloom, DoF, tonemapping, color grading, AA, screen effects
-6. **Finalize** (`renderFinalize()`) — Final blit with vignette, film grain, dithering, chromatic aberration
+5. **Post-Processing** — Luminance/exposure, depth of field, bloom, then one pass doing tonemapping, color grading and the bloom composite together, then AA and CAS
+6. **Finalize** (`renderFinalize()`) — Final blit with lens distortion, vignette, film grain, dithering, CVD compensation
+
+Depth of field runs **before** bloom and before the tonemapper, on linear HDR. Gathering over display-space values gathers over already-compressed highlights, and bloom-after-defocus is the optical order, so a defocused highlight blooms as a soft disc rather than a sharp core on a blurred background.
 
 **GBuffer layout** (MRT attachments on `deferredScreen`):
 - frag_data[0]: Base color (GL_RGBA)
@@ -101,18 +103,23 @@ The deferred rendering pipeline is orchestrated by `LLPipeline` (`indra/newview/
 - `mMainRT` — Full resolution for main scene
 - `mAuxillaryRT` — 512×512 for reflection probes and dynamic texture bakes
 - `mHeroProbeRT` — High-res hero probe rendering
-- Additional targets: `mSceneMap` (SSR input), `mLuminanceMap`/`mExposureMap` (auto-exposure), `mPostPingMap`/`mPostPongMap` (post-process ping-pong), `mFXAAMap`, `mSMAABlendBuffer`, `mGlow[3]` (bloom pyramid), `mWaterDis` (refraction), `mSpotShadow[2]`, `mPbrBrdfLut`
+- Additional targets: `mSceneMap` (SSR input), `mLuminanceMap`/`mExposureMap` (auto-exposure), `postPingMap`/`postPongMap` (post-process ping-pong), `mFXAAMap`, `mSMAABlendBuffer`, `bloomMip[BLOOM_MAX_MIPS]` (HDR bloom pyramid, up to 7 levels, live count in `bloomMipCount`), `mWaterDis` (refraction; also lends its quadrants to the cross-screen filter's two scratch buffers and accumulator, and its whole to depth of field's sharp copy, while it is idle after the water pass — `crossFilterReady`/`crossFilterWidth`/`crossFilterHeight` tell `colorCorrect` where the accumulator is), `mSpotShadow[2]`, `mPbrBrdfLut`
+- `mGlow[3]` is the **legacy non-HDR glow chain**, not the bloom pyramid, and lives outside the pack. So does `mLensDirtMap`, the generated lens dirt plate — an `LLRenderTarget` allocated the first frame the effect is enabled and released when it is switched off.
 
 **Post-processing chain:**
 - **Auto-exposure:** Progressive histogram (`gLuminanceProgram`, `gExposureProgram`) with history fade
-- **Bloom:** Bright-area extraction → 3-level glow pyramid (`mGlow[3]`) with warmth correction
-- **Depth of Field:** Circle-of-confusion via `gDeferredCoFProgram`, combine via `gDeferredDoFCombineProgram`. Settings: `CameraFNumber`, `CameraFocalLength`, `CameraMaxCoF`
+- **Lens flare sun state:** a 2x1 temporal pass (`gLensFlareStateProgram`, `lensFlareStateF.glsl`) run just before colour correction measures how much of the sun disc is unoccluded and its colour, and filters both under a rate limit; `computeLensFlare` in `postEffectUtilsF.glsl` reads one texel of it. The shader is the source of truth for the filter; `scripts/content_tools/check_lens_flare_state.py` mirrors it and is its regression test
+- **Bloom:** Bright-area extraction → downsample/upsample pyramid over `bloomMip[]` with warmth correction and optional halation carried in alpha. The additive composite is **not** a pass of its own: it is folded into `colorCorrect`'s `BLOOM_COMPOSITE` permutation. `compositeBloomHDR` is a standalone equivalent that nothing currently calls
+- **Cross-screen (star) filter:** `gCrossFilterProgram` streaks every thresholded highlight, seeded from `bloomMip[0]` and accumulated through three quadrants of `mWaterDis`, which the two shaders address through `uCrossRegion`/`uCrossClamp` so a tap at the quadrant's edge clamps exactly as it did at a dedicated target's edge. One strictly one-sided three-pass chain per arm, at strides that tile the reachable offsets exactly once — the tiling is load-bearing and the shader explains why. Composited in `colorCorrect` alongside the pyramid, so it inherits bloom strength
+- **Lens dirt:** `gLensDirtGenProgram` draws the grime plate into `mLensDirtMap` — dust motes, wipe smudges, stray fibres, fine grit and optional scratches, built from hashes and distance fields rather than loaded from an image. Not a per-frame pass: it runs when a generation parameter moves or the window resizes, guarded by the cached parameter set in `mLensDirtParams`, which is also what makes a failed allocation stop retrying. Generated at the frame's own resolution, so nothing has to fit a square plate to a wide window. A rebuild is held off while `mLensDirtSliderHeld` is raised — the Lightbox raises it on a generation slider's mouse-down and lowers it on mouse-up, so a drag costs one plate on release rather than one per frame. Everything that is not a drag (typed values, resets, applying a Look, undo, window resizes) rebuilds immediately, which is what a settle timer would have delayed for no reason. `colorCorrect` multiplies the accumulated bloom and flare terms by it
+- **Depth of Field:** three passes — circle of confusion (`gDeferredCoFProgram`, writing sharp linear colour plus signed CoF in alpha), a gather blur at `CameraDoFResScale`, and a combine (`gDeferredDoFCombineProgram`) back over `mRT->screen` under `setColorMask(true, false)` so the legacy prim-glow alpha tag survives. It owns no targets: the sharp copy borrows `mWaterDis`, which the water passes refill each frame and have finished with, and the blur borrows `bloomMip[0]` between the luminance read and the extract pass (`postPongMap` without HDR). The blur viewport is clamped to what mip 0 can hold when `RenderBloomResolutionScale` shrinks it, and the combine is told the fraction it actually covers via `res_scale` and where it sits via `dof_uv_scale`. The gather has four compile-time variants over two axes, `FRONT_BLUR` × `DOF_SHAPED`: `gDeferredPostProgram`, `gDeferredPostProgramNoNear`, `gDeferredPostProgramShaped`, `gDeferredPostProgramNoNearShaped`. Optics: `CameraFNumber`, `CameraFocalLength`, `CameraFieldOfView`, `CameraMaxCoF`, `CameraDoFResScale`
+- **Bokeh shaping** (inside the `DOF_SHAPED` gather): polygonal aperture (`RenderBokehApertureBlades`, `Rotation`, `Curvature`), anamorphic squeeze, cat's-eye optical vignetting, defocus fringing, and the lens aberrations — spherical (`RenderBokehSphericalAberration`), field stretch for swirl and coma (`RenderBokehFieldStretch`, `FieldFalloff`) and comatic asymmetry. The CPU picks a shaped variant only when one of them is actually doing something
 - **Screen Space Reflections:** Class 3+ feature, iterative ray marching
 - **Tonemapping:** ACES, Reinhard, Filmic, AGX — selectable via `AlchemyRenderTonemapType`
-- **Color Grading:** 3D LUT-based (`gDeferredPostGammaCorrectCGLutProgram`, `mCGLut`)
+- **Color Grading:** 3D LUT-based (`gDeferredPostGammaCorrectCGLutProgram`, `mCGLut`), plus a CPU-baked 1D tone curve LUT (`mToneCurveLut`, baked from `ALToneCurveSet` on a dirty flag) and precomputed split-tone ramps; the helpers live in `colorGradeUtilF.glsl` under `shaders/class1/alchemy/`
 - **Anti-aliasing:** FXAA (1-pass, `gFXAAProgram[4]`) or SMAA (3-pass edge detect → blend weights → neighborhood blend, `gSMAAEdgeDetectProgram[4]`/`gSMAABlendWeightsProgram[4]`/`gSMAANeighborhoodBlendProgram[4]`). CAS (Contrast Adaptive Sharpening) via `gCASProgram`
-- **Final blit effects** (`blitWithEffectsF.glsl` in `shaders/class1/alchemy/`): Vignette (configurable shape/softness/color), film grain (luma/color/coarse/photon styles), TPDF dithering, CVD compensation/preview
-- **Chromatic aberration** (`colorCorrectF.glsl` in `shaders/class1/alchemy/`): Per-channel offset with amount, falloff, angle, anisotropy controls
+- **Final blit effects** (`blitWithEffectsF.glsl` in `shaders/class1/alchemy/`): geometric lens distortion (Brown-Conrady radial `k1`/`k2` and tangential `p1`/`p2`, anamorphic squeeze, decentring, with the auto-fit rescale solved on the CPU and out-of-frame samples masked to black), vignette (configurable shape/softness/color), film grain (luma/color/coarse/photon styles), TPDF dithering, CVD compensation/preview. Distortion warps the world view only — overlays drawn after the blit do not follow it
+- **Effects inside `colorCorrectF.glsl`** (`shaders/class1/alchemy/`), which runs in every variant including the no-post ones and so gates them itself: chromatic aberration (per-channel offset with amount, falloff, angle, anisotropy), the five-component lens flare, the bloom and cross-filter composite, and lens dirt — the generated grime plate above, multiplied by the accumulated flare and bloom terms, so it only lights up where something already is
 
 Post-processing settings are exposed in the Lightbox floater (`ALFloaterLightBox`); see `doc/LIGHTBOX.md` for how to add UI sections for new effects.
 
@@ -126,9 +133,9 @@ GLSL shaders live in `indra/newview/app_settings/shaders/` organized by quality
 - **`class1/`** — Base shaders (all hardware)
 - **`class2/`** — Mid-tier features
 - **`class3/`** — Advanced features (SSR, high-quality lighting)
-- Categories: `deferred/`, `objects/`, `environment/`, `alchemy/` (Alchemy post-processing), `windlight/`, `avatar/`, `interface/`
+- Categories: `deferred/`, `objects/`, `environment/`, `alchemy/` (Alchemy post-processing), `effects/` (glow, the bloom pyramid, the cross-screen filter), `windlight/`, `avatar/`, `interface/`
 
-Key shader groups: GBuffer write (`gDeferredDiffuseProgram`, `gDeferredPBROpaqueProgram`, `gDeferredBumpProgram`, `gDeferredMaterialProgram[]`, etc.), deferred lighting (`gDeferredSunProgram`, `gDeferredLightProgram`, `gDeferredMultiLightProgram[16]`, `gDeferredSpotLightProgram`), shadows (`gDeferredShadowProgram` and variants), environment (`gDeferredWLSkyProgram`, `gWaterProgram`, `gHazeProgram`), post-processing (tonemap, FXAA, SMAA, CAS, bloom, DoF programs).
+Key shader groups: GBuffer write (`gDeferredDiffuseProgram`, `gDeferredPBROpaqueProgram`, `gDeferredBumpProgram`, `gDeferredMaterialProgram[]`, etc.), deferred lighting (`gDeferredSunProgram`, `gDeferredLightProgram`, `gDeferredMultiLightProgram[16]`, `gDeferredSpotLightProgram`), shadows (`gDeferredShadowProgram` and variants), environment (`gDeferredWLSkyProgram`, `gWaterProgram`, `gHazeProgram`), post-processing (tonemap, FXAA, SMAA, CAS, the bloom pyramid programs, `gCrossFilterProgram`, and the four-variant DoF gather set).
 
 ### Draw Pool & Spatial System
 

doc/BUILD.md

@@ -218,6 +218,10 @@ This creates a build tree at `build-<HostSystem>-<preset>/` next to the source 
 
 The first configure run downloads and builds every vcpkg dependency from source. Expect **30–60+ minutes** and several GB of disk; subsequent configures finish in seconds.
 
+An optional [R2 binary cache](VCPKG-R2.md) can restore matching dependencies.
+The setup guide covers pipeline environment variables, read-only developer
+access, retention, and rollout checks.
+
 #### Platform notes
 
 - **macOS** — `xcode-os` and `ninja-os` (no arch suffix) pick the host architecture. Use the explicit `-arm64` / `-x64` preset to cross-build (e.g. an arm64 bundle from an Intel Mac).