Array Textures in Unity

Unity Engine
1

Previously I’d inquired about using 3d textures, and I had that working, however, mipmaps and filtering are completely broken for my use case.

To explain the problem - I need more than 16 textures in a shader. In 90% of the cases I will be using no more than 6 to 12, but in about 10% of edge cases, my terrain will be blending many more textures, 24, 30, for certain meshes.

I’ve been trying to use 3d textures to store sets of textures (diffuse, normal, height, etc) in a 3d texture, and then read in the shader. This is fine, except it requires point filtering and I cannot use mipmaps.

Is Unity going to have any support for Array Textures?

Alternatively, is there any way to adequately use cubemaps as texture arrays, and fetch from one singular face of a cubemap for each call? I explored converting UV’s to a directional coordinate, but I’ve either done it wrong or it is not possible (taking the positive X facing as say, (1, x, y), x,y being the UV coordinates).

Essentially, I want to use more than 16 textures, but texture atlases have mipmap, filtering, and wrapping issues, 3d textures have mipmap and filtering problems, and cubemaps take a direction, not a UV coordinate, and I cannot seem to get a pixel value from them that is actually correct.

The use-case is a voxel-based terrain that uses vertex/uv’s to blend textures, blending multiple texture sets such as grass flooring, rock walls, dirt overlays onto stone, alpha blending vines onto walls with tessellation, and more. Most meshes will use only a few sets, but some cases will involve blending between themed areas that could collide.

My last solution would be to create texture atlases with copied pixels from the opposite side of the texture, so that wrapping is seamless even on mips 1, 2, and 3, and past that any minor bleeding on the padding would not be noticeable. And handling wrapping in the shader between the valid sections (not including the copied pixels), so filtering is all correct. I’d like something cleaner than this, however. Is there any ideas?

2

Bump & Upvote:

The use-case is a voxel-based terrain that uses vertex/uv’s to blend textures, blending multiple texture sets such as grass flooring, rock walls, dirt overlays onto stone, alpha blending vines onto walls with tessellation, and more. Most meshes will use only a few sets, but some cases will involve blending between themed areas that could collide.

We really need Texture Arrays! This will make it possible to not just blend, but also height-tesselate!

(I only care about PC & consoles!)

3

I’ve created a solution that generates the atlas textures on the fly with the GPU, and built the shader for it, but I would really prefer to use texture arrays.

However, I do have a shader that can now represent 14 textures at once with various options. Texture arrays would dramatically increase the flexibility though, because I have to downsample and add bordering to prevent issues with mipmaps, and bilinear/trilinear filtering!

1 Like
4

From Unity - Manual: Built-in macros where they also explain how to avoid this limit!

5

Interesting! Thanks! That was not there pre-Unity 5, I don’t believe (I could be wrong, but I’ve been working on this issue for quite a while and I don’t recall it in any shape or form).

That might solve my issues right on it’s own, in every way. Still, array textures would be useful in terms of cleanliness.

I’m not entirely sure whether to be annoyed or happy, because I’ve collectively spent several weeks dealing with sampler limits. I’ve learned a lot, but that’s several weeks I could’ve used elsewhere. Ah well.

6

Yeah, I think Unity 5.0 exposed a LOT more to the documentation in regards to stuff like this, and thanks to the Standard shader they have shown us, at long last, how to set stencil values and blend modes per material and / or renderer!
But as you say, it’s hard to know if this functionality was exposed pre-5.0 or not.

7

Hi plutoman (and zicandar too of course)
i’m interested in the way you coded your texture atlas and rendered it into a texture.
did you create a custom editor window ?
i also want to create 2 textures diffuse/alpha and normals/heightmap from 2 texture atlases…
Thanks in advance
Victor

8

The point of this discussion was how to NOT have to atlas textures!
I think that unity has built in ways of creating atlases, but generally this is avoided or done by hand. (Our artists do it in photoshop and/or when they create the UV-layouts to fit a compact atlas’d texture for much reused assets such as the ground.)

9

I wrote a quick script to set them into an atlas. Before I did this, I did a downsampling by 16 pixels, and built the opposite edges into the texture. I wrote a compute shader for that, too, but it was not perfect, as it had a few edge borders (I don’t think the bilinear filtering properly handled the wrap mode of repeat).

This is a compute shader.

#pragma kernel CSMain

RWTexture2D<float4> Result;
Texture2D<float4> Texture;
uint2 Offsets;

[numthreads(8,8,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    uint2 tex = uint2(id.x, id.y);
    uint2 res = uint2(id.x + Offsets.x, id.y + Offsets.y);

    Result[res] = Texture[tex];
}

And called it with this at runtime, before assigning the texture to a material (most of the time to do this was simply memory allocation, and don’t forget to release any unused render textures);

public static RenderTexture CreateAtlasTexture(ComputeShader cs, params Texture[] textures)
    {
        int width = textures[0].width; //assume all textures of equal sizing
        int height = textures[0].height;

        RenderTexture rt = new RenderTexture(width * 2, height * 2, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
        rt.useMipMap = false;
        rt.enableRandomWrite = true;
        rt.filterMode = FilterMode.Bilinear;
        rt.wrapMode = TextureWrapMode.Repeat;
        rt.Create();

        if (!SystemInfo.supportsComputeShaders)
            return rt;

        cs.SetTexture(0, "Texture", textures[0]);
        cs.SetTexture(0, "Result", rt);
        cs.SetInts("Offsets", 0, 0);
        cs.Dispatch(0, width, height, 1);

        cs.SetTexture(0, "Texture", textures[1]);
        cs.SetTexture(0, "Result", rt);
        cs.SetInts("Offsets", width, 0);
        cs.Dispatch(0, width, height, 1);

        cs.SetTexture(0, "Texture", textures[2]);
        cs.SetTexture(0, "Result", rt);
        cs.SetInts("Offsets", 0, height);
        cs.Dispatch(0, width, height, 1);

        return rt;
    }
10

I did quite a lot of research into this, since it actually impacts quite a lot - I wanted to blend textures in for dynamic effects that follow terrain, rather than flat particle effects.

If anyone is interested in how my code is set up now, I simply assign textures in to the material, normally, but my shader code works like this;

Properties

Properties {
        // etc
        _Diffuse0 ("Diffuse0", 2D) = "white" {}
        _Diffuse1 ("Diffuse1", 2D) = "white" {}
        _Diffuse2 ("Diffuse2", 2D) = "white" {}
        // .... etc w/ more Diffuse
        _Normal0 ("Normal0", 2D) = "white" {}
        // .. etc
        _Height0 ("Height0", 2D) = "white" {}
        // .. etc
    }

Inside the program block;

Texture2D<float4> _Diffuse0; uniform float4 _Diffuse0_ST;
Texture2D<float4> _Diffuse1; uniform float4 _Diffuse1_ST;
Texture2D<float4> _Diffuse2; uniform float4 _Diffuse2_ST;
// .. etc
Texture2D<float4> _Normal0; uniform float4 _Normal0_ST;
// .. etc
Texture2D<float4> _Height0; uniform float4 _Height0_ST;
// .. etc
SamplerState _LinearRepeat;
//Also valid, for the various combinations
//SamplerState _LinearClamp;
//SamplerState _PointRepeat;
//SamplerState _PointClamp;

And to actually get values;

if (vertexColor.r > .01)
{
    tex += _Diffuse0.Sample(_LinearRepeat, TRANSFORM_TEX(UV, _Diffuse0)) * vertexColor.r;
}
if (vertexColor.g > .01)
{
    tex += _Diffuse1.Sample(_LinearRepeat, TRANSFORM_TEX(UV, _Diffuse1)) * vertexColor.g;
}
// .. etc

Since I’m using this for blending, triplanar as it stands, I’m adding based on vertex colors/uv values. But there’s no need to complicate with their macros, and in fact, using their macros prevents you from using SampleLevel for specific mips (maybe most don’t need that, but it’s used in the domain portion of the shader for tessellation).

If you want the specific definitions of Unity’s macros, they are in HLSLSupprt.cginc, in the Editor/Data/CGIncludes folder of the unity installation. But essentially, the declare simply declares the Texture2D as separate. I prefer handling it myself if I know what is going on, but really, I had no idea this code was valid and could compile on Unity’s platform.

This gives me an almost infinite set, limited primarily by rendering power. Tex2D calls are expensive. 12 channels directly, between vertex colors and 4 uv’s, and more if I want to compress channels, or to alter textures based on normals.

1 Like
11

thanks for the hints

12

My suggestion for blending stuff in on say: Terrain, use deferred and deferred decals. The unity example is kinda a start, but really not complete. For our project I use a modified G-buffer layout, but I’m considering making a Deferred decal system that doesn’t need that change in exchange for 2 passes.
It should really allow you limitless amounts of variation “painted” onto the terrain/whatever :smile:

13

I’m not entirely sure what you mean by that, but I’ll take a look at it. Here’s an example of my shader.

https://www.dropbox.com/s/ruklhq5wk968fp9/Screenshot 2015-04-26 18.08.12.png?dl=0

We generate themed sections, and it’ll blend between sections, between walls, and we blend lake beds into the terrain, dirt sections in, etc etc. I also use it on walls to blend in vines. The whole section of rocks is actually tessellation, that rock facing is maybe 20 tris (another 10 or so at the very base where it angles in). The vines pop out as I use the alpha channel of diffuse textures to blend in textures on a conditional basis, and Bitmap2Material to generate varied textures to be applied and blended in.

I haven’t decided how to apply burnt sections though from a fireball explosion, or other alternatives, so I’ll take a look at what you’re mentioning.

Oh, that’s nifty. I see they are also Unity 5. I had made all my plans originally involving Unity 4. I’m not sure whether to be sad or happy at the new features… mainly wish I had known earlier! I’ll take a look and see if it can really apply the blending I’d like, but it’d be much quicker for a burn patch from an explosion to be applied that way than iterating through vertexes. My work isn’t wasted, though, as the blending of vines, dirt, bricks, etc is still valid.

14

Perhaps enough could be moved out to deferred decals that your base terrain layers (visible on screen) never exceed 16?
Remember that you could always swap what 16 textures are active at any one time.
Btw, are you on unity 5.x or 4.x ?

Or did it already work on OpenGL as it is?

15

Oh, everything works fine at this point, so there’s no concerns there anymore. The sampler issue was the primary fix required.

But I will take into some consideration of using decals for more interesting features like explosions and burn effects, acid, etc. It’s easier to wrap my mind around the terrain blending, but I’m also more familiar, so it’s a bias. The concept of scrolling UV’s on specific textures to let blended sections scroll is also easier for me to understand.

I’m not altogether too concerned with a mac release. I’m mainly concerned about Windows, Xbox One, and Playstation 4. Compiling to mac is not my biggest concern… it’s never been a good platform for gaming, imo.

16

Hi Plutoman, I’m in the same case in my terrain system now.
I’m trying my best to get texture2DArray to work at least on Dx11 device.
What I got now is using Dx11 native code to create a Texture2DArray SRV

extern "C" EXPORT_API void* ApplyTextureArray()
{
    if (!g_D3D11Device)
    {
        OutputDebugStringA("D3D11Device not set!\n");
        return NULL;
    }
    if (g_ArrayCount<=0)
    SAFE_RELEASE(g_pTextureArray);
    D3D11_TEXTURE2D_DESC descTexture;
    g_ppTextures[0]->GetDesc(&descTexture);
    descTexture.ArraySize = g_ArrayCount;
    descTexture.Usage = D3D11_USAGE_DEFAULT;
    descTexture.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    g_D3D11Device->CreateTexture2D(&descTexture, NULL, &g_pTextureArray);
    ID3D11DeviceContext *ctx;
    g_D3D11Device->GetImmediateContext(&ctx);
    for (int _arrayIndex = 0; _arrayIndex < g_ArrayCount; _arrayIndex++)
    {
        for (int _mipIndex = 0; _mipIndex < descTexture.MipLevels; _mipIndex++)
        {
            ctx->CopySubresourceRegion(g_pTextureArray, D3D11CalcSubresource(_mipIndex, _arrayIndex, descTexture.MipLevels), 0, 0, 0,
                g_ppTextures[_arrayIndex], D3D11CalcSubresource(_mipIndex, 0, descTexture.MipLevels), NULL);
        }
    }
    g_D3D11Device->CreateShaderResourceView(g_pTextureArray, NULL, &g_SRV);
    return g_SRV;
}

and apply this srv to unity Texture2D object by:

            textureArray = Texture2D.CreateExternalTexture(2048,2048,TextureFormat.DXT1,true,false,ApplyTextureArray());
            GetComponent<Renderer>().material.mainTexture = textureArray;

But It is still a dead end as unity shader compiler won’t go with :

Texture2DArray _MainTex;
SamplerState sampler_MainTex;

If i change it to Texture2D the texture can be sampled in shader but only the first layer.
This syntax is good as I tried to render with this Texture2DArray in native code with shader like:

static const char* kD3D11ShaderText =
    "Texture2DArray mTexture: register(t100);"
    "SamplerState mTextureSampler:register(s15);\n"
    "cbuffer MyCB : register(b0) {\n"
    "    float4x4 worldMatrix;\n"
    "    float4 arrayIdx;\n"
    "}\n"
    "void VS (float3 pos : POSITION, float4 color : COLOR, out float4 ocolor : COLOR, out float4 opos : SV_Position) {\n"
    "    opos = mul (worldMatrix, float4(pos,1));\n"
    "    ocolor = float4(pos.xy,arrayIdx.x,1);\n"
    "}\n"
    "float4 PS (float4 color : COLOR,float4 pos : SV_Position) : SV_TARGET {\n"
    "    return mTexture.Sample(mTextureSampler,float3(color.xyz));\n"
    "}\n";

And all layer can be sampled correctly.

It was so close! SamplerState to Texture2D/Texture3DArray are the same. It is only the compiler that is stopingit to happen.

17

And I found this Possible texture array syntax · GitHub
Aras is planning to put array texture in unity, i don’t know what is stoping him. maybe how to view the resource in inspector?

18

I wonder if there’s a way to access/use/reference a pre-compiled shader, compiled under DX?

I’m not sure if that’s possible with Unity, or at least, in any simple form, but since the rendering pipeline is calling shaders that run on the GPU, it makes sense that it would be possible.

19

Guys, Did you checked the 5.4 changelog?

Looks like we, the Minecraft cloners, finally can have vistas done in a single draw call! Hardware Texture Arrays are coming on March, 16!

20

@petersvp The 5.4 has been out there since then. Did you have a chance to play with it? I was wondering whether the texture arrays are working faster or better than the texture atlases solutions.