495 lines
18 KiB
C#
495 lines
18 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Core;
|
|
using Core.Lifecycle;
|
|
using AppleHills.Core;
|
|
|
|
namespace UI.Tracking
|
|
{
|
|
/// <summary>
|
|
/// Singleton manager that tracks off-screen targets and displays directional pins.
|
|
/// Uses ManagedBehaviour pattern and lazily accesses camera via QuickAccess (like AudioManager).
|
|
/// </summary>
|
|
public class OffScreenTrackerManager : ManagedBehaviour
|
|
{
|
|
[Header("Configuration")]
|
|
[Tooltip("Prefab for the off-screen tracking pin")]
|
|
[SerializeField] private OffScreenPin pinPrefab;
|
|
|
|
[Tooltip("Pixel padding from screen edges (pins appear this many pixels from edge)")]
|
|
[SerializeField] private float screenPadding = 50f;
|
|
|
|
[Tooltip("Buffer zone in pixels to prevent spawn/despawn flickering (spawn is stricter than despawn)")]
|
|
[SerializeField] private float bufferZone = 100f;
|
|
|
|
[Tooltip("Time in seconds a target must be off-screen before pin appears")]
|
|
[SerializeField] private float spawnDebounceDelay = 0.3f;
|
|
|
|
[Tooltip("Time in seconds a target must be on-screen before pin disappears")]
|
|
[SerializeField] private float despawnDebounceDelay = 0.2f;
|
|
|
|
[Tooltip("Update interval in seconds for checking target visibility")]
|
|
[SerializeField] private float updateInterval = 0.1f;
|
|
|
|
// Singleton instance
|
|
private static OffScreenTrackerManager _instance;
|
|
public static OffScreenTrackerManager Instance => _instance;
|
|
|
|
// Tracking data
|
|
private Dictionary<TrackableTarget, TargetTrackingData> _trackedTargets = new Dictionary<TrackableTarget, TargetTrackingData>();
|
|
|
|
// Pin pooling
|
|
private List<OffScreenPin> _inactivePins = new List<OffScreenPin>();
|
|
|
|
// Coroutine tracking
|
|
private Coroutine _updateCoroutine;
|
|
|
|
// Auto-created canvas for pins
|
|
private Canvas _pinCanvas;
|
|
private RectTransform _pinContainer;
|
|
|
|
/// <summary>
|
|
/// Nested class to track per-target state and timers
|
|
/// </summary>
|
|
private class TargetTrackingData
|
|
{
|
|
public TrackableTarget Target;
|
|
public OffScreenPin ActivePin;
|
|
public float OffScreenTimer;
|
|
public float OnScreenTimer;
|
|
public bool IsCurrentlyOffScreen;
|
|
|
|
public TargetTrackingData(TrackableTarget target)
|
|
{
|
|
Target = target;
|
|
ActivePin = null;
|
|
OffScreenTimer = 0f;
|
|
OnScreenTimer = 0f;
|
|
IsCurrentlyOffScreen = false;
|
|
}
|
|
}
|
|
|
|
internal override void OnManagedAwake()
|
|
{
|
|
// Set singleton instance
|
|
_instance = this;
|
|
}
|
|
|
|
internal override void OnManagedStart()
|
|
{
|
|
// Validate configuration
|
|
if (pinPrefab == null)
|
|
{
|
|
Logging.Error("[OffScreenTrackerManager] Pin prefab not assigned!");
|
|
return;
|
|
}
|
|
|
|
// Create dedicated canvas for pins
|
|
CreatePinCanvas();
|
|
|
|
// Subscribe to scene load events from SceneManagerService (like InputManager does)
|
|
// This must happen in ManagedStart because SceneManagerService instance needs to be set first
|
|
if (SceneManagerService.Instance != null)
|
|
{
|
|
SceneManagerService.Instance.SceneLoadCompleted += OnSceneLoadCompleted;
|
|
Logging.Debug("[OffScreenTrackerManager] Subscribed to SceneLoadCompleted events");
|
|
}
|
|
|
|
// Initialize for current scene and start coroutine
|
|
InitializeForCurrentScene();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when any scene finishes loading. Refreshes camera and restarts coroutine.
|
|
/// </summary>
|
|
private void OnSceneLoadCompleted(string sceneName)
|
|
{
|
|
Logging.Debug($"[OffScreenTrackerManager] Scene loaded: {sceneName}, reinitializing camera and coroutine");
|
|
InitializeForCurrentScene();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize camera reference and start/restart tracking coroutine for current scene
|
|
/// </summary>
|
|
private void InitializeForCurrentScene()
|
|
{
|
|
// Stop existing coroutine if running
|
|
if (_updateCoroutine != null)
|
|
{
|
|
StopCoroutine(_updateCoroutine);
|
|
_updateCoroutine = null;
|
|
Logging.Debug("[OffScreenTrackerManager] Stopped previous coroutine");
|
|
}
|
|
|
|
// Start the tracking coroutine (camera accessed lazily via QuickAccess)
|
|
_updateCoroutine = StartCoroutine(UpdateTrackingCoroutine());
|
|
Logging.Debug("[OffScreenTrackerManager] Started tracking coroutine");
|
|
}
|
|
|
|
internal override void OnManagedDestroy()
|
|
{
|
|
// Unsubscribe from SceneManagerService events (like InputManager does)
|
|
if (SceneManagerService.Instance != null)
|
|
{
|
|
SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;
|
|
}
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
// Stop coroutine
|
|
if (_updateCoroutine != null)
|
|
{
|
|
StopCoroutine(_updateCoroutine);
|
|
}
|
|
|
|
// Clean up pooled pins
|
|
foreach (var pin in _inactivePins)
|
|
{
|
|
if (pin != null)
|
|
{
|
|
Destroy(pin.gameObject);
|
|
}
|
|
}
|
|
_inactivePins.Clear();
|
|
|
|
// Clean up active pins
|
|
foreach (var data in _trackedTargets.Values)
|
|
{
|
|
if (data.ActivePin != null)
|
|
{
|
|
Destroy(data.ActivePin.gameObject);
|
|
}
|
|
}
|
|
_trackedTargets.Clear();
|
|
|
|
// Clean up canvas
|
|
if (_pinCanvas != null)
|
|
{
|
|
Destroy(_pinCanvas.gameObject);
|
|
}
|
|
|
|
// Clear singleton
|
|
if (_instance == this)
|
|
{
|
|
_instance = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a dedicated canvas for pins with sort order 50
|
|
/// </summary>
|
|
private void CreatePinCanvas()
|
|
{
|
|
// Create a new GameObject for the canvas
|
|
GameObject canvasObj = new GameObject("OffScreenPinCanvas");
|
|
canvasObj.transform.SetParent(transform, false);
|
|
|
|
// Add and configure Canvas
|
|
_pinCanvas = canvasObj.AddComponent<Canvas>();
|
|
_pinCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
|
|
_pinCanvas.sortingOrder = 50;
|
|
|
|
// Add CanvasScaler for consistent sizing
|
|
var scaler = canvasObj.AddComponent<UnityEngine.UI.CanvasScaler>();
|
|
scaler.uiScaleMode = UnityEngine.UI.CanvasScaler.ScaleMode.ScaleWithScreenSize;
|
|
scaler.referenceResolution = new Vector2(1920, 1080);
|
|
scaler.screenMatchMode = UnityEngine.UI.CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
|
|
scaler.matchWidthOrHeight = 0.5f;
|
|
|
|
// Add GraphicRaycaster (required for UI)
|
|
canvasObj.AddComponent<UnityEngine.UI.GraphicRaycaster>();
|
|
|
|
// Get RectTransform for pin container
|
|
_pinContainer = canvasObj.GetComponent<RectTransform>();
|
|
|
|
Logging.Debug("[OffScreenTrackerManager] Created dedicated pin canvas with sort order 50");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register a target for tracking
|
|
/// </summary>
|
|
public void RegisterTarget(TrackableTarget target)
|
|
{
|
|
if (target == null)
|
|
return;
|
|
|
|
if (_trackedTargets.ContainsKey(target))
|
|
{
|
|
Logging.Warning($"[OffScreenTrackerManager] Target {target.name} is already registered");
|
|
return;
|
|
}
|
|
|
|
_trackedTargets.Add(target, new TargetTrackingData(target));
|
|
Logging.Debug($"[OffScreenTrackerManager] Registered target: {target.name}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unregister a target from tracking
|
|
/// </summary>
|
|
public void UnregisterTarget(TrackableTarget target)
|
|
{
|
|
if (target == null)
|
|
return;
|
|
|
|
if (_trackedTargets.TryGetValue(target, out TargetTrackingData data))
|
|
{
|
|
// Despawn pin if active
|
|
if (data.ActivePin != null)
|
|
{
|
|
DespawnPin(data);
|
|
}
|
|
|
|
_trackedTargets.Remove(target);
|
|
Logging.Debug($"[OffScreenTrackerManager] Unregistered target: {target.name}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Main update coroutine that runs every updateInterval seconds
|
|
/// </summary>
|
|
private IEnumerator UpdateTrackingCoroutine()
|
|
{
|
|
Logging.Debug("[OffScreenTrackerManager] Tracking coroutine started");
|
|
WaitForSeconds wait = new WaitForSeconds(updateInterval);
|
|
|
|
while (true)
|
|
{
|
|
yield return wait;
|
|
|
|
// Get camera lazily via QuickAccess (like AudioManager does)
|
|
Camera mainCamera = QuickAccess.Instance?.MainCamera;
|
|
|
|
if (mainCamera == null)
|
|
{
|
|
// Camera not available yet (early in boot or scene transition)
|
|
continue;
|
|
}
|
|
|
|
// Create list of targets to remove (for null cleanup)
|
|
List<TrackableTarget> targetsToRemove = new List<TrackableTarget>();
|
|
|
|
foreach (var kvp in _trackedTargets)
|
|
{
|
|
TrackableTarget target = kvp.Key;
|
|
TargetTrackingData data = kvp.Value;
|
|
|
|
// Check if target was destroyed
|
|
if (target == null)
|
|
{
|
|
targetsToRemove.Add(target);
|
|
if (data.ActivePin != null)
|
|
{
|
|
DespawnPin(data);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Check if target is off-screen
|
|
bool isOffScreen = IsTargetOffScreen(target, mainCamera);
|
|
|
|
// Update timers and state
|
|
if (isOffScreen)
|
|
{
|
|
// Target is off-screen
|
|
data.OffScreenTimer += updateInterval;
|
|
data.OnScreenTimer = 0f;
|
|
|
|
// Check if we should spawn a pin
|
|
if (!data.IsCurrentlyOffScreen && data.OffScreenTimer >= spawnDebounceDelay)
|
|
{
|
|
data.IsCurrentlyOffScreen = true;
|
|
SpawnPin(data);
|
|
}
|
|
// Pin updates itself every frame, no need to call UpdatePositionAndRotation here
|
|
}
|
|
else
|
|
{
|
|
// Target is on-screen
|
|
data.OnScreenTimer += updateInterval;
|
|
data.OffScreenTimer = 0f;
|
|
|
|
// Check if we should despawn the pin
|
|
if (data.IsCurrentlyOffScreen && data.OnScreenTimer >= despawnDebounceDelay)
|
|
{
|
|
data.IsCurrentlyOffScreen = false;
|
|
if (data.ActivePin != null)
|
|
{
|
|
DespawnPin(data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Clean up null targets
|
|
foreach (var target in targetsToRemove)
|
|
{
|
|
_trackedTargets.Remove(target);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check if a target is off-screen by checking its actual bounds.
|
|
/// - For SPAWNING: Entire object must be off-screen (all corners outside viewport)
|
|
/// - For DESPAWNING: Any part of object on-screen triggers despawn (any corner inside viewport)
|
|
/// Uses bufferZone to prevent flickering at boundaries.
|
|
/// </summary>
|
|
private bool IsTargetOffScreen(TrackableTarget target, Camera cam)
|
|
{
|
|
// Get the world bounds of the target
|
|
Bounds worldBounds = target.GetWorldBounds();
|
|
|
|
// Get the 8 corners of the bounds (we only need the min/max points in 2D)
|
|
Vector3 min = worldBounds.min;
|
|
Vector3 max = worldBounds.max;
|
|
|
|
// Convert corners to screen space
|
|
Vector3 minScreen = cam.WorldToScreenPoint(new Vector3(min.x, min.y, worldBounds.center.z));
|
|
Vector3 maxScreen = cam.WorldToScreenPoint(new Vector3(max.x, max.y, worldBounds.center.z));
|
|
|
|
// Check if behind camera
|
|
if (minScreen.z < 0 && maxScreen.z < 0)
|
|
return true;
|
|
|
|
// Shrink detection zones to 80% of screen (10% inset on each side)
|
|
// This makes spawn/despawn more conservative
|
|
float insetPercent = 0.1f; // 10% on each side = 80% total
|
|
float horizontalInset = Screen.width * insetPercent;
|
|
float verticalInset = Screen.height * insetPercent;
|
|
|
|
float screenLeft = horizontalInset;
|
|
float screenRight = Screen.width - horizontalInset;
|
|
float screenBottom = verticalInset;
|
|
float screenTop = Screen.height - verticalInset;
|
|
|
|
// Check if ENTIRELY off-screen (all corners outside viewport)
|
|
// This is when we should spawn the pin
|
|
bool entirelyOffScreenLeft = maxScreen.x < screenLeft;
|
|
bool entirelyOffScreenRight = minScreen.x > screenRight;
|
|
bool entirelyOffScreenBottom = maxScreen.y < screenBottom;
|
|
bool entirelyOffScreenTop = minScreen.y > screenTop;
|
|
|
|
bool entirelyOffScreen = entirelyOffScreenLeft || entirelyOffScreenRight ||
|
|
entirelyOffScreenBottom || entirelyOffScreenTop;
|
|
|
|
// Apply buffer zone to prevent flickering
|
|
// If already off-screen, require target to move bufferZone pixels on-screen before considering it "on-screen"
|
|
// This creates hysteresis to prevent rapid spawn/despawn cycles
|
|
if (entirelyOffScreen)
|
|
{
|
|
return true; // Definitely off-screen
|
|
}
|
|
|
|
// Check if ANY part is on-screen (for despawn logic)
|
|
// We add bufferZone to make despawn slightly more eager
|
|
bool anyPartOnScreen = !(minScreen.x > screenRight - bufferZone ||
|
|
maxScreen.x < screenLeft + bufferZone ||
|
|
minScreen.y > screenTop - bufferZone ||
|
|
maxScreen.y < screenBottom + bufferZone);
|
|
|
|
// If any part is on-screen (with buffer), consider it "on-screen" (pin should despawn)
|
|
return !anyPartOnScreen;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spawn a pin for the given target data
|
|
/// </summary>
|
|
private void SpawnPin(TargetTrackingData data)
|
|
{
|
|
// Try to get pin from pool
|
|
OffScreenPin pin = GetPinFromPool();
|
|
|
|
// Initialize the pin (this also caches the target and settings)
|
|
pin.Initialize(data.Target, screenPadding);
|
|
|
|
// CRITICAL: Update position BEFORE activating to prevent flicker
|
|
// Get camera for immediate position update
|
|
Camera mainCamera = QuickAccess.Instance?.MainCamera;
|
|
if (mainCamera != null)
|
|
{
|
|
pin.UpdatePositionAndRotation(mainCamera, screenPadding);
|
|
}
|
|
|
|
// Now activate the pin at the correct position
|
|
pin.gameObject.SetActive(true);
|
|
|
|
|
|
data.ActivePin = pin;
|
|
|
|
Logging.Debug($"[OffScreenTrackerManager] Spawned pin for target: {data.Target.name}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Despawn a pin and return it to the pool
|
|
/// </summary>
|
|
private void DespawnPin(TargetTrackingData data)
|
|
{
|
|
if (data.ActivePin == null)
|
|
return;
|
|
|
|
OffScreenPin pin = data.ActivePin;
|
|
data.ActivePin = null;
|
|
|
|
// Reset and return to pool
|
|
pin.ResetPin();
|
|
pin.gameObject.SetActive(false);
|
|
_inactivePins.Add(pin);
|
|
|
|
Logging.Debug($"[OffScreenTrackerManager] Despawned pin for target: {data.Target?.name ?? "null"}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a pin from the pool or instantiate a new one
|
|
/// </summary>
|
|
private OffScreenPin GetPinFromPool()
|
|
{
|
|
// Try to reuse an inactive pin
|
|
if (_inactivePins.Count > 0)
|
|
{
|
|
OffScreenPin pin = _inactivePins[_inactivePins.Count - 1];
|
|
_inactivePins.RemoveAt(_inactivePins.Count - 1);
|
|
return pin;
|
|
}
|
|
|
|
// Create a new pin
|
|
OffScreenPin newPin = Instantiate(pinPrefab, _pinContainer);
|
|
newPin.gameObject.SetActive(false);
|
|
return newPin;
|
|
}
|
|
|
|
#region Public Configuration Accessors
|
|
|
|
/// <summary>
|
|
/// Get or set the screen padding in pixels
|
|
/// </summary>
|
|
public float ScreenPadding
|
|
{
|
|
get => screenPadding;
|
|
set => screenPadding = Mathf.Max(0f, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get or set the spawn debounce delay
|
|
/// </summary>
|
|
public float SpawnDebounceDelay
|
|
{
|
|
get => spawnDebounceDelay;
|
|
set => spawnDebounceDelay = Mathf.Max(0f, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get or set the despawn debounce delay
|
|
/// </summary>
|
|
public float DespawnDebounceDelay
|
|
{
|
|
get => despawnDebounceDelay;
|
|
set => despawnDebounceDelay = Mathf.Max(0f, value);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|