Move solution and projects to src

src/Ryujinx.Graphics.Texture/BlockLinearLayout.cs

@@ -0,0 +1,195 @@
+using Ryujinx.Common;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+
+using static Ryujinx.Graphics.Texture.BlockLinearConstants;
+
+namespace Ryujinx.Graphics.Texture
+{
+    class BlockLinearLayout
+    {
+        private struct RobAndSliceSizes
+        {
+            public int RobSize;
+            public int SliceSize;
+
+            public RobAndSliceSizes(int robSize, int sliceSize)
+            {
+                RobSize   = robSize;
+                SliceSize = sliceSize;
+            }
+        }
+
+        private int _texBpp;
+
+        private int _bhMask;
+        private int _bdMask;
+
+        private int _bhShift;
+        private int _bdShift;
+        private int _bppShift;
+
+        private int _xShift;
+
+        private int _robSize;
+        private int _sliceSize;
+
+        // Variables for built in iteration.
+        private int _yPart;
+        private int _yzPart;
+        private int _zPart;
+
+        public BlockLinearLayout(
+            int width,
+            int height,
+            int gobBlocksInY,
+            int gobBlocksInZ,
+            int bpp)
+        {
+            _texBpp = bpp;
+
+            _bppShift = BitOperations.TrailingZeroCount(bpp);
+
+            _bhMask = gobBlocksInY - 1;
+            _bdMask = gobBlocksInZ - 1;
+
+            _bhShift = BitOperations.TrailingZeroCount(gobBlocksInY);
+            _bdShift = BitOperations.TrailingZeroCount(gobBlocksInZ);
+
+            _xShift = BitOperations.TrailingZeroCount(GobSize * gobBlocksInY * gobBlocksInZ);
+
+            RobAndSliceSizes rsSizes = GetRobAndSliceSizes(width, height, gobBlocksInY, gobBlocksInZ);
+
+            _robSize   = rsSizes.RobSize;
+            _sliceSize = rsSizes.SliceSize;
+        }
+
+        private RobAndSliceSizes GetRobAndSliceSizes(int width, int height, int gobBlocksInY, int gobBlocksInZ)
+        {
+            int widthInGobs = BitUtils.DivRoundUp(width * _texBpp, GobStride);
+
+            int robSize = GobSize * gobBlocksInY * gobBlocksInZ * widthInGobs;
+
+            int sliceSize = BitUtils.DivRoundUp(height, gobBlocksInY * GobHeight) * robSize;
+
+            return new RobAndSliceSizes(robSize, sliceSize);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetOffset(int x, int y, int z)
+        {
+            return GetOffsetWithLineOffset(x << _bppShift, y, z);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetOffsetWithLineOffset(int x, int y, int z)
+        {
+            int yh = y / GobHeight;
+
+            int offset = (z >> _bdShift) * _sliceSize + (yh >> _bhShift) * _robSize;
+
+            offset += (x / GobStride) << _xShift;
+
+            offset += (yh & _bhMask) * GobSize;
+
+            offset += ((z & _bdMask) * GobSize) << _bhShift;
+
+            offset += ((x & 0x3f) >> 5) << 8;
+            offset += ((y & 0x07) >> 1) << 6;
+            offset += ((x & 0x1f) >> 4) << 5;
+            offset += ((y & 0x01) >> 0) << 4;
+            offset += ((x & 0x0f) >> 0) << 0;
+
+            return offset;
+        }
+
+        public (int offset, int size) GetRectangleRange(int x, int y, int width, int height)
+        {
+            // Justification:
+            // The 2D offset is a combination of separate x and y parts.
+            // Both components increase with input and never overlap bits.
+            // Therefore for each component, the minimum input value is the lowest that component can go.
+            // Minimum total value is minimum X component + minimum Y component. Similar goes for maximum.
+
+            int start = GetOffset(x, y, 0);
+            int end = GetOffset(x + width - 1, y + height - 1, 0) + _texBpp; // Cover the last pixel.
+            return (start, end - start);
+        }
+
+        public bool LayoutMatches(BlockLinearLayout other)
+        {
+            return _robSize == other._robSize &&
+                   _sliceSize == other._sliceSize &&
+                   _texBpp == other._texBpp &&
+                   _bhMask == other._bhMask &&
+                   _bdMask == other._bdMask;
+        }
+
+        // Functions for built in iteration.
+        // Components of the offset can be updated separately, and combined to save some time.
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetY(int y)
+        {
+            int yh = y / GobHeight;
+            int offset = (yh >> _bhShift) * _robSize;
+
+            offset += (yh & _bhMask) * GobSize;
+
+            offset += ((y & 0x07) >> 1) << 6;
+            offset += ((y & 0x01) >> 0) << 4;
+
+            _yPart = offset;
+            _yzPart = offset + _zPart;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetZ(int z)
+        {
+            int offset = (z >> _bdShift) * _sliceSize;
+
+            offset += ((z & _bdMask) * GobSize) << _bhShift;
+
+            _zPart = offset;
+            _yzPart = offset + _yPart;
+        }
+
+        /// <summary>
+        /// Optimized conversion for line offset in bytes to an absolute offset. Input x must be divisible by 16.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetOffsetWithLineOffset16(int x)
+        {
+            int offset = (x / GobStride) << _xShift;
+
+            offset += ((x & 0x3f) >> 5) << 8;
+            offset += ((x & 0x1f) >> 4) << 5;
+
+            return offset + _yzPart;
+        }
+
+        /// <summary>
+        /// Optimized conversion for line offset in bytes to an absolute offset. Input x must be divisible by 64.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetOffsetWithLineOffset64(int x)
+        {
+            int offset = (x / GobStride) << _xShift;
+
+            return offset + _yzPart;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetOffset(int x)
+        {
+            x <<= _bppShift;
+            int offset = (x / GobStride) << _xShift;
+
+            offset += ((x & 0x3f) >> 5) << 8;
+            offset += ((x & 0x1f) >> 4) << 5;
+            offset += (x & 0x0f);
+
+            return offset + _yzPart;
+        }
+    }
+}