aboutsummaryrefslogtreecommitdiff
path: root/Ryujinx.Graphics.Texture/SizeInfo.cs
blob: eb573728374a09f43c1ab14eb52979998db913cc (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
using System;
using System.Collections.Generic;

namespace Ryujinx.Graphics.Texture
{
    public readonly struct SizeInfo
    {
        private readonly int[] _mipOffsets;

        private readonly int _levels;
        private readonly int _depth;
        private readonly bool _is3D;

        public readonly int[] AllOffsets;
        public readonly int[] SliceSizes;
        public readonly int[] LevelSizes;
        public int LayerSize { get; }
        public int TotalSize { get; }

        public SizeInfo(int size)
        {
            _mipOffsets = new int[] { 0 };
            AllOffsets  = new int[] { 0 };
            SliceSizes  = new int[] { size };
            LevelSizes  = new int[] { size };
            _depth      = 1;
            _levels     = 1;
            LayerSize   = size;
            TotalSize   = size;
            _is3D       = false;
        }

        internal SizeInfo(
            int[] mipOffsets,
            int[] allOffsets,
            int[] sliceSizes,
            int[] levelSizes,
            int   depth,
            int   levels,
            int   layerSize,
            int   totalSize,
            bool  is3D)
        {
            _mipOffsets = mipOffsets;
            AllOffsets  = allOffsets;
            SliceSizes  = sliceSizes;
            LevelSizes  = levelSizes;
            _depth      = depth;
            _levels     = levels;
            LayerSize   = layerSize;
            TotalSize   = totalSize;
            _is3D       = is3D;
        }

        public int GetMipOffset(int level)
        {
            if ((uint)level >= _mipOffsets.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(level));
            }

            return _mipOffsets[level];
        }

        public bool FindView(int offset, out int firstLayer, out int firstLevel)
        {
            int index = Array.BinarySearch(AllOffsets, offset);

            if (index < 0)
            {
                firstLayer = 0;
                firstLevel = 0;

                return false;
            }

            if (_is3D)
            {
                firstLayer = index;
                firstLevel = 0;

                int levelDepth = _depth;

                while (firstLayer >= levelDepth)
                {
                    firstLayer -= levelDepth;
                    firstLevel++;
                    levelDepth = Math.Max(levelDepth >> 1, 1);
                }
            }
            else
            {
                firstLayer = index / _levels;
                firstLevel = index - (firstLayer * _levels);
            }

            return true;
        }

        public IEnumerable<Region> AllRegions()
        {
            if (_is3D)
            {
                for (int i = 0; i < _mipOffsets.Length; i++)
                {
                    int maxSize = TotalSize - _mipOffsets[i];
                    yield return new Region(_mipOffsets[i], Math.Min(maxSize, LevelSizes[i]));
                }
            }
            else
            {
                for (int i = 0; i < AllOffsets.Length; i++)
                {
                    yield return new Region(AllOffsets[i], SliceSizes[i % _levels]);
                }
            }
        }
    }
}