texture.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <algorithm>
#include <cstring>
#include <functional>
 
#include <rex/platform.h>
#include <rex/assert.h>
#include <rex/types.h>
#include <rex/xenos/fetch.h>
#include <rex/xenos/format.h>
#include <rex/bit.h>
 
namespace rex::xenos {

void GetSubresourcesFromFetchConstant(const xenos::TextureFetch& fetch, u32* width_minus_1_out,
                                      u32* height_minus_1_out, u32* depth_or_array_size_minus_1_out,
                                      u32* base_page_out, u32* mip_page_out, u32* mip_min_level_out,
                                      u32* mip_max_level_out);

inline u32 GetPackedMipLevel(u32 width, u32 height) {
  u32 log2_size = rex::log2_ceil(std::min(width, height));
  return log2_size > 4 ? log2_size - 4 : 0;
}

bool GetPackedMipOffset(u32 width, u32 height, u32 depth, xenos::TextureFormat format, u32 mip,
                        u32& x_blocks, u32& y_blocks, u32& z_blocks);

struct GuestTextureLayout {
  struct Level {
    u32 row_pitch_bytes; 
    u32 z_layer_stride_block_rows;
    u32 array_layer_stride_bytes;      
    u32 x_extent_blocks;               
    u32 y_extent_blocks;               
    u32 z_extent;                      
    u32 array_layer_data_extent_bytes; 
    u32 level_data_extent_bytes;       
  };
 
  Level base;
  Level mips[xenos::kTextureMaxMips];
  u32 mip_offsets_bytes[xenos::kTextureMaxMips]; 
  u32 mips_total_extent_bytes;
  u32 max_level;    
  u32 packed_level; 
  u32 array_size;   
};

GuestTextureLayout GetGuestTextureLayout(xenos::DataDimension dimension,
                                         u32 base_pitch_texels_div_32, u32 width_texels,
                                         u32 height_texels, u32 depth_or_array_size, bool is_tiled,
                                         xenos::TextureFormat format, bool has_packed_levels,
                                         bool has_base, u32 max_level);

i32 GetTiledOffset2D(i32 x, i32 y, u32 pitch, u32 bytes_per_block_log2);

i32 GetTiledOffset3D(i32 x, i32 y, i32 z, u32 pitch, u32 height, u32 bytes_per_block_log2);

inline u32 GetTiledAddressLowerBound2D(u32 left, u32 top, u32 pitch, u32 bytes_per_block_log2) {
  return static_cast<u32>(GetTiledOffset2D(
      static_cast<i32>(left & ~(xenos::kTextureTileWidthHeight - 1)),
      static_cast<i32>(top & ~(xenos::kTextureTileWidthHeight - 1)), pitch, bytes_per_block_log2));
}

inline u32 GetTiledAddressLowerBound3D(u32 left, u32 top, u32 front, u32 pitch, u32 height,
                                       u32 bytes_per_block_log2) {
  return static_cast<u32>(
      GetTiledOffset3D(static_cast<i32>(left & ~(xenos::kTextureTileWidthHeight - 1)),
                       static_cast<i32>(top & ~(xenos::kTextureTileWidthHeight - 1)),
                       static_cast<i32>(front & ~(xenos::kTextureTileDepth - 1)), pitch, height,
                       bytes_per_block_log2));
}

u32 GetTiledAddressUpperBound2D(u32 right, u32 bottom, u32 pitch, u32 bytes_per_block_log2);

u32 GetTiledAddressUpperBound3D(u32 right, u32 bottom, u32 back, u32 pitch, u32 height,
                                u32 bytes_per_block_log2);

u8 SwizzleSigns(const xenos::TextureFetch& fetch);

constexpr bool HasNonSignedComponent(u8 packed_signs) {
  return packed_signs != std::to_underlying(xenos::TextureSign::kSigned) * 0b01010101;
}

constexpr bool HasSignedComponent(u8 packed_signs) {
  u32 xor_signed = packed_signs ^ (std::to_underlying(xenos::TextureSign::kSigned) * 0b01010101);
  return ((xor_signed | (xor_signed >> 1)) & 0b01010101) != 0b01010101;
}

void GetClampModesForDimension(const xenos::TextureFetch& fetch, xenos::ClampMode& clamp_x_out,
                               xenos::ClampMode& clamp_y_out, xenos::ClampMode& clamp_z_out);
 
}  // namespace rex::xenos
 
namespace rex::xenos {

inline xenos::TextureFormat GetBaseFormat(xenos::TextureFormat texture_format) {
  switch (texture_format) {
    case xenos::TextureFormat::k_16_EXPAND:
      return xenos::TextureFormat::k_16_FLOAT;
    case xenos::TextureFormat::k_16_16_EXPAND:
      return xenos::TextureFormat::k_16_16_FLOAT;
    case xenos::TextureFormat::k_16_16_16_16_EXPAND:
      return xenos::TextureFormat::k_16_16_16_16_FLOAT;
    case xenos::TextureFormat::k_8_8_8_8_AS_16_16_16_16:
      return xenos::TextureFormat::k_8_8_8_8;
    case xenos::TextureFormat::k_DXT1_AS_16_16_16_16:
      return xenos::TextureFormat::k_DXT1;
    case xenos::TextureFormat::k_DXT2_3_AS_16_16_16_16:
      return xenos::TextureFormat::k_DXT2_3;
    case xenos::TextureFormat::k_DXT4_5_AS_16_16_16_16:
      return xenos::TextureFormat::k_DXT4_5;
    case xenos::TextureFormat::k_2_10_10_10_AS_16_16_16_16:
      return xenos::TextureFormat::k_2_10_10_10;
    case xenos::TextureFormat::k_10_11_11_AS_16_16_16_16:
      return xenos::TextureFormat::k_10_11_11;
    case xenos::TextureFormat::k_11_11_10_AS_16_16_16_16:
      return xenos::TextureFormat::k_11_11_10;
    case xenos::TextureFormat::k_8_8_8_8_GAMMA_EDRAM:
      return xenos::TextureFormat::k_8_8_8_8;
    default:
      break;
  }
 
  return texture_format;
}

inline size_t GetTexelSize(xenos::TextureFormat format) {
  switch (format) {
    case xenos::TextureFormat::k_8:
      return 1;
    case xenos::TextureFormat::k_1_5_5_5:
    case xenos::TextureFormat::k_4_4_4_4:
    case xenos::TextureFormat::k_5_6_5:
    case xenos::TextureFormat::k_8_8:
      return 2;
    case xenos::TextureFormat::k_2_10_10_10:
    case xenos::TextureFormat::k_8_8_8_8:
    case xenos::TextureFormat::k_16:
    case xenos::TextureFormat::k_16_FLOAT:
    case xenos::TextureFormat::k_16_16:
    case xenos::TextureFormat::k_16_16_FLOAT:
    case xenos::TextureFormat::k_32_FLOAT:
    case xenos::TextureFormat::k_10_11_11:
    case xenos::TextureFormat::k_11_11_10:
      return 4;
    case xenos::TextureFormat::k_16_16_16_16:
    case xenos::TextureFormat::k_16_16_16_16_FLOAT:
    case xenos::TextureFormat::k_32_32_FLOAT:
      return 8;
    case xenos::TextureFormat::k_32_32_32_32_FLOAT:
      return 16;
    default:
      REX_UNHANDLED_CASE(format);
      return 0;
  }
}

inline xenos::TextureFormat ColorFormatToTextureFormat(xenos::ColorFormat color_format) {
  return static_cast<xenos::TextureFormat>(color_format);
}

inline xenos::TextureFormat DepthRenderTargetToTextureFormat(
    xenos::DepthRenderTargetFormat depth_format) {
  switch (depth_format) {
    case xenos::DepthRenderTargetFormat::kD24S8:
      return xenos::TextureFormat::k_24_8;
    case xenos::DepthRenderTargetFormat::kD24FS8:
      return xenos::TextureFormat::k_24_8_FLOAT;
    default:
      REX_UNHANDLED_CASE(depth_format);
      return static_cast<xenos::TextureFormat>(~0);
  }
}
 
enum class FormatType : u8 {
  kResolvable,   
  kUncompressed, 
  kCompressed,
};
 
struct FormatInfo {
  xenos::TextureFormat format;
  const char* name; 
  FormatType type;
  u32 block_width;
  u32 block_height;
  u32 bits_per_pixel;
 
  u32 GetBytesPerBlock() const { return block_width * block_height * bits_per_pixel / 8; }

  static const FormatInfo* Get(u32 gpu_format);
 
  static const FormatInfo* Get(xenos::TextureFormat format) {
    return Get(static_cast<u32>(format));
  }
};
 
struct TextureInfo;
 
struct TextureExtent {
  u32 pitch;
  u32 height;        
  u32 block_width;   
  u32 block_height;  
  u32 block_pitch_h; 
  u32 block_pitch_v; 
  u32 depth;

  u32 GetAllBlocks() const { return block_pitch_h * block_pitch_v * depth; }

  u32 GetVisibleBlocks() const { return block_pitch_h * block_height * depth; }

  static TextureExtent Calculate(const FormatInfo* format_info, u32 pitch, u32 height, u32 depth,
                                 bool is_tiled, bool is_guest);

  static TextureExtent Calculate(const TextureInfo* texture_info, bool is_guest);
 
  bool operator==(const TextureExtent& other) const = default;
};
 
struct TextureMemoryRanges {
  u32 base_address; 
  u32 base_size;
  u32 mip_address; 
  u32 mip_size;
 
  bool operator==(const TextureMemoryRanges& other) const = default;
};

struct TextureInfo {
  xenos::TextureFormat format;
  xenos::Endian endianness;
 
  xenos::DataDimension dimension; 
  u32 width_minus_1;
  u32 height_minus_1;
  u32 depth_or_array_size_minus_1;
  u32 pitch;
  u32 mip_min_level;
  u32 mip_max_level;
  bool is_stacked; 
  bool is_tiled;
  bool has_packed_mips; 
 
  TextureMemoryRanges memory;
  TextureExtent extent; 
 
  const FormatInfo* GetFormatInfo() const { return FormatInfo::Get(static_cast<u32>(format)); }
 
  bool IsCompressed() const { return GetFormatInfo()->type == FormatType::kCompressed; }
 
  u32 GetMipLevels() const { return 1 + (mip_max_level - mip_min_level); }

  static bool FromFetchConstant(const xenos::TextureFetch& fetch, TextureInfo* out_info);

  static bool FromResolve(u32 physical_address, xenos::TextureFormat texture_format,
                          xenos::Endian endian, u32 pitch, u32 width, u32 height, u32 depth,
                          TextureInfo* out_info);

  u32 GetMaxMipLevels() const;

  const TextureExtent GetMipExtent(u32 mip, bool is_guest) const;

  void GetMipSize(u32 mip, u32* width, u32* height) const;

  u32 GetMipLocation(u32 mip, u32* offset_x, u32* offset_y, bool is_guest) const;

  static bool GetPackedMipOffset(u32 width, u32 height, const FormatInfo* format_info,
                                 u32 packed_tile, u32* offset_x, u32* offset_y);

  bool GetPackedMipOffset(u32 packed_tile, u32* offset_x, u32* offset_y) const;

  u64 Hash() const;
 
  bool operator==(const TextureInfo& other) const = default;
 
 private:
  void SetupMemoryRanges(u32 base_address, u32 mip_address);
};
 
}  // namespace rex::xenos
 
namespace rex::xenos {

using CopyBlockCallback = std::function<void(xenos::Endian, void*, const void*, size_t)>;

void CopySwapBlock(xenos::Endian endian, void* output, const void* input, size_t length);

void ConvertTexelCTX1ToR8G8(xenos::Endian endian, void* output, const void* input,
                            size_t output_pitch);

void ConvertTexelDXT3AToDXT3(xenos::Endian endian, void* output, const void* input, size_t length);
 
using UntileCopyBlockCallback = std::function<void(void*, const void*, size_t)>;
 
struct UntileRegion {
  u32 offset_x;     
  u32 offset_y;     
  u32 width;        
  u32 height;       
  u32 input_pitch;  
  u32 output_pitch; 
  const FormatInfo* input_format_info;
  const FormatInfo* output_format_info;
  UntileCopyBlockCallback copy_callback;
};

void Untile(u8* output_buffer, const u8* input_buffer, const UntileRegion* untile_info);
 
}  // namespace rex::xenos