// SPDX-FileCopyrightText: Copyright 2025 suyu Emulator Project
// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
// (Triforce) The Tegra GPU's block-linear texture layout undone, ported from suyu's video_core/textures/decoders.cpp
// (SwizzleImpl with TO_LINEAR false, depth 1). A texture is stored in GOBs (64 bytes by 8 rows, 512 bytes), stacked
// 2^blockHeight GOBs tall into blocks; blocks run left to right, then the next row of blocks.
//
// Inside a GOB this is the Switch 2's order, as in our suyu's decoders.h: the Tegra X1's (x bits 0-3, 5, 8 / y bits 4,
// 6, 7) with offset bits 5 and 6 swapped, so x bit 4 lands on bit 6 and y bit 1 on bit 5. (The X1's order, which most
// Switch tools use, scrambles this game's textures in 4x4-block patches.)
namespace Triforce.Core.GameFiles;
/// Tegra block-linear to linear.
public static class BlockLinear
{
const int GobSizeXShift = 6; // 64 bytes
const int GobSizeYShift = 3; // 8 rows
const int GobSizeShift = GobSizeXShift + GobSizeYShift; // 512 bytes
/// The position of a byte inside its GOB: pdep of x into SWIZZLE_X_BITS 0b1_0100_1111 and of y into
/// SWIZZLE_Y_BITS 0b0_1011_0000.
static int SwizzleX(int x) => (x & 15) | (x & 16) << 2 | (x & 32) << 3;
static int SwizzleY(int y) => (y & 3) << 4 | (y & 4) << 5;
/// The size a block-linear image takes, in bytes.
public static long Size(int width, int height, int bytesPerElement, int blockHeightLog2)
{
var alignedWidth = (width * bytesPerElement + 63) & ~63;
var rows = 1 << (GobSizeYShift + blockHeightLog2);
var alignedHeight = (height + rows - 1) / rows * rows;
return (long)alignedWidth * alignedHeight;
}
///
/// A block-linear image made linear. width and height count elements (pixels, or blocks of a compressed format);
/// bytesPerElement is 1, 2, 4, 8 or 16. The result is width * height * bytesPerElement bytes, rows one after another.
///
public static byte[] Deswizzle(ReadOnlySpan input, int width, int height, int bytesPerElement, int blockHeightLog2)
{
if (bytesPerElement is not (1 or 2 or 4 or 8 or 16))
throw new NotSupportedException(bytesPerElement + " bytes per element");
var pitch = width * bytesPerElement;
var output = new byte[pitch * height];
var gobsInX = (pitch + 63) >> GobSizeXShift;
var blockSize = gobsInX << (GobSizeShift + blockHeightLog2);
var blockHeightMask = (1 << blockHeightLog2) - 1;
var xShift = GobSizeShift + blockHeightLog2;
if (Size(width, height, bytesPerElement, blockHeightLog2) > input.Length)
throw new InvalidDataException("the texture's data is shorter than its size calls for");
for (var y = 0; y < height; y++)
{
var swizzledY = SwizzleY(y);
var blockY = y >> GobSizeYShift;
var offsetY = (blockY >> blockHeightLog2) * blockSize + ((blockY & blockHeightMask) << GobSizeShift);
var row = output.AsSpan(y * pitch, pitch);
for (var x = 0; x < pitch; x += bytesPerElement)
{
var offsetX = (x >> GobSizeXShift) << xShift;
var at = offsetY + offsetX + (SwizzleX(x & 63) | swizzledY);
input.Slice(at, bytesPerElement).CopyTo(row.Slice(x, bytesPerElement));
}
}
return output;
}
}