In-VR menu: replace chunky prop-knob panel with Godot Control UI in a SubViewport
WorldPanel is now the project's one SubViewport screen: MainMenu (tabs Player /
World / System; Return to spawn, Recalibrate body, Reset props, Ping, click
volume slider, scrollable log, FPS, Close) rendered by MenuScreen into a
960x640 SubViewport on a thin 0.36x0.24 m panel.
Input = touch-first hybrid cursor injected as mouse events: both controller
rays are projected analytically onto the panel plane, converted to viewport
pixels and pushed via Viewport.PushInput (MouseMotion/MouseButton, wheel from
thumbstick). Stylus tip within 6 cm = touch cursor (press crossing 0.6 cm from
the front, release past 1.8 cm); farther = laser cursor with trigger edge. One
owning hand per viewport. Haptic tick + synthesized click on press.
Kept: ax_button summon/dismiss, XROrigin3D parenting, grip drag (direct/laser)
with head re-orient, IsBlocking/IsPanelCollider. Locomotion's beam now takes
its length from WorldPanel.TryGetLaserDistance (no beam while touching) and
starts at the stylus tip. Recalibrate calls Recalibrate() on the first node in
group "calibration" (disabled when absent).
New headless regression scenes/menu_spike.tscn ("MENU: overall PASS").
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
FoxyzandClaude Opus 5.5 committed
1 parent
3a990c6dbe
commit
661fe1089a
11 files changed
+1281
-316
No files matched your search
+12
-5
@@ -7,6 +7,7 @@ public partial class Locomotion : Node
|
||||
private const float RayLength = 50f;
|
||||
private const float LaserMinDistance = 0.35f;
|
||||
private const float MarkerNearDistance = 1.2f;
|
||||
private const float LaserStart = 0.12f;
|
||||
|
||||
private XROrigin3D _origin;
|
||||
private XRCamera3D _camera;
|
||||
@@ -78,7 +79,7 @@ public partial class Locomotion : Node
|
||||
Node3D pivot = new() { Visible = false };
|
||||
pivot.AddChild(beam);
|
||||
Basis rot = Basis.FromEuler(new Vector3(-Mathf.Pi / 2f, 0, 0));
|
||||
pivot.Transform = new Transform3D(rot, new Vector3(0, 0, -0.12f));
|
||||
pivot.Transform = new Transform3D(rot, new Vector3(0, 0, -LaserStart));
|
||||
controller.AddChild(pivot);
|
||||
return pivot;
|
||||
}
|
||||
@@ -127,13 +128,19 @@ public partial class Locomotion : Node
|
||||
|
||||
bool show = false;
|
||||
float dist = 0f;
|
||||
if (hit.TryGetValue("collider", out Variant collider) && collider.As<Node>() is Node node)
|
||||
if (WorldPanel.TryGetLaserDistance(controller, out float panelDist))
|
||||
{
|
||||
// The menu decides touch vs laser itself (tip near the surface = touch, no beam).
|
||||
dist = panelDist;
|
||||
show = dist > LaserMinDistance;
|
||||
}
|
||||
else if (hit.TryGetValue("collider", out Variant collider) && collider.As<Node>() is Node node)
|
||||
{
|
||||
bool interactive;
|
||||
if (node.GetParent() is TeleportMarker marker)
|
||||
interactive = !marker.IsNear;
|
||||
else
|
||||
interactive = WorldPanel.IsPanelCollider(node);
|
||||
interactive = false; // panel hit but the menu isn't in laser mode for this hand
|
||||
if (interactive && hit.TryGetValue("position", out Variant posVariant))
|
||||
{
|
||||
dist = from.DistanceTo(posVariant.As<Vector3>());
|
||||
@@ -142,8 +149,8 @@ public partial class Locomotion : Node
|
||||
}
|
||||
|
||||
laser.Visible = show;
|
||||
if (show)
|
||||
laser.Scale = new Vector3(1, dist, 1);
|
||||
if (show) // beam starts at the stylus tip (LaserStart ahead of the controller)
|
||||
laser.Scale = new Vector3(1, Mathf.Max(0.01f, dist - LaserStart), 1);
|
||||
}
|
||||
|
||||
private void CheckTeleport(XRController3D controller, ref bool wasPressed)
|
||||
|
||||
@@ -0,0 +1,288 @@
|
||||
using Godot;
|
||||
using System;
|
||||
|
||||
// The in-VR menu content: plain Godot Controls, rendered by MenuScreen into its SubViewport.
|
||||
// Built in code (no .tscn) so the spike can instantiate it without XR. Actions are C# events;
|
||||
// WorldPanel wires them to the game. Sized for a 960x640 viewport on a 0.36x0.24 m panel
|
||||
// (~2.7 px/mm): 26 px body text ≈ 1.2° at 45 cm, 64 px buttons ≈ 24 mm touch targets.
|
||||
public partial class MainMenu : PanelContainer
|
||||
{
|
||||
public const string CalibrationGroup = "calibration";
|
||||
|
||||
private const int FontSize = 26;
|
||||
private const int ButtonHeight = 64;
|
||||
private const int MaxLogLines = 40;
|
||||
|
||||
public event Action ReturnToSpawnRequested;
|
||||
public event Action ResetPropsRequested;
|
||||
public event Action PingRequested;
|
||||
public event Action CloseRequested;
|
||||
public event Action Clicked;
|
||||
|
||||
public TabContainer Tabs { get; private set; }
|
||||
public Button ReturnToSpawnButton { get; private set; }
|
||||
public Button RecalibrateButton { get; private set; }
|
||||
public Button ResetPropsButton { get; private set; }
|
||||
public Button PingButton { get; private set; }
|
||||
public Button CloseButton { get; private set; }
|
||||
public Button HeaderCloseButton { get; private set; }
|
||||
public HSlider ClickVolumeSlider { get; private set; }
|
||||
public ScrollContainer LogScroll { get; private set; }
|
||||
|
||||
private Label _fpsLabel;
|
||||
private Label _calibrationStatus;
|
||||
private VBoxContainer _logLines;
|
||||
private double _refreshTimer;
|
||||
|
||||
public MainMenu()
|
||||
{
|
||||
Theme = BuildTheme();
|
||||
BuildLayout();
|
||||
}
|
||||
|
||||
public override void _Ready() => RefreshCalibration();
|
||||
|
||||
public override void _Process(double delta)
|
||||
{
|
||||
_refreshTimer -= delta;
|
||||
if (_refreshTimer > 0)
|
||||
return;
|
||||
_refreshTimer = 0.25;
|
||||
_fpsLabel.Text = $"{Engine.GetFramesPerSecond():0} fps";
|
||||
RefreshCalibration();
|
||||
}
|
||||
|
||||
// Contract with the body-calibration work: a node in group "calibration" exposing
|
||||
// Recalibrate(). Absent → button disabled. We never create that node here.
|
||||
public Node FindCalibration()
|
||||
{
|
||||
if (!IsInsideTree())
|
||||
return null;
|
||||
Node node = GetTree().GetFirstNodeInGroup(CalibrationGroup);
|
||||
return node != null && node.HasMethod("Recalibrate") ? node : null;
|
||||
}
|
||||
|
||||
public void RefreshCalibration()
|
||||
{
|
||||
bool available = FindCalibration() != null;
|
||||
RecalibrateButton.Disabled = !available;
|
||||
_calibrationStatus.Text = available ? "" : "Not available";
|
||||
}
|
||||
|
||||
public void Log(string line)
|
||||
{
|
||||
_logLines.AddChild(new Label { Text = line, AutowrapMode = TextServer.AutowrapMode.WordSmart });
|
||||
while (_logLines.GetChildCount() > MaxLogLines)
|
||||
{
|
||||
Node oldest = _logLines.GetChild(0);
|
||||
_logLines.RemoveChild(oldest);
|
||||
oldest.QueueFree();
|
||||
}
|
||||
}
|
||||
|
||||
private void BuildLayout()
|
||||
{
|
||||
VBoxContainer root = new();
|
||||
root.AddThemeConstantOverride("separation", 10);
|
||||
AddChild(root);
|
||||
|
||||
HBoxContainer header = new();
|
||||
header.AddThemeConstantOverride("separation", 16);
|
||||
root.AddChild(header);
|
||||
Label title = new() { Text = "VR Messs", SizeFlagsHorizontal = SizeFlags.ExpandFill, VerticalAlignment = VerticalAlignment.Center };
|
||||
title.AddThemeFontSizeOverride("font_size", 30);
|
||||
header.AddChild(title);
|
||||
_fpsLabel = new Label { Text = "-- fps", VerticalAlignment = VerticalAlignment.Center };
|
||||
_fpsLabel.AddThemeColorOverride("font_color", new Color(0.6f, 0.68f, 0.8f));
|
||||
header.AddChild(_fpsLabel);
|
||||
HeaderCloseButton = MakeButton("Close", () => CloseRequested?.Invoke());
|
||||
HeaderCloseButton.CustomMinimumSize = new Vector2(120, 52);
|
||||
header.AddChild(HeaderCloseButton);
|
||||
|
||||
Tabs = new TabContainer { SizeFlagsVertical = SizeFlags.ExpandFill, TabFocusMode = FocusModeEnum.None };
|
||||
Tabs.TabChanged += _ => Clicked?.Invoke();
|
||||
root.AddChild(Tabs);
|
||||
|
||||
// Player
|
||||
VBoxContainer player = MakePage("Player");
|
||||
ReturnToSpawnButton = MakeButton("Return to spawn", () => ReturnToSpawnRequested?.Invoke());
|
||||
player.AddChild(ReturnToSpawnButton);
|
||||
HBoxContainer calibRow = new();
|
||||
calibRow.AddThemeConstantOverride("separation", 16);
|
||||
RecalibrateButton = MakeButton("Recalibrate body", Recalibrate);
|
||||
RecalibrateButton.SizeFlagsHorizontal = SizeFlags.ExpandFill;
|
||||
calibRow.AddChild(RecalibrateButton);
|
||||
_calibrationStatus = new Label { VerticalAlignment = VerticalAlignment.Center };
|
||||
_calibrationStatus.AddThemeColorOverride("font_color", new Color(0.6f, 0.6f, 0.65f));
|
||||
calibRow.AddChild(_calibrationStatus);
|
||||
player.AddChild(calibRow);
|
||||
Tabs.AddChild(player);
|
||||
|
||||
// World
|
||||
VBoxContainer world = MakePage("World");
|
||||
ResetPropsButton = MakeButton("Reset props", () => ResetPropsRequested?.Invoke());
|
||||
world.AddChild(ResetPropsButton);
|
||||
PingButton = MakeButton("Ping sound", () => PingRequested?.Invoke());
|
||||
world.AddChild(PingButton);
|
||||
Tabs.AddChild(world);
|
||||
|
||||
// System
|
||||
VBoxContainer system = MakePage("System");
|
||||
HBoxContainer volumeRow = new();
|
||||
volumeRow.AddThemeConstantOverride("separation", 20);
|
||||
volumeRow.AddChild(new Label { Text = "Click volume", VerticalAlignment = VerticalAlignment.Center, CustomMinimumSize = new Vector2(200, 0) });
|
||||
ClickVolumeSlider = new HSlider
|
||||
{
|
||||
MinValue = 0,
|
||||
MaxValue = 100,
|
||||
Step = 1,
|
||||
Value = 70,
|
||||
SizeFlagsHorizontal = SizeFlags.ExpandFill,
|
||||
SizeFlagsVertical = SizeFlags.ShrinkCenter,
|
||||
CustomMinimumSize = new Vector2(0, 48),
|
||||
FocusMode = FocusModeEnum.None,
|
||||
};
|
||||
volumeRow.AddChild(ClickVolumeSlider);
|
||||
system.AddChild(volumeRow);
|
||||
CloseButton = MakeButton("Close menu", () => CloseRequested?.Invoke());
|
||||
system.AddChild(CloseButton);
|
||||
Label logTitle = new() { Text = "Log (thumbstick scrolls)" };
|
||||
logTitle.AddThemeColorOverride("font_color", new Color(0.6f, 0.68f, 0.8f));
|
||||
system.AddChild(logTitle);
|
||||
LogScroll = new ScrollContainer
|
||||
{
|
||||
SizeFlagsVertical = SizeFlags.ExpandFill,
|
||||
HorizontalScrollMode = ScrollContainer.ScrollMode.Disabled,
|
||||
};
|
||||
_logLines = new VBoxContainer { SizeFlagsHorizontal = SizeFlags.ExpandFill };
|
||||
_logLines.AddThemeConstantOverride("separation", 2);
|
||||
LogScroll.AddChild(_logLines);
|
||||
system.AddChild(LogScroll);
|
||||
Tabs.AddChild(system);
|
||||
}
|
||||
|
||||
private void Recalibrate()
|
||||
{
|
||||
Node calibration = FindCalibration();
|
||||
if (calibration == null)
|
||||
{
|
||||
RefreshCalibration();
|
||||
return;
|
||||
}
|
||||
GD.Print("MainMenu: Recalibrate body → calibration.Recalibrate()");
|
||||
calibration.Call("Recalibrate");
|
||||
}
|
||||
|
||||
private static VBoxContainer MakePage(string title)
|
||||
{
|
||||
VBoxContainer page = new() { Name = title };
|
||||
page.AddThemeConstantOverride("separation", 14);
|
||||
return page;
|
||||
}
|
||||
|
||||
private Button MakeButton(string text, Action action)
|
||||
{
|
||||
Button button = new()
|
||||
{
|
||||
Text = text,
|
||||
CustomMinimumSize = new Vector2(0, ButtonHeight),
|
||||
FocusMode = FocusModeEnum.None,
|
||||
};
|
||||
button.Pressed += () =>
|
||||
{
|
||||
Clicked?.Invoke();
|
||||
// Deferred: actions may hide/move the panel; never do that from inside the
|
||||
// input event MenuScreen is injecting.
|
||||
Callable.From(action).CallDeferred();
|
||||
};
|
||||
return button;
|
||||
}
|
||||
|
||||
private static StyleBoxFlat Box(Color bg, int radius, float marginX, float marginY, Color? border = null, int borderWidth = 0)
|
||||
{
|
||||
StyleBoxFlat box = new() { BgColor = bg };
|
||||
box.SetCornerRadiusAll(radius);
|
||||
box.ContentMarginLeft = marginX;
|
||||
box.ContentMarginRight = marginX;
|
||||
box.ContentMarginTop = marginY;
|
||||
box.ContentMarginBottom = marginY;
|
||||
if (border is Color c)
|
||||
{
|
||||
box.BorderColor = c;
|
||||
box.SetBorderWidthAll(borderWidth);
|
||||
}
|
||||
return box;
|
||||
}
|
||||
|
||||
private static Theme BuildTheme()
|
||||
{
|
||||
Color accent = new(0.35f, 0.6f, 0.95f);
|
||||
Theme theme = new() { DefaultFontSize = FontSize };
|
||||
|
||||
theme.SetStylebox("panel", "PanelContainer", Box(new Color(0.07f, 0.08f, 0.11f), 0, 18, 14));
|
||||
|
||||
theme.SetStylebox("normal", "Button", Box(new Color(0.17f, 0.2f, 0.27f), 10, 20, 8));
|
||||
theme.SetStylebox("hover", "Button", Box(new Color(0.24f, 0.31f, 0.44f), 10, 20, 8, accent, 3));
|
||||
theme.SetStylebox("pressed", "Button", Box(new Color(0.33f, 0.5f, 0.78f), 10, 20, 8, new Color(0.7f, 0.85f, 1f), 3));
|
||||
theme.SetStylebox("hover_pressed", "Button", Box(new Color(0.33f, 0.5f, 0.78f), 10, 20, 8, new Color(0.7f, 0.85f, 1f), 3));
|
||||
theme.SetStylebox("disabled", "Button", Box(new Color(0.11f, 0.12f, 0.15f), 10, 20, 8));
|
||||
theme.SetStylebox("focus", "Button", new StyleBoxEmpty());
|
||||
theme.SetColor("font_color", "Button", new Color(0.92f, 0.94f, 0.98f));
|
||||
theme.SetColor("font_hover_color", "Button", Colors.White);
|
||||
theme.SetColor("font_pressed_color", "Button", Colors.White);
|
||||
theme.SetColor("font_disabled_color", "Button", new Color(0.45f, 0.47f, 0.52f));
|
||||
|
||||
theme.SetStylebox("panel", "TabContainer", Box(new Color(0.1f, 0.12f, 0.16f), 10, 18, 16));
|
||||
StyleBoxFlat tabSelected = Box(new Color(0.1f, 0.12f, 0.16f), 0, 28, 12);
|
||||
tabSelected.CornerRadiusTopLeft = 10;
|
||||
tabSelected.CornerRadiusTopRight = 10;
|
||||
tabSelected.BorderColor = accent;
|
||||
tabSelected.BorderWidthTop = 4;
|
||||
theme.SetStylebox("tab_selected", "TabContainer", tabSelected);
|
||||
StyleBoxFlat tabUnselected = Box(new Color(0.13f, 0.15f, 0.2f), 0, 28, 12);
|
||||
tabUnselected.CornerRadiusTopLeft = 10;
|
||||
tabUnselected.CornerRadiusTopRight = 10;
|
||||
theme.SetStylebox("tab_unselected", "TabContainer", tabUnselected);
|
||||
StyleBoxFlat tabHovered = Box(new Color(0.2f, 0.26f, 0.37f), 0, 28, 12);
|
||||
tabHovered.CornerRadiusTopLeft = 10;
|
||||
tabHovered.CornerRadiusTopRight = 10;
|
||||
theme.SetStylebox("tab_hovered", "TabContainer", tabHovered);
|
||||
theme.SetStylebox("tab_focus", "TabContainer", new StyleBoxEmpty());
|
||||
theme.SetConstant("tab_separation", "TabContainer", 6);
|
||||
theme.SetFontSize("font_size", "TabContainer", FontSize);
|
||||
|
||||
// Slider: thick track, big round grabber (default icons are ~16 px — too small in VR).
|
||||
StyleBoxFlat track = Box(new Color(0.17f, 0.2f, 0.27f), 6, 0, 6);
|
||||
theme.SetStylebox("slider", "HSlider", track);
|
||||
theme.SetStylebox("grabber_area", "HSlider", Box(accent, 6, 0, 6));
|
||||
theme.SetStylebox("grabber_area_highlight", "HSlider", Box(accent.Lightened(0.2f), 6, 0, 6));
|
||||
theme.SetIcon("grabber", "HSlider", Circle(36, new Color(0.9f, 0.94f, 1f)));
|
||||
theme.SetIcon("grabber_highlight", "HSlider", Circle(36, Colors.White));
|
||||
theme.SetIcon("grabber_disabled", "HSlider", Circle(36, new Color(0.4f, 0.4f, 0.45f)));
|
||||
|
||||
// Wide scrollbar so it is touchable.
|
||||
theme.SetStylebox("scroll", "VScrollBar", Box(new Color(0.13f, 0.15f, 0.2f), 6, 9, 0));
|
||||
theme.SetStylebox("grabber", "VScrollBar", Box(new Color(0.3f, 0.36f, 0.48f), 6, 9, 0));
|
||||
theme.SetStylebox("grabber_highlight", "VScrollBar", Box(new Color(0.4f, 0.5f, 0.68f), 6, 9, 0));
|
||||
theme.SetStylebox("grabber_pressed", "VScrollBar", Box(accent, 6, 9, 0));
|
||||
|
||||
theme.SetColor("font_color", "Label", new Color(0.88f, 0.9f, 0.95f));
|
||||
return theme;
|
||||
}
|
||||
|
||||
private static ImageTexture Circle(int size, Color color)
|
||||
{
|
||||
Image image = Image.CreateEmpty(size, size, false, Image.Format.Rgba8);
|
||||
float r = size * 0.5f;
|
||||
for (int y = 0; y < size; y++)
|
||||
{
|
||||
for (int x = 0; x < size; x++)
|
||||
{
|
||||
float d = new Vector2(x + 0.5f - r, y + 0.5f - r).Length();
|
||||
float a = Mathf.Clamp(r - d, 0f, 1f); // 1 px anti-aliased edge
|
||||
image.SetPixel(x, y, new Color(color, a));
|
||||
}
|
||||
}
|
||||
return ImageTexture.CreateFromImage(image);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
uid://dv7mp0go4oxof
|
||||
@@ -0,0 +1,467 @@
|
||||
using Godot;
|
||||
using System;
|
||||
|
||||
// A thin 3D panel showing Godot Control UI rendered into a SubViewport (the project's ONE
|
||||
// SubViewport screen, see AGENTS.md), plus the touch-first hybrid cursor that drives it.
|
||||
// Input-agnostic: callers feed per-hand rays (origin + forward dir), trigger and thumbstick;
|
||||
// the screen projects them onto its plane and injects InputEventMouseMotion/MouseButton into
|
||||
// the SubViewport via Viewport.PushInput(event, in_local_coords: true).
|
||||
//
|
||||
// Cursor rules per hand (panel-local frame: X right, Y up, +Z = front normal, origin = center):
|
||||
// TOUCH — the stylus tip (origin + dir * TipLength) is within HoverDepth in front of the plane
|
||||
// (or pushed up to PushThroughDepth behind it) and over the panel: the tip's
|
||||
// projection is the cursor. Crossing ContactDepth from the front presses, backing out
|
||||
// past ReleaseDepth releases (hysteresis; entering from the side/behind never presses).
|
||||
// LASER — otherwise, the ray hits the panel from the front: the hit is the cursor and the
|
||||
// trigger (edge) clicks; holding the trigger drags (sliders).
|
||||
// One Godot mouse exists per viewport, so one hand owns it: the hand holding a press keeps it,
|
||||
// else a touching hand beats a laser hand, else the previous owner is preferred.
|
||||
public partial class MenuScreen : Node3D
|
||||
{
|
||||
public const float TipLength = 0.12f;
|
||||
public const float HoverDepth = 0.06f;
|
||||
public const float ContactDepth = 0.006f;
|
||||
public const float ReleaseDepth = 0.018f;
|
||||
public const float PushThroughDepth = 0.08f;
|
||||
public const float TouchEdgeMargin = 0.015f;
|
||||
public const float ScrollDeadzone = 0.3f;
|
||||
public const float ScrollNotchesPerSecond = 14f;
|
||||
|
||||
public enum PointerMode { None, Touch, Laser }
|
||||
|
||||
public struct PointerInput
|
||||
{
|
||||
public bool Valid;
|
||||
public Vector3 Origin;
|
||||
public Vector3 Direction;
|
||||
public bool Trigger;
|
||||
public Vector2 Stick;
|
||||
}
|
||||
|
||||
private struct HandState
|
||||
{
|
||||
public PointerMode Mode;
|
||||
public Vector3 Local;
|
||||
public Vector2 Pixel;
|
||||
public float Depth;
|
||||
public float RayDistance;
|
||||
public bool Armed;
|
||||
public bool TriggerPrev;
|
||||
public bool WantDown;
|
||||
}
|
||||
|
||||
public Vector2 SizeMeters { get; }
|
||||
public Vector2I SizePixels { get; }
|
||||
public SubViewport Viewport { get; private set; }
|
||||
public StaticBody3D Body { get; private set; }
|
||||
|
||||
// Fired when a hand presses down on the UI (touch contact or trigger) — for haptics.
|
||||
public event Action<int, PointerMode> PointerPressed;
|
||||
|
||||
private readonly HandState[] _hands = new HandState[2];
|
||||
private readonly MeshInstance3D[] _dots = new MeshInstance3D[2];
|
||||
private readonly StandardMaterial3D[] _dotMaterials = new StandardMaterial3D[2];
|
||||
private int _owner = -1;
|
||||
private bool _down;
|
||||
private bool _mouseInside;
|
||||
private Vector2 _lastSent = new(-1, -1);
|
||||
private float _scrollAccum;
|
||||
private StandardMaterial3D _screenMaterial;
|
||||
|
||||
public MenuScreen() : this(new Vector2(0.36f, 0.24f), new Vector2I(960, 640)) { }
|
||||
|
||||
public MenuScreen(Vector2 sizeMeters, Vector2I sizePixels)
|
||||
{
|
||||
SizeMeters = sizeMeters;
|
||||
SizePixels = sizePixels;
|
||||
Build();
|
||||
}
|
||||
|
||||
public override void _Ready()
|
||||
{
|
||||
// ViewportTexture is fetched once the viewport is inside the tree (docs: may return
|
||||
// incorrect data before the scene root is ready).
|
||||
_screenMaterial.AlbedoTexture = Viewport.GetTexture();
|
||||
}
|
||||
|
||||
public PointerMode GetMode(int hand) => _hands[hand].Mode;
|
||||
public bool IsPressing(int hand) => _owner == hand && _down;
|
||||
public Vector2 GetPixel(int hand) => _hands[hand].Pixel;
|
||||
|
||||
public bool TryGetLaserDistance(int hand, out float distance)
|
||||
{
|
||||
distance = _hands[hand].RayDistance;
|
||||
return Visible && _hands[hand].Mode == PointerMode.Laser;
|
||||
}
|
||||
|
||||
public Vector2 LocalToPixel(Vector3 local) => new(
|
||||
(local.X / SizeMeters.X + 0.5f) * SizePixels.X,
|
||||
(0.5f - local.Y / SizeMeters.Y) * SizePixels.Y);
|
||||
|
||||
public Vector3 PixelToLocal(Vector2 pixel) => new(
|
||||
(pixel.X / SizePixels.X - 0.5f) * SizeMeters.X,
|
||||
(0.5f - pixel.Y / SizePixels.Y) * SizeMeters.Y,
|
||||
0f);
|
||||
|
||||
public Vector3 PixelToGlobal(Vector2 pixel) => GlobalTransform * PixelToLocal(pixel);
|
||||
|
||||
public void SetContent(Control content)
|
||||
{
|
||||
content.SetAnchorsAndOffsetsPreset(Control.LayoutPreset.FullRect);
|
||||
Viewport.AddChild(content);
|
||||
}
|
||||
|
||||
public void SetActive(bool active)
|
||||
{
|
||||
if (!active)
|
||||
ReleaseAll();
|
||||
Visible = active;
|
||||
Viewport.RenderTargetUpdateMode = active ? SubViewport.UpdateMode.Always : SubViewport.UpdateMode.Disabled;
|
||||
foreach (Node child in Body.GetChildren())
|
||||
if (child is CollisionShape3D shape)
|
||||
shape.SetDeferred(CollisionShape3D.PropertyName.Disabled, !active);
|
||||
}
|
||||
|
||||
public void ReleaseAll()
|
||||
{
|
||||
if (_owner >= 0 && _down)
|
||||
SendButton(_lastSent, false);
|
||||
_down = false;
|
||||
_owner = -1;
|
||||
if (_mouseInside)
|
||||
{
|
||||
Viewport.NotifyMouseExited();
|
||||
_mouseInside = false;
|
||||
}
|
||||
_scrollAccum = 0f;
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
// TriggerPrev survives: a trigger still held across a reset must not re-click.
|
||||
_hands[i] = new HandState { TriggerPrev = _hands[i].TriggerPrev };
|
||||
if (_dots[i] != null)
|
||||
_dots[i].Visible = false;
|
||||
}
|
||||
}
|
||||
|
||||
private void Build()
|
||||
{
|
||||
Viewport = new SubViewport
|
||||
{
|
||||
Name = "MenuViewport",
|
||||
Size = SizePixels,
|
||||
Disable3D = true,
|
||||
TransparentBg = false,
|
||||
GuiEmbedSubwindows = true,
|
||||
HandleInputLocally = true,
|
||||
Msaa2D = Godot.Viewport.Msaa.Msaa4X,
|
||||
RenderTargetUpdateMode = SubViewport.UpdateMode.Disabled,
|
||||
};
|
||||
AddChild(Viewport);
|
||||
|
||||
// Screen quad with explicit UVs so the pixel mapping above is ours, not QuadMesh's.
|
||||
float hx = SizeMeters.X * 0.5f, hy = SizeMeters.Y * 0.5f;
|
||||
var st = new SurfaceTool();
|
||||
st.Begin(Mesh.PrimitiveType.Triangles);
|
||||
Vector3[] corners = { new(-hx, hy, 0), new(hx, hy, 0), new(hx, -hy, 0), new(-hx, -hy, 0) };
|
||||
Vector2[] uvs = { new(0, 0), new(1, 0), new(1, 1), new(0, 1) };
|
||||
int[] order = { 0, 1, 2, 0, 2, 3 };
|
||||
foreach (int i in order)
|
||||
{
|
||||
st.SetNormal(Vector3.Back);
|
||||
st.SetUV(uvs[i]);
|
||||
st.AddVertex(corners[i]);
|
||||
}
|
||||
_screenMaterial = new StandardMaterial3D
|
||||
{
|
||||
ShadingMode = BaseMaterial3D.ShadingModeEnum.Unshaded,
|
||||
TextureFilter = BaseMaterial3D.TextureFilterEnum.Linear,
|
||||
CullMode = BaseMaterial3D.CullModeEnum.Disabled,
|
||||
};
|
||||
MeshInstance3D screen = new()
|
||||
{
|
||||
Name = "Screen",
|
||||
Mesh = st.Commit(),
|
||||
CastShadow = GeometryInstance3D.ShadowCastingSetting.Off,
|
||||
};
|
||||
screen.SetSurfaceOverrideMaterial(0, _screenMaterial);
|
||||
AddChild(screen);
|
||||
|
||||
// Thin backing frame (hides the mirrored back side, gives the panel an edge).
|
||||
StandardMaterial3D frameMaterial = new() { AlbedoColor = new Color(0.05f, 0.06f, 0.08f) };
|
||||
MeshInstance3D frame = new()
|
||||
{
|
||||
Name = "Frame",
|
||||
Mesh = new BoxMesh { Size = new Vector3(SizeMeters.X + 0.012f, SizeMeters.Y + 0.012f, 0.008f) },
|
||||
Position = new Vector3(0, 0, -0.0045f),
|
||||
CastShadow = GeometryInstance3D.ShadowCastingSetting.Off,
|
||||
};
|
||||
frame.SetSurfaceOverrideMaterial(0, frameMaterial);
|
||||
AddChild(frame);
|
||||
|
||||
// UI layer 2, mask 0: lasers/raycasts see it, props pass through it.
|
||||
Body = new StaticBody3D { Name = "PanelBody", CollisionLayer = 2, CollisionMask = 0 };
|
||||
Body.AddChild(new CollisionShape3D
|
||||
{
|
||||
Shape = new BoxShape3D { Size = new Vector3(SizeMeters.X, SizeMeters.Y, 0.02f) },
|
||||
Position = new Vector3(0, 0, -0.005f),
|
||||
});
|
||||
AddChild(Body);
|
||||
|
||||
for (int i = 0; i < 2; i++)
|
||||
{
|
||||
_dotMaterials[i] = new StandardMaterial3D
|
||||
{
|
||||
ShadingMode = BaseMaterial3D.ShadingModeEnum.Unshaded,
|
||||
AlbedoColor = Colors.White,
|
||||
NoDepthTest = true,
|
||||
RenderPriority = 1,
|
||||
};
|
||||
_dots[i] = new MeshInstance3D
|
||||
{
|
||||
Name = $"Cursor{i}",
|
||||
Mesh = new SphereMesh { Radius = 0.004f, Height = 0.008f, RadialSegments = 12, Rings = 6 },
|
||||
CastShadow = GeometryInstance3D.ShadowCastingSetting.Off,
|
||||
Visible = false,
|
||||
};
|
||||
_dots[i].SetSurfaceOverrideMaterial(0, _dotMaterials[i]);
|
||||
AddChild(_dots[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Call once per frame with both hands' input (index 0 = left, 1 = right).
|
||||
public void UpdatePointers(PointerInput[] inputs, double delta)
|
||||
{
|
||||
if (!Visible)
|
||||
{
|
||||
// Keep trigger edges current while hidden so a held trigger can't click on summon.
|
||||
for (int hand = 0; hand < 2 && hand < inputs.Length; hand++)
|
||||
_hands[hand].TriggerPrev = inputs[hand].Trigger;
|
||||
return;
|
||||
}
|
||||
|
||||
for (int hand = 0; hand < 2; hand++)
|
||||
Classify(hand, hand < inputs.Length ? inputs[hand] : default);
|
||||
|
||||
int owner = PickOwner();
|
||||
if (owner != _owner)
|
||||
{
|
||||
if (_owner >= 0 && _down)
|
||||
{
|
||||
SendButton(_lastSent, false);
|
||||
_down = false;
|
||||
}
|
||||
_owner = owner;
|
||||
_scrollAccum = 0f;
|
||||
}
|
||||
|
||||
if (_owner < 0)
|
||||
{
|
||||
if (_mouseInside)
|
||||
{
|
||||
Viewport.NotifyMouseExited();
|
||||
_mouseInside = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
HandState h = _hands[_owner];
|
||||
if (!_mouseInside)
|
||||
{
|
||||
Viewport.NotifyMouseEntered();
|
||||
_mouseInside = true;
|
||||
}
|
||||
if (h.Pixel != _lastSent)
|
||||
SendMotion(h.Pixel);
|
||||
int current = _owner;
|
||||
if (h.WantDown != _down)
|
||||
{
|
||||
_down = h.WantDown;
|
||||
SendButton(h.Pixel, _down);
|
||||
if (_down)
|
||||
PointerPressed?.Invoke(current, h.Mode);
|
||||
}
|
||||
// A UI handler may have reset us (ReleaseAll) during the injected event.
|
||||
if (_owner == current && current < inputs.Length)
|
||||
Scroll(inputs[current].Stick, h.Pixel, (float)delta);
|
||||
}
|
||||
|
||||
UpdateDots();
|
||||
}
|
||||
|
||||
private void Classify(int hand, PointerInput input)
|
||||
{
|
||||
HandState h = _hands[hand];
|
||||
PointerMode mode = PointerMode.None;
|
||||
bool wasOwnerDown = _owner == hand && _down;
|
||||
|
||||
if (input.Valid && input.Direction.LengthSquared() > 1e-6f)
|
||||
{
|
||||
Transform3D inv = GlobalTransform.AffineInverse();
|
||||
Vector3 from = inv * input.Origin;
|
||||
Vector3 dir = (inv.Basis * input.Direction).Normalized();
|
||||
Vector3 tip = from + dir * TipLength;
|
||||
float hx = SizeMeters.X * 0.5f, hy = SizeMeters.Y * 0.5f;
|
||||
|
||||
bool tipOver = Mathf.Abs(tip.X) <= hx + TouchEdgeMargin && Mathf.Abs(tip.Y) <= hy + TouchEdgeMargin;
|
||||
if (from.Z > 0f && tipOver && tip.Z <= HoverDepth && tip.Z >= -PushThroughDepth)
|
||||
{
|
||||
mode = PointerMode.Touch;
|
||||
h.Local = new Vector3(Mathf.Clamp(tip.X, -hx, hx), Mathf.Clamp(tip.Y, -hy, hy), 0f);
|
||||
h.Depth = tip.Z;
|
||||
h.RayDistance = 0f;
|
||||
}
|
||||
else if (from.Z > 0f && dir.Z < -1e-4f)
|
||||
{
|
||||
float t = -from.Z / dir.Z;
|
||||
Vector3 hit = from + dir * t;
|
||||
if (Mathf.Abs(hit.X) <= hx && Mathf.Abs(hit.Y) <= hy)
|
||||
{
|
||||
mode = PointerMode.Laser;
|
||||
h.Local = hit;
|
||||
h.Depth = float.MaxValue;
|
||||
h.RayDistance = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
h.Mode = mode;
|
||||
if (mode != PointerMode.None)
|
||||
{
|
||||
Vector2 px = LocalToPixel(h.Local);
|
||||
h.Pixel = new Vector2(
|
||||
Mathf.Clamp(px.X, 0f, SizePixels.X - 1),
|
||||
Mathf.Clamp(px.Y, 0f, SizePixels.Y - 1));
|
||||
}
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
case PointerMode.Touch:
|
||||
h.WantDown = wasOwnerDown ? h.Depth <= ReleaseDepth : h.Armed && h.Depth <= ContactDepth;
|
||||
break;
|
||||
case PointerMode.Laser:
|
||||
h.WantDown = wasOwnerDown ? input.Trigger : input.Trigger && !h.TriggerPrev;
|
||||
break;
|
||||
default:
|
||||
h.WantDown = false;
|
||||
break;
|
||||
}
|
||||
h.Armed = mode == PointerMode.Touch && h.Depth > ContactDepth;
|
||||
h.TriggerPrev = input.Trigger;
|
||||
_hands[hand] = h;
|
||||
}
|
||||
|
||||
private int PickOwner()
|
||||
{
|
||||
if (_owner >= 0 && _down && _hands[_owner].Mode != PointerMode.None)
|
||||
return _owner;
|
||||
int best = -1;
|
||||
for (int hand = 0; hand < 2; hand++)
|
||||
{
|
||||
if (_hands[hand].Mode != PointerMode.Touch)
|
||||
continue;
|
||||
if (best < 0 || _hands[hand].Depth < _hands[best].Depth)
|
||||
best = hand;
|
||||
}
|
||||
if (best >= 0)
|
||||
return best;
|
||||
if (_owner >= 0 && _hands[_owner].Mode == PointerMode.Laser)
|
||||
return _owner;
|
||||
for (int hand = 0; hand < 2; hand++)
|
||||
if (_hands[hand].Mode == PointerMode.Laser)
|
||||
return hand;
|
||||
return -1;
|
||||
}
|
||||
|
||||
private void Scroll(Vector2 stick, Vector2 pixel, float delta)
|
||||
{
|
||||
if (Mathf.Abs(stick.Y) < ScrollDeadzone)
|
||||
{
|
||||
_scrollAccum = 0f;
|
||||
return;
|
||||
}
|
||||
_scrollAccum += stick.Y * ScrollNotchesPerSecond * delta;
|
||||
while (Mathf.Abs(_scrollAccum) >= 1f)
|
||||
{
|
||||
bool up = _scrollAccum > 0f;
|
||||
_scrollAccum -= up ? 1f : -1f;
|
||||
SendWheel(pixel, up ? MouseButton.WheelUp : MouseButton.WheelDown);
|
||||
}
|
||||
}
|
||||
|
||||
public void SendWheel(Vector2 pixel, MouseButton wheel)
|
||||
{
|
||||
foreach (bool pressed in new[] { true, false })
|
||||
{
|
||||
Viewport.PushInput(new InputEventMouseButton
|
||||
{
|
||||
Position = pixel,
|
||||
GlobalPosition = pixel,
|
||||
ButtonIndex = wheel,
|
||||
Pressed = pressed,
|
||||
Factor = 1f,
|
||||
ButtonMask = _down ? MouseButtonMask.Left : 0,
|
||||
}, true);
|
||||
}
|
||||
}
|
||||
|
||||
private void SendMotion(Vector2 pixel)
|
||||
{
|
||||
Vector2 relative = _lastSent.X < 0 ? Vector2.Zero : pixel - _lastSent;
|
||||
Viewport.PushInput(new InputEventMouseMotion
|
||||
{
|
||||
Position = pixel,
|
||||
GlobalPosition = pixel,
|
||||
Relative = relative,
|
||||
ButtonMask = _down ? MouseButtonMask.Left : 0,
|
||||
}, true);
|
||||
_lastSent = pixel;
|
||||
}
|
||||
|
||||
private void SendButton(Vector2 pixel, bool pressed)
|
||||
{
|
||||
Viewport.PushInput(new InputEventMouseButton
|
||||
{
|
||||
Position = pixel,
|
||||
GlobalPosition = pixel,
|
||||
ButtonIndex = MouseButton.Left,
|
||||
Pressed = pressed,
|
||||
ButtonMask = pressed ? MouseButtonMask.Left : 0,
|
||||
}, true);
|
||||
_lastSent = pixel;
|
||||
}
|
||||
|
||||
private void UpdateDots()
|
||||
{
|
||||
for (int hand = 0; hand < 2; hand++)
|
||||
{
|
||||
HandState h = _hands[hand];
|
||||
MeshInstance3D dot = _dots[hand];
|
||||
dot.Visible = h.Mode != PointerMode.None;
|
||||
if (!dot.Visible)
|
||||
continue;
|
||||
bool pressing = _owner == hand && _down;
|
||||
float scale;
|
||||
Color color;
|
||||
if (h.Mode == PointerMode.Touch)
|
||||
{
|
||||
// Shrinks as the tip approaches the surface: a proximity cue for touch.
|
||||
float k = Mathf.Clamp(h.Depth / HoverDepth, 0f, 1f);
|
||||
scale = Mathf.Lerp(0.6f, 1.6f, k);
|
||||
color = pressing ? new Color(0.5f, 1f, 0.6f) : new Color(0.55f, 0.85f, 1f);
|
||||
}
|
||||
else
|
||||
{
|
||||
scale = 1f;
|
||||
color = pressing ? new Color(1f, 0.85f, 0.4f) : new Color(1f, 0.55f, 0.15f);
|
||||
}
|
||||
if (_owner != hand)
|
||||
color.A = 0.5f;
|
||||
_dotMaterials[hand].AlbedoColor = color;
|
||||
_dotMaterials[hand].Transparency = color.A < 1f
|
||||
? BaseMaterial3D.TransparencyEnum.Alpha
|
||||
: BaseMaterial3D.TransparencyEnum.Disabled;
|
||||
dot.Position = new Vector3(h.Local.X, h.Local.Y, 0.002f);
|
||||
dot.Scale = Vector3.One * scale;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
uid://cnjnswvcuecyf
|
||||
@@ -0,0 +1,258 @@
|
||||
using Godot;
|
||||
using System;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
// Headless regression for the in-VR menu (MenuScreen + MainMenu), no XR: drives simulated
|
||||
// controller rays at known controls and asserts the Godot UI reacted. Run:
|
||||
// godot-mono --headless --fixed-fps 90 --path . scenes/menu_spike.tscn
|
||||
// Must print "MENU: overall PASS".
|
||||
public partial class MenuSpike : Node3D
|
||||
{
|
||||
private partial class CalibrationStub : Node
|
||||
{
|
||||
public int Calls;
|
||||
public void Recalibrate() => Calls++;
|
||||
}
|
||||
|
||||
private MenuScreen _screen;
|
||||
private MainMenu _menu;
|
||||
private readonly MenuScreen.PointerInput[] _inputs = new MenuScreen.PointerInput[2];
|
||||
private int _spawn, _reset, _ping, _close, _clicks, _pressedEvents;
|
||||
private bool _allPass = true;
|
||||
|
||||
public override void _Ready()
|
||||
{
|
||||
_screen = new MenuScreen();
|
||||
AddChild(_screen);
|
||||
// Arbitrary, non-axis-aligned pose to exercise the plane math.
|
||||
_screen.GlobalTransform = new Transform3D(
|
||||
Basis.FromEuler(new Vector3(Mathf.DegToRad(-15f), Mathf.DegToRad(30f), 0f)),
|
||||
new Vector3(0.3f, 1.3f, -0.5f));
|
||||
_menu = new MainMenu();
|
||||
_screen.SetContent(_menu);
|
||||
_screen.SetActive(true);
|
||||
_screen.PointerPressed += (_, _) => _pressedEvents++;
|
||||
_menu.ReturnToSpawnRequested += () => _spawn++;
|
||||
_menu.ResetPropsRequested += () => _reset++;
|
||||
_menu.PingRequested += () => _ping++;
|
||||
_menu.CloseRequested += () => _close++;
|
||||
_menu.Clicked += () => _clicks++;
|
||||
GetTree().CreateTimer(30.0).Timeout += () =>
|
||||
{
|
||||
GD.Print("MENU: timeout — overall FAIL");
|
||||
GetTree().Quit(1);
|
||||
};
|
||||
Run();
|
||||
}
|
||||
|
||||
private void Check(string name, bool ok, string detail = "")
|
||||
{
|
||||
GD.Print($"MENU: {name} {detail} → {(ok ? "PASS" : "FAIL")}");
|
||||
_allPass &= ok;
|
||||
}
|
||||
|
||||
private async Task Frame(int count = 1)
|
||||
{
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
_screen.UpdatePointers(_inputs, 1.0 / 90.0);
|
||||
await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
|
||||
}
|
||||
}
|
||||
|
||||
private Vector2 Center(Control c) => c.GetGlobalRect().GetCenter();
|
||||
private Vector3 Normal => _screen.GlobalBasis.Z.Normalized();
|
||||
|
||||
private void SetHand(int hand, Vector3 origin, Vector3 dir, bool trigger = false, Vector2 stick = default) =>
|
||||
_inputs[hand] = new MenuScreen.PointerInput { Valid = true, Origin = origin, Direction = dir.Normalized(), Trigger = trigger, Stick = stick };
|
||||
|
||||
private void ClearHand(int hand) => _inputs[hand] = default;
|
||||
|
||||
// Stylus straight at the panel: tip depth d in front of the pixel (negative = pushed through).
|
||||
private void TipAt(int hand, Vector2 pixel, float depth)
|
||||
{
|
||||
Vector3 p = _screen.PixelToGlobal(pixel);
|
||||
SetHand(hand, p + Normal * (MenuScreen.TipLength + depth), -Normal);
|
||||
}
|
||||
|
||||
private async Task TouchPress(int hand, Vector2 pixel)
|
||||
{
|
||||
for (float d = 0.10f; d > -0.012f; d -= 0.004f)
|
||||
{
|
||||
TipAt(hand, pixel, d);
|
||||
await Frame();
|
||||
}
|
||||
for (float d = -0.012f; d < 0.08f; d += 0.006f)
|
||||
{
|
||||
TipAt(hand, pixel, d);
|
||||
await Frame();
|
||||
}
|
||||
ClearHand(hand);
|
||||
await Frame(3);
|
||||
}
|
||||
|
||||
// Laser from 0.8 m, off-axis, aimed at the pixel.
|
||||
private void LaserAt(int hand, Vector2 pixel, bool trigger, Vector2 stick = default)
|
||||
{
|
||||
Vector3 p = _screen.PixelToGlobal(pixel);
|
||||
Vector3 origin = p + Normal * 0.7f + _screen.GlobalBasis.X * 0.25f + Vector3.Up * 0.2f;
|
||||
SetHand(hand, origin, p - origin, trigger, stick);
|
||||
}
|
||||
|
||||
private async Task LaserClick(int hand, Vector2 pixel)
|
||||
{
|
||||
LaserAt(hand, pixel, false);
|
||||
await Frame(4);
|
||||
LaserAt(hand, pixel, true);
|
||||
await Frame(4);
|
||||
LaserAt(hand, pixel, false);
|
||||
await Frame(4);
|
||||
ClearHand(hand);
|
||||
await Frame(3);
|
||||
}
|
||||
|
||||
private Vector2 TabCenter(int index)
|
||||
{
|
||||
TabBar bar = _menu.Tabs.GetTabBar();
|
||||
Rect2 r = bar.GetTabRect(index);
|
||||
return bar.GetGlobalRect().Position + r.GetCenter();
|
||||
}
|
||||
|
||||
private async void Run()
|
||||
{
|
||||
await Frame(10); // layout
|
||||
|
||||
// Mapping sanity: pixel → world → local → pixel round trip.
|
||||
Vector2 probe = new(123f, 456f);
|
||||
Vector2 back = _screen.LocalToPixel(_screen.GlobalTransform.AffineInverse() * _screen.PixelToGlobal(probe));
|
||||
Check("pixel mapping round trip", back.DistanceTo(probe) < 0.01f, $"({back})");
|
||||
|
||||
// 1) Touch path, with the other hand idling as a laser on the panel (arbitration:
|
||||
// touch beats laser).
|
||||
Vector2 spawnPx = Center(_menu.ReturnToSpawnButton);
|
||||
LaserAt(0, new Vector2(800, 600), false);
|
||||
await Frame(3);
|
||||
Check("idle laser is laser mode", _screen.GetMode(0) == MenuScreen.PointerMode.Laser);
|
||||
bool sawHover = false, sawTouch = false;
|
||||
for (float d = 0.10f; d > -0.012f; d -= 0.004f)
|
||||
{
|
||||
TipAt(1, spawnPx, d);
|
||||
await Frame();
|
||||
sawTouch |= _screen.GetMode(1) == MenuScreen.PointerMode.Touch;
|
||||
sawHover |= _menu.ReturnToSpawnButton.IsHovered();
|
||||
}
|
||||
bool pressedWhileIn = _screen.IsPressing(1);
|
||||
for (float d = -0.012f; d < 0.08f; d += 0.006f)
|
||||
{
|
||||
TipAt(1, spawnPx, d);
|
||||
await Frame();
|
||||
}
|
||||
ClearHand(0);
|
||||
ClearHand(1);
|
||||
await Frame(3);
|
||||
Check("touch: tip mode + hover", sawTouch && sawHover, $"(touch={sawTouch}, hover={sawHover})");
|
||||
Check("touch: contact holds press", pressedWhileIn);
|
||||
Check("touch: Return to spawn fired once", _spawn == 1, $"(count={_spawn}, pressedEvents={_pressedEvents})");
|
||||
|
||||
// 2) Tip sweeping in sideways already behind the surface must NOT press.
|
||||
int before = _spawn;
|
||||
Vector2 offPanel = new(-60f, spawnPx.Y);
|
||||
for (int i = 0; i <= 30; i++)
|
||||
{
|
||||
Vector2 px = offPanel.Lerp(spawnPx, i / 30f);
|
||||
Vector3 p = _screen.GlobalTransform * new Vector3(
|
||||
(px.X / _screen.SizePixels.X - 0.5f) * _screen.SizeMeters.X,
|
||||
(0.5f - px.Y / _screen.SizePixels.Y) * _screen.SizeMeters.Y, 0f);
|
||||
SetHand(1, p + Normal * (MenuScreen.TipLength - 0.01f), -Normal);
|
||||
await Frame();
|
||||
}
|
||||
TipAt(1, spawnPx, 0.08f);
|
||||
await Frame(3);
|
||||
ClearHand(1);
|
||||
await Frame(3);
|
||||
Check("touch: side entry behind surface does not press", _spawn == before, $"(count={_spawn})");
|
||||
|
||||
// 3) Laser + trigger: switch to the World tab, then Reset props.
|
||||
await LaserClick(0, TabCenter(1));
|
||||
Check("laser: World tab selected", _menu.Tabs.CurrentTab == 1, $"(tab={_menu.Tabs.CurrentTab})");
|
||||
await Frame(2);
|
||||
Vector2 resetPx = Center(_menu.ResetPropsButton);
|
||||
LaserAt(0, resetPx, false);
|
||||
await Frame(2);
|
||||
bool laserDist = _screen.TryGetLaserDistance(0, out float dist) && dist > 0.5f && dist < 1.0f;
|
||||
Check("laser: distance reported", laserDist, $"({dist:F3} m)");
|
||||
await LaserClick(0, resetPx);
|
||||
Check("laser: Reset props fired once", _reset == 1, $"(count={_reset})");
|
||||
|
||||
// 4) Trigger already held when the laser arrives must not click.
|
||||
LaserAt(0, new Vector2(-200, -200), true); // off panel
|
||||
await Frame(3);
|
||||
LaserAt(0, Center(_menu.PingButton), true);
|
||||
await Frame(5);
|
||||
LaserAt(0, Center(_menu.PingButton), false);
|
||||
await Frame(3);
|
||||
ClearHand(0);
|
||||
await Frame(2);
|
||||
Check("laser: held trigger arriving does not click", _ping == 0, $"(count={_ping})");
|
||||
await LaserClick(0, Center(_menu.PingButton));
|
||||
Check("laser: Ping fired once", _ping == 1, $"(count={_ping})");
|
||||
|
||||
// 5) Touch a tab, then drag the slider with the laser (trigger held).
|
||||
await TouchPress(1, TabCenter(2));
|
||||
Check("touch: System tab selected", _menu.Tabs.CurrentTab == 2, $"(tab={_menu.Tabs.CurrentTab})");
|
||||
await Frame(2);
|
||||
Rect2 sr = _menu.ClickVolumeSlider.GetGlobalRect();
|
||||
double v0 = _menu.ClickVolumeSlider.Value;
|
||||
Vector2 grab = new(sr.Position.X + sr.Size.X * (float)(v0 / 100.0), sr.GetCenter().Y);
|
||||
LaserAt(0, grab, false);
|
||||
await Frame(3);
|
||||
LaserAt(0, grab, true);
|
||||
await Frame(3);
|
||||
for (int i = 1; i <= 20; i++)
|
||||
{
|
||||
LaserAt(0, grab.Lerp(new Vector2(sr.Position.X + 4f, grab.Y), i / 20f), true);
|
||||
await Frame();
|
||||
}
|
||||
LaserAt(0, new Vector2(sr.Position.X + 4f, grab.Y), false);
|
||||
await Frame(3);
|
||||
ClearHand(0);
|
||||
await Frame(2);
|
||||
double v1 = _menu.ClickVolumeSlider.Value;
|
||||
Check("laser: slider drag", v1 < v0 - 30, $"({v0} → {v1})");
|
||||
|
||||
// 6) Thumbstick scrolls the log while hovering it.
|
||||
for (int i = 0; i < 60; i++)
|
||||
_menu.Log($"log line {i}");
|
||||
await Frame(5);
|
||||
Vector2 logPx = Center(_menu.LogScroll);
|
||||
LaserAt(0, logPx, false, new Vector2(0, -1));
|
||||
await Frame(30);
|
||||
int scrolled = _menu.LogScroll.ScrollVertical;
|
||||
LaserAt(0, logPx, false, new Vector2(0, 1));
|
||||
await Frame(60);
|
||||
int scrolledBack = _menu.LogScroll.ScrollVertical;
|
||||
ClearHand(0);
|
||||
await Frame(2);
|
||||
Check("stick: scroll down then up", scrolled > 50 && scrolledBack < scrolled, $"({scrolled} → {scrolledBack})");
|
||||
|
||||
// 7) Recalibrate: disabled without a calibration node, enabled + calls it when present.
|
||||
await TouchPress(1, TabCenter(0));
|
||||
Check("Recalibrate disabled without group node", _menu.RecalibrateButton.Disabled);
|
||||
await TouchPress(1, Center(_menu.RecalibrateButton));
|
||||
CalibrationStub stub = new();
|
||||
AddChild(stub);
|
||||
stub.AddToGroup(MainMenu.CalibrationGroup);
|
||||
await Frame(40); // refresh runs at 4 Hz
|
||||
Check("Recalibrate enabled with group node", !_menu.RecalibrateButton.Disabled);
|
||||
await TouchPress(1, Center(_menu.RecalibrateButton));
|
||||
Check("touch: Recalibrate called once", stub.Calls == 1, $"(calls={stub.Calls})");
|
||||
|
||||
// 8) Header Close via touch.
|
||||
await TouchPress(1, Center(_menu.HeaderCloseButton));
|
||||
Check("touch: Close fired once", _close == 1, $"(count={_close})");
|
||||
Check("click feedback fired", _clicks >= 8, $"(clicks={_clicks})");
|
||||
|
||||
GD.Print($"MENU: overall {(_allPass ? "PASS" : "FAIL")}");
|
||||
GetTree().Quit(_allPass ? 0 : 1);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
uid://bybf7naa4ron3
|
||||
+123
-260
@@ -1,16 +1,18 @@
|
||||
using Godot;
|
||||
using System.Collections.Generic;
|
||||
|
||||
// The in-VR menu: a MenuScreen (Godot Control UI in a SubViewport on a thin 0.36x0.24 m
|
||||
// panel) showing MainMenu. This node is the XR glue: summon/dismiss with ax_button (A/X),
|
||||
// grip-drag (direct or along the laser), re-orient toward the head, feed both controllers'
|
||||
// pointer rays into the screen, click sound + haptics. PARENTED UNDER XROrigin3D (fixed in the
|
||||
// player's room; game locomotion carries it).
|
||||
public partial class WorldPanel : Node3D
|
||||
{
|
||||
private const float GripThreshold = 0.6f;
|
||||
private const float TriggerThreshold = 0.6f;
|
||||
private const float DirectGrabRadius = 0.45f;
|
||||
private const float TipHoverRadius = 0.07f;
|
||||
private const float PressContactDistance = 0.045f;
|
||||
private const ulong PressCooldownMs = 400;
|
||||
private const float TipLength = 0.12f;
|
||||
private const float RayLength = 50f;
|
||||
private const float SummonDistance = 0.3f;
|
||||
private const float HeadRecallDistance = 0.45f;
|
||||
private const float HeadRecallDrop = 0.12f;
|
||||
|
||||
private static WorldPanel _instance;
|
||||
|
||||
@@ -20,29 +22,17 @@ public partial class WorldPanel : Node3D
|
||||
private Locomotion _locomotion;
|
||||
private PropShop _propShop;
|
||||
private AudioStreamPlayer3D _click;
|
||||
private AudioStreamPlayer3D _ping;
|
||||
|
||||
private StaticBody3D _panelBody;
|
||||
|
||||
private struct Knob
|
||||
{
|
||||
public string Name;
|
||||
public Node3D Root;
|
||||
public MeshInstance3D Mesh;
|
||||
public StandardMaterial3D Material;
|
||||
public Callable Action;
|
||||
public ulong LastPressMs;
|
||||
}
|
||||
|
||||
private readonly List<Knob> _knobs = new();
|
||||
private MenuScreen _screen;
|
||||
private MainMenu _menu;
|
||||
|
||||
private readonly bool[] _dragging = new bool[2];
|
||||
private readonly bool[] _directDrag = new bool[2];
|
||||
private readonly float[] _laserDist = new float[2];
|
||||
private readonly Vector3[] _directOffset = new Vector3[2];
|
||||
private readonly bool[] _triggerPrev = new bool[2];
|
||||
private readonly bool[] _summonPrev = new bool[2];
|
||||
private readonly int[] _hover = new int[2] { -1, -1 };
|
||||
private readonly bool[] _hoverPanel = new bool[2];
|
||||
private readonly MenuScreen.PointerInput[] _inputs = new MenuScreen.PointerInput[2];
|
||||
|
||||
public override void _Ready()
|
||||
{
|
||||
@@ -52,9 +42,38 @@ public partial class WorldPanel : Node3D
|
||||
_camera = GetNode<XRCamera3D>("../XRCamera3D");
|
||||
_locomotion = GetNode<Locomotion>("../../Locomotion");
|
||||
_propShop = GetNode<PropShop>("../../PropShop");
|
||||
Visible = false;
|
||||
BuildPanel();
|
||||
BuildClickSound();
|
||||
|
||||
_screen = new MenuScreen { Name = "Screen" };
|
||||
AddChild(_screen);
|
||||
_menu = new MainMenu { Name = "MainMenu" };
|
||||
_screen.SetContent(_menu);
|
||||
_screen.PointerPressed += OnPointerPressed;
|
||||
|
||||
_menu.ReturnToSpawnRequested += () =>
|
||||
{
|
||||
_locomotion.ReturnToSpawn();
|
||||
ResetInteractionState();
|
||||
PlaceInFrontOfHead();
|
||||
_menu.Log("Returned to spawn");
|
||||
};
|
||||
_menu.ResetPropsRequested += () =>
|
||||
{
|
||||
_propShop.Respawn();
|
||||
_menu.Log("Props reset");
|
||||
};
|
||||
_menu.PingRequested += () =>
|
||||
{
|
||||
GD.Print("WorldPanel: ping");
|
||||
_ping.Play();
|
||||
_menu.Log("Ping");
|
||||
};
|
||||
_menu.CloseRequested += () => SetPanelActive(false);
|
||||
_menu.Clicked += () => _click.Play();
|
||||
|
||||
_click = MakeTone(900f, 25, 0.35f, 1f);
|
||||
_ping = MakeTone(1320f, 4, 0.3f, 3f);
|
||||
_menu.ClickVolumeSlider.ValueChanged += v => _click.VolumeDb = Mathf.LinearToDb((float)v / 70f);
|
||||
|
||||
SetPanelActive(false);
|
||||
}
|
||||
|
||||
@@ -64,16 +83,48 @@ public partial class WorldPanel : Node3D
|
||||
|
||||
public static bool IsPanelCollider(Node node) =>
|
||||
_instance != null && _instance.Visible && node != null &&
|
||||
(node.HasMeta("knob_index") || node == _instance._panelBody || node.GetParent() == _instance._panelBody);
|
||||
(node == _instance._screen.Body || node.GetParent() == _instance._screen.Body);
|
||||
|
||||
// Laser length to the menu for this controller, if the controller is currently using its
|
||||
// laser (not touch) on the menu. Locomotion.UpdatePointer draws the beam from this.
|
||||
public static bool TryGetLaserDistance(XRController3D controller, out float distance)
|
||||
{
|
||||
distance = 0f;
|
||||
if (_instance == null || !_instance.Visible)
|
||||
return false;
|
||||
int hand = controller == _instance._left ? 0 : controller == _instance._right ? 1 : -1;
|
||||
return hand >= 0 && _instance._screen.TryGetLaserDistance(hand, out distance);
|
||||
}
|
||||
|
||||
public override void _Process(double delta)
|
||||
{
|
||||
PollSummon(_left, 0);
|
||||
PollSummon(_right, 1);
|
||||
if (!Visible)
|
||||
return;
|
||||
UpdateHand(_left, 0);
|
||||
UpdateHand(_right, 1);
|
||||
if (Visible)
|
||||
{
|
||||
UpdateDrag(_left, 0);
|
||||
UpdateDrag(_right, 1);
|
||||
}
|
||||
_inputs[0] = ReadPointer(_left, 0);
|
||||
_inputs[1] = ReadPointer(_right, 1);
|
||||
_screen.UpdatePointers(_inputs, delta);
|
||||
}
|
||||
|
||||
private MenuScreen.PointerInput ReadPointer(XRController3D controller, int hand) => new()
|
||||
{
|
||||
// A hand dragging the panel doesn't also point at it.
|
||||
Valid = !_dragging[hand] && controller.GetIsActive(),
|
||||
Origin = controller.GlobalPosition,
|
||||
Direction = -controller.GlobalTransform.Basis.Z,
|
||||
Trigger = controller.GetFloat("trigger") > TriggerThreshold,
|
||||
Stick = controller.GetVector2("primary"),
|
||||
};
|
||||
|
||||
private void OnPointerPressed(int hand, MenuScreen.PointerMode mode)
|
||||
{
|
||||
XRController3D controller = hand == 0 ? _left : _right;
|
||||
// Short tick on contact: the "physical press" feel for the touch cursor.
|
||||
controller.TriggerHapticPulse("haptic", 0.0, mode == MenuScreen.PointerMode.Touch ? 0.35 : 0.2, 0.02, 0.0);
|
||||
}
|
||||
|
||||
private void PollSummon(XRController3D controller, int hand)
|
||||
@@ -91,173 +142,68 @@ public partial class WorldPanel : Node3D
|
||||
|
||||
private void SetPanelActive(bool active)
|
||||
{
|
||||
if (!active)
|
||||
ResetInteractionState();
|
||||
ResetInteractionState();
|
||||
Visible = active;
|
||||
SetShapesEnabled(this, active);
|
||||
}
|
||||
|
||||
private static void SetShapesEnabled(Node root, bool enabled)
|
||||
{
|
||||
foreach (Node child in root.GetChildren())
|
||||
{
|
||||
if (child is CollisionShape3D shape)
|
||||
shape.SetDeferred(CollisionShape3D.PropertyName.Disabled, !enabled);
|
||||
SetShapesEnabled(child, enabled);
|
||||
}
|
||||
_screen.SetActive(active);
|
||||
if (active)
|
||||
_menu.RefreshCalibration();
|
||||
}
|
||||
|
||||
private void PlaceInFrontOf(XRController3D controller) =>
|
||||
OrientTo(controller.GlobalPosition - controller.GlobalTransform.Basis.Z * 0.5f);
|
||||
OrientTo(controller.GlobalPosition - controller.GlobalTransform.Basis.Z * SummonDistance);
|
||||
|
||||
private void PlaceInFrontOfHead() =>
|
||||
OrientTo(_camera.GlobalPosition - _camera.GlobalTransform.Basis.Z * 0.5f);
|
||||
|
||||
private void OrientTo(Vector3 pos)
|
||||
private void PlaceInFrontOfHead()
|
||||
{
|
||||
Vector3 look = _camera.GlobalPosition - pos;
|
||||
Vector3 forward = -_camera.GlobalTransform.Basis.Z;
|
||||
forward.Y = 0f;
|
||||
forward = forward.LengthSquared() < 0.0001f ? Vector3.Forward : forward.Normalized();
|
||||
OrientTo(_camera.GlobalPosition + forward * HeadRecallDistance + Vector3.Down * HeadRecallDrop);
|
||||
}
|
||||
|
||||
private static Basis FacingBasis(Vector3 from, Vector3 head, out bool ok)
|
||||
{
|
||||
ok = false;
|
||||
Vector3 look = head - from;
|
||||
if (look.LengthSquared() < 0.0001f)
|
||||
return;
|
||||
return Basis.Identity;
|
||||
Vector3 zAxis = look.Normalized();
|
||||
Vector3 xAxis = Vector3.Up.Cross(zAxis);
|
||||
if (xAxis.LengthSquared() < 0.0001f)
|
||||
return;
|
||||
return Basis.Identity;
|
||||
xAxis = xAxis.Normalized();
|
||||
Vector3 yAxis = zAxis.Cross(xAxis).Normalized();
|
||||
GlobalTransform = new Transform3D(new Basis(xAxis, yAxis, zAxis), pos);
|
||||
ok = true;
|
||||
return new Basis(xAxis, yAxis, zAxis);
|
||||
}
|
||||
|
||||
private void OrientTo(Vector3 pos)
|
||||
{
|
||||
Basis basis = FacingBasis(pos, _camera.GlobalPosition, out bool ok);
|
||||
if (ok)
|
||||
GlobalTransform = new Transform3D(basis, pos);
|
||||
}
|
||||
|
||||
private void OrientTowardCamera()
|
||||
{
|
||||
Vector3 look = _camera.GlobalPosition - GlobalPosition;
|
||||
if (look.LengthSquared() < 0.0001f)
|
||||
return;
|
||||
Vector3 zAxis = look.Normalized();
|
||||
Vector3 xAxis = Vector3.Up.Cross(zAxis);
|
||||
if (xAxis.LengthSquared() < 0.0001f)
|
||||
return;
|
||||
xAxis = xAxis.Normalized();
|
||||
Vector3 yAxis = zAxis.Cross(xAxis).Normalized();
|
||||
GlobalBasis = GlobalBasis.Slerp(new Basis(xAxis, yAxis, zAxis), 0.35f).Orthonormalized();
|
||||
Basis basis = FacingBasis(GlobalPosition, _camera.GlobalPosition, out bool ok);
|
||||
if (ok)
|
||||
GlobalBasis = GlobalBasis.Slerp(basis, 0.35f).Orthonormalized();
|
||||
}
|
||||
|
||||
private void BuildPanel()
|
||||
{
|
||||
Node3D plate = new() { Name = "Plate" };
|
||||
AddChild(plate);
|
||||
|
||||
StandardMaterial3D plateMaterial = new()
|
||||
{
|
||||
AlbedoColor = new Color(0.08f, 0.09f, 0.12f),
|
||||
EmissionEnabled = true,
|
||||
Emission = new Color(0.1f, 0.2f, 0.35f),
|
||||
EmissionEnergyMultiplier = 0.4f,
|
||||
};
|
||||
MeshInstance3D plateMesh = new() { Mesh = new BoxMesh { Size = new Vector3(0.6f, 0.34f, 0.02f) } };
|
||||
plateMesh.SetSurfaceOverrideMaterial(0, plateMaterial);
|
||||
plate.AddChild(plateMesh);
|
||||
|
||||
_panelBody = new StaticBody3D
|
||||
{
|
||||
Name = "PanelBody",
|
||||
CollisionLayer = 2,
|
||||
CollisionMask = 0,
|
||||
};
|
||||
_panelBody.AddChild(new CollisionShape3D { Shape = new BoxShape3D { Size = new Vector3(0.6f, 0.34f, 0.06f) } });
|
||||
plate.AddChild(_panelBody);
|
||||
|
||||
Vector3[] positions =
|
||||
{
|
||||
new(-0.21f, 0.06f, 0.03f),
|
||||
new(-0.07f, 0.06f, 0.03f),
|
||||
new(0.07f, 0.06f, 0.03f),
|
||||
new(0.21f, 0.06f, 0.03f),
|
||||
};
|
||||
string[] names = { "Spawn", "Ping", "Reset", "Close" };
|
||||
Color[] colors =
|
||||
{
|
||||
new(0.25f, 0.6f, 1f),
|
||||
new(0.95f, 0.75f, 0.25f),
|
||||
new(0.2f, 0.8f, 0.35f),
|
||||
new(0.9f, 0.3f, 0.3f),
|
||||
};
|
||||
Callable[] actions =
|
||||
{
|
||||
Callable.From(() =>
|
||||
{
|
||||
_locomotion.ReturnToSpawn();
|
||||
ResetInteractionState();
|
||||
PlaceInFrontOfHead();
|
||||
}),
|
||||
Callable.From(Ping),
|
||||
Callable.From(() => _propShop.Respawn()),
|
||||
Callable.From(Close),
|
||||
};
|
||||
|
||||
for (int i = 0; i < names.Length; i++)
|
||||
{
|
||||
StandardMaterial3D material = new()
|
||||
{
|
||||
AlbedoColor = colors[i],
|
||||
EmissionEnabled = true,
|
||||
Emission = colors[i],
|
||||
EmissionEnergyMultiplier = 1.2f,
|
||||
};
|
||||
MeshInstance3D mesh = new()
|
||||
{
|
||||
Mesh = new CylinderMesh { TopRadius = 0.032f, BottomRadius = 0.032f, Height = 0.025f },
|
||||
RotationDegrees = new Vector3(90, 0, 0),
|
||||
};
|
||||
mesh.SetSurfaceOverrideMaterial(0, material);
|
||||
|
||||
StaticBody3D body = new()
|
||||
{
|
||||
CollisionLayer = 2,
|
||||
CollisionMask = 0,
|
||||
};
|
||||
body.SetMeta("knob_index", i);
|
||||
body.AddChild(new CollisionShape3D { Shape = new BoxShape3D { Size = new Vector3(0.09f, 0.09f, 0.06f) } });
|
||||
|
||||
Node3D root = new() { Position = positions[i] };
|
||||
root.AddChild(mesh);
|
||||
root.AddChild(body);
|
||||
|
||||
Label3D label = new()
|
||||
{
|
||||
Text = names[i],
|
||||
FontSize = 96,
|
||||
PixelSize = 0.00025f,
|
||||
OutlineSize = 6,
|
||||
Position = new Vector3(0, -0.08f, 0.015f),
|
||||
};
|
||||
root.AddChild(label);
|
||||
|
||||
plate.AddChild(root);
|
||||
_knobs.Add(new Knob
|
||||
{
|
||||
Name = names[i],
|
||||
Root = root,
|
||||
Mesh = mesh,
|
||||
Material = material,
|
||||
Action = actions[i],
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private void BuildClickSound()
|
||||
private AudioStreamPlayer3D MakeTone(float frequency, int durationDivisor, float amplitude, float decayPower)
|
||||
{
|
||||
const int rate = 44100;
|
||||
const int samples = rate / 25;
|
||||
int samples = rate / durationDivisor;
|
||||
byte[] data = new byte[samples * 2];
|
||||
for (int i = 0; i < samples; i++)
|
||||
{
|
||||
float envelope = 1f - (float)i / samples;
|
||||
float value = Mathf.Sin(Mathf.Tau * 900f * i / rate) * envelope * 0.35f;
|
||||
float envelope = Mathf.Pow(1f - (float)i / samples, decayPower);
|
||||
float value = Mathf.Sin(Mathf.Tau * frequency * i / rate) * envelope * amplitude;
|
||||
short sample = (short)(value * short.MaxValue);
|
||||
data[i * 2] = (byte)sample;
|
||||
data[i * 2 + 1] = (byte)(sample >> 8);
|
||||
}
|
||||
_click = new AudioStreamPlayer3D
|
||||
AudioStreamPlayer3D player = new()
|
||||
{
|
||||
Stream = new AudioStreamWav
|
||||
{
|
||||
@@ -267,23 +213,22 @@ public partial class WorldPanel : Node3D
|
||||
Data = data,
|
||||
},
|
||||
};
|
||||
AddChild(_click);
|
||||
AddChild(player);
|
||||
return player;
|
||||
}
|
||||
|
||||
private void UpdateHand(XRController3D controller, int hand)
|
||||
private void UpdateDrag(XRController3D controller, int hand)
|
||||
{
|
||||
Vector3 from = controller.GlobalPosition;
|
||||
Vector3 dir = -controller.GlobalTransform.Basis.Z;
|
||||
Vector3 tip = from + dir * TipLength;
|
||||
|
||||
UpdateHover(controller, hand, from, dir, tip);
|
||||
bool laserOnPanel = _screen.GetMode(hand) == MenuScreen.PointerMode.Laser;
|
||||
|
||||
bool grip = controller.GetFloat("grip") > GripThreshold
|
||||
&& !PropGrabber.IsGrabbing(controller);
|
||||
if (grip && !_dragging[hand] && (_hoverPanel[hand] || GlobalPosition.DistanceTo(from) < DirectGrabRadius))
|
||||
if (grip && !_dragging[hand] && (laserOnPanel || GlobalPosition.DistanceTo(from) < DirectGrabRadius))
|
||||
{
|
||||
_dragging[hand] = true;
|
||||
_directDrag[hand] = !_hoverPanel[hand];
|
||||
_directDrag[hand] = !laserOnPanel;
|
||||
if (_directDrag[hand])
|
||||
_directOffset[hand] = GlobalPosition - from;
|
||||
else
|
||||
@@ -303,94 +248,12 @@ public partial class WorldPanel : Node3D
|
||||
: from + dir * _laserDist[hand];
|
||||
OrientTowardCamera();
|
||||
}
|
||||
|
||||
bool trigger = controller.GetFloat("trigger") > TriggerThreshold;
|
||||
if (trigger && !_triggerPrev[hand] && _hover[hand] >= 0)
|
||||
Press(_hover[hand]);
|
||||
_triggerPrev[hand] = trigger;
|
||||
|
||||
if (_hover[hand] >= 0)
|
||||
{
|
||||
int hovered = _hover[hand];
|
||||
Knob knob = _knobs[hovered];
|
||||
if (knob.Root.GlobalPosition.DistanceTo(tip) < PressContactDistance)
|
||||
{
|
||||
ulong now = Time.GetTicksMsec();
|
||||
if (now - knob.LastPressMs > PressCooldownMs)
|
||||
{
|
||||
knob.LastPressMs = now;
|
||||
_knobs[hovered] = knob;
|
||||
Press(hovered);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void UpdateHover(XRController3D controller, int hand, Vector3 from, Vector3 dir, Vector3 tip)
|
||||
{
|
||||
int knob = -1;
|
||||
bool panel = false;
|
||||
|
||||
var query = PhysicsRayQueryParameters3D.Create(from, from + dir * RayLength);
|
||||
var hit = GetViewport().GetWorld3D().DirectSpaceState.IntersectRay(query);
|
||||
if (hit.TryGetValue("collider", out Variant collider) && collider.As<Node>() is Node node)
|
||||
{
|
||||
if (node.HasMeta("knob_index"))
|
||||
knob = (int)node.GetMeta("knob_index");
|
||||
else
|
||||
panel = IsPanelCollider(node) || node.GetParent() == _panelBody;
|
||||
}
|
||||
|
||||
if (knob < 0)
|
||||
{
|
||||
for (int i = 0; i < _knobs.Count; i++)
|
||||
{
|
||||
if (_knobs[i].Root.GlobalPosition.DistanceTo(tip) < TipHoverRadius)
|
||||
{
|
||||
knob = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (knob != _hover[hand])
|
||||
{
|
||||
if (_hover[hand] >= 0)
|
||||
_knobs[_hover[hand]].Material.EmissionEnergyMultiplier = 1.2f;
|
||||
_hover[hand] = knob;
|
||||
if (knob >= 0)
|
||||
_knobs[knob].Material.EmissionEnergyMultiplier = 2.8f;
|
||||
}
|
||||
_hoverPanel[hand] = panel;
|
||||
}
|
||||
|
||||
private void Press(int index)
|
||||
{
|
||||
Knob knob = _knobs[index];
|
||||
GD.Print($"WorldPanel: pressed '{knob.Name}'");
|
||||
_click.Play();
|
||||
Tween tween = CreateTween();
|
||||
tween.TweenProperty(knob.Mesh, "position:z", -0.014f, 0.05);
|
||||
tween.Parallel().TweenProperty(knob.Material, "emission_energy_multiplier", 4.0f, 0.05);
|
||||
tween.TweenProperty(knob.Mesh, "position:z", 0f, 0.12);
|
||||
tween.Parallel().TweenProperty(knob.Material, "emission_energy_multiplier", 1.2f, 0.3);
|
||||
knob.Action.Call();
|
||||
}
|
||||
|
||||
private void Ping() => GD.Print("WorldPanel: ping");
|
||||
|
||||
private void Close() => SetPanelActive(false);
|
||||
|
||||
private void ResetInteractionState()
|
||||
{
|
||||
for (int hand = 0; hand < 2; hand++)
|
||||
{
|
||||
_dragging[hand] = false;
|
||||
_hoverPanel[hand] = false;
|
||||
_triggerPrev[hand] = false;
|
||||
if (_hover[hand] >= 0)
|
||||
_knobs[_hover[hand]].Material.EmissionEnergyMultiplier = 1.2f;
|
||||
_hover[hand] = -1;
|
||||
}
|
||||
_screen?.ReleaseAll();
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user