///一些Texture的设置Unity2019.4新特性

HDR Textures

When importing from an EXR or HDR
 file containing HDR information, the Texture Importer automatically chooses the right HDR format for the output Texture. This format changes automatically depending on which platform you are building for.

Texture dimension sizes

Ideally, Texture dimension sizes should be powers of two on each side (that is, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048 pixels (px), and so on). The Textures do not have to be square; that is the width can be different from height.

It is possible to use NPOT (non-power of two) Texture sizes with Unity. However, NPOT Texture sizes generally take slightly more memory and might be slower for the GPU to sample, so it’s better for performance to use power of two sizes whenever you can.

If the platform or GPU does not support NPOT Texture sizes, Unity scales and pads the Texture up to the next power of two size. This process uses more memory and makes loading slower (especially on older mobile devices). In general, you should only use NPOT sizes for GUI purposes.

You can scale up NPOT Texture Assets at import time using the Non Power of 2 option in the Advanced section of the Texture Importer.

Note: Specific platforms may impose maximum Texture dimension sizes. For DirectX, the maximum Texture sizes for different feature levels are as follows:

Notes:

• The Texture Importer only allows you to choose dimension sizes up to 8K (that is 8192 x 8192 px).
• Most Mail GPUs support Texture dimension sizes up to 4K for cubemaps.

Mip maps

Mip maps are lists of progressively smaller versions of an image. When a texture uses mip maps, Unity automatically uses a smaller version of the texture when it is far away from the Camera
. This reduces the performance cost of rendering
 the texture, without noticeable loss of detail. Mip maps can also reduce texture aliasing and shimmering.

Enabling mipmaps uses 33% more memory, so you should use it only on textures whose distance from the Camera will change. You should not use it on textures whose distance from the Camera will not change, such as textures used for UI
, skyboxes, and so on.

You can control the way that Unity loads mipmaps at runtime using Texture Streaming.

Normal maps

Normal maps are used by normal map Shaders to make low-polygon models look as if they contain more detail. Unity uses normal maps encoded as RGB images. You also have the option to generate a normal map from a grayscale height map image.

Alpha maps

An alpha map is a Texture that contains only alpha information. You can use an alpha map to apply varying levels of transparency to a Material.

You can create an alpha map by creating a Texture with information in the alpha channel, or by creating a grayscale Texture and converting the grayscale values to alpha in Unity.

See the documentation on the Alpha Source Texture import setting for more information.

Detail maps

If you want to make a Terrain, you normally use your main Texture to show areas of terrain
 such as grass, rocks and sand. If your terrain is large, it may end up very blurry. Detail Textures hide this fact by fading in small details as your main Texture gets closer.

When drawing Detail Textures, a neutral gray is invisible, white makes the main Texture twice as bright, and black makes the main Texture completely black.

See documentation on Secondary Maps (Detail Maps) for more information.

Reflections (cubemaps)

To use a Texture for reflection maps (for example, in Reflection Probes
 or a cubemapped Skybox
, set the Texture Shape to Cube. See documentation on Cubemap Textures for more information.

Anisotropic filtering

Anisotropic filtering increases Texture quality when viewed from a grazing angle. This rendering is resource-intensive on the graphics card. Increasing the level of anisotropy is usually a good idea for ground and floor Textures. Use Quality settings to force anisotropic filtering for all Textures or disable it completely.

Supported file formats

Unity can read the following file formats:

• BMP
• EXR
• GIF
• HDR
• IFF
• JPG
• PICT
• PNG
• PSD
• TGA
• TIFF

Note that Unity can import multi-layer Photoshop PSD or TIFF files, which Unity automatically flattens on import so that there is no size penalty for your game. This flattening happens to the imported data in Unity, not to the file itself, so you can continue to save and import your PSD or TIFF files without losing any of your work when using these file types natively. This is important, because it allows you to have just one copy of each Texture which you can use in different applications: Photoshop; your 3D modeling application; and in Unity.

Texture Import Settings

SWITCH TO SCRIPTING

The Texture Import Settings window defines how Unity imports images from your project’s Assets folder into the Unity Editor.

To access this window, select the image file in the Project window
. The Texture Import Settings window appears in the Inspector
.

Note: Some of the less commonly used properties are hidden by default. Expand the Advanced section in the Inspector window to view these.

The Texture Import Settings window

There are several sections on the Texture Import Settings window:

(A) Texture Type. Select the type of Texture you want to create.

(B) Texture Shape. Select the shape and set properties specific to that shape in this area.

(C) Type-specific and advanced settings. Depending on what Texture Type value you select, extra properties might appear in this area. For more information, see the documentation on Texture types.

(D) Platform-specific overrides. Use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

(E) Texture preview. You can preview the Texture and adjust its values here.

Texture Type

Use the Texture Type property to select the type of Texture you want to create from the source image file. The other properties in the Texture Import settings window change depending on the value you set.

For information about specific Texture Types, see the Texture Types documentation.

Texture Shape

Use the Texture Shape property to select and define the shape and structure of the Texture. There are two shape types:

• 2D is the most common setting for all Textures; it defines the image file as a 2D Texture. These are used to map Textures to 3D Meshes and GUI elements, among other Project elements.
• Cube defines the Texture as a cubemap
  . You could use this for Skyboxes or Reflection Probes
  , for example. This type is only available with the Default, Normal Map, and Single Channel Texture types.

Cubemap mapping

You can further refine cubemaps with the following properties (not available with the 2D Texture shape):

Type-specific and advanced settings

Depending on which Texture Type you select, different options might appear on the Texture Import Settings window. Some of these options are specific to the Texture Type itself, such as the Sprite Mode settings available with the Sprite (2D and UI) type.

The Advanced settings allow you to make finer adjustments to the way Unity handles your Texture. The order and availability of these settings might vary slightly depending on the Texture Type you choose.

Platform-specific overrides

When building for different platforms, you need to think about the resolution, the file size with associated memory size requirements, the quality of your Textures, and what compression format to use for each target platform. The Platform-specific overrides panel provides one tab for the Default options, and one tab for every target platform you are building for.

Platform-specific overrides panel

To set up override values:

1. Set the default properties on the Default tab.
2. Navigate to a specific target platform tab and enable the Override for <target-platform> option.
3. Set the override properties.

The following table describes which properties are available:

Texture types

You can import different Texture
 types into the Unity Editor via the Texture Importer.

Below are the properties available to configure the various Texture types in Unity in the Texture Inspector
 window. Scroll down or select from the list below to find details of the Texture type you wish to learn about.

• Default
• Normal Map
• Editor GUI and Legacy
• Sprite (2D and UI)
• Cursor
• Cookie
• Lightmap
• Single Channel

Default

Default is the most common Texture type used for all Textures. It provides access to most of the properties for Texture importing. With this Texture type, you can also change the Texture Shape property to define the Texture Shape.

Settings for the Default Texture Type

When you choose the Default Texture type, the following properties are available (click the links for detailed information on each property):

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Normal map

Select Normal map
 to turn the color channels into a format suitable for real-time normal mapping. With this Texture type, you can also change the Texture Shape property to define the Texture Shape.

Settings for the Normal map Texture Type

When you choose the Normal map Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Editor GUI and Legacy GUI

Select Editor GUI and Legacy GUI if you are using the Texture on any HUD or GUI controls. With this Texture type, the Texture Shape property is always set to 2D for this Texture Type. For more information, see the documentation on Texture Shapes.

Settings for the Editor GUI and Legacy GUI Texture Type

When you choose the Editor GUI and Legacy GUI Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Sprite (2D and UI)

Select Sprite (2D and UI) if you are using the Texture in a 2D game as a Sprite
. With this Texture type, the Texture Shape property is always set to 2D for this Texture Type. For more information, see the documentation on Texture Shapes.

Settings for the Sprite (2D and UI) Texture Type

When you choose the Sprite (2D and UI) Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Cursor

Select Cursor to use the Texture as a custom cursor. With this Texture type, the Texture Shape property is always set to 2D for this Texture Type. For more information, see the documentation on Texture Shapes.

Settings for the Cursor Texture Type

When you choose the Cursor Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Cookie

Select Cookie to set your Texture up with the basic parameters used for cookies in the Built-in Render Pipeline. With this Texture type, Unity updates the Texture Shapes property automatically based on the selected Light Type:

• Directional and Spotlight cookies are always 2D Textures (the 2D shape type).
• Point Light cookies must be cubemaps
   (the Cube shape type).

Settings for the Cookie Texture Type

When you choose the Cookie Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Lightmap

Select Lightmap
 if you are using the Texture as a Lightmap. This option enables encoding into a specific format (RGBM or dLDR, depending on the platform) and a post-processing
 step on Texture data (a push-pull dilation pass). With this Texture type, the Texture Shape property is always set to 2Dfor this Texture Type. For more information, see the documentation on Texture Shapes.

Settings for the Lightmap Texture Type

When you choose the Lightmap Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Single Channel

Select Single Channel if you only need one channel in the Texture. With this Texture type, you can also change the Texture Shape property to define the Texture Shape.

Settings for the Single Channel Texture Type

When you choose the Single Channel Texture type, you can set the following additional properties:

In addition, you can use the Platform-specific overrides panel to set default options and their overrides for a specific platforms.

Texture compression formats

The Unity Editor can import texture source files with a number of common formats, such as JPEG or PNG. However, GPUs do not use these formats at runtime; instead, they use different, specialized compression
 formats that are optimized for memory usage and speed of sampling operations.

You can configure the texture compression
 format for a texture asset in its import settings. When you add a texture asset to your project, the Unity Editor automatically chooses an appropriate compression format for each build target; however, most platforms support several texture compression formats.

Texture compression format can affect load times, GPU frame times, memory usage, visual quality, build size, and compression times; it is therefore important to understand this subject before you make changes to this setting.

This page contains the following information:

• Texture compression overview
• Crunch compression
• Applying texture compression formats to texture assets

For general information on texture asset import settings, see Texture import settings. For information on the recommended, default, and supported texture compression formats for each platform, see Recommended, default, and supported texture compression formats, by platform.

Texture compression overview

Bits per pixel
 (bpp) is the amount of storage required for a single texture pixel. Textures with a lower bpp value have a smaller size on disk and in memory. A lower bpp value also means that the GPU uses less memory bandwidth to read the texture pixels. GPU memory bandwidth can often be a frame rate bottleneck, and thus texture compression helps to avoid it.

The higher the visual quality of a texture asset, the higher the bits per pixel; which, consequently, leads to greater build size, loading time, and runtime memory usage. All texture compression formats are lossy, to some extent. Uncompressed textures offer the highest quality, but they also have the highest bits per pixel. Different texture compression formats offer different trade-offs.

In general, for the best runtime performance and size on disk, for most of your texture assets, you should choose a texture compression format that is supported by your target device, and has the fewest bits per pixel for the visual quality you want.

When you use a texture for a specific purpose, you can change its individual settings. For example, if you are using a texture with only one channel as a mask, you might choose the BC4 format to reduce file size but preserve quality. If you are using some textures for pixel-perfect UI
, you might choose not to compress them.

Choose a format that your target platforms and devices support. When Unity loads a texture with a compression format that the device does not support, it decompresses the texture to the default uncompressed format for that platform and stores the uncompressed copy in memory alongside the original compressed texture. This increases texture loading time and uses additional memory. When Unity loads a texture with a compression format that the device supports, the GPU can use the data without any need for conversion.

Crunch compression

Crunch is a compression format that works on top of DXT or ETC compression, by providing additional variable bit rate compression. When Unity loads a Crunch-compressed texture, it decompresses the texture to DXT or ETC on the CPU, and then uploads the DXT or ETC compressed texture data to the GPU.

Crunch compression helps the texture use the lowest possible amount of disk space, but has no effect on runtime memory usage. Crunch textures can take a long time to compress, but decompression at runtime is fairly fast. You can adjust how lossy Crunch compression is, to strike a balance between file size and quality.

If you are particularly concerned about the size of your build and Crunch is supported on your target platform, consider adding Crunch compression.

Applying texture compression formats to texture assets

For information about texture import settings and how to set up platform-specific overrides, see Texture Import Settings.

Recommended, default, and supported texture compression formats, by platform

This page contains the following information:

• Terminology
• Recommended texture compression formats, by platform
• Desktop
• iOS and tvOS
• Android
• Default texture compression formats, by platform
• Supported texture compression formats, by platform

This page does not contain information about console platforms. For information about console platforms, see the platform-specific documentation.

For an overview of texture compression formats, see Texture compression formats. For information about texture import settings and how to set up platform-specific overrides, see Texture import settings.

Terminology

This page uses the following terminology:

• Bits per pixel
   (bpp) is the amount of storage required for a single texture pixel. Textures with a lower bpp value have a smaller size on disk and in memory. A lower bpp value also means that the GPU can store more pixels in its cache, which results in faster texture access.
• LDR (Low Dynamic Range) refers to most typical images where colors are conceptually between 0.0 (black) and 1.0 (white) values. The majority of image files (such as PNG and JPG) have low dynamic range.
• HDR
   (High Dynamic Range) refers to special image and texture formats where colors can have a higher range than 0 through 1. Image file formats like .exr or .hdr are often used for HDR image data. At runtime and on the GPU, there are several HDR formats, trading off accuracy, range and memory usage.
• RGB is a color model in which red, green and blue combine to reproduce an array of colors.
• RGBA is a version of RGB with an alpha channel, which supports blending and opacity alteration.
• Variable bit rate (VBR) means that bits per pixel is not a fixed value, and depends on the actual content instead. VBR only applies to Crunch compression, and only texture size on disk. The size in memory is the same as when using the underlying texture format (for example, RGB Compressed DXT1 for RGB Crunched DXT1).

Recommended texture compression formats, by platform

Desktop

For devices with DirectX 11 or better class GPUs, where support for BC7 and BC6H formats is guaranteed to be available, the recommended choice of compression formats is: RGB textures - DXT1 at four bits/pixel. RGBA textures - BC7 (higher quality, slower to compress) or DXT5 (faster to compress), both at eight bits/pixel. HDR textures - BC6H at eight bits/pixel. If you need to support DirectX 10 class GPUs on PC (NVIDIA GPUs before 2010, AMD before 2009, Intel before 2012), then DXT5 instead of BC7 would be preferred, since these GPUs do not support BC7 nor BC6H.

See the Supported texture compression formats reference table for detailed information about all supported formats.

iOS and tvOS

For Apple devices that use the A8 chip (2014) or above, ATSC is the recommended texture compression format for RGB and RGBA textures. This format allows you to choose between texture quality and size on a granular level: all the way from eight bits/pixel (4x4 block size) down to 0.89 bits/pixel (12x12 block size). If support for older devices is needed, or you want additional Crunch compression, then Apple devices support ETC/ETC2 formats starting with A7 chip (2013). For even older devices, PVRTC is the compression format to use. On iOS
, Unity’s default texture compression format is PVRTC, for the broadest possible compatibility. If your application does not include OpenGL ES 2 support, change this to one of the above formats. Unity only supports tvOS devices that have Metal support, and so the default texture compression format is ASTC. If you manually add OpenGL ES 2 support to your tvOS project, you must change the texture compression to either PVRTC or ETC to avoid texture decompression at runtime.

See the Supported texture compression formats reference table for detailed information about all supported formats.

Android

Texture compression support on Android is complicated, and you might need to build several application versions with different sub-targets.

Unless your app targets specific hardware that supports a limited range of texture compression formats, you can choose between several compressed and uncompressed formats, which offer different trade-offs.

For LDR RGB and RGBA textures, most modern Android GPUs support ASTC compression format, including: Qualcomm GPUs since Adreno 4xx / Snapdragon 415 (2015) ARM GPUs since Mali T624 (2012) NVIDIA GPUs since Tegra K1 (2014) PowerVR GPUs since GX6250 (2014) If you need support for older devices, or you want additional Crunch compression, then all GPUs that run Vulkan or OpenGL ES 3.0 support ETC2 format. The resulting image quality is quite high, and it supports one- to four-component texture data. OpenGL ES 2 devices do not support the ETC2 format, so Unity decompresses the texture at runtime to the format ETC2 fallback specifies. For even older devices, usually only ETC format is available. The drawback is that there is no direct alpha channel support. For Sprites
, Unity offers an option to use ETC1 compression by splitting a texture into two ETC1 textures: one for RGB, one for alpha. To enable this, enable the Android-specific Split Alpha Channel option for the Texture when importing a Sprite Atlas
. The sprite shader
 samples both textures and combines them into the final result. For HDR textures, ASTC HDR is the only compressed format available on Android devices. ASTC HDR requires Vulkan or GL_KHR_texture_compression_astc_hdr support. ASTC is the most flexible format.

For devices that don’t support ASTC HDR, all devices running Vulkan or OpenGL ES 3.0 support RGB9e5, which is suitable for textures without an alpha channel. If an alpha channel or even wider support is needed, use RGBA Half: this takes twice as much memory as RGB9e5.

See the Supported texture compression formats reference table for detailed information about all supported formats.

Default texture compression formats, by platform

The following table shows the default formats used for each platform.

Supported texture compression formats, by platform

The table below shows each compression format available in Unity, and the platforms that support it.

Notes:

1. Except on pre-DX11 level GPUs, or macOS when using OpenGL. When not supported, BC6H textures get decompressed to RGBA Half, and BC7 get decompressed to RGBA32 at load time.
2. With linear rendering on web browsers that do not support sRGB DXT, textures are decompressed to RGBA32 at load time.
3. Except on Android devices with NVIDIA Tegra GPUs; these do support DXT/BC formats.
4. Except on OpenGL ES 2.0 / WebGL 1.
5. When on OpenGL ES 2.0 / WebGL 1: requires GL_EXT_texture_rg extension support.
6. Requires GL_EXT_texture_norm16 or corresponding Vulkan capability on Android.
7. When on OpenGL ES 2.0 / WebGL 1: requires OES_texture_half_float extension support.
8. Requires Vulkan or GL_KHR_texture_compression_astc_ldr OpenGL ES extension.
9. Except on OpenGL ES 2.0; there ETC2 textures are decompressed into the format ETC2 fallback specifies in the Android Build Settings or on the Android tab for the Platform-specific overrides.
10. Except on Apple A7 chip devices (2013).
11. Android: requires GL_KHR_texture_compression_astc_hdr extension. iOS: requires A13 or later chip (2019). When not supported, the texture is decompressed to RGB9E5 format, losing the alpha channel.
12. Except on Android devices with Imagination PowerVR GPUs; these do support PVRTC formats.

Render Texture

SWITCH TO SCRIPTING

Render Textures are special types of Textures
 that are created and updated at run time. To use them, you first create a new Render Texture and designate one of your Cameras
 to render into it. Then you can use the Render Texture in a Material
 just like a regular Texture. The Water prefabs
 in Unity Standard Assets are an example of real-world use of Render Textures for making real-time reflections and refractions.

Properties

The Render Texture Inspector
 is different from most Inspectors, but very similar to the Texture Inspector.

The Render Texture Inspector is almost identical to the Texture Inspector

The Render Texture inspector displays the current contents of Render Texture in realtime and can be an invaluable debugging tool for effects that use render textures.

Example

A very quick way to make a live arena-camera in your game:

1. Create a new Render Texture asset using Assets >Create >Render Texture.
2. Create a new Camera using GameObject > Camera.
3. Assign the Render Texture to the Target Texture of the new Camera.
4. Create a new 3D cube using GameObject > 3D Object > Cube.
5. Drag the Render Texture onto the cube to create a Material that uses the render texture.
6. Enter Play Mode, and observe that the cube’s texture is updated in real-time based on the new Camera’s output.

Render Textures are set up as demonstrated above

Custom Render Textures

SWITCH TO SCRIPTING

Custom Render Textures
 are an extension to Render Textures that allows users to easily update said texture with a shader. This is useful to implement all kind of complex simulations like caustics, ripple simulation for rain effects, splatting liquids against a wall, etc. It also provides a scripting and Shader
framework to help with more complicated configuration like partial or multi-pass updates, varying update frequency etc.

To use them, you need to create a new Custom Render Texture asset and assign a Material to it. This Material will then update the content of the texture according to its various parameters. The Custom Render Texture can then be assigned to any kind of Material just like a regular texture, even one used for another Custom Render Texture.

Properties

The inspector
 for Custom Render Textures will display most of the properties of the Render Texture inspector as well as many specific ones.

Render Texture:

Custom Texture:

Custom Texture parameters are separated in three main categories:

• Material: Defines what shader is used to update the texture.
• Initialization: Controls how the texture is initialized before any update is done by the shader
• Update: Controls how the texture is updated by the shader.

Exporting Custom Render Texture to a file:

Custom Render Textures can be exported to a PNG or EXR file (depending on the texture format) via the contextual “Export” menu.

Update Zones:

By default, when the Custom Render Texture is updated, the whole texture is updated at once by the Material. One of the important features of the Custom Texture is the ability for the user to define zones of partial update. With this, users can define as many zones as they want and the order in which they are processed.

This can be used for several different purpose. For example, you could have multiple small zones to splat water drops on the texture and then do a full pass to simulate the ripples. This can also be used as an optimization when you know that you don’t need to update the full texture.

Update zones have their own set of properties. The Update Zone Space will be reflected in the display. Depending on the Dimension of the texture, coordinates will be 2D (for 2D and Cube textures) or 3D (for 3D textures).

Double Buffered Custom Textures

Custom Render Textures can be “Double Buffered”. Internally, there are two textures but from the user standpoint they are the same. After each update, the two textures will be swapped. This allows the user to read the result of the last update while writing a new result in the Custom Render Texture. This is particularly useful if the shader needs to use the content already written in the texture but cannot mix the values with classic blend modes. This is also needed if the shaders has to sample different pixels of the preceding result.

Performance Warning: Due to some technicalities, the double buffering currently involves a copy of the texture at each swap which can lead to a drop in performance depending on the frequency at which it is done and the resolution of the texture.

Chaining Custom Render Textures

Custom Render Textures need a Material to be updated. This Material can have textures as input. This means that the a Custom Texture can be used as an input to generate another one. This way, users can chain up several Custom Textures to generate a more complex multi-step simulation. The system will correctly handle all the dependencies
 so that the different updates happen in the right order.

Writing a shader for a Custom Render Texture

Updating a Custom Texture is like doing a 2D post process in a Render Texture. To help users write their custom texture shaders, we provide a small framework with utility functions and built-in helper variables.

Here is a really simple example that will fill the texture with a color multiplied by a color:

Shader "CustomRenderTexture/Simple"

{
     

    Properties

    {
     

        _Color ("Color", Color) = (1,1,1,1)

                                _Tex("InputTex", 2D) = "white" {}

     }

     SubShader

     {
     

        Lighting Off

        Blend One Zero

        Pass

        {
     

            CGPROGRAM

            #include "UnityCustomRenderTexture.cginc"

            #pragma vertex CustomRenderTextureVertexShader

            #pragma fragment frag

             #pragma target 3.0

            float4      _Color;

                                        sampler2D   _Tex;

            float4 frag(v2f_customrendertexture IN) : COLOR

            {
     

                return _Color * tex2D(_Tex, IN.localTexcoord.xy);

            }

            ENDCG

                    }

    }

}

The only mandatory steps when writing a shader for a custom texture are:

* #include “UnityCustomRenderTexture.cginc”

• Use the provided Vertex Shader
   CustomRenderTextureVertexShader
• Use the provided input structure v2f_customrendertexture for the pixel shader

Other than that, the user is free to write the pixel shader as he wishes.

Here is another example for a shader used in an initialization material:

Shader "CustomRenderTexture/CustomTextureInit"

{
     

    Properties

    {
     

        _Color ("Color", Color) = (1,1,1,1)

        _Tex("InputTex", 2D) = "white" {}

    }

    SubShader

    {
     

        Lighting Off

        Blend One Zero

        Pass

        {
     

            CGPROGRAM

            #include "UnityCustomRenderTexture.cginc"

            #pragma vertex InitCustomRenderTextureVertexShader

            #pragma fragment frag

            #pragma target 3.0

            float4      _Color;

                                        sampler2D   _Tex;

            float4 frag(v2f_init_customrendertexture IN) : COLOR

            {
     

                _Color * tex2D(_Tex, IN.texcoord.xy);

            }

            ENDCG

        }

    }

}

Same as for the update shader, the only mandatory steps are these:

* #include “UnityCustomRenderTexture.cginc”

• Use the provided Vertex Shader InitCustomRenderTextureVertexShader
• Use the provided input structure v2f_init_customrendertexture for the pixel shader

In order to help the user in this process we provide a set of built-in values:

Input values from the v2f_customrendertexture structure:

Input values from the v2f_init_customrendertexture structure:

Global values:

Controlling Custom Render Texture from Script

Most of the functionalities described here can be accessed via the Scripting API. Changing material parameters, update frequency, update zones, requesting an update etc, can all be done with the script.

One thing to keep in mind though is that any update requested for the Custom Texture will happen at a very specific time at the beginning of the frame with the current state of the Custom Texture. This guarantees that any material using this texture will have the up-to-date result.

This means that this kind of pattern:

customRenderTexture.updateZones = updateZones1;

customRenderTexture.Update();

customRenderTexture.updateZones = updateZones2;

customRenderTexture.Update();

Will not yield the “expected” result of one update done with the first array of update zones and then a second update with the other array. This will do two updates with the second array.

The good rule of thumb is that any property modified will only be active in the next frame.

Movie Textures

SWITCH TO SCRIPTING

Note: MovieTexture is due to be deprecated in a future version of Unity. You should use VideoPlayer for video download and movie playback.

Movie Textures are animated Textures
 that are created from a video file. By placing a video file in your project’s Assets Folder, you can import the video to be used exactly as you would use a regular Texture.

Video files are imported via Apple QuickTime. Supported file types are what your QuickTime installation can play (usually .mov, .mpg, .mpeg, .mp4, .avi, .asf). On Windows, movie importing requires Quicktime to be installed. Download Quicktime from Apple Support Downloads.

Properties

The Movie Texture Inspector
 is very similar to the regular Texture Inspector.

Video files are Movie Textures in Unity

Details

When a video file is added to your Project, it will automatically be imported and converted to Ogg Theora format. Once your Movie Texture has been imported, you can attach it to any GameObject
 or Material
, just like a regular Texture.

Playing the Movie

Your Movie Texture will not play automatically when the game begins running. You must use a short script to tell it when to play.

// this line of code will make the Movie Texture begin playing

((MovieTexture)GetComponent<Renderer>().material.mainTexture).Play();

Attach the following script to toggle Movie playback when the space bar is pressed:

public class PlayMovieOnSpace : MonoBehaviour {
     

    void Update () {
     

        if (Input.GetButtonDown ("Jump")) {
     

            Renderer r = GetComponent<Renderer>();

            MovieTexture movie = (MovieTexture)r.material.mainTexture;

            if (movie.isPlaying) {
     

                movie.Pause();

            }

            else {
     

                movie.Play();

            }

        }

    }

}

For more information about playing Movie Textures, see the Movie Texture Script Reference page

Movie Audio

When a Movie Texture is imported, the audio track accompanying the visuals are imported as well. This audio appears as an AudioClip child of the Movie Texture.

The video’s audio track appears as a child of the Movie Texture in the Project View

To play this audio, the Audio Clip
 must be attached to a GameObject, like any other Audio Clip. Drag the Audio Clip from the Project View onto any GameObject in the Scene
 or Hierarchy View. Usually, this will be the same GameObject that is showing the Movie. Then use AudioSource.Play() to make the the movie’s audio track play along with its video.

iOS

Movie Textures are not supported on iOS
. Instead, full-screen streaming playback is provided using Handheld.PlayFullScreenMovie.

You need to keep your videos inside the StreamingAssets folder located in the Assets folder of your project.

Unity iOS supports any movie file types that play correctly on an iOS device, implying files with the extensions .mov, .mp4, .mpv, and .3gp and using one of the following compression standards:

• H.264 Baseline Profile Level 3.0 video
• MPEG–4 Part 2 video

For more information about supported compression standards, consult the iPhone SDK MPMoviePlayerController Class Reference.

As soon as you call Handheld.PlayFullScreenMovie the screen will fade from your current content to the designated background color. It might take some time before the movie is ready to play but in the meantime, the player will continue displaying the background color and may also display a progress indicator to let the user know the movie is loading. When playback finishes, the screen will fade back to your content.

The video player does not respect switching to mute while playing videos

As written above, video files are played using Apple’s embedded player (as of SDK 3.2 and iPhone OS 3.1.2 and earlier). This contains a bug that prevents Unity switching to mute.

The video player does not respect the device’s orientation

The Apple video player and iPhone SDK do not provide a way to adjust the orientation of the video. A common approach is to manually create two copies of each movie in landscape and portrait orientations. Then, the orientation of the device can be determined before playback so the right version of the movie can be chosen.

Android

Movie Textures are not supported on Android. Instead, full-screen streaming playback is provided using Handheld.PlayFullScreenMovie.

You need to keep your videos inside the StreamingAssets folder located in the Assets folder of your project.

Unity Android supports any movie file type supported by Android, (ie, files with the extensions .mp4 and .3gp) and using one of the following compression standards:

• H.263
• H.264 AVC
• MPEG–4 SP

However, device vendors are keen on expanding this list, so some Android devices are able to play formats other than those listed, such as HD videos.

For more information about the supported compression standards, consult the Android SDK Core Media Formats documentation.

As soon as you call Handheld.PlayFullScreenMovie the screen will fade from your current content to the designated background color. It might take some time before the movie is ready to play but in the meantime, the player will continue displaying the background color and may also display a progress indicator to let the user know the movie is loading. When playback finishes, the screen will fade back to your content.

3D textures

SWITCH TO SCRIPTING

A 3D texture is a bitmap image that contains information in three dimensions rather than the standard two. 3D textures are commonly used to simulate volumetric effects such as fog or smoke, to approximate a volumetric 3D mesh
, or to store animated textures and blend between them smoothly.

In your Unity Project, the Unity Editor represents 3D textures as Texture Assets. To configure a Texture Asset’s import settings you can select the Texture Asset and use the Inspector
, or write a script that uses the TextureImporter API.

In the Unity engine, Unity uses the Texture3D class to represent 3D textures. Use this class to interact with 3D textures in C# scripts
.

3D texture size

The maximum resolution of a 3D texture is 2048 x 2048 x 2048.

Be aware that the size of a 3D texture in memory and on disk increases quickly as its resolution increases. An RGBA32 3D texture with no mip maps and a resolution of 16 x 16 x 16 has a size of 128KB, but with a resolution of 256 x 256 x 256 it has a size of 512MB.

Creating a 3D texture

To create a 3D texture in your Project, you must use a script.

The following example is an Editor script that creates an instance of the Texture3D class, populates it with color data, and then saves it to your Project as a Texture Asset.

using UnityEditor;

using UnityEngine;

public class ExampleEditorScript : MonoBehaviour

{
     

    [MenuItem("CreateExamples/3DTexture")]

    static void CreateTexture3D()

    {
     

        // Configure the texture

        int size = 32;

        TextureFormat format = TextureFormat.RGBA32;

        TextureWrapMode wrapMode =  TextureWrapMode.Clamp;

        // Create the texture and apply the configuration

        Texture3D texture = new Texture3D(size, size, size, format, false);

        texture.wrapMode = wrapMode;

        // Create a 3-dimensional array to store color data

        Color[] colors = new Color[size * size * size];

        // Populate the array so that the x, y, and z values of the texture will map to red, blue, and green colors

        float inverseResolution = 1.0f / (size - 1.0f);

        for (int z = 0; z < size; z++)

        {
     

            int zOffset = z * size * size;

            for (int y = 0; y < size; y++)

            {
     

                int yOffset = y * size;

                for (int x = 0; x < size; x++)

                {
     

                    colors[x + yOffset + zOffset] = new Color(x * inverseResolution,

                        y * inverseResolution, z * inverseResolution, 1.0f);

                }

            }

        }

        // Copy the color values to the texture

        texture.SetPixels(colors);

        // Apply the changes to the texture and upload the updated texture to the GPU

        texture.Apply();        

        // Save the texture to your Unity Project

        AssetDatabase.CreateAsset(texture, "Assets/Example3DTexture.asset");

    }

}

Using a 3D texture in a shader

Here is an example of a simple raymarching shader
 that uses a 3D texture to visualize a volume.

Shader "Unlit/VolumeShader"

{
     

    Properties

    {
     

        _MainTex ("Texture", 3D) = "white" {}

        _Alpha ("Alpha", float) = 0.02

        _StepSize ("Step Size", float) = 0.01

    }

    SubShader

    {
     

        Tags { "Queue" = "Transparent" "RenderType" = "Transparent" }

        Blend One OneMinusSrcAlpha

        LOD 100

        Pass

        {
     

            CGPROGRAM

            #pragma vertex vert

            #pragma fragment frag

            #include "UnityCG.cginc"

            // Maximum amount of raymarching samples

            #define MAX_STEP_COUNT 128

            // Allowed floating point inaccuracy

            #define EPSILON 0.00001f

            struct appdata

            {
     

                float4 vertex : POSITION;

            };

            struct v2f

            {
     

                float4 vertex : SV_POSITION;

                float3 objectVertex : TEXCOORD0;

                float3 vectorToSurface : TEXCOORD1;

            };

            sampler3D _MainTex;

            float4 _MainTex_ST;

            float _Alpha;

            float _StepSize;

            v2f vert (appdata v)

            {
     

                v2f o;

                // Vertex in object space this will be the starting point of raymarching

                o.objectVertex = v.vertex;

                // Calculate vector from camera to vertex in world space

                float3 worldVertex = mul(unity_ObjectToWorld, v.vertex).xyz;

                o.vectorToSurface = worldVertex - _WorldSpaceCameraPos;

                o.vertex = UnityObjectToClipPos(v.vertex);

                return o;

            }

            float4 BlendUnder(float4 color, float4 newColor)

            {
     

                color.rgb += (1.0 - color.a) * newColor.a * newColor.rgb;

                color.a += (1.0 - color.a) * newColor.a;

                return color;

            }

            fixed4 frag(v2f i) : SV_Target

            {
     

                // Start raymarching at the front surface of the object

                float3 rayOrigin = i.objectVertex;

                // Use vector from camera to object surface to get ray direction

                float3 rayDirection = mul(unity_WorldToObject, float4(normalize(i.vectorToSurface), 1));

                float4 color = float4(0, 0, 0, 0);

                float3 samplePosition = rayOrigin;

                // Raymarch through object space

                for (int i = 0; i < MAX_STEP_COUNT; i++)

                {
     

                    // Accumulate color only within unit cube bounds

                    if(max(abs(samplePosition.x), max(abs(samplePosition.y), abs(samplePosition.z))) < 0.5f + EPSILON)

                    {
     

                        float4 sampledColor = tex3D(_MainTex, samplePosition + float3(0.5f, 0.5f, 0.5f));

                        sampledColor.a *= _Alpha;

                        color = BlendUnder(color, sampledColor);

                        samplePosition += rayDirection * _StepSize;

                    }

                }

                return color;

            }

            ENDCG

        }

    }

}

If you use this shader with the 3D texture created in the example at the top of the page, the result looks like this:

Texture arrays

SWITCH TO SCRIPTING

A texture array is a collection of same size/format/flags 2D textures that look like a single object to the GPU, and can be sampled in the shader
 with a texture element index. They are useful for implementing custom terrain
 rendering
 systems or other special effects where you need an efficient way of accessing many textures of the same size and format. Elements of a 2D texture array are also known as slices, or layers.

Platform Support

Texture arrays need to be supported by the underlying graphics API and the GPU. They are available on:

• Direct3D 11/12 (Windows, Xbox One)
• OpenGL Core
   (Mac OS X, Linux)
• Metal (iOS, Mac OS X)
• OpenGL ES 3.0 (Android, iOS, WebGL 2.0)
• PlayStation 4

Other platforms do not support texture arrays (OpenGL ES 2.0 or WebGL 1.0). Use SystemInfo.supports2DArrayTextures to determine texture array support at runtime.

Creating and manipulating texture arrays

As there is no texture import pipeline for texture arrays, they must be created from within your scripts
. Use the Texture2DArray class to create and manipulate them. Note that texture arrays can be serialized as assets, so it is possible to create and fill them with data from editor scripts.

Normally, texture arrays are used purely within GPU memory, but you can use Graphics.CopyTexture, Texture2DArray.GetPixels and Texture2DArray.SetPixels to transfer pixels
 to and from system memory.

Using texture arrays as render targets

Texture array elements may also be used as render targets. Use RenderTexture.dimension to specify in advance whether the render target is to be a 2D texture array. The depthSlice argument to Graphics.SetRenderTarget specifies which mipmap level or cube map face to render to. On platforms that support “layered rendering” (i.e. geometry shaders), you can set the depthSlice argument to –1 to set the whole texture array as a render target. You can also use a geometry shader to render into individual elements.

Using texture arrays in shaders

See Using texture arrays in shaders.

Cubemaps

SWITCH TO SCRIPTING

A Cubemap is a collection of six square textures that represent the reflections on an environment. The six squares form the faces of an imaginary cube that surrounds an object; each face represents the view along the directions of the world axes (up, down, left, right, forward and back).

Cubemaps are often used to capture reflections or “surroundings” of objects; for example skyboxes and environment reflections often use cubemaps.

Cubemapped skybox and reflections

Creating Cubemaps from Textures

The fastest way to create cubemaps is to import them from specially laid out Textures
. Select the Texture in the Project window
, to see the Import Settings in the Inspector
 window. In the Import Settings, set the Texture Type to Default, Normal Map
 or Single Channel, and the Texture Shape to Cube. Unity then automatically sets the Texture up as a Cubemap.

Cubemap texture import type

Several commonly-used cubemap layouts are supported (and in most cases, Unity detects them automatically).

Vertical and horizontal cross layouts, as well as column and row of cubemap faces are supported:

Another common layout is LatLong (Latitude-Longitude, sometimes called cylindrical). Panorama images are often in this layout:

SphereMap (spherical environment map) images can also be found:

By default Unity looks at the aspect ratio
 of the imported texture to determine the most appopriate layout from the above. When imported, a cubemap is produced which can be used for skyboxes and reflections:

Selecting Glossy Reflection option is useful for cubemap textures that will be used by Reflection Probes
. It processed cubemap mip levels in a special way (specular convolution) that can be used to simulate reflections from surfaces of different smoothness:

Cubemap used in a Reflection Probe on varying-smoothness surface

Legacy Cubemap Assets

Unity also supports creating cubemaps out of six separate textures. Select Assets > Create > Legacy > Cubemap from the menu, and drag six textures into empty slots in the inspector.

Legacy Cubemap Inspector

Note that it is preferred to create cubemaps using the Cubemap texture import type (see above) - this way cubemap texture data can be compressed; edge fixups and glossy reflection convolution be performed; and HDR
 cubemaps are supported.

Other Techniques

Another useful technique is to generate the cubemap from the contents of a Unity scene
 using a script. The Camera.RenderToCubemap function can record the six face images from any desired position in the scene; the code example on the function’s script reference page adds a menu command to make this task easy.