How To Make Parallax Background Infinite Scrolling Unity

Robin Robert

3 min read

·

03-02-2025

1

0

Share

Creating an infinite scrolling parallax background in Unity adds a captivating layer of depth and immersion to your 2D games. This tutorial will guide you through the process, equipping you with the knowledge to implement this visually stunning effect. We'll cover everything from setting up the scene to implementing smooth, seamless looping.

Understanding Parallax Scrolling

Parallax scrolling is a technique where background layers move at different speeds, creating an illusion of depth. Closer layers move faster, while further layers move slower, mimicking the perspective experienced in real life. This simple effect significantly enhances the visual appeal of games, particularly in side-scrolling or endless runner genres. The "infinite" aspect means the background seamlessly loops, creating the impression of endless movement.

Setting Up Your Scene in Unity

1. Create Your Background Layers: Begin by creating several sprite images representing your background layers. Ideally, these should have varying levels of detail and visual complexity. For instance, you might have a far background with mountains, a middle layer with trees, and a close layer with bushes or smaller details. Remember to ensure seamless looping; the edges of your sprites should blend seamlessly to avoid noticeable repetition.

2. Import Sprites into Unity: Import your background sprite images into your Unity project. Make sure the sprites have the correct aspect ratio and resolution for your game. Place them in a suitable folder for organization.

3. Create Game Objects: Create separate GameObjects in your Unity scene for each background layer. Assign the corresponding sprites as their respective sprites. You'll need one GameObject for each layer. Position them strategically to create the parallax effect.

Implementing the Script

This is where the magic happens. We'll create a C# script to manage the parallax scrolling.

using UnityEngine;

public class ParallaxBackground : MonoBehaviour
{
    public Transform[] backgrounds; // Array to hold background layers
    public float[] parallaxSpeeds; // Array to define speed for each layer
    private float screenHeight;

    void Start()
    {
        screenHeight = 2f * Camera.main.orthographicSize; // Calculate screen height
    }

    void Update()
    {
        foreach (Transform bg in backgrounds)
        {
            float speed = parallaxSpeeds[System.Array.IndexOf(backgrounds, bg)]; //get individual speed
            float newPosition = bg.position.y + speed * Time.deltaTime; // Calculate new position

            if (newPosition < -screenHeight)
            {
                newPosition += screenHeight * 2f; //Looping mechanism
            }
             else if (newPosition > screenHeight)
            {
                newPosition -= screenHeight * 2f; //Looping mechanism
            }
            
            Vector3 newPos = new Vector3(bg.position.x, newPosition, bg.position.z);
            bg.position = newPos; // Apply new position

        }
    }
}

Explanation:

• backgrounds: This array holds references to the GameObjects representing your background layers. You'll assign these in the Unity editor.
• parallaxSpeeds: This array defines the scrolling speed for each layer. Layers further in the background should have lower speeds.
• screenHeight: This variable calculates the height of the camera's view.
• Update(): This function runs every frame. It iterates through the background layers, updating their positions based on their parallax speed and implementing the looping mechanism. The looping logic ensures seamless transition when a background layer moves off-screen.

Attaching the Script and Configuring in Unity

1. Create a new C# script in your Unity project and paste the code above.
2. Create an empty GameObject in your scene. Name it something like "Parallax Manager."
3. Attach the script to the "Parallax Manager" GameObject.
4. In the Inspector panel, drag and drop your background GameObjects into the backgrounds array.
5. Set the corresponding speeds in the parallaxSpeeds array. Experiment with different values to achieve the desired effect. Layers further away should have smaller values.

Optimizing for Performance

For optimal performance, consider these points:

• Sprite Resolution: Use appropriately sized sprites. Avoid excessively high-resolution images that can impact performance.
• Layer Ordering: Ensure your layers are correctly ordered in the scene hierarchy. Layers further in the background should be placed behind closer layers.
• Pooling: For complex backgrounds or many layers, consider using object pooling to recycle GameObjects instead of constantly instantiating and destroying them.

By following these steps, you can create a captivating and efficient infinite scrolling parallax background in your Unity project. Remember to experiment with different speeds and layer combinations to find the perfect visual style for your game. Happy coding!