2022-04-23 10:59:50 +02:00
|
|
|
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2018-03-20 00:00:29 +01:00
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2020-12-30 06:25:23 +01:00
|
|
|
#include <span>
|
|
|
|
|
2018-03-20 00:00:29 +01:00
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "video_core/textures/texture.h"
|
|
|
|
|
2018-07-21 00:14:17 +02:00
|
|
|
namespace Tegra::Texture {
|
2018-03-20 00:00:29 +01:00
|
|
|
|
2020-07-04 23:42:10 +02:00
|
|
|
constexpr u32 GOB_SIZE_X = 64;
|
|
|
|
constexpr u32 GOB_SIZE_Y = 8;
|
|
|
|
constexpr u32 GOB_SIZE_Z = 1;
|
|
|
|
constexpr u32 GOB_SIZE = GOB_SIZE_X * GOB_SIZE_Y * GOB_SIZE_Z;
|
2019-12-08 18:13:18 +01:00
|
|
|
|
2020-12-30 06:25:23 +01:00
|
|
|
constexpr u32 GOB_SIZE_X_SHIFT = 6;
|
|
|
|
constexpr u32 GOB_SIZE_Y_SHIFT = 3;
|
|
|
|
constexpr u32 GOB_SIZE_Z_SHIFT = 0;
|
|
|
|
constexpr u32 GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT + GOB_SIZE_Z_SHIFT;
|
|
|
|
|
2022-08-09 01:04:45 +02:00
|
|
|
constexpr u32 SWIZZLE_X_BITS = 0b100101111;
|
|
|
|
constexpr u32 SWIZZLE_Y_BITS = 0b011010000;
|
|
|
|
|
2020-12-30 06:25:23 +01:00
|
|
|
using SwizzleTable = std::array<std::array<u32, GOB_SIZE_X>, GOB_SIZE_Y>;
|
|
|
|
|
2021-02-13 22:49:24 +01:00
|
|
|
/**
|
|
|
|
* This table represents the internal swizzle of a gob, in format 16 bytes x 2 sector packing.
|
|
|
|
* Calculates the offset of an (x, y) position within a swizzled texture.
|
|
|
|
* Taken from the Tegra X1 Technical Reference Manual. pages 1187-1188
|
|
|
|
*/
|
|
|
|
constexpr SwizzleTable MakeSwizzleTable() {
|
|
|
|
SwizzleTable table{};
|
|
|
|
for (u32 y = 0; y < table.size(); ++y) {
|
|
|
|
for (u32 x = 0; x < table[0].size(); ++x) {
|
|
|
|
table[y][x] = ((x % 64) / 32) * 256 + ((y % 8) / 2) * 64 + ((x % 32) / 16) * 32 +
|
|
|
|
(y % 2) * 16 + (x % 16);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return table;
|
|
|
|
}
|
2020-12-30 06:25:23 +01:00
|
|
|
|
|
|
|
/// Unswizzles a block linear texture into linear memory.
|
|
|
|
void UnswizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel,
|
|
|
|
u32 width, u32 height, u32 depth, u32 block_height, u32 block_depth,
|
|
|
|
u32 stride_alignment = 1);
|
|
|
|
|
|
|
|
/// Swizzles linear memory into a block linear texture.
|
|
|
|
void SwizzleTexture(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width,
|
|
|
|
u32 height, u32 depth, u32 block_height, u32 block_depth,
|
|
|
|
u32 stride_alignment = 1);
|
2018-04-25 04:58:45 +02:00
|
|
|
|
2019-02-24 01:22:54 +01:00
|
|
|
/// This function calculates the correct size of a texture depending if it's tiled or not.
|
2018-10-12 20:21:53 +02:00
|
|
|
std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
|
|
|
|
u32 block_height, u32 block_depth);
|
|
|
|
|
2018-10-18 03:26:40 +02:00
|
|
|
/// Copies an untiled subrectangle into a tiled surface.
|
2022-08-14 11:36:36 +02:00
|
|
|
void SwizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel, u32 width,
|
|
|
|
u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x, u32 extent_y,
|
|
|
|
u32 block_height, u32 block_depth, u32 pitch_linear);
|
2019-02-24 01:22:54 +01:00
|
|
|
|
2018-10-18 03:26:40 +02:00
|
|
|
/// Copies a tiled subrectangle into a linear surface.
|
2022-08-14 11:36:36 +02:00
|
|
|
void UnswizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixel,
|
|
|
|
u32 width, u32 height, u32 depth, u32 origin_x, u32 origin_y, u32 extent_x,
|
|
|
|
u32 extent_y, u32 block_height, u32 block_depth, u32 pitch_linear);
|
2019-04-16 03:06:04 +02:00
|
|
|
|
2020-04-28 19:53:47 +02:00
|
|
|
/// Obtains the offset of the gob for positions 'dst_x' & 'dst_y'
|
2020-04-28 05:57:24 +02:00
|
|
|
u64 GetGOBOffset(u32 width, u32 height, u32 dst_x, u32 dst_y, u32 block_height,
|
|
|
|
u32 bytes_per_pixel);
|
|
|
|
|
2018-07-21 00:14:17 +02:00
|
|
|
} // namespace Tegra::Texture
|