Unity logs 'Assertion failed on expression: 'mipLevel < m_MipCount' but code works fine?

Unity Engine
,
1

I have already filed it as a bug report, but I wanted to know if anybody has an idea of how I can workaround it. I wrote this utility to execute Texture2D.Compress() asynchronously and it works, but I get the error 'Assertion failed on expression: ‘mipLevel < m_MipCount’ whenever I call compress. (to recreate it attach this mono-behaviour to an object and press play.)

using System;
using System.Collections;
using Unity.Collections;
using Unity.Profiling;
using UnityEngine;
public class BugExample : MonoBehaviour
{
    public Texture2D testUncompressed;
    public Texture2D testCompressed;
    public int width = 256, height = 256;
    // Start is called before the first frame update
    void Start()
    {
        testUncompressed = new Texture2D(width, height, TextureFormat.RGBA32, true);
        for (int y = 0; y < height; y++)
            for (int x = 0; x < width; x++)
                testUncompressed.SetPixel(x, y, new Color(x / (float)width, y / (float)height, 0.3f));
        testUncompressed.Apply();
        (IEnumerator job, Texture2D result) = AsyncCompression.CompressTextureJob(testUncompressed);
        while (job.MoveNext()) { }
        testCompressed = result;
    }
    // Update is called once per frame
    void Update() 
    {
     
    }
}
public static class AsyncCompression
{
    public static TextureFormat GetCompressedFormat(TextureFormat format)
    {
        return format switch
        {
            TextureFormat.RGBA32 => TextureFormat.DXT5,
            TextureFormat.ARGB32 => TextureFormat.DXT5,
            TextureFormat.RGB24 => TextureFormat.DXT1,
            TextureFormat.R8 => TextureFormat.BC4,
            _ => throw new NotSupportedException()
        };
    }
    // log2 of value. returns 0 for 1, 1 for 2, 2 for 4
    static int PowerOfTwo(int value)
    {
        for (int i = 0; i < 32; ++i)
            if (value >> i == 0)
                return i - 1;
        throw new ArgumentOutOfRangeException($"cannot get power of two: {value}");
    }
    public static (IEnumerator job, Texture2D result) CompressTextureJob(Texture2D source, int blockCount = 8)
    {
        TextureFormat compressed = GetCompressedFormat(source.format);
        Texture2D result = new(source.width, source.height, compressed, source.mipmapCount - 2, !source.isDataSRGB, true);
        return (CompressTexureJob(source, result, blockCount), result);
    }
    static readonly ProfilerMarker PCompressTextureBlock = new("Compress Texture Block");
    static IEnumerator CompressTexureJob(Texture2D source, Texture2D result, int blockCount)
    {
        bool linear = !source.isDataSRGB;
        NativeArray<byte>[] resultData = new NativeArray<byte>[result.mipmapCount];
        for (int i = 0; i < resultData.Length; ++i)
            resultData[i] = result.GetPixelData<byte>(i); // pointer, not copy
        NativeArray<byte>[] sourceData = new NativeArray<byte>[source.mipmapCount];
        for (int i = 0; i < sourceData.Length; ++i)
            sourceData[i] = source.GetPixelData<byte>(i); // pointer, not copy
        int sourceBlockByteSize = sourceData[0].Length / blockCount;
        int blockByteSize = resultData[0].Length / blockCount;
        int blockHeight = source.height / blockCount;
        int blockMipCount = PowerOfTwo(blockHeight) - 2;
        Texture2D block = new(source.width, blockHeight, source.format, blockMipCount, linear, true);
        for (int i = 0; i < blockCount; ++i)
        {
            PCompressTextureBlock.Begin();
            for (int mip = 0; mip < blockMipCount; ++mip)
                block.SetPixelData(sourceData[mip], mip, (sourceBlockByteSize >> mip * 2) * i);
            block.Compress(true);
            for (int mip = 0; mip < blockMipCount; ++mip)
            {
                NativeArray<byte> blockData = block.GetPixelData<byte>(mip);
                int mipBlockByteSize = blockByteSize >> mip * 2;
                resultData[mip].Slice(mipBlockByteSize * i, mipBlockByteSize).CopyFrom(blockData);
            }
            block.Reinitialize(block.width, block.height, source.format, true);
            PCompressTextureBlock.End();
            yield return null;
        }
        GameObject.Destroy(block);
        int remainingMips = source.mipmapCount - 2 - blockMipCount;
        if (remainingMips > 0)
        {
            Texture2D lowMips = new(source.width >> blockMipCount, source.height >> blockMipCount, source.format, remainingMips, linear, true);
            for (int mip = 0; mip < remainingMips; ++mip)
                lowMips.SetPixelData(sourceData[mip + blockMipCount], mip);
            lowMips.Compress(true);
            for (int mip = 0; mip < remainingMips; ++mip)
                result.SetPixelData(lowMips.GetPixelData<byte>(mip), mip + blockMipCount);
                GameObject.Destroy(lowMips);
        }
        result.Apply(false);
    }
}
2

This doesn’t look right:

int blockHeight = source.height / blockCount;
int blockMipCount = PowerOfTwo(blockHeight)

I think you need to call PowerOfTwo(Math.Max(source.width, source.height)).

Also, why do you exclude the last 2 mip levels? Even block compressed textures can go down to 1 x 1. The smallest mips will still be at least one block large but the GPU will ignore most texels of the block.

The expression sourceBlockByteSize >> mip * 2 looks weird to me too. Are you sure the operator precedence is what you think it is? I would put some parentheses around it. Also, why times two?

You also should deal with non-square textures. Your code won’t work if width is greater than height. You need to clamp the mip size.
int mipWidth = Math.Max(source.width >> mipLevel, 1);
int mipHeight = Math.Max(source.height >> mipLevel, 1);

PS: Actually, the longer I look at it, the less I understand the code. Why do you go through all of the trouble with blocks? Can’t you just call Texture2D.Compress on the entire texture?

3

I should have said this is only running on square textures at the moment. It would be nice to support non square ones so I’ll do it at some point.

The operator precedence is multiply first, but I should probably have parenthesis for code readability. The reason for it is that each mip is 4 times less data then the previous, because its twice as small on both the x and y axis.

The reason to go for all the trouble with blocks is to make the compression asynchronous. If you call Texture2D.Compress() on a 1024 square texture (which my project does regularly at runtime) that takes around 40ms on my fast CPU, and probably would take around 80-100ms on our min-spec. That would involve dropping a lot of frames. By doing the work like this in an enumerator, you can keep the work per-frame to something more reasonable like 5ms.

To be clear though, this code does work, it just gives this error message. It’s not a C# exception, its unity C++ logging an error, and I don’t know what I did that causes the unity code to run in a bad state.

4

Ok, thanks for the clarification. I would probably do it on the GPU in a shader to make it fast enough.

I’m still wondering why you need mips for a single block, though.

5

I’m not sure I know what you mean by needing mips for a block. The blocks need to have mips because you need your final texture needs to have mips. If you have no mips in your blocks, then you to do all the mips in the final pass of this function, which is 25% of the total work, which is not a small enough subdivision.

I’m not doing it on the GPU because as bug-prone and annoying as the way I’m doing it now is, doing it on the GPU is like 10x worse. I’d have to write my own BC compressor in HLSL, use the GraphicsFence which in my experience only works if you use the enum value that explicitly says its unsupported, do some weird Graphics.CopyTexture call between non-compressed and compressed textures of different sizes (does that even work in unity? what they do in the paper is create two textures that share a GPU memory buffer but I don’t think unity exposes an API that lets you do that). And all that would have to work at different mip levels and be called a bunch of times. It would be faster, but I don’t think it’s worth it.

6

That’s just an optimization for XBox. But I understand if you don’t want to go this route because it would require some additional time and effort.

I mean that you are passing blockMipCount instead of 1 when creating the block texture.

Texture2D block = new(source.width, blockHeight, source.format, blockMipCount, linear, true);

I haven’t looked at your code in detail but conceptionally this doesn’t make sense to me. When you use block compression, each mip level is subdivided into 4x4 blocks of texels. Then instead of storing 16 colors, you just store a palette of 2 colors and 16 two-bit indices that give you 4 ways to mix those two colors. So a block is a two-dimensional by nature. Each mip level is seen as a separate image. Blocks don’t reference texels of other mip levels.

So in pseudo code you would write something like this

Texture2D block = new(4, 4, source.format, 1, source.linear);

for (int mip = 0; mip < source.mipCount; ++mip)
{
    int mipWidth = Math.Max(source.width >> mip, 1);
    int mipHeight = Math.Max(source.height >> mip, 1);
    int numBlocksX = Math.Max(mipWidth / 4, 1);
    int numBlocksY = Math.Max(mipHeight / 4, 1);

    for (int y = 0; y < numBlocksY; ++y)
    {
        for (int x = 0; x < numBlocksX; ++x)
        {
            Rect sourceRect = new Rect(x * 4, y * 4, 4, 4);
            Point destPos = new Point(0, 0);
            int srcMip = mip;
            int dstMip = 0;
            CopyTexture(source, block, sourceRect, destPos, srcMip, dstMip);
            block.Compress();
            // TODO copy compressed texels to destination texture
            yield return;
        }
    }
}

Am I missing something?

PS: Here is a compute shader implementation for Unity:
https://discussions.unity.com/t/822609

7

The difference between what you are doing and what I am doing is just that I iterate over the mips within the x and y iterations, not over them. its foreach (x) { foreach (y) { foreach (mip) } } instead of foreach (mip) { foreach (x) { foreach (y) } } I call compress on the block outside of the loop for the mip and because the compressed block has mips, I am effectively compressing all the mips in the 1 call to .Compress() and then copying them into the destination texture.