Documentation

Unity Engine

User Manual

Script Reference

Unity Engine

Blit

Uses a shader to copy the pixel data from a texture into a render target.
Read time 42 minutesLast updated 13 days ago

Definition

  • Type: Method
  • Namespace: UnityEngine
  • Assembly: UnityEngine.CoreModule

Blit(Texture, RenderTexture)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, RenderTexture, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest, int sourceDepthSlice, int destDepthSlice)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

sourceDepthSlice

int
The element in the source texture to copy from, for example the texture in a texture array. You can't use 
sourceDepthSlice
to specify a face in a Cubemap.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, RenderTexture, Vector2, Vector2)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest, Vector2 scale, Vector2 offset)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

scale

Vector2
The scale to apply.

offset

Vector2
The offset to apply.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, RenderTexture, Vector2, Vector2, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest, Vector2 scale, Vector2 offset, int sourceDepthSlice, int destDepthSlice)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

scale

Vector2
The scale to apply.

offset

Vector2
The offset to apply.

sourceDepthSlice

int
The element in the source texture to copy from, for example the texture in a texture array. You can't use 
sourceDepthSlice
to specify a face in a Cubemap.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, RenderTexture, Material, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest, Material mat, int pass)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

pass

int
If the value is 
-1
, Unity draws all the passes in 
mat
. Otherwise, Unity draws only the pass you set 
pass
to. The default value is 
-1
.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, RenderTexture, Material, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest, Material mat, int pass, int destDepthSlice)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

pass

int
If the value is 
-1
, Unity draws all the passes in 
mat
. Otherwise, Unity draws only the pass you set 
pass
to. The default value is 
-1
.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, RenderTexture, Material)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, RenderTexture dest, Material mat)

Parameters

source

Texture
The source texture.

dest

RenderTexture
The destination RenderTexture or GraphicsTexture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, Material, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, Material mat, int pass)

Parameters

source

Texture
The source texture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

pass

int
If the value is 
-1
, Unity draws all the passes in 
mat
. Otherwise, Unity draws only the pass you set 
pass
to. The default value is 
-1
.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, Material, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, Material mat, int pass, int destDepthSlice)

Parameters

source

Texture
The source texture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

pass

int
If the value is 
-1
, Unity draws all the passes in 
mat
. Otherwise, Unity draws only the pass you set 
pass
to. The default value is 
-1
.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, Material)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, Material mat)

Parameters

source

Texture
The source texture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest, int sourceDepthSlice, int destDepthSlice)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

sourceDepthSlice

int
The element in the source texture to copy from, for example the texture in a texture array. You can't use 
sourceDepthSlice
to specify a face in a Cubemap.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture, Vector2, Vector2)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest, Vector2 scale, Vector2 offset)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

scale

Vector2
The scale to apply.

offset

Vector2
The offset to apply.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture, Vector2, Vector2, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest, Vector2 scale, Vector2 offset, int sourceDepthSlice, int destDepthSlice)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

scale

Vector2
The scale to apply.

offset

Vector2
The offset to apply.

sourceDepthSlice

int
The element in the source texture to copy from, for example the texture in a texture array. You can't use 
sourceDepthSlice
to specify a face in a Cubemap.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture, Material, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest, Material mat, int pass)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

pass

int
If the value is 
-1
, Unity draws all the passes in 
mat
. Otherwise, Unity draws only the pass you set 
pass
to. The default value is 
-1
.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture, Material, int, int)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest, Material mat, int pass, int destDepthSlice)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

pass

int
If the value is 
-1
, Unity draws all the passes in 
mat
. Otherwise, Unity draws only the pass you set 
pass
to. The default value is 
-1
.

destDepthSlice

int
The element in the destination texture to copy from, for example the texture in a texture array. You can't use 
destDepthSlice
to specify a face in a Cubemap.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}

Blit(Texture, GraphicsTexture, Material)

Uses a shader to copy the pixel data from a texture into a render target.
public static void Blit(Texture source, GraphicsTexture dest, Material mat)

Parameters

source

Texture
The source texture.

dest

GraphicsTexture
The destination RenderTexture or GraphicsTexture.

mat

Material
The material to use. If you don't provide 
mat
, Unity uses a default material.

Remarks

This method copies pixel data from a texture on the GPU to a render texture or graphics texture on the GPU. This is one of the fastest ways to copy a texture.
When you use 
Graphics.Blit
, Unity does the following:
  1. Sets the active render target to the 
    dest
    texture. (See RenderTexture.active and GraphicsTexture.active.)
  2. Passes 
    source
    to the 
    mat
    material as the 
    _MainTex
    property.
  3. Uses the material's shader to draw a full-screen surface from the 
    source
    texture to the 
    dest
    texture.
If you provide a 
mat
material that doesn't have a 
_MainTex
property, 
Blit
doesn't use 
source
. If you provide a GraphicsTexture as 
dest
, it must have GraphicsTextureDescriptorFlags.RenderTarget enabled in its GraphicsTextureDescriptor.flags.
You can use 
Graphics.Blit
to create post-processing effects, by setting 
mat
to a material with a custom shader.
Blit
changes RenderTexture.active and GraphicsTexture.active. Store the active render target before you use 
Blit
if you need to use it afterwards.
Avoid setting 
source
and 
dest
to the same texture, as this may cause undefined behaviour. Use Custom Render Textures with double buffering instead, or use two render textures and alternate between them to implement double buffering manually.
In linear color space, set GL.sRGBWrite before using 
Blit
, to make sure the sRGB-to-linear color conversion is what you expect.
To blit to the screen in the Built-in Render Pipeline, follow these steps:
  1. Set 
    dest
    to 
    null
    . Unity now uses 
    Camera.main.targetTexture
    as the destination texture.
  2. Set the Camera.targetTexture property of Camera.main to 
    null
    .
To blit to the screen in the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must call Graphics.Blit or CommandBuffer.Blit inside a method that you call from the RenderPipelineManager.endContextRendering callback.
If you want to use a depth or stencil buffer that is part of the source (Render)texture, or blit to a subregion of a texture, you have to manually write an equivalent of the Graphics.Blit function - i.e. Graphics.SetRenderTarget with destination color buffer and source depth buffer, setup orthographic projection (GL.LoadOrtho), setup material pass (Material.SetPass) and draw a quad (GL.Begin).
Additional Resources: Graphics.BlitMultiTap, Post-processing effects.

Examples

using UnityEngine;public class Example : MonoBehaviour{ // Copies aTexture to rTex and displays it in all cameras.    Texture aTexture;    RenderTexture rTex;    void Start()    {        if (!aTexture || !rTex)        {            Debug.LogError("A texture or a render texture are missing, assign them.");        }    }    void Update()    {        Graphics.Blit(aTexture, rTex);    }}