/**
 ******************************************************************************
 * Xenia : Xbox 360 Emulator Research Project                                 *
 ******************************************************************************
 * Copyright 2018 Ben Vanik. All rights reserved.                             *
 * Released under the BSD license - see LICENSE in the root for more details. *
 ******************************************************************************
 */

#include "xenia/gpu/dxbc_shader_translator.h"

#include <cstdint>

#include "xenia/base/assert.h"
#include "xenia/base/math.h"
#include "xenia/gpu/draw_util.h"

namespace xe {
namespace gpu {
using namespace ucode;

void DxbcShaderTranslator::ROV_GetColorFormatSystemConstants(
    xenos::ColorRenderTargetFormat format, uint32_t write_mask,
    float& clamp_rgb_low, float& clamp_alpha_low, float& clamp_rgb_high,
    float& clamp_alpha_high, uint32_t& keep_mask_low,
    uint32_t& keep_mask_high) {
  keep_mask_low = keep_mask_high = 0;
  switch (format) {
    case xenos::ColorRenderTargetFormat::k_8_8_8_8:
    case xenos::ColorRenderTargetFormat::k_8_8_8_8_GAMMA: {
      clamp_rgb_low = clamp_alpha_low = 0.0f;
      clamp_rgb_high = clamp_alpha_high = 1.0f;
      for (uint32_t i = 0; i < 4; ++i) {
        if (!(write_mask & (1 << i))) {
          keep_mask_low |= uint32_t(0xFF) << (i * 8);
        }
      }
    } break;
    case xenos::ColorRenderTargetFormat::k_2_10_10_10:
    case xenos::ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10: {
      clamp_rgb_low = clamp_alpha_low = 0.0f;
      clamp_rgb_high = clamp_alpha_high = 1.0f;
      for (uint32_t i = 0; i < 3; ++i) {
        if (!(write_mask & (1 << i))) {
          keep_mask_low |= uint32_t(0x3FF) << (i * 10);
        }
      }
      if (!(write_mask & 0b1000)) {
        keep_mask_low |= uint32_t(3) << 30;
      }
    } break;
    case xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT:
    case xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16: {
      clamp_rgb_low = clamp_alpha_low = 0.0f;
      clamp_rgb_high = 31.875f;
      clamp_alpha_high = 1.0f;
      for (uint32_t i = 0; i < 3; ++i) {
        if (!(write_mask & (1 << i))) {
          keep_mask_low |= uint32_t(0x3FF) << (i * 10);
        }
      }
      if (!(write_mask & 0b1000)) {
        keep_mask_low |= uint32_t(3) << 30;
      }
    } break;
    case xenos::ColorRenderTargetFormat::k_16_16:
    case xenos::ColorRenderTargetFormat::k_16_16_16_16:
      // Alpha clamping affects blending source, so it's non-zero for alpha for
      // k_16_16 (the render target is fixed-point). There's one deviation from
      // how Direct3D 11.3 functional specification defines SNorm conversion
      // (NaN should be 0, not the lowest negative number), but NaN handling in
      // output shouldn't be very important.
      clamp_rgb_low = clamp_alpha_low = -32.0f;
      clamp_rgb_high = clamp_alpha_high = 32.0f;
      if (!(write_mask & 0b0001)) {
        keep_mask_low |= 0xFFFFu;
      }
      if (!(write_mask & 0b0010)) {
        keep_mask_low |= 0xFFFF0000u;
      }
      if (format == xenos::ColorRenderTargetFormat::k_16_16_16_16) {
        if (!(write_mask & 0b0100)) {
          keep_mask_high |= 0xFFFFu;
        }
        if (!(write_mask & 0b1000)) {
          keep_mask_high |= 0xFFFF0000u;
        }
      } else {
        write_mask &= 0b0011;
      }
      break;
    case xenos::ColorRenderTargetFormat::k_16_16_FLOAT:
    case xenos::ColorRenderTargetFormat::k_16_16_16_16_FLOAT:
      // No NaNs on the Xbox 360 GPU, though can't use the extended range with
      // f32tof16.
      clamp_rgb_low = clamp_alpha_low = -65504.0f;
      clamp_rgb_high = clamp_alpha_high = 65504.0f;
      if (!(write_mask & 0b0001)) {
        keep_mask_low |= 0xFFFFu;
      }
      if (!(write_mask & 0b0010)) {
        keep_mask_low |= 0xFFFF0000u;
      }
      if (format == xenos::ColorRenderTargetFormat::k_16_16_16_16_FLOAT) {
        if (!(write_mask & 0b0100)) {
          keep_mask_high |= 0xFFFFu;
        }
        if (!(write_mask & 0b1000)) {
          keep_mask_high |= 0xFFFF0000u;
        }
      } else {
        write_mask &= 0b0011;
      }
      break;
    case xenos::ColorRenderTargetFormat::k_32_FLOAT:
      // No clamping - let min/max always pick the original value.
      clamp_rgb_low = clamp_alpha_low = clamp_rgb_high = clamp_alpha_high =
          std::nanf("");
      write_mask &= 0b0001;
      if (!(write_mask & 0b0001)) {
        keep_mask_low = ~uint32_t(0);
      }
      break;
    case xenos::ColorRenderTargetFormat::k_32_32_FLOAT:
      // No clamping - let min/max always pick the original value.
      clamp_rgb_low = clamp_alpha_low = clamp_rgb_high = clamp_alpha_high =
          std::nanf("");
      write_mask &= 0b0011;
      if (!(write_mask & 0b0001)) {
        keep_mask_low = ~uint32_t(0);
      }
      if (!(write_mask & 0b0010)) {
        keep_mask_high = ~uint32_t(0);
      }
      break;
    default:
      assert_unhandled_case(format);
      // Disable invalid render targets.
      write_mask = 0;
      break;
  }
  // Special case handled in the shaders for empty write mask to completely skip
  // a disabled render target: all keep bits are set.
  if (!write_mask) {
    keep_mask_low = keep_mask_high = ~uint32_t(0);
  }
}

void DxbcShaderTranslator::StartPixelShader_LoadROVParameters() {
  bool any_color_targets_written = current_shader().writes_color_targets() != 0;

  // ***************************************************************************
  // Get EDRAM offsets for the pixel:
  // system_temp_rov_params_.y - for depth (absolute).
  // system_temp_rov_params_.z - for 32bpp color (base-relative).
  // system_temp_rov_params_.w - for 64bpp color (base-relative).
  // ***************************************************************************

  uint32_t resolution_scale_host_pixel_temp = UINT32_MAX;
  if (draw_resolution_scale_ > 1) {
    // Convert the host pixel position to integer to
    // resolution_scale_host_pixel_temp.xy.
    // resolution_scale_host_pixel_temp.x = X host pixel position as uint
    // resolution_scale_host_pixel_temp.y = Y host pixel position as uint
    resolution_scale_host_pixel_temp = PushSystemTemp();
    in_position_used_ |= 0b0011;
    a_.OpFToU(dxbc::Dest::R(resolution_scale_host_pixel_temp, 0b0011),
              dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition)));
    // Revert the resolution scale to convert the position to guest pixels.
    // system_temp_rov_params_.z = X guest pixel position / sample width
    // system_temp_rov_params_.w = Y guest pixel position / sample height
    // Also, get the linear host pixel index within the guest pixel.
    // resolution_scale_host_pixel_temp.x = host pixel linear index
    switch (draw_resolution_scale_) {
      case 2:
        // Guest pixel index.
        a_.OpUShR(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
                  dxbc::Src::R(resolution_scale_host_pixel_temp, 0b0100 << 4),
                  dxbc::Src::LU(1));
        // Host pixel index within the guest pixel.
        a_.OpAnd(
            dxbc::Dest::R(resolution_scale_host_pixel_temp, 0b0001),
            dxbc::Src::R(resolution_scale_host_pixel_temp, dxbc::Src::kXXXX),
            dxbc::Src::LU(1));
        a_.OpBFI(
            dxbc::Dest::R(resolution_scale_host_pixel_temp, 0b0001),
            dxbc::Src::LU(1), dxbc::Src::LU(1),
            dxbc::Src::R(resolution_scale_host_pixel_temp, dxbc::Src::kYYYY),
            dxbc::Src::R(resolution_scale_host_pixel_temp, dxbc::Src::kXXXX));
        break;
      case 3:
        // Guest pixel index.
        a_.OpUMul(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
                  dxbc::Dest::Null(),
                  dxbc::Src::R(resolution_scale_host_pixel_temp, 0b0100 << 4),
                  dxbc::Src::LU(draw_util::kDivideScale3));
        a_.OpUShR(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
                  dxbc::Src::R(system_temp_rov_params_),
                  dxbc::Src::LU(draw_util::kDivideUpperShift3));
        // Host pixel index.
        a_.OpIMAd(dxbc::Dest::R(resolution_scale_host_pixel_temp, 0b0011),
                  dxbc::Src::R(system_temp_rov_params_, 0b1110),
                  dxbc::Src::LI(-3),
                  dxbc::Src::R(resolution_scale_host_pixel_temp));
        a_.OpUMAd(
            dxbc::Dest::R(resolution_scale_host_pixel_temp, 0b0001),
            dxbc::Src::R(resolution_scale_host_pixel_temp, dxbc::Src::kYYYY),
            dxbc::Src::LU(3),
            dxbc::Src::R(resolution_scale_host_pixel_temp, dxbc::Src::kXXXX));
        break;
      default:
        assert_unhandled_case(draw_resolution_scale_);
    }
  } else {
    // Convert the host pixel position to integer to system_temp_rov_params_.zw.
    // system_temp_rov_params_.z = X host pixel position as uint
    // system_temp_rov_params_.w = Y host pixel position as uint
    in_position_used_ |= 0b0011;
    a_.OpFToU(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
              dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition), 0b01000000));
  }
  // Convert the position from pixels to samples.
  // system_temp_rov_params_.z = X guest sample 0 position
  // system_temp_rov_params_.w = Y guest sample 0 position
  system_constants_used_ |= 1ull << kSysConst_SampleCountLog2_Index;
  a_.OpIShL(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
            dxbc::Src::R(system_temp_rov_params_),
            dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_SampleCountLog2_Vec,
                          (kSysConst_SampleCountLog2_Comp << 4) |
                              ((kSysConst_SampleCountLog2_Comp + 1) << 6)));
  // Get 80x16 samples tile index - start dividing X by 80 by getting the high
  // part of the result of multiplication of X by kDivideScale5 into X.
  // system_temp_rov_params_.x = (X * kDivideScale5) >> 32
  // system_temp_rov_params_.z = X guest sample 0 position
  // system_temp_rov_params_.w = Y guest sample 0 position
  a_.OpUMul(dxbc::Dest::R(system_temp_rov_params_, 0b0001), dxbc::Dest::Null(),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
            dxbc::Src::LU(draw_util::kDivideScale5));
  // Get 80x16 samples tile index - finish dividing X by 80 and divide Y by 16
  // into system_temp_rov_params_.xy.
  // system_temp_rov_params_.x = X tile position
  // system_temp_rov_params_.y = Y tile position
  // system_temp_rov_params_.z = X guest sample 0 position
  // system_temp_rov_params_.w = Y guest sample 0 position
  a_.OpUShR(dxbc::Dest::R(system_temp_rov_params_, 0b0011),
            dxbc::Src::R(system_temp_rov_params_, 0b00001100),
            dxbc::Src::LU(draw_util::kDivideUpperShift5 + 4, 4, 0, 0));
  // Get the tile index to system_temp_rov_params_.y.
  // system_temp_rov_params_.x = X tile position
  // system_temp_rov_params_.y = tile index
  // system_temp_rov_params_.z = X guest sample 0 position
  // system_temp_rov_params_.w = Y guest sample 0 position
  system_constants_used_ |= 1ull << kSysConst_EdramPitchTiles_Index;
  a_.OpUMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
            dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramPitchTiles_Vec)
                .Select(kSysConst_EdramPitchTiles_Comp),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX));
  // Convert the tile index into a tile offset.
  // system_temp_rov_params_.x = X tile position
  // system_temp_rov_params_.y = tile offset
  // system_temp_rov_params_.z = X guest sample 0 position
  // system_temp_rov_params_.w = Y guest sample 0 position
  a_.OpUMul(dxbc::Dest::Null(), dxbc::Dest::R(system_temp_rov_params_, 0b0010),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
            dxbc::Src::LU(1280));
  // Get tile-local X sample index into system_temp_rov_params_.z.
  // system_temp_rov_params_.y = tile offset
  // system_temp_rov_params_.z = X sample 0 position within the tile
  // system_temp_rov_params_.w = Y guest sample 0 position
  a_.OpIMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0100),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
            dxbc::Src::LI(-80),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ));
  // Get tile-local Y sample index into system_temp_rov_params_.w.
  // system_temp_rov_params_.y = tile offset
  // system_temp_rov_params_.z = X sample 0 position within the tile
  // system_temp_rov_params_.w = Y sample 0 position within the tile
  a_.OpAnd(dxbc::Dest::R(system_temp_rov_params_, 0b1000),
           dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
           dxbc::Src::LU(15));
  // Go to the target row within the tile in system_temp_rov_params_.y.
  // system_temp_rov_params_.y = row offset
  // system_temp_rov_params_.z = X sample 0 position within the tile
  a_.OpIMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
            dxbc::Src::LI(80),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY));
  // Choose in which 40-sample half of the tile the pixel is, for swapping
  // 40-sample columns when accessing the depth buffer - games expect this
  // behavior when writing depth back to the EDRAM via color writing (GTA IV,
  // Halo 3).
  // system_temp_rov_params_.x = tile-local sample 0 X >= 40
  // system_temp_rov_params_.y = row offset
  // system_temp_rov_params_.z = X sample 0 position within the tile
  a_.OpUGE(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
           dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
           dxbc::Src::LU(40));
  // Choose what to add to the depth/stencil X position.
  // system_temp_rov_params_.x = 40 or -40 offset for the depth buffer
  // system_temp_rov_params_.y = row offset
  // system_temp_rov_params_.z = X sample 0 position within the tile
  a_.OpMovC(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
            dxbc::Src::LI(-40), dxbc::Src::LI(40));
  // Flip tile halves for the depth/stencil buffer.
  // system_temp_rov_params_.x = X sample 0 position within the depth tile
  // system_temp_rov_params_.y = row offset
  // system_temp_rov_params_.z = X sample 0 position within the tile
  a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX));
  if (any_color_targets_written) {
    // Write 32bpp color offset to system_temp_rov_params_.z.
    // system_temp_rov_params_.x = X sample 0 position within the depth tile
    // system_temp_rov_params_.y = row offset
    // system_temp_rov_params_.z = unscaled 32bpp color offset
    a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0100),
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ));
  }
  // Write depth/stencil offset to system_temp_rov_params_.y.
  // system_temp_rov_params_.y = unscaled 32bpp depth/stencil offset
  // system_temp_rov_params_.z = unscaled 32bpp color offset if needed
  a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX));
  // Add the EDRAM base for depth/stencil.
  // system_temp_rov_params_.y = unscaled 32bpp depth/stencil address
  // system_temp_rov_params_.z = unscaled 32bpp color offset if needed
  system_constants_used_ |= 1ull << kSysConst_EdramDepthBaseDwords_Index;
  a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
            dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramDepthBaseDwords_Vec)
                .Select(kSysConst_EdramDepthBaseDwords_Comp));
  if (draw_resolution_scale_ > 1) {
    assert_true(resolution_scale_host_pixel_temp != UINT32_MAX);
    // Apply the resolution scale and the host pixel offset within the guest
    // sample.
    // system_temp_rov_params_.y = scaled 32bpp depth/stencil first host pixel
    //                             address
    // system_temp_rov_params_.z = scaled 32bpp color first host pixel offset if
    //                             needed
    a_.OpUMAd(dxbc::Dest::R(system_temp_rov_params_,
                            any_color_targets_written ? 0b0110 : 0b0010),
              dxbc::Src::R(system_temp_rov_params_),
              dxbc::Src::LU(draw_resolution_scale_ * draw_resolution_scale_),
              dxbc::Src::R(resolution_scale_host_pixel_temp, dxbc::Src::kXXXX));
    // Release resolution_scale_host_pixel_temp.
    PopSystemTemp();
  } else {
    assert_true(resolution_scale_host_pixel_temp == UINT32_MAX);
  }
  if (any_color_targets_written) {
    // Get the 64bpp color offset to system_temp_rov_params_.w.
    // TODO(Triang3l): Find some game that aliases 64bpp with 32bpp to emulate
    // the real layout.
    // system_temp_rov_params_.y = scaled 32bpp depth/stencil address
    // system_temp_rov_params_.z = scaled 32bpp color offset
    // system_temp_rov_params_.w = scaled 64bpp color offset
    a_.OpIShL(dxbc::Dest::R(system_temp_rov_params_, 0b1000),
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
              dxbc::Src::LU(1));
  }

  // ***************************************************************************
  // Sample coverage to system_temp_rov_params_.x.
  // ***************************************************************************

  // Using ForcedSampleCount of 4 (2 is not supported on Nvidia), so for 2x
  // MSAA, handling samples 0 and 3 (upper-left and lower-right) as 0 and 1.

  // Check if 4x MSAA is enabled.
  system_constants_used_ |= 1ull << kSysConst_SampleCountLog2_Index;
  a_.OpIf(true, dxbc::Src::CB(cbuffer_index_system_constants_,
                              uint32_t(CbufferRegister::kSystemConstants),
                              kSysConst_SampleCountLog2_Vec)
                    .Select(kSysConst_SampleCountLog2_Comp));
  {
    // Copy the 4x AA coverage to system_temp_rov_params_.x, making top-right
    // the sample [2] and bottom-left the sample [1] (the opposite of Direct3D
    // 12), because on the Xbox 360, 2x MSAA doubles the storage width, 4x MSAA
    // doubles the storage height.
    // Flip samples in bits 0:1 to bits 29:30.
    a_.OpBFRev(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
               dxbc::Src::VCoverage());
    a_.OpUShR(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
              dxbc::Src::LU(29));
    a_.OpBFI(dxbc::Dest::R(system_temp_rov_params_, 0b0001), dxbc::Src::LU(2),
             dxbc::Src::LU(1),
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::VCoverage());
  }
  // Handle 1 or 2 samples.
  a_.OpElse();
  {
    // Extract sample 3 coverage, which will be used as sample 1.
    a_.OpUBFE(dxbc::Dest::R(system_temp_rov_params_, 0b0001), dxbc::Src::LU(1),
              dxbc::Src::LU(3), dxbc::Src::VCoverage());
    // Combine coverage of samples 0 (in bit 0 of vCoverage) and 3 (in bit 0 of
    // system_temp_rov_params_.x).
    a_.OpBFI(dxbc::Dest::R(system_temp_rov_params_, 0b0001), dxbc::Src::LU(31),
             dxbc::Src::LU(1),
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::VCoverage());
  }
  // Close the 4x MSAA conditional.
  a_.OpEndIf();
}

void DxbcShaderTranslator::ROV_DepthStencilTest() {
  uint32_t temp = PushSystemTemp();
  dxbc::Dest temp_x_dest(dxbc::Dest::R(temp, 0b0001));
  dxbc::Src temp_x_src(dxbc::Src::R(temp, dxbc::Src::kXXXX));
  dxbc::Dest temp_y_dest(dxbc::Dest::R(temp, 0b0010));
  dxbc::Src temp_y_src(dxbc::Src::R(temp, dxbc::Src::kYYYY));
  dxbc::Dest temp_z_dest(dxbc::Dest::R(temp, 0b0100));
  dxbc::Src temp_z_src(dxbc::Src::R(temp, dxbc::Src::kZZZZ));
  dxbc::Dest temp_w_dest(dxbc::Dest::R(temp, 0b1000));
  dxbc::Src temp_w_src(dxbc::Src::R(temp, dxbc::Src::kWWWW));

  // Check whether depth/stencil is enabled.
  // temp.x = kSysFlag_ROVDepthStencil
  system_constants_used_ |= 1ull << kSysConst_Flags_Index;
  a_.OpAnd(temp_x_dest,
           dxbc::Src::CB(cbuffer_index_system_constants_,
                         uint32_t(CbufferRegister::kSystemConstants),
                         kSysConst_Flags_Vec)
               .Select(kSysConst_Flags_Comp),
           dxbc::Src::LU(kSysFlag_ROVDepthStencil));
  // Open the depth/stencil enabled conditional.
  // temp.x = free
  a_.OpIf(true, temp_x_src);

  bool depth_stencil_early = ROV_IsDepthStencilEarly();
  bool shader_writes_depth = current_shader().writes_depth();

  for (uint32_t i = 0; i < 4; ++i) {
    // With early depth/stencil, depth/stencil writing may be deferred to the
    // end of the shader to prevent writing in case something (like alpha test,
    // which is dynamic GPU state) discards the pixel. So, write directly to the
    // persistent register, system_temp_depth_stencil_, instead of a local
    // temporary register.
    dxbc::Dest sample_depth_stencil_dest(
        depth_stencil_early ? dxbc::Dest::R(system_temp_depth_stencil_, 1 << i)
                            : temp_x_dest);
    dxbc::Src sample_depth_stencil_src(
        depth_stencil_early ? dxbc::Src::R(system_temp_depth_stencil_).Select(i)
                            : temp_x_src);

    if (!i) {
      if (shader_writes_depth) {
        // Convert the shader-generated depth to 24-bit, using temp.x as
        // temporary. oDepth is already written by StoreResult with saturation,
        // no need to clamp here. Adreno 200 doesn't have PA_SC_VPORT_ZMIN/ZMAX,
        // so likely there's no need to clamp to the viewport depth bounds.
        ROV_DepthTo24Bit(system_temp_depth_stencil_, 0,
                         system_temp_depth_stencil_, 0, temp, 0);
      } else {
        // Load the first sample's Z*W and W to temp.xy - need this regardless
        // of coverage for polygon offset.
        // temp.x = first sample's clip space Z*W
        // temp.y = first sample's clip space W
        a_.OpEvalSampleIndex(
            dxbc::Dest::R(temp, 0b0011),
            dxbc::Src::V(uint32_t(InOutRegister::kPSInClipSpaceZW)),
            dxbc::Src::LU(0));
        // Calculate the first sample's Z/W to temp.x for conversion to 24-bit
        // and depth test.
        // temp.x? = first sample's clip space Z
        // temp.y = free
        a_.OpDiv(sample_depth_stencil_dest, temp_x_src, temp_y_src, true);
        // Apply viewport Z range to the first sample because this would affect
        // the slope-scaled depth bias (tested on PC on Direct3D 12, by
        // comparing the fraction of the polygon's area with depth clamped -
        // affected by the constant bias, but not affected by the slope-scaled
        // bias, also depth range clamping should be done after applying the
        // offset as well).
        // temp.x? = first sample's viewport space Z
        system_constants_used_ |= 1ull << kSysConst_EdramDepthRange_Index;
        a_.OpMAd(sample_depth_stencil_dest, sample_depth_stencil_src,
                 dxbc::Src::CB(cbuffer_index_system_constants_,
                               uint32_t(CbufferRegister::kSystemConstants),
                               kSysConst_EdramDepthRange_Vec)
                     .Select(kSysConst_EdramDepthRangeScale_Comp),
                 dxbc::Src::CB(cbuffer_index_system_constants_,
                               uint32_t(CbufferRegister::kSystemConstants),
                               kSysConst_EdramDepthRange_Vec)
                     .Select(kSysConst_EdramDepthRangeOffset_Comp),
                 true);
        // Get the derivatives of a sample's depth, for the slope-scaled polygon
        // offset. Probably not very significant that it's for the sample 0
        // rather than for the center, likely neither is accurate because Xenos
        // probably calculates the slope between 16ths of a pixel according to
        // the meaning of the slope-scaled polygon offset in R5xx Acceleration.
        // temp.x? = first sample's viewport space Z
        // temp.y = ddx(z)
        // temp.z = ddy(z)
        a_.OpDerivRTXCoarse(temp_y_dest, sample_depth_stencil_src);
        a_.OpDerivRTYCoarse(temp_z_dest, sample_depth_stencil_src);
        // Get the maximum depth slope for polygon offset to temp.y.
        // https://docs.microsoft.com/en-us/windows/desktop/direct3d9/depth-bias
        // temp.x? = first sample's viewport space Z
        // temp.y = max(|ddx(z)|, |ddy(z)|)
        // temp.z = free
        a_.OpMax(temp_y_dest, temp_y_src.Abs(), temp_z_src.Abs());
        // Copy the needed polygon offset values to temp.zw.
        // temp.x? = first sample's viewport space Z
        // temp.y = max(|ddx(z)|, |ddy(z)|)
        // temp.z = polygon offset scale
        // temp.w = polygon offset bias
        in_front_face_used_ = true;
        system_constants_used_ |=
            (1ull << kSysConst_EdramPolyOffsetFront_Index) |
            (1ull << kSysConst_EdramPolyOffsetBack_Index);
        a_.OpMovC(
            dxbc::Dest::R(temp, 0b1100),
            dxbc::Src::V(uint32_t(InOutRegister::kPSInFrontFaceAndSampleIndex),
                         dxbc::Src::kXXXX),
            dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramPolyOffsetFront_Vec,
                          (kSysConst_EdramPolyOffsetFrontScale_Comp << 4) |
                              (kSysConst_EdramPolyOffsetFrontOffset_Comp << 6)),
            dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramPolyOffsetBack_Vec,
                          (kSysConst_EdramPolyOffsetBackScale_Comp << 4) |
                              (kSysConst_EdramPolyOffsetBackOffset_Comp << 6)));
        // Apply the slope scale and the constant bias to the offset.
        // temp.x? = first sample's viewport space Z
        // temp.y = polygon offset
        // temp.z = free
        // temp.w = free
        a_.OpMAd(temp_y_dest, temp_y_src, temp_z_src, temp_w_src);
        // Calculate the upper Z range bound to temp.z for clamping after
        // biasing.
        // temp.x? = first sample's viewport space Z
        // temp.y = polygon offset
        // temp.z = viewport maximum depth
        system_constants_used_ |= 1ull << kSysConst_EdramDepthRange_Index;
        a_.OpAdd(temp_z_dest,
                 dxbc::Src::CB(cbuffer_index_system_constants_,
                               uint32_t(CbufferRegister::kSystemConstants),
                               kSysConst_EdramDepthRange_Vec)
                     .Select(kSysConst_EdramDepthRangeOffset_Comp),
                 dxbc::Src::CB(cbuffer_index_system_constants_,
                               uint32_t(CbufferRegister::kSystemConstants),
                               kSysConst_EdramDepthRange_Vec)
                     .Select(kSysConst_EdramDepthRangeScale_Comp));
      }
    }

    // Get if the current sample is covered to temp.w.
    // temp.x = first sample's viewport space Z if not writing to oDepth
    // temp.y = polygon offset if not writing to oDepth
    // temp.z = viewport maximum depth if not writing to oDepth
    // temp.w = coverage of the current sample
    a_.OpAnd(temp_w_dest,
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::LU(1 << i));
    // Check if the current sample is covered. Release 1 VGPR.
    // temp.x = first sample's viewport space Z if not writing to oDepth
    // temp.y = polygon offset if not writing to oDepth
    // temp.z = viewport maximum depth if not writing to oDepth
    // temp.w = free
    a_.OpIf(true, temp_w_src);

    if (shader_writes_depth) {
      // Copy the 24-bit depth common to all samples to sample_depth_stencil.
      // temp.x = shader-generated 24-bit depth
      a_.OpMov(sample_depth_stencil_dest,
               dxbc::Src::R(system_temp_depth_stencil_, dxbc::Src::kXXXX));
    } else {
      if (i) {
        // Sample's depth precalculated for sample 0 (for slope-scaled depth
        // bias calculation), but need to calculate it for other samples.
        //
        // Reusing temp.x because it may contain the depth value for the first
        // sample, but it has been written already.
        //
        // For 2x:
        // Using ForcedSampleCount of 4 (2 is not supported on Nvidia), so for
        // 2x MSAA, handling samples 0 and 3 (upper-left and lower-right) as 0
        // and 1. Thus, evaluating Z/W at sample 3 when 4x is not enabled.
        //
        // For 4x:
        // Direct3D 12's sample pattern has 1 as top-right, 2 as bottom-left.
        // Xbox 360's render targets are 2x taller with 2x MSAA, 2x wider with
        // 4x, thus, likely 1 is bottom-left, 2 is top-right - swapping these.
        //
        // temp.x = sample's clip space Z*W
        // temp.y = polygon offset if not writing to oDepth
        // temp.z = viewport maximum depth if not writing to oDepth
        // temp.w = sample's clip space W
        if (i == 1) {
          system_constants_used_ |= 1ull << kSysConst_SampleCountLog2_Index;
          a_.OpMovC(sample_depth_stencil_dest,
                    dxbc::Src::CB(cbuffer_index_system_constants_,
                                  uint32_t(CbufferRegister::kSystemConstants),
                                  kSysConst_SampleCountLog2_Vec)
                        .Select(kSysConst_SampleCountLog2_Comp),
                    dxbc::Src::LU(3), dxbc::Src::LU(2));
          a_.OpEvalSampleIndex(
              dxbc::Dest::R(temp, 0b1001),
              dxbc::Src::V(uint32_t(InOutRegister::kPSInClipSpaceZW),
                           0b01000000),
              sample_depth_stencil_src);
        } else {
          a_.OpEvalSampleIndex(
              dxbc::Dest::R(temp, 0b1001),
              dxbc::Src::V(uint32_t(InOutRegister::kPSInClipSpaceZW),
                           0b01000000),
              dxbc::Src::LU(i == 2 ? 1 : i));
        }
        // Calculate Z/W for the current sample from the evaluated Z*W and W.
        // temp.x? = sample's clip space Z
        // temp.y = polygon offset if not writing to oDepth
        // temp.z = viewport maximum depth if not writing to oDepth
        // temp.w = free
        a_.OpDiv(sample_depth_stencil_dest, temp_x_src, temp_w_src, true);
        // Apply viewport Z range the same way as it was applied to sample 0.
        // temp.x? = sample's viewport space Z
        // temp.y = polygon offset if not writing to oDepth
        // temp.z = viewport maximum depth if not writing to oDepth
        system_constants_used_ |= 1ull << kSysConst_EdramDepthRange_Index;
        a_.OpMAd(sample_depth_stencil_dest, sample_depth_stencil_src,
                 dxbc::Src::CB(cbuffer_index_system_constants_,
                               uint32_t(CbufferRegister::kSystemConstants),
                               kSysConst_EdramDepthRange_Vec)
                     .Select(kSysConst_EdramDepthRangeScale_Comp),
                 dxbc::Src::CB(cbuffer_index_system_constants_,
                               uint32_t(CbufferRegister::kSystemConstants),
                               kSysConst_EdramDepthRange_Vec)
                     .Select(kSysConst_EdramDepthRangeOffset_Comp),
                 true);
      }
      // Add the bias to the depth of the sample.
      // temp.x? = sample's unclamped biased Z
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      a_.OpAdd(sample_depth_stencil_dest, sample_depth_stencil_src, temp_y_src);
      // Clamp the biased depth to the lower viewport depth bound.
      // temp.x? = sample's lower-clamped biased Z
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      system_constants_used_ |= 1ull << kSysConst_EdramDepthRange_Index;
      a_.OpMax(sample_depth_stencil_dest, sample_depth_stencil_src,
               dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_EdramDepthRange_Vec)
                   .Select(kSysConst_EdramDepthRangeOffset_Comp));
      // Clamp the biased depth to the upper viewport depth bound.
      // temp.x? = sample's biased Z
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      a_.OpMin(sample_depth_stencil_dest, sample_depth_stencil_src, temp_z_src,
               true);
      // Convert the sample's depth to 24-bit, using temp.w as a temporary.
      // temp.x? = sample's 24-bit Z
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      ROV_DepthTo24Bit(sample_depth_stencil_src.index_1d_.index_,
                       sample_depth_stencil_src.swizzle_ & 3,
                       sample_depth_stencil_src.index_1d_.index_,
                       sample_depth_stencil_src.swizzle_ & 3, temp, 3);
    }
    // Load the old depth/stencil value to temp.w.
    // temp.x? = sample's 24-bit Z
    // temp.y = polygon offset if not writing to oDepth
    // temp.z = viewport maximum depth if not writing to oDepth
    // temp.w = old depth/stencil
    if (uav_index_edram_ == kBindingIndexUnallocated) {
      uav_index_edram_ = uav_count_++;
    }
    a_.OpLdUAVTyped(
        temp_w_dest, dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY), 1,
        dxbc::Src::U(uav_index_edram_, uint32_t(UAVRegister::kEdram),
                     dxbc::Src::kXXXX));

    uint32_t sample_temp = PushSystemTemp();
    dxbc::Dest sample_temp_x_dest(dxbc::Dest::R(sample_temp, 0b0001));
    dxbc::Src sample_temp_x_src(dxbc::Src::R(sample_temp, dxbc::Src::kXXXX));
    dxbc::Dest sample_temp_y_dest(dxbc::Dest::R(sample_temp, 0b0010));
    dxbc::Src sample_temp_y_src(dxbc::Src::R(sample_temp, dxbc::Src::kYYYY));
    dxbc::Dest sample_temp_z_dest(dxbc::Dest::R(sample_temp, 0b0100));
    dxbc::Src sample_temp_z_src(dxbc::Src::R(sample_temp, dxbc::Src::kZZZZ));

    // Depth test.

    // Extract the old depth part to sample_depth_stencil.
    // sample_temp.x = old depth
    a_.OpUShR(sample_temp_x_dest, temp_w_src, dxbc::Src::LU(8));
    // Get the difference between the new and the old depth, > 0 - greater,
    // == 0 - equal, < 0 - less.
    // sample_temp.x = old depth
    // sample_temp.y = depth difference
    a_.OpIAdd(sample_temp_y_dest, sample_depth_stencil_src, -sample_temp_x_src);
    // Check if the depth is "less" or "greater or equal".
    // sample_temp.x = old depth
    // sample_temp.y = depth difference
    // sample_temp.z = depth difference less than 0
    a_.OpILT(sample_temp_z_dest, sample_temp_y_src, dxbc::Src::LI(0));
    // Choose the passed depth function bits for "less" or for "greater".
    // sample_temp.x = old depth
    // sample_temp.y = depth difference
    // sample_temp.z = depth function passed bits for "less" or "greater"
    a_.OpMovC(sample_temp_z_dest, sample_temp_z_src,
              dxbc::Src::LU(kSysFlag_ROVDepthPassIfLess),
              dxbc::Src::LU(kSysFlag_ROVDepthPassIfGreater));
    // Do the "equal" testing.
    // sample_temp.x = old depth
    // sample_temp.y = depth function passed bits
    // sample_temp.z = free
    a_.OpMovC(sample_temp_y_dest, sample_temp_y_src, sample_temp_z_src,
              dxbc::Src::LU(kSysFlag_ROVDepthPassIfEqual));
    // Mask the resulting bits with the ones that should pass.
    // sample_temp.x = old depth
    // sample_temp.y = masked depth function passed bits
    // sample_temp.z = free
    system_constants_used_ |= 1ull << kSysConst_Flags_Index;
    a_.OpAnd(sample_temp_y_dest, sample_temp_y_src,
             dxbc::Src::CB(cbuffer_index_system_constants_,
                           uint32_t(CbufferRegister::kSystemConstants),
                           kSysConst_Flags_Vec)
                 .Select(kSysConst_Flags_Comp));
    // Check if depth test has passed.
    // sample_temp.x = old depth
    // sample_temp.y = free
    a_.OpIf(true, sample_temp_y_src);
    {
      // Extract the depth write flag.
      // sample_temp.x = old depth
      // sample_temp.y = depth write mask
      system_constants_used_ |= 1ull << kSysConst_Flags_Index;
      a_.OpAnd(sample_temp_y_dest,
               dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_Flags_Vec)
                   .Select(kSysConst_Flags_Comp),
               dxbc::Src::LU(kSysFlag_ROVDepthWrite));
      // If depth writing is disabled, don't change the depth.
      // temp.x? = resulting sample depth after the depth test
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      // temp.w = old depth/stencil
      // sample_temp.x = free
      // sample_temp.y = free
      a_.OpMovC(sample_depth_stencil_dest, sample_temp_y_src,
                sample_depth_stencil_src, sample_temp_x_src);
    }
    // Depth test has failed.
    a_.OpElse();
    {
      // Exclude the bit from the covered sample mask.
      // sample_temp.x = old depth
      a_.OpAnd(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
               dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
               dxbc::Src::LU(~uint32_t(1 << i)));
    }
    a_.OpEndIf();
    // Create packed depth/stencil, with the stencil value unchanged at this
    // point.
    // temp.x? = resulting sample depth, current resulting stencil
    // temp.y = polygon offset if not writing to oDepth
    // temp.z = viewport maximum depth if not writing to oDepth
    // temp.w = old depth/stencil
    a_.OpBFI(sample_depth_stencil_dest, dxbc::Src::LU(24), dxbc::Src::LU(8),
             sample_depth_stencil_src, temp_w_src);

    // Stencil test.

    // Extract the stencil test bit.
    // sample_temp.x = stencil test enabled
    system_constants_used_ |= 1ull << kSysConst_Flags_Index;
    a_.OpAnd(sample_temp_x_dest,
             dxbc::Src::CB(cbuffer_index_system_constants_,
                           uint32_t(CbufferRegister::kSystemConstants),
                           kSysConst_Flags_Vec)
                 .Select(kSysConst_Flags_Comp),
             dxbc::Src::LU(kSysFlag_ROVStencilTest));
    // Check if stencil test is enabled.
    // sample_temp.x = free
    a_.OpIf(true, sample_temp_x_src);
    {
      dxbc::Src stencil_front_src(
          dxbc::Src::CB(cbuffer_index_system_constants_,
                        uint32_t(CbufferRegister::kSystemConstants),
                        kSysConst_EdramStencil_Front_Vec));
      dxbc::Src stencil_back_src(
          dxbc::Src::CB(cbuffer_index_system_constants_,
                        uint32_t(CbufferRegister::kSystemConstants),
                        kSysConst_EdramStencil_Back_Vec));

      // Check the current face to get the reference and apply the read mask.
      in_front_face_used_ = true;
      a_.OpIf(true, dxbc::Src::V(
                        uint32_t(InOutRegister::kPSInFrontFaceAndSampleIndex),
                        dxbc::Src::kXXXX));
      system_constants_used_ |= 1ull << kSysConst_EdramStencil_Index;
      for (uint32_t j = 0; j < 2; ++j) {
        if (j) {
          // Go to the back face.
          a_.OpElse();
        }
        dxbc::Src stencil_side_src(j ? stencil_back_src : stencil_front_src);
        // Read-mask the stencil reference.
        // sample_temp.x = read-masked stencil reference
        a_.OpAnd(sample_temp_x_dest,
                 stencil_side_src.Select(kSysConst_EdramStencil_Reference_Comp),
                 stencil_side_src.Select(kSysConst_EdramStencil_ReadMask_Comp));
        // Read-mask the old stencil value (also dropping the depth bits).
        // sample_temp.x = read-masked stencil reference
        // sample_temp.y = read-masked old stencil
        a_.OpAnd(sample_temp_y_dest, temp_w_src,
                 stencil_side_src.Select(kSysConst_EdramStencil_ReadMask_Comp));
      }
      // Close the face check.
      a_.OpEndIf();
      // Get the difference between the stencil reference and the old stencil,
      // > 0 - greater, == 0 - equal, < 0 - less.
      // sample_temp.x = stencil difference
      // sample_temp.y = free
      a_.OpIAdd(sample_temp_x_dest, sample_temp_x_src, -sample_temp_y_src);
      // Check if the stencil is "less" or "greater or equal".
      // sample_temp.x = stencil difference
      // sample_temp.y = stencil difference less than 0
      a_.OpILT(sample_temp_y_dest, sample_temp_x_src, dxbc::Src::LI(0));
      // Choose the passed depth function bits for "less" or for "greater".
      // sample_temp.x = stencil difference
      // sample_temp.y = stencil function passed bits for "less" or "greater"
      a_.OpMovC(sample_temp_y_dest, sample_temp_y_src,
                dxbc::Src::LU(uint32_t(xenos::CompareFunction::kLess)),
                dxbc::Src::LU(uint32_t(xenos::CompareFunction::kGreater)));
      // Do the "equal" testing.
      // sample_temp.x = stencil function passed bits
      // sample_temp.y = free
      a_.OpMovC(sample_temp_x_dest, sample_temp_x_src, sample_temp_y_src,
                dxbc::Src::LU(uint32_t(xenos::CompareFunction::kEqual)));
      // Get the comparison function and the operations for the current face.
      // sample_temp.x = stencil function passed bits
      // sample_temp.y = stencil function and operations
      in_front_face_used_ = true;
      system_constants_used_ |= 1ull << kSysConst_EdramStencil_Index;
      a_.OpMovC(
          sample_temp_y_dest,
          dxbc::Src::V(uint32_t(InOutRegister::kPSInFrontFaceAndSampleIndex),
                       dxbc::Src::kXXXX),
          stencil_front_src.Select(kSysConst_EdramStencil_FuncOps_Comp),
          stencil_back_src.Select(kSysConst_EdramStencil_FuncOps_Comp));
      // Mask the resulting bits with the ones that should pass (the comparison
      // function is in the low 3 bits of the constant, and only ANDing 3-bit
      // values with it, so safe not to UBFE the function).
      // sample_temp.x = stencil test result
      // sample_temp.y = stencil function and operations
      a_.OpAnd(sample_temp_x_dest, sample_temp_x_src, sample_temp_y_src);
      // Handle passing and failure of the stencil test, to choose the operation
      // and to discard the sample.
      // sample_temp.x = free
      // sample_temp.y = stencil function and operations
      a_.OpIf(true, sample_temp_x_src);
      {
        // Check if depth test has passed for this sample to sample_temp.y (the
        // sample will only be processed if it's covered, so the only thing that
        // could unset the bit at this point that matters is the depth test).
        // sample_temp.x = depth test result
        // sample_temp.y = stencil function and operations
        a_.OpAnd(sample_temp_x_dest,
                 dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
                 dxbc::Src::LU(1 << i));
        // Choose the bit offset of the stencil operation.
        // sample_temp.x = sample operation offset
        // sample_temp.y = stencil function and operations
        a_.OpMovC(sample_temp_x_dest, sample_temp_x_src, dxbc::Src::LU(6),
                  dxbc::Src::LU(9));
        // Extract the stencil operation.
        // sample_temp.x = stencil operation
        // sample_temp.y = free
        a_.OpUBFE(sample_temp_x_dest, dxbc::Src::LU(3), sample_temp_x_src,
                  sample_temp_y_src);
      }
      // Stencil test has failed.
      a_.OpElse();
      {
        // Extract the stencil fail operation.
        // sample_temp.x = stencil operation
        // sample_temp.y = free
        a_.OpUBFE(sample_temp_x_dest, dxbc::Src::LU(3), dxbc::Src::LU(3),
                  sample_temp_y_src);
        // Exclude the bit from the covered sample mask.
        // sample_temp.x = stencil operation
        a_.OpAnd(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
                 dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
                 dxbc::Src::LU(~uint32_t(1 << i)));
      }
      // Close the stencil pass check.
      a_.OpEndIf();

      // Open the stencil operation switch for writing the new stencil (not
      // caring about bits 8:31).
      // sample_temp.x = will contain unmasked new stencil in 0:7 and junk above
      a_.OpSwitch(sample_temp_x_src);
      {
        // Zero.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kZero)));
        a_.OpMov(sample_temp_x_dest, dxbc::Src::LU(0));
        a_.OpBreak();
        // Replace.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kReplace)));
        in_front_face_used_ = true;
        system_constants_used_ |= 1ull << kSysConst_EdramStencil_Index;
        a_.OpMovC(
            sample_temp_x_dest,
            dxbc::Src::V(uint32_t(InOutRegister::kPSInFrontFaceAndSampleIndex),
                         dxbc::Src::kXXXX),
            stencil_front_src.Select(kSysConst_EdramStencil_Reference_Comp),
            stencil_back_src.Select(kSysConst_EdramStencil_Reference_Comp));
        a_.OpBreak();
        // Increment and clamp.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kIncrementClamp)));
        {
          // Clear the upper bits for saturation.
          a_.OpAnd(sample_temp_x_dest, temp_w_src, dxbc::Src::LU(UINT8_MAX));
          // Increment.
          a_.OpIAdd(sample_temp_x_dest, sample_temp_x_src, dxbc::Src::LI(1));
          // Clamp.
          a_.OpIMin(sample_temp_x_dest, sample_temp_x_src,
                    dxbc::Src::LI(UINT8_MAX));
        }
        a_.OpBreak();
        // Decrement and clamp.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kDecrementClamp)));
        {
          // Clear the upper bits for saturation.
          a_.OpAnd(sample_temp_x_dest, temp_w_src, dxbc::Src::LU(UINT8_MAX));
          // Increment.
          a_.OpIAdd(sample_temp_x_dest, sample_temp_x_src, dxbc::Src::LI(-1));
          // Clamp.
          a_.OpIMax(sample_temp_x_dest, sample_temp_x_src, dxbc::Src::LI(0));
        }
        a_.OpBreak();
        // Invert.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kInvert)));
        a_.OpNot(sample_temp_x_dest, temp_w_src);
        a_.OpBreak();
        // Increment and wrap.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kIncrementWrap)));
        a_.OpIAdd(sample_temp_x_dest, temp_w_src, dxbc::Src::LI(1));
        a_.OpBreak();
        // Decrement and wrap.
        a_.OpCase(dxbc::Src::LU(uint32_t(xenos::StencilOp::kDecrementWrap)));
        a_.OpIAdd(sample_temp_x_dest, temp_w_src, dxbc::Src::LI(-1));
        a_.OpBreak();
        // Keep.
        a_.OpDefault();
        a_.OpMov(sample_temp_x_dest, temp_w_src);
        a_.OpBreak();
      }
      // Close the new stencil switch.
      a_.OpEndSwitch();

      // Select the stencil write mask for the face.
      // sample_temp.x = unmasked new stencil in 0:7 and junk above
      // sample_temp.y = stencil write mask
      in_front_face_used_ = true;
      system_constants_used_ |= 1ull << kSysConst_EdramStencil_Index;
      a_.OpMovC(
          sample_temp_y_dest,
          dxbc::Src::V(uint32_t(InOutRegister::kPSInFrontFaceAndSampleIndex),
                       dxbc::Src::kXXXX),
          stencil_front_src.Select(kSysConst_EdramStencil_WriteMask_Comp),
          stencil_back_src.Select(kSysConst_EdramStencil_WriteMask_Comp));
      // Apply the write mask to the new stencil, also dropping the upper 24
      // bits.
      // sample_temp.x = masked new stencil
      // sample_temp.y = stencil write mask
      a_.OpAnd(sample_temp_x_dest, sample_temp_x_src, sample_temp_y_src);
      // Invert the write mask for keeping the old stencil and the depth bits.
      // sample_temp.x = masked new stencil
      // sample_temp.y = inverted stencil write mask
      a_.OpNot(sample_temp_y_dest, sample_temp_y_src);
      // Remove the bits that will be replaced from the new combined
      // depth/stencil.
      // sample_temp.x = masked new stencil
      // sample_temp.y = free
      a_.OpAnd(sample_depth_stencil_dest, sample_depth_stencil_src,
               sample_temp_y_src);
      // Merge the old and the new stencil.
      // temp.x? = resulting sample depth/stencil
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      // temp.w = old depth/stencil
      // sample_temp.x = free
      a_.OpOr(sample_depth_stencil_dest, sample_depth_stencil_src,
              sample_temp_x_src);
    }
    // Close the stencil test check.
    a_.OpEndIf();

    // Check if the depth/stencil has failed not to modify the depth if it has.
    // sample_temp.x = whether depth/stencil has passed for this sample
    a_.OpAnd(sample_temp_x_dest,
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::LU(1 << i));
    // If the depth/stencil test has failed, don't change the depth.
    // sample_temp.x = free
    a_.OpIf(false, sample_temp_x_src);
    {
      // Copy the new stencil over the old depth.
      // temp.x? = resulting sample depth/stencil
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      // temp.w = old depth/stencil
      a_.OpBFI(sample_depth_stencil_dest, dxbc::Src::LU(8), dxbc::Src::LU(0),
               sample_depth_stencil_src, temp_w_src);
    }
    // Close the depth/stencil passing check.
    a_.OpEndIf();
    // Check if the new depth/stencil is different, and thus needs to be
    // written, to temp.w.
    // temp.x? = resulting sample depth/stencil
    // temp.y = polygon offset if not writing to oDepth
    // temp.z = viewport maximum depth if not writing to oDepth
    // temp.w = whether depth/stencil has been modified
    a_.OpINE(temp_w_dest, sample_depth_stencil_src, temp_w_src);
    if (depth_stencil_early &&
        !current_shader().implicit_early_z_write_allowed()) {
      // Set the sample bit in bits 4:7 of system_temp_rov_params_.x - always
      // need to write late in this shader, as it may do something like
      // explicitly killing pixels.
      a_.OpBFI(dxbc::Dest::R(system_temp_rov_params_, 0b0001), dxbc::Src::LU(1),
               dxbc::Src::LU(4 + i), temp_w_src,
               dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX));
    } else {
      // Check if need to write.
      // temp.x? = resulting sample depth/stencil
      // temp.y = polygon offset if not writing to oDepth
      // temp.z = viewport maximum depth if not writing to oDepth
      // temp.w = free
      a_.OpIf(true, temp_w_src);
      {
        if (depth_stencil_early) {
          // Get if early depth/stencil write is enabled to temp.w.
          // temp.w = whether early depth/stencil write is enabled
          system_constants_used_ |= 1ull << kSysConst_Flags_Index;
          a_.OpAnd(temp_w_dest,
                   dxbc::Src::CB(cbuffer_index_system_constants_,
                                 uint32_t(CbufferRegister::kSystemConstants),
                                 kSysConst_Flags_Vec)
                       .Select(kSysConst_Flags_Comp),
                   dxbc::Src::LU(kSysFlag_ROVDepthStencilEarlyWrite));
          // Check if need to write early.
          // temp.w = free
          a_.OpIf(true, temp_w_src);
        }
        // Write the new depth/stencil.
        if (uav_index_edram_ == kBindingIndexUnallocated) {
          uav_index_edram_ = uav_count_++;
        }
        a_.OpStoreUAVTyped(
            dxbc::Dest::U(uav_index_edram_, uint32_t(UAVRegister::kEdram)),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY), 1,
            sample_depth_stencil_src);
        if (depth_stencil_early) {
          // Need to still run the shader to know whether to write the
          // depth/stencil value.
          a_.OpElse();
          // Set the sample bit in bits 4:7 of system_temp_rov_params_.x if need
          // to write later (after checking if the sample is not discarded by a
          // kill instruction, alphatest or alpha-to-coverage).
          a_.OpOr(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
                  dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
                  dxbc::Src::LU(1 << (4 + i)));
          // Close the early depth/stencil check.
          a_.OpEndIf();
        }
      }
      // Close the write check.
      a_.OpEndIf();
    }

    // Release sample_temp.
    PopSystemTemp();

    // Close the sample conditional.
    a_.OpEndIf();

    // Go to the next sample (samples are at +0, +80, +1, +81, so need to do
    // +80, -79, +80 and -81 after each sample).
    a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
              dxbc::Src::LI(((i & 1) ? -78 - i : 80) *
                            (int32_t(draw_resolution_scale_) *
                             int32_t(draw_resolution_scale_))));
  }

  if (ROV_IsDepthStencilEarly()) {
    // Check if safe to discard the whole 2x2 quad early, without running the
    // translated pixel shader, by checking if coverage is 0 in all pixels in
    // the quad and if there are no samples which failed the depth test, but
    // where stencil was modified and needs to be written in the end. Must
    // reject at 2x2 quad granularity because texture fetches need derivatives.

    // temp.x = coverage | deferred depth/stencil write
    a_.OpAnd(dxbc::Dest::R(temp, 0b0001),
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::LU(0b11111111));
    // temp.x = 1.0 if any sample is covered or potentially needs stencil write
    // in the end of the shader in the current pixel
    a_.OpMovC(dxbc::Dest::R(temp, 0b0001), dxbc::Src::R(temp, dxbc::Src::kXXXX),
              dxbc::Src::LF(1.0f), dxbc::Src::LF(0.0f));
    // temp.x = 1.0 if any sample is covered or potentially needs stencil write
    // in the end of the shader in the current pixel
    // temp.y = non-zero if anything is covered in the pixel across X
    a_.OpDerivRTXFine(dxbc::Dest::R(temp, 0b0010),
                      dxbc::Src::R(temp, dxbc::Src::kXXXX));
    // temp.x = 1.0 if anything is covered in the current half of the quad
    // temp.y = free
    a_.OpMovC(dxbc::Dest::R(temp, 0b0001), dxbc::Src::R(temp, dxbc::Src::kYYYY),
              dxbc::Src::LF(1.0f), dxbc::Src::R(temp, dxbc::Src::kXXXX));
    // temp.x = 1.0 if anything is covered in the current half of the quad
    // temp.y = non-zero if anything is covered in the two pixels across Y
    a_.OpDerivRTYCoarse(dxbc::Dest::R(temp, 0b0010),
                        dxbc::Src::R(temp, dxbc::Src::kXXXX));
    // temp.x = 1.0 if anything is covered in the current whole quad
    // temp.y = free
    a_.OpMovC(dxbc::Dest::R(temp, 0b0001), dxbc::Src::R(temp, dxbc::Src::kYYYY),
              dxbc::Src::LF(1.0f), dxbc::Src::R(temp, dxbc::Src::kXXXX));
    // End the shader if nothing is covered in the 2x2 quad after early
    // depth/stencil.
    // temp.x = free
    a_.OpRetC(false, dxbc::Src::R(temp, dxbc::Src::kXXXX));
  }

  // Close the large depth/stencil conditional.
  a_.OpEndIf();

  // Release temp.
  PopSystemTemp();
}

void DxbcShaderTranslator::ROV_UnpackColor(
    uint32_t rt_index, uint32_t packed_temp, uint32_t packed_temp_components,
    uint32_t color_temp, uint32_t temp1, uint32_t temp1_component,
    uint32_t temp2, uint32_t temp2_component) {
  assert_true(color_temp != packed_temp || packed_temp_components == 0);

  dxbc::Src packed_temp_low(
      dxbc::Src::R(packed_temp).Select(packed_temp_components));
  dxbc::Dest temp1_dest(dxbc::Dest::R(temp1, 1 << temp1_component));
  dxbc::Src temp1_src(dxbc::Src::R(temp1).Select(temp1_component));
  dxbc::Dest temp2_dest(dxbc::Dest::R(temp2, 1 << temp2_component));
  dxbc::Src temp2_src(dxbc::Src::R(temp2).Select(temp2_component));

  // Break register dependencies and initialize if there are not enough
  // components. The rest of the function will write at least RG (k_32_FLOAT and
  // k_32_32_FLOAT handled with the same default label), and if packed_temp is
  // the same as color_temp, the packed color won't be touched.
  a_.OpMov(dxbc::Dest::R(color_temp, 0b1100),
           dxbc::Src::LF(0.0f, 0.0f, 0.0f, 1.0f));

  // Choose the packing based on the render target's format.
  system_constants_used_ |= 1ull << kSysConst_EdramRTFormatFlags_Index;
  a_.OpSwitch(dxbc::Src::CB(cbuffer_index_system_constants_,
                            uint32_t(CbufferRegister::kSystemConstants),
                            kSysConst_EdramRTFormatFlags_Vec)
                  .Select(rt_index));

  // ***************************************************************************
  // k_8_8_8_8
  // k_8_8_8_8_GAMMA
  // ***************************************************************************
  for (uint32_t i = 0; i < 2; ++i) {
    a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
        i ? xenos::ColorRenderTargetFormat::k_8_8_8_8_GAMMA
          : xenos::ColorRenderTargetFormat::k_8_8_8_8)));
    // Unpack the components.
    a_.OpUBFE(dxbc::Dest::R(color_temp), dxbc::Src::LU(8),
              dxbc::Src::LU(0, 8, 16, 24), packed_temp_low);
    // Convert from fixed-point.
    a_.OpUToF(dxbc::Dest::R(color_temp), dxbc::Src::R(color_temp));
    // Normalize.
    a_.OpMul(dxbc::Dest::R(color_temp), dxbc::Src::R(color_temp),
             dxbc::Src::LF(1.0f / 255.0f));
    if (i) {
      for (uint32_t j = 0; j < 3; ++j) {
        ConvertPWLGamma(false, color_temp, j, color_temp, j, temp1,
                        temp1_component, temp2, temp2_component);
      }
    }
    a_.OpBreak();
  }

  // ***************************************************************************
  // k_2_10_10_10
  // k_2_10_10_10_AS_10_10_10_10
  // ***************************************************************************
  a_.OpCase(dxbc::Src::LU(
      ROV_AddColorFormatFlags(xenos::ColorRenderTargetFormat::k_2_10_10_10)));
  a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
      xenos::ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10)));
  {
    // Unpack the components.
    a_.OpUBFE(dxbc::Dest::R(color_temp), dxbc::Src::LU(10, 10, 10, 2),
              dxbc::Src::LU(0, 10, 20, 30), packed_temp_low);
    // Convert from fixed-point.
    a_.OpUToF(dxbc::Dest::R(color_temp), dxbc::Src::R(color_temp));
    // Normalize.
    a_.OpMul(dxbc::Dest::R(color_temp), dxbc::Src::R(color_temp),
             dxbc::Src::LF(1.0f / 1023.0f, 1.0f / 1023.0f, 1.0f / 1023.0f,
                           1.0f / 3.0f));
  }
  a_.OpBreak();

  // ***************************************************************************
  // k_2_10_10_10_FLOAT
  // k_2_10_10_10_FLOAT_AS_16_16_16_16
  // https://github.com/Microsoft/DirectXTex/blob/master/DirectXTex/DirectXTexConvert.cpp
  // ***************************************************************************
  a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
      xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT)));
  a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
      xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16)));
  {
    // Unpack the alpha.
    a_.OpUBFE(dxbc::Dest::R(color_temp, 0b1000), dxbc::Src::LU(2),
              dxbc::Src::LU(30), packed_temp_low);
    // Convert the alpha from fixed-point.
    a_.OpUToF(dxbc::Dest::R(color_temp, 0b1000),
              dxbc::Src::R(color_temp, dxbc::Src::kWWWW));
    // Normalize the alpha.
    a_.OpMul(dxbc::Dest::R(color_temp, 0b1000),
             dxbc::Src::R(color_temp, dxbc::Src::kWWWW),
             dxbc::Src::LF(1.0f / 3.0f));
    // Process the components in reverse order because color_temp.r stores the
    // packed color which shouldn't be touched until G and B are converted if
    // packed_temp and color_temp are the same.
    for (int32_t i = 2; i >= 0; --i) {
      Float7e3To32(a_, dxbc::Dest::R(color_temp, 1 << i), packed_temp,
                   packed_temp_components, i * 10, color_temp, i, temp1,
                   temp1_component);
    }
  }
  a_.OpBreak();

  // ***************************************************************************
  // k_16_16
  // k_16_16_16_16 (64bpp)
  // ***************************************************************************
  for (uint32_t i = 0; i < 2; ++i) {
    a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
        i ? xenos::ColorRenderTargetFormat::k_16_16_16_16
          : xenos::ColorRenderTargetFormat::k_16_16)));
    dxbc::Dest color_components_dest(
        dxbc::Dest::R(color_temp, i ? 0b1111 : 0b0011));
    // Unpack the components.
    a_.OpIBFE(color_components_dest, dxbc::Src::LU(16),
              dxbc::Src::LU(0, 16, 0, 16),
              dxbc::Src::R(packed_temp,
                           0b01010000 + packed_temp_components * 0b01010101));
    // Convert from fixed-point.
    a_.OpIToF(color_components_dest, dxbc::Src::R(color_temp));
    // Normalize.
    a_.OpMul(color_components_dest, dxbc::Src::R(color_temp),
             dxbc::Src::LF(32.0f / 32767.0f));
    a_.OpBreak();
  }

  // ***************************************************************************
  // k_16_16_FLOAT
  // k_16_16_16_16_FLOAT (64bpp)
  // ***************************************************************************
  for (uint32_t i = 0; i < 2; ++i) {
    a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
        i ? xenos::ColorRenderTargetFormat::k_16_16_16_16_FLOAT
          : xenos::ColorRenderTargetFormat::k_16_16_FLOAT)));
    dxbc::Dest color_components_dest(
        dxbc::Dest::R(color_temp, i ? 0b1111 : 0b0011));
    // Unpack the components.
    a_.OpUBFE(color_components_dest, dxbc::Src::LU(16),
              dxbc::Src::LU(0, 16, 0, 16),
              dxbc::Src::R(packed_temp,
                           0b01010000 + packed_temp_components * 0b01010101));
    // Convert from 16-bit float.
    a_.OpF16ToF32(color_components_dest, dxbc::Src::R(color_temp));
    a_.OpBreak();
  }

  if (packed_temp != color_temp) {
    // Assume k_32_FLOAT or k_32_32_FLOAT for the rest.
    a_.OpDefault();
    a_.OpMov(
        dxbc::Dest::R(color_temp, 0b0011),
        dxbc::Src::R(packed_temp, 0b0100 + packed_temp_components * 0b0101));
    a_.OpBreak();
  }

  a_.OpEndSwitch();
}

void DxbcShaderTranslator::ROV_PackPreClampedColor(
    uint32_t rt_index, uint32_t color_temp, uint32_t packed_temp,
    uint32_t packed_temp_components, uint32_t temp1, uint32_t temp1_component,
    uint32_t temp2, uint32_t temp2_component) {
  // Packing normalized formats according to the Direct3D 11.3 functional
  // specification, but assuming clamping was done by the caller.

  assert_true(color_temp != packed_temp || packed_temp_components == 0);

  dxbc::Dest packed_dest_low(
      dxbc::Dest::R(packed_temp, 1 << packed_temp_components));
  dxbc::Src packed_src_low(
      dxbc::Src::R(packed_temp).Select(packed_temp_components));
  dxbc::Dest temp1_dest(dxbc::Dest::R(temp1, 1 << temp1_component));
  dxbc::Src temp1_src(dxbc::Src::R(temp1).Select(temp1_component));
  dxbc::Dest temp2_dest(dxbc::Dest::R(temp2, 1 << temp2_component));
  dxbc::Src temp2_src(dxbc::Src::R(temp2).Select(temp2_component));

  // Break register dependency after 32bpp cases.
  a_.OpMov(dxbc::Dest::R(packed_temp, 1 << (packed_temp_components + 1)),
           dxbc::Src::LU(0));

  // Choose the packing based on the render target's format.
  system_constants_used_ |= 1ull << kSysConst_EdramRTFormatFlags_Index;
  a_.OpSwitch(dxbc::Src::CB(cbuffer_index_system_constants_,
                            uint32_t(CbufferRegister::kSystemConstants),
                            kSysConst_EdramRTFormatFlags_Vec)
                  .Select(rt_index));

  // ***************************************************************************
  // k_8_8_8_8
  // k_8_8_8_8_GAMMA
  // ***************************************************************************
  for (uint32_t i = 0; i < 2; ++i) {
    a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
        i ? xenos::ColorRenderTargetFormat::k_8_8_8_8_GAMMA
          : xenos::ColorRenderTargetFormat::k_8_8_8_8)));
    for (uint32_t j = 0; j < 4; ++j) {
      if (i && j < 3) {
        ConvertPWLGamma(true, color_temp, j, temp1, temp1_component, temp1,
                        temp1_component, temp2, temp2_component);
        // Denormalize and add 0.5 for rounding.
        a_.OpMAd(temp1_dest, temp1_src, dxbc::Src::LF(255.0f),
                 dxbc::Src::LF(0.5f));
      } else {
        // Denormalize and add 0.5 for rounding.
        a_.OpMAd(temp1_dest, dxbc::Src::R(color_temp).Select(j),
                 dxbc::Src::LF(255.0f), dxbc::Src::LF(0.5f));
      }
      // Convert to fixed-point.
      a_.OpFToU(j ? temp1_dest : packed_dest_low, temp1_src);
      // Pack the upper components.
      if (j) {
        a_.OpBFI(packed_dest_low, dxbc::Src::LU(8), dxbc::Src::LU(j * 8),
                 temp1_src, packed_src_low);
      }
    }
    a_.OpBreak();
  }

  // ***************************************************************************
  // k_2_10_10_10
  // k_2_10_10_10_AS_10_10_10_10
  // ***************************************************************************
  a_.OpCase(dxbc::Src::LU(
      ROV_AddColorFormatFlags(xenos::ColorRenderTargetFormat::k_2_10_10_10)));
  a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
      xenos::ColorRenderTargetFormat::k_2_10_10_10_AS_10_10_10_10)));
  for (uint32_t i = 0; i < 4; ++i) {
    // Denormalize and convert to fixed-point.
    a_.OpMAd(temp1_dest, dxbc::Src::R(color_temp).Select(i),
             dxbc::Src::LF(i < 3 ? 1023.0f : 3.0f), dxbc::Src::LF(0.5f));
    a_.OpFToU(i ? temp1_dest : packed_dest_low, temp1_src);
    // Pack the upper components.
    if (i) {
      a_.OpBFI(packed_dest_low, dxbc::Src::LU(i < 3 ? 10 : 2),
               dxbc::Src::LU(i * 10), temp1_src, packed_src_low);
    }
  }
  a_.OpBreak();

  // ***************************************************************************
  // k_2_10_10_10_FLOAT
  // k_2_10_10_10_FLOAT_AS_16_16_16_16
  // https://github.com/Microsoft/DirectXTex/blob/master/DirectXTex/DirectXTexConvert.cpp
  // ***************************************************************************
  a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
      xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT)));
  a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
      xenos::ColorRenderTargetFormat::k_2_10_10_10_FLOAT_AS_16_16_16_16)));
  {
    // Convert red directly to the destination, which may be the same as the
    // source, but PreClampedFloat32To7e3 allows that.
    PreClampedFloat32To7e3(a_, packed_temp, packed_temp_components, color_temp,
                           0, temp1, temp1_component);
    for (uint32_t i = 1; i < 3; ++i) {
      // Convert green and blue to a temporary register and insert them into the
      // result.
      PreClampedFloat32To7e3(a_, temp1, temp1_component, color_temp, i, temp2,
                             temp2_component);
      a_.OpBFI(packed_dest_low, dxbc::Src::LU(10), dxbc::Src::LU(i * 10),
               temp1_src, packed_src_low);
    }
    // Denormalize the alpha and convert it to fixed-point.
    a_.OpMAd(temp1_dest, dxbc::Src::R(color_temp, dxbc::Src::kWWWW),
             dxbc::Src::LF(3.0f), dxbc::Src::LF(0.5f));
    a_.OpFToU(temp1_dest, temp1_src);
    // Pack the alpha.
    a_.OpBFI(packed_dest_low, dxbc::Src::LU(2), dxbc::Src::LU(30), temp1_src,
             packed_src_low);
  }
  a_.OpBreak();

  // ***************************************************************************
  // k_16_16
  // k_16_16_16_16 (64bpp)
  // ***************************************************************************
  for (uint32_t i = 0; i < 2; ++i) {
    a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
        i ? xenos::ColorRenderTargetFormat::k_16_16_16_16
          : xenos::ColorRenderTargetFormat::k_16_16)));
    for (uint32_t j = 0; j < (uint32_t(2) << i); ++j) {
      // Denormalize and convert to fixed-point, making 0.5 with the proper sign
      // in temp2.
      a_.OpGE(temp2_dest, dxbc::Src::R(color_temp).Select(j),
              dxbc::Src::LF(0.0f));
      a_.OpMovC(temp2_dest, temp2_src, dxbc::Src::LF(0.5f),
                dxbc::Src::LF(-0.5f));
      a_.OpMAd(temp1_dest, dxbc::Src::R(color_temp).Select(j),
               dxbc::Src::LF(32767.0f / 32.0f), temp2_src);
      dxbc::Dest packed_dest_half(
          dxbc::Dest::R(packed_temp, 1 << (packed_temp_components + (j >> 1))));
      // Convert to fixed-point.
      a_.OpFToI((j & 1) ? temp1_dest : packed_dest_half, temp1_src);
      // Pack green or alpha.
      if (j & 1) {
        a_.OpBFI(packed_dest_half, dxbc::Src::LU(16), dxbc::Src::LU(16),
                 temp1_src,
                 dxbc::Src::R(packed_temp)
                     .Select(packed_temp_components + (j >> 1)));
      }
    }
    a_.OpBreak();
  }

  // ***************************************************************************
  // k_16_16_FLOAT
  // k_16_16_16_16_FLOAT (64bpp)
  // ***************************************************************************
  for (uint32_t i = 0; i < 2; ++i) {
    a_.OpCase(dxbc::Src::LU(ROV_AddColorFormatFlags(
        i ? xenos::ColorRenderTargetFormat::k_16_16_16_16_FLOAT
          : xenos::ColorRenderTargetFormat::k_16_16_FLOAT)));
    for (uint32_t j = 0; j < (uint32_t(2) << i); ++j) {
      dxbc::Dest packed_dest_half(
          dxbc::Dest::R(packed_temp, 1 << (packed_temp_components + (j >> 1))));
      // Convert to 16-bit float.
      a_.OpF32ToF16((j & 1) ? temp1_dest : packed_dest_half,
                    dxbc::Src::R(color_temp).Select(j));
      // Pack green or alpha.
      if (j & 1) {
        a_.OpBFI(packed_dest_half, dxbc::Src::LU(16), dxbc::Src::LU(16),
                 temp1_src,
                 dxbc::Src::R(packed_temp)
                     .Select(packed_temp_components + (j >> 1)));
      }
    }
    a_.OpBreak();
  }

  if (packed_temp != color_temp) {
    // Assume k_32_FLOAT or k_32_32_FLOAT for the rest.
    a_.OpDefault();
    a_.OpMov(dxbc::Dest::R(packed_temp, 0b11 << packed_temp_components),
             dxbc::Src::R(color_temp, 0b0100 << (packed_temp_components * 2)));
    a_.OpBreak();
  }

  a_.OpEndSwitch();
}

void DxbcShaderTranslator::ROV_HandleColorBlendFactorCases(
    uint32_t src_temp, uint32_t dst_temp, uint32_t factor_temp) {
  dxbc::Dest factor_dest(dxbc::Dest::R(factor_temp, 0b0111));
  dxbc::Src one_src(dxbc::Src::LF(1.0f));

  // kOne.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOne)));
  a_.OpMov(factor_dest, one_src);
  a_.OpBreak();

  // kSrcColor
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kSrcColor)));
  if (factor_temp != src_temp) {
    a_.OpMov(factor_dest, dxbc::Src::R(src_temp));
  }
  a_.OpBreak();

  // kOneMinusSrcColor
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusSrcColor)));
  a_.OpAdd(factor_dest, one_src, -dxbc::Src::R(src_temp));
  a_.OpBreak();

  // kSrcAlpha
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kSrcAlpha)));
  a_.OpMov(factor_dest, dxbc::Src::R(src_temp, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kOneMinusSrcAlpha
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusSrcAlpha)));
  a_.OpAdd(factor_dest, one_src, -dxbc::Src::R(src_temp, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kDstColor
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kDstColor)));
  if (factor_temp != dst_temp) {
    a_.OpMov(factor_dest, dxbc::Src::R(dst_temp));
  }
  a_.OpBreak();

  // kOneMinusDstColor
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusDstColor)));
  a_.OpAdd(factor_dest, one_src, -dxbc::Src::R(dst_temp));
  a_.OpBreak();

  // kDstAlpha
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kDstAlpha)));
  a_.OpMov(factor_dest, dxbc::Src::R(dst_temp, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kOneMinusDstAlpha
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusDstAlpha)));
  a_.OpAdd(factor_dest, one_src, -dxbc::Src::R(dst_temp, dxbc::Src::kWWWW));
  a_.OpBreak();

  // Factors involving the constant.
  system_constants_used_ |= 1ull << kSysConst_EdramBlendConstant_Index;

  // kConstantColor
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kConstantColor)));
  a_.OpMov(factor_dest,
           dxbc::Src::CB(cbuffer_index_system_constants_,
                         uint32_t(CbufferRegister::kSystemConstants),
                         kSysConst_EdramBlendConstant_Vec));
  a_.OpBreak();

  // kOneMinusConstantColor
  a_.OpCase(
      dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusConstantColor)));
  a_.OpAdd(factor_dest, one_src,
           -dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramBlendConstant_Vec));
  a_.OpBreak();

  // kConstantAlpha
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kConstantAlpha)));
  a_.OpMov(factor_dest,
           dxbc::Src::CB(cbuffer_index_system_constants_,
                         uint32_t(CbufferRegister::kSystemConstants),
                         kSysConst_EdramBlendConstant_Vec, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kOneMinusConstantAlpha
  a_.OpCase(
      dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusConstantAlpha)));
  a_.OpAdd(factor_dest, one_src,
           -dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramBlendConstant_Vec, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kSrcAlphaSaturate
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kSrcAlphaSaturate)));
  a_.OpAdd(dxbc::Dest::R(factor_temp, 0b0001), one_src,
           -dxbc::Src::R(dst_temp, dxbc::Src::kWWWW));
  a_.OpMin(factor_dest, dxbc::Src::R(src_temp, dxbc::Src::kWWWW),
           dxbc::Src::R(factor_temp, dxbc::Src::kXXXX));
  a_.OpBreak();

  // kZero default.
  a_.OpDefault();
  a_.OpMov(factor_dest, dxbc::Src::LF(0.0f));
  a_.OpBreak();
}

void DxbcShaderTranslator::ROV_HandleAlphaBlendFactorCases(
    uint32_t src_temp, uint32_t dst_temp, uint32_t factor_temp,
    uint32_t factor_component) {
  dxbc::Dest factor_dest(dxbc::Dest::R(factor_temp, 1 << factor_component));
  dxbc::Src one_src(dxbc::Src::LF(1.0f));

  // kOne, kSrcAlphaSaturate.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOne)));
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kSrcAlphaSaturate)));
  a_.OpMov(factor_dest, one_src);
  a_.OpBreak();

  // kSrcColor, kSrcAlpha.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kSrcColor)));
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kSrcAlpha)));
  if (factor_temp != src_temp || factor_component != 3) {
    a_.OpMov(factor_dest, dxbc::Src::R(src_temp, dxbc::Src::kWWWW));
  }
  a_.OpBreak();

  // kOneMinusSrcColor, kOneMinusSrcAlpha.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusSrcColor)));
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusSrcAlpha)));
  a_.OpAdd(factor_dest, one_src, -dxbc::Src::R(src_temp, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kDstColor, kDstAlpha.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kDstColor)));
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kDstAlpha)));
  if (factor_temp != dst_temp || factor_component != 3) {
    a_.OpMov(factor_dest, dxbc::Src::R(dst_temp, dxbc::Src::kWWWW));
  }
  a_.OpBreak();

  // kOneMinusDstColor, kOneMinusDstAlpha.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusDstColor)));
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusDstAlpha)));
  a_.OpAdd(factor_dest, one_src, -dxbc::Src::R(dst_temp, dxbc::Src::kWWWW));
  a_.OpBreak();

  // Factors involving the constant.
  system_constants_used_ |= 1ull << kSysConst_EdramBlendConstant_Index;

  // kConstantColor, kConstantAlpha.
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kConstantColor)));
  a_.OpCase(dxbc::Src::LU(uint32_t(xenos::BlendFactor::kConstantAlpha)));
  a_.OpMov(factor_dest,
           dxbc::Src::CB(cbuffer_index_system_constants_,
                         uint32_t(CbufferRegister::kSystemConstants),
                         kSysConst_EdramBlendConstant_Vec, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kOneMinusConstantColor, kOneMinusConstantAlpha.
  a_.OpCase(
      dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusConstantColor)));
  a_.OpCase(
      dxbc::Src::LU(uint32_t(xenos::BlendFactor::kOneMinusConstantAlpha)));
  a_.OpAdd(factor_dest, one_src,
           -dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_EdramBlendConstant_Vec, dxbc::Src::kWWWW));
  a_.OpBreak();

  // kZero default.
  a_.OpDefault();
  a_.OpMov(factor_dest, dxbc::Src::LF(0.0f));
  a_.OpBreak();
}

void DxbcShaderTranslator::CompletePixelShader_WriteToRTVs() {
  uint32_t shader_writes_color_targets =
      current_shader().writes_color_targets();
  if (!shader_writes_color_targets) {
    return;
  }

  uint32_t gamma_temp = PushSystemTemp();
  for (uint32_t i = 0; i < 4; ++i) {
    if (!(shader_writes_color_targets & (1 << i))) {
      continue;
    }
    // Apply the exponent bias after alpha to coverage because it needs the
    // unbiased alpha from the shader
    system_constants_used_ |= 1ull << kSysConst_ColorExpBias_Index;
    a_.OpMul(dxbc::Dest::R(system_temps_color_[i]),
             dxbc::Src::R(system_temps_color_[i]),
             dxbc::Src::CB(cbuffer_index_system_constants_,
                           uint32_t(CbufferRegister::kSystemConstants),
                           kSysConst_ColorExpBias_Vec)
                 .Select(i));
    if (!gamma_render_target_as_srgb_) {
      // Convert to gamma space - this is incorrect, since it must be done after
      // blending on the Xbox 360, but this is just one of many blending issues
      // in the RTV path.
      system_constants_used_ |= 1ull << kSysConst_Flags_Index;
      a_.OpAnd(dxbc::Dest::R(gamma_temp, 0b0001),
               dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_Flags_Vec)
                   .Select(kSysConst_Flags_Comp),
               dxbc::Src::LU(kSysFlag_ConvertColor0ToGamma << i));
      a_.OpIf(true, dxbc::Src::R(gamma_temp, dxbc::Src::kXXXX));
      for (uint32_t j = 0; j < 3; ++j) {
        ConvertPWLGamma(true, system_temps_color_[i], j, system_temps_color_[i],
                        j, gamma_temp, 0, gamma_temp, 1);
      }
      a_.OpEndIf();
    }
    // Copy the color from a readable temp register to an output register.
    a_.OpMov(dxbc::Dest::O(i), dxbc::Src::R(system_temps_color_[i]));
  }
  // Release gamma_temp.
  PopSystemTemp();
}

void DxbcShaderTranslator::CompletePixelShader_DSV_DepthTo24Bit() {
  bool shader_writes_depth = current_shader().writes_depth();

  if (!DSV_IsWritingFloat24Depth()) {
    if (shader_writes_depth) {
      // If not converting, but the shader writes depth explicitly, for float24,
      // need to scale it from guest 0...1 to host 0...0.5 to support
      // reinterpretation round trips as viewport scaling doesn't apply to
      // oDepth.
      system_constants_used_ |= 1ull << kSysConst_Flags_Index;
      a_.OpAnd(dxbc::Dest::R(system_temp_depth_stencil_, 0b0010),
               dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_Flags_Vec)
                   .Select(kSysConst_Flags_Comp),
               dxbc::Src::LU(kSysFlag_DepthFloat24));
      a_.OpIf(true, dxbc::Src::R(system_temp_depth_stencil_, dxbc::Src::kYYYY));
      a_.OpMul(dxbc::Dest::R(system_temp_depth_stencil_, 0b0001),
               dxbc::Src::R(system_temp_depth_stencil_, dxbc::Src::kXXXX),
               dxbc::Src::LF(0.5f));
      a_.OpEndIf();
      // Write the depth from the temporary to the system depth output.
      a_.OpMov(dxbc::Dest::ODepth(),
               dxbc::Src::R(system_temp_depth_stencil_, dxbc::Src::kXXXX));
    }
    return;
  }

  uint32_t temp;
  if (shader_writes_depth) {
    // The depth is already written to system_temp_depth_stencil_.x and clamped
    // to 0...1 with NaNs dropped (saturating in StoreResult); yzw are free.
    temp = system_temp_depth_stencil_;
  } else {
    // Need a temporary variable; remap the sample's depth input from host
    // 0...0.5 back to guest 0...1 for conversion purposes to it and saturate it
    // (in Direct3D 11, depth is clamped to the viewport bounds after the pixel
    // shader, and SV_Position.z contains the unclamped depth, which may be
    // outside the viewport's depth range if it's biased); though it will be
    // clamped to the viewport bounds anyway, but to be able to make the
    // assumption of it being clamped while working with the bit representation.
    temp = PushSystemTemp();
    in_position_used_ |= 0b0100;
    a_.OpMul(
        dxbc::Dest::R(temp, 0b0001),
        dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition), dxbc::Src::kZZZZ),
        dxbc::Src::LF(2.0f), true);
  }

  dxbc::Dest temp_x_dest(dxbc::Dest::R(temp, 0b0001));
  dxbc::Src temp_x_src(dxbc::Src::R(temp, dxbc::Src::kXXXX));
  dxbc::Dest temp_y_dest(dxbc::Dest::R(temp, 0b0010));
  dxbc::Src temp_y_src(dxbc::Src::R(temp, dxbc::Src::kYYYY));

  if (GetDxbcShaderModification().pixel.depth_stencil_mode ==
      Modification::DepthStencilMode::kFloat24Truncating) {
    // Simplified conversion, always less than or equal to the original value -
    // just drop the lower bits.
    // The float32 exponent bias is 127.
    // After saturating, the exponent range is -127...0.
    // The smallest normalized 20e4 exponent is -14 - should drop 3 mantissa
    // bits at -14 or above.
    // The smallest denormalized 20e4 number is -34 - should drop 23 mantissa
    // bits at -34.
    // Anything smaller than 2^-34 becomes 0.
    dxbc::Dest truncate_dest(shader_writes_depth ? dxbc::Dest::ODepth()
                                                 : dxbc::Dest::ODepthLE());
    // Check if the number is representable as a float24 after truncation - the
    // exponent is at least -34.
    a_.OpUGE(temp_y_dest, temp_x_src, dxbc::Src::LU(0x2E800000));
    a_.OpIf(true, temp_y_src);
    {
      // Extract the biased float32 exponent to temp.y.
      // temp.y = 113+ at exponent -14+.
      // temp.y = 93 at exponent -34.
      a_.OpUBFE(temp_y_dest, dxbc::Src::LU(8), dxbc::Src::LU(23), temp_x_src);
      // Convert exponent to the unclamped number of bits to truncate.
      // 116 - 113 = 3.
      // 116 - 93 = 23.
      // temp.y = 3+ at exponent -14+.
      // temp.y = 23 at exponent -34.
      a_.OpIAdd(temp_y_dest, dxbc::Src::LI(116), -temp_y_src);
      // Clamp the truncated bit count to drop 3 bits of any normal number.
      // Exponents below -34 are handled separately.
      // temp.y = 3 at exponent -14.
      // temp.y = 23 at exponent -34.
      a_.OpIMax(temp_y_dest, temp_y_src, dxbc::Src::LI(3));
      // Truncate the mantissa - fill the low bits with zeros.
      // temp.x = result in 0...1 range
      a_.OpBFI(temp_x_dest, temp_y_src, dxbc::Src::LU(0), dxbc::Src::LU(0),
               temp_x_src);
      // Remap from guest 0...1 to host 0...0.5.
      a_.OpMul(truncate_dest, temp_x_src, dxbc::Src::LF(0.5f));
    }
    // The number is not representable as float24 after truncation - zero.
    a_.OpElse();
    a_.OpMov(truncate_dest, dxbc::Src::LF(0.0f));
    // Close the non-zero result check.
    a_.OpEndIf();
  } else {
    // Properly convert to 20e4, with rounding to the nearest even (the bias was
    // pre-applied by multiplying by 2), then convert back restoring the bias.
    PreClampedDepthTo20e4(a_, temp, 0, temp, 0, temp, 1, false);
    Depth20e4To32(a_, dxbc::Dest::ODepth(), temp, 0, 0, temp, 0, temp, 1, true);
  }

  if (!shader_writes_depth) {
    // Release temp.
    PopSystemTemp();
  }
}

void DxbcShaderTranslator::CompletePixelShader_AlphaToMaskSample(
    uint32_t sample_index, float threshold_base, dxbc::Src threshold_offset,
    float threshold_offset_scale, uint32_t coverage_temp,
    uint32_t coverage_temp_component, uint32_t temp, uint32_t temp_component) {
  dxbc::Dest temp_dest(dxbc::Dest::R(temp, 1 << temp_component));
  dxbc::Src temp_src(dxbc::Src::R(temp).Select(temp_component));
  // Calculate the threshold.
  a_.OpMAd(temp_dest, threshold_offset, dxbc::Src::LF(-threshold_offset_scale),
           dxbc::Src::LF(threshold_base));
  // Check if alpha of oC0 is at or greater than the threshold (handling NaN
  // according to the Direct3D 11.3 functional specification, as not covered).
  a_.OpGE(temp_dest, dxbc::Src::R(system_temps_color_[0], dxbc::Src::kWWWW),
          temp_src);
  dxbc::Dest coverage_dest(
      dxbc::Dest::R(coverage_temp, 1 << coverage_temp_component));
  dxbc::Src coverage_src(
      dxbc::Src::R(coverage_temp).Select(coverage_temp_component));
  if (edram_rov_used_) {
    assert_true(coverage_temp != temp ||
                coverage_temp_component != temp_component);
    // Keep all bits in but the ones that need to be removed in case of failure.
    // For ROV, the test must effect not only the coverage bits, but also the
    // deferred depth/stencil write bits since the coverage is zeroed for
    // samples that have failed the depth/stencil test, but stencil may still
    // require writing - but if the sample is discarded by alpha to coverage, it
    // must not be written at all.
    a_.OpOr(temp_dest, temp_src,
            dxbc::Src::LU(~(uint32_t(0b00010001) << sample_index)));
    // Clear the coverage for samples that have failed the test.
    a_.OpAnd(coverage_dest, coverage_src, temp_src);
  } else {
    if (sample_index) {
      // Not first sample - add.
      a_.OpAnd(temp_dest, temp_src, dxbc::Src::LU(uint32_t(1) << sample_index));
      a_.OpOr(coverage_dest, coverage_src, temp_src);
    } else {
      // First sample - initialize.
      assert_true(coverage_temp != temp ||
                  coverage_temp_component != temp_component);
      a_.OpAnd(coverage_dest, temp_src,
               dxbc::Src::LU(uint32_t(1) << sample_index));
    }
  }
}

void DxbcShaderTranslator::CompletePixelShader_AlphaToMask() {
  // Check if alpha to coverage can be done at all in this shader.
  if (!current_shader().writes_color_target(0)) {
    return;
  }

  if (!edram_rov_used_) {
    // Initialize the output coverage for the case if alpha to mask is not
    // enabled - it needs to be written on every execution path.
    a_.OpMov(dxbc::Dest::OMask(), dxbc::Src::LU(UINT32_MAX));
  }

  // Check if alpha to coverage is enabled.
  system_constants_used_ |= 1ull << kSysConst_AlphaToMask_Index;
  a_.OpIf(true, dxbc::Src::CB(cbuffer_index_system_constants_,
                              uint32_t(CbufferRegister::kSystemConstants),
                              kSysConst_AlphaToMask_Vec)
                    .Select(kSysConst_AlphaToMask_Comp));

  uint32_t temp = PushSystemTemp();
  dxbc::Dest temp_x_dest(dxbc::Dest::R(temp, 0b0001));
  dxbc::Src temp_x_src(dxbc::Src::R(temp, dxbc::Src::kXXXX));

  // Get the dithering threshold offset index for the pixel, Y - low bit of
  // offset index, X - high bit, and extract the offset and convert it to
  // floating-point. With resolution scaling, still using host pixels, to
  // preserve the idea of dithering.
  // temp.x = alpha to coverage offset as float 0.0...3.0.
  in_position_used_ |= 0b0011;
  a_.OpFToU(dxbc::Dest::R(temp, 0b0011),
            dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition)));
  a_.OpAnd(dxbc::Dest::R(temp, 0b0010), dxbc::Src::R(temp, dxbc::Src::kYYYY),
           dxbc::Src::LU(1));
  a_.OpBFI(temp_x_dest, dxbc::Src::LU(1), dxbc::Src::LU(1), temp_x_src,
           dxbc::Src::R(temp, dxbc::Src::kYYYY));
  a_.OpIShL(temp_x_dest, temp_x_src, dxbc::Src::LU(1));
  system_constants_used_ |= 1ull << kSysConst_AlphaToMask_Index;
  a_.OpUBFE(temp_x_dest, dxbc::Src::LU(2), temp_x_src,
            dxbc::Src::CB(cbuffer_index_system_constants_,
                          uint32_t(CbufferRegister::kSystemConstants),
                          kSysConst_AlphaToMask_Vec)
                .Select(kSysConst_AlphaToMask_Comp));
  a_.OpUToF(temp_x_dest, temp_x_src);

  // Write the result to temp.z for RTV or to system_temp_rov_params_.x for ROV.
  // temp.x = alpha to coverage offset as float 0.0...3.0.
  // temp.z = without ROV, accumulated coverage.
  uint32_t coverage_temp = edram_rov_used_ ? system_temp_rov_params_ : temp;
  uint32_t coverage_temp_component = edram_rov_used_ ? 0 : 2;

  // Check if MSAA is enabled.
  system_constants_used_ |= 1ull << kSysConst_SampleCountLog2_Index;
  a_.OpIf(true, dxbc::Src::CB(cbuffer_index_system_constants_,
                              uint32_t(CbufferRegister::kSystemConstants),
                              kSysConst_SampleCountLog2_Vec)
                    .Select(kSysConst_SampleCountLog2_Comp + 1));
  {
    // Check if MSAA is 4x or 2x.
    system_constants_used_ |= 1ull << kSysConst_SampleCountLog2_Index;
    a_.OpIf(true, dxbc::Src::CB(cbuffer_index_system_constants_,
                                uint32_t(CbufferRegister::kSystemConstants),
                                kSysConst_SampleCountLog2_Vec)
                      .Select(kSysConst_SampleCountLog2_Comp));
    // 4x MSAA.
    // Sample 0 must be checked first - CompletePixelShader_AlphaToMaskSample
    // initializes the result for sample index 0.
    CompletePixelShader_AlphaToMaskSample(0, 0.75f, temp_x_src, 1.0f / 16.0f,
                                          coverage_temp,
                                          coverage_temp_component, temp, 1);
    CompletePixelShader_AlphaToMaskSample(1, 0.25f, temp_x_src, 1.0f / 16.0f,
                                          coverage_temp,
                                          coverage_temp_component, temp, 1);
    CompletePixelShader_AlphaToMaskSample(2, 0.5f, temp_x_src, 1.0f / 16.0f,
                                          coverage_temp,
                                          coverage_temp_component, temp, 1);
    CompletePixelShader_AlphaToMaskSample(3, 1.0f, temp_x_src, 1.0f / 16.0f,
                                          coverage_temp,
                                          coverage_temp_component, temp, 1);
    // 2x MSAA (as 2x or samples 0 and 3 of 4x).
    a_.OpElse();
    CompletePixelShader_AlphaToMaskSample(0, 0.5f, temp_x_src, 1.0f / 8.0f,
                                          coverage_temp,
                                          coverage_temp_component, temp, 1);
    CompletePixelShader_AlphaToMaskSample(
        (!edram_rov_used_ && !msaa_2x_supported_) ? 3 : 1, 1.0f, temp_x_src,
        1.0f / 8.0f, coverage_temp, coverage_temp_component, temp, 1);
    // Close the 4x check.
    a_.OpEndIf();
  }
  // MSAA is disabled.
  a_.OpElse();
  CompletePixelShader_AlphaToMaskSample(0, 1.0f, temp_x_src, 1.0f / 4.0f,
                                        coverage_temp, coverage_temp_component,
                                        temp, 1);
  // Close the 2x/4x check.
  a_.OpEndIf();

  // Check if any sample is still covered and return to avoid unneeded work (the
  // driver's shader compiler may place return after a discard, but it will
  // likely not place one during SV_Coverage assignment - that's what the AMD
  // compiler does, at least). Then, if needed, write the coverage value.
  if (edram_rov_used_) {
    // The mask includes both 0:3 and 4:7 parts because there may be samples
    // which passed alpha to coverage, but not stencil test, and the stencil
    // buffer needs to be modified - in this case, samples would be dropped in
    // 0:3, but not in 4:7).
    a_.OpAnd(temp_x_dest,
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::LU(0b11111111));
    a_.OpRetC(false, temp_x_src);
  } else {
    dxbc::Src coverage_src(
        dxbc::Src::R(coverage_temp, coverage_temp_component));
    a_.OpDiscard(false, coverage_src);
    a_.OpMov(dxbc::Dest::OMask(), coverage_src);
  }

  // Release temp.
  PopSystemTemp();

  // Close the alpha to coverage check.
  a_.OpEndIf();
}

void DxbcShaderTranslator::CompletePixelShader_WriteToROV() {
  uint32_t temp = PushSystemTemp();
  dxbc::Dest temp_x_dest(dxbc::Dest::R(temp, 0b0001));
  dxbc::Src temp_x_src(dxbc::Src::R(temp, dxbc::Src::kXXXX));
  dxbc::Dest temp_y_dest(dxbc::Dest::R(temp, 0b0010));
  dxbc::Src temp_y_src(dxbc::Src::R(temp, dxbc::Src::kYYYY));
  dxbc::Dest temp_z_dest(dxbc::Dest::R(temp, 0b0100));
  dxbc::Src temp_z_src(dxbc::Src::R(temp, dxbc::Src::kZZZZ));
  dxbc::Dest temp_w_dest(dxbc::Dest::R(temp, 0b1000));
  dxbc::Src temp_w_src(dxbc::Src::R(temp, dxbc::Src::kWWWW));

  uint32_t resolution_scale_square =
      draw_resolution_scale_ * draw_resolution_scale_;

  // Do late depth/stencil test (which includes writing) if needed or deferred
  // depth writing.
  if (ROV_IsDepthStencilEarly()) {
    // Write modified depth/stencil.
    for (uint32_t i = 0; i < 4; ++i) {
      // Get if need to write to temp.x.
      // temp.x = whether the depth sample needs to be written.
      a_.OpAnd(temp_x_dest,
               dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
               dxbc::Src::LU(1 << (4 + i)));
      // Check if need to write.
      // temp.x = free.
      a_.OpIf(true, temp_x_src);
      {
        // Write the new depth/stencil.
        if (uav_index_edram_ == kBindingIndexUnallocated) {
          uav_index_edram_ = uav_count_++;
        }
        a_.OpStoreUAVTyped(
            dxbc::Dest::U(uav_index_edram_, uint32_t(UAVRegister::kEdram)),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY), 1,
            dxbc::Src::R(system_temp_depth_stencil_).Select(i));
      }
      // Close the write check.
      a_.OpEndIf();
      // Go to the next sample (samples are at +0, +80, +1, +81, so need to do
      // +80, -79, +80 and -81 after each sample).
      if (i < 3) {
        a_.OpIAdd(
            dxbc::Dest::R(system_temp_rov_params_, 0b0010),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
            dxbc::Src::LI(((i & 1) ? -78 - i : 80) * resolution_scale_square));
      }
    }
  } else {
    ROV_DepthStencilTest();
  }

  if (!is_depth_only_pixel_shader_) {
    // Check if any sample is still covered after depth testing and writing,
    // skip color writing completely in this case.
    // temp.x = whether any sample is still covered.
    a_.OpAnd(temp_x_dest,
             dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
             dxbc::Src::LU(0b1111));
    // temp.x = free.
    a_.OpRetC(false, temp_x_src);
  }

  // Write color values.
  uint32_t shader_writes_color_targets =
      current_shader().writes_color_targets();
  for (uint32_t i = 0; i < 4; ++i) {
    if (!(shader_writes_color_targets & (1 << i))) {
      continue;
    }

    dxbc::Src keep_mask_vec_src(
        dxbc::Src::CB(cbuffer_index_system_constants_,
                      uint32_t(CbufferRegister::kSystemConstants),
                      kSysConst_EdramRTKeepMask_Vec + (i >> 1)));
    uint32_t keep_mask_component = (i & 1) * 2;
    uint32_t keep_mask_swizzle = keep_mask_component * 0b0101 + 0b0100;

    // Check if color writing is disabled - special keep mask constant case,
    // both 32bpp parts are forced UINT32_MAX, but also check whether the shader
    // has written anything to this target at all.

    // Combine both parts of the keep mask to check if both are 0xFFFFFFFF.
    // temp.x = whether all bits need to be kept.
    system_constants_used_ |= 1ull << kSysConst_EdramRTKeepMask_Index;
    a_.OpAnd(temp_x_dest, keep_mask_vec_src.Select(keep_mask_component),
             keep_mask_vec_src.Select(keep_mask_component + 1));
    // Flip the bits so both UINT32_MAX would result in 0 - not writing.
    // temp.x = whether any bits need to be written.
    a_.OpNot(temp_x_dest, temp_x_src);
    // Get the bits that will be used for checking wherther the render target
    // has been written to on the taken execution path - if the write mask is
    // empty, AND zero with the test bit to always get zero.
    // temp.x = bits for checking whether the render target has been written to.
    a_.OpMovC(temp_x_dest, temp_x_src,
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
              dxbc::Src::LU(0));
    // Check if the render target was written to on the execution path.
    // temp.x = whether anything was written and needs to be stored.
    a_.OpAnd(temp_x_dest, temp_x_src, dxbc::Src::LU(1 << (8 + i)));
    // Check if need to write anything to the render target.
    // temp.x = free.
    a_.OpIf(true, temp_x_src);

    // Apply the exponent bias after alpha to coverage because it needs the
    // unbiased alpha from the shader.
    system_constants_used_ |= 1ull << kSysConst_ColorExpBias_Index;
    a_.OpMul(dxbc::Dest::R(system_temps_color_[i]),
             dxbc::Src::R(system_temps_color_[i]),
             dxbc::Src::CB(cbuffer_index_system_constants_,
                           uint32_t(CbufferRegister::kSystemConstants),
                           kSysConst_ColorExpBias_Vec)
                 .Select(i));

    // Add the EDRAM bases of the render target to system_temp_rov_params_.zw.
    system_constants_used_ |= 1ull << kSysConst_EdramRTBaseDwordsScaled_Index;
    a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
              dxbc::Src::R(system_temp_rov_params_),
              dxbc::Src::CB(cbuffer_index_system_constants_,
                            uint32_t(CbufferRegister::kSystemConstants),
                            kSysConst_EdramRTBaseDwordsScaled_Vec)
                  .Select(i));

    dxbc::Src rt_blend_factors_ops_src(
        dxbc::Src::CB(cbuffer_index_system_constants_,
                      uint32_t(CbufferRegister::kSystemConstants),
                      kSysConst_EdramRTBlendFactorsOps_Vec)
            .Select(i));
    dxbc::Src rt_clamp_vec_src(
        dxbc::Src::CB(cbuffer_index_system_constants_,
                      uint32_t(CbufferRegister::kSystemConstants),
                      kSysConst_EdramRTClamp_Vec + i));
    // Get if not blending to pack the color once for all 4 samples.
    // temp.x = whether blending is disabled.
    system_constants_used_ |= 1ull << kSysConst_EdramRTBlendFactorsOps_Index;
    a_.OpIEq(temp_x_dest, rt_blend_factors_ops_src, dxbc::Src::LU(0x00010001));
    // Check if not blending.
    // temp.x = free.
    a_.OpIf(true, temp_x_src);
    {
      // Clamp the color to the render target's representable range - will be
      // packed.
      system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
      a_.OpMax(dxbc::Dest::R(system_temps_color_[i]),
               dxbc::Src::R(system_temps_color_[i]),
               rt_clamp_vec_src.Swizzle(0b01000000));
      a_.OpMin(dxbc::Dest::R(system_temps_color_[i]),
               dxbc::Src::R(system_temps_color_[i]),
               rt_clamp_vec_src.Swizzle(0b11101010));
      // Pack the color once if blending.
      // temp.xy = packed color.
      ROV_PackPreClampedColor(i, system_temps_color_[i], temp, 0, temp, 2, temp,
                              3);
    }
    // Blending is enabled.
    a_.OpElse();
    {
      // Get if the blending source color is fixed-point for clamping if it is.
      // temp.x = whether color is fixed-point.
      system_constants_used_ |= 1ull << kSysConst_EdramRTFormatFlags_Index;
      a_.OpAnd(temp_x_dest,
               dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_EdramRTFormatFlags_Vec)
                   .Select(i),
               dxbc::Src::LU(kRTFormatFlag_FixedPointColor));
      // Check if the blending source color is fixed-point and needs clamping.
      // temp.x = free.
      a_.OpIf(true, temp_x_src);
      {
        // Clamp the blending source color if needed.
        system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
        a_.OpMax(dxbc::Dest::R(system_temps_color_[i], 0b0111),
                 dxbc::Src::R(system_temps_color_[i]),
                 rt_clamp_vec_src.Select(0));
        a_.OpMin(dxbc::Dest::R(system_temps_color_[i], 0b0111),
                 dxbc::Src::R(system_temps_color_[i]),
                 rt_clamp_vec_src.Select(2));
      }
      // Close the fixed-point color check.
      a_.OpEndIf();

      // Get if the blending source alpha is fixed-point for clamping if it is.
      // temp.x = whether alpha is fixed-point.
      system_constants_used_ |= 1ull << kSysConst_EdramRTFormatFlags_Index;
      a_.OpAnd(temp_x_dest,
               dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_EdramRTFormatFlags_Vec)
                   .Select(i),
               dxbc::Src::LU(kRTFormatFlag_FixedPointAlpha));
      // Check if the blending source alpha is fixed-point and needs clamping.
      // temp.x = free.
      a_.OpIf(true, temp_x_src);
      {
        // Clamp the blending source alpha if needed.
        system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
        a_.OpMax(dxbc::Dest::R(system_temps_color_[i], 0b1000),
                 dxbc::Src::R(system_temps_color_[i], dxbc::Src::kWWWW),
                 rt_clamp_vec_src.Select(1));
        a_.OpMin(dxbc::Dest::R(system_temps_color_[i], 0b1000),
                 dxbc::Src::R(system_temps_color_[i], dxbc::Src::kWWWW),
                 rt_clamp_vec_src.Select(3));
      }
      // Close the fixed-point alpha check.
      a_.OpEndIf();
      // Break register dependency in the color sample raster operation.
      // temp.xy = 0 instead of packed color.
      a_.OpMov(dxbc::Dest::R(temp, 0b0011), dxbc::Src::LU(0));
    }
    a_.OpEndIf();

    dxbc::Src rt_format_flags_src(
        dxbc::Src::CB(cbuffer_index_system_constants_,
                      uint32_t(CbufferRegister::kSystemConstants),
                      kSysConst_EdramRTFormatFlags_Vec)
            .Select(i));

    // Blend, mask and write all samples.
    for (uint32_t j = 0; j < 4; ++j) {
      // Get if the sample is covered.
      // temp.z = whether the sample is covered.
      a_.OpAnd(temp_z_dest,
               dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
               dxbc::Src::LU(1 << j));

      // Check if the sample is covered.
      // temp.z = free.
      a_.OpIf(true, temp_z_src);

      // Only temp.xy are used at this point (containing the packed color from
      // the shader if not blending).

      // ***********************************************************************
      // Color sample raster operation.
      // ***********************************************************************

      // ***********************************************************************
      // Checking if color loading must be done - if any component needs to be
      // kept or if blending is enabled.
      // ***********************************************************************

      // Get if need to keep any components to temp.z.
      // temp.z = whether any components must be kept (OR of keep masks).
      system_constants_used_ |= 1ull << kSysConst_EdramRTKeepMask_Index;
      a_.OpOr(temp_z_dest, keep_mask_vec_src.Select(keep_mask_component),
              keep_mask_vec_src.Select(keep_mask_component + 1));
      // Blending isn't done if it's 1 * source + 0 * destination. But since the
      // previous color also needs to be loaded if any original components need
      // to be kept, force the blend control to something with blending in this
      // case in temp.z.
      // temp.z = blending mode used to check if need to load.
      system_constants_used_ |= 1ull << kSysConst_EdramRTBlendFactorsOps_Index;
      a_.OpMovC(temp_z_dest, temp_z_src, dxbc::Src::LU(0),
                rt_blend_factors_ops_src);
      // Get if the blend control register requires loading the color to temp.z.
      // temp.z = whether need to load the color.
      a_.OpINE(temp_z_dest, temp_z_src, dxbc::Src::LU(0x00010001));
      // Check if need to do something with the previous color.
      // temp.z = free.
      a_.OpIf(true, temp_z_src);
      {
        // *********************************************************************
        // Loading the previous color to temp.zw.
        // *********************************************************************

        // Get if the format is 64bpp to temp.z.
        // temp.z = whether the render target is 64bpp.
        system_constants_used_ |= 1ull << kSysConst_EdramRTFormatFlags_Index;
        a_.OpAnd(temp_z_dest, rt_format_flags_src,
                 dxbc::Src::LU(kRTFormatFlag_64bpp));
        // Check if the format is 64bpp.
        // temp.z = free.
        a_.OpIf(true, temp_z_src);
        {
          // Load the lower 32 bits of the 64bpp color to temp.z.
          // temp.z = lower 32 bits of the packed color.
          if (uav_index_edram_ == kBindingIndexUnallocated) {
            uav_index_edram_ = uav_count_++;
          }
          a_.OpLdUAVTyped(
              temp_z_dest,
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW), 1,
              dxbc::Src::U(uav_index_edram_, uint32_t(UAVRegister::kEdram),
                           dxbc::Src::kXXXX));
          // Get the address of the upper 32 bits of the color to temp.w.
          // temp.w = address of the upper 32 bits of the packed color.
          a_.OpIAdd(temp_w_dest,
                    dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
                    dxbc::Src::LU(1));
          // Load the upper 32 bits of the 64bpp color to temp.w.
          // temp.zw = packed destination color/alpha.
          if (uav_index_edram_ == kBindingIndexUnallocated) {
            uav_index_edram_ = uav_count_++;
          }
          a_.OpLdUAVTyped(
              temp_w_dest, temp_w_src, 1,
              dxbc::Src::U(uav_index_edram_, uint32_t(UAVRegister::kEdram),
                           dxbc::Src::kXXXX));
        }
        // The color is 32bpp.
        a_.OpElse();
        {
          // Load the 32bpp color to temp.z.
          // temp.z = packed 32bpp destination color.
          if (uav_index_edram_ == kBindingIndexUnallocated) {
            uav_index_edram_ = uav_count_++;
          }
          a_.OpLdUAVTyped(
              temp_z_dest,
              dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ), 1,
              dxbc::Src::U(uav_index_edram_, uint32_t(UAVRegister::kEdram),
                           dxbc::Src::kXXXX));
          // Break register dependency in temp.w if the color is 32bpp.
          // temp.zw = packed destination color/alpha.
          a_.OpMov(temp_w_dest, dxbc::Src::LU(0));
        }
        // Close the color format check.
        a_.OpEndIf();

        uint32_t color_temp = PushSystemTemp();
        dxbc::Dest color_temp_rgb_dest(dxbc::Dest::R(color_temp, 0b0111));
        dxbc::Dest color_temp_a_dest(dxbc::Dest::R(color_temp, 0b1000));
        dxbc::Src color_temp_src(dxbc::Src::R(color_temp));
        dxbc::Src color_temp_a_src(dxbc::Src::R(color_temp, dxbc::Src::kWWWW));

        // Get if blending is enabled to color_temp.x.
        // color_temp.x = whether blending is enabled.
        system_constants_used_ |= 1ull
                                  << kSysConst_EdramRTBlendFactorsOps_Index;
        a_.OpINE(dxbc::Dest::R(color_temp, 0b0001), rt_blend_factors_ops_src,
                 dxbc::Src::LU(0x00010001));
        // Check if need to blend.
        // color_temp.x = free.
        a_.OpIf(true, dxbc::Src::R(color_temp, dxbc::Src::kXXXX));
        {
          // Now, when blending is enabled, temp.xy are used as scratch since
          // the color is packed after blending.

          // Unpack the destination color to color_temp, using temp.xy as temps.
          // The destination color never needs clamping because out-of-range
          // values can't be loaded.
          // color_temp.xyzw = destination color/alpha.
          ROV_UnpackColor(i, temp, 2, color_temp, temp, 0, temp, 1);

          // *******************************************************************
          // Color blending.
          // *******************************************************************

          // Extract the color min/max bit to temp.x.
          // temp.x = whether min/max should be used for color.
          system_constants_used_ |= 1ull
                                    << kSysConst_EdramRTBlendFactorsOps_Index;
          a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                   dxbc::Src::LU(1 << (5 + 1)));
          // Check if need to do blend the color with factors.
          // temp.x = free.
          a_.OpIf(false, temp_x_src);
          {
            uint32_t blend_src_temp = PushSystemTemp();
            dxbc::Dest blend_src_temp_rgb_dest(
                dxbc::Dest::R(blend_src_temp, 0b0111));
            dxbc::Src blend_src_temp_src(dxbc::Src::R(blend_src_temp));

            // Extract the source color factor to temp.x.
            // temp.x = source color factor index.
            system_constants_used_ |= 1ull
                                      << kSysConst_EdramRTBlendFactorsOps_Index;
            a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                     dxbc::Src::LU((1 << 5) - 1));
            // Check if the source color factor is not zero - if it is, the
            // source must be ignored completely, and Infinity and NaN in it
            // shouldn't affect blending.
            a_.OpIf(true, temp_x_src);
            {
              // Open the switch for choosing the source color blend factor.
              // temp.x = free.
              a_.OpSwitch(temp_x_src);
              // Write the source color factor to blend_src_temp.xyz.
              // blend_src_temp.xyz = unclamped source color factor.
              ROV_HandleColorBlendFactorCases(system_temps_color_[i],
                                              color_temp, blend_src_temp);
              // Close the source color factor switch.
              a_.OpEndSwitch();
              // Get if the render target color is fixed-point and the source
              // color factor needs clamping to temp.x.
              // temp.x = whether color is fixed-point.
              system_constants_used_ |= 1ull
                                        << kSysConst_EdramRTFormatFlags_Index;
              a_.OpAnd(temp_x_dest, rt_format_flags_src,
                       dxbc::Src::LU(kRTFormatFlag_FixedPointColor));
              // Check if the source color factor needs clamping.
              a_.OpIf(true, temp_x_src);
              {
                // Clamp the source color factor in blend_src_temp.xyz.
                // blend_src_temp.xyz = source color factor.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(blend_src_temp_rgb_dest, blend_src_temp_src,
                         rt_clamp_vec_src.Select(0));
                a_.OpMin(blend_src_temp_rgb_dest, blend_src_temp_src,
                         rt_clamp_vec_src.Select(2));
              }
              // Close the source color factor clamping check.
              a_.OpEndIf();
              // Apply the factor to the source color.
              // blend_src_temp.xyz = unclamped source color part without
              //                      addition sign.
              a_.OpMul(blend_src_temp_rgb_dest,
                       dxbc::Src::R(system_temps_color_[i]),
                       blend_src_temp_src);
              // Check if the source color part needs clamping after the
              // multiplication.
              // temp.x = free.
              a_.OpIf(true, temp_x_src);
              {
                // Clamp the source color part.
                // blend_src_temp.xyz = source color part without addition sign.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(blend_src_temp_rgb_dest, blend_src_temp_src,
                         rt_clamp_vec_src.Select(0));
                a_.OpMin(blend_src_temp_rgb_dest, blend_src_temp_src,
                         rt_clamp_vec_src.Select(2));
              }
              // Close the source color part clamping check.
              a_.OpEndIf();
              // Extract the source color sign to temp.x.
              // temp.x = source color sign as zero for 1 and non-zero for -1.
              system_constants_used_ |=
                  1ull << kSysConst_EdramRTBlendFactorsOps_Index;
              a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                       dxbc::Src::LU(1 << (5 + 2)));
              // Apply the source color sign.
              // blend_src_temp.xyz = source color part.
              // temp.x = free.
              a_.OpMovC(blend_src_temp_rgb_dest, temp_x_src,
                        -blend_src_temp_src, blend_src_temp_src);
            }
            // The source color factor is zero.
            a_.OpElse();
            {
              // Write zero to the source color part.
              // blend_src_temp.xyz = source color part.
              // temp.x = free.
              a_.OpMov(blend_src_temp_rgb_dest, dxbc::Src::LF(0.0f));
            }
            // Close the source color factor zero check.
            a_.OpEndIf();

            // Extract the destination color factor to temp.x.
            // temp.x = destination color factor index.
            system_constants_used_ |= 1ull
                                      << kSysConst_EdramRTBlendFactorsOps_Index;
            a_.OpUBFE(temp_x_dest, dxbc::Src::LU(5), dxbc::Src::LU(8),
                      rt_blend_factors_ops_src);
            // Check if the destination color factor is not zero.
            a_.OpIf(true, temp_x_src);
            {
              uint32_t blend_dest_factor_temp = PushSystemTemp();
              dxbc::Src blend_dest_factor_temp_src(
                  dxbc::Src::R(blend_dest_factor_temp));
              // Open the switch for choosing the destination color blend
              // factor.
              // temp.x = free.
              a_.OpSwitch(temp_x_src);
              // Write the destination color factor to
              // blend_dest_factor_temp.xyz.
              // blend_dest_factor_temp.xyz = unclamped destination color
              //                              factor.
              ROV_HandleColorBlendFactorCases(
                  system_temps_color_[i], color_temp, blend_dest_factor_temp);
              // Close the destination color factor switch.
              a_.OpEndSwitch();
              // Get if the render target color is fixed-point and the
              // destination color factor needs clamping to temp.x.
              // temp.x = whether color is fixed-point.
              system_constants_used_ |= 1ull
                                        << kSysConst_EdramRTFormatFlags_Index;
              a_.OpAnd(temp_x_dest, rt_format_flags_src,
                       dxbc::Src::LU(kRTFormatFlag_FixedPointColor));
              // Check if the destination color factor needs clamping.
              a_.OpIf(true, temp_x_src);
              {
                // Clamp the destination color factor in
                // blend_dest_factor_temp.xyz.
                // blend_dest_factor_temp.xyz = destination color factor.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(dxbc::Dest::R(blend_dest_factor_temp, 0b0111),
                         blend_dest_factor_temp_src,
                         rt_clamp_vec_src.Select(0));
                a_.OpMin(dxbc::Dest::R(blend_dest_factor_temp, 0b0111),
                         blend_dest_factor_temp_src,
                         rt_clamp_vec_src.Select(2));
              }
              // Close the destination color factor clamping check.
              a_.OpEndIf();
              // Apply the factor to the destination color in color_temp.xyz.
              // color_temp.xyz = unclamped destination color part without
              //                  addition sign.
              // blend_dest_temp.xyz = free.
              a_.OpMul(color_temp_rgb_dest, color_temp_src,
                       blend_dest_factor_temp_src);
              // Release blend_dest_factor_temp.
              PopSystemTemp();
              // Check if the destination color part needs clamping after the
              // multiplication.
              // temp.x = free.
              a_.OpIf(true, temp_x_src);
              {
                // Clamp the destination color part.
                // color_temp.xyz = destination color part without addition
                // sign.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(color_temp_rgb_dest, color_temp_src,
                         rt_clamp_vec_src.Select(0));
                a_.OpMin(color_temp_rgb_dest, color_temp_src,
                         rt_clamp_vec_src.Select(2));
              }
              // Close the destination color part clamping check.
              a_.OpEndIf();
              // Extract the destination color sign to temp.x.
              // temp.x = destination color sign as zero for 1 and non-zero for
              //          -1.
              system_constants_used_ |=
                  1ull << kSysConst_EdramRTBlendFactorsOps_Index;
              a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                       dxbc::Src::LU(1 << 5));
              // Select the sign for destination multiply-add as 1.0 or -1.0 to
              // temp.x.
              // temp.x = destination color sign as float.
              a_.OpMovC(temp_x_dest, temp_x_src, dxbc::Src::LF(-1.0f),
                        dxbc::Src::LF(1.0f));
              // Perform color blending to color_temp.xyz.
              // color_temp.xyz = unclamped blended color.
              // blend_src_temp.xyz = free.
              // temp.x = free.
              a_.OpMAd(color_temp_rgb_dest, color_temp_src, temp_x_src,
                       blend_src_temp_src);
            }
            // The destination color factor is zero.
            a_.OpElse();
            {
              // Write the source color part without applying the destination
              // color.
              // color_temp.xyz = unclamped blended color.
              // blend_src_temp.xyz = free.
              // temp.x = free.
              a_.OpMov(color_temp_rgb_dest, blend_src_temp_src);
            }
            // Close the destination color factor zero check.
            a_.OpEndIf();

            // Release blend_src_temp.
            PopSystemTemp();

            // Clamp the color in color_temp.xyz before packing.
            // color_temp.xyz = blended color.
            system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
            a_.OpMax(color_temp_rgb_dest, color_temp_src,
                     rt_clamp_vec_src.Select(0));
            a_.OpMin(color_temp_rgb_dest, color_temp_src,
                     rt_clamp_vec_src.Select(2));
          }
          // Need to do min/max for color.
          a_.OpElse();
          {
            // Extract the color min (0) or max (1) bit to temp.x
            // temp.x = whether min or max should be used for color.
            system_constants_used_ |= 1ull
                                      << kSysConst_EdramRTBlendFactorsOps_Index;
            a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                     dxbc::Src::LU(1 << 5));
            // Check if need to do min or max for color.
            // temp.x = free.
            a_.OpIf(true, temp_x_src);
            {
              // Choose max of the colors without applying the factors to
              // color_temp.xyz.
              // color_temp.xyz = blended color.
              a_.OpMax(color_temp_rgb_dest,
                       dxbc::Src::R(system_temps_color_[i]), color_temp_src);
            }
            // Need to do min.
            a_.OpElse();
            {
              // Choose min of the colors without applying the factors to
              // color_temp.xyz.
              // color_temp.xyz = blended color.
              a_.OpMin(color_temp_rgb_dest,
                       dxbc::Src::R(system_temps_color_[i]), color_temp_src);
            }
            // Close the min or max check.
            a_.OpEndIf();
          }
          // Close the color factor blending or min/max check.
          a_.OpEndIf();

          // *******************************************************************
          // Alpha blending.
          // *******************************************************************

          // Extract the alpha min/max bit to temp.x.
          // temp.x = whether min/max should be used for alpha.
          system_constants_used_ |= 1ull
                                    << kSysConst_EdramRTBlendFactorsOps_Index;
          a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                   dxbc::Src::LU(1 << (21 + 1)));
          // Check if need to do blend the color with factors.
          // temp.x = free.
          a_.OpIf(false, temp_x_src);
          {
            // Extract the source alpha factor to temp.x.
            // temp.x = source alpha factor index.
            system_constants_used_ |= 1ull
                                      << kSysConst_EdramRTBlendFactorsOps_Index;
            a_.OpUBFE(temp_x_dest, dxbc::Src::LU(5), dxbc::Src::LU(16),
                      rt_blend_factors_ops_src);
            // Check if the source alpha factor is not zero.
            a_.OpIf(true, temp_x_src);
            {
              // Open the switch for choosing the source alpha blend factor.
              // temp.x = free.
              a_.OpSwitch(temp_x_src);
              // Write the source alpha factor to temp.x.
              // temp.x = unclamped source alpha factor.
              ROV_HandleAlphaBlendFactorCases(system_temps_color_[i],
                                              color_temp, temp, 0);
              // Close the source alpha factor switch.
              a_.OpEndSwitch();
              // Get if the render target alpha is fixed-point and the source
              // alpha factor needs clamping to temp.y.
              // temp.y = whether alpha is fixed-point.
              system_constants_used_ |= 1ull
                                        << kSysConst_EdramRTFormatFlags_Index;
              a_.OpAnd(temp_y_dest, rt_format_flags_src,
                       dxbc::Src::LU(kRTFormatFlag_FixedPointAlpha));
              // Check if the source alpha factor needs clamping.
              a_.OpIf(true, temp_y_src);
              {
                // Clamp the source alpha factor in temp.x.
                // temp.x = source alpha factor.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(temp_x_dest, temp_x_src, rt_clamp_vec_src.Select(1));
                a_.OpMin(temp_x_dest, temp_x_src, rt_clamp_vec_src.Select(3));
              }
              // Close the source alpha factor clamping check.
              a_.OpEndIf();
              // Apply the factor to the source alpha.
              // temp.x = unclamped source alpha part without addition sign.
              a_.OpMul(temp_x_dest,
                       dxbc::Src::R(system_temps_color_[i], dxbc::Src::kWWWW),
                       temp_x_src);
              // Check if the source alpha part needs clamping after the
              // multiplication.
              // temp.y = free.
              a_.OpIf(true, temp_y_src);
              {
                // Clamp the source alpha part.
                // temp.x = source alpha part without addition sign.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(temp_x_dest, temp_x_src, rt_clamp_vec_src.Select(1));
                a_.OpMin(temp_x_dest, temp_x_src, rt_clamp_vec_src.Select(3));
              }
              // Close the source alpha part clamping check.
              a_.OpEndIf();
              // Extract the source alpha sign to temp.y.
              // temp.y = source alpha sign as zero for 1 and non-zero for -1.
              system_constants_used_ |=
                  1ull << kSysConst_EdramRTBlendFactorsOps_Index;
              a_.OpAnd(temp_y_dest, rt_blend_factors_ops_src,
                       dxbc::Src::LU(1 << (21 + 2)));
              // Apply the source alpha sign.
              // temp.x = source alpha part.
              a_.OpMovC(temp_x_dest, temp_y_src, -temp_x_src, temp_x_src);
            }
            // The source alpha factor is zero.
            a_.OpElse();
            {
              // Write zero to the source alpha part.
              // temp.x = source alpha part.
              a_.OpMov(temp_x_dest, dxbc::Src::LF(0.0f));
            }
            // Close the source alpha factor zero check.
            a_.OpEndIf();

            // Extract the destination alpha factor to temp.y.
            // temp.y = destination alpha factor index.
            system_constants_used_ |= 1ull
                                      << kSysConst_EdramRTBlendFactorsOps_Index;
            a_.OpUBFE(temp_y_dest, dxbc::Src::LU(5), dxbc::Src::LU(24),
                      rt_blend_factors_ops_src);
            // Check if the destination alpha factor is not zero.
            a_.OpIf(true, temp_y_src);
            {
              // Open the switch for choosing the destination alpha blend
              // factor.
              // temp.y = free.
              a_.OpSwitch(temp_y_src);
              // Write the destination alpha factor to temp.y.
              // temp.y = unclamped destination alpha factor.
              ROV_HandleAlphaBlendFactorCases(system_temps_color_[i],
                                              color_temp, temp, 1);
              // Close the destination alpha factor switch.
              a_.OpEndSwitch();
              // Get if the render target alpha is fixed-point and the
              // destination alpha factor needs clamping.
              // alpha_is_fixed_temp.x = whether alpha is fixed-point.
              uint32_t alpha_is_fixed_temp = PushSystemTemp();
              system_constants_used_ |= 1ull
                                        << kSysConst_EdramRTFormatFlags_Index;
              a_.OpAnd(dxbc::Dest::R(alpha_is_fixed_temp, 0b0001),
                       rt_format_flags_src,
                       dxbc::Src::LU(kRTFormatFlag_FixedPointAlpha));
              // Check if the destination alpha factor needs clamping.
              a_.OpIf(true,
                      dxbc::Src::R(alpha_is_fixed_temp, dxbc::Src::kXXXX));
              {
                // Clamp the destination alpha factor in temp.y.
                // temp.y = destination alpha factor.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(temp_y_dest, temp_y_src, rt_clamp_vec_src.Select(1));
                a_.OpMin(temp_y_dest, temp_y_src, rt_clamp_vec_src.Select(3));
              }
              // Close the destination alpha factor clamping check.
              a_.OpEndIf();
              // Apply the factor to the destination alpha in color_temp.w.
              // color_temp.w = unclamped destination alpha part without
              //                addition sign.
              a_.OpMul(color_temp_a_dest, color_temp_a_src, temp_y_src);
              // Check if the destination alpha part needs clamping after the
              // multiplication.
              // alpha_is_fixed_temp.x = free.
              a_.OpIf(true,
                      dxbc::Src::R(alpha_is_fixed_temp, dxbc::Src::kXXXX));
              // Release alpha_is_fixed_temp.
              PopSystemTemp();
              {
                // Clamp the destination alpha part.
                // color_temp.w = destination alpha part without addition sign.
                system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
                a_.OpMax(color_temp_a_dest, color_temp_a_src,
                         rt_clamp_vec_src.Select(1));
                a_.OpMin(color_temp_a_dest, color_temp_a_src,
                         rt_clamp_vec_src.Select(3));
              }
              // Close the destination alpha factor clamping check.
              a_.OpEndIf();
              // Extract the destination alpha sign to temp.y.
              // temp.y = destination alpha sign as zero for 1 and non-zero for
              //          -1.
              system_constants_used_ |=
                  1ull << kSysConst_EdramRTBlendFactorsOps_Index;
              a_.OpAnd(temp_y_dest, rt_blend_factors_ops_src,
                       dxbc::Src::LU(1 << 21));
              // Select the sign for destination multiply-add as 1.0 or -1.0 to
              // temp.y.
              // temp.y = destination alpha sign as float.
              a_.OpMovC(temp_y_dest, temp_y_src, dxbc::Src::LF(-1.0f),
                        dxbc::Src::LF(1.0f));
              // Perform alpha blending to color_temp.w.
              // color_temp.w = unclamped blended alpha.
              // temp.xy = free.
              a_.OpMAd(color_temp_a_dest, color_temp_a_src, temp_y_src,
                       temp_x_src);
            }
            // The destination alpha factor is zero.
            a_.OpElse();
            {
              // Write the source alpha part without applying the destination
              // alpha.
              // color_temp.w = unclamped blended alpha.
              // temp.xy = free.
              a_.OpMov(color_temp_a_dest, temp_x_src);
            }
            // Close the destination alpha factor zero check.
            a_.OpEndIf();

            // Clamp the alpha in color_temp.w before packing.
            // color_temp.w = blended alpha.
            system_constants_used_ |= 1ull << kSysConst_EdramRTClamp_Index;
            a_.OpMax(color_temp_a_dest, color_temp_a_src,
                     rt_clamp_vec_src.Select(1));
            a_.OpMin(color_temp_a_dest, color_temp_a_src,
                     rt_clamp_vec_src.Select(3));
          }
          // Need to do min/max for alpha.
          a_.OpElse();
          {
            // Extract the alpha min (0) or max (1) bit to temp.x.
            // temp.x = whether min or max should be used for alpha.
            system_constants_used_ |= 1ull
                                      << kSysConst_EdramRTBlendFactorsOps_Index;
            a_.OpAnd(temp_x_dest, rt_blend_factors_ops_src,
                     dxbc::Src::LU(1 << 21));
            // Check if need to do min or max for alpha.
            // temp.x = free.
            a_.OpIf(true, temp_x_src);
            {
              // Choose max of the alphas without applying the factors to
              // color_temp.w.
              // color_temp.w = blended alpha.
              a_.OpMax(color_temp_a_dest,
                       dxbc::Src::R(system_temps_color_[i], dxbc::Src::kWWWW),
                       color_temp_a_src);
            }
            // Need to do min.
            a_.OpElse();
            {
              // Choose min of the alphas without applying the factors to
              // color_temp.w.
              // color_temp.w = blended alpha.
              a_.OpMin(color_temp_a_dest,
                       dxbc::Src::R(system_temps_color_[i], dxbc::Src::kWWWW),
                       color_temp_a_src);
            }
            // Close the min or max check.
            a_.OpEndIf();
          }
          // Close the alpha factor blending or min/max check.
          a_.OpEndIf();

          // Pack the new color/alpha to temp.xy.
          // temp.xy = packed new color/alpha.
          uint32_t color_pack_temp = PushSystemTemp();
          ROV_PackPreClampedColor(i, color_temp, temp, 0, color_pack_temp, 0,
                                  color_pack_temp, 1);
          // Release color_pack_temp.
          PopSystemTemp();
        }
        // Close the blending check.
        a_.OpEndIf();

        // *********************************************************************
        // Write mask application
        // *********************************************************************

        // Apply the keep mask to the previous packed color/alpha in temp.zw.
        // temp.zw = masked packed old color/alpha.
        system_constants_used_ |= 1ull << kSysConst_EdramRTKeepMask_Index;
        a_.OpAnd(dxbc::Dest::R(temp, 0b1100), dxbc::Src::R(temp),
                 keep_mask_vec_src.Swizzle(keep_mask_swizzle << 4));
        // Invert the keep mask into color_temp.xy.
        // color_temp.xy = inverted keep mask (write mask).
        system_constants_used_ |= 1ull << kSysConst_EdramRTKeepMask_Index;
        a_.OpNot(dxbc::Dest::R(color_temp, 0b0011),
                 keep_mask_vec_src.Swizzle(keep_mask_swizzle));
        // Release color_temp.
        PopSystemTemp();
        // Apply the write mask to the new color/alpha in temp.xy.
        // temp.xy = masked packed new color/alpha.
        a_.OpAnd(dxbc::Dest::R(temp, 0b0011), dxbc::Src::R(temp),
                 dxbc::Src::R(color_temp));
        // Combine the masked colors into temp.xy.
        // temp.xy = packed resulting color/alpha.
        // temp.zw = free.
        a_.OpOr(dxbc::Dest::R(temp, 0b0011), dxbc::Src::R(temp),
                dxbc::Src::R(temp, 0b1110));
      }
      // Close the previous color load check.
      a_.OpEndIf();

      // ***********************************************************************
      // Writing the color
      // ***********************************************************************

      // Get if the format is 64bpp to temp.z.
      // temp.z = whether the render target is 64bpp.
      system_constants_used_ |= 1ull << kSysConst_EdramRTFormatFlags_Index;
      a_.OpAnd(temp_z_dest, rt_format_flags_src,
               dxbc::Src::LU(kRTFormatFlag_64bpp));
      // Check if the format is 64bpp.
      // temp.z = free.
      a_.OpIf(true, temp_z_src);
      {
        // Store the lower 32 bits of the 64bpp color.
        if (uav_index_edram_ == kBindingIndexUnallocated) {
          uav_index_edram_ = uav_count_++;
        }
        a_.OpStoreUAVTyped(
            dxbc::Dest::U(uav_index_edram_, uint32_t(UAVRegister::kEdram)),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW), 1,
            temp_x_src);
        // Get the address of the upper 32 bits of the color to temp.z (can't
        // use temp.x because components when not blending, packing is done once
        // for all samples, so it has to be preserved).
        a_.OpIAdd(temp_z_dest,
                  dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
                  dxbc::Src::LU(1));
        // Store the upper 32 bits of the 64bpp color.
        if (uav_index_edram_ == kBindingIndexUnallocated) {
          uav_index_edram_ = uav_count_++;
        }
        a_.OpStoreUAVTyped(
            dxbc::Dest::U(uav_index_edram_, uint32_t(UAVRegister::kEdram)),
            temp_z_src, 1, temp_y_src);
      }
      // The color is 32bpp.
      a_.OpElse();
      {
        // Store the 32bpp color.
        if (uav_index_edram_ == kBindingIndexUnallocated) {
          uav_index_edram_ = uav_count_++;
        }
        a_.OpStoreUAVTyped(
            dxbc::Dest::U(uav_index_edram_, uint32_t(UAVRegister::kEdram)),
            dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ), 1,
            temp_x_src);
      }
      // Close the 64bpp/32bpp conditional.
      a_.OpEndIf();

      // ***********************************************************************
      // End of color sample raster operation.
      // ***********************************************************************

      // Close the sample covered check.
      a_.OpEndIf();

      // Go to the next sample (samples are at +0, +80, +1, +81, so need to do
      // +80, -79, +80 and -81 after each sample).
      int32_t next_sample_distance =
          ((j & 1) ? -78 - j : 80) * int32_t(resolution_scale_square);
      a_.OpIAdd(
          dxbc::Dest::R(system_temp_rov_params_, 0b1100),
          dxbc::Src::R(system_temp_rov_params_),
          dxbc::Src::LI(0, 0, next_sample_distance, next_sample_distance * 2));
    }

    // Revert adding the EDRAM bases of the render target to
    // system_temp_rov_params_.zw.
    system_constants_used_ |= 1ull << kSysConst_EdramRTBaseDwordsScaled_Index;
    a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
              dxbc::Src::R(system_temp_rov_params_),
              -dxbc::Src::CB(cbuffer_index_system_constants_,
                             uint32_t(CbufferRegister::kSystemConstants),
                             kSysConst_EdramRTBaseDwordsScaled_Vec)
                   .Select(i));
    // Close the render target write check.
    a_.OpEndIf();
  }

  // Release temp.
  PopSystemTemp();
}

void DxbcShaderTranslator::CompletePixelShader() {
  if (is_depth_only_pixel_shader_) {
    // The depth-only shader only needs to do the depth test and to write the
    // depth to the ROV.
    if (edram_rov_used_) {
      CompletePixelShader_WriteToROV();
    }
    return;
  }

  if (current_shader().writes_color_target(0)) {
    // Alpha test.
    // X - mask, then masked result (SGPR for loading, VGPR for masking).
    // Y - operation result (SGPR for mask operations, VGPR for alpha
    //     operations).
    uint32_t alpha_test_temp = PushSystemTemp();
    dxbc::Dest alpha_test_mask_dest(dxbc::Dest::R(alpha_test_temp, 0b0001));
    dxbc::Src alpha_test_mask_src(
        dxbc::Src::R(alpha_test_temp, dxbc::Src::kXXXX));
    dxbc::Dest alpha_test_op_dest(dxbc::Dest::R(alpha_test_temp, 0b0010));
    dxbc::Src alpha_test_op_src(
        dxbc::Src::R(alpha_test_temp, dxbc::Src::kYYYY));
    // Extract the comparison mask to check if the test needs to be done at all.
    // Don't care about flow control being somewhat dynamic - early Z is forced
    // using a special version of the shader anyway.
    system_constants_used_ |= 1ull << kSysConst_Flags_Index;
    a_.OpUBFE(alpha_test_mask_dest, dxbc::Src::LU(3),
              dxbc::Src::LU(kSysFlag_AlphaPassIfLess_Shift),
              dxbc::Src::CB(cbuffer_index_system_constants_,
                            uint32_t(CbufferRegister::kSystemConstants),
                            kSysConst_Flags_Vec)
                  .Select(kSysConst_Flags_Comp));
    // Compare the mask to ALWAYS to check if the test shouldn't be done (will
    // pass even for NaNs, though the expected behavior in this case hasn't been
    // checked, but let's assume this means "always", not "less, equal or
    // greater".
    // TODO(Triang3l): Check how alpha test works with NaN on Direct3D 9.
    a_.OpINE(alpha_test_op_dest, alpha_test_mask_src, dxbc::Src::LU(0b111));
    // Don't do the test if the mode is "always".
    a_.OpIf(true, alpha_test_op_src);
    {
      // Do the test. Can't use subtraction and sign because of float specials.
      dxbc::Src alpha_src(
          dxbc::Src::R(system_temps_color_[0], dxbc::Src::kWWWW));
      system_constants_used_ |= 1ull << kSysConst_AlphaTestReference_Index;
      dxbc::Src alpha_test_reference_src(
          dxbc::Src::CB(cbuffer_index_system_constants_,
                        uint32_t(CbufferRegister::kSystemConstants),
                        kSysConst_AlphaTestReference_Vec)
              .Select(kSysConst_AlphaTestReference_Comp));
      // Less than.
      a_.OpLT(alpha_test_op_dest, alpha_src, alpha_test_reference_src);
      a_.OpOr(alpha_test_op_dest, alpha_test_op_src,
              dxbc::Src::LU(~uint32_t(1 << 0)));
      a_.OpAnd(alpha_test_mask_dest, alpha_test_mask_src, alpha_test_op_src);
      // Equals to.
      a_.OpEq(alpha_test_op_dest, alpha_src, alpha_test_reference_src);
      a_.OpOr(alpha_test_op_dest, alpha_test_op_src,
              dxbc::Src::LU(~uint32_t(1 << 1)));
      a_.OpAnd(alpha_test_mask_dest, alpha_test_mask_src, alpha_test_op_src);
      // Greater than.
      a_.OpLT(alpha_test_op_dest, alpha_test_reference_src, alpha_src);
      a_.OpOr(alpha_test_op_dest, alpha_test_op_src,
              dxbc::Src::LU(~uint32_t(1 << 2)));
      a_.OpAnd(alpha_test_mask_dest, alpha_test_mask_src, alpha_test_op_src);
      // Discard the pixel if it has failed the test.
      if (edram_rov_used_) {
        a_.OpRetC(false, alpha_test_mask_src);
      } else {
        a_.OpDiscard(false, alpha_test_mask_src);
      }
    }
    // Close the "not always" check.
    a_.OpEndIf();
    // Release alpha_test_temp.
    PopSystemTemp();
  }

  // Discard samples with alpha to coverage.
  CompletePixelShader_AlphaToMask();

  // Write the values to the render targets. Not applying the exponent bias yet
  // because the original 0 to 1 alpha value is needed for alpha to coverage,
  // which is done differently for ROV and RTV/DSV.
  if (edram_rov_used_) {
    CompletePixelShader_WriteToROV();
  } else {
    CompletePixelShader_WriteToRTVs();
    CompletePixelShader_DSV_DepthTo24Bit();
  }
}

void DxbcShaderTranslator::PreClampedFloat32To7e3(
    dxbc::Assembler& a, uint32_t f10_temp, uint32_t f10_temp_component,
    uint32_t f32_temp, uint32_t f32_temp_component, uint32_t temp_temp,
    uint32_t temp_temp_component) {
  assert_true(temp_temp != f10_temp ||
              temp_temp_component != f10_temp_component);
  assert_true(temp_temp != f32_temp ||
              temp_temp_component != f32_temp_component);
  // Source and destination may be the same.
  dxbc::Dest f10_dest(dxbc::Dest::R(f10_temp, 1 << f10_temp_component));
  dxbc::Src f10_src(dxbc::Src::R(f10_temp).Select(f10_temp_component));
  dxbc::Src f32_src(dxbc::Src::R(f32_temp).Select(f32_temp_component));
  dxbc::Dest temp_dest(dxbc::Dest::R(temp_temp, 1 << temp_temp_component));
  dxbc::Src temp_src(dxbc::Src::R(temp_temp).Select(temp_temp_component));

  // https://github.com/Microsoft/DirectXTex/blob/master/DirectXTex/DirectXTexConvert.cpp
  // Assuming the color is already clamped to [0, 31.875].

  // Check if the number is too small to be represented as normalized 20e4.
  // temp = f32 < 2^-2
  a.OpULT(temp_dest, f32_src, dxbc::Src::LU(0x3E800000));
  // Handle denormalized numbers separately.
  a.OpIf(true, temp_src);
  {
    // temp = f32 >> 23
    a.OpUShR(temp_dest, f32_src, dxbc::Src::LU(23));
    // temp = 125 - (f32 >> 23)
    a.OpIAdd(temp_dest, dxbc::Src::LI(125), -temp_src);
    // Don't allow the shift to overflow, since in DXBC the lower 5 bits of the
    // shift amount are used.
    // temp = min(125 - (f32 >> 23), 24)
    a.OpUMin(temp_dest, temp_src, dxbc::Src::LU(24));
    // biased_f32 = (f32 & 0x7FFFFF) | 0x800000
    a.OpBFI(f10_dest, dxbc::Src::LU(9), dxbc::Src::LU(23), dxbc::Src::LU(1),
            f32_src);
    // biased_f32 = ((f32 & 0x7FFFFF) | 0x800000) >> min(125 - (f32 >> 23), 24)
    a.OpUShR(f10_dest, f10_src, temp_src);
  }
  // Not denormalized?
  a.OpElse();
  {
    // Bias the exponent.
    // biased_f32 = f32 + (-124 << 23)
    // (left shift of a negative value is undefined behavior)
    a.OpIAdd(f10_dest, f32_src, dxbc::Src::LU(0xC2000000u));
  }
  // Close the denormal check.
  a.OpEndIf();
  // Build the 7e3 number.
  // temp = (biased_f32 >> 16) & 1
  a.OpUBFE(temp_dest, dxbc::Src::LU(1), dxbc::Src::LU(16), f10_src);
  // f10 = biased_f32 + 0x7FFF
  a.OpIAdd(f10_dest, f10_src, dxbc::Src::LU(0x7FFF));
  // f10 = biased_f32 + 0x7FFF + ((biased_f32 >> 16) & 1)
  a.OpIAdd(f10_dest, f10_src, temp_src);
  // f24 = ((biased_f32 + 0x7FFF + ((biased_f32 >> 16) & 1)) >> 16) & 0x3FF
  a.OpUBFE(f10_dest, dxbc::Src::LU(10), dxbc::Src::LU(16), f10_src);
}

void DxbcShaderTranslator::UnclampedFloat32To7e3(
    dxbc::Assembler& a, uint32_t f10_temp, uint32_t f10_temp_component,
    uint32_t f32_temp, uint32_t f32_temp_component, uint32_t temp_temp,
    uint32_t temp_temp_component) {
  // Source and destination might be the same or different, just like in
  // PreClampedFloat32To7e3 - clamp to the destination and use it as source.
  a.OpMax(dxbc::Dest::R(f10_temp, 1 << f10_temp_component),
          dxbc::Src::R(f32_temp).Select(f32_temp_component),
          dxbc::Src::LF(0.0f));
  a.OpMin(dxbc::Dest::R(f10_temp, 1 << f10_temp_component),
          dxbc::Src::R(f10_temp).Select(f10_temp_component),
          dxbc::Src::LF(31.875f));
  PreClampedFloat32To7e3(a, f10_temp, f10_temp_component, f10_temp,
                         f10_temp_component, temp_temp, temp_temp_component);
}

void DxbcShaderTranslator::Float7e3To32(
    dxbc::Assembler& a, const dxbc::Dest& f32, uint32_t f10_temp,
    uint32_t f10_temp_component, uint32_t f10_shift, uint32_t temp1_temp,
    uint32_t temp1_temp_component, uint32_t temp2_temp,
    uint32_t temp2_temp_component) {
  assert_true(f10_shift <= (32 - 10));
  assert_true(temp1_temp != temp2_temp ||
              temp1_temp_component != temp2_temp_component);
  // Source may be the same as temp1 or temp2.
  dxbc::Dest exponent_dest(
      dxbc::Dest::R(temp1_temp, 1 << temp1_temp_component));
  dxbc::Src exponent_src(dxbc::Src::R(temp1_temp).Select(temp1_temp_component));
  dxbc::Dest mantissa_dest(
      dxbc::Dest::R(temp2_temp, 1 << temp2_temp_component));
  dxbc::Src mantissa_src(dxbc::Src::R(temp2_temp).Select(temp2_temp_component));

  // https://github.com/Microsoft/DirectXTex/blob/master/DirectXTex/DirectXTexConvert.cpp

  if (!(f10_temp == temp1_temp && f10_temp_component == temp1_temp_component)) {
    // Unpack the exponent before the mantissa if that doesn't overwrite the
    // source.
    a.OpUBFE(exponent_dest, dxbc::Src::LU(3), dxbc::Src::LU(f10_shift + 7),
             dxbc::Src::R(f10_temp).Select(f10_temp_component));
  }
  // Unpack the mantissa.
  a.OpUBFE(mantissa_dest, dxbc::Src::LU(7), dxbc::Src::LU(f10_shift),
           dxbc::Src::R(f10_temp).Select(f10_temp_component));
  if (f10_temp == temp1_temp && f10_temp_component == temp1_temp_component) {
    // Unpack the exponent after the mantissa if doing that before the mantissa
    // would overwrite the source.
    a.OpUBFE(exponent_dest, dxbc::Src::LU(3), dxbc::Src::LU(f10_shift + 7),
             dxbc::Src::R(f10_temp).Select(f10_temp_component));
  }
  // Check if the number is denormalized.
  a.OpIf(false, exponent_src);
  {
    // Check if the number is non-zero (if the mantissa isn't zero - the
    // exponent is known to be zero at this point).
    a.OpIf(true, mantissa_src);
    {
      // Normalize the mantissa.
      // Note that HLSL firstbithigh(x) is compiled to DXBC like:
      // `x ? 31 - firstbit_hi(x) : -1`
      // (returns the index from the LSB, not the MSB, but -1 for zero too).
      // exponent = firstbit_hi(mantissa)
      a.OpFirstBitHi(exponent_dest, mantissa_src);
      // exponent = 7 - firstbithigh(mantissa)
      // Or:
      // exponent = 7 - (31 - firstbit_hi(mantissa))
      a.OpIAdd(exponent_dest, exponent_src, dxbc::Src::LI(7 - 31));
      // mantissa = mantissa << (7 - firstbithigh(mantissa))
      // AND 0x7F not needed after this - BFI will do it.
      a.OpIShL(mantissa_dest, mantissa_src, exponent_src);
      // Get the normalized exponent.
      // exponent = 1 - (7 - firstbithigh(mantissa))
      a.OpIAdd(exponent_dest, dxbc::Src::LI(1), -exponent_src);
    }
    // The number is zero.
    a.OpElse();
    {
      // Set the unbiased exponent to -124 for zero - 124 will be added later,
      // resulting in zero float32.
      a.OpMov(exponent_dest, dxbc::Src::LI(-124));
    }
    // Close the non-zero check.
    a.OpEndIf();
  }
  // Close the denormal check.
  a.OpEndIf();
  // Bias the exponent and move it to the correct location in f32.
  a.OpIMAd(exponent_dest, exponent_src, dxbc::Src::LI(1 << 23),
           dxbc::Src::LI(124 << 23));
  // Combine the mantissa and the exponent.
  a.OpBFI(f32, dxbc::Src::LU(7), dxbc::Src::LU(23 - 7), mantissa_src,
          exponent_src);
}

void DxbcShaderTranslator::PreClampedDepthTo20e4(
    dxbc::Assembler& a, uint32_t f24_temp, uint32_t f24_temp_component,
    uint32_t f32_temp, uint32_t f32_temp_component, uint32_t temp_temp,
    uint32_t temp_temp_component, bool remap_from_0_to_0_5) {
  assert_true(temp_temp != f24_temp ||
              temp_temp_component != f24_temp_component);
  assert_true(temp_temp != f32_temp ||
              temp_temp_component != f32_temp_component);
  // Source and destination may be the same.
  dxbc::Dest f24_dest(dxbc::Dest::R(f24_temp, 1 << f24_temp_component));
  dxbc::Src f24_src(dxbc::Src::R(f24_temp).Select(f24_temp_component));
  dxbc::Src f32_src(dxbc::Src::R(f32_temp).Select(f32_temp_component));
  dxbc::Dest temp_dest(dxbc::Dest::R(temp_temp, 1 << temp_temp_component));
  dxbc::Src temp_src(dxbc::Src::R(temp_temp).Select(temp_temp_component));

  // CFloat24 from d3dref9.dll +
  // https://github.com/Microsoft/DirectXTex/blob/master/DirectXTex/DirectXTexConvert.cpp
  // Assuming the depth is already clamped to [0, 2) (in all places, the depth
  // is written with the saturate flag set).

  uint32_t remap_bias = uint32_t(remap_from_0_to_0_5);

  // Check if the number is too small to be represented as normalized 20e4.
  // temp = f32 < 2^-14
  a.OpULT(temp_dest, f32_src, dxbc::Src::LU(0x38800000 - (remap_bias << 23)));
  // Handle denormalized numbers separately.
  a.OpIf(true, temp_src);
  {
    // temp = f32 >> 23
    a.OpUShR(temp_dest, f32_src, dxbc::Src::LU(23));
    // temp = 113 - (f32 >> 23)
    a.OpIAdd(temp_dest, dxbc::Src::LI(113 - remap_bias), -temp_src);
    // Don't allow the shift to overflow, since in DXBC the lower 5 bits of the
    // shift amount are used (otherwise 0 becomes 8).
    // temp = min(113 - (f32 >> 23), 24)
    a.OpUMin(temp_dest, temp_src, dxbc::Src::LU(24));
    // biased_f32 = (f32 & 0x7FFFFF) | 0x800000
    a.OpBFI(f24_dest, dxbc::Src::LU(9), dxbc::Src::LU(23), dxbc::Src::LU(1),
            f32_src);
    // biased_f32 = ((f32 & 0x7FFFFF) | 0x800000) >> min(113 - (f32 >> 23), 24)
    a.OpUShR(f24_dest, f24_src, temp_src);
  }
  // Not denormalized?
  a.OpElse();
  {
    // Bias the exponent.
    // biased_f32 = f32 + (-112 << 23)
    // (left shift of a negative value is undefined behavior)
    a.OpIAdd(f24_dest, f32_src,
             dxbc::Src::LU(0xC8000000u + (remap_bias << 23)));
  }
  // Close the denormal check.
  a.OpEndIf();
  // Build the 20e4 number.
  // temp = (biased_f32 >> 3) & 1
  a.OpUBFE(temp_dest, dxbc::Src::LU(1), dxbc::Src::LU(3), f24_src);
  // f24 = biased_f32 + 3
  a.OpIAdd(f24_dest, f24_src, dxbc::Src::LU(3));
  // f24 = biased_f32 + 3 + ((biased_f32 >> 3) & 1)
  a.OpIAdd(f24_dest, f24_src, temp_src);
  // f24 = ((biased_f32 + 3 + ((biased_f32 >> 3) & 1)) >> 3) & 0xFFFFFF
  a.OpUBFE(f24_dest, dxbc::Src::LU(24), dxbc::Src::LU(3), f24_src);
}

void DxbcShaderTranslator::Depth20e4To32(
    dxbc::Assembler& a, const dxbc::Dest& f32, uint32_t f24_temp,
    uint32_t f24_temp_component, uint32_t f24_shift, uint32_t temp1_temp,
    uint32_t temp1_temp_component, uint32_t temp2_temp,
    uint32_t temp2_temp_component, bool remap_to_0_to_0_5) {
  assert_true(f24_shift <= (32 - 24));
  assert_true(temp1_temp != temp2_temp ||
              temp1_temp_component != temp2_temp_component);
  // Source may be the same as temp1 or temp2.
  dxbc::Dest exponent_dest(
      dxbc::Dest::R(temp1_temp, 1 << temp1_temp_component));
  dxbc::Src exponent_src(dxbc::Src::R(temp1_temp).Select(temp1_temp_component));
  dxbc::Dest mantissa_dest(
      dxbc::Dest::R(temp2_temp, 1 << temp2_temp_component));
  dxbc::Src mantissa_src(dxbc::Src::R(temp2_temp).Select(temp2_temp_component));

  // CFloat24 from d3dref9.dll +
  // https://github.com/Microsoft/DirectXTex/blob/master/DirectXTex/DirectXTexConvert.cpp

  uint32_t remap_bias = uint32_t(remap_to_0_to_0_5);

  if (!(f24_temp == temp1_temp && f24_temp_component == temp1_temp_component)) {
    // Unpack the exponent before the mantissa if that doesn't overwrite the
    // source.
    a.OpUBFE(exponent_dest, dxbc::Src::LU(4), dxbc::Src::LU(f24_shift + 20),
             dxbc::Src::R(f24_temp).Select(f24_temp_component));
  }
  // Unpack the mantissa.
  a.OpUBFE(mantissa_dest, dxbc::Src::LU(20), dxbc::Src::LU(f24_shift),
           dxbc::Src::R(f24_temp).Select(f24_temp_component));
  if (f24_temp == temp1_temp && f24_temp_component == temp1_temp_component) {
    // Unpack the exponent after the mantissa if doing that before the mantissa
    // would overwrite the source.
    a.OpUBFE(exponent_dest, dxbc::Src::LU(4), dxbc::Src::LU(f24_shift + 20),
             dxbc::Src::R(f24_temp).Select(f24_temp_component));
  }
  // Check if the number is denormalized.
  a.OpIf(false, exponent_src);
  {
    // Check if the number is non-zero (if the mantissa isn't zero - the
    // exponent is known to be zero at this point).
    a.OpIf(true, mantissa_src);
    {
      // Normalize the mantissa.
      // Note that HLSL firstbithigh(x) is compiled to DXBC like:
      // `x ? 31 - firstbit_hi(x) : -1`
      // (returns the index from the LSB, not the MSB, but -1 for zero too).
      // exponent = firstbit_hi(mantissa)
      a.OpFirstBitHi(exponent_dest, mantissa_src);
      // exponent = 20 - firstbithigh(mantissa)
      // Or:
      // exponent = 20 - (31 - firstbit_hi(mantissa))
      a.OpIAdd(exponent_dest, exponent_src, dxbc::Src::LI(20 - 31));
      // mantissa = mantissa << (20 - firstbithigh(mantissa))
      // AND 0xFFFFF not needed after this - BFI will do it.
      a.OpIShL(mantissa_dest, mantissa_src, exponent_src);
      // Get the normalized exponent.
      // exponent = 1 - (20 - firstbithigh(mantissa))
      a.OpIAdd(exponent_dest, dxbc::Src::LI(1), -exponent_src);
    }
    // The number is zero.
    a.OpElse();
    {
      // Set the unbiased exponent to -112 for zero - 112 will be added later
      // (taking the range remap bias into account), resulting in zero float32.
      a.OpMov(exponent_dest, dxbc::Src::LI(-int32_t(112 - remap_bias)));
    }
    // Close the non-zero check.
    a.OpEndIf();
  }
  // Close the denormal check.
  a.OpEndIf();
  // Bias the exponent and move it to the correct location in f32, and also
  // remap from guest 0...1 to host 0...0.5 if needed.
  a.OpIMAd(exponent_dest, exponent_src, dxbc::Src::LI(1 << 23),
           dxbc::Src::LI((112 - remap_bias) << 23));
  // Combine the mantissa and the exponent.
  a.OpBFI(f32, dxbc::Src::LU(20), dxbc::Src::LU(23 - 20), mantissa_src,
          exponent_src);
}

void DxbcShaderTranslator::ROV_DepthTo24Bit(uint32_t d24_temp,
                                            uint32_t d24_temp_component,
                                            uint32_t d32_temp,
                                            uint32_t d32_temp_component,
                                            uint32_t temp_temp,
                                            uint32_t temp_temp_component) {
  assert_true(temp_temp != d32_temp ||
              temp_temp_component != d32_temp_component);
  // Source and destination may be the same.

  system_constants_used_ |= 1ull << kSysConst_Flags_Index;
  a_.OpAnd(dxbc::Dest::R(temp_temp, 1 << temp_temp_component),
           dxbc::Src::CB(cbuffer_index_system_constants_,
                         uint32_t(CbufferRegister::kSystemConstants),
                         kSysConst_Flags_Vec)
               .Select(kSysConst_Flags_Comp),
           dxbc::Src::LU(kSysFlag_DepthFloat24));
  // Convert according to the format.
  a_.OpIf(true, dxbc::Src::R(temp_temp).Select(temp_temp_component));
  {
    // 20e4 conversion.
    PreClampedDepthTo20e4(a_, d24_temp, d24_temp_component, d32_temp,
                          d32_temp_component, temp_temp, temp_temp_component,
                          false);
  }
  a_.OpElse();
  {
    // Unorm24 conversion.
    dxbc::Dest d24_dest(dxbc::Dest::R(d24_temp, 1 << d24_temp_component));
    dxbc::Src d24_src(dxbc::Src::R(d24_temp).Select(d24_temp_component));
    a_.OpMul(d24_dest, dxbc::Src::R(d32_temp).Select(d32_temp_component),
             dxbc::Src::LF(float(0xFFFFFF)));
    // Round to the nearest even integer. This seems to be the correct way:
    // rounding towards zero gives 0xFF instead of 0x100 in clear shaders in,
    // for instance, Halo 3, but other clear shaders in it are also broken if
    // 0.5 is added before ftou instead of round_ne.
    a_.OpRoundNE(d24_dest, d24_src);
    // Convert to fixed-point.
    a_.OpFToU(d24_dest, d24_src);
  }
  a_.OpEndIf();
}

}  // namespace gpu
}  // namespace xe