Scaling my background Sprite to fill screen? (2d)

A little dated post, but you can do that simpler with C#

 SpriteRenderer sr = GetComponent<SpriteRenderer>();

 float worldScreenHeight = Camera.main.orthographicSize * 2;
 float worldScreenWidth = worldScreenHeight / Screen.height * Screen.width;
         
 transform.localScale = new Vector3(
     worldScreenWidth / sr.sprite.bounds.size.x,
     worldScreenHeight / sr.sprite.bounds.size.y, 1);

Also, you may not want to do "if(sr==null) return;", because debugger would just let it run and you wouldn't see where the error is.

Zafis, your right that would also work...

Use "Public SpriteRender sr;" at the beginning of the script ins$$anonymous$$d of "SpriteRenderer sr = GetComponent();" so that you can use it in any gameobject, however this requires more work if the sprite is created by code...

Dated addition. Also, probably a little redundant and not the cleanest solution. However, I've modified the above to allow for keeping an aspect ratio (so if you try and put a 640x480 sprite on a 500x500 screen - it will create a 667x500 sprite).

In this case, I called it AutoStretchSprite.cs and attached it to a SpriteRender.

 using UnityEngine;
 using System.Collections;
 [RequireComponent(typeof(SpriteRenderer))]
 
 public class AutoStretchSprite : $$anonymous$$onoBehaviour {
 
     /// <summary> Do you want the sprite to maintain the aspect ratio? </summary>
     public bool $$anonymous$$eepAspectRatio = true;
     /// <summary> Do you want it to continually check the screen size and update? </summary>
     public bool ExecuteOnUpdate = true;
 
     void Start () {
         Resize($$anonymous$$eepAspectRatio);
     }
     
     void FixedUpdate () {
         if (ExecuteOnUpdate)
             Resize($$anonymous$$eepAspectRatio);
     }
 
     /// <summary>
     /// Resize the attached sprite according to the camera view
     /// </summary>
     /// <param name="keepAspect">bool : if true, the image aspect ratio will be retained</param>
     void Resize(bool keepAspect = false)
     {
         SpriteRenderer sr = GetComponent<SpriteRenderer>();
         transform.localScale = new Vector3(1, 1, 1);
 
         // example of a 640x480 sprite
         float width = sr.sprite.bounds.size.x; // 4.80f
         float height = sr.sprite.bounds.size.y; // 6.40f
 
         // and a 2D camera at 0,0,-10
         float worldScreenHeight = Camera.main.orthographicSize * 2f; // 10f
         float worldScreenWidth = worldScreenHeight / Screen.height * Screen.width; // 10f
 
         Vector3 imgScale = new Vector3(1f, 1f, 1f);
 
         // do we scale according to the image, or do we stretch it?
         if (keepAspect)
         {
             Vector2 ratio = new Vector2(width / height, height / width);
             if ((worldScreenWidth / width) > (worldScreenHeight / height))
             {
                 // wider than tall
                 imgScale.x = worldScreenWidth / width;
                 imgScale.y = imgScale.x * ratio.y; 
             }
             else
             {
                 // taller than wide
                 imgScale.y = worldScreenHeight / height;
                 imgScale.x = imgScale.y * ratio.x;             
             }
         }
         else
         {
             imgScale.x = worldScreenWidth / width;
             imgScale.y = worldScreenHeight / height;
         }
 
         // apply change
         transform.localScale = imgScale;
     }
 }

This is great, thanks

Just a little note: this code does not work if the Sprite in a child object and the parent Object has scale not equal to (1,1,1). I've made 2 adjustents:

1) The image is centered with the camera; 2) The localScale is modified to fit the screen even if the sprite is a child of some other GameObject

 SpriteRenderer sr = GetComponent<SpriteRenderer>();
 
         transform.position = Camera.main.transform.position + Vector3.forward * this.transform.position.z;
 
         transform.localScale = new Vector3(1, 1, 1);
         Vector3 lossyScale = transform.lossyScale;
 
         float width = sr.sprite.bounds.size.x;
         float height = sr.sprite.bounds.size.y;
 
         float worldScreenHeight = Camera.main.orthographicSize * 2f;
         float worldScreenWidth = worldScreenHeight / Screen.height * Screen.width;
 
         Vector3 xWidth = transform.localScale;
         xWidth.x = worldScreenWidth / width;
         transform.localScale = xWidth;
         //transform.localScale.x = worldScreenWidth / width;
         Vector3 yHeight = transform.localScale;
         yHeight.y = worldScreenHeight / height;
         transform.localScale = yHeight;
 
         Vector3 newLocalScale = new Vector3(transform.localScale.x / lossyScale.x,
             transform.localScale.y / lossyScale.y,
             transform.localScale.z / lossyScale.z
         );
 
         transform.localScale = newLocalScale;