Unity渲染展示（一） 相机渲染背景

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

[RequireComponent(typeof(MeshFilter))]
[RequireComponent(typeof(MeshRenderer))]
[ExecuteInEditMode]
public class CameraBackground : MonoBehaviour
{
    public enum QuadMatchMode
    {
        /// <summary>
        /// Expand the Quad area either horizontally or vertically, so the size of the Quad will never be smaller than the Camera Viewport.
        /// </summary>
        Expand = 1,
        /// <summary>
        /// Crop the Quad area either horizontally or vertically, so the size of the Quad will never be larger than the Camera Viewport.
        /// </summary>
        Shrink = 2
    }

    [Tooltip("需要Quad适配的Camera")]
    public Camera _camera;

    [Tooltip("Quad贴图渲染使用的Shader名称")]
    public string _shaderName = "Unlit/Transparent-Color";

    [Tooltip("Camera视窗下Quad的适配模式")]
    public QuadMatchMode _quadMatchMode = QuadMatchMode.Expand;

    [Tooltip("摄像机背景图片原始尺寸大小（适配需要）")]
    public Vector2 _viewSize = Vector2.zero;
    public Vector3 _size = new Vector3(Screen.width, Screen.height, 0);
    private float _aspectRatio;

    private float _matchW;
    private float _matchH;
    private float _matchAspectRatio;

    private MeshRenderer _meshRenderer;
    private Material _material;
    Material material
    {
        get
        {
            if (_meshRenderer == null)
            {
                _meshRenderer = GetComponent<MeshRenderer>();
            }
            if (_meshRenderer.material != null)
            {
                _material = _meshRenderer.material;
            }
            else
            {
                _material = new Material(Shader.Find(_shaderName));
                _material.hideFlags = HideFlags.HideAndDontSave;
                _meshRenderer.material = _material;
            }
            return _material;
        }
    }

    void OnEnable()
    {
        if (_camera == null)
        {
            _camera = Camera.main;
        }
        _viewSize = Vector2.zero;
        Ray ray = new Ray(_camera.transform.position, _camera.transform.forward);
        transform.position = ray.GetPoint(_camera.farClipPlane - _camera.nearClipPlane - 0.1f);
        transform.forward = _camera.transform.forward;
        resetSize();
    }

#if UNITY_EDITOR
    void Update()
    {
        resetSize();
        Debug.DrawRay(_camera.transform.position, _camera.transform.forward * (_camera.farClipPlane - _camera.nearClipPlane - 0.1f), Color.red);
    }
#endif

    public void SetViewSize(Vector2 size)
    {
        _viewSize = size;
        resetSize();
    }

    public void SetTexture(Texture texture, Color blurColor, float w = 1280f, float h = 720f)
    {
        material.mainTexture = texture;
        material.color = blurColor;
        _size.x = w;
        _size.y = h;
        resetSize();
    }

    public void resetSize()
    {
        if (_camera == null) return;
        _matchH = Mathf.Tan(_camera.fieldOfView * 0.5f * Mathf.Deg2Rad) * (_camera.farClipPlane) * 2;
        if (_viewSize != Vector2.zero)
        {
            _matchW = (_viewSize.x / _viewSize.y) * _matchH;
        }
        else
        {
            _matchW = ((float)Screen.width / (float)Screen.height) * _matchH;
        }
        _matchAspectRatio = _matchW / _matchH;

        _aspectRatio = _size.x / _size.y;

        if (_aspectRatio == _matchAspectRatio)
        {
            _size.x = _matchW;
            _size.y = _matchH;
        }
        else if (_aspectRatio > _matchAspectRatio)
        {
            if (_quadMatchMode == QuadMatchMode.Expand)
            {
                _size.x = _size.x / _size.y * _matchH;
                _size.y = _matchH;
            }
            else if (_quadMatchMode == QuadMatchMode.Shrink)
            {
                _size.y = _size.y / _size.x * _matchW;
                _size.x = _matchW;
            }
        }
        else if (_aspectRatio < _matchAspectRatio)
        {
            if (_quadMatchMode == QuadMatchMode.Expand)
            {
                _size.y = _size.y / _size.x * _matchW;
                _size.x = _matchW;
            }
            else if (_quadMatchMode == QuadMatchMode.Shrink)
            {
                _size.x = _size.x / _size.y * _matchH;
                _size.y = _matchH;
            }
        }
        transform.localScale = _size;
    }

    void OnDestroy()
    {
        if (_material) Object.DestroyImmediate(_material);
        _material = null;
    }
}