src | Source texture. |
dst | Destination texture. |
srcElement | Source texture element (cubemap face, texture array layer or 3D texture depth slice). |
srcMip | Source texture mipmap level. |
dstElement | Destination texture element (cubemap face, texture array layer or 3D texture depth slice). |
dstMip | Destination texture mipmap level. |
srcX | X coordinate of source texture region to copy (left side is zero). |
srcY | Y coordinate of source texture region to copy (bottom is zero). |
srcWidth | Width of source texture region to copy. |
srcHeight | Height of source texture region to copy. |
dstX | X coordinate of where to copy region in destination texture (left side is zero). |
dstY | Y coordinate of where to copy region in destination texture (bottom is zero). |
Copy texture contents.
This function allows copying pixel data from one texture into another efficiently.
It also allows copying from an element (e.g. cubemap face) or a specific mip level, and from a subregion of a texture.
When you copy from an element it does not perform any scaling. As a result, the source and destination sizes must be the same. Texture formats should be compatible, for example, TextureFormat.ARGB32
and RenderTextureFormat.ARGB32. MSAA sample counts for render textures should also be the same. Generally, you can always copy formats that are exactly the same, but format compatibility does vary
between graphics APIs. On some platforms (e.g. D3D11) you can also copy between formats that are of the same bit width.
You can load Textures at different resolutions by using QualitySettings.masterTextureLimit. Note that this affects CopyTextures as you cannot copy a full mip between textures with different master
texture limit values. If you need to copy between textures with a different master texture limit, use the region-based overload. The region-based overload adjusts the source rectangle based on the source
texture's master texture limit. It also adjusts the destination offset based on the destination's master texture limit. For example, copying a 128x128 area from position 16,16 to position 32,32 results
in the following behaviours in these example cases:
The following sample shows how you can copy to or from a Texture2DArray, when Texture2Ds are subject to a master texture limit different from 0:
using UnityEngine;
public class CopyTextureSample : MonoBehaviour { // Sample to copy all available mips: inTex -> outArray (no master texture limits) -> outTex [SerializeField] Texture2D inTex; [SerializeField] Texture2DArray outArray; [SerializeField] Texture2D outTex; [SerializeField] bool considerMasterTextureLimits;
void Start() { int width = inTex.width; int height = inTex.width; outArray = new Texture2DArray(width, height, 1, inTex.format, true); outTex = new Texture2D(width, height, inTex.format, true);
if (!considerMasterTextureLimits) { // Texture2D -> Texture2DArray // Master Texture Limit: "1: Half Resolution" => copies into mips that are now too large; will copy each mip of inTex into a quarter of outArray for (int mip = 0; mip < inTex.mipmapCount; ++mip) { int copyWidth = width >> mip; int copyHeight = height >> mip; Graphics.CopyTexture(inTex, 0, mip, 0, 0, copyWidth, copyHeight, outArray, 0, mip, 0, 0); }
// Texture2DArray -> Texture2D // Master Texture Limit: "1: Half Resolution" => errors, since we try to copy into mips that are now too small for (int mip = 0; mip < outArray.mipmapCount; ++mip) { int copyWidth = width >> mip; int copyHeight = height >> mip; Graphics.CopyTexture(outArray, 0, mip, 0, 0, copyWidth, copyHeight, outTex, 0, mip, 0, 0); } } else // considering master texture limits { int masterTextureLimit = QualitySettings.masterTextureLimit; // Texture2D -> Texture2DArray // Master Texture Limit: "1: Half Resolution" => mip0 of outArray is not written to, other mips copy as expected // (ALTERNATIVE: if outArray creation already considered masterTextureLimit for its dimensions, // the CopyTexture call can ignore masterTextureLimit since the mips will line up again) for (int mip = 0; mip < inTex.mipmapCount - masterTextureLimit; ++mip) { int copyWidth = width >> mip; int copyHeight = height >> mip; int srcMip = mip; int dstMip = mip + masterTextureLimit; Graphics.CopyTexture(inTex, 0, srcMip, 0, 0, copyWidth, copyHeight, outArray, 0, dstMip, 0, 0); }
// Texture2DArray -> Texture2D // Master Texture Limit: "1: Half Resolution" => mip0 of outArray is not copied (but outTex does not upload it to GPU anyway) for (int mip = masterTextureLimit; mip < outArray.mipmapCount; ++mip) { int copyWidth = width >> mip; int copyHeight = height >> mip; int srcMip = mip; int dstMip = mip - masterTextureLimit; Graphics.CopyTexture(outArray, 0, srcMip, 0, 0, copyWidth, copyHeight, outTex, 0, dstMip, 0, 0); } } } }
Mipmap level arguments always apply to the texture as loaded under the current master texture limit. For example, a 256x256 texture with master texture limit set to 0 mip 1 refers to a 128x128 mip.
However, if the mastertexture limit is set to 2 on that texture, mip 1 refers to a 32x32 mip. This means that in many cases when using CopyTexture you do not need to take the master texture limit into
account in your calls. In less common calls (for example, copying from Texture2D to TextureArray) you do need to adjust for it. To copy textures in a cubemap array, calculate the destination element as
6 * cubemapIndex + faceIndex. As a result, the six faces from the cubemap at index 0 are elements 0,1,2... 5. The six faces from the cubemap at array index 1 are 6,7 .... 11 and so on.
Compressed texture formats add some restrictions to the CopyTexture with a region variant. For example, PVRTC formats
are not supported since they are not block-based (for these formats you can only copy whole texture or whole mip level).
For block-based formats (e.g. DXT, BCn, ETC), the region size and coordinates must be a multiple of compression block size
(4 pixels for DXT).
If both source and destination textures are marked as "readable" (i.e. copy of data exists
in system memory for reading/writing on the CPU), these functions copy it as well.
Some platforms might not have functionality of all sorts of texture copying (e.g. copy from a
render texture into a regular texture). See CopyTextureSupport, and use
SystemInfo.copyTextureSupport to check.
Calling Texture2D.Apply, Texture2DArray.Apply or Texture3D.Apply after CopyTexture
yields undefined results as CopyTexture
operates on GPU-side data exclusively, whereas Apply
transfers data from CPU to GPU-side.
See Also: CopyTextureSupport.