diff --git a/Assets/Scripts/HsvColorPicker.cs b/Assets/Scripts/HsvColorPicker.cs
index 9d67ef5..8bd68ff 100644
--- a/Assets/Scripts/HsvColorPicker.cs
+++ b/Assets/Scripts/HsvColorPicker.cs
@@ -3,35 +3,33 @@ using UnityEngine;
 using UnityEngine.UI;
 
 /// <summary>
-/// Compact runtime HSV colour picker: a saturation/value square, a hue bar, an alpha bar and a
-/// live swatch. The square is a pure-hue base with two static gradient overlays on top (white-out
-/// -> saturation, black-out -> value), so only the base tint changes per hue - no per-frame
-/// texture rebuilds. Hue is never lost while dragging the square (the square only edits S/V,
-/// the bar only edits H, the alpha bar only edits A).
+/// Compact runtime HSV colour picker: a saturation/value square, a hue bar and a live swatch. The
+/// square is a pure-hue base with two static gradient overlays on top (white-out -> saturation,
+/// black-out -> value), so only the base tint changes per hue - no per-frame texture rebuilds. Hue is
+/// never lost while dragging the square (the square only edits S/V, the bar only edits H). Alpha is
+/// edited separately by a standalone slider in the HUD, not by this picker; <see cref="SetColor"/>
+/// still stores the incoming alpha so <see cref="Value"/> round-trips it.
 ///
 /// <see cref="Build"/> creates the child structure (stable names, no sprites or hooks); it can
 /// be baked into a prefab. <see cref="Rebind"/> then (re)assigns the runtime gradient sprites
 /// (which a prefab cannot store) and (re)hooks the drag relays - it runs for both the code-built
-/// picker and one instantiated from a prefab, so the two are behaviourally identical. For a prefab
-/// baked before the alpha bar existed it also builds that bar on the fly (and grows the picker's
-/// reserved layout height), so no re-bake is required.
+/// picker and one instantiated from a prefab, so the two are behaviourally identical. A leftover
+/// alpha bar from a pre-split prefab is hidden by <see cref="Rebind"/>, so no re-bake is required.
 /// </summary>
 public class HsvColorPicker : MonoBehaviour
 {
-    /// <summary>Raised with the new colour when the user moves the square, hue bar or alpha bar.</summary>
+    /// <summary>Raised with the new colour (RGB; alpha is preserved, not edited here) when the user moves
+    /// the square or hue bar.</summary>
     public event Action<Color> Changed;
 
     private float _h, _s, _v, _a = 1f;
 
-    // Gap between the stacked square / hue / alpha rows (matches the layout in Build).
+    // Gap between the stacked square / hue rows (matches the layout in Build).
     private const float RowGap = 6f;
-    private static readonly Color AlphaBackdrop = new Color(0.5f, 0.5f, 0.5f, 1f);
 
     private Image _hueBase;          // pure-hue background of the SV square
     private RectTransform _svHandle;
     private RectTransform _hueHandle;
-    private Image _alphaGrad;        // colour-tinted transparency ramp of the alpha bar
-    private RectTransform _alphaHandle;
     private Image _swatch;
 
     /// <summary>Current colour (HSV -> RGB, with the preserved alpha).</summary>
@@ -54,7 +52,7 @@ public class HsvColorPicker : MonoBehaviour
     }
 
     /// <summary>
-    /// Builds the picker structure (square + hue bar + alpha bar + swatch) under this object,
+    /// Builds the picker structure (square + hue bar + swatch) under this object,
     /// top-left aligned. Layout only - no gradient sprites and no event hooks, so the result is
     /// safe to bake into a prefab. Call <see cref="Rebind"/> afterwards (at runtime) to make it
     /// functional.
@@ -87,41 +85,12 @@ public class HsvColorPicker : MonoBehaviour
         hueHandle.sizeDelta = new Vector2(4f, hueHeight + 4f);
         PaintHud.AddImage(hueHandle.gameObject, Color.white).raycastTarget = false;
 
-        // Alpha bar below the hue bar.
-        BuildAlphaBar(sv, hue);
-
         // Swatch, to the right of the square.
         var sw = PaintHud.NewRect("Swatch", transform);
         TopLeft(sw, new Vector2(squareSize + 10f, 0f), new Vector2(34f, 34f));
         PaintHud.AddImage(sw.gameObject, Color.white).raycastTarget = false;
     }
 
-    /// <summary>
-    /// Builds the alpha bar (grey backdrop + colour-tinted transparency ramp + drag relay + handle)
-    /// directly below the hue bar, sized/positioned from the existing SV square and hue bar so it
-    /// works for both a fresh build and an older baked prefab. Sprites/hooks are applied by
-    /// <see cref="Rebind"/>.
-    /// </summary>
-    private RectTransform BuildAlphaBar(RectTransform sv, RectTransform hue)
-    {
-        float width = sv.sizeDelta.x;
-        float barHeight = hue.sizeDelta.y;
-        float y = hue.anchoredPosition.y - (barHeight + RowGap);
-
-        var alpha = PaintHud.NewRect("Alpha", transform);
-        TopLeft(alpha, new Vector2(0f, y), new Vector2(width, barHeight));
-        PaintHud.AddImage(alpha.gameObject, AlphaBackdrop); // raycast target for the drag relay
-
-        PaintHud.AddOverlay(alpha, "AlphaGrad"); // tinted alpha ramp, sprite assigned in Rebind
-
-        alpha.gameObject.AddComponent<UiPointerSurface>();
-
-        var handle = PaintHud.NewRect("Handle", alpha);
-        handle.sizeDelta = new Vector2(4f, barHeight + 4f);
-        PaintHud.AddImage(handle.gameObject, Color.white).raycastTarget = false;
-        return alpha;
-    }
-
     /// <summary>
     /// Re-finds the child widgets, (re)assigns the runtime gradient sprites and (re)hooks the drag
     /// relays. Idempotent (unsubscribe-then-subscribe), so it is safe whether the structure was just
@@ -161,32 +130,10 @@ public class HsvColorPicker : MonoBehaviour
             }
         }
 
-        // Alpha bar: build it if the (older) prefab lacks it, then (re)assign sprite + relay.
-        var alpha = transform.Find("Alpha") as RectTransform;
-        bool builtAlpha = false;
-        if (!alpha && sv is RectTransform svRect && hue)
-        {
-            alpha = BuildAlphaBar(svRect, hue);
-            builtAlpha = true;
-        }
-        if (alpha)
-        {
-            var grad = alpha.Find("AlphaGrad");
-            if (grad && grad.TryGetComponent(out Image gradImg))
-            {
-                gradImg.sprite = PaintHud.AlphaSprite();
-                _alphaGrad = gradImg;
-            }
-            _alphaHandle = alpha.Find("Handle") as RectTransform;
-
-            if (alpha.TryGetComponent(out UiPointerSurface alphaPointer))
-            {
-                alphaPointer.Picked -= OnAlphaPicked;
-                alphaPointer.Picked += OnAlphaPicked;
-            }
-
-            if (builtAlpha) GrowReservedHeight(alpha.sizeDelta.y + RowGap);
-        }
+        // Alpha now lives on a standalone slider (PaintHud), not in the picker. Hide any alpha bar a
+        // pre-split prefab still carries so it does not show as a dead, non-functional strip.
+        var leftoverAlpha = transform.Find("Alpha");
+        if (leftoverAlpha) leftoverAlpha.gameObject.SetActive(false);
 
         var swatch = transform.Find("Swatch");
         if (swatch) _swatch = swatch.GetComponent<Image>();
@@ -194,15 +141,6 @@ public class HsvColorPicker : MonoBehaviour
         Refresh();
     }
 
-    /// <summary>Grows this picker's LayoutElement so a runtime-added alpha bar does not overlap the
-    /// widget below it; the panel's ContentSizeFitter then expands to match. No-op without a LayoutElement.</summary>
-    private void GrowReservedHeight(float extra)
-    {
-        if (!TryGetComponent(out LayoutElement le)) return;
-        if (le.minHeight > 0f) le.minHeight += extra;
-        if (le.preferredHeight > 0f) le.preferredHeight += extra;
-    }
-
     private void OnSvPicked(Vector2 p)
     {
         _s = p.x;
@@ -218,13 +156,6 @@ public class HsvColorPicker : MonoBehaviour
         Changed?.Invoke(Value);
     }
 
-    private void OnAlphaPicked(Vector2 p)
-    {
-        _a = p.x;
-        Refresh();
-        Changed?.Invoke(Value);
-    }
-
     private void Refresh()
     {
         if (_hueBase) _hueBase.color = Color.HSVToRGB(_h, 1f, 1f);
@@ -238,12 +169,6 @@ public class HsvColorPicker : MonoBehaviour
             _hueHandle.anchorMin = _hueHandle.anchorMax = new Vector2(_h, 0.5f);
             _hueHandle.anchoredPosition = Vector2.zero;
         }
-        if (_alphaGrad) _alphaGrad.color = Color.HSVToRGB(_h, _s, _v); // tint the transparency ramp to the current colour
-        if (_alphaHandle)
-        {
-            _alphaHandle.anchorMin = _alphaHandle.anchorMax = new Vector2(_a, 0.5f);
-            _alphaHandle.anchoredPosition = Vector2.zero;
-        }
         if (_swatch) _swatch.color = Color.HSVToRGB(_h, _s, _v);
     }
 
diff --git a/Assets/Scripts/MeshPainter.Persistence.cs b/Assets/Scripts/MeshPainter.Persistence.cs
index 10dde16..0701d45 100644
--- a/Assets/Scripts/MeshPainter.Persistence.cs
+++ b/Assets/Scripts/MeshPainter.Persistence.cs
@@ -16,9 +16,21 @@ public partial class MeshPainter
     // map's canonical Color32 bytes. Raw (not PNG) avoids any sRGB/alpha-premultiply ambiguity and
     // round-trips the exact canonical bytes ReadCanonical produces.
     private const uint PaintFileMagic = 0x504D4843; // 'CHMP' little-endian
-    private const int PaintFileVersion = 2;         // v2: added the display-name header
+    private const int PaintFileVersion = 3;         // v3: added the per-player material scalars (emission + camo)
     private const string PaintFileExt = ".paint";
 
+    /// <summary>
+    /// Per-player material scalars stored alongside the maps from v3 on. These are NOT baked into the
+    /// painted pixels (a global emission multiplier + the PlayerCamoLit knobs), so they ride the slot
+    /// header and are re-applied onto the painter when the slot loads.
+    /// </summary>
+    private struct PaintScalars
+    {
+        public bool has; // false = legacy v2 slot with no scalars -> leave the painter's values untouched
+        public float emissionIntensity;
+        public float camoHalfLambert, camoHalfLambertBrightness, camoSpecularDampen;
+    }
+
     private static string PaintLibraryDir =>
         Path.Combine(Application.persistentDataPath, "MeshPaint", "Saved");
 
@@ -83,6 +95,14 @@ public partial class MeshPainter
                 w.Write(textureSize);
                 w.Write(MAP_COUNT);
 
+                // v3: per-player material scalars that are NOT baked into the maps (a global emission
+                // multiplier + the PlayerCamoLit knobs). The painter is ready here (_setupValid), so the
+                // material-backed camo getters return the live values rather than the not-ready 0.
+                w.Write(emissionIntensity);
+                w.Write(CamoHalfLambert);
+                w.Write(CamoHalfLambertBrightness);
+                w.Write(CamoSpecularDampen);
+
                 var bytes = new byte[n * 4];
                 for (int mi = 0; mi < MAP_COUNT; mi++)
                 {
@@ -116,7 +136,7 @@ public partial class MeshPainter
     {
         if (!_setupValid) return false;
 
-        Color32[][] canonical = ReadMaps(PathForName(name));
+        Color32[][] canonical = ReadMaps(PathForName(name), out PaintScalars scalars);
         if (canonical == null) return false;
 
         // Re-seed exactly like SwitchBackend / ApplyPaintSnapshot, so the island/dilation seeding path
@@ -126,6 +146,19 @@ public partial class MeshPainter
         // A load replaces the whole painting and is NOT undoable: the loaded maps become the new history
         // baseline, clearing any prior undo/redo. Peers reset to the same baseline via the load broadcast.
         ResetHistoryToCurrent(canonical);
+
+        // v3 slots also carry the per-player material scalars; apply them so the loaded look is complete.
+        // Legacy v2 slots have none -> leave the current emission/camo untouched. The painter is ready here
+        // (_setupValid), so the material-backed camo setters take effect; PlayerPaintSync replicates the
+        // changed values to peers via their owner-authoritative NetworkVariables on its next LateUpdate.
+        if (scalars.has)
+        {
+            emissionIntensity = scalars.emissionIntensity;
+            RefreshEmissionColor();
+            CamoHalfLambert = scalars.camoHalfLambert;
+            CamoHalfLambertBrightness = scalars.camoHalfLambertBrightness;
+            CamoSpecularDampen = scalars.camoSpecularDampen;
+        }
         return true;
     }
 
@@ -155,7 +188,8 @@ public partial class MeshPainter
             using (var r = new BinaryReader(fs, Encoding.UTF8))
             {
                 if (r.ReadUInt32() != PaintFileMagic) return null;
-                if (r.ReadInt32() != PaintFileVersion) return null;
+                int ver = r.ReadInt32();
+                if (ver != 2 && ver != PaintFileVersion) return null; // list legacy v2 slots + current
                 return r.ReadString();
             }
         }
@@ -169,8 +203,9 @@ public partial class MeshPainter
     /// Reads all maps from a slot file in canonical layout, or null if missing / incompatible. Per-map
     /// null entries are tolerated by both backends (they fall back to the material seed).
     /// </summary>
-    private Color32[][] ReadMaps(string path)
+    private Color32[][] ReadMaps(string path, out PaintScalars scalars)
     {
+        scalars = default;
         if (!File.Exists(path)) return null;
 
         try
@@ -180,12 +215,22 @@ public partial class MeshPainter
             {
                 if (r.ReadUInt32() != PaintFileMagic) return null;
                 int ver = r.ReadInt32();
-                if (ver != PaintFileVersion) return null;
+                if (ver != 2 && ver != PaintFileVersion) return null; // read legacy v2 + current
                 r.ReadString(); // display name (header only; not needed for the pixel load)
                 int w = r.ReadInt32();
                 int h = r.ReadInt32();
                 int maps = r.ReadInt32();
 
+                // v3+: the per-player material scalars sit between the header and the pixel maps.
+                if (ver >= 3)
+                {
+                    scalars.has = true;
+                    scalars.emissionIntensity = r.ReadSingle();
+                    scalars.camoHalfLambert = r.ReadSingle();
+                    scalars.camoHalfLambertBrightness = r.ReadSingle();
+                    scalars.camoSpecularDampen = r.ReadSingle();
+                }
+
                 // Resolution change -> ignore rather than smear mismatched data; the brush re-seeds
                 // from the material instead.
                 if (w != textureSize || h != textureSize)
diff --git a/Assets/Scripts/PaintHud.Library.cs b/Assets/Scripts/PaintHud.Library.cs
index a375507..fb52090 100644
--- a/Assets/Scripts/PaintHud.Library.cs
+++ b/Assets/Scripts/PaintHud.Library.cs
@@ -21,6 +21,7 @@ public partial class PaintHud
     private const string LibSaveButton = "Lib_Save";
     private const string LibLoadButton = "Lib_Load";
     private const string LibDeleteButton = "Lib_Delete";
+    private const string LibResetButton = "Lib_ResetHud";
     private const string LibSaveDialog = "Lib_SaveDialog";
     private const string LibNameInput = "Lib_NameInput";
     private const string LibSaveInfo = "Lib_SaveInfo";
@@ -34,7 +35,7 @@ public partial class PaintHud
     private bool _libraryBound;
     private RectTransform _listContent;
     private GameObject _entryTemplate;
-    private Button _saveButton, _loadButton, _deleteButton;
+    private Button _saveButton, _loadButton, _deleteButton, _resetButton;
     private string _selectedPainting;
 
     // Save dialog
@@ -76,9 +77,11 @@ public partial class PaintHud
         _saveButton = Find<Button>(root, LibSaveButton);
         _loadButton = Find<Button>(root, LibLoadButton);
         _deleteButton = Find<Button>(root, LibDeleteButton);
+        _resetButton = Find<Button>(root, LibResetButton); // optional: present only if authored in the layout
         Hook(_saveButton, OnSaveClicked);
         Hook(_loadButton, OnLoadClicked);
         Hook(_deleteButton, OnDeleteClicked);
+        Hook(_resetButton, OnResetClicked);
 
         var sd = FindDeep(root, LibSaveDialog);
         _saveDialog = sd ? sd.gameObject : null;
@@ -233,11 +236,27 @@ public partial class PaintHud
         ShowConfirm($"Delete \"{name}\"?", OkDanger, () => DoDelete(name));
     }
 
+    /// <summary>Reset the panels + brush values to their authored defaults (confirmed; the dialog reuses the
+    /// library's confirm path). Falls back to an immediate reset if no confirm dialog is authored.</summary>
+    private void OnResetClicked()
+    {
+        if (_confirmDialog)
+            ShowConfirm("Reset the HUD panels and brush values to their defaults?", OkDanger, ResetHudToDefaults);
+        else
+            ResetHudToDefaults();
+    }
+
     private void DoLoad(string name)
     {
         if (!painter || !painter.LoadPaintByName(name)) return;
 
-        // Re-sync the loaded baseline to every other peer (no-op offline / single-player).
+        // The load also restored the slot's emission intensity + camo knobs onto the painter (v3 slots) ->
+        // push them into the sliders so the HUD reflects the loaded look, exactly like a pipette pick does.
+        SyncFromPainter();
+        SyncCamoSliders();
+
+        // Re-sync the loaded baseline to every other peer (no-op offline / single-player). The restored
+        // emission/camo replicate on their own via PlayerPaintSync's owner-authoritative NetworkVariables.
         var sync = painter.GetComponentInParent<PlayerPaintSync>();
         if (sync) sync.BroadcastLoadedPaint();
     }
diff --git a/Assets/Scripts/PaintHud.Persistence.cs b/Assets/Scripts/PaintHud.Persistence.cs
index c3b582b..e06fa99 100644
--- a/Assets/Scripts/PaintHud.Persistence.cs
+++ b/Assets/Scripts/PaintHud.Persistence.cs
@@ -60,6 +60,16 @@ public partial class PaintHud
     private bool _hasPendingCamo;
     private bool _camoEverReady;
 
+    // Authored defaults for the runtime reset (= "as if the saved layout file had been deleted"): the
+    // prefab's panel positions, captured before any saved layout is restored over them, and the painter's
+    // prefab/material default brush values, captured before carry/restore mutate the live painter. Camo is
+    // material-backed (readable only once IsReady), so it is filled in the LateUpdate ready-gate instead.
+    private readonly Dictionary<string, Vector2> _authoredPanelPos = new Dictionary<string, Vector2>();
+    private bool _hasAuthoredLayout;
+    private readonly HudValues _defaults = new HudValues();
+    private bool _hasDefaults;    // non-camo defaults captured (first bind, before restore/carry)
+    private bool _hasDefaultCamo; // camo defaults captured (first ready-gate, before any pending camo apply)
+
     private static string HudSaveDir => Path.Combine(Application.persistentDataPath, "MeshPaint");
 
     private string HudSavePath()
@@ -211,6 +221,17 @@ public partial class PaintHud
             // save file) the material keeps its authored camo and the sliders just reflect it.
             if (!_camoSynced && painter.IsReady)
             {
+                // Capture the material's authored camo as the reset default BEFORE any pending (restored or
+                // carried) camo is applied over it. Once per HUD: a later session/respawn keeps the very
+                // first authored value, so a reset always returns to the genuine material default.
+                if (!_hasDefaultCamo)
+                {
+                    _defaults.camoHalfLambert = painter.CamoHalfLambert;
+                    _defaults.camoHalfLambertBrightness = painter.CamoHalfLambertBrightness;
+                    _defaults.camoSpecularDampen = painter.CamoSpecularDampen;
+                    _hasDefaultCamo = true;
+                }
+
                 if (_hasPendingCamo)
                 {
                     painter.CamoHalfLambert = _pendingCamo.x;
@@ -402,6 +423,80 @@ public partial class PaintHud
         }
     }
 
+    // --- Reset to authored defaults (drives the HUD's reset button) ---
+
+    /// <summary>
+    /// Snapshots the authored panel positions from the freshly instantiated layout, before any saved
+    /// layout is restored over them. The runtime reset restores exactly these. Called once from Start
+    /// (right after the layout prefab is instantiated); idempotent.
+    /// </summary>
+    public void CaptureAuthoredLayout()
+    {
+        if (_hasAuthoredLayout || !_panel) return;
+        var root = _panel.transform;
+        foreach (var name in DraggablePanels)
+            if (FindDeep(root, name) is RectTransform rt)
+                _authoredPanelPos[name] = rt.anchoredPosition;
+        _hasAuthoredLayout = true;
+    }
+
+    /// <summary>
+    /// Snapshots the painter's prefab-default brush values on the first bind, before carry/restore mutate
+    /// the live painter. Non-camo only here (a freshly spawned painter holds its prefab defaults); the
+    /// material-backed camo is not readable yet and is captured later in the LateUpdate ready-gate.
+    /// </summary>
+    private void CaptureDefaults()
+    {
+        if (_hasDefaults || !painter) return;
+        CopyValues(painter, _defaults); // CopyValues skips camo until IsReady -> camo stays for the ready-gate
+        _hasDefaults = true;
+    }
+
+    /// <summary>
+    /// Resets the HUD to its authored defaults, exactly as if the saved layout file had been deleted: the
+    /// panels jump back to their prefab positions and every brush value returns to the painter's prefab /
+    /// material defaults. The save file is deleted too, so the reset also survives the next start.
+    /// </summary>
+    [ContextMenu("Reset HUD Layout And Values")]
+    public void ResetHudToDefaults()
+    {
+        // Delete the saved layout so a restart opens at the authored defaults as well (the literal intent).
+        ClearSavedHudState();
+
+        // Panels -> authored prefab positions.
+        if (_panel && _hasAuthoredLayout)
+        {
+            var root = _panel.transform;
+            foreach (var kv in _authoredPanelPos)
+                if (FindDeep(root, kv.Key) is RectTransform rt)
+                    rt.anchoredPosition = kv.Value;
+        }
+
+        // Brush values -> painter prefab/material defaults, then push them to every widget.
+        if (painter && _hasDefaults)
+        {
+            // Reset clicked before the ready-gate captured the camo defaults? keep the live camo rather than
+            // slamming it to the not-yet-filled 0 (which would flatten the material's lighting).
+            if (!_hasDefaultCamo && painter.IsReady)
+            {
+                _defaults.camoHalfLambert = painter.CamoHalfLambert;
+                _defaults.camoHalfLambertBrightness = painter.CamoHalfLambertBrightness;
+                _defaults.camoSpecularDampen = painter.CamoSpecularDampen;
+            }
+
+            ApplyValues(painter, _defaults);
+            SyncFromPainter();
+            SyncCamoSliders();
+
+            // ApplyValues wrote the camo straight to the material (painter is ready at a runtime reset), so
+            // drop any still-pending restored camo the ready-gate would otherwise re-apply over the default.
+            _hasPendingCamo = false;
+
+            CaptureCarry();          // a later respawn now carries the defaults, not the pre-reset values
+            SnapshotSavedBaseline(); // values match the (now deleted) save -> the reset itself triggers no auto-save
+        }
+    }
+
     /// <summary>Deletes the saved HUD layout (next start opens at the authored layout / defaults). Editor convenience.</summary>
     [ContextMenu("Clear Saved HUD Layout")]
     public void ClearSavedHudState()
diff --git a/Assets/Scripts/PaintHud.cs b/Assets/Scripts/PaintHud.cs
index 8d2061f..a52b9eb 100644
--- a/Assets/Scripts/PaintHud.cs
+++ b/Assets/Scripts/PaintHud.cs
@@ -51,6 +51,8 @@ public partial class PaintHud : MonoBehaviour
     private const string TogglePipette = "Toggle_Pipette";
     private const string PickerAlbedo = "Picker_Albedo";
     private const string PickerEmission = "Picker_Emission";
+    private const string SliderAlbedoAlpha = "Slider_AlbedoAlpha";
+    private const string SliderEmissionAlpha = "Slider_EmissionAlpha";
     private const string SliderMetallic = "Slider_Metallic";
     private const string SliderSmoothness = "Slider_Smoothness";
     private const string SliderMetallicSmoothnessAlpha = "Slider_MetallicSmoothnessAlpha";
@@ -121,6 +123,10 @@ public partial class PaintHud : MonoBehaviour
             _panel = go;
         }
 
+        // Snapshot the authored panel positions now, while the layout is untouched - before RestoreHudState
+        // (in BindPainter) overwrites them. The reset button restores exactly these.
+        CaptureAuthoredLayout();
+
         // The paint library now lives inside the authored layout prefab; bind its widgets like the brush panel.
         BindLibrary(_panel ? _panel.transform : null);
 
@@ -167,6 +173,11 @@ public partial class PaintHud : MonoBehaviour
         // Re-sync the brush-size slider when Shift+wheel resizes the brush in-world (painter -> HUD).
         painter.BrushSizeChanged += SyncBrushSize;
 
+        // Snapshot the painter's prefab-default brush values before carry/restore mutate them; the reset
+        // button returns to exactly these. Once per HUD (a freshly spawned respawn painter holds the same
+        // prefab defaults, so re-capturing would be redundant).
+        CaptureDefaults();
+
         // First bind this session: restore panel positions + brush values from disk (cross-session).
         // A later bind is an avatar respawn (scene switch) -> carry the in-session brush values onto the
         // fresh painter instead, so they are not reset to its prefab defaults.
@@ -259,18 +270,23 @@ public partial class PaintHud : MonoBehaviour
         WirePanelFade(panel, PanelEmission, ToggleEmission);
         WirePanelFade(panel, PanelSpray, ToggleSpray);
 
+        // Picker drives only RGB (keeping the painter's current alpha); a standalone slider drives alpha.
         WirePicker(panel, PickerAlbedo, painter ? painter.brushColor : Color.red,
-            c => { if (painter) painter.brushColor = c; });
+            c => { if (painter) painter.brushColor = WithRgb(painter.brushColor, c); });
+        WireSlider(panel, SliderAlbedoAlpha, painter ? painter.brushColor.a : .6f,
+            v => { if (painter) painter.brushColor = WithAlpha(painter.brushColor, v); });
 
         WireSlider(panel, SliderMetallic, painter ? painter.metallic : 0f, v => { if (painter) painter.metallic = v; });
         WireSlider(panel, SliderSmoothness, painter ? painter.smoothness : 0.5f, v => { if (painter) painter.smoothness = v; });
-        WireSlider(panel, SliderMetallicSmoothnessAlpha, painter ? painter.metallicSmoothnessOpacity : 1f, v => { if (painter) painter.metallicSmoothnessOpacity = v; });
+        WireSlider(panel, SliderMetallicSmoothnessAlpha, painter ? painter.metallicSmoothnessOpacity : .6f, v => { if (painter) painter.metallicSmoothnessOpacity = v; });
         WireSlider(panel, SliderOcclusion, painter ? painter.occlusion : 0.5f, v => { if (painter) painter.occlusion = v; });
-        WireSlider(panel, SliderOcclusionAlpha, painter ? painter.occlusionOpacity : 1f, v => { if (painter) painter.occlusionOpacity = v; });
+        WireSlider(panel, SliderOcclusionAlpha, painter ? painter.occlusionOpacity : .6f, v => { if (painter) painter.occlusionOpacity = v; });
 
         WirePicker(panel, PickerEmission, painter ? painter.emissionColor : Color.black,
-            c => { if (painter) painter.emissionColor = c; });
+            c => { if (painter) painter.emissionColor = WithRgb(painter.emissionColor, c); });
         WireSlider(panel, SliderEmissionIntensity, painter ? painter.emissionIntensity : 1f, v => { if (painter) painter.emissionIntensity = v; });
+        WireSlider(panel, SliderEmissionAlpha, painter ? painter.emissionColor.a : .6f,
+            v => { if (painter) painter.emissionColor = WithAlpha(painter.emissionColor, v); });
 
         WireSlider(panel, SliderBrushSize, painter ? painter.brushSize : 16f, v => { if (painter) painter.brushSize = Mathf.RoundToInt(v); });
 
@@ -279,8 +295,8 @@ public partial class PaintHud : MonoBehaviour
         WireSlider(panel, SliderSprayDots, painter ? painter.sprayDots : 24f, v => { if (painter) painter.sprayDots = Mathf.RoundToInt(v); });
         WireSlider(panel, SliderSprayDotSizeMin, painter ? painter.sprayDotSizeMin : .05f, v => { if (painter) painter.sprayDotSizeMin = v; });
         WireSlider(panel, SliderSprayDotSizeMax, painter ? painter.sprayDotSizeMax : .18f, v => { if (painter) painter.sprayDotSizeMax = v; });
-        WireSlider(panel, SliderSprayDotAlphaMin, painter ? painter.sprayDotAlphaMin : .25f, v => { if (painter) painter.sprayDotAlphaMin = v; });
-        WireSlider(panel, SliderSprayDotAlphaMax, painter ? painter.sprayDotAlphaMax : 1f, v => { if (painter) painter.sprayDotAlphaMax = v; });
+        WireSlider(panel, SliderSprayDotAlphaMin, painter ? painter.sprayDotAlphaMin : .2f, v => { if (painter) painter.sprayDotAlphaMin = v; });
+        WireSlider(panel, SliderSprayDotAlphaMax, painter ? painter.sprayDotAlphaMax : .6f, v => { if (painter) painter.sprayDotAlphaMax = v; });
 
         // Camouflage knobs on the player's PlayerCamoLit material instance (material-backed, not painter
         // fields). The values are not readable here yet - the HUD binds in the avatar's OnNetworkSpawn,
@@ -314,6 +330,8 @@ public partial class PaintHud : MonoBehaviour
 
         SetPicker(panel, PickerAlbedo, painter.brushColor);
         SetPicker(panel, PickerEmission, painter.emissionColor);
+        SetSlider(panel, SliderAlbedoAlpha, painter.brushColor.a);
+        SetSlider(panel, SliderEmissionAlpha, painter.emissionColor.a);
 
         SetSlider(panel, SliderMetallic, painter.metallic);
         SetSlider(panel, SliderSmoothness, painter.smoothness);
@@ -369,7 +387,10 @@ public partial class PaintHud : MonoBehaviour
     {
         var cell = FindDeep(panel, name);
         var slider = cell ? cell.GetComponentInChildren<Slider>() : null;
-        if (slider) slider.value = value; // listener refreshes the value label + painter
+        if (!slider) return;
+        var curve = slider.GetComponent<SliderCurve>();
+        if (curve) curve.SetOutput(value); // inverts the value onto the handle, then fires the slider listener
+        else slider.value = value;         // listener refreshes the value label + painter
     }
 
     private static void SetPicker(Transform panel, string name, Color color)
@@ -378,6 +399,12 @@ public partial class PaintHud : MonoBehaviour
         if (picker) picker.SetColor(color);
     }
 
+    // Albedo/emission colour is split across two widgets: the picker drives RGB (keeping the painter's
+    // current alpha), the standalone alpha slider drives alpha (keeping RGB). Kept independent so neither
+    // widget's edit clobbers the other's channel.
+    private static Color WithRgb(Color current, Color rgb) => new Color(rgb.r, rgb.g, rgb.b, current.a);
+    private static Color WithAlpha(Color current, float a) => new Color(current.r, current.g, current.b, a);
+
     // Active = accent frame, inactive = subtle frame. Selection lives on the painter (activeBrushIndex);
     // the swatch click only sets it - the painter resolves the new mask on its next Update.
     private static readonly Color MaskFrameSelected = new Color(0.30f, 0.62f, 1f, 1f);
@@ -509,18 +536,23 @@ public partial class PaintHud : MonoBehaviour
         if (!cell) return;
         var slider = cell.GetComponentInChildren<Slider>();
         if (!slider) return;
+        var curve = slider.GetComponent<SliderCurve>(); // optional non-linear response on the same object
         var valueRt = cell.Find("Value");
         var valueText = valueRt ? valueRt.GetComponent<TMPro.TMP_Text>() : null;
 
-        bool whole = slider.wholeNumbers;
-        slider.value = value;
+        // With a curve the slider handle is linear but the bound value is the curved output; whole-number
+        // quantisation moves onto the curve so the slider itself stays continuous.
+        if (curve) curve.SetOutputWithoutNotify(value); // seed the handle by inverting the value (no listener yet)
+        else slider.value = value;
+
+        Func<float> read = () => curve ? curve.Value : slider.value;
 
         Action<float> setText = v =>
         {
-            if (valueText) valueText.text = whole ? Mathf.RoundToInt(v).ToString() : v.ToString("0.00");
+            if (valueText) valueText.text = slider.wholeNumbers ? Mathf.RoundToInt(v).ToString() : v.ToString("0.00");
         };
-        setText(slider.value); // show the actual (clamped) value, not the unclamped input
-        slider.onValueChanged.AddListener(v => { setText(v); onChanged(v); });
+        setText(read()); // show the actual (clamped/curved) value, not the unclamped input
+        slider.onValueChanged.AddListener(_ => { float v = read(); setText(v); onChanged(v); });
     }
 
     private void WirePicker(Transform panel, string name, Color color, Action<Color> onChanged)
@@ -581,7 +613,7 @@ public partial class PaintHud : MonoBehaviour
     }
 
     // Cached gradient sprites for the colour picker.
-    private static Sprite _satSprite, _valSprite, _hueSprite, _alphaSprite;
+    private static Sprite _satSprite, _valSprite, _hueSprite;
 
     /// <summary>Horizontal white-out: opaque white (left) -> transparent (right) = saturation.</summary>
     public static Sprite SaturationSprite()
@@ -615,23 +647,6 @@ public partial class PaintHud : MonoBehaviour
         return _valSprite;
     }
 
-    /// <summary>Horizontal white transparency ramp: transparent (left) -> opaque (right) = alpha.
-    /// Tinted to the current colour by the picker so it reads as a colour-over-backdrop fade.</summary>
-    public static Sprite AlphaSprite()
-    {
-        if (_alphaSprite) return _alphaSprite;
-        const int n = 64;
-        var tex = NewGradientTex(n, 1);
-        for (int x = 0; x < n; x++)
-        {
-            byte a = (byte)Mathf.RoundToInt(255f * (x / (float)(n - 1)));
-            tex.SetPixel(x, 0, new Color32(255, 255, 255, a));
-        }
-        tex.Apply(false);
-        _alphaSprite = ToSprite(tex);
-        return _alphaSprite;
-    }
-
     /// <summary>Horizontal full-saturation hue ramp 0..1.</summary>
     public static Sprite HueSprite()
     {
diff --git a/Assets/Scripts/SliderCurve.cs b/Assets/Scripts/SliderCurve.cs
new file mode 100644
index 0000000..f219ab7
--- /dev/null
+++ b/Assets/Scripts/SliderCurve.cs
@@ -0,0 +1,84 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+
+/// <summary>
+/// Reshapes a UI <see cref="Slider"/>'s response with an <see cref="AnimationCurve"/> so the value runs
+/// non-linearly between the slider's authored <c>minValue</c>/<c>maxValue</c>. The curve maps the handle
+/// position (x, 0..1 - linear in screen space) to a value fraction (y, 0..1) that is then scaled to the
+/// slider's range. The slider's own min/max stays the single source of truth for the range; this only
+/// bends the mapping inside it - so dropping the component onto an existing slider needs no range re-entry.
+///
+/// <see cref="Value"/> is the curved output, <see cref="SetOutput"/> positions the handle to show a given
+/// output (inverting the curve), and <see cref="ValueChanged"/> raises the curved value whenever the
+/// handle moves - so the component is usable both standalone (wire <see cref="ValueChanged"/>) and from
+/// code that drives the raw slider (read <see cref="Value"/>).
+///
+/// The curve should be monotonic increasing (the default linear is); the inverse used by
+/// <see cref="SetOutput"/> assumes that.
+/// </summary>
+[RequireComponent(typeof(Slider))]
+[DisallowMultipleComponent]
+public class SliderCurve : MonoBehaviour
+{
+    [Tooltip("Maps the handle position (x, 0..1) to a value fraction (y, 0..1), scaled to the slider's " +
+             "minValue/maxValue. Default linear = no change. Should be monotonic increasing.")]
+    public AnimationCurve response = AnimationCurve.Linear(0f, 0f, 1f, 1f);
+
+    /// <summary>Raised with the curved output whenever the handle moves.</summary>
+    public event Action<float> ValueChanged;
+
+    private Slider _slider;
+    private Slider Slider => _slider ? _slider : (_slider = GetComponent<Slider>());
+
+    /// <summary>The curved output value for the current handle position.</summary>
+    public float Value => Slider ? Curve(Slider.normalizedValue) : 0f;
+
+    private void OnEnable()
+    {
+        if (Slider) Slider.onValueChanged.AddListener(OnSliderChanged);
+    }
+
+    private void OnDisable()
+    {
+        if (_slider) _slider.onValueChanged.RemoveListener(OnSliderChanged);
+    }
+
+    private void OnSliderChanged(float _) => ValueChanged?.Invoke(Value);
+
+    /// <summary>Positions the handle so <see cref="Value"/> reads <paramref name="output"/>, raising the
+    /// slider's <c>onValueChanged</c> (and thus <see cref="ValueChanged"/>).</summary>
+    public void SetOutput(float output)
+    {
+        if (Slider) Slider.normalizedValue = Position(output); // normalizedValue setter notifies
+    }
+
+    /// <summary>As <see cref="SetOutput"/> but without raising any change event (for silent seeding).</summary>
+    public void SetOutputWithoutNotify(float output)
+    {
+        if (Slider) Slider.SetValueWithoutNotify(Mathf.Lerp(Slider.minValue, Slider.maxValue, Position(output)));
+    }
+
+    // handle position (0..1) -> curved output value in [minValue, maxValue]
+    private float Curve(float t)
+    {
+        float y = Mathf.Clamp01(response.Evaluate(Mathf.Clamp01(t)));
+        float v = Mathf.Lerp(Slider.minValue, Slider.maxValue, y);
+        return Slider && Slider.wholeNumbers ? Mathf.Round(v) : v;
+    }
+
+    // curved output value -> handle position (0..1), inverting the (monotonic) curve via bisection
+    private float Position(float output)
+    {
+        var s = Slider;
+        if (!s) return 0f;
+        float target = Mathf.Clamp01(Mathf.InverseLerp(s.minValue, s.maxValue, output)); // desired y
+        float lo = 0f, hi = 1f;
+        for (int i = 0; i < 24; i++)
+        {
+            float mid = 0.5f * (lo + hi);
+            if (Mathf.Clamp01(response.Evaluate(mid)) < target) lo = mid; else hi = mid;
+        }
+        return 0.5f * (lo + hi);
+    }
+}
diff --git a/Assets/Scripts/SliderCurve.cs.meta b/Assets/Scripts/SliderCurve.cs.meta
new file mode 100644
index 0000000..ab4357e
--- /dev/null
+++ b/Assets/Scripts/SliderCurve.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2e66618c2739718459e4ecd2253c4ba7
\ No newline at end of file