Mirrors/Switch-Toolbox
2
0
Fork 0
mirror of https://github.com/KillzXGaming/Switch-Toolbox synced 2024-11-30 00:10:36 +00:00
Code Issues Projects Releases Packages Wiki Activity
Switch-Toolbox/Switch_Toolbox_Library/Swizzling/NewSwizzleCodeBackup.cs

2594 lines
96 KiB
C#
Raw Normal View History

Some more fixes. Revert the GX2 one more time since swizzling is a bit bugged, but add a more up to date code as a backup. Fix the swizzle pattern settings
2019-04-17 18:59:08 +00:00
using System;
using System.Linq;
using System.Collections.Generic;
Make sure to use the right GX2 swizzling code so i don't break anything
2019-05-31 21:21:13 +00:00
namespace Switch_Toolbox.Library.NEW
Some more fixes. Revert the GX2 one more time since swizzling is a bit bugged, but add a more up to date code as a backup. Fix the swizzle pattern settings
2019-04-17 18:59:08 +00:00
{
//Todo fix swizzle issues with this one
public class GX2
{
public const uint SwizzleMask = 0xFF00FF;
//Some enums and parts from https://github.com/jam1garner/Smash-Forge/blob/master/Smash%20Forge/Filetypes/Textures/GTX.cs
public class GX2Surface
{
public uint dim;
public uint width;
public uint height;
public uint depth;
public uint numMips;
public uint firstSlice;
public uint numSlices;
public uint format;
public uint aa;
public uint use;
public int resourceFlags;
public uint imageSize;
public uint imagePtr;
public int MemPtr;
public uint mipSize;
public uint mipPtr;
public uint tileMode;
public uint swizzle;
public uint mip_swizzle; //Used for botw Tex2
public uint alignment;
public uint pitch;
public uint bpp;
public uint imageCount;
public uint firstMip;
public uint numArray;
public byte[] data;
public byte[] mipData;
public uint[] mipOffset;
public byte[] compSel;
public uint[] texRegs;
};
public static uint expPitch = 0;
public static uint expHeight = 0;
public static uint expNumSlices = 0;
public class surfaceIn
{
public uint size = 0;
public uint tileMode = 0;
public uint format = 0;
public uint bpp = 0;
public uint numSamples = 0;
public uint width = 0;
public uint height = 0;
public uint numSlices = 0;
public uint slice = 0;
public uint mipLevel = 0;
public Flags flags = new Flags();
public uint numFrags = 0;
public uint tileType = 0;
public TileInfo pTileInfo = new TileInfo();
public int tileIndex = 0;
}
public class surfaceOut
{
public uint size = 0;
public uint pitch = 0;
public uint height = 0;
public uint depth = 0;
public long surfSize = 0;
public uint tileMode = 0;
public uint baseAlign = 0;
public uint pitchAlign = 0;
public uint heightAlign = 0;
public uint depthAlign = 0;
public uint bpp = 0;
public uint pixelPitch = 0;
public uint pixelHeight = 0;
public uint pixelBits = 0;
public uint sliceSize = 0;
public uint pitchTileMax = 0;
public uint heightTileMax = 0;
public uint sliceTileMax = 0;
public uint tileType = 0;
public TileInfo pTileInfo = new TileInfo();
public int tileIndex = 0;
}
public class Flags
{
public uint value = 0;
}
public class TileInfo
{
public int banks = 0;
public int bankWidth = 0;
public int bankHeight = 0;
public int macroAspectRatio = 0;
public int tileSplitBytes = 0;
public int pipeConfig = 0;
}
static surfaceIn pIn = new surfaceIn();
static surfaceOut pOut = new surfaceOut();
public enum GX2SurfaceDimension
{
DIM_1D = 0x0,
DIM_2D = 0x1,
DIM_3D = 0x2,
DIM_CUBE = 0x3,
DIM_1D_ARRAY = 0x4,
DIM_2D_ARRAY = 0x5,
DIM_2D_MSAA = 0x6,
DIM_2D_MSAA_ARRAY = 0x7,
DIM_FIRST = 0x0,
DIM_LAST = 0x7,
};
public enum GX2SurfaceFormat
{
INVALID = 0x0,
TC_R8_UNORM = 0x1,
TC_R8_UINT = 0x101,
TC_R8_SNORM = 0x201,
TC_R8_SINT = 0x301,
T_R4_G4_UNORM = 0x2,
TCD_R16_UNORM = 0x5,
TC_R16_UINT = 0x105,
TC_R16_SNORM = 0x205,
TC_R16_SINT = 0x305,
TC_R16_FLOAT = 0x806,
TC_R8_G8_UNORM = 0x7,
TC_R8_G8_UINT = 0x107,
TC_R8_G8_SNORM = 0x207,
TC_R8_G8_SINT = 0x307,
TCS_R5_G6_B5_UNORM = 0x8,
TC_R5_G5_B5_A1_UNORM = 0xA,
TC_R4_G4_B4_A4_UNORM = 0xB,
TC_A1_B5_G5_R5_UNORM = 0xC,
TC_R32_UINT = 0x10D,
TC_R32_SINT = 0x30D,
TCD_R32_FLOAT = 0x80E,
TC_R16_G16_UNORM = 0xF,
TC_R16_G16_UINT = 0x10F,
TC_R16_G16_SNORM = 0x20F,
TC_R16_G16_SINT = 0x30F,
TC_R16_G16_FLOAT = 0x810,
D_D24_S8_UNORM = 0x11,
T_R24_UNORM_X8 = 0x11,
T_X24_G8_UINT = 0x111,
D_D24_S8_FLOAT = 0x811,
TC_R11_G11_B10_FLOAT = 0x816,
TCS_R10_G10_B10_A2_UNORM = 0x19,
TC_R10_G10_B10_A2_UINT = 0x119,
T_R10_G10_B10_A2_SNORM = 0x219,
TC_R10_G10_B10_A2_SNORM = 0x219,
TC_R10_G10_B10_A2_SINT = 0x319,
TCS_R8_G8_B8_A8_UNORM = 0x1A,
TC_R8_G8_B8_A8_UINT = 0x11A,
TC_R8_G8_B8_A8_SNORM = 0x21A,
TC_R8_G8_B8_A8_SINT = 0x31A,
TCS_R8_G8_B8_A8_SRGB = 0x41A,
TCS_A2_B10_G10_R10_UNORM = 0x1B,
TC_A2_B10_G10_R10_UINT = 0x11B,
D_D32_FLOAT_S8_UINT_X24 = 0x81C,
T_R32_FLOAT_X8_X24 = 0x81C,
T_X32_G8_UINT_X24 = 0x11C,
TC_R32_G32_UINT = 0x11D,
TC_R32_G32_SINT = 0x31D,
TC_R32_G32_FLOAT = 0x81E,
TC_R16_G16_B16_A16_UNORM = 0x1F,
TC_R16_G16_B16_A16_UINT = 0x11F,
TC_R16_G16_B16_A16_SNORM = 0x21F,
TC_R16_G16_B16_A16_SINT = 0x31F,
TC_R16_G16_B16_A16_FLOAT = 0x820,
TC_R32_G32_B32_A32_UINT = 0x122,
TC_R32_G32_B32_A32_SINT = 0x322,
TC_R32_G32_B32_A32_FLOAT = 0x823,
T_BC1_UNORM = 0x31,
T_BC1_SRGB = 0x431,
T_BC2_UNORM = 0x32,
T_BC2_SRGB = 0x432,
T_BC3_UNORM = 0x33,
T_BC3_SRGB = 0x433,
T_BC4_UNORM = 0x34,
T_BC4_SNORM = 0x234,
T_BC5_UNORM = 0x35,
T_BC5_SNORM = 0x235,
T_NV12_UNORM = 0x81,
FIRST = 0x1,
LAST = 0x83F,
};
public enum GX2AAMode
{
GX2_AA_MODE_1X = 0x0,
GX2_AA_MODE_2X = 0x1,
GX2_AA_MODE_4X = 0x2,
GX2_AA_MODE_8X = 0x3,
GX2_AA_MODE_FIRST = 0x0,
GX2_AA_MODE_LAST = 0x3,
};
public enum GX2SurfaceUse : uint
{
USE_TEXTURE = 0x1,
USE_COLOR_BUFFER = 0x2,
USE_DEPTH_BUFFER = 0x4,
USE_SCAN_BUFFER = 0x8,
USE_FTV = 0x80000000,
USE_COLOR_BUFFER_TEXTURE = 0x3,
USE_DEPTH_BUFFER_TEXTURE = 0x5,
USE_COLOR_BUFFER_FTV = 0x80000002,
USE_COLOR_BUFFER_TEXTURE_FTV = 0x80000003,
USE_FIRST = 0x1,
USE_LAST = 0x8,
};
public enum GX2RResourceFlags
{
GX2R_RESOURCE_FLAGS_NONE = 0x0,
GX2R_BIND_NONE = 0x0,
GX2R_BIND_TEXTURE = 0x1,
GX2R_BIND_COLOR_BUFFER = 0x2,
GX2R_BIND_DEPTH_BUFFER = 0x4,
GX2R_BIND_SCAN_BUFFER = 0x8,
GX2R_BIND_VERTEX_BUFFER = 0x10,
GX2R_BIND_INDEX_BUFFER = 0x20,
GX2R_BIND_UNIFORM_BLOCK = 0x40,
GX2R_BIND_SHADER_PROGRAM = 0x80,
GX2R_BIND_STREAM_OUTPUT = 0x100,
GX2R_BIND_DISPLAY_LIST = 0x200,
GX2R_BIND_GS_RING = 0x400,
GX2R_USAGE_NONE = 0x0,
GX2R_USAGE_CPU_READ = 0x800,
GX2R_USAGE_CPU_WRITE = 0x1000,
GX2R_USAGE_GPU_READ = 0x2000,
GX2R_USAGE_GPU_WRITE = 0x4000,
GX2R_USAGE_DMA_READ = 0x8000,
GX2R_USAGE_DMA_WRITE = 0x10000,
GX2R_USAGE_FORCE_MEM1 = 0x20000,
GX2R_USAGE_FORCE_MEM2 = 0x40000,
GX2R_USAGE_MEM_DEFAULT = 0x0,
GX2R_USAGE_CPU_READWRITE = 0x1800,
GX2R_USAGE_GPU_READWRITE = 0x6000,
GX2R_USAGE_NON_CPU_WRITE = 0x14000,
GX2R_OPTION_NONE = 0x0,
GX2R_OPTION_IGNORE_IN_USE = 0x80000,
GX2R_OPTION_FIRST = 0x80000,
GX2R_OPTION_NO_CPU_INVALIDATE = 0x100000,
GX2R_OPTION_NO_GPU_INVALIDATE = 0x200000,
GX2R_OPTION_LOCK_READONLY = 0x400000,
GX2R_OPTION_NO_TOUCH_DESTROY = 0x800000,
GX2R_OPTION_LAST = 0x800000,
GX2R_OPTION_NO_INVALIDATE = 0x300000,
GX2R_OPTION_MASK = 0xF80000,
GX2R_RESOURCE_FLAG_RESERVED2 = 0x10000000,
GX2R_RESOURCE_FLAG_RESERVED1 = 0x20000000,
GX2R_RESOURCE_FLAG_RESERVED0 = 0x40000000,
};
public enum GX2TileMode
{
MODE_DEFAULT = 0x0,
MODE_LINEAR_SPECIAL = 0x10,
MODE_LINEAR_ALIGNED = 0x1,
MODE_1D_TILED_THIN1 = 0x2,
MODE_1D_TILED_THICK = 0x3,
MODE_2D_TILED_THIN1 = 0x4,
MODE_2D_TILED_THIN2 = 0x5,
MODE_2D_TILED_THIN4 = 0x6,
MODE_2D_TILED_THICK = 0x7,
MODE_2B_TILED_THIN1 = 0x8,
MODE_2B_TILED_THIN2 = 0x9,
MODE_2B_TILED_THIN4 = 0xA,
MODE_2B_TILED_THICK = 0xB,
MODE_3D_TILED_THIN1 = 0xC,
MODE_3D_TILED_THICK = 0xD,
MODE_3B_TILED_THIN1 = 0xE,
MODE_3B_TILED_THICK = 0xF,
MODE_LAST = 0x20,
};
public enum AddrTileMode
{
ADDR_TM_LINEAR_GENERAL = 0x0,
ADDR_TM_LINEAR_ALIGNED = 0x1,
ADDR_TM_1D_TILED_THIN1 = 0x2,
ADDR_TM_1D_TILED_THICK = 0x3,
ADDR_TM_2D_TILED_THIN1 = 0x4,
ADDR_TM_2D_TILED_THIN2 = 0x5,
ADDR_TM_2D_TILED_THIN4 = 0x6,
ADDR_TM_2D_TILED_THICK = 0x7,
ADDR_TM_2B_TILED_THIN1 = 0x8,
ADDR_TM_2B_TILED_THIN2 = 0x9,
ADDR_TM_2B_TILED_THIN4 = 0x0A,
ADDR_TM_2B_TILED_THICK = 0x0B,
ADDR_TM_3D_TILED_THIN1 = 0x0C,
ADDR_TM_3D_TILED_THICK = 0x0D,
ADDR_TM_3B_TILED_THIN1 = 0x0E,
ADDR_TM_3B_TILED_THICK = 0x0F,
ADDR_TM_2D_TILED_XTHICK = 0x10,
ADDR_TM_3D_TILED_XTHICK = 0x11,
ADDR_TM_POWER_SAVE = 0x12,
ADDR_TM_COUNT = 0x13,
}
public enum AddrTileType
{
ADDR_DISPLAYABLE = 0,
ADDR_NON_DISPLAYABLE = 1,
ADDR_DEPTH_SAMPLE_ORDER = 2,
ADDR_THICK_TILING = 3,
}
public enum AddrPipeCfg
{
ADDR_PIPECFG_INVALID = 0x0,
ADDR_PIPECFG_P2 = 0x1,
ADDR_PIPECFG_P4_8x16 = 0x5,
ADDR_PIPECFG_P4_16x16 = 0x6,
ADDR_PIPECFG_P4_16x32 = 0x7,
ADDR_PIPECFG_P4_32x32 = 0x8,
ADDR_PIPECFG_P8_16x16_8x16 = 0x9,
ADDR_PIPECFG_P8_16x32_8x16 = 0xA,
ADDR_PIPECFG_P8_32x32_8x16 = 0xB,
ADDR_PIPECFG_P8_16x32_16x16 = 0xC,
ADDR_PIPECFG_P8_32x32_16x16 = 0xD,
ADDR_PIPECFG_P8_32x32_16x32 = 0xE,
ADDR_PIPECFG_P8_32x64_32x32 = 0xF,
ADDR_PIPECFG_MAX = 0x10,
}
public enum AddrFormat
{
ADDR_FMT_INVALID = 0x0,
ADDR_FMT_8 = 0x1,
ADDR_FMT_4_4 = 0x2,
ADDR_FMT_3_3_2 = 0x3,
ADDR_FMT_RESERVED_4 = 0x4,
ADDR_FMT_16 = 0x5,
ADDR_FMT_16_FLOAT = 0x6,
ADDR_FMT_8_8 = 0x7,
ADDR_FMT_5_6_5 = 0x8,
ADDR_FMT_6_5_5 = 0x9,
ADDR_FMT_1_5_5_5 = 0xA,
ADDR_FMT_4_4_4_4 = 0xB,
ADDR_FMT_5_5_5_1 = 0xC,
ADDR_FMT_32 = 0xD,
ADDR_FMT_32_FLOAT = 0xE,
ADDR_FMT_16_16 = 0xF,
ADDR_FMT_16_16_FLOAT = 0x10,
ADDR_FMT_8_24 = 0x11,
ADDR_FMT_8_24_FLOAT = 0x12,
ADDR_FMT_24_8 = 0x13,
ADDR_FMT_24_8_FLOAT = 0x14,
ADDR_FMT_10_11_11 = 0x15,
ADDR_FMT_10_11_11_FLOAT = 0x16,
ADDR_FMT_11_11_10 = 0x17,
ADDR_FMT_11_11_10_FLOAT = 0x18,
ADDR_FMT_2_10_10_10 = 0x19,
ADDR_FMT_8_8_8_8 = 0x1A,
ADDR_FMT_10_10_10_2 = 0x1B,
ADDR_FMT_X24_8_32_FLOAT = 0x1C,
ADDR_FMT_32_32 = 0x1D,
ADDR_FMT_32_32_FLOAT = 0x1E,
ADDR_FMT_16_16_16_16 = 0x1F,
ADDR_FMT_16_16_16_16_FLOAT = 0x20,
ADDR_FMT_RESERVED_33 = 0x21,
ADDR_FMT_32_32_32_32 = 0x22,
ADDR_FMT_32_32_32_32_FLOAT = 0x23,
ADDR_FMT_RESERVED_36 = 0x24,
ADDR_FMT_1 = 0x25,
ADDR_FMT_1_REVERSED = 0x26,
ADDR_FMT_GB_GR = 0x27,
ADDR_FMT_BG_RG = 0x28,
ADDR_FMT_32_AS_8 = 0x29,
ADDR_FMT_32_AS_8_8 = 0x2A,
ADDR_FMT_5_9_9_9_SHAREDEXP = 0x2B,
ADDR_FMT_8_8_8 = 0x2C,
ADDR_FMT_16_16_16 = 0x2D,
ADDR_FMT_16_16_16_FLOAT = 0x2E,
ADDR_FMT_32_32_32 = 0x2F,
ADDR_FMT_32_32_32_FLOAT = 0x30,
ADDR_FMT_BC1 = 0x31,
ADDR_FMT_BC2 = 0x32,
ADDR_FMT_BC3 = 0x33,
ADDR_FMT_BC4 = 0x34,
ADDR_FMT_BC5 = 0x35,
ADDR_FMT_BC6 = 0x36,
ADDR_FMT_BC7 = 0x37,
ADDR_FMT_32_AS_32_32_32_32 = 0x38,
ADDR_FMT_APC3 = 0x39,
ADDR_FMT_APC4 = 0x3A,
ADDR_FMT_APC5 = 0x3B,
ADDR_FMT_APC6 = 0x3C,
ADDR_FMT_APC7 = 0x3D,
ADDR_FMT_CTX1 = 0x3E,
ADDR_FMT_RESERVED_63 = 0x3F,
};
public static void Debug(surfaceOut surf)
{
if (surf == null)
surf = getSurfaceInfo((GX2SurfaceFormat)0x33, 701, 77, 1, 0, 13, 1, 0);
Console.WriteLine($"size {surf.size}");
Console.WriteLine($"pitch {surf.pitch}");
Console.WriteLine($"height {surf.height}");
Console.WriteLine($"depth {surf.depth}");
Console.WriteLine($"surfSize {surf.surfSize}");
Console.WriteLine($"tileMode {surf.tileMode}");
Console.WriteLine($"baseAlign {surf.baseAlign}");
Console.WriteLine($"pitchAlign {surf.pitchAlign}");
Console.WriteLine($"heightAlign {surf.heightAlign}");
Console.WriteLine($"depthAlign {surf.depthAlign}");
Console.WriteLine($"bpp {surf.bpp}");
Console.WriteLine($"pixelPitch {surf.pixelPitch}");
Console.WriteLine($"pixelHeight {surf.pixelHeight}");
Console.WriteLine($"pixelBits {surf.pixelBits}");
Console.WriteLine($"sliceSize {surf.sliceSize}");
Console.WriteLine($"pitchTileMax {surf.pitchTileMax}");
Console.WriteLine($"heightTileMax {surf.heightTileMax}");
Console.WriteLine($"sliceTileMax {surf.sliceTileMax}");
Console.WriteLine($"tileType {surf.tileType}");
Console.WriteLine($"tileIndex {surf.tileIndex}");
}
static bool DebugSurface = false;
public static GX2Surface CreateGx2Texture(byte[] imageData, string Name, uint TileMode, uint AAMode,
Simpify BNTX deswizzling and start to do XTX saving.
2019-04-30 19:25:42 +00:00
uint Width, uint Height, uint Depth, uint Format, uint swizzle, uint SurfaceDim, uint MipCount)
Some more fixes. Revert the GX2 one more time since swizzling is a bit bugged, but add a more up to date code as a backup. Fix the swizzle pattern settings
2019-04-17 18:59:08 +00:00
{
var surfOut = getSurfaceInfo((GX2SurfaceFormat)Format, Width, Height, 1, 1, TileMode, 0, 0);
uint imageSize = (uint)surfOut.surfSize;
uint alignment = surfOut.baseAlign;
uint pitch = surfOut.pitch;
uint mipSize = 0;
uint dataSize = (uint)imageData.Length;
uint bpp = GX2.surfaceGetBitsPerPixel((uint)Format) >> 3;
int DepthLevel = 1;
if (dataSize <= 0)
throw new Exception($"Image is empty!!");
uint s = (swizzle << 8);
uint blkWidth, blkHeight;
if (GX2.IsFormatBCN((GX2SurfaceFormat)Format))
{
blkWidth = 4;
blkHeight = 4;
}
else
{
blkWidth = 1;
blkHeight = 1;
}
if (TileMode == 0)
TileMode = GX2.getDefaultGX2TileMode((uint)SurfaceDim, Width, Height, 1, (uint)Format, 0, 1);
Starto to add material presets. Add option to add empty meshes
2019-05-30 19:28:43 +00:00
uint tilingDepth = surfOut.depth;
if (TileMode == 3)
tilingDepth /= 4;
if (tilingDepth != 1)
throw new Exception($"Unsupported Depth {surfOut.depth}!");
Some more fixes. Revert the GX2 one more time since swizzling is a bit bugged, but add a more up to date code as a backup. Fix the swizzle pattern settings
2019-04-17 18:59:08 +00:00
int tiling1dLevel = 0;
bool tiling1dLevelSet = false;
List<uint> mipOffsets = new List<uint>();
List<byte[]> Swizzled = new List<byte[]>();
for (int mipLevel = 0; mipLevel < MipCount; mipLevel++)
{
uint swizzleValue = s;
var result = TextureHelper.GetCurrentMipSize(Width, Height, blkWidth, blkHeight, bpp, mipLevel);
uint offset = result.Item1;
uint size = result.Item2;
byte[] data_ = new byte[size];
Array.Copy(imageData, offset, data_, 0, size);
uint width_ = Math.Max(1, Width >> mipLevel);
uint height_ = Math.Max(1, Height >> mipLevel);
if (mipLevel != 0)
{
surfOut = GX2.getSurfaceInfo((GX2SurfaceFormat)Format, Width, Height, 1, 1, TileMode, 0, mipLevel);
if (mipLevel == 1)
mipOffsets.Add(imageSize);
else
mipOffsets.Add(mipSize);
}
data_ = Utils.CombineByteArray(data_, new byte[surfOut.surfSize - size]);
byte[] dataAlignBytes = new byte[RoundUp(mipSize, surfOut.baseAlign) - mipSize];
if (mipLevel != 0)
mipSize += (uint)(surfOut.surfSize + dataAlignBytes.Length);
byte[] SwizzledData = GX2.swizzle(width_, height_, surfOut.depth, surfOut.height, (uint)Format, 0, 1, surfOut.tileMode, swizzleValue,
surfOut.pitch, surfOut.bpp, 0, 0, data_);
Swizzled.Add(dataAlignBytes.Concat(SwizzledData).ToArray());
if (surfOut.tileMode == 1 || surfOut.tileMode == 2 ||
surfOut.tileMode == 3 || surfOut.tileMode == 16)
{
tiling1dLevelSet = true;
}
if (!tiling1dLevelSet)
tiling1dLevel += 1;
}
if (tiling1dLevelSet)
s |= (uint)(tiling1dLevel << 16);
else
s |= (uint)(13 << 16);
GX2.GX2Surface surf = new GX2.GX2Surface();
surf.depth = Depth;
surf.width = Width;
surf.height = Height;
surf.use = 1;
surf.dim = (uint)SurfaceDim;
surf.tileMode = TileMode;
surf.swizzle = s;
surf.resourceFlags = 0;
surf.pitch = pitch;
surf.bpp = bpp;
surf.format = (uint)Format;
surf.numMips = MipCount;
surf.aa = AAMode;
surf.mipOffset = mipOffsets.ToArray();
surf.numMips = (uint)Swizzled.Count;
surf.alignment = alignment;
surf.mipSize = mipSize;
surf.imageSize = imageSize;
surf.data = Swizzled[0];
List<byte[]> mips = new List<byte[]>();
for (int mipLevel = 1; mipLevel < Swizzled.Count; mipLevel++)
{
mips.Add(Swizzled[mipLevel]);
}
surf.mipData = Utils.CombineByteArray(mips.ToArray());
mips.Clear();
Console.WriteLine("");
Console.WriteLine("// ----- GX2Surface Swizzled Info ----- ");
Console.WriteLine(" dim = 1");
Console.WriteLine(" width = " + surf.width);
Console.WriteLine(" height = " + surf.height);
Console.WriteLine(" depth = 1");
Console.WriteLine(" numMips = " + surf.numMips);
Console.WriteLine(" format = " + surf.format);
Console.WriteLine(" aa = 0");
Console.WriteLine(" use = 1");
Console.WriteLine(" imageSize = " + surf.imageSize);
Console.WriteLine(" mipSize = " + surf.mipSize);
Console.WriteLine(" tileMode = " + surf.tileMode);
Console.WriteLine(" swizzle = " + surf.swizzle);
Console.WriteLine(" alignment = " + surf.alignment);
Console.WriteLine(" pitch = " + surf.pitch);
Console.WriteLine(" data = " + surf.data.Length);
Console.WriteLine(" mipData = " + surf.mipData.Length);
Console.WriteLine("");
Console.WriteLine(" GX2 Component Selector:");
Console.WriteLine("");
Console.WriteLine(" bits per pixel = " + (surf.bpp << 3));
Console.WriteLine(" bytes per pixel = " + surf.bpp);
Console.WriteLine(" realSize = " + imageData.Length);
return surf;
}
private static int RoundUp(int X, int Y)
{
return ((X - 1) | (Y - 1)) + 1;
}
private static uint RoundUp(uint X, uint Y)
{
return ((X - 1) | (Y - 1)) + 1;
}
public static List<List<byte[]>> Decode(GX2Surface tex, string DebugTextureName = "")
{
if (tex.data == null || tex.data.Length <= 0)
throw new Exception("Invalid GX2 surface data. Make sure to not open Tex2 files if this is one. Those will load automatically next to Tex1!");
Console.WriteLine("DECODING TEX " + DebugTextureName);
var surfdEBUG = getSurfaceInfo((GX2SurfaceFormat)tex.format, tex.width, tex.height, tex.depth, (uint)tex.dim, (uint)tex.tileMode, (uint)tex.aa, 0);
Debug(surfdEBUG);
/* Console.WriteLine("");
Console.WriteLine("// ----- GX2Surface Decode Info ----- ");
Console.WriteLine(" dim = " + tex.dim);
Console.WriteLine(" width = " + tex.width);
Console.WriteLine(" height = " + tex.height);
Console.WriteLine(" depth = " + tex.depth);
Console.WriteLine(" numMips = " + tex.numMips);
Console.WriteLine(" format = " + (GX2SurfaceFormat)tex.format);
Console.WriteLine(" aa = " + tex.aa);
Console.WriteLine(" use = " + tex.use);
Console.WriteLine(" imageSize = " + tex.imageSize);
Console.WriteLine(" mipSize = " + tex.mipSize);
Console.WriteLine(" tileMode = " + (GX2TileMode)tex.tileMode);
Console.WriteLine(" swizzle = " + tex.swizzle);
Console.WriteLine(" alignment = " + tex.alignment);
Console.WriteLine(" pitch = " + tex.pitch);
Console.WriteLine(" bits per pixel = " + (tex.bpp << 3));
Console.WriteLine(" bytes per pixel = " + tex.bpp);
Console.WriteLine(" data size = " + tex.data.Length);
Console.WriteLine(" realSize = " + tex.imageSize);*/
uint blkWidth, blkHeight;
if (IsFormatBCN((GX2SurfaceFormat)tex.format))
{
blkWidth = 4;
blkHeight = 4;
}
else
{
blkWidth = 1;
blkHeight = 1;
}
byte[] data = tex.data;
var surfInfo = getSurfaceInfo((GX2SurfaceFormat)tex.format, tex.width, tex.height, tex.depth, (uint)tex.dim, (uint)tex.tileMode, (uint)tex.aa, 0);
uint bpp = DIV_ROUND_UP(surfInfo.bpp, 8);
if (surfInfo.depth != 1)
{
// System.Windows.Forms.MessageBox.Show($"Unsupported Depth {surfInfo.depth} for texture {DebugTextureName}!");
// return new List<List<byte[]>>();
}
if (tex.numArray == 0)
tex.numArray = 1;
uint mipCount = tex.numMips;
if (tex.mipData == null || tex.mipData.Length <= 0)
mipCount = 1;
int ArrayImageize = data.Length / (int)tex.depth;
int ArrayMipImageize = 0;
if (tex.mipData != null)
ArrayMipImageize = tex.mipData.Length / (int)tex.depth;
int dataOffset = 0;
int mipDataOffset = 0;
int TotalImageSize = tex.data.Length;
List<List<byte[]>> result = new List<List<byte[]>>();
for (int arrayLevel = 0; arrayLevel < tex.depth; arrayLevel++)
{
List<byte[]> mips = new List<byte[]>();
for (int mipLevel = 0; mipLevel < mipCount; mipLevel++)
{
uint swizzle = tex.swizzle;
uint width_ = (uint)Math.Max(1, tex.width >> mipLevel);
uint height_ = (uint)Math.Max(1, tex.height >> mipLevel);
uint size = DIV_ROUND_UP(width_, blkWidth) * DIV_ROUND_UP(height_, blkHeight) * bpp;
uint mipOffset;
if (mipLevel != 0)
{
if (tex.mip_swizzle != 0)
swizzle = tex.mip_swizzle;
mipOffset = (tex.mipOffset[mipLevel - 1]);
if (mipLevel == 1)
mipOffset -= (uint)surfInfo.surfSize;
surfInfo = getSurfaceInfo((GX2SurfaceFormat)tex.format, tex.width, tex.height, tex.depth, (uint)tex.dim, (uint)tex.tileMode, (uint)tex.aa, mipLevel);
data = new byte[surfInfo.surfSize];
Array.Copy(tex.mipData, (uint)mipOffset, data, 0, surfInfo.surfSize);
}
else
Array.Copy(tex.data, (uint)dataOffset, data, 0, size);
byte[] deswizzled = deswizzle(width_, height_, surfInfo.depth, surfInfo.height, (uint)tex.format, 0, tex.use,
surfInfo.tileMode, (uint)swizzle, surfInfo.pitch, surfInfo.bpp, (uint)arrayLevel, 0, data);
//Create a copy and use that to remove uneeded data
byte[] result_ = new byte[size];
Array.Copy(deswizzled, 0, result_, 0, size);
mips.Add(result_);
}
result.Add(mips);
Load the x64 folder for direct x tex by default as it causes issues without.
2019-05-31 21:12:23 +00:00
// dataOffset += ArrayImageize;
// mipDataOffset += ArrayMipImageize;
Some more fixes. Revert the GX2 one more time since swizzling is a bit bugged, but add a more up to date code as a backup. Fix the swizzle pattern settings
2019-04-17 18:59:08 +00:00
}
return result;
}
private static byte[] SubArray(byte[] data, int offset, int length)
{
return data.Skip(offset).Take(length).ToArray();
}
private static uint DIV_ROUND_UP(uint n, uint d)
{
return (n + d - 1) / d;
}
/*---------------------------------------
*
* Code ported from AboodXD's GTX Extractor:
* https://github.com/aboood40091/GTX-Extractor/blob/cf1a15c41630745d9a0d370bafe5760c1e5f8cbe/addrlib/addrlib_cy.pyx
*
*---------------------------------------*/
public static bool IsFormatBCN(GX2SurfaceFormat Format)
{
switch (Format)
{
case GX2SurfaceFormat.T_BC1_UNORM:
case GX2SurfaceFormat.T_BC1_SRGB:
case GX2SurfaceFormat.T_BC2_UNORM:
case GX2SurfaceFormat.T_BC2_SRGB:
case GX2SurfaceFormat.T_BC3_UNORM:
case GX2SurfaceFormat.T_BC3_SRGB:
case GX2SurfaceFormat.T_BC4_UNORM:
case GX2SurfaceFormat.T_BC4_SNORM:
case GX2SurfaceFormat.T_BC5_SNORM:
case GX2SurfaceFormat.T_BC5_UNORM:
return true;
default:
return false;
}
}
public static byte[] deswizzle(uint width, uint height, uint depth, uint height_, uint format_, uint aa, uint use, uint tileMode, uint swizzle_,
uint pitch, uint bpp, uint slice, uint sample, byte[] data)
{
return swizzleSurf(width, height, depth, format_, aa, use, tileMode, swizzle_, pitch, bpp, slice, sample, data, 0);
}
public static byte[] swizzle(uint width, uint height, uint depth, uint height_, uint format_, uint aa, uint use, uint tileMode, uint swizzle_,
uint pitch, uint bpp, uint slice, uint sample, byte[] data)
{
return swizzleSurf(width, height, depth, format_, aa, use, tileMode, swizzle_, pitch, bpp, slice, sample, data, 1);
}
private static byte[] swizzleSurf(uint width, uint height, uint depth, uint format, uint aa, uint use, uint tileMode, uint swizzle_,
uint pitch, uint bitsPerPixel, uint slice, uint sample, byte[] data, int swizzle)
{
uint bytesPerPixel = bitsPerPixel / 8;
byte[] result = new byte[data.Length];
uint pipeSwizzle, bankSwizzle, pos_;
ulong pos;
if (IsFormatBCN((GX2SurfaceFormat)format))
{
width = (width + 3) / 4;
height = (height + 3) / 4;
}
pipeSwizzle = (swizzle_ >> 8) & 1;
bankSwizzle = (swizzle_ >> 9) & 3;
if (depth > 1)
{
bankSwizzle = (uint)(slice % 4);
}
tileMode = GX2TileModeToAddrTileMode(tileMode);
bool IsDepth = (use & 4) != 0;
uint numSamples = (uint)(1 << (int)aa);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
if (tileMode == 0 || tileMode == 1)
{
pos = computeSurfaceAddrFromCoordLinear((uint)x, (uint)y, slice, sample, bytesPerPixel, pitch, height, depth);
}
else if (tileMode == 2 || tileMode == 3)
{
pos = computeSurfaceAddrFromCoordMicroTiled((uint)x, (uint)y, slice, bitsPerPixel, pitch, height, (AddrTileMode)tileMode, IsDepth);
}
else
{
pos = computeSurfaceAddrFromCoordMacroTiled((uint)x, (uint)y, slice, sample, bitsPerPixel, pitch, height, numSamples, (AddrTileMode)tileMode, IsDepth, pipeSwizzle, bankSwizzle);
}
pos_ = (uint)(y * width + x) * bytesPerPixel;
if (pos_ + bytesPerPixel <= data.Length && pos + bytesPerPixel <= (ulong)data.Length)
{
if (swizzle == 0)
{
for (int n = 0; n < bytesPerPixel; n++)
result[pos_ + n] = data[(uint)pos + n];
}
else
{
for (int n = 0; n < bytesPerPixel; n++)
result[(uint)pos + n] = data[pos_ + n];
}
}
}
}
return result;
}
private static byte[] formatHwInfo = {
0x00, 0x00, 0x00, 0x01, 0x08, 0x03, 0x00, 0x01, 0x08, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x01, 0x10, 0x07, 0x00, 0x00, 0x10, 0x03, 0x00, 0x01, 0x10, 0x03, 0x00, 0x01,
0x10, 0x0B, 0x00, 0x01, 0x10, 0x01, 0x00, 0x01, 0x10, 0x03, 0x00, 0x01, 0x10, 0x03, 0x00, 0x01,
0x10, 0x03, 0x00, 0x01, 0x20, 0x03, 0x00, 0x00, 0x20, 0x07, 0x00, 0x00, 0x20, 0x03, 0x00, 0x00,
0x20, 0x03, 0x00, 0x01, 0x20, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
0x00, 0x00, 0x00, 0x01, 0x20, 0x0B, 0x00, 0x01, 0x20, 0x0B, 0x00, 0x01, 0x20, 0x0B, 0x00, 0x01,
0x40, 0x05, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00, 0x40, 0x03, 0x00, 0x00,
0x40, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00, 0x80, 0x03, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x10, 0x01, 0x00, 0x00,
0x10, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00, 0x20, 0x01, 0x00, 0x00,
0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x60, 0x01, 0x00, 0x00,
0x60, 0x01, 0x00, 0x00, 0x40, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x01,
0x40, 0x01, 0x00, 0x01, 0x80, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
private static byte[] formatExInfo = {
0x00, 0x01, 0x01, 0x03, 0x08, 0x01, 0x01, 0x03, 0x08, 0x01, 0x01, 0x03, 0x08, 0x01, 0x01, 0x03,
0x00, 0x01, 0x01, 0x03, 0x10, 0x01, 0x01, 0x03, 0x10, 0x01, 0x01, 0x03, 0x10, 0x01, 0x01, 0x03,
0x10, 0x01, 0x01, 0x03, 0x10, 0x01, 0x01, 0x03, 0x10, 0x01, 0x01, 0x03, 0x10, 0x01, 0x01, 0x03,
0x10, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03,
0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03,
0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03,
0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03,
0x40, 0x01, 0x01, 0x03, 0x40, 0x01, 0x01, 0x03, 0x40, 0x01, 0x01, 0x03, 0x40, 0x01, 0x01, 0x03,
0x40, 0x01, 0x01, 0x03, 0x00, 0x01, 0x01, 0x03, 0x80, 0x01, 0x01, 0x03, 0x80, 0x01, 0x01, 0x03,
0x00, 0x01, 0x01, 0x03, 0x01, 0x08, 0x01, 0x05, 0x01, 0x08, 0x01, 0x06, 0x10, 0x01, 0x01, 0x07,
0x10, 0x01, 0x01, 0x08, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03, 0x20, 0x01, 0x01, 0x03,
0x18, 0x03, 0x01, 0x04, 0x30, 0x03, 0x01, 0x04, 0x30, 0x03, 0x01, 0x04, 0x60, 0x03, 0x01, 0x04,
0x60, 0x03, 0x01, 0x04, 0x40, 0x04, 0x04, 0x09, 0x80, 0x04, 0x04, 0x0A, 0x80, 0x04, 0x04, 0x0B,
0x40, 0x04, 0x04, 0x0C, 0x40, 0x04, 0x04, 0x0D, 0x40, 0x04, 0x04, 0x0D, 0x40, 0x04, 0x04, 0x0D,
0x00, 0x01, 0x01, 0x03, 0x00, 0x01, 0x01, 0x03, 0x00, 0x01, 0x01, 0x03, 0x00, 0x01, 0x01, 0x03,
0x00, 0x01, 0x01, 0x03, 0x00, 0x01, 0x01, 0x03, 0x40, 0x01, 0x01, 0x03, 0x00, 0x01, 0x01, 0x03,
};
public static uint surfaceGetBitsPerPixel(uint surfaceFormat)
{
return formatHwInfo[(surfaceFormat & 0x3F) * 4];
}
public static uint nextPow2(uint dim)
{
uint newDim = 1;
if (dim < 0x7FFFFFFF)
{
while (newDim < dim)
newDim *= 2;
}
else
newDim = 0x80000000;
return newDim;
}
public static uint getDefaultGX2TileMode(uint dim, uint width, uint height, uint depth, uint format_, uint aa, uint use)
{
uint tileMode = 1;
bool IsDepthBuffer = (use & 4) != 0;
bool isColorBuffer = (use & 2) != 0;
if (dim != 0 || aa != 0 || IsDepthBuffer)
{
if (dim != 2 || isColorBuffer)
tileMode = 4;
else
tileMode = 7;
var surfOut = getSurfaceInfo((GX2SurfaceFormat)format_, width, height, depth, dim, tileMode, aa, 0);
if (width < surfOut.pitchAlign && height < surfOut.heightAlign)
{
if (tileMode == 7)
tileMode = 3;
else
tileMode = 2;
}
}
return tileMode;
}
private static uint GX2TileModeToAddrTileMode(uint tileMode)
{
if (tileMode == 0)
throw new Exception("Use tileMode from getDefaultGX2TileMode().");
if (tileMode == 16)
return 0;
return tileMode;
}
private static uint computeSurfaceThickness(AddrTileMode tileMode)
{
switch (tileMode)
{
case AddrTileMode.ADDR_TM_1D_TILED_THICK:
case AddrTileMode.ADDR_TM_2D_TILED_THICK:
case AddrTileMode.ADDR_TM_2B_TILED_THICK:
case AddrTileMode.ADDR_TM_3D_TILED_THICK:
case AddrTileMode.ADDR_TM_3B_TILED_THICK:
return 4;
case AddrTileMode.ADDR_TM_2D_TILED_XTHICK:
case AddrTileMode.ADDR_TM_3D_TILED_XTHICK:
return 8;
default:
return 1;
}
}
private static uint computePixelIndexWithinMicroTile(uint x, uint y, uint z, uint bpp, AddrTileMode tileMode, bool IsDepth)
{
uint pixelBit0 = 0;
uint pixelBit1 = 0;
uint pixelBit2 = 0;
uint pixelBit3 = 0;
uint pixelBit4 = 0;
uint pixelBit5 = 0;
uint pixelBit6 = 0;
uint pixelBit7 = 0;
uint pixelBit8 = 0;
uint thickness = computeSurfaceThickness(tileMode);
if (IsDepth)
{
pixelBit0 = x & 1;
pixelBit1 = y & 1;
pixelBit2 = (x & 2) >> 1;
pixelBit3 = (y & 2) >> 1;
pixelBit4 = (x & 4) >> 2;
pixelBit5 = (y & 4) >> 2;
}
else
{
switch (bpp)
{
case 8:
pixelBit0 = x & 1;
pixelBit1 = (x & 2) >> 1;
pixelBit2 = (x & 4) >> 2;
pixelBit3 = (y & 2) >> 1;
pixelBit4 = y & 1;
pixelBit5 = (y & 4) >> 2;
break;
case 0x10:
pixelBit0 = x & 1;
pixelBit1 = (x & 2) >> 1;
pixelBit2 = (x & 4) >> 2;
pixelBit3 = y & 1;
pixelBit4 = (y & 2) >> 1;
pixelBit5 = (y & 4) >> 2;
break;
case 0x20:
case 0x60:
pixelBit0 = x & 1;
pixelBit1 = (x & 2) >> 1;
pixelBit2 = y & 1;
pixelBit3 = (x & 4) >> 2;
pixelBit4 = (y & 2) >> 1;
pixelBit5 = (y & 4) >> 2;
break;
case 0x40:
pixelBit0 = x & 1;
pixelBit1 = y & 1;
pixelBit2 = (x & 2) >> 1;
pixelBit3 = (x & 4) >> 2;
pixelBit4 = (y & 2) >> 1;
pixelBit5 = (y & 4) >> 2;
break;
case 0x80:
pixelBit0 = y & 1;
pixelBit1 = x & 1;
pixelBit2 = (x & 2) >> 1;
pixelBit3 = (x & 4) >> 2;
pixelBit4 = (y & 2) >> 1;
pixelBit5 = (y & 4) >> 2;
break;
default:
pixelBit0 = x & 1;
pixelBit1 = (x & 2) >> 1;
pixelBit2 = y & 1;
pixelBit3 = (x & 4) >> 2;
pixelBit4 = (y & 2) >> 1;
pixelBit5 = (y & 4) >> 2;
break;
}
}
if (thickness > 1)
{
pixelBit6 = z & 1;
pixelBit7 = (z & 2) >> 1;
}
if (thickness == 8)
pixelBit8 = (z & 4) >> 2;
return (pixelBit8 << 8) | (pixelBit7 << 7) | (pixelBit6 << 6) | 32 * pixelBit5 | 16 * pixelBit4 | 8 * pixelBit3 | 4 * pixelBit2 | pixelBit0 | 2 * pixelBit1;
}
private static uint computePipeFromCoordWoRotation(uint x, uint y)
{
return ((y >> 3) ^ (x >> 3)) & 1;
}
private static uint computeBankFromCoordWoRotation(uint x, uint y)
{
return ((y >> 5) ^ (x >> 3)) & 1 | 2 * (((y >> 4) ^ (x >> 4)) & 1);
}
private static uint computeSurfaceRotationFromTileMode(AddrTileMode tileMode)
{
switch (tileMode)
{
case AddrTileMode.ADDR_TM_2D_TILED_THIN1:
case AddrTileMode.ADDR_TM_2D_TILED_THIN2:
case AddrTileMode.ADDR_TM_2D_TILED_THIN4:
case AddrTileMode.ADDR_TM_2D_TILED_THICK:
case AddrTileMode.ADDR_TM_2B_TILED_THIN1:
case AddrTileMode.ADDR_TM_2B_TILED_THIN2:
case AddrTileMode.ADDR_TM_2B_TILED_THIN4:
case AddrTileMode.ADDR_TM_2B_TILED_THICK:
return 2;
case AddrTileMode.ADDR_TM_3D_TILED_THIN1:
case AddrTileMode.ADDR_TM_3D_TILED_THICK:
case AddrTileMode.ADDR_TM_3B_TILED_THIN1:
case AddrTileMode.ADDR_TM_3B_TILED_THICK:
return 1;
default:
return 0;
}
}
private static uint isThickMacroTiled(AddrTileMode tileMode)
{
switch (tileMode)
{
case AddrTileMode.ADDR_TM_2D_TILED_THICK:
case AddrTileMode.ADDR_TM_2B_TILED_THICK:
case AddrTileMode.ADDR_TM_3D_TILED_THICK:
case AddrTileMode.ADDR_TM_3B_TILED_THICK:
return 1;
default:
return 0;
}
}
private static uint isBankSwappedTileMode(AddrTileMode tileMode)
{
switch (tileMode)
{
case AddrTileMode.ADDR_TM_2B_TILED_THIN1:
case AddrTileMode.ADDR_TM_2B_TILED_THIN2:
case AddrTileMode.ADDR_TM_2B_TILED_THIN4:
case AddrTileMode.ADDR_TM_2B_TILED_THICK:
case AddrTileMode.ADDR_TM_3B_TILED_THIN1:
case AddrTileMode.ADDR_TM_3B_TILED_THICK:
return 1;
default:
return 0;
}
}
private static uint computeMacroTileAspectRatio(AddrTileMode tileMode)
{
switch (tileMode)
{
case AddrTileMode.ADDR_TM_2D_TILED_THIN2:
case AddrTileMode.ADDR_TM_2B_TILED_THIN2:
return 2;
case AddrTileMode.ADDR_TM_2D_TILED_THIN4:
case AddrTileMode.ADDR_TM_2B_TILED_THIN4:
return 4;
default:
return 1;
}
}
private static uint computeSurfaceBankSwappedWidth(AddrTileMode tileMode, uint bpp, uint numSamples, uint pitch)
{
if (isBankSwappedTileMode(tileMode) == 0)
return 0;
uint bytesPerSample = 8 * bpp;
uint samplesPerTile, slicesPerTile;
if (bytesPerSample != 0)
{
samplesPerTile = 2048 / bytesPerSample;
slicesPerTile = Math.Max(1, numSamples / samplesPerTile);
}
else
slicesPerTile = 1;
if (isThickMacroTiled(tileMode) != 0)
numSamples = 4;
uint bytesPerTileSlice = numSamples * bytesPerSample / slicesPerTile;
uint factor = computeMacroTileAspectRatio(tileMode);
uint swapTiles = Math.Max(1, 128 / bpp);
uint swapWidth = swapTiles * 32;
uint heightBytes = numSamples * factor * bpp * 2 / slicesPerTile;
uint swapMax = 0x4000 / heightBytes;
uint swapMin = 256 / bytesPerTileSlice;
uint bankSwapWidth = Math.Min(swapMax, Math.Max(swapMin, swapWidth));
while (bankSwapWidth >= 2 * pitch)
bankSwapWidth >>= 1;
return bankSwapWidth;
}
private static ulong computeSurfaceAddrFromCoordLinear(uint x, uint y, uint slice, uint sample, uint bpp, uint pitch, uint height, uint numSlices)
{
uint sliceOffset = pitch * height * (slice + sample * numSlices);
return (y * pitch + x + sliceOffset) * bpp;
}
private static ulong computeSurfaceAddrFromCoordMicroTiled(uint x, uint y, uint slice, uint bpp, uint pitch, uint height, AddrTileMode tileMode, bool IsDepth)
{
int microTileThickness = 1;
if (tileMode == AddrTileMode.ADDR_TM_1D_TILED_THICK)
microTileThickness = 4;
uint microTileBytes = (uint)(64 * microTileThickness * bpp + 7) / 8;
uint microTilesPerRow = pitch >> 3;
uint microTileIndexX = x >> 3;
uint microTileIndexY = y >> 3;
uint microTileIndexZ = slice / (uint)microTileThickness;
ulong microTileOffset = microTileBytes * (microTileIndexX + microTileIndexY * microTilesPerRow);
ulong sliceBytes = (ulong)(pitch * height * microTileThickness * bpp + 7) / 8;
ulong sliceOffset = microTileIndexZ * sliceBytes;
uint pixelIndex = computePixelIndexWithinMicroTile(x, y, slice, bpp, tileMode, IsDepth);
ulong pixelOffset = (bpp * pixelIndex) >> 3;
return pixelOffset + microTileOffset + sliceOffset;
}
private static byte[] bankSwapOrder = { 0, 1, 3, 2, 6, 7, 5, 4, 0, 0 };
private static ulong computeSurfaceAddrFromCoordMacroTiled(uint x, uint y, uint slice, uint sample, uint bpp, uint pitch, uint height,
uint numSamples, AddrTileMode tileMode, bool IsDepth, uint pipeSwizzle, uint bankSwizzle)
{
uint microTileThickness = computeSurfaceThickness(tileMode);
uint microTileBits = numSamples * bpp * (microTileThickness * 64);
uint microTileBytes = (microTileBits + 7) / 8;
uint pixelIndex = computePixelIndexWithinMicroTile(x, y, slice, bpp, tileMode, IsDepth);
uint bytesPerSample = microTileBytes / numSamples;
uint sampleOffset = 0;
uint pixelOffset = 0;
uint samplesPerSlice = 0;
uint numSampleSplits = 0;
uint sampleSlice = 0;
if (IsDepth)
{
sampleOffset = bpp * sample;
pixelOffset = numSamples * bpp * pixelIndex;
}
else
{
sampleOffset = sample * (microTileBits / numSamples);
pixelOffset = bpp * pixelIndex;
}
uint elemOffset = pixelOffset + sampleOffset;
if (numSamples <= 1 || microTileBytes <= 2048)
{
samplesPerSlice = numSamples;
numSampleSplits = 1;
sampleSlice = 0;
}
else
{
samplesPerSlice = 2048 / bytesPerSample;
numSampleSplits = numSamples / samplesPerSlice;
numSamples = samplesPerSlice;
uint tileSliceBits = microTileBits / numSampleSplits;
sampleSlice = elemOffset / tileSliceBits;
elemOffset %= tileSliceBits;
}
elemOffset = (elemOffset + 7) / 8;
uint pipe = computePipeFromCoordWoRotation(x, y);
uint bank = computeBankFromCoordWoRotation(x, y);
uint swizzle_ = pipeSwizzle + 2 * bankSwizzle;
uint bankPipe = pipe + 2 * bank;
uint rotation = computeSurfaceRotationFromTileMode(tileMode);
uint sliceIn = slice;
if (isThickMacroTiled(tileMode) != 0)
sliceIn >>= 2;
bankPipe ^= 2 * sampleSlice * 3 ^ (swizzle_ + sliceIn * rotation);
bankPipe %= 8;
pipe = bankPipe % 2;
bank = bankPipe / 2;
uint sliceBytes = (height * pitch * microTileThickness * bpp * numSamples + 7) / 8;
uint sliceOffset = sliceBytes * (sampleSlice + numSampleSplits * slice) / microTileThickness;
uint macroTilePitch = 32;
uint macroTileHeight = 16;
switch (tileMode)
{
case AddrTileMode.ADDR_TM_2D_TILED_THIN2:
case AddrTileMode.ADDR_TM_2B_TILED_THIN2:
{
macroTilePitch = 16;
macroTileHeight = 32;
break;
}
case AddrTileMode.ADDR_TM_2D_TILED_THIN4:
case AddrTileMode.ADDR_TM_2B_TILED_THIN4:
{
macroTilePitch = 8;
macroTileHeight = 64;
break;
}
}
uint macroTilesPerRow = pitch / macroTilePitch;
uint macroTileBytes = (numSamples * microTileThickness * bpp * macroTileHeight
* macroTilePitch + 7) / 8;
uint macroTileIndexX = x / macroTilePitch;
uint macroTileIndexY = y / macroTileHeight;
ulong macroTileOffset = (macroTileIndexX + macroTilesPerRow * macroTileIndexY) * macroTileBytes;
if (isBankSwappedTileMode(tileMode) != 0)
{
uint bankSwapWidth = computeSurfaceBankSwappedWidth(tileMode, bpp, 1, pitch);
uint swapIndex = macroTilePitch * macroTileIndexX / bankSwapWidth;
bank ^= bankSwapOrder[swapIndex & 3];
}
ulong totalOffset = elemOffset + ((macroTileOffset + sliceOffset) >> 3);
return bank << 9 | pipe << 8 | totalOffset & 255 | (ulong)((int)totalOffset & -256) << 3;
}
public static uint computeSurfaceMipLevelTileMode(uint baseTileMode, uint bpp, uint level, uint width, uint height,
uint numSlices, uint numSamples, uint isDepth, uint noRecursive)
{
uint widthAlignFactor = 1;
uint macroTileWidth = 32;
uint macroTileHeight = 16;
uint tileSlices = computeSurfaceTileSlices(baseTileMode, bpp, numSamples);
uint expTileMode = baseTileMode;
uint widtha, heighta, numSlicesa, thickness, microTileBytes;
if (DebugSurface)
Console.WriteLine("baseTileMode " + baseTileMode);
if (numSamples > 1 || tileSlices > 1 || isDepth != 0)
{
if (baseTileMode == 7)
expTileMode = 4;
else if (baseTileMode == 13)
expTileMode = 12;
else if (baseTileMode == 11)
expTileMode = 8;
else if (baseTileMode == 15)
expTileMode = 14;
}
if (baseTileMode == 2 && numSamples > 1)
{
expTileMode = 4;
}
else if (baseTileMode == 3)
{
if (numSamples > 1 || isDepth != 0)
expTileMode = 2;
if (numSamples == 2 || numSamples == 4)
expTileMode = 7;
}
else
{
expTileMode = baseTileMode;
}
if (DebugSurface)
Console.WriteLine("computeSurfaceMipLevelTileMode expTileMode " + expTileMode);
if (noRecursive != 0 || level == 0)
return expTileMode;
switch (bpp)
{
case 24:
case 48:
case 96:
bpp /= 3;
break;
}
widtha = nextPow2(width);
heighta = nextPow2(height);
numSlicesa = nextPow2(numSlices);
expTileMode = convertToNonBankSwappedMode((AddrTileMode)expTileMode);
thickness = computeSurfaceThickness((AddrTileMode)expTileMode);
microTileBytes = (numSamples * bpp * (thickness << 6) + 7) >> 3;
if (microTileBytes < 256)
{
widthAlignFactor = Math.Max(1, 256 / microTileBytes);
}
if (expTileMode == 4 || expTileMode == 12)
{
if ((widtha < widthAlignFactor * macroTileWidth) || heighta < macroTileHeight)
expTileMode = 2;
}
else if (expTileMode == 5)
{
macroTileWidth = 16;
macroTileHeight = 32;
if ((widtha < widthAlignFactor * macroTileWidth) || heighta < macroTileHeight)
expTileMode = 2;
}
else if (expTileMode == 6)
{
macroTileWidth = 8;
macroTileHeight = 64;
if ((widtha < widthAlignFactor * macroTileWidth) || heighta < macroTileHeight)
expTileMode = 2;
}
else if (expTileMode == 7 || expTileMode == 13)
{
if ((widtha < widthAlignFactor * macroTileWidth) || heighta < macroTileHeight)
expTileMode = 3;
}
if (numSlicesa < 4)
{
if (expTileMode == 3)
expTileMode = 2;
else if (expTileMode == 7)
expTileMode = 4;
else if (expTileMode == 13)
expTileMode = 12;
}
return computeSurfaceMipLevelTileMode(
expTileMode,
bpp,
level,
widtha,
heighta,
numSlicesa,
numSamples,
isDepth,
1);
}
private static uint computeSurfaceTileSlices(uint tileMode, uint bpp, uint numSamples)
{
uint bytePerSample = ((bpp << 6) + 7) >> 3;
uint tileSlices = 1;
uint samplePerTile;
if (computeSurfaceThickness((AddrTileMode)tileMode) > 1)
numSamples = 4;
if (bytePerSample != 0)
{
samplePerTile = 2048 / bytePerSample;
if (samplePerTile < numSamples)
tileSlices = Math.Max(1, numSamples / samplePerTile);
}
return tileSlices;
}
private static uint ComputeSurfaceInfoEx()
{
uint tileMode = pIn.tileMode;
uint bpp = pIn.bpp;
uint numSamples = Math.Max(1, pIn.numSamples);
uint pitch = pIn.width;
Console.WriteLine("ComputeSurfaceInfoEx pitch " + pitch);
uint height = pIn.height;
uint numSlices = pIn.numSlices;
uint mipLevel = pIn.mipLevel;
Flags flags = new Flags();
uint pPitchOut = pOut.pitch;
uint pHeightOut = pOut.height;
uint pNumSlicesOut = pOut.depth;
uint pTileModeOut = pOut.tileMode;
uint pSurfSize = (uint)pOut.surfSize;
uint pBaseAlign = pOut.baseAlign;
uint pPitchAlign = pOut.pitchAlign;
uint pHeightAlign = pOut.heightAlign;
uint pDepthAlign = pOut.depthAlign;
uint padDims = 0;
uint valid = 0;
uint baseTileMode = tileMode;
if (DebugSurface)
{
Console.WriteLine("---------------------------");
Console.WriteLine(tileMode);
Console.WriteLine(bpp);
Console.WriteLine(numSamples);
Console.WriteLine(pitch);
Console.WriteLine(height);
Console.WriteLine(numSlices);
Console.WriteLine(mipLevel);
Console.WriteLine(flags);
Console.WriteLine(pPitchOut);
Console.WriteLine(pHeightOut);
Console.WriteLine(pNumSlicesOut);
Console.WriteLine(pTileModeOut);
Console.WriteLine(pSurfSize);
Console.WriteLine(pBaseAlign);
Console.WriteLine(pPitchAlign);
Console.WriteLine(pHeightAlign);
Console.WriteLine(pDepthAlign);
Console.WriteLine(padDims);
Console.WriteLine(valid);
Console.WriteLine(baseTileMode);
Console.WriteLine("---------------------------");
}
flags.value = pIn.flags.value;
Console.WriteLine("padDims " + padDims);
if ((((flags.value >> 4) & 1) != 0) && (mipLevel == 0))
padDims = 2;
Console.WriteLine("padDims " + padDims);
if (((flags.value >> 6) & 1) != 0)
tileMode = convertToNonBankSwappedMode((AddrTileMode)tileMode);
else
{
if (DebugSurface)
Console.WriteLine(tileMode);
tileMode = computeSurfaceMipLevelTileMode(
tileMode,
bpp,
mipLevel,
pitch,
height,
numSlices,
numSamples,
(flags.value >> 1) & 1, 0);
if (DebugSurface)
{
Console.WriteLine("---------------------------");
Console.WriteLine(tileMode);
Console.WriteLine("---------------------------");
}
}
switch (tileMode)
{
case 0:
case 1:
var compSurfInfoLinear = computeSurfaceInfoLinear(
tileMode,
bpp,
numSamples,
pitch,
height,
numSlices,
mipLevel,
padDims,
flags);
valid = compSurfInfoLinear[0];
pPitchOut = compSurfInfoLinear[1];
pHeightOut = compSurfInfoLinear[2];
pNumSlicesOut = compSurfInfoLinear[3];
pSurfSize = compSurfInfoLinear[4];
pBaseAlign = compSurfInfoLinear[5];
pPitchAlign = compSurfInfoLinear[6];
pHeightAlign = compSurfInfoLinear[7];
pDepthAlign = compSurfInfoLinear[8];
pTileModeOut = tileMode;
break;
case 2:
case 3:
var compSurfInfoMicroTile = computeSurfaceInfoMicroTiled(
tileMode,
bpp,
numSamples,
pitch,
height,
numSlices,
mipLevel,
padDims,
flags);
valid = compSurfInfoMicroTile[0];
pPitchOut = compSurfInfoMicroTile[1];
pHeightOut = compSurfInfoMicroTile[2];
pNumSlicesOut = compSurfInfoMicroTile[3];
pSurfSize = compSurfInfoMicroTile[4];
pTileModeOut = compSurfInfoMicroTile[5];
pBaseAlign = compSurfInfoMicroTile[6];
pPitchAlign = compSurfInfoMicroTile[7];
pHeightAlign = compSurfInfoMicroTile[8];
pDepthAlign = compSurfInfoMicroTile[9];
break;
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
var compSurfInfoMacoTile = computeSurfaceInfoMacroTiled(
tileMode,
baseTileMode,
bpp,
numSamples,
pitch,
height,
numSlices,
mipLevel,
padDims,
flags);
valid = compSurfInfoMacoTile[0];
pPitchOut = compSurfInfoMacoTile[1];
pHeightOut = compSurfInfoMacoTile[2];
pNumSlicesOut = compSurfInfoMacoTile[3];
pSurfSize = compSurfInfoMacoTile[4];
pTileModeOut = compSurfInfoMacoTile[5];
pBaseAlign = compSurfInfoMacoTile[6];
pPitchAlign = compSurfInfoMacoTile[7];
pHeightAlign = compSurfInfoMacoTile[8];
pDepthAlign = compSurfInfoMacoTile[9];
break;
}
pOut.pitch = pPitchOut;
pOut.height = pHeightOut;
pOut.depth = pNumSlicesOut;
pOut.tileMode = pTileModeOut;
pOut.surfSize = pSurfSize;
pOut.baseAlign = pBaseAlign;
pOut.pitchAlign = pPitchAlign;
pOut.heightAlign = pHeightAlign;
pOut.depthAlign = pDepthAlign;
if (DebugSurface)
{
Console.WriteLine(pOut.pitch);
Console.WriteLine(pOut.height);
Console.WriteLine(pOut.depth);
Console.WriteLine(pOut.tileMode);
Console.WriteLine(pOut.surfSize);
Console.WriteLine(pOut.baseAlign);
Console.WriteLine(pOut.pitchAlign);
Console.WriteLine(pOut.heightAlign);
Console.WriteLine(pOut.depthAlign);
}
if (valid == 0)
return 3;
return 0;
}
private static uint[] computeSurfaceInfoLinear(uint tileMode, uint bpp, uint numSamples, uint pitch, uint height,
uint numSlices, uint mipLevel, uint padDims, Flags flags)
{
expPitch = pitch;
expHeight = height;
expNumSlices = numSlices;
uint valid = 1;
uint microTileThickness = computeSurfaceThickness((AddrTileMode)tileMode);
uint baseAlign, pitchAlign, heightAlign, slices;
uint pPitchOut, pHeightOut, pNumSlicesOut, pSurfSize, pBaseAlign, pPitchAlign, pHeightAlign, pDepthAlign;
var compAllignLinear = computeSurfaceAlignmentsLinear(tileMode, bpp, flags);
baseAlign = compAllignLinear.Item1;
pitchAlign = compAllignLinear.Item2;
heightAlign = compAllignLinear.Item3;
if ((((flags.value >> 9) & 1) != 0) && (mipLevel == 0))
{
expPitch /= 3;
expPitch = nextPow2(expPitch);
}
if (mipLevel != 0)
{
expPitch = nextPow2(expPitch);
expHeight = nextPow2(expHeight);
if (((flags.value >> 4) & 1) != 0)
{
expNumSlices = numSlices;
if (numSlices <= 1)
padDims = 2;
else
padDims = 0;
}
else
expNumSlices = nextPow2(numSlices);
}
var padimens = padDimensions(
tileMode,
padDims,
(flags.value >> 4) & 1,
pitchAlign,
heightAlign,
microTileThickness);
expPitch = padimens.Item1;
expHeight = padimens.Item2;
expNumSlices = padimens.Item3;
if ((((flags.value >> 9) & 1) != 0) && (mipLevel == 0))
expPitch *= 3;
slices = expNumSlices * numSamples / microTileThickness;
pPitchOut = expPitch;
pHeightOut = expHeight;
pNumSlicesOut = expNumSlices;
pSurfSize = (expHeight * expPitch * slices * bpp * numSamples + 7) / 8;
pBaseAlign = baseAlign;
pPitchAlign = pitchAlign;
pHeightAlign = heightAlign;
pDepthAlign = microTileThickness;
return new uint[] { valid, pPitchOut, pHeightOut, pNumSlicesOut, pSurfSize, pBaseAlign, pPitchAlign, pHeightAlign, pDepthAlign };
}
private static Tuple<uint, uint, uint> computeSurfaceAlignmentsLinear(uint tileMode, uint bpp, Flags flags)
{
uint pixelsPerPipeInterleave;
uint baseAlign, pitchAlign, heightAlign;
if (tileMode == 0)
{
baseAlign = 1;
pitchAlign = (bpp != 1 ? (uint)1 : 8);
heightAlign = 1;
}
else if (tileMode == 1)
{
pixelsPerPipeInterleave = 2048 / bpp;
baseAlign = 256;
pitchAlign = Math.Max(0x40, pixelsPerPipeInterleave);
heightAlign = 1;
}
else
{
baseAlign = 1;
pitchAlign = 1;
heightAlign = 1;
}
pitchAlign = adjustPitchAlignment(flags, pitchAlign);
return new Tuple<uint, uint, uint>(baseAlign, pitchAlign, heightAlign);
}
private static uint convertToNonBankSwappedMode(AddrTileMode tileMode)
{
switch ((uint)tileMode)
{
case 8:
return 4;
case 9:
return 5;
case 10:
return 6;
case 11:
return 7;
case 14:
return 12;
case 15:
return 13;
}
return (uint)tileMode;
}
private static void computeSurfaceInfo(surfaceIn aSurfIn, surfaceOut pSurfOut)
{
if (DebugSurface)
{
Console.WriteLine(" computeSurfaceInfo ------------------------------------ ");
}
pIn = aSurfIn;
pOut = pSurfOut;
uint returnCode = 0;
uint width, height, bpp, elemMode = 0;
uint expandY, expandX;
if (pIn.bpp > 0x80)
returnCode = 3;
if (DebugSurface)
Console.WriteLine("returnCode " + returnCode);
if (returnCode == 0)
{
if (DebugSurface)
{
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" computeMipLevel");
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" pIn.width " + pIn.width);
Console.WriteLine(" pIn.height " + pIn.height);
Console.WriteLine(" pIn.numSlices " + pIn.numSlices);
}
computeMipLevel();
width = pIn.width;
height = pIn.height;
bpp = pIn.bpp;
expandX = 1;
expandY = 1;
if (DebugSurface)
{
Console.WriteLine(pIn.width);
Console.WriteLine(pIn.height);
Console.WriteLine(pIn.numSlices);
Console.WriteLine("-------------------------------------------");
}
pOut.pixelBits = pIn.bpp;
if (pIn.format != 0)
{
bpp = formatExInfo[pIn.format * 4];
expandX = formatExInfo[pIn.format * 4 + 1];
expandY = formatExInfo[pIn.format * 4 + 2];
elemMode = formatExInfo[pIn.format * 4 + 3];
if (DebugSurface)
{
Console.WriteLine($"bpp {bpp}");
Console.WriteLine($"expandX {expandX}");
Console.WriteLine($"expandY {expandY}");
Console.WriteLine($"elemMode {elemMode}");
}
if (elemMode == 4 && expandX == 3 && pIn.tileMode == 1)
pIn.flags.value |= 0x200;
bpp = adjustSurfaceInfo(elemMode, expandX, expandY, bpp, width, height);
if (DebugSurface)
{
Console.WriteLine($"width {pIn.width}");
Console.WriteLine($"height {pIn.height}");
Console.WriteLine($"bpp {pIn.bpp}");
}
}
else if (pIn.bpp != 0)
{
pIn.width = Math.Max(1, pIn.width);
pIn.height = Math.Max(1, pIn.height);
}
else
returnCode = 3;
if (returnCode == 0)
returnCode = ComputeSurfaceInfoEx();
if (returnCode == 0)
{
pOut.bpp = pIn.bpp;
pOut.pixelPitch = pOut.pitch;
pOut.pixelHeight = pOut.height;
if (pIn.format != 0 && (((pIn.flags.value >> 9) & 1) == 0 || pIn.mipLevel == 0))
bpp = restoreSurfaceInfo(elemMode, expandX, expandY, bpp);
if (((pIn.flags.value >> 5) & 1) != 0)
pOut.sliceSize = (uint)pOut.surfSize;
else
{
pOut.sliceSize = (uint)(pOut.surfSize / pOut.depth);
if (pIn.slice == (pIn.numSlices - 1) && pIn.numSlices > 1)
pOut.sliceSize += pOut.sliceSize * (pOut.depth - pIn.numSlices);
}
pOut.pitchTileMax = (pOut.pitch >> 3) - 1;
pOut.heightTileMax = (pOut.height >> 3) - 1;
pOut.sliceTileMax = (pOut.height * pOut.pitch >> 6) - 1;
}
}
}
private static uint[] computeSurfaceInfoMicroTiled(uint tileMode, uint bpp, uint numSamples, uint pitch, uint height, uint numSlices, uint mipLevel, uint padDims, Flags flags)
{
expPitch = pitch;
expHeight = height;
expNumSlices = numSlices;
uint valid = 1;
uint expTileMode = tileMode;
uint microTileThickness = computeSurfaceThickness((AddrTileMode)tileMode);
uint pPitchOut, pHeightOut, pNumSlicesOut, pSurfSize, pTileModeOut, pBaseAlign, pPitchAlign, pHeightAlign, pDepthAlign;
if (mipLevel != 0)
{
expPitch = nextPow2(pitch);
expHeight = nextPow2(height);
if (((flags.value >> 4) & 1) != 0)
{
expNumSlices = numSlices;
if (numSlices <= 1)
padDims = 2;
else
padDims = 0;
}
else
expNumSlices = nextPow2(numSlices);
if (expTileMode == 3 && expNumSlices < 4)
{
expTileMode = 2;
microTileThickness = 1;
}
}
var surfMicroAlign = computeSurfaceAlignmentsMicroTiled(
expTileMode,
bpp,
flags,
numSamples);
uint baseAlign = surfMicroAlign.Item1;
uint pitchAlign = surfMicroAlign.Item2;
uint heightAlign = surfMicroAlign.Item3;
var padDimens = padDimensions(
expTileMode,
padDims,
(flags.value >> 4) & 1,
pitchAlign,
heightAlign,
microTileThickness);
expPitch = padDimens.Item1;
expHeight = padDimens.Item2;
expNumSlices = padDimens.Item3;
pPitchOut = expPitch;
pHeightOut = expHeight;
pNumSlicesOut = expNumSlices;
pSurfSize = (expHeight * expPitch * expNumSlices * bpp * numSamples + 7) / 8;
Console.WriteLine("pSurfSize " + pSurfSize);
Console.WriteLine("expHeight " + expHeight);
Console.WriteLine("expPitch " + expPitch);
Console.WriteLine("expNumSlices " + expNumSlices);
Console.WriteLine("numSamples " + numSamples);
pTileModeOut = expTileMode;
pBaseAlign = baseAlign;
pPitchAlign = pitchAlign;
pHeightAlign = heightAlign;
pDepthAlign = microTileThickness;
return new uint[] { valid, pPitchOut, pHeightOut, pNumSlicesOut, pSurfSize, pTileModeOut, pBaseAlign, pPitchAlign, pHeightAlign, pDepthAlign };
}
private static Tuple<uint, uint, uint> padDimensions(uint tileMode, uint padDims, uint isCube, uint pitchAlign, uint heightAlign, uint sliceAlign)
{
uint thickness = computeSurfaceThickness((AddrTileMode)tileMode);
if (padDims == 0)
padDims = 3;
if ((pitchAlign & (pitchAlign - 1)) == 0)
expPitch = powTwoAlign(expPitch, pitchAlign);
else
{
expPitch += pitchAlign - 1;
expPitch /= pitchAlign;
expPitch *= pitchAlign;
}
if (padDims > 1)
expHeight = powTwoAlign(expHeight, heightAlign);
if (padDims > 2 || thickness > 1)
{
if (isCube != 0)
expNumSlices = nextPow2(expNumSlices);
if (thickness > 1)
expNumSlices = powTwoAlign(expNumSlices, sliceAlign);
}
return new Tuple<uint, uint, uint>(expPitch, expHeight, expNumSlices);
}
private static uint[] computeSurfaceInfoMacroTiled(uint tileMode, uint baseTileMode, uint bpp, uint numSamples,
uint pitch, uint height, uint numSlices, uint mipLevel, uint padDims, Flags flags)
{
expPitch = pitch;
expHeight = height;
expNumSlices = numSlices;
uint valid = 1;
uint expTileMode = tileMode;
uint microTileThickness = computeSurfaceThickness((AddrTileMode)tileMode);
uint baseAlign, pitchAlign, heightAlign, macroWidth, macroHeight;
uint bankSwappedWidth, pitchAlignFactor;
uint result, pPitchOut, pHeightOut, pNumSlicesOut, pSurfSize, pTileModeOut, pBaseAlign, pPitchAlign, pHeightAlign, pDepthAlign;
if (mipLevel != 0)
{
expPitch = nextPow2(pitch);
expHeight = nextPow2(height);
if (((flags.value >> 4) & 1) != 0)
{
expNumSlices = numSlices;
if (numSlices <= 1)
padDims = 2;
else
padDims = 0;
}
else
expNumSlices = nextPow2(numSlices);
if (expTileMode == 7 && expNumSlices < 4)
{
expTileMode = 4;
microTileThickness = 1;
}
}
if (tileMode == baseTileMode
|| mipLevel == 0
|| isThickMacroTiled((AddrTileMode)baseTileMode) == 0
|| isThickMacroTiled((AddrTileMode)tileMode) != 0)
{
var tup = computeSurfaceAlignmentsMacroTiled(
tileMode,
bpp,
flags,
numSamples);
baseAlign = tup.Item1;
pitchAlign = tup.Item2;
heightAlign = tup.Item3;
macroWidth = tup.Item4;
macroHeight = tup.Item5;
bankSwappedWidth = computeSurfaceBankSwappedWidth((AddrTileMode)tileMode, bpp, numSamples, pitch);
if (bankSwappedWidth > pitchAlign)
pitchAlign = bankSwappedWidth;
var padDimens = padDimensions(
tileMode,
padDims,
(flags.value >> 4) & 1,
pitchAlign,
heightAlign,
microTileThickness);
expPitch = padDimens.Item1;
expHeight = padDimens.Item2;
expNumSlices = padDimens.Item3;
pPitchOut = expPitch;
pHeightOut = expHeight;
pNumSlicesOut = expNumSlices;
pSurfSize = (expHeight * expPitch * expNumSlices * bpp * numSamples + 7) / 8;
pTileModeOut = expTileMode;
pBaseAlign = baseAlign;
pPitchAlign = pitchAlign;
pHeightAlign = heightAlign;
pDepthAlign = microTileThickness;
result = valid;
}
else
{
var tup = computeSurfaceAlignmentsMacroTiled(
baseTileMode,
bpp,
flags,
numSamples);
baseAlign = tup.Item1;
pitchAlign = tup.Item2;
heightAlign = tup.Item3;
macroWidth = tup.Item4;
macroHeight = tup.Item5;
pitchAlignFactor = Math.Max(1, 32 / bpp);
if (expPitch < pitchAlign * pitchAlignFactor || expHeight < heightAlign)
{
expTileMode = 2;
var microTileInfo = computeSurfaceInfoMicroTiled(
2,
bpp,
numSamples,
pitch,
height,
numSlices,
mipLevel,
padDims,
flags);
result = microTileInfo[0];
pPitchOut = microTileInfo[1];
pHeightOut = microTileInfo[2];
pNumSlicesOut = microTileInfo[3];
pSurfSize = microTileInfo[4];
pTileModeOut = microTileInfo[5];
pBaseAlign = microTileInfo[6];
pPitchAlign = microTileInfo[7];
pHeightAlign = microTileInfo[8];
pDepthAlign = microTileInfo[9];
}
else
{
tup = computeSurfaceAlignmentsMacroTiled(
tileMode,
bpp,
flags,
numSamples);
baseAlign = tup.Item1;
pitchAlign = tup.Item2;
heightAlign = tup.Item3;
macroWidth = tup.Item4;
macroHeight = tup.Item5;
bankSwappedWidth = computeSurfaceBankSwappedWidth((AddrTileMode)tileMode, bpp, numSamples, pitch);
if (bankSwappedWidth > pitchAlign)
pitchAlign = bankSwappedWidth;
var padDimens = padDimensions(
tileMode,
padDims,
(flags.value >> 4) & 1,
pitchAlign,
heightAlign,
microTileThickness);
expPitch = padDimens.Item1;
expHeight = padDimens.Item2;
expNumSlices = padDimens.Item3;
pPitchOut = expPitch;
pHeightOut = expHeight;
pNumSlicesOut = expNumSlices;
pSurfSize = (expHeight * expPitch * expNumSlices * bpp * numSamples + 7) / 8;
pTileModeOut = expTileMode;
pBaseAlign = baseAlign;
pPitchAlign = pitchAlign;
pHeightAlign = heightAlign;
pDepthAlign = microTileThickness;
result = valid;
}
}
return new uint[] { result, pPitchOut, pHeightOut,
pNumSlicesOut, pSurfSize, pTileModeOut, pBaseAlign, pitchAlign, heightAlign, pDepthAlign};
}
private static Tuple<uint, uint, uint> computeSurfaceAlignmentsMicroTiled(uint tileMode, uint bpp, Flags flags, uint numSamples)
{
switch (bpp)
{
case 24:
case 48:
case 96:
bpp /= 3;
break;
}
uint thickness = computeSurfaceThickness((AddrTileMode)tileMode);
uint baseAlign = 256;
uint pitchAlign = Math.Max(8, 256 / bpp / numSamples / thickness);
uint heightAlign = 8;
pitchAlign = adjustPitchAlignment(flags, pitchAlign);
return new Tuple<uint, uint, uint>(baseAlign, pitchAlign, heightAlign);
}
private static Tuple<uint, uint, uint, uint, uint> computeSurfaceAlignmentsMacroTiled(uint tileMode, uint bpp, Flags flags, uint numSamples)
{
uint aspectRatio = computeMacroTileAspectRatio((AddrTileMode)tileMode);
uint thickness = computeSurfaceThickness((AddrTileMode)tileMode);
switch (bpp)
{
case 24:
case 48:
case 96:
bpp /= 3;
break;
case 3:
bpp = 1;
break;
}
uint macroTileWidth = 32 / aspectRatio;
uint macroTileHeight = aspectRatio * 16;
uint pitchAlign = Math.Max(macroTileWidth, macroTileWidth * (256 / bpp / (8 * thickness) / numSamples));
pitchAlign = adjustPitchAlignment(flags, pitchAlign);
uint heightAlign = macroTileHeight;
uint macroTileBytes = numSamples * ((bpp * macroTileHeight * macroTileWidth + 7) >> 3);
uint baseAlign;
if (thickness == 1)
baseAlign = Math.Max(macroTileBytes, (numSamples * heightAlign * bpp * pitchAlign + 7) >> 3);
else
baseAlign = Math.Max(256, (4 * heightAlign * bpp * pitchAlign + 7) >> 3);
uint microTileBytes = (thickness * numSamples * (bpp << 6) + 7) >> 3;
uint numSlicesPerMicroTile = (microTileBytes < 2048 ? (uint)1 : microTileBytes / 2048);
baseAlign /= numSlicesPerMicroTile;
return new Tuple<uint, uint, uint, uint, uint>(baseAlign, pitchAlign, heightAlign, macroTileWidth, macroTileHeight);
}
private static uint adjustPitchAlignment(Flags flags, uint pitchAlign)
{
if (((flags.value >> 13) & 1) != 0)
pitchAlign = powTwoAlign(pitchAlign, 0x20);
return pitchAlign;
}
private static uint adjustSurfaceInfo(uint elemMode, uint expandX, uint expandY, uint bpp, uint width, uint height)
{
uint bBCnFormat = 0;
uint widtha, heighta;
switch (elemMode)
{
case 9:
case 10:
case 11:
case 12:
case 13:
if (bpp != 0)
bBCnFormat = 1;
break;
}
if (width != 0 && height != 0)
{
if (expandX > 1 || expandY > 1)
{
if (elemMode == 4)
{
widtha = expandX * width;
heighta = expandY * height;
}
else if (bBCnFormat != 0)
{
widtha = width / expandX;
heighta = height / expandY;
}
else
{
widtha = (width + expandX - 1) / expandX;
heighta = (height + expandY - 1) / expandY;
}
pIn.width = Math.Max(1, widtha);
pIn.height = Math.Max(1, heighta);
}
}
if (bpp != 0)
{
switch (elemMode)
{
case 4:
pIn.bpp = bpp / expandX / expandY;
break;
case 5:
case 6:
pIn.bpp = expandY * expandX * bpp;
break;
case 9:
case 12:
pIn.bpp = 64;
break;
case 10:
case 11:
case 13:
pIn.bpp = 128;
break;
default:
pIn.bpp = bpp;
break;
}
return pIn.bpp;
}
return 0;
}
private static void computeMipLevel()
{
uint slices = 0;
uint height = 0;
uint width = 0;
uint hwlHandled = 0;
if (49 <= pIn.format && pIn.format <= 55 && (pIn.mipLevel == 0 || ((pIn.flags.value >> 12) & 1) != 0))
{
pIn.width = powTwoAlign(pIn.width, 4);
pIn.height = powTwoAlign(pIn.height, 4);
}
if (DebugSurface)
{
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" hwlComputeMipLevel");
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" pIn.width " + pIn.width);
Console.WriteLine(" pIn.height " + pIn.height);
Console.WriteLine(" pIn.numSlices " + pIn.numSlices);
}
hwlHandled = hwlComputeMipLevel();
if (DebugSurface)
{
Console.WriteLine(" Output:");
Console.WriteLine(" pIn.width " + pIn.width);
Console.WriteLine(" pIn.height " + pIn.height);
Console.WriteLine(" pIn.numSlices " + pIn.numSlices);
Console.WriteLine("-------------------------------------------");
}
if (hwlHandled == 0 && pIn.mipLevel != 0 && ((pIn.flags.value >> 12) & 1) != 0)
{
width = Math.Max(1, pIn.width >> (int)pIn.mipLevel);
height = Math.Max(1, pIn.height >> (int)pIn.mipLevel);
slices = Math.Max(1, pIn.numSlices);
if (((pIn.flags.value >> 4) & 1) == 0)
slices = Math.Max(1, slices >> (int)pIn.mipLevel);
if (pIn.format != 47 && pIn.format != 48)
{
width = nextPow2(width);
height = nextPow2(height);
slices = nextPow2(slices);
}
pIn.width = width;
pIn.height = height;
pIn.numSlices = slices;
}
}
private static uint restoreSurfaceInfo(uint elemMode, uint expandX, uint expandY, uint bpp)
{
uint width, height;
if (pOut.pixelPitch != 0 && pOut.pixelHeight != 0)
{
width = pOut.pixelPitch;
height = pOut.pixelHeight;
if (expandX > 1 || expandY > 1)
{
if (elemMode == 4)
{
width /= expandX;
height /= expandY;
}
else
{
width *= expandX;
height *= expandY;
}
}
pOut.pixelPitch = Math.Max(1, width);
pOut.pixelHeight = Math.Max(1, height);
}
if (bpp != 0)
{
switch (elemMode)
{
case 4:
return expandY * expandX * bpp;
case 5:
case 6:
return bpp / expandX / expandY;
case 9:
case 12:
return 64;
case 10:
case 11:
case 13:
return 128;
default:
return bpp;
}
}
return 0;
}
private static uint hwlComputeMipLevel()
{
uint handled = 0;
if (49 <= pIn.format && pIn.format <= 55)
{
if (pIn.mipLevel != 0)
{
uint width = pIn.width;
uint height = pIn.height;
uint slices = pIn.numSlices;
if (((pIn.flags.value >> 12) & 1) != 0)
{
uint widtha = width >> (int)pIn.mipLevel;
uint heighta = height >> (int)pIn.mipLevel;
if (((pIn.flags.value >> 4) & 1) == 0)
slices >>= (int)pIn.mipLevel;
width = Math.Max(1, widtha);
height = Math.Max(1, heighta);
slices = Math.Max(1, slices);
}
pIn.width = nextPow2(width);
pIn.height = nextPow2(height);
pIn.numSlices = slices;
}
handled = 1;
}
return handled;
}
private static uint powTwoAlign(uint x, uint align)
{
return ~(align - 1) & (x + align - 1);
}
/// <summary>
/// Gets the surface info of a GX2 texture
/// </summary>
/// <param name="surfaceFormat">The <see cref="GX2SurfaceFormat"/> of the surface.</param>
/// <param name="surfaceWidth">The width of the surface.</param>
/// <param name="surfaceHeight">The height of the surface.</param>
/// <param name="surfaceDepth">The depth of the surface.</param>
/// <param name="surfaceDim">The <see cref="GX2SurfaceDim"/ of the surface.</param>
/// <param name="surfaceTileMode">The <see cref="GX2TileMode"/ of the surface.</param>
/// <param name="surfaceAA">The <see cref="GX2AAMode"/ of the surface.</param>
/// <param name="level">The mip level of which the info will be calculated for (first mipmap corresponds to value 1</param>
public static surfaceOut getSurfaceInfo(GX2SurfaceFormat surfaceFormat, uint surfaceWidth, uint surfaceHeight, uint surfaceDepth, uint surfaceDim, uint surfaceTileMode, uint surfaceAA, int level)
{
uint dim = 0;
uint width = 0;
uint blockSize = 0;
uint numSamples = 0;
uint hwFormat = 0;
var aSurfIn = new surfaceIn();
var pSurfOut = new surfaceOut();
hwFormat = (uint)((int)surfaceFormat & 0x3F);
if (surfaceTileMode == 16)
{
numSamples = (uint)(1 << (int)surfaceAA);
if (hwFormat < 0x31 || hwFormat > 0x35)
blockSize = 1;
else
blockSize = 4;
width = (uint)(~(blockSize - 1) & (Math.Max(1, surfaceWidth >> level) + blockSize - 1));
pSurfOut.bpp = formatHwInfo[hwFormat * 4];
pSurfOut.size = 96;
pSurfOut.pitch = (uint)(width / blockSize);
pSurfOut.pixelBits = formatHwInfo[hwFormat * 4];
pSurfOut.baseAlign = 1;
pSurfOut.pitchAlign = 1;
pSurfOut.heightAlign = 1;
pSurfOut.depthAlign = 1;
dim = surfaceDim;
if (dim == 0)
{
pSurfOut.height = 1;
pSurfOut.depth = 1;
}
else if (dim == 1 || dim == 6)
{
pSurfOut.height = Math.Max(1, surfaceHeight >> level);
pSurfOut.depth = 1;
}
else if (dim == 2)
{
pSurfOut.height = Math.Max(1, surfaceHeight >> level);
pSurfOut.depth = Math.Max(1, surfaceDepth >> level);
}
else if (dim == 3)
{
pSurfOut.height = Math.Max(1, surfaceHeight >> level);
pSurfOut.depth = Math.Max(6, surfaceDepth);
}
else if (dim == 4)
{
pSurfOut.height = 1;
pSurfOut.depth = surfaceDepth;
}
else if (dim == 5 || dim == 7)
{
pSurfOut.height = Math.Max(1, surfaceHeight >> level);
pSurfOut.depth = surfaceDepth;
}
pSurfOut.pixelPitch = width;
pSurfOut.pixelHeight = (uint)(~(blockSize - 1) & (pSurfOut.height + blockSize - 1));
pSurfOut.height = (uint)(pSurfOut.pixelHeight / blockSize);
pSurfOut.surfSize = pSurfOut.bpp * numSamples * pSurfOut.depth * pSurfOut.height * pSurfOut.pitch >> 3;
if (surfaceDim == 2)
pSurfOut.sliceSize = (uint)pSurfOut.surfSize;
else
pSurfOut.sliceSize = (uint)(pSurfOut.surfSize / pSurfOut.depth);
pSurfOut.pitchTileMax = (pSurfOut.pitch >> 3) - 1;
pSurfOut.heightTileMax = (pSurfOut.height >> 3) - 1;
pSurfOut.sliceTileMax = (pSurfOut.height * pSurfOut.pitch >> 6) - 1;
}
else
{
aSurfIn.size = 60;
aSurfIn.tileMode = surfaceTileMode & 0x0F;
aSurfIn.format = hwFormat;
aSurfIn.bpp = formatHwInfo[hwFormat * 4];
aSurfIn.numSamples = (uint)(1 << (int)surfaceAA);
aSurfIn.numFrags = aSurfIn.numSamples;
aSurfIn.width = (uint)Math.Max(1, surfaceWidth >> level);
dim = surfaceDim;
if (dim == 0)
{
aSurfIn.height = 1;
aSurfIn.numSlices = 1;
}
else if (dim == 1 || dim == 6)
{
aSurfIn.height = (uint)Math.Max(1, surfaceHeight >> level);
aSurfIn.numSlices = 1;
}
else if (dim == 2)
{
aSurfIn.height = (uint)Math.Max(1, surfaceHeight >> level);
aSurfIn.numSlices = (uint)Math.Max(1, surfaceDepth >> level);
}
else if (dim == 3)
{
aSurfIn.height = (uint)Math.Max(1, surfaceHeight >> level);
aSurfIn.numSlices = (uint)Math.Max(6, surfaceDepth);
aSurfIn.flags.value |= 0x10;
}
else if (dim == 4)
{
aSurfIn.height = 1;
aSurfIn.numSlices = (uint)surfaceDepth;
}
else if (dim == 5 || dim == 7)
{
aSurfIn.height = (uint)Math.Max(1, surfaceHeight >> level);
aSurfIn.numSlices = (uint)surfaceDepth;
}
aSurfIn.slice = 0;
aSurfIn.mipLevel = (uint)level;
if (surfaceDim == 2)
aSurfIn.flags.value |= 0x20;
if (level == 0)
aSurfIn.flags.value = (1 << 12) | aSurfIn.flags.value & 0xFFFFEFFF;
else
aSurfIn.flags.value = aSurfIn.flags.value & 0xFFFFEFFF;
pSurfOut.size = 96;
computeSurfaceInfo(aSurfIn, pSurfOut);
pSurfOut = pOut;
}
if (pSurfOut.tileMode == 0)
pSurfOut.tileMode = 16;
return pSurfOut;
}
}
}
Reference in a new issue Copy permalink