2026-06-11 기본 매니저 구성

Assets/02_Scripts/ISceneInitializable.cs

@@ -0,0 +1,6 @@
+using UnityEngine;
+
+public interface ISceneInitializable
+{
+    public void OnSceneLoaded();
+}

Assets/02_Scripts/ISceneInitializable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bcdbb0f5d9b20b248a68735a72da71e4

Assets/02_Scripts/Managers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ed45df9bef7ca3c41876538192c8458d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/02_Scripts/Managers/GameManager.cs

@@ -0,0 +1,24 @@
+using UnityEngine;
+
+public class GameManager : MonoBehaviour,ISceneInitializable
+{
+    public static GameManager Instance;
+
+    private void Awake()
+    {
+        if (Instance == null)
+        {
+            Instance = this; //만들어진 자신을 인스턴스로 설정
+            DontDestroyOnLoad(gameObject);
+        }
+        else
+        {
+            Destroy(gameObject); //이미 인스턴스가 있으면 자신을 파괴
+        }
+    }
+
+    public void OnSceneLoaded()
+    { 
+
+    }
+}

Assets/02_Scripts/Managers/GameManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 80bc92795d0805849afa6755063fb9d5

Assets/02_Scripts/Managers/InputManager.cs

@@ -0,0 +1,42 @@
+using System;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+public class InputManager : MonoBehaviour, GameInput.IPlayerActions
+{
+    // 외부에서 InputManager.Instance.OnXxx_Event += handler 형태로 구독.
+    public static InputManager Instance { get; private set; }
+
+    private GameInput _input;
+
+    // ─── 입력 이벤트들 (PlayerController 등이 구독) ──────────────────────
+    public event Action OnJump_Event;             // 한 번씩 (눌렀을 때)
+
+    private void Awake()
+    {
+        if (Instance == null)
+        {
+            Instance = this; //만들어진 자신을 인스턴스로 설정
+            DontDestroyOnLoad(gameObject);
+        }
+        else
+        {
+            Destroy(gameObject); //이미 인스턴스가 있으면 자신을 파괴
+        }
+
+        _input = new GameInput();
+        // IPlayerActions의 OnJump/... 메서드를 인풋 액션의 콜백으로 자동 연결.
+        _input.Player.SetCallbacks(this);
+    }
+
+    // GameInput은 활성/비활성 토글이 필요한 자원 ?. 처리로 Awake보다 OnEnable이 먼저 호출되는 경우 보호.
+    private void OnEnable()  => _input?.Player.Enable();
+    private void OnDisable() => _input?.Player.Disable();
+    private void OnDestroy() => _input?.Dispose();
+
+    public void OnJump(InputAction.CallbackContext ctx)
+    {
+        if (ctx.phase == InputActionPhase.Started)
+            OnJump_Event?.Invoke();
+    }
+}

Assets/02_Scripts/Managers/InputManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4d8ea6a700fa8a44a9fc25c4aa211098

Assets/02_Scripts/Managers/SceneLoadManager.cs

@@ -0,0 +1,120 @@
+using System;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+public class SceneLoadManager : MonoBehaviour
+{
+    public static SceneLoadManager Instance;
+
+    [SerializeField] private GameObject _loadingRoot;
+    [SerializeField] private Camera _loadingCam;
+    [SerializeField] private Transform _loadingCamTargetTransform;
+
+    private void Awake()
+    {
+        if (Instance == null)
+        {
+            Instance = this; //만들어진 자신을 인스턴스로 설정
+            DontDestroyOnLoad(gameObject);
+        }
+        else
+        {
+            Destroy(gameObject); //이미 인스턴스가 있으면 자신을 파괴
+        }
+    }
+
+    private void Start()
+    {
+        SceneManager.sceneLoaded += OnSceneLoaded;
+        OnSceneLoaded(SceneManager.GetActiveScene(), LoadSceneMode.Single);
+    }
+
+    private void Update()
+    {
+        if(_loadingCamTargetTransform != null)
+        {
+            _loadingRoot.transform.position = _loadingCamTargetTransform.position;
+        }
+    }
+
+    //씬이 로드되었을때 호출
+    private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
+    {
+        MonoBehaviour[] allObjs = UnityEngine.Object.FindObjectsByType<MonoBehaviour>(FindObjectsSortMode.None);
+
+        foreach (var obj in allObjs)
+        {
+            if (obj is ISceneInitializable initializable)
+            {
+                //씬에서 ISceneInitializable 인터페이스를 가진 오브젝트의 초기화 로직을 실행
+                initializable.OnSceneLoaded();
+            }
+        }
+    }
+
+    public void SetSceneLoadingProgressValue(float value)
+    {
+   
+    }
+
+    public void RequestSceneChange(string sceneName)
+    {
+        _ = SceneChange(sceneName);
+    }
+
+    private async Awaitable SceneChange(string sceneName)
+    {
+        try
+        {
+            //로딩바 수치 0으로 설정
+            SetSceneLoadingProgressValue(0f);
+
+            AsyncOperation op = SceneManager.LoadSceneAsync(sceneName);
+
+            //자동 전환을 하고 싶지 않을 경우 해당값을 false로 두었다가 true로 바꾸면 그 때 전환됨
+            op.allowSceneActivation = false;
+
+            //화면에 보여줄 로딩 수치
+            float displayProgress = 0f;
+
+            //op.progress 0.9가 데이터 로딩이 끝난 기준 allowSceneActivation이 트루면 다음으로 넘어가면서 op.isDone이 true가 된다.
+            while (op.progress < 0.9f) 
+            {
+                //실제 로딩 수치
+                float realProgress = Mathf.Clamp01(op.progress / 0.9f);
+
+                //보여줄 값을 실제값을 향해 부드럽게 이동
+                displayProgress = Mathf.MoveTowards(displayProgress, realProgress, Time.deltaTime * 0.5f);
+
+                // 로딩바 UI에 값 적용
+                SetSceneLoadingProgressValue(displayProgress);
+
+                //자기자신이 파괴될때 토큰에 취소요청을 보냄
+                await Awaitable.NextFrameAsync(this.destroyCancellationToken);
+            }
+
+            //로딩바 수치 1(100%)로 설정 (데이터 로딩은 이미 끝이기 때문에)
+            SetSceneLoadingProgressValue(1);
+
+            // 잠시 대기했다가 전환
+            await Awaitable.WaitForSecondsAsync(1.0f, this.destroyCancellationToken);
+
+            // 다음씬으로 넘어가도 됨을 알림
+            op.allowSceneActivation = true;
+
+            // 씬 활성화가 완전히 끝날 때까지 대기
+            // allowSceneActivation가 true가 되고 완전히 전환되기까지는 몇프레임 걸림. op.isDone 은 이 과정이 끝난 뒤에 true가 됨.
+            while(!op.isDone)
+            {
+                await Awaitable.NextFrameAsync(this.destroyCancellationToken);
+            }
+
+            //VR용 로직
+            //트래킹이 중단되면 안되기 때문에 카메라를 유지해야 한다
+            _loadingCamTargetTransform = Camera.main.transform; // 새로운 씬의 메인카메라를 따라가게끔 설정
+        }
+        catch (OperationCanceledException)
+        {
+            Debug.Log("씬 전환 작업이 취소됨");
+        }
+    }
+}

Assets/02_Scripts/Managers/SceneLoadManager.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 01c67a0d5e5e96240a6b1f1c8e34e749

Assets/02_Scripts/Player.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2d33246055dff62479d621abdd5e4066
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/02_Scripts/Player/PlayerController.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PlayerController : MonoBehaviour,ISceneInitializable
+{
+    public void OnSceneLoaded()
+    {
+        InputManager.Instance.OnJump_Event += this.OnJump;
+    }
+
+    public void OnJump()
+    {
+        
+    }
+}

Assets/02_Scripts/Player/PlayerController.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 2a803a0dad9eb494a89b1befc37bbdff

Assets/99_Settings/Input.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0aeb8722199f1b14899ca0c8008e7e5d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/99_Settings/Input/GameInput.cs

@@ -0,0 +1,312 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was auto-generated by com.unity.inputsystem:InputActionCodeGenerator
+//     version 1.17.0
+//     from Assets/99_Settings/Input/GameInput.inputactions
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Utilities;
+
+/// <summary>
+/// Provides programmatic access to <see cref="InputActionAsset" />, <see cref="InputActionMap" />, <see cref="InputAction" /> and <see cref="InputControlScheme" /> instances defined in asset "Assets/99_Settings/Input/GameInput.inputactions".
+/// </summary>
+/// <remarks>
+/// This class is source generated and any manual edits will be discarded if the associated asset is reimported or modified.
+/// </remarks>
+/// <example>
+/// <code>
+/// using namespace UnityEngine;
+/// using UnityEngine.InputSystem;
+///
+/// // Example of using an InputActionMap named "Player" from a UnityEngine.MonoBehaviour implementing callback interface.
+/// public class Example : MonoBehaviour, MyActions.IPlayerActions
+/// {
+///     private MyActions_Actions m_Actions;                  // Source code representation of asset.
+///     private MyActions_Actions.PlayerActions m_Player;     // Source code representation of action map.
+///
+///     void Awake()
+///     {
+///         m_Actions = new MyActions_Actions();              // Create asset object.
+///         m_Player = m_Actions.Player;                      // Extract action map object.
+///         m_Player.AddCallbacks(this);                      // Register callback interface IPlayerActions.
+///     }
+///
+///     void OnDestroy()
+///     {
+///         m_Actions.Dispose();                              // Destroy asset object.
+///     }
+///
+///     void OnEnable()
+///     {
+///         m_Player.Enable();                                // Enable all actions within map.
+///     }
+///
+///     void OnDisable()
+///     {
+///         m_Player.Disable();                               // Disable all actions within map.
+///     }
+///
+///     #region Interface implementation of MyActions.IPlayerActions
+///
+///     // Invoked when "Move" action is either started, performed or canceled.
+///     public void OnMove(InputAction.CallbackContext context)
+///     {
+///         Debug.Log($"OnMove: {context.ReadValue&lt;Vector2&gt;()}");
+///     }
+///
+///     // Invoked when "Attack" action is either started, performed or canceled.
+///     public void OnAttack(InputAction.CallbackContext context)
+///     {
+///         Debug.Log($"OnAttack: {context.ReadValue&lt;float&gt;()}");
+///     }
+///
+///     #endregion
+/// }
+/// </code>
+/// </example>
+public partial class @GameInput: IInputActionCollection2, IDisposable
+{
+    /// <summary>
+    /// Provides access to the underlying asset instance.
+    /// </summary>
+    public InputActionAsset asset { get; }
+
+    /// <summary>
+    /// Constructs a new instance.
+    /// </summary>
+    public @GameInput()
+    {
+        asset = InputActionAsset.FromJson(@"{
+    ""version"": 1,
+    ""name"": ""GameInput"",
+    ""maps"": [
+        {
+            ""name"": ""Player"",
+            ""id"": ""5d026a6e-8169-45f1-bc0c-240db1a29d82"",
+            ""actions"": [
+                {
+                    ""name"": ""Jump"",
+                    ""type"": ""Button"",
+                    ""id"": ""546a2fae-0afa-4133-8c4a-aa15ff66e23d"",
+                    ""expectedControlType"": """",
+                    ""processors"": """",
+                    ""interactions"": """",
+                    ""initialStateCheck"": false
+                }
+            ],
+            ""bindings"": [
+                {
+                    ""name"": """",
+                    ""id"": ""5bb26581-2c13-4476-bc62-503239d4d151"",
+                    ""path"": ""<XRController>{RightHand}/{PrimaryButton}"",
+                    ""interactions"": """",
+                    ""processors"": """",
+                    ""groups"": """",
+                    ""action"": ""Jump"",
+                    ""isComposite"": false,
+                    ""isPartOfComposite"": false
+                }
+            ]
+        }
+    ],
+    ""controlSchemes"": []
+}");
+        // Player
+        m_Player = asset.FindActionMap("Player", throwIfNotFound: true);
+        m_Player_Jump = m_Player.FindAction("Jump", throwIfNotFound: true);
+    }
+
+    ~@GameInput()
+    {
+        UnityEngine.Debug.Assert(!m_Player.enabled, "This will cause a leak and performance issues, GameInput.Player.Disable() has not been called.");
+    }
+
+    /// <summary>
+    /// Destroys this asset and all associated <see cref="InputAction"/> instances.
+    /// </summary>
+    public void Dispose()
+    {
+        UnityEngine.Object.Destroy(asset);
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.bindingMask" />
+    public InputBinding? bindingMask
+    {
+        get => asset.bindingMask;
+        set => asset.bindingMask = value;
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.devices" />
+    public ReadOnlyArray<InputDevice>? devices
+    {
+        get => asset.devices;
+        set => asset.devices = value;
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.controlSchemes" />
+    public ReadOnlyArray<InputControlScheme> controlSchemes => asset.controlSchemes;
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.Contains(InputAction)" />
+    public bool Contains(InputAction action)
+    {
+        return asset.Contains(action);
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.GetEnumerator()" />
+    public IEnumerator<InputAction> GetEnumerator()
+    {
+        return asset.GetEnumerator();
+    }
+
+    /// <inheritdoc cref="IEnumerable.GetEnumerator()" />
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.Enable()" />
+    public void Enable()
+    {
+        asset.Enable();
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.Disable()" />
+    public void Disable()
+    {
+        asset.Disable();
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.bindings" />
+    public IEnumerable<InputBinding> bindings => asset.bindings;
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.FindAction(string, bool)" />
+    public InputAction FindAction(string actionNameOrId, bool throwIfNotFound = false)
+    {
+        return asset.FindAction(actionNameOrId, throwIfNotFound);
+    }
+
+    /// <inheritdoc cref="UnityEngine.InputSystem.InputActionAsset.FindBinding(InputBinding, out InputAction)" />
+    public int FindBinding(InputBinding bindingMask, out InputAction action)
+    {
+        return asset.FindBinding(bindingMask, out action);
+    }
+
+    // Player
+    private readonly InputActionMap m_Player;
+    private List<IPlayerActions> m_PlayerActionsCallbackInterfaces = new List<IPlayerActions>();
+    private readonly InputAction m_Player_Jump;
+    /// <summary>
+    /// Provides access to input actions defined in input action map "Player".
+    /// </summary>
+    public struct PlayerActions
+    {
+        private @GameInput m_Wrapper;
+
+        /// <summary>
+        /// Construct a new instance of the input action map wrapper class.
+        /// </summary>
+        public PlayerActions(@GameInput wrapper) { m_Wrapper = wrapper; }
+        /// <summary>
+        /// Provides access to the underlying input action "Player/Jump".
+        /// </summary>
+        public InputAction @Jump => m_Wrapper.m_Player_Jump;
+        /// <summary>
+        /// Provides access to the underlying input action map instance.
+        /// </summary>
+        public InputActionMap Get() { return m_Wrapper.m_Player; }
+        /// <inheritdoc cref="UnityEngine.InputSystem.InputActionMap.Enable()" />
+        public void Enable() { Get().Enable(); }
+        /// <inheritdoc cref="UnityEngine.InputSystem.InputActionMap.Disable()" />
+        public void Disable() { Get().Disable(); }
+        /// <inheritdoc cref="UnityEngine.InputSystem.InputActionMap.enabled" />
+        public bool enabled => Get().enabled;
+        /// <summary>
+        /// Implicitly converts an <see ref="PlayerActions" /> to an <see ref="InputActionMap" /> instance.
+        /// </summary>
+        public static implicit operator InputActionMap(PlayerActions set) { return set.Get(); }
+        /// <summary>
+        /// Adds <see cref="InputAction.started"/>, <see cref="InputAction.performed"/> and <see cref="InputAction.canceled"/> callbacks provided via <param cref="instance" /> on all input actions contained in this map.
+        /// </summary>
+        /// <param name="instance">Callback instance.</param>
+        /// <remarks>
+        /// If <paramref name="instance" /> is <c>null</c> or <paramref name="instance"/> have already been added this method does nothing.
+        /// </remarks>
+        /// <seealso cref="PlayerActions" />
+        public void AddCallbacks(IPlayerActions instance)
+        {
+            if (instance == null || m_Wrapper.m_PlayerActionsCallbackInterfaces.Contains(instance)) return;
+            m_Wrapper.m_PlayerActionsCallbackInterfaces.Add(instance);
+            @Jump.started += instance.OnJump;
+            @Jump.performed += instance.OnJump;
+            @Jump.canceled += instance.OnJump;
+        }
+
+        /// <summary>
+        /// Removes <see cref="InputAction.started"/>, <see cref="InputAction.performed"/> and <see cref="InputAction.canceled"/> callbacks provided via <param cref="instance" /> on all input actions contained in this map.
+        /// </summary>
+        /// <remarks>
+        /// Calling this method when <paramref name="instance" /> have not previously been registered has no side-effects.
+        /// </remarks>
+        /// <seealso cref="PlayerActions" />
+        private void UnregisterCallbacks(IPlayerActions instance)
+        {
+            @Jump.started -= instance.OnJump;
+            @Jump.performed -= instance.OnJump;
+            @Jump.canceled -= instance.OnJump;
+        }
+
+        /// <summary>
+        /// Unregisters <param cref="instance" /> and unregisters all input action callbacks via <see cref="PlayerActions.UnregisterCallbacks(IPlayerActions)" />.
+        /// </summary>
+        /// <seealso cref="PlayerActions.UnregisterCallbacks(IPlayerActions)" />
+        public void RemoveCallbacks(IPlayerActions instance)
+        {
+            if (m_Wrapper.m_PlayerActionsCallbackInterfaces.Remove(instance))
+                UnregisterCallbacks(instance);
+        }
+
+        /// <summary>
+        /// Replaces all existing callback instances and previously registered input action callbacks associated with them with callbacks provided via <param cref="instance" />.
+        /// </summary>
+        /// <remarks>
+        /// If <paramref name="instance" /> is <c>null</c>, calling this method will only unregister all existing callbacks but not register any new callbacks.
+        /// </remarks>
+        /// <seealso cref="PlayerActions.AddCallbacks(IPlayerActions)" />
+        /// <seealso cref="PlayerActions.RemoveCallbacks(IPlayerActions)" />
+        /// <seealso cref="PlayerActions.UnregisterCallbacks(IPlayerActions)" />
+        public void SetCallbacks(IPlayerActions instance)
+        {
+            foreach (var item in m_Wrapper.m_PlayerActionsCallbackInterfaces)
+                UnregisterCallbacks(item);
+            m_Wrapper.m_PlayerActionsCallbackInterfaces.Clear();
+            AddCallbacks(instance);
+        }
+    }
+    /// <summary>
+    /// Provides a new <see cref="PlayerActions" /> instance referencing this action map.
+    /// </summary>
+    public PlayerActions @Player => new PlayerActions(this);
+    /// <summary>
+    /// Interface to implement callback methods for all input action callbacks associated with input actions defined by "Player" which allows adding and removing callbacks.
+    /// </summary>
+    /// <seealso cref="PlayerActions.AddCallbacks(IPlayerActions)" />
+    /// <seealso cref="PlayerActions.RemoveCallbacks(IPlayerActions)" />
+    public interface IPlayerActions
+    {
+        /// <summary>
+        /// Method invoked when associated input action "Jump" is either <see cref="UnityEngine.InputSystem.InputAction.started" />, <see cref="UnityEngine.InputSystem.InputAction.performed" /> or <see cref="UnityEngine.InputSystem.InputAction.canceled" />.
+        /// </summary>
+        /// <seealso cref="UnityEngine.InputSystem.InputAction.started" />
+        /// <seealso cref="UnityEngine.InputSystem.InputAction.performed" />
+        /// <seealso cref="UnityEngine.InputSystem.InputAction.canceled" />
+        void OnJump(InputAction.CallbackContext context);
+    }
+}

Assets/99_Settings/Input/GameInput.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 34b0d0d41528a3244b8ce12d0b8df0db

Assets/99_Settings/Input/GameInput.inputactions

@@ -0,0 +1,35 @@
+{
+    "version": 1,
+    "name": "GameInput",
+    "maps": [
+        {
+            "name": "Player",
+            "id": "5d026a6e-8169-45f1-bc0c-240db1a29d82",
+            "actions": [
+                {
+                    "name": "Jump",
+                    "type": "Button",
+                    "id": "546a2fae-0afa-4133-8c4a-aa15ff66e23d",
+                    "expectedControlType": "",
+                    "processors": "",
+                    "interactions": "",
+                    "initialStateCheck": false
+                }
+            ],
+            "bindings": [
+                {
+                    "name": "",
+                    "id": "5bb26581-2c13-4476-bc62-503239d4d151",
+                    "path": "<XRController>{RightHand}/{PrimaryButton}",
+                    "interactions": "",
+                    "processors": "",
+                    "groups": "",
+                    "action": "Jump",
+                    "isComposite": false,
+                    "isPartOfComposite": false
+                }
+            ]
+        }
+    ],
+    "controlSchemes": []
+}

Assets/99_Settings/Input/GameInput.inputactions.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 97db30ac5807bfa40be4e32b71f0abf3
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 8404be70184654265930450def6a9037, type: 3}
+  generateWrapperCode: 1
+  wrapperCodePath: 
+  wrapperClassName: 
+  wrapperCodeNamespace: