format.h

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <bit>
 
#include <rex/assert.h>
#include <rex/platform.h>
#include <rex/types.h>
 
namespace rex::xenos {

// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class Endian : u32 {
  kNone = 0,
  k8in16 = 1,  
  k8in32 = 2,  
  k16in32 = 3, 
};

// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class Endian128 : u32 {
  kNone = 0,
  k8in16 = 1,  
  k8in32 = 2,  
  k16in32 = 3, 
  k8in64 = 4,  
  k8in128 = 5, 
};
 
// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class IndexFormat : u32 {
  kInt16,
  kInt32,
};
 
// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class SurfaceNumberFormat : u32 {
  kUnsignedRepeatingFraction = 0, 
  kSignedRepeatingFraction = 1,   
  kUnsignedInteger = 2,
  kSignedInteger = 3,
  kFloat = 7,
};
 
// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class ColorRenderTargetFormat : u32 {
  k_8_8_8_8 = 0,          
  k_8_8_8_8_GAMMA = 1,    
  k_2_10_10_10 = 2,       
  k_2_10_10_10_FLOAT = 3, 
  k_16_16 = 4,            
  k_16_16_16_16 = 5,      
  k_16_16_FLOAT = 6,
  k_16_16_16_16_FLOAT = 7,
  k_2_10_10_10_AS_10_10_10_10 = 10,       
  k_2_10_10_10_FLOAT_AS_16_16_16_16 = 12, 
  k_32_FLOAT = 14,
  k_32_32_FLOAT = 15,
};

const char* GetColorRenderTargetFormatName(ColorRenderTargetFormat format);

constexpr bool IsColorRenderTargetFormat64bpp(ColorRenderTargetFormat format) {
  return format == ColorRenderTargetFormat::k_16_16_16_16 ||
         format == ColorRenderTargetFormat::k_16_16_16_16_FLOAT ||
         format == ColorRenderTargetFormat::k_32_32_FLOAT;
}

inline u32 GetColorRenderTargetFormatComponentCount(ColorRenderTargetFormat format) {
  switch (format) {
    case ColorRenderTargetFormat::k_8_8_8_8:
    case ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
    case ColorRenderTargetFormat::k_2_10_10_10:
    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT:
    case ColorRenderTargetFormat::k_16_16_16_16:
    case ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
    case ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
      return 4;
    case ColorRenderTargetFormat::k_16_16:
    case ColorRenderTargetFormat::k_16_16_FLOAT:
    case ColorRenderTargetFormat::k_32_32_FLOAT:
      return 2;
    case ColorRenderTargetFormat::k_32_FLOAT:
      return 1;
    default:
      REX_UNHANDLED_CASE(format);
      return 0;
  }
}

constexpr ColorRenderTargetFormat GetStorageColorFormat(ColorRenderTargetFormat format) {
  switch (format) {
    case ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
      return ColorRenderTargetFormat::k_2_10_10_10;
    case ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16:
      return ColorRenderTargetFormat::k_2_10_10_10_FLOAT;
    default:
      return format;
  }
}
 
// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class DepthRenderTargetFormat : u32 {
  kD24S8 = 0,  
  kD24FS8 = 1, 
};

const char* GetDepthRenderTargetFormatName(DepthRenderTargetFormat format);

f32 PWLGammaToLinear(f32 gamma);

f32 LinearToPWLGamma(f32 linear);

f32 Float7e3To32(u32 f10);

u32 Float32To20e4(f32 value, bool round_to_nearest_even);

f32 Float20e4To32(u32 f24);

constexpr f32 UNorm24To32(u32 n24) {
  return static_cast<f32>(n24 + (n24 >> 23)) * (1.0f / static_cast<f32>(1 << 24));
}
 
constexpr u32 kColorRenderTargetFormatBits = 4;
constexpr u32 kDepthRenderTargetFormatBits = 1;
constexpr u32 kRenderTargetFormatBits =
    std::max(kColorRenderTargetFormatBits, kDepthRenderTargetFormatBits);
 
constexpr u32 kFormatBits = 6;
 
// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class TextureFormat : u32 {
  k_1_REVERSE = 0, 
  k_1 = 1,
  k_8 = 2,
  k_1_5_5_5 = 3,
  k_5_6_5 = 4,
  k_6_5_5 = 5,
  k_8_8_8_8 = 6,
  k_2_10_10_10 = 7,
  k_8_A = 8, 
  k_8_B = 9, 
  k_8_8 = 10,
  k_Cr_Y1_Cb_Y0_REP = 11, 
  k_Y1_Cr_Y0_Cb_REP = 12, 
  k_16_16_EDRAM = 13,
  k_8_8_8_8_A = 14, 
  k_4_4_4_4 = 15,
  k_10_11_11 = 16,
  k_11_11_10 = 17,
  k_DXT1 = 18,
  k_DXT2_3 = 19,
  k_DXT4_5 = 20,
  k_16_16_16_16_EDRAM = 21,
  k_24_8 = 22,       
  k_24_8_FLOAT = 23, 
  k_16 = 24,
  k_16_16 = 25,
  k_16_16_16_16 = 26,
  k_16_EXPAND = 27,
  k_16_16_EXPAND = 28,
  k_16_16_16_16_EXPAND = 29,
  k_16_FLOAT = 30,
  k_16_16_FLOAT = 31,
  k_16_16_16_16_FLOAT = 32,
  k_32 = 33,
  k_32_32 = 34,
  k_32_32_32_32 = 35,
  k_32_FLOAT = 36,
  k_32_32_FLOAT = 37,
  k_32_32_32_32_FLOAT = 38,
  k_32_AS_8 = 39,
  k_32_AS_8_8 = 40,
  k_16_MPEG = 41,
  k_16_16_MPEG = 42,
  k_8_INTERLACED = 43,
  k_32_AS_8_INTERLACED = 44,
  k_32_AS_8_8_INTERLACED = 45,
  k_16_INTERLACED = 46,
  k_16_MPEG_INTERLACED = 47,
  k_16_16_MPEG_INTERLACED = 48,
  k_DXN = 49, 
  k_8_8_8_8_AS_16_16_16_16 = 50,
  k_DXT1_AS_16_16_16_16 = 51,
  k_DXT2_3_AS_16_16_16_16 = 52,
  k_DXT4_5_AS_16_16_16_16 = 53,
  k_2_10_10_10_AS_16_16_16_16 = 54,
  k_10_11_11_AS_16_16_16_16 = 55,
  k_11_11_10_AS_16_16_16_16 = 56,
  k_32_32_32_FLOAT = 57,
  k_DXT3A = 58,
  k_DXT5A = 59,
  k_CTX1 = 60, 
  k_DXT3A_AS_1_1_1_1 = 61,
  k_8_8_8_8_GAMMA_EDRAM = 62,
  k_2_10_10_10_FLOAT_EDRAM = 63, 
};

// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class ColorFormat : u32 {
  k_8 = 2,
  k_1_5_5_5 = 3,
  k_5_6_5 = 4,
  k_6_5_5 = 5,
  k_8_8_8_8 = 6,
  k_2_10_10_10 = 7,
  k_8_A = 8,
  k_8_B = 9,
  k_8_8 = 10,
  k_8_8_8_8_A = 14,
  k_4_4_4_4 = 15,
  k_10_11_11 = 16,
  k_11_11_10 = 17,
  k_16 = 24,
  k_16_16 = 25,
  k_16_16_16_16 = 26,
  k_16_FLOAT = 30,
  k_16_16_FLOAT = 31,
  k_16_16_16_16_FLOAT = 32,
  k_32_FLOAT = 36,
  k_32_32_FLOAT = 37,
  k_32_32_32_32_FLOAT = 38,
  k_8_8_8_8_AS_16_16_16_16 = 50,
  k_2_10_10_10_AS_16_16_16_16 = 54,
  k_10_11_11_AS_16_16_16_16 = 55,
  k_11_11_10_AS_16_16_16_16 = 56,
};

constexpr bool IsColorResolveFormatBitwiseEquivalent(ColorRenderTargetFormat render_target_format,
                                                     ColorFormat color_format) {
  switch (render_target_format) {
    case ColorRenderTargetFormat::k_8_8_8_8:
    case ColorRenderTargetFormat::k_8_8_8_8_GAMMA:
      return color_format == ColorFormat::k_8_8_8_8 || color_format == ColorFormat::k_8_8_8_8_A ||
             color_format == ColorFormat::k_8_8_8_8_AS_16_16_16_16;
    case ColorRenderTargetFormat::k_2_10_10_10:
    case ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10:
      return color_format == ColorFormat::k_2_10_10_10 ||
             color_format == ColorFormat::k_2_10_10_10_AS_16_16_16_16;
    case ColorRenderTargetFormat::k_16_16_FLOAT:
      return color_format == ColorFormat::k_16_16_FLOAT;
    case ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
      return color_format == ColorFormat::k_16_16_16_16_FLOAT;
    case ColorRenderTargetFormat::k_32_FLOAT:
      return color_format == ColorFormat::k_32_FLOAT;
    case ColorRenderTargetFormat::k_32_32_FLOAT:
      return color_format == ColorFormat::k_32_32_FLOAT;
    default:
      return false;
  }
}
 
// NOLINTNEXTLINE(performance-enum-size): Xenos bit field, MSVC packs per type
enum class VertexFormat : u32 {
  kUndefined = 0,
  k_8_8_8_8 = 6,
  k_2_10_10_10 = 7,
  k_10_11_11 = 16,
  k_11_11_10 = 17,
  k_16_16 = 25,
  k_16_16_16_16 = 26,
  k_16_16_FLOAT = 31,
  k_16_16_16_16_FLOAT = 32,
  k_32 = 33,
  k_32_32 = 34,
  k_32_32_32_32 = 35,
  k_32_FLOAT = 36,
  k_32_32_FLOAT = 37,
  k_32_32_32_32_FLOAT = 38,
  k_32_32_32_FLOAT = 57,
};

inline int GetVertexFormatComponentCount(VertexFormat format) {
  switch (format) {
    case VertexFormat::k_32:
    case VertexFormat::k_32_FLOAT:
      return 1;
    case VertexFormat::k_16_16:
    case VertexFormat::k_16_16_FLOAT:
    case VertexFormat::k_32_32:
    case VertexFormat::k_32_32_FLOAT:
      return 2;
    case VertexFormat::k_10_11_11:
    case VertexFormat::k_11_11_10:
    case VertexFormat::k_32_32_32_FLOAT:
      return 3;
    case VertexFormat::k_8_8_8_8:
    case VertexFormat::k_2_10_10_10:
    case VertexFormat::k_16_16_16_16:
    case VertexFormat::k_16_16_16_16_FLOAT:
    case VertexFormat::k_32_32_32_32:
    case VertexFormat::k_32_32_32_32_FLOAT:
      return 4;
    default:
      REX_UNHANDLED_CASE(format);
      return 0;
  }
}

inline u32 GetVertexFormatNeededWords(VertexFormat format, u32 used_components) {
  REX_ASSERT((used_components & ~static_cast<u32>(0b1111)) == 0);
  if (!used_components) {
    return 0;
  }
  switch (format) {
    case VertexFormat::k_8_8_8_8:
    case VertexFormat::k_2_10_10_10:
      return 0b0001;
    case VertexFormat::k_10_11_11:
    case VertexFormat::k_11_11_10:
      return (used_components & 0b0111) ? 0b0001 : 0b0000;
    case VertexFormat::k_16_16:
    case VertexFormat::k_16_16_FLOAT:
      return (used_components & 0b0011) ? 0b0001 : 0b0000;
    case VertexFormat::k_16_16_16_16:
    case VertexFormat::k_16_16_16_16_FLOAT:
      return ((used_components & 0b0011) ? 0b0001 : 0b0000) |
             ((used_components & 0b1100) ? 0b0010 : 0b0000);
    case VertexFormat::k_32:
    case VertexFormat::k_32_FLOAT:
      return used_components & 0b0001;
    case VertexFormat::k_32_32:
    case VertexFormat::k_32_32_FLOAT:
      return used_components & 0b0011;
    case VertexFormat::k_32_32_32_32:
    case VertexFormat::k_32_32_32_32_FLOAT:
      return used_components;
    case VertexFormat::k_32_32_32_FLOAT:
      return used_components & 0b0111;
    default:
      REX_UNHANDLED_CASE(format);
      return 0b0000;
  }
}

inline u16 GPUSwap(u16 value, Endian endianness) {
  switch (endianness) {
    case Endian::kNone:
      return value;
    case Endian::k8in16:
      return ((value << 8) & 0xFF00FF00) | ((value >> 8) & 0x00FF00FF);
    default:
      REX_UNHANDLED_CASE(endianness);
      return value;
  }
}
 
inline u32 GPUSwap(u32 value, Endian endianness) {
  switch (endianness) {
    default:
    case Endian::kNone:
      return value;
    case Endian::k8in16:
      return ((value << 8) & 0xFF00FF00) | ((value >> 8) & 0x00FF00FF);
    case Endian::k8in32:
      return std::byteswap(value);
    case Endian::k16in32:
      return ((value >> 16) & 0xFFFF) | (value << 16);
  }
}

inline f32 GPUSwap(f32 value, Endian endianness) {
  union {
    u32 i;
    f32 f;
  } v;
  v.f = value;
  v.i = GPUSwap(v.i, endianness);
  return v.f;
}

inline u32 GPUToCPU(u32 p) {
  return p;
}

inline u32 CPUToGPU(u32 p) {
  return p & 0x1FFFFFFF;
}

inline u16 FloatToHalf(f32 value, bool preserve_denormal = false,
                       bool round_to_nearest_even = false) {
  u32 integer_value = std::bit_cast<u32>(value);
  u32 abs_value = integer_value & 0x7FFFFFFFu;
  u32 result;
  if (abs_value >= 0x47FFE000u) {
    result = 0x7FFFu;
  } else {
    if (abs_value < 0x38800000u) {
      if (preserve_denormal) {
        u32 shift = std::min(static_cast<u32>(113u - (abs_value >> 23u)), static_cast<u32>(24u));
        result = (0x800000u | (abs_value & 0x7FFFFFu)) >> shift;
      } else {
        result = 0u;
      }
    } else {
      result = abs_value + 0xC8000000u;
    }
    if (round_to_nearest_even) {
      result += 0xFFFu + ((result >> 13u) & 1u);
    }
    result = (result >> 13u) & 0x7FFFu;
  }
  return static_cast<u16>(result | ((integer_value & 0x80000000u) >> 16u));
}

inline f32 HalfToFloat(u16 value, bool preserve_denormal = false) {
  u32 mantissa = value & 0x3FFu;
  u32 exponent = (value >> 10u) & 0x1Fu;
  if (!exponent) {
    if (!preserve_denormal) {
      mantissa = 0;
    } else if (mantissa) {
      u32 mantissa_lzcnt = static_cast<u32>(std::countl_zero(mantissa)) - (32u - 11u);
      exponent = static_cast<u32>(1 - static_cast<i32>(mantissa_lzcnt));
      mantissa = (mantissa << mantissa_lzcnt) & 0x3FFu;
    }
    if (!mantissa) {
      exponent = static_cast<u32>(-112);
    }
  }
  u32 result =
      (static_cast<u32>(value & 0x8000u) << 16u) | ((exponent + 112u) << 23u) | (mantissa << 13u);
  return std::bit_cast<f32>(result);
}
 
}  // namespace rex::xenos