Add a system for setting up "real" camera framing to work between devices (#26)

- In-level authoring utility to designate level bounds
- Camera Adapter component to be placed on a level's camera to perform the adjustments
- EdgeAnchor tool, which allows anchoring of game objects to the screen bounds

Co-authored-by: Michal Pikulski <michal@foolhardyhorizons.com>
Reviewed-on: #26

Assets/Scripts/AppleHillsCamera/ScreenReferenceMarker.cs

@@ -0,0 +1,142 @@
+using UnityEngine;
+
+namespace AppleHillsCamera
+{
+    /// <summary>
+    /// Defines reference sizes and distances for screen adaptation.
+    /// Used by CameraScreenAdapter and EdgeAnchor components.
+    /// </summary>
+    public class ScreenReferenceMarker : MonoBehaviour
+    {
+        [Header("Horizontal Reference")]
+        [Tooltip("The target width that should match the screen width")]
+        public float targetWidth = 10f;
+
+        [Header("Vertical References")]
+        [Tooltip("Distance from top of screen to use for anchoring")]
+        public float topMargin = 1f;
+        
+        [Tooltip("Distance from bottom of screen to use for anchoring")]
+        public float bottomMargin = 1f;
+        
+        [Tooltip("Distance from left of screen to use for anchoring")]
+        public float leftMargin = 1f;
+        
+        [Tooltip("Distance from right of screen to use for anchoring")]
+        public float rightMargin = 1f;
+
+        [Header("Visualization")]
+        [Tooltip("Color to use for gizmo visualization")]
+        public Color gizmoColor = new Color(0f, 1f, 0f, 0.5f);
+        
+        [Tooltip("Color to use for screen edge visualization")]
+        public Color screenEdgeColor = new Color(1f, 1f, 0f, 0.3f);
+        
+        [Tooltip("Show the vertical margins in scene view")]
+        public bool showVerticalMargins = true;
+        
+        [Tooltip("Show the horizontal margins in scene view")]
+        public bool showHorizontalMargins = true;
+
+#if UNITY_EDITOR
+        private void OnDrawGizmos()
+        {
+            // Save original color
+            Color originalColor = Gizmos.color;
+            
+            // Set the color for our gizmos
+            Gizmos.color = gizmoColor;
+            
+            Vector3 position = transform.position;
+            
+            // Draw the width reference
+            Vector3 left = position + Vector3.left * (targetWidth / 2f);
+            Vector3 right = position + Vector3.right * (targetWidth / 2f);
+            Gizmos.DrawLine(left, right);
+            
+            // Draw vertical endpoints
+            float endCapSize = 0.5f;
+            Gizmos.DrawLine(left, left + Vector3.up * endCapSize);
+            Gizmos.DrawLine(left, left + Vector3.down * endCapSize);
+            Gizmos.DrawLine(right, right + Vector3.up * endCapSize);
+            Gizmos.DrawLine(right, right + Vector3.down * endCapSize);
+            
+            // Calculate visual screen edges based on actual camera viewport
+            float halfWidth = targetWidth / 2f;
+            float halfHeight;
+            
+            // Try to get camera references in the preferred order
+            
+            // 1. Try to find the main camera in the scene (highest priority)
+            Camera mainCamera = Camera.main;
+            if (mainCamera != null && mainCamera.orthographic)
+            {
+                // Use the main camera's actual orthographic size for the height
+                halfHeight = mainCamera.orthographicSize;
+            }
+            else
+            {
+                // 2. Use Game/Simulator window resolution
+                float gameViewAspect = (float)Screen.height / Screen.width;
+                halfHeight = halfWidth * gameViewAspect;
+                
+                // 3. Fallback to the scene view camera if needed
+                UnityEditor.SceneView sceneView = UnityEditor.SceneView.lastActiveSceneView;
+                if (sceneView != null && sceneView.camera != null && sceneView.camera.orthographic)
+                {
+                    // Use the scene view camera's aspect ratio instead
+                    float sceneAspect = sceneView.camera.pixelHeight / (float)sceneView.camera.pixelWidth;
+                    halfHeight = halfWidth * sceneAspect;
+                }
+            }
+            
+            // Screen edge positions
+            Vector3 topEdge = position + Vector3.up * halfHeight;
+            Vector3 bottomEdge = position + Vector3.down * halfHeight;
+            Vector3 leftEdge = position + Vector3.left * halfWidth;
+            Vector3 rightEdge = position + Vector3.right * halfWidth;
+            
+            // Draw screen edges with yellow color
+            Gizmos.color = screenEdgeColor;
+            
+            // Draw full screen rectangle
+            Gizmos.DrawLine(leftEdge + Vector3.up * halfHeight, rightEdge + Vector3.up * halfHeight); // Top edge
+            Gizmos.DrawLine(leftEdge + Vector3.down * halfHeight, rightEdge + Vector3.down * halfHeight); // Bottom edge
+            Gizmos.DrawLine(leftEdge + Vector3.up * halfHeight, leftEdge + Vector3.down * halfHeight); // Left edge
+            Gizmos.DrawLine(rightEdge + Vector3.up * halfHeight, rightEdge + Vector3.down * halfHeight); // Right edge
+            
+            // Draw margin references if enabled
+            Gizmos.color = gizmoColor;
+            
+            if (showVerticalMargins)
+            {
+                // Top margin (distance from top edge)
+                Gizmos.DrawLine(
+                    topEdge + Vector3.down * topMargin + Vector3.left * (targetWidth / 4f), 
+                    topEdge + Vector3.down * topMargin + Vector3.right * (targetWidth / 4f));
+                
+                // Bottom margin (distance from bottom edge)
+                Gizmos.DrawLine(
+                    bottomEdge + Vector3.up * bottomMargin + Vector3.left * (targetWidth / 4f),
+                    bottomEdge + Vector3.up * bottomMargin + Vector3.right * (targetWidth / 4f));
+            }
+            
+            if (showHorizontalMargins)
+            {
+                // Left margin (distance from left edge)
+                Gizmos.DrawLine(
+                    leftEdge + Vector3.right * leftMargin + Vector3.up * (halfHeight / 2f),
+                    leftEdge + Vector3.right * leftMargin + Vector3.down * (halfHeight / 2f));
+                
+                // Right margin (distance from right edge)
+                Gizmos.DrawLine(
+                    rightEdge + Vector3.left * rightMargin + Vector3.up * (halfHeight / 2f),
+                    rightEdge + Vector3.left * rightMargin + Vector3.down * (halfHeight / 2f));
+            }
+            
+            // Restore original color
+            Gizmos.color = originalColor;
+        }
+#endif
+    }
+}