update SpriteScaler.cs

Assets/Scripts/MDPro3/Managers/BackgroundManager.cs

@@ -4,6 +4,7 @@ using MDPro3.UI;
 using System.Collections;
 using System.IO;
 using static UnityEngine.UI.Image;
+using YgomSystem.Effect;
 
 namespace MDPro3
 {
@@ -79,7 +80,11 @@ namespace MDPro3
 
             var endString = id.ToString("D4");
             back = ABLoader.LoadFromFolder("MasterDuel/Background/Back" + endString, "Background" + endString, true);
-            back.transform.GetChild(0).gameObject.AddComponent<AutoScale>();
+            if (back.transform.GetChild(0).gameObject.TryGetComponent<SpriteScaler>(out var spriteScaler))
+            {
+                spriteScaler.isApplyOnUpdate = true;
+                spriteScaler.SetFitMode(SpriteScaler.FitMode.FitHighestResolutionMaintainAspectRatio);
+            }
             Tools.ChangeLayer(back, "2D");
             back.transform.SetParent(transform, false);
 

Assets/Scripts/MDPro3/Managers/TimeLineManager.cs

@@ -433,7 +433,6 @@ namespace MDPro3
             DoWhenStop(summon);
             var manager = summon.GetComponent<ElementObjectManager>();
             currentSyncManager = manager;
-            manager.GetElement("BlackNormal").AddComponent<AutoScaleOnce>();
 
             var subManager = manager.GetElement<ElementObjectManager>("SummonLinkpostLink");
             dummyCard = subManager.GetElement("DummyCardLink");

Assets/Scripts/MDPro3/Servant/CutinViewer.cs

@@ -270,17 +270,6 @@ namespace MDPro3.Servant
             else//4
                 back = ABLoader.LoadFromFile("MasterDuel/Timeline/Summon/SummonMonster/04BackEff/SummonMonster_Bgdve_S2", true);
             back.transform.SetParent(Program.instance.container_2D, false);
-            Transform eff_flame = back.transform.Find("Eff_Flame");
-            eff_flame.localScale = new Vector3(2.76f, 1.55f, 1f);
-            eff_flame.gameObject.AddComponent<AutoScaleOnce>();
-            Transform eff_bg00 = back.transform.Find("Eff_Bg00");
-            eff_bg00.localScale = new Vector3(250f, 25f, 1f);
-            Transform flame_re = back.transform.Find("flame_re");
-            if (flame_re == null)
-                flame_re = back.transform.Find("Eff_group/flame_re");
-            if (flame_re == null)
-                flame_re = back.transform.Find("Eff_Flame01_re");
-            flame_re.gameObject.AddComponent<AutoScaleOnce>();
             Destroy(back, CUTIN_PLAY_TIME);
 
             //Name Bar

Assets/Scripts/MDPro3/Servant/OcgCore.cs

@@ -2643,7 +2643,8 @@ namespace MDPro3.Servant
                         var mono = myDeck.gameObject.AddComponent<DoWhenPlayableDirectorStop>();
                         mono.action = () =>
                         {
-                            var effect = ABLoader.LoadFromFile("MasterDuel/Timeline/DuelText/DuelTextStart", true);
+                            //var effect = ABLoader.LoadFromFile("MasterDuel/Timeline/DuelText/DuelTextStart", true);
+                            var effect = Instantiate(container.duelTextStart);
                             var mono = effect.AddComponent<DoWhenPlayableDirectorStop>();
                             mono.action = () =>
                             {

Assets/Scripts/MasterDuel/YgomSystem/Effect/SpriteScaler.cs

+using MDPro3;
+using System.Collections;
 using System.Runtime.CompilerServices;
 using UnityEngine;
 
@@ -49,16 +51,19 @@ namespace YgomSystem.Effect
 
 		private bool applyOnCustomSize;
 
-		private Vector2 appliedScreenSize;
+        private bool m_ScaleYtoZ;
+
+        private Vector2 appliedScreenSize;
 
 		public bool isApplyOnUpdate
 		{
 			get
 			{
-				return false;
+				return applyOnUpdate;
 			}
 			set
 			{
+				applyOnUpdate = value;
 			}
 		}
 
@@ -66,7 +71,7 @@ namespace YgomSystem.Effect
 		{
 			get
 			{
-				return false;
+				return _useDirectSizeSetting;
 			}
 			set
 			{
@@ -77,7 +82,7 @@ namespace YgomSystem.Effect
 		{
 			get
 			{
-				return default(Vector2);
+				return _directSizeSetting;
 			}
 			set
 			{
@@ -88,7 +93,7 @@ namespace YgomSystem.Effect
 		{
 			get
 			{
-				return false;
+				return _changePosition;
 			}
 			set
 			{
@@ -99,7 +104,7 @@ namespace YgomSystem.Effect
 		{
 			get
 			{
-				return false;
+				return _isUseFixedDepth;
 			}
 			set
 			{
@@ -110,88 +115,188 @@ namespace YgomSystem.Effect
 		{
 			get
 			{
-				return 0f;
+				return _fixedDepth;
 			}
 			set
 			{
 			}
 		}
 
-		public Camera viewCamera
+        public Camera viewCamera { get; private set; }
+
+        public bool scaleYtoZ
+        {
+            get
+            {
+                return m_ScaleYtoZ;
+            }
+            set
+            {
+            }
+        }
+
+        public void SetFitMode(FitMode fitMode)
 		{
-			[CompilerGenerated]
-			get
-			{
-				return null;
-			}
-			[CompilerGenerated]
-			private set
-			{
-			}
+			this.fitMode = fitMode;
 		}
 
-		public void SetFitMode(FitMode fitMode)
+        public FitMode GetFitMode()
+        {
+            return fitMode;
+        }
+
+        public Sprite TryGetTargetSprite()
+        {
+			if(targetSprite != null)
+				return targetSprite.sprite;
+            return null;
+        }
+
+        private void OnEnable()
+        {
+			StartCoroutine(SetupAsync());
+        }
+
+		private IEnumerator SetupAsync()
 		{
-		}
+            if (targetSprite == null) targetSprite = GetComponent<SpriteRenderer>();
+            var originalColor = targetSprite.color;
+            targetSprite.color = Color.clear;
 
-		public void Setup(Camera view_camera)
+            // Wait for the next frame to ensure script changes are ready.
+            yield return null;
+
+            targetSprite.color = originalColor;
+
+            Camera viewCamera = gameObject.layer switch
+            {
+                3 => Program.instance.camera_.camera2D,
+                16 => Program.instance.camera_.cameraDuelOverlay3D,
+                17 => Program.instance.camera_.cameraDuelOverlayEffect3D,
+                18 => Program.instance.camera_.cameraDuelOverlay2D,
+                19 => Program.instance.camera_.cameraDuelOverlayEffect2D,
+                _ => Program.instance.camera_.cameraMain,
+            };
+
+            Setup(viewCamera);
+        }
+
+        public void Setup(Camera view_camera)
 		{
-		}
-        private void Awake()
-        {
+			viewCamera = view_camera;
 			Apply();
-        }
+		}
 
         public void Apply()
 		{
-			var widthScale = transform.localScale.x;
-			var heightScale = transform.localScale.y;
-			var z = transform.localScale.z;
-            if (fitMode == FitMode.FitWidth)
-			{
-				var x = widthScale * (Screen.width * 9f / (Screen.height * 16f));
-				transform.localScale = new Vector3(x, heightScale, z);
-			}
-			else if(fitMode == FitMode.FitHeight)
-			{
-				var y = heightScale * (Screen.height * 16f / (Screen.width * 9f));
-				transform.localScale=new Vector3(widthScale, y, z);
-			}
-            else if (fitMode == FitMode.FitWidthMaintainAspectRatio)
-            {
-				if(name == "SpliteDummy" || name == "White")
-				{
-					var x = widthScale * (Screen.width * 9f / (Screen.height * 16f));
-					transform.localScale = new Vector3(x, heightScale * x / widthScale, z);
-				}
-				else if(name == "Black")
-				{
-					widthScale = 15f * (Screen.width * 9f / (Screen.height * 16f));
-					transform.localScale = new Vector3(widthScale, widthScale, z);
-				}
-            }
-            else if (fitMode == FitMode.FitHeightMaintainAspectRatio)
+            if (viewCamera == null)
+                return;
+
+            if (_changePosition)
+                transform.position = viewCamera.ViewportToWorldPoint(new Vector3(0.5f, 0.5f, _fixedDepth));
+
+            //float depth = _isUseFixedDepth ? _fixedDepth : viewCamera.WorldToScreenPoint(transform.position).z;
+            float depth = viewCamera.WorldToScreenPoint(transform.position).z;
+
+            float screenWidth;
+            float screenHeight;
+
+            if (viewCamera.orthographic)
             {
-				Debug.Log("mark: FitMode.FitHeightMaintainAspectRatio");
-				//heightScale = 6f;
-				//transform.localScale = new Vector3(heightScale, heightScale, z);
+                Vector3 bottomLeft = viewCamera.ViewportToWorldPoint(new Vector3(0, 0, depth));
+                Vector3 topRight = viewCamera.ViewportToWorldPoint(new Vector3(1, 1, depth));
+                screenWidth = topRight.x - bottomLeft.x;
+                screenHeight = topRight.y - bottomLeft.y;
             }
-            else if (fitMode == FitMode.FitWidthHeight)
+            else
             {
-                var x = heightScale * Screen.width / Screen.height;
-                transform.localScale = new Vector3(x * 1.1f, heightScale, z);
-				if (transform.parent != null && transform.parent.name.StartsWith("Ef04678"))
-                    transform.localScale = new Vector3(x * 2f, heightScale * 2f, z);
+                float halfFOV = viewCamera.fieldOfView * 0.5f * Mathf.Deg2Rad;
+                screenHeight = 2f * depth * Mathf.Tan(halfFOV);
+                screenWidth = screenHeight * viewCamera.aspect;
             }
+            Apply(screenWidth, screenHeight);
         }
 
         public void Apply(float screenWidth, float screenHeight)
 		{
-		}
+            if (isApplied && appliedScreenSize.x == screenWidth && appliedScreenSize.y == screenHeight)
+                return;
+
+            if (targetSprite == null) targetSprite = GetComponent<SpriteRenderer>();
+            if (targetMask == null) targetMask = GetComponent<SpriteMask>();
+
+            Sprite sprite = TryGetTargetSprite();
+            if (sprite == null) return;
+
+            Vector2 spriteSize = sprite.rect.size / sprite.pixelsPerUnit;
+            Vector2 targetSize = Vector2.zero;
+
+            if (_useDirectSizeSetting)
+            {
+                targetSize = _directSizeSetting;
+            }
+            else
+            {
+                switch (fitMode)
+                {
+                    case FitMode.None:
+                        targetSize = spriteSize;
+                        break;
+                    case FitMode.FitWidth:
+                        targetSize = new Vector2(screenWidth, spriteSize.y);
+                        break;
+                    case FitMode.FitHeight:
+                        targetSize = new Vector2(spriteSize.x, screenHeight);
+                        break;
+                    case FitMode.FitWidthMaintainAspectRatio:
+                        float widthScale = screenWidth / spriteSize.x;
+                        targetSize = spriteSize * widthScale;
+                        break;
+                    case FitMode.FitHeightMaintainAspectRatio:
+                        float heightScale = screenHeight / spriteSize.y;
+                        targetSize = spriteSize * heightScale;
+                        break;
+                    case FitMode.FitWidthHeight:
+                        targetSize = new Vector2(screenWidth, screenHeight);
+                        break;
+                    case FitMode.FitHighestResolutionMaintainAspectRatio:
+                        float maxScale = Mathf.Max(screenWidth / spriteSize.x, screenHeight / spriteSize.y);
+                        targetSize = spriteSize * maxScale;
+                        break;
+                    case FitMode.FitLowestResolutionMaintainAspectRatio:
+                        float minScale = Mathf.Min(screenWidth / spriteSize.x, screenHeight / spriteSize.y);
+                        targetSize = spriteSize * minScale;
+                        break;
+                    default:
+                        targetSize = spriteSize;
+                        break;
+                }
+            }
+
+            Vector3 newScale = new(
+                targetSize.x / spriteSize.x,
+                targetSize.y / spriteSize.y,
+                1f
+            );
+
+			newScale += offsetScale;
+
+            if (m_ScaleYtoZ)
+                newScale.z = newScale.y;
+
+            transform.localScale = newScale;
+
+            isApplied = true;
+            appliedScreenSize = new Vector2(screenWidth, screenHeight);
+
+            Debug.Log($"SpriteScaler applied: {gameObject.name}, Camera: {viewCamera}, Mode: {fitMode}, Scale: {transform.localScale}, Screen Size: {appliedScreenSize}");
+        }
 
 		public void Reapply()
 		{
-		}
+            isApplied = false;
+            Apply();
+        }
 
 		private void OnDestroy()
 		{
@@ -199,6 +304,8 @@ namespace YgomSystem.Effect
 
 		private void Update()
 		{
-		}
+            if (applyOnUpdate && viewCamera != null)
+                Apply();
+        }
 	}
 }