app.hypergames.hypersdk 1.8.20 → 1.8.22

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.8.22](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.21...v1.8.22) (2026-07-08)
+
+
+### Bug Fixes
+
+* add tutorial announcement prompt ([0b5e009](https://github.com/mvmhyper/hyper-sdk/commit/0b5e0099346d144b56d35a39d613e24a776ef11b))
+
+## [1.8.21](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.20...v1.8.21) (2026-07-08)
+
+
+### Bug Fixes
+
+* smooth tutorial loader and media switching ([b4cfbef](https://github.com/mvmhyper/hyper-sdk/commit/b4cfbef45d5544e7c5dfa37f702acb9f7be67548))
+
 ## [1.8.20](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.19...v1.8.20) (2026-07-07)
 
 

package/Runtime/Internal/Bootstrap/HyperLoader.cs

@@ -263,6 +263,9 @@ namespace Hyper.Internal
             _bootstrapProgress = _progressAfterInit;
             _loadingBarSlider.value = _bootstrapProgress;
 
+            // Start tutorial discovery early, but never wait for it before loading gameplay.
+            HyperRuntime.BackendManager.GetTutorial(null);
+
             // Step 2: Handle Backend/PVP or Practice mode initialization
             if (_gameManager.Config.IsBackendGame && _gameManager.Config.isPVP)
             {
@@ -475,4 +478,4 @@ namespace Hyper.Internal
 
         #endregion
     }
-}
+}

package/Runtime/Internal/Managers/BackendManager.cs

@@ -49,7 +49,8 @@ namespace Hyper.Internal.Managers
         public bool isSocketConnected { get; private set; }
         public bool tutorialFetchSuccess { get; private set; }
         public bool tutorialExistsButFailed { get; private set; }
-        public bool tutorialDoesNotExist => !tutorialExistsButFailed && !tutorialFetchSuccess && !_isFetchingTutorial;
+        public bool tutorialDoesNotExist => TutorialAvailability == TutorialAvailabilityState.Unavailable;
+        public TutorialAvailabilityState TutorialAvailability { get; private set; } = TutorialAvailabilityState.Unknown;
 
         /// <summary>
         /// Type of error that occurred during score submission.
@@ -127,7 +128,7 @@ namespace Hyper.Internal.Managers
         private void FetchAndCacheTutorials(string serverBaseUrl, string gameSlug, string gameObject)
         {
             _isFetchingTutorial = false;
-            _onTutorialSuccess?.Invoke();
+            OnTutorialCacheComplete("success");
         }
 
         private void InitWebSocket(string serverUrl) { }
@@ -1587,27 +1588,41 @@ namespace Hyper.Internal.Managers
             NetworkError
         }
 
-        private Action _onFetchComplete;
-        private Action _onTutorialSuccess;
-        private Action<TutorialFetchStatus> _onTutorialFailure;
+        public enum TutorialAvailabilityState
+        {
+            Unknown,
+            InProgress,
+            Available,
+            Unavailable,
+            ExistsButFailed
+        }
+
+        private readonly List<Action> _fetchCompleteCallbacks = new List<Action>();
+        private readonly List<Action> _tutorialSuccessCallbacks = new List<Action>();
+        private readonly List<Action<TutorialFetchStatus>> _tutorialFailureCallbacks = new List<Action<TutorialFetchStatus>>();
         private bool _isFetchingTutorial;
 
         public void GetTutorial(Action fetchComplete, Action onSuccess = null, Action<TutorialFetchStatus> onFailure = null)
         {
             if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
 
+            if (IsTutorialFetchComplete())
+            {
+                InvokeTutorialCallbacksForCurrentState(fetchComplete, onSuccess, onFailure);
+                return;
+            }
+
+            AddTutorialCallbacks(fetchComplete, onSuccess, onFailure);
+
             if (_isFetchingTutorial)
             {
-                HyperDebug.LogWarning("Tutorial fetch already in progress");
                 return;
             }
 
-            _onFetchComplete = fetchComplete;
-            _onTutorialSuccess = onSuccess;
-            _onTutorialFailure = onFailure;
             _currentRetryCount = 0;
             tutorialExistsButFailed = false;
             tutorialFetchSuccess = false;
+            TutorialAvailability = TutorialAvailabilityState.InProgress;
             TryFetchTutorial();
         }
 
@@ -1618,30 +1633,32 @@ namespace Hyper.Internal.Managers
 
 #if UNITY_WEBGL && !UNITY_EDITOR
             FetchAndCacheTutorials(GetServerUrl(), gameSlug, gameObject.name);
-#else
+#elif UNITY_EDITOR
             StartCoroutine(SimulateTutorialFetch());
+#else
+            OnTutorialCacheComplete("fetch_failed");
 #endif
         }
 
         public void OnTutorialCacheComplete(string result)
         {
-            _onFetchComplete?.Invoke();
-
             switch (result)
             {
                 case "success":
-                    _eventManager?.InvokeTutorialFetchCompleteEvent();
                     _isFetchingTutorial = false;
                     tutorialExistsButFailed = false;
                     tutorialFetchSuccess = true;
-                    _onTutorialSuccess?.Invoke();
+                    TutorialAvailability = TutorialAvailabilityState.Available;
+                    _eventManager?.InvokeTutorialFetchCompleteEvent();
+                    InvokeAndClearTutorialCallbacks(TutorialFetchStatus.Success);
                     break;
 
                 case "no_tutorial":
                     _isFetchingTutorial = false;
                     tutorialExistsButFailed = false;
                     tutorialFetchSuccess = false;
-                    _onTutorialFailure?.Invoke(TutorialFetchStatus.NoTutorialExists);
+                    TutorialAvailability = TutorialAvailabilityState.Unavailable;
+                    InvokeAndClearTutorialCallbacks(TutorialFetchStatus.NoTutorialExists);
                     _eventManager?.InvokeTutorialNotExistsEvent();
                     break;
 
@@ -1659,16 +1676,106 @@ namespace Hyper.Internal.Managers
 
         private void HandleRetryOrFail(TutorialFetchStatus status)
         {
-            _onTutorialFailure?.Invoke(status);
-            _eventManager?.InvokeTutorialFetchFailedEvent();
             _isFetchingTutorial = false;
+
+            if (status == TutorialFetchStatus.DownloadFailed)
+            {
+                tutorialExistsButFailed = true;
+                tutorialFetchSuccess = false;
+                TutorialAvailability = TutorialAvailabilityState.ExistsButFailed;
+            }
+            else
+            {
+                tutorialExistsButFailed = false;
+                tutorialFetchSuccess = false;
+                TutorialAvailability = TutorialAvailabilityState.Unknown;
+            }
+
+            InvokeAndClearTutorialCallbacks(status);
+            _eventManager?.InvokeTutorialFetchFailedEvent();
+        }
+
+        private bool IsTutorialFetchComplete()
+        {
+            return TutorialAvailability == TutorialAvailabilityState.Available ||
+                   TutorialAvailability == TutorialAvailabilityState.Unavailable;
+        }
+
+        private void AddTutorialCallbacks(Action fetchComplete, Action onSuccess, Action<TutorialFetchStatus> onFailure)
+        {
+            if (fetchComplete != null) _fetchCompleteCallbacks.Add(fetchComplete);
+            if (onSuccess != null) _tutorialSuccessCallbacks.Add(onSuccess);
+            if (onFailure != null) _tutorialFailureCallbacks.Add(onFailure);
+        }
+
+        private void InvokeTutorialCallbacksForCurrentState(Action fetchComplete, Action onSuccess, Action<TutorialFetchStatus> onFailure)
+        {
+            switch (TutorialAvailability)
+            {
+                case TutorialAvailabilityState.Available:
+                    onSuccess?.Invoke();
+                    break;
+                case TutorialAvailabilityState.Unavailable:
+                    onFailure?.Invoke(TutorialFetchStatus.NoTutorialExists);
+                    break;
+                case TutorialAvailabilityState.ExistsButFailed:
+                    onFailure?.Invoke(TutorialFetchStatus.DownloadFailed);
+                    break;
+            }
+
+            fetchComplete?.Invoke();
+        }
+
+        private void InvokeAndClearTutorialCallbacks(TutorialFetchStatus status)
+        {
+            if (status == TutorialFetchStatus.Success)
+            {
+                for (int i = 0; i < _tutorialSuccessCallbacks.Count; i++)
+                {
+                    _tutorialSuccessCallbacks[i]?.Invoke();
+                }
+            }
+            else
+            {
+                for (int i = 0; i < _tutorialFailureCallbacks.Count; i++)
+                {
+                    _tutorialFailureCallbacks[i]?.Invoke(status);
+                }
+            }
+
+            for (int i = 0; i < _fetchCompleteCallbacks.Count; i++)
+            {
+                _fetchCompleteCallbacks[i]?.Invoke();
+            }
+
+            _fetchCompleteCallbacks.Clear();
+            _tutorialSuccessCallbacks.Clear();
+            _tutorialFailureCallbacks.Clear();
         }
 
 #if UNITY_EDITOR
         private IEnumerator SimulateTutorialFetch()
         {
-            yield return new WaitForSecondsRealtime(1.5f);
-            OnTutorialCacheComplete(UnityEngine.Random.value > 0.5f ? "no_tutorial" : "download_failed");
+            var value = UnityEngine.Random.Range(0, 4);
+            Debug.Log($"[Tutorial] Simulating tutorial fetch result: {value}");
+
+            switch (value)
+            {
+                case 0:
+                    OnTutorialCacheComplete("success");
+                    break;
+                case 1:
+                    OnTutorialCacheComplete("download_failed");
+                    break;
+                case 2:
+                    OnTutorialCacheComplete("fetch_failed");
+                    break;
+                default:
+                    OnTutorialCacheComplete("no_tutorial");
+                    break;
+            }
+
+            yield break;
         }
 #endif
 

package/Runtime/Internal/Managers/GameManager.cs

@@ -805,20 +805,13 @@ namespace Hyper.Internal.Managers
 
             ShowControlBarElements();
             AddTutorialModal();
-            ShowStartingInstructionModal();
+            ShowTutorialAnnouncementOrStartingInstruction();
         }
 
         private IEnumerator BootstrapAndStart()
         {
             HyperRuntime.EventManager.OnGameStart += HandleGameStarted;
-
-            bool tutorialDone = false;
-            HyperRuntime.BackendManager.GetTutorial(() => tutorialDone = true);
-
-            while (!tutorialDone)
-            {
-                yield return null;
-            }
+            yield break;
         }
 
         private void HandleGameStarted()
@@ -978,6 +971,7 @@ namespace Hyper.Internal.Managers
         private GameObject _battleGameOverModal;
         private GameObject _practiceGameOverModal;
         private GameObject _startingInstructionModal;
+        private GameObject _tutorialAnnouncementModal;
         private GameObject _tutorialPortraitModal;
         private GameObject _tutorialLandscapeModal;
         private GameObject _controlBarElements;
@@ -987,6 +981,7 @@ namespace Hyper.Internal.Managers
         private GameOverModal _gameOverModalComponent;
         private ControlBar _controlBarModal;
         private TutorialModal _tutorialModalComponent;
+        private TutorialAnnouncementModal _tutorialAnnouncementModalComponent;
         private ScoreSubmissionFailedModal _scoreSubmissionFailedModalComponent;
         private StartingInstructionModal _startingInstructionModalComponent;
 
@@ -1495,6 +1490,109 @@ namespace Hyper.Internal.Managers
             SetBlockerActive(false);
         }
 
+        private void ShowTutorialAnnouncementOrStartingInstruction()
+        {
+            if (ShouldShowTutorialAnnouncement())
+            {
+                ShowTutorialAnnouncementModal();
+                return;
+            }
+
+            ShowStartingInstructionModal();
+        }
+
+        private bool ShouldShowTutorialAnnouncement()
+        {
+            var availability = HyperRuntime.BackendManager.TutorialAvailability;
+            bool tutorialKnownToExist =
+                availability == BackendManager.TutorialAvailabilityState.Available ||
+                availability == BackendManager.TutorialAvailabilityState.ExistsButFailed;
+
+            return tutorialKnownToExist && !HasSeenTutorialAnnouncement();
+        }
+
+        private bool HasSeenTutorialAnnouncement()
+        {
+            string key = GetTutorialAnnouncementSeenKey();
+            return !string.IsNullOrEmpty(key) && PlayerPrefs.GetInt(key, 0) == 1;
+        }
+
+        private void MarkTutorialAnnouncementSeen()
+        {
+            string key = GetTutorialAnnouncementSeenKey();
+            if (string.IsNullOrEmpty(key)) return;
+
+            PlayerPrefs.SetInt(key, 1);
+            PlayerPrefs.Save();
+        }
+
+        private string GetTutorialAnnouncementSeenKey()
+        {
+            string gameIdentifier = Config != null ? Config.GameSlug : null;
+
+#if UNITY_EDITOR
+            if (string.IsNullOrWhiteSpace(gameIdentifier))
+            {
+                gameIdentifier = Application.productName;
+            }
+#endif
+
+            if (string.IsNullOrWhiteSpace(gameIdentifier))
+            {
+                gameIdentifier = HyperRuntime.GameContent != null
+                    ? HyperRuntime.GameContent.GameScene?.SceneName
+                    : null;
+            }
+
+            return string.IsNullOrWhiteSpace(gameIdentifier)
+                ? null
+                : $"{gameIdentifier}_sdkTutorialPromptSeen";
+        }
+
+        private void ShowTutorialAnnouncementModal()
+        {
+            EnsureTutorialAnnouncementModal();
+
+            if (_tutorialAnnouncementModalComponent == null)
+            {
+                ShowStartingInstructionModal();
+                return;
+            }
+
+            _tutorialAnnouncementModalComponent.Show(() =>
+            {
+                MarkTutorialAnnouncementSeen();
+                SetBlockerActive(false);
+                ShowStartingInstructionModal();
+            });
+
+            SetBlockerActive(true);
+        }
+
+        private void EnsureTutorialAnnouncementModal()
+        {
+            if (_tutorialAnnouncementModal != null)
+            {
+                _tutorialAnnouncementModal.SetActive(true);
+                return;
+            }
+
+            if (_canvas == null) CreateCanvas();
+
+            GameObject prefab = Resources.Load<GameObject>("UIPrefabs/TutorialAnnouncementModal");
+            if (prefab == null)
+            {
+                HyperDebug.LogWarning("[GameManager] TutorialAnnouncementModal prefab not found.");
+                return;
+            }
+
+            GameObject instance = Instantiate(prefab);
+            instance.transform.SetParent(_safeArea.transform, false);
+
+            _tutorialAnnouncementModal = instance;
+            _tutorialAnnouncementModalComponent = instance.GetComponent<TutorialAnnouncementModal>();
+        }
+
         private void EnsureStartingInstructionModal()
         {
             if (_startingInstructionModal != null)

package/Runtime/Internal/ScriptableObjects/HyperSDKSettings.cs

@@ -95,4 +95,4 @@ namespace Hyper.Internal
 
         #endregion
     }
-}
+}

package/Runtime/Internal/UI/Modals/TutorialAnnouncementModal.cs

@@ -0,0 +1,57 @@
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    internal class TutorialAnnouncementModal : MonoBehaviour
+    {
+        [SerializeField] private Button closeButton;
+
+        private System.Action _onClosed;
+        private bool _hasClosed;
+
+        private void Awake()
+        {
+            if (closeButton == null)
+            {
+                closeButton = GetComponentInChildren<Button>(true);
+            }
+
+            if (closeButton != null)
+            {
+                closeButton.onClick.AddListener(HandleCloseClicked);
+            }
+            else
+            {
+                HyperDebug.LogWarning("[TutorialAnnouncementModal] Close button is not assigned.");
+            }
+        }
+
+        private void OnDestroy()
+        {
+            if (closeButton != null)
+            {
+                closeButton.onClick.RemoveListener(HandleCloseClicked);
+            }
+        }
+
+        internal void Show(System.Action onClosed)
+        {
+            _onClosed = onClosed;
+            _hasClosed = false;
+            gameObject.SetActive(true);
+        }
+
+        private void HandleCloseClicked()
+        {
+            if (_hasClosed) return;
+
+            _hasClosed = true;
+            gameObject.SetActive(false);
+
+            System.Action onClosed = _onClosed;
+            _onClosed = null;
+            onClosed?.Invoke();
+        }
+    }
+}

package/Runtime/Internal/UI/Modals/TutorialAnnouncementModal.cs.meta

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

package/Runtime/Internal/UI/Modals/TutorialLoaderModal.cs

@@ -36,10 +36,10 @@ namespace Hyper.Internal
             KillTweens();
             tutorialLoaderModalCG.alpha = 0f;
 
-            // Fade in and enable
-            tutorialLoaderModalCG.DOFade(1, 0.3f).SetUpdate(true);
-
             HandleLoadingTutorial();
+
+            // Fade in after loading state has reset its own tweens.
+            tutorialLoaderModalCG.DOFade(1, 0.3f).SetUpdate(true);
         }
 
         void OnDestroy()
@@ -124,6 +124,7 @@ namespace Hyper.Internal
         void HandleTutorialFailed()
         {
             KillTweens();
+            tutorialLoaderModalCG.alpha = 1f;
 
             loaderTextTween.SetActive(false);
             loaderText.SetActive(true);

package/Runtime/Internal/UI/Modals/TutorialModal.cs

@@ -21,6 +21,8 @@ namespace Hyper.Internal
         private const float SlideInDuration = 0.33f;
         private const float ContentFadeInDuration = 0.28f;
         private const float ContentFadeOutDuration = 0.18f;
+        private const float MediaFadeInDuration = 0.18f;
+        private const float VideoRevealDelay = 0.05f;
         private const float HiddenPreloadPlayDuration = 0.75f;
 
 #if UNITY_WEBGL && !UNITY_EDITOR
@@ -69,6 +71,7 @@ namespace Hyper.Internal
         private Coroutine updateVideoTimeCo = null;
         private Coroutine editorTutorialLoadCo = null;
         private Coroutine hiddenPreloadCloseCo = null;
+        private Coroutine mediaDisplayFadeCo = null;
         private TutorialData tutorialData;
         private bool isClosing;
         private bool hasInvokedTutorialLoadComplete;
@@ -621,6 +624,90 @@ namespace Hyper.Internal
             }
         }
 
+        private void ResetCardMediaState()
+        {
+            StopMediaDisplayFade();
+            ResetVideoProgressState();
+            HideMediaDisplay(tutorialDisplayP);
+            HideMediaDisplay(tutorialDisplayL);
+            HideMediaDisplay(tutorialImageDisplay);
+        }
+
+        private void ResetVideoProgressState()
+        {
+            cachedVideoLength = 0f;
+            isDraggingSlider = false;
+
+            if (timeSlider == null) return;
+
+            timeSlider.minValue = 0f;
+            timeSlider.maxValue = 1f;
+            timeSlider.value = 0f;
+        }
+
+        private void HideMediaDisplay(RawImage display)
+        {
+            if (display == null) return;
+
+            SetMediaDisplayAlpha(display, 0f);
+            display.gameObject.SetActive(false);
+        }
+
+        private void SetMediaDisplayAlpha(RawImage display, float alpha)
+        {
+            if (display == null) return;
+
+            Color color = display.color;
+            color.a = alpha;
+            display.color = color;
+        }
+
+        private void StopMediaDisplayFade()
+        {
+            if (mediaDisplayFadeCo == null) return;
+
+            StopCoroutine(mediaDisplayFadeCo);
+            mediaDisplayFadeCo = null;
+        }
+
+        private void FadeInMediaDisplay(RawImage display, float delay = 0f)
+        {
+            if (display == null) return;
+
+            StopMediaDisplayFade();
+            mediaDisplayFadeCo = StartCoroutine(FadeInMediaDisplayCoroutine(display, delay));
+        }
+
+        private IEnumerator FadeInMediaDisplayCoroutine(RawImage display, float delay)
+        {
+            display.gameObject.SetActive(true);
+            SetMediaDisplayAlpha(display, 0f);
+
+            if (delay > 0f)
+            {
+                yield return new WaitForSecondsRealtime(delay);
+            }
+
+            float elapsed = 0f;
+
+            while (elapsed < MediaFadeInDuration)
+            {
+                if (display == null) yield break;
+
+                elapsed += Time.unscaledDeltaTime;
+                float t = Mathf.Clamp01(elapsed / MediaFadeInDuration);
+                SetMediaDisplayAlpha(display, Mathf.SmoothStep(0f, 1f, t));
+                yield return null;
+            }
+
+            if (display != null)
+            {
+                SetMediaDisplayAlpha(display, 1f);
+            }
+
+            mediaDisplayFadeCo = null;
+        }
+
 
 
         private void DisplayCurrentCard(bool isInitialDisplay)
@@ -628,6 +715,7 @@ namespace Hyper.Internal
             if (currentCardIndex < 0 || currentCardIndex >= tutorialCards.Count) return;
 
             StopVideoPlayback();
+            ResetCardMediaState();
             TutorialCardData card = tutorialCards[currentCardIndex];
 
             if (descriptionText != null)
@@ -656,12 +744,7 @@ namespace Hyper.Internal
                 return;
             }
 
-            if (tutorialImageDisplay != null)
-                tutorialImageDisplay.gameObject.SetActive(false);
-
-            // Start with portrait display as default; will switch to landscape in OnCardVideoPrepared if needed
-            tutorialDisplayP.gameObject.SetActive(true);
-            tutorialDisplayL.gameObject.SetActive(false);
+            // Keep the media surface hidden while VideoPlayer prepares the next source.
             currentDisplay = tutorialDisplayP;
 
             videoPlayer.enabled = true;
@@ -714,6 +797,7 @@ namespace Hyper.Internal
             tutorialDisplayP.gameObject.SetActive(targetDisplay == tutorialDisplayP);
             tutorialDisplayL.gameObject.SetActive(targetDisplay == tutorialDisplayL);
             currentDisplay = targetDisplay;
+            SetMediaDisplayAlpha(currentDisplay, 0f);
 
             if (targetTexture != null)
             {
@@ -733,7 +817,9 @@ namespace Hyper.Internal
             updateVideoTimeCo = StartCoroutine(UpdateVideoTime());
 
             InvokeTutorialLoadingCompleteOnce();
+            videoPlayer.time = 0;
             videoPlayer.Play();
+            FadeInMediaDisplay(currentDisplay, VideoRevealDelay);
         }
 
         private void DisplayImageCard(TutorialCardData card, bool isInitialDisplay)
@@ -754,6 +840,7 @@ namespace Hyper.Internal
 
             tutorialImageDisplay.gameObject.SetActive(true);
             tutorialImageDisplay.texture = card.image.texture;
+            FadeInMediaDisplay(tutorialImageDisplay);
 
             if (isInitialDisplay)
             {
@@ -781,6 +868,11 @@ namespace Hyper.Internal
             if (videoPlayer == null) return;
 
             videoPlayer.prepareCompleted -= OnCardVideoPrepared;
+            videoPlayer.loopPointReached -= OnLoopPointReached;
+            if (videoPlayer.isPrepared)
+            {
+                videoPlayer.time = 0;
+            }
             videoPlayer.Stop();
             videoPlayer.targetTexture = null;
         }
@@ -1023,6 +1115,7 @@ namespace Hyper.Internal
             contentRevealScheduled = false;
             isClosing = false;
             CancelHiddenPreloadClose();
+            StopMediaDisplayFade();
             HideTutorialContent();
 
 #if UNITY_EDITOR

package/Runtime/Resources/Materials/RoundedRawImage.mat

@@ -32,7 +32,7 @@ Material:
     m_Floats:
     - _ColorMask: 15
     - _InvertedRadius: 0
-    - _Radius: 60
+    - _Radius: 75
     - _Softness: 1.75
     - _Stencil: 0
     - _StencilComp: 8
@@ -44,10 +44,10 @@ Material:
     m_Colors:
     - _ClipRect: {r: -32767, g: -32767, b: 32767, a: 32767}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
-    - _CornerRadii: {r: 60, g: 60, b: 0, a: 0}
+    - _CornerRadii: {r: 75, g: 75, b: 0, a: 0}
     - _InvertedCornerRadii: {r: 0, g: 0, b: 962.5, a: 1481.2}
     - _Pivot: {r: 0.5, g: 0.556, b: 0, a: 0}
-    - _RectSize: {r: 998, g: 2160, b: 0, a: 0}
+    - _RectSize: {r: 2532, g: 1216, b: 0, a: 0}
   m_BuildTextureStacks: []
   m_AllowLocking: 1
 --- !u!114 &4644396538228076653