Comments

• ChrisIceBox

  August 2020

  Parallax2D does not account for screen ratio directly, but If you're using the Dynamic Camera Limits wiki script, then that camera's position does depend on the ratio, which in turn will affect the parallax position.

  Try this instead:

  using UnityEngine;
  
  public class EdgeParallax : MonoBehaviour
  {
  
      [SerializeField] private EdgeType edgeType = EdgeType.LeftEdge;
      [SerializeField] private Transform edgeMarker = null;
      [SerializeField] private float depth = 0f;
      private enum EdgeType { LeftEdge, RightEdge };
      private Vector3 originalPosition;
  
      private void Awake()
      {
          originalPosition = transform.position;
      }
  
      private void LateUpdate ()
      {
          float edgeMarkerScreenPosition = Camera.main.WorldToScreenPoint (edgeMarker.position).x / Camera.main.pixelWidth;
          switch (edgeType)
          { 
              case EdgeType.LeftEdge:
                  transform.position = new Vector3 (originalPosition.x - (edgeMarkerScreenPosition * depth), originalPosition.y, originalPosition.z);
                  break;
  
              case EdgeType.RightEdge:
                  edgeMarkerScreenPosition = 1f - edgeMarkerScreenPosition;
                  transform.position = new Vector3(originalPosition.x + (edgeMarkerScreenPosition * depth), originalPosition.y, originalPosition.z);
                  break;
          }
      }
  
  }
  
• kloot

  August 2020 edited August 2020

  That almost works, but it breaks apart when the screen ratio gets too wide:
  https://1drv.ms/u/s!Amz_vh8OYDX3vKt15F7uVgYmeMhxJA?e=QPUw0Y

  Here's a fresh repro that illustrates the problem:
  https://1drv.ms/u/s!Amz_vh8OYDX3vKt2Ny_K4CJvmOECzA?e=fhW9mQ

  Here's an idea: Since the DynamicCameraLimits script seem to be the root of the problem... Maybe the min/max settings of GameCamera2D could be hooked up to the edge markers and there would be no need for DynamicCameraLimits at all. That would make such a great addition to the out-of-the-box offering of AC.

  This has been the last thing I haven't been able to get AC to handle, I would so love a solution to this.

  Thanks a bunch!
• ChrisIceBox

  August 2020 edited August 2020

  That almost works, but it breaks apart when the screen ratio gets too wide:

  But the camera there is also going beyond the limits of the background. So long as the camera doesn't go past the edge marker, it should be OK.

  Maybe the min/max settings of GameCamera2D could be hooked up to the edge markers

  I've thought of that as well, but it's problematic to know what the camera's edge positions will be in advance of it actually being there. I shall give it some more thought, though.
• kloot

  August 2020

  But the camera there is also going beyond the limits of the background. So long as the camera doesn't go past the edge marker, it should be OK.

  Yes, but this is not that unusual. This happens pretty much anytime anyone with a really wide screen monitor (which are getting more common) plays one of these games. We pad with black borders to make up for this, but the markers would have to be where they are on the repro in order to work right for less wide screen ratios.

  If only the foreground elements would stay put at the screen limits rather than moving "inside" the screen it would be fine, but as it is, people are reporting broken off pieces of foreground floating across the screen.

  I've thought of that as well, but it's problematic to know what the camera's edge positions will be in advance of it actually being there. I shall give it some more thought, though.

  Well, I really appreciate you looking into this, as it stands I'm leaning towards non moving foregrounds since the results on wide screens are just super extreme.
• ChrisIceBox

  August 2020

  If only the foreground elements would stay put at the screen limits rather than moving "inside" the screen it would be fine

  You need only clamp the calculated float in LateUpdate. Here's one that does that, and also removes the need to define edge markers (provided the foreground element is already in the most extreme position):

  using UnityEngine;
  
  public class EdgeParallax : MonoBehaviour
  {
  
      [SerializeField] private EdgeType edgeType = EdgeType.LeftEdge;
      [SerializeField] private float depth = 0f;
      private enum EdgeType { LeftEdge, RightEdge };
      private Vector3 originalPosition;
  
      private void Awake ()
      {
          originalPosition = transform.position;
      }
  
      private void LateUpdate ()
      {
          float originalScreenPosition = Camera.main.WorldToScreenPoint (originalPosition).x / Camera.main.pixelWidth;
          switch (edgeType)
          { 
              case EdgeType.LeftEdge:
                  if (originalScreenPosition > 0f) originalScreenPosition = 0f;
                  transform.position = new Vector3 (originalPosition.x - (originalScreenPosition * depth), originalPosition.y, originalPosition.z);
                  break;
  
              case EdgeType.RightEdge:
                  if (originalScreenPosition < 1f) originalScreenPosition = 1f;
                  originalScreenPosition = 1f - originalScreenPosition;
                  transform.position = new Vector3(originalPosition.x + (originalScreenPosition * depth), originalPosition.y, originalPosition.z);
                  break;
          }
      }
  
  }
  

  the results on wide screens are just super extreme

  This is experimental, and only works when using Orthographic projection, but give this a try:

  using UnityEngine;
  using AC;
  
  [RequireComponent(typeof(GameCamera2D))]
  public class DynamicCameraLimits : MonoBehaviour
  {
  
      #region Variables
  
      [SerializeField] private Transform bottomLeftCorner = null;
      [SerializeField] private Transform topRightCorner = null;
      [SerializeField] private bool updateHorizontalLimits = true;
      [SerializeField] private bool updateVerticalLimits = false;
      private GameCamera2D gameCamera2D;
  
      #endregion
  
      #region UnityStandards
  
      private void OnEnable()
      {
          gameCamera2D = GetComponent<GameCamera2D>();
  
          EventManager.OnUpdatePlayableScreenArea += OnUpdatePlayableScreenArea;
      }
  
  
      private void OnDisable()
      {
          EventManager.OnUpdatePlayableScreenArea -= OnUpdatePlayableScreenArea;
      }
  
      #endregion
  
  
      #region PrivateFunctions
  
      private void OnUpdatePlayableScreenArea()
      {
          if (bottomLeftCorner == null || topRightCorner == null) return;
          if (!updateHorizontalLimits && !updateVerticalLimits) return;
  
          gameCamera2D = GetComponent<GameCamera2D>();
  
          Vector3 bottomLeftWorldPosition = Camera.main.ViewportToWorldPoint (new Vector3 (0f, 0f, gameCamera2D.Camera.nearClipPlane));
          Vector3 topRightWorldPosition = Camera.main.ViewportToWorldPoint (new Vector3 (1f, 1f, gameCamera2D.Camera.nearClipPlane));
  
          Vector2 bottomLeftOffset = new Vector2 (transform.position.x - bottomLeftWorldPosition.x, transform.position.y - bottomLeftWorldPosition.y);
          Vector2 topRightOffset = new Vector2 (transform.position.x - topRightWorldPosition.x, transform.position.y - topRightWorldPosition.y);
  
          if (updateHorizontalLimits)
          {
              Vector2 hLimits = new Vector2 (bottomLeftOffset.x + bottomLeftCorner.position.x, topRightOffset.x + topRightCorner.position.x);
              gameCamera2D.constrainHorizontal = hLimits;
          }
  
          if (updateVerticalLimits)
          {
              Vector2 vLimits = new Vector2 (bottomLeftOffset.y + bottomLeftCorner.position.y, topRightOffset.y + topRightCorner.position.y);
              gameCamera2D.constrainVertical = vLimits;
          }
      }
  
      #endregion
  
  }
  
• kloot

  August 2020

  Nice!
  EdgeParallax works flawlessly! 👌

  DynamicCameraLimits also works fine in my experiments though when I resize the game window in free aspect mode to narrow ratios I sometime get some of the area outside the limit marker in view. But I noticed that if I "refresh" it by switching player to one in a new scene and then back, everything looks perfect again. And I don't really need perfect results as typically people don't get to resize in-game anyway.
  I noticed it still affects game objects with the Parallax2D component differently depending on the screen ratio, but that doesn't matter now that we can use EdgeParallax for objects that should be snapped to the edges!
  Using the markers makes it easier to use than the previous version of DynamicCameraLimits too, will you be including these components in a release perhaps?

  Thanks a bunch. I'll make sure to update my review of this asset with even more praise 👍