ScriptableRenderPipeline/Assets/ScriptableRenderLoop/common/TextureCache.cs

using UnityEngine;
using System.Collections.Generic;

public class TextureCache2D : TextureCache
{
    private Texture2DArray m_Cache;

    public override void TransferToSlice(int sliceIndex, Texture texture)
    {
        var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);

        if (texture is Texture2D)
        {
            mismatch |= (m_Cache.format != (texture as Texture2D).format);
        }

        if (mismatch)
        {
            if (!Graphics.ConvertTexture(texture, 0, m_Cache, sliceIndex))
            {
                Debug.LogErrorFormat(texture, "Unable to convert texture \"{0}\" to match renderloop settings ({1}x{2} {3})",
                  texture.name, m_Cache.width, m_Cache.height, m_Cache.format);
            }
        }
        else
        {
            Graphics.CopyTexture(texture, 0, m_Cache, sliceIndex);
        }
    }

    public override Texture GetTexCache()
    {
        return m_Cache;
    }

    public bool AllocTextureArray(int numTextures, int width, int height, TextureFormat format, bool isMipMapped)
    {
        var res = AllocTextureArray(numTextures);
        m_NumMipLevels = GetNumMips(width, height);

        m_Cache = new Texture2DArray(width, height, numTextures, format, isMipMapped)
        {
            hideFlags = HideFlags.HideAndDontSave,
            wrapMode = TextureWrapMode.Clamp
        };

        return res;
    }

    public void Release()
    {
        Texture.DestroyImmediate(m_Cache);      // do I need this?
    }
}

public class TextureCacheCubemap : TextureCache
{
    private CubemapArray m_Cache;

    // alternative panorama path intended for mobile
    // the member variables below are only in use when m_IsNoCubeArray is true.
    private bool m_IsNoCubeArray = false;
    private Texture2DArray m_CacheNoCubeArray;
    private RenderTexture[] m_StagingRTs;
    private int m_NumPanoMipLevels;
    private Material m_CubeBlitMaterial;
    private int m_CubeMipLevelPropName;
    private int m_cubeSrcTexPropName;
    // alternative panorama path intended for mobile
    // the member variables below are only in use when m_IsNoCubeArray is true.


    public override void TransferToSlice(int sliceIndex, Texture texture)
    {
        if(m_IsNoCubeArray)
            TransferToPanoCache(sliceIndex, texture);
        else
        {
            var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);

            if (texture is Cubemap)
            {
                mismatch |= (m_Cache.format != (texture as Cubemap).format);
            }

            if (mismatch)
            {
                bool failed = false;

                for (int f = 0; f < 6; f++)
                {
                    if (!Graphics.ConvertTexture(texture, f, m_Cache, 6 * sliceIndex + f))
                    {
                        failed = true;
                        break;
                    }
                }

                if (failed)
                {
                    Debug.LogErrorFormat(texture, "Unable to convert texture \"{0}\" to match renderloop settings ({1}x{2} {3})",
                      texture.name, m_Cache.width, m_Cache.height, m_Cache.format);
                }
            }
            else
            {
                for (int f = 0; f < 6; f++)
                    Graphics.CopyTexture(texture, f, m_Cache, 6 * sliceIndex + f);
            }
        }
    }

    public override Texture GetTexCache()
    {
        return m_IsNoCubeArray ? (Texture) m_CacheNoCubeArray : m_Cache;
    }

    public bool AllocTextureArray(int numCubeMaps, int width, TextureFormat format, bool isMipMapped)
    {
        var res = AllocTextureArray(numCubeMaps);
        m_NumMipLevels = GetNumMips(width, width);      // will calculate same way whether we have cube array or not
        
        if(m_IsNoCubeArray)
        {
            if(!m_CubeBlitMaterial) m_CubeBlitMaterial = new Material(Shader.Find("Hidden/CubeToPano"));

            int panoWidthTop = 4*width;
            int panoHeightTop = 2*width;

            // create panorama 2D array. Hardcoding the render target for now when m_IsNoCubeArray is true. No convenient way atm. to
            // map from TextureFormat to RenderTextureFormat and don't want to deal with sRGB issues for now.
            m_CacheNoCubeArray = new Texture2DArray(panoWidthTop, panoHeightTop, numCubeMaps, TextureFormat.RGBAHalf, isMipMapped)
            {
                hideFlags = HideFlags.HideAndDontSave,
                wrapMode = TextureWrapMode.Repeat,
                filterMode = FilterMode.Trilinear,
                anisoLevel = 0
            };

            m_NumPanoMipLevels = isMipMapped ? GetNumMips(panoWidthTop, panoHeightTop) : 1;
            m_StagingRTs = new RenderTexture[m_NumPanoMipLevels];
            for(int m=0; m<m_NumPanoMipLevels; m++)
            {
                m_StagingRTs[m] = new RenderTexture(Mathf.Max(1,panoWidthTop>>m), Mathf.Max(1,panoHeightTop>>m), 0, RenderTextureFormat.ARGBHalf);
            }

            if(m_CubeBlitMaterial)
            {
                m_CubeMipLevelPropName = Shader.PropertyToID("_cubeMipLvl");
                m_cubeSrcTexPropName = Shader.PropertyToID("_srcCubeTexture");
            }
        }
        else
        {
            m_Cache = new CubemapArray(width, numCubeMaps, format, isMipMapped)
            {
                hideFlags = HideFlags.HideAndDontSave,
                wrapMode = TextureWrapMode.Clamp,
                filterMode = FilterMode.Trilinear,
                anisoLevel = 0 // It is important to set 0 here, else unity force anisotropy filtering
            };
        }

        return res;
    }

    public void Release()
    {
        if(m_IsNoCubeArray)
        {
            Texture.DestroyImmediate(m_CacheNoCubeArray);
            for(int m=0; m<m_NumPanoMipLevels; m++)
            {
                m_StagingRTs[m].Release();
            }
            m_StagingRTs=null;
            if(m_CubeBlitMaterial) Material.DestroyImmediate(m_CubeBlitMaterial);
        }
        else Texture.DestroyImmediate(m_Cache);
    }

    private void TransferToPanoCache(int sliceIndex, Texture texture)
    {
        m_CubeBlitMaterial.SetTexture(m_cubeSrcTexPropName, texture);
        for(int m=0; m<m_NumPanoMipLevels; m++)
        {
            m_CubeBlitMaterial.SetInt(m_CubeMipLevelPropName, Mathf.Min(m_NumMipLevels-1,m) );
            Graphics.SetRenderTarget(m_StagingRTs[m]);
            Graphics.Blit(null, m_CubeBlitMaterial, 0);
        }

        for(int m=0; m<m_NumPanoMipLevels; m++)
            Graphics.CopyTexture(m_StagingRTs[m], 0, 0, m_CacheNoCubeArray, sliceIndex, m);
    }
}


public abstract class TextureCache
{
    protected int m_NumMipLevels;

    static int s_GlobalTextureCacheVersion = 0;
    int m_TextureCacheVersion = 0;

#if UNITY_EDITOR
    internal class AssetReloader : UnityEditor.AssetPostprocessor
    {
        void OnPostprocessTexture(Texture texture)
        {
            s_GlobalTextureCacheVersion++;
        }
    }
#endif

    private struct SSliceEntry
    {
        public uint texId;
        public uint countLRU;
    };

    private int m_NumTextures;
    private int[] m_SortedIdxArray;
    private SSliceEntry[] m_SliceArray;

    Dictionary<uint, int> m_LocatorInSliceArray;

    private static uint g_MaxFrameCount = unchecked((uint)(-1));
    private static uint g_InvalidTexID = (uint)0;

    public int FetchSlice(Texture texture)
    {
        if (texture == null) return 0;
        var texId = (uint)texture.GetInstanceID();

        //assert(TexID!=g_InvalidTexID);
        if (texId == g_InvalidTexID) return 0;

        var bSwapSlice = false;
        var bFoundAvailOrExistingSlice = false;
        var sliceIndex = -1;

        // search for existing copy
        if (m_LocatorInSliceArray.ContainsKey(texId))
        {
            if (m_TextureCacheVersion != s_GlobalTextureCacheVersion)
            {
                m_LocatorInSliceArray.Remove(texId);
                m_TextureCacheVersion++;
                Debug.Assert(m_TextureCacheVersion <= s_GlobalTextureCacheVersion);
            }
            else
            {
                sliceIndex = m_LocatorInSliceArray[texId];
                bFoundAvailOrExistingSlice = true;
            }
            //assert(m_SliceArray[sliceIndex].TexID==TexID);
        }

        // If no existing copy found in the array
        if (!bFoundAvailOrExistingSlice)
        {
            // look for first non zero entry. Will by the least recently used entry
            // since the array was pre-sorted (in linear time) in NewFrame()
            var bFound = false;
            int j = 0, idx = 0;
            while ((!bFound) && j < m_NumTextures)
            {
                idx = m_SortedIdxArray[j];
                if (m_SliceArray[idx].countLRU == 0) ++j;       // if entry already snagged by a new texture in this frame then ++j
                else bFound = true;
            }

            if (bFound)
            {
                // if we are replacing an existing entry delete it from m_locatorInSliceArray.
                if (m_SliceArray[idx].texId != g_InvalidTexID)
                {
                    m_LocatorInSliceArray.Remove(m_SliceArray[idx].texId);
                }

                m_LocatorInSliceArray.Add(texId, idx);
                m_SliceArray[idx].texId = texId;

                sliceIndex = idx;
                bFoundAvailOrExistingSlice = true;
                bSwapSlice = true;
            }
        }


        // wrap up
        //assert(bFoundAvailOrExistingSlice);
        if (bFoundAvailOrExistingSlice)
        {
            m_SliceArray[sliceIndex].countLRU = 0;      // mark slice as in use this frame

            if (bSwapSlice) // if this was a miss
            {
                // transfer new slice to sliceIndex from source texture
                TransferToSlice(sliceIndex, texture);
            }
        }

        return sliceIndex;
    }

    public void NewFrame()
    {
        var numNonZeros = 0;
        var tmpBuffer = new int[m_NumTextures];
        for (int i = 0; i < m_NumTextures; i++)
        {
            tmpBuffer[i] = m_SortedIdxArray[i];     // copy buffer
            if (m_SliceArray[m_SortedIdxArray[i]].countLRU != 0) ++numNonZeros;
        }
        int nonZerosBase = 0, zerosBase = 0;
        for (int i = 0; i < m_NumTextures; i++)
        {
            if (m_SliceArray[tmpBuffer[i]].countLRU == 0)
            {
                m_SortedIdxArray[zerosBase + numNonZeros] = tmpBuffer[i];
                ++zerosBase;
            }
            else
            {
                m_SortedIdxArray[nonZerosBase] = tmpBuffer[i];
                ++nonZerosBase;
            }
        }

        for (int i = 0; i < m_NumTextures; i++)
        {
            if (m_SliceArray[i].countLRU < g_MaxFrameCount) ++m_SliceArray[i].countLRU;     // next frame
        }

        //for(int q=1; q<m_numTextures; q++)
        //    assert(m_SliceArray[m_SortedIdxArray[q-1]].CountLRU>=m_SliceArray[m_SortedIdxArray[q]].CountLRU);
    }

    protected TextureCache()
    {
        m_NumTextures = 0;
        m_NumMipLevels = 0;
    }

    public virtual void TransferToSlice(int sliceIndex, Texture texture)
    {
    }

    public virtual Texture GetTexCache()
    {
        return null;
    }

    protected bool AllocTextureArray(int numTextures)
    {
        if (numTextures > 0)
        {
            m_SliceArray = new SSliceEntry[numTextures];
            m_SortedIdxArray = new int[numTextures];
            m_LocatorInSliceArray = new Dictionary<uint, int>();

            m_NumTextures = numTextures;
            for (int i = 0; i < m_NumTextures; i++)
            {
                m_SliceArray[i].countLRU = g_MaxFrameCount;         // never used before
                m_SliceArray[i].texId = g_InvalidTexID;
                m_SortedIdxArray[i] = i;
            }
        }

        //return m_SliceArray != NULL && m_SortedIdxArray != NULL && numTextures > 0;
        return numTextures > 0;
    }

    // should not really be used in general. Assuming lights are culled properly entries will automatically be replaced efficiently.
    public void RemoveEntryFromSlice(Texture texture)
    {
        var texId = (uint)texture.GetInstanceID();

        //assert(TexID!=g_InvalidTexID);
        if (texId == g_InvalidTexID) return;

        // search for existing copy
        if (!m_LocatorInSliceArray.ContainsKey(texId))
            return;

        var sliceIndex = m_LocatorInSliceArray[texId];

        //assert(m_SliceArray[sliceIndex].TexID==TexID);

        // locate entry sorted by uCountLRU in m_pSortedIdxArray
        var foundIdxSortLRU = false;
        var i = 0;
        while ((!foundIdxSortLRU) && i < m_NumTextures)
        {
            if (m_SortedIdxArray[i] == sliceIndex) foundIdxSortLRU = true;
            else ++i;
        }

        if (!foundIdxSortLRU)
            return;

        // relocate sliceIndex to front of m_pSortedIdxArray since uCountLRU will be set to maximum.
        for (int j = 0; j < i; j++)
        {
            m_SortedIdxArray[j + 1] = m_SortedIdxArray[j];
        }
        m_SortedIdxArray[0] = sliceIndex;

        // delete from m_locatorInSliceArray and m_pSliceArray.
        m_LocatorInSliceArray.Remove(texId);
        m_SliceArray[sliceIndex].countLRU = g_MaxFrameCount;            // never used before
        m_SliceArray[sliceIndex].texId = g_InvalidTexID;
    }

    protected int GetNumMips(int width, int height)
    {
        return GetNumMips(width > height ? width : height);
    }

    protected int GetNumMips(int dim)
    {
        var uDim = (uint)dim;
        var iNumMips = 0;
        while (uDim > 0)
        { ++iNumMips; uDim >>= 1; }
        return iNumMips;
    }
}