ShuriZma
/
xenia-canary
mirror of https://github.com/xenia-canary/xenia-canary.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into vulkan

This commit is contained in:
Triang3l 2021-12-12 21:32:43 +03:00
parent 6630442588 e25167d2bc
commit 95c2101ca9
273 changed files with 82285 additions and 339957 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

248
src/xenia/apu/xaudio2/xaudio2_audio_driver.cc
View File

@ -50,8 +50,6 @@ XAudio2AudioDriver::XAudio2AudioDriver(Memory* memory,
XAudio2AudioDriver::~XAudio2AudioDriver() = default;
bool XAudio2AudioDriver::Initialize() {
HRESULT hr;
voice_callback_ = new VoiceCallback(semaphore_);
// Load the XAudio2 DLL dynamically. Needed both for 2.7 and for
@ -60,77 +58,63 @@ bool XAudio2AudioDriver::Initialize() {
// Windows 10 SDK references XAudio2_9.dll in it, which is only available in
// Windows 10, and XAudio2_8.dll is linked through a different .lib -
// xaudio2_8.lib, so easier not to link the .lib at all.
xaudio2_module_ = reinterpret_cast<void*>(LoadLibraryW(L"XAudio2_8.dll"));
xaudio2_module_ = static_cast<void*>(LoadLibraryW(L"XAudio2_8.dll"));
if (xaudio2_module_) {
api_minor_version_ = 8;
} else {
xaudio2_module_ = reinterpret_cast<void*>(LoadLibraryW(L"XAudio2_7.dll"));
xaudio2_create_ = reinterpret_cast<decltype(xaudio2_create_)>(
GetProcAddress(static_cast<HMODULE>(xaudio2_module_), "XAudio2Create"));
if (xaudio2_create_) {
api_minor_version_ = 8;
} else {
XELOGE("XAudio2Create not found in XAudio2_8.dll");
FreeLibrary(static_cast<HMODULE>(xaudio2_module_));
xaudio2_module_ = nullptr;
}
}
if (!xaudio2_module_) {
xaudio2_module_ = static_cast<void*>(LoadLibraryW(L"XAudio2_7.dll"));
if (xaudio2_module_) {
api_minor_version_ = 7;
} else {
XELOGE("Failed to load XAudio 2.8 or 2.7 library DLL");
assert_always();
return false;
}
}
if (api_minor_version_ >= 8) {
union {
// clang-format off
HRESULT (__stdcall* xaudio2_create)(
api::IXAudio2_8** xaudio2_out, UINT32 flags,
api::XAUDIO2_PROCESSOR xaudio2_processor);
// clang-format on
FARPROC xaudio2_create_ptr;
};
xaudio2_create_ptr = GetProcAddress(
reinterpret_cast<HMODULE>(xaudio2_module_), "XAudio2Create");
if (!xaudio2_create_ptr) {
XELOGE("XAudio2Create not found in XAudio2_8.dll");
assert_always();
return false;
}
hr = xaudio2_create(&objects_.api_2_8.audio, 0, kProcessor);
if (FAILED(hr)) {
XELOGE("XAudio2Create failed with {:08X}", hr);
assert_always();
return false;
}
return InitializeObjects(objects_.api_2_8);
} else {
// We need to be able to accept frames from any non-STA thread - primarily
// from any guest thread, so MTA needs to be used. The AudioDriver, however,
// may be initialized from the UI thread, which has the STA concurrency
// model, or from another thread regardless of its concurrency model. So,
// all management of the objects needs to be performed in MTA. Launch the
// lifecycle management thread, which will handle initialization and
// shutdown, and also provide a scope for implicit MTA in threads that have
// never initialized COM explicitly, which lasts until all threads that have
// initialized MTA explicitly have uninitialized it - the thread that holds
// the MTA scope needs to be running while other threads are able to submit
// frames as they might have not initialized MTA explicitly.
// https://devblogs.microsoft.com/oldnewthing/?p=4613
assert_false(mta_thread_.joinable());
mta_thread_initialization_attempt_completed_ = false;
mta_thread_shutdown_requested_ = false;
mta_thread_ = std::thread(&XAudio2AudioDriver::MTAThread, this);
{
std::unique_lock<std::mutex> mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
while (true) {
if (mta_thread_initialization_attempt_completed_) {
break;
}
mta_thread_initialization_completion_cond_.wait(
mta_thread_initialization_completion_lock);
// We need to be able to accept frames from any non-STA thread - primarily
// from any guest thread, so MTA needs to be used. The AudioDriver, however,
// may be initialized from the UI thread, which has the STA concurrency model,
// or from another thread regardless of its concurrency model. So, all
// management of the objects needs to be performed in MTA. Launch the
// lifecycle management thread, which will handle initialization and shutdown,
// and also provide a scope for implicit MTA in threads that have never
// initialized COM explicitly, which lasts until all threads that have
// initialized MTA explicitly have uninitialized it - the thread that holds
// the MTA scope needs to be running while other threads are able to submit
// frames as they might have not initialized MTA explicitly.
// https://devblogs.microsoft.com/oldnewthing/?p=4613
// This is needed for both XAudio 2.7 (created via explicit CoCreateInstance)
// and 2.8 (using XAudio2Create, but still requiring CoInitializeEx).
// https://docs.microsoft.com/en-us/windows/win32/xaudio2/how-to--initialize-xaudio2
assert_false(mta_thread_.joinable());
mta_thread_initialization_attempt_completed_ = false;
mta_thread_shutdown_requested_ = false;
mta_thread_ = std::thread(&XAudio2AudioDriver::MTAThread, this);
{
std::unique_lock<std::mutex> mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
while (true) {
if (mta_thread_initialization_attempt_completed_) {
break;
}
mta_thread_initialization_completion_cond_.wait(
mta_thread_initialization_completion_lock);
}
if (!mta_thread_initialization_completion_result_) {
mta_thread_.join();
return false;
}
return true;
}
if (!mta_thread_initialization_completion_result_) {
mta_thread_.join();
return false;
}
return true;
}
template <typename Objects>
@ -148,8 +132,8 @@ bool XAudio2AudioDriver::InitializeObjects(Objects& objects) {
hr = objects.audio->CreateMasteringVoice(&objects.mastering_voice);
if (FAILED(hr)) {
XELOGE("IXAudio2::CreateMasteringVoice failed with {:08X}", hr);
assert_always();
XELOGE("IXAudio2::CreateMasteringVoice failed with 0x{:08X}", hr);
ShutdownObjects(objects);
return false;
}
@ -186,15 +170,15 @@ bool XAudio2AudioDriver::InitializeObjects(Objects& objects) {
0, // api::XE_XAUDIO2_VOICE_NOSRC | api::XE_XAUDIO2_VOICE_NOPITCH,
api::XE_XAUDIO2_MAX_FREQ_RATIO, voice_callback_);
if (FAILED(hr)) {
XELOGE("IXAudio2::CreateSourceVoice failed with {:08X}", hr);
assert_always();
XELOGE("IXAudio2::CreateSourceVoice failed with 0x{:08X}", hr);
ShutdownObjects(objects);
return false;
}
hr = objects.pcm_voice->Start();
if (FAILED(hr)) {
XELOGE("IXAudio2SourceVoice::Start failed with {:08X}", hr);
assert_always();
XELOGE("IXAudio2SourceVoice::Start failed with 0x{:08X}", hr);
ShutdownObjects(objects);
return false;
}
@ -242,8 +226,7 @@ void XAudio2AudioDriver::SubmitFrame(uint32_t frame_ptr) {
hr = objects_.api_2_7.pcm_voice->SubmitSourceBuffer(&buffer);
}
if (FAILED(hr)) {
XELOGE("SubmitSourceBuffer failed with {:08X}", hr);
assert_always();
XELOGE("SubmitSourceBuffer failed with 0x{:08X}", hr);
return;
}
@ -260,23 +243,20 @@ void XAudio2AudioDriver::SubmitFrame(uint32_t frame_ptr) {
}
void XAudio2AudioDriver::Shutdown() {
if (api_minor_version_ >= 8) {
ShutdownObjects(objects_.api_2_8);
} else {
// XAudio 2.7 lifecycle is managed by the MTA thread.
if (mta_thread_.joinable()) {
{
std::unique_lock<std::mutex> mta_thread_shutdown_request_lock(
mta_thread_shutdown_request_mutex_);
mta_thread_shutdown_requested_ = true;
}
mta_thread_shutdown_request_cond_.notify_all();
mta_thread_.join();
// XAudio2 lifecycle is managed by the MTA thread.
if (mta_thread_.joinable()) {
{
std::unique_lock<std::mutex> mta_thread_shutdown_request_lock(
mta_thread_shutdown_request_mutex_);
mta_thread_shutdown_requested_ = true;
}
mta_thread_shutdown_request_cond_.notify_all();
mta_thread_.join();
}
xaudio2_create_ = nullptr;
if (xaudio2_module_) {
FreeLibrary(reinterpret_cast<HMODULE>(xaudio2_module_));
FreeLibrary(static_cast<HMODULE>(xaudio2_module_));
xaudio2_module_ = nullptr;
}
@ -307,7 +287,7 @@ void XAudio2AudioDriver::ShutdownObjects(Objects& objects) {
}
void XAudio2AudioDriver::MTAThread() {
xe::threading::set_name("XAudio 2.7 MTA");
xe::threading::set_name("XAudio2 MTA");
assert_false(mta_thread_initialization_attempt_completed_);
@ -315,70 +295,72 @@ void XAudio2AudioDriver::MTAThread() {
// Initializing MTA COM in this thread, as well making other (guest) threads
// that don't explicitly call CoInitializeEx implicitly MTA for the period of
// time when they can interact with XAudio 2.7 through the XAudio2AudioDriver,
// time when they can interact with XAudio through the XAudio2AudioDriver,
// until the CoUninitialize (to be more precise, the CoUninitialize for the
// last remaining MTA thread, but we need implicit MTA for the audio here).
// https://devblogs.microsoft.com/oldnewthing/?p=4613
HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
if (FAILED(hr)) {
XELOGE("XAudio 2.7 MTA thread CoInitializeEx failed with {:08X}", hr);
bool com_initialized = SUCCEEDED(hr);
if (!com_initialized) {
XELOGE("XAudio2 MTA thread CoInitializeEx failed with 0x{:08X}", hr);
} else {
hr = CoCreateInstance(__uuidof(api::XAudio2_7), nullptr,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&objects_.api_2_7.audio));
if (FAILED(hr)) {
XELOGE("CoCreateInstance for XAudio2 failed with {:08X}", hr);
} else {
hr = objects_.api_2_7.audio->Initialize(0, kProcessor);
if (api_minor_version_ >= 8) {
hr = xaudio2_create_(&objects_.api_2_8.audio, 0, kProcessor);
if (FAILED(hr)) {
XELOGE("IXAudio2::Initialize failed with {:08X}", hr);
XELOGE("XAudio2Create failed with 0x{:08X}", hr);
} else {
if (InitializeObjects(objects_.api_2_7)) {
initialized = true;
// Initialized successfully, await a shutdown request while keeping an
// implicit COM MTA scope.
mta_thread_initialization_completion_result_ = true;
{
std::unique_lock<std::mutex>
mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
mta_thread_initialization_attempt_completed_ = true;
}
mta_thread_initialization_completion_cond_.notify_all();
{
std::unique_lock<std::mutex> mta_thread_shutdown_request_lock(
mta_thread_shutdown_request_mutex_);
while (true) {
if (mta_thread_shutdown_requested_) {
break;
}
mta_thread_shutdown_request_cond_.wait(
mta_thread_shutdown_request_lock);
}
}
initialized = InitializeObjects(objects_.api_2_8);
}
} else {
hr = CoCreateInstance(__uuidof(api::XAudio2_7), nullptr,
CLSCTX_INPROC_SERVER,
IID_PPV_ARGS(&objects_.api_2_7.audio));
if (FAILED(hr)) {
XELOGE("CoCreateInstance for XAudio2 failed with 0x{:08X}", hr);
} else {
hr = objects_.api_2_7.audio->Initialize(0, kProcessor);
if (FAILED(hr)) {
XELOGE("IXAudio2::Initialize failed with 0x{:08X}", hr);
} else {
initialized = InitializeObjects(objects_.api_2_7);
}
// Even if InitializeObjects has failed, need to clean up with
// ShutdownObjects.
ShutdownObjects(objects_.api_2_7);
}
}
CoUninitialize();
}
if (!initialized) {
mta_thread_initialization_completion_result_ = false;
// Notify the threads waiting for the initialization of the result.
mta_thread_initialization_completion_result_ = initialized;
{
std::unique_lock<std::mutex> mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
mta_thread_initialization_attempt_completed_ = true;
}
mta_thread_initialization_completion_cond_.notify_all();
if (initialized) {
// Initialized successfully, await a shutdown request while keeping an
// implicit COM MTA scope.
{
// Failed to initialize - notify the threads waiting for the
// initialization.
std::unique_lock<std::mutex> mta_thread_initialization_completion_lock(
mta_thread_initialization_completion_mutex_);
mta_thread_initialization_attempt_completed_ = true;
std::unique_lock<std::mutex> mta_thread_shutdown_request_lock(
mta_thread_shutdown_request_mutex_);
while (true) {
if (mta_thread_shutdown_requested_) {
break;
}
mta_thread_shutdown_request_cond_.wait(
mta_thread_shutdown_request_lock);
}
}
mta_thread_initialization_completion_cond_.notify_all();
if (api_minor_version_ >= 8) {
ShutdownObjects(objects_.api_2_8);
} else {
ShutdownObjects(objects_.api_2_7);
}
}
if (com_initialized) {
CoUninitialize();
}
}

11
src/xenia/apu/xaudio2/xaudio2_audio_driver.h
View File

@ -33,7 +33,7 @@ class XAudio2AudioDriver : public AudioDriver {
~XAudio2AudioDriver() override;
bool Initialize();
// Must not be called from COM STA threads as MTA XAudio 2.7 may be used. It's
// Must not be called from COM STA threads as MTA XAudio2 will be used. It's
// fine to call this from threads that have never initialized COM as
// initializing MTA for any thread implicitly initializes it for all threads
// not explicitly requesting STA (until COM is uninitialized all threads that
@ -49,8 +49,8 @@ class XAudio2AudioDriver : public AudioDriver {
// even beyond the 6 guest cores.
api::XAUDIO2_PROCESSOR kProcessor = 0x00000001;
// For XAudio 2.7, InitializeObjects and ShutdownObjects must be called only
// in the lifecycle management thread with COM MTA initialized.
// InitializeObjects and ShutdownObjects must be called only in the lifecycle
// management thread with COM MTA initialized.
template <typename Objects>
bool InitializeObjects(Objects& objects);
template <typename Objects>
@ -59,6 +59,11 @@ class XAudio2AudioDriver : public AudioDriver {
void MTAThread();
void* xaudio2_module_ = nullptr;
// clang-format off
HRESULT (__stdcall* xaudio2_create_)(
api::IXAudio2_8** xaudio2_out, UINT32 flags,
api::XAUDIO2_PROCESSOR xaudio2_processor) = nullptr;
// clang-format on
uint32_t api_minor_version_ = 7;
bool mta_thread_initialization_completion_result_;

4
src/xenia/cpu/backend/x64/x64_op.h
View File

@ -46,6 +46,7 @@ enum KeyType {
#pragma pack(push, 1)
union InstrKey {
uint32_t value;
struct {
uint32_t opcode : 8;
uint32_t dest : 5;
@ -54,11 +55,10 @@ union InstrKey {
uint32_t src3 : 5;
uint32_t reserved : 4;
};
uint32_t value;
operator uint32_t() const { return value; }
InstrKey() : value(0) {}
InstrKey() : value(0) { static_assert_size(*this, sizeof(value)); }
InstrKey(uint32_t v) : value(v) {}
InstrKey(const Instr* i) : value(0) {
opcode = i->opcode->num;

6
src/xenia/gpu/command_processor.h
View File

@ -67,34 +67,34 @@ enum class GammaRampType {
struct GammaRamp {
struct NormalEntry {
union {
uint32_t value;
struct {
uint32_t b : 10;
uint32_t g : 10;
uint32_t r : 10;
uint32_t : 2;
};
uint32_t value;
};
};
struct PWLValue {
union {
uint32_t value;
struct {
uint16_t base;
uint16_t delta;
};
uint32_t value;
};
};
struct PWLEntry {
union {
PWLValue values[3];
struct {
PWLValue r;
PWLValue g;
PWLValue b;
};
PWLValue values[3];
};
};

77
src/xenia/gpu/d3d12/d3d12_command_processor.cc
View File

@ -778,11 +778,10 @@ std::string D3D12CommandProcessor::GetWindowTitleText() const {
default:
break;
}
uint32_t resolution_scale = render_target_cache_->GetResolutionScale();
if (resolution_scale > 1) {
title.put(' ');
title << resolution_scale;
title.put('x');
uint32_t resolution_scale_x = texture_cache_->GetDrawResolutionScaleX();
uint32_t resolution_scale_y = texture_cache_->GetDrawResolutionScaleY();
if (resolution_scale_x > 1 || resolution_scale_y > 1) {
title << ' ' << resolution_scale_x << 'x' << resolution_scale_y;
}
}
return title.str();
@ -1203,7 +1202,8 @@ bool D3D12CommandProcessor::SetupContext() {
texture_cache_ = std::make_unique<TextureCache>(
*this, *register_file_, *shared_memory_, bindless_resources_used_,
render_target_cache_->GetResolutionScale());
render_target_cache_->GetResolutionScaleX(),
render_target_cache_->GetResolutionScaleY());
if (!texture_cache_->Initialize()) {
XELOGE("Failed to initialize the texture cache");
return false;
@ -1791,10 +1791,11 @@ void D3D12CommandProcessor::PerformSwap(uint32_t frontbuffer_ptr,
PushTransitionBarrier(swap_texture_, D3D12_RESOURCE_STATE_RENDER_TARGET,
D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE);
// Don't care about graphics state because the frame is ending anyway.
auto swap_screen_size = GetSwapScreenSize();
{
std::lock_guard<std::mutex> lock(swap_state_.mutex);
swap_state_.width = swap_texture_size.first;
swap_state_.height = swap_texture_size.second;
swap_state_.width = swap_screen_size.first;
swap_state_.height = swap_screen_size.second;
swap_state_.front_buffer_texture =
reinterpret_cast<uintptr_t>(swap_texture_srv_descriptor_heap_);
}
@ -1961,13 +1962,14 @@ bool D3D12CommandProcessor::IssueDraw(xenos::PrimitiveType primitive_type,
}
// Get dynamic rasterizer state.
uint32_t resolution_scale = texture_cache_->GetDrawResolutionScale();
uint32_t resolution_scale_x = texture_cache_->GetDrawResolutionScaleX();
uint32_t resolution_scale_y = texture_cache_->GetDrawResolutionScaleY();
RenderTargetCache::DepthFloat24Conversion depth_float24_conversion =
render_target_cache_->depth_float24_conversion();
draw_util::ViewportInfo viewport_info;
draw_util::GetHostViewportInfo(
regs, resolution_scale, true, D3D12_VIEWPORT_BOUNDS_MAX,
D3D12_VIEWPORT_BOUNDS_MAX, false,
regs, resolution_scale_x, resolution_scale_y, true,
D3D12_VIEWPORT_BOUNDS_MAX, D3D12_VIEWPORT_BOUNDS_MAX, false,
host_render_targets_used &&
(depth_float24_conversion ==
RenderTargetCache::DepthFloat24Conversion::kOnOutputTruncating ||
@ -1977,10 +1979,10 @@ bool D3D12CommandProcessor::IssueDraw(xenos::PrimitiveType primitive_type,
viewport_info);
draw_util::Scissor scissor;
draw_util::GetScissor(regs, scissor);
scissor.offset[0] *= resolution_scale;
scissor.offset[1] *= resolution_scale;
scissor.extent[0] *= resolution_scale;
scissor.extent[1] *= resolution_scale;
scissor.offset[0] *= resolution_scale_x;
scissor.offset[1] *= resolution_scale_y;
scissor.extent[0] *= resolution_scale_x;
scissor.extent[1] *= resolution_scale_y;
// Update viewport, scissor, blend factor and stencil reference.
UpdateFixedFunctionState(viewport_info, scissor, primitive_polygonal);
@ -2374,7 +2376,7 @@ bool D3D12CommandProcessor::IssueCopy() {
return false;
}
if (cvars::d3d12_readback_resolve &&
texture_cache_->GetDrawResolutionScale() <= 1 && written_length) {
!texture_cache_->IsDrawResolutionScaled() && written_length) {
// Read the resolved data on the CPU.
ID3D12Resource* readback_buffer = RequestReadbackBuffer(written_length);
if (readback_buffer != nullptr) {
@ -2873,7 +2875,8 @@ void D3D12CommandProcessor::UpdateSystemConstantValues(
bool edram_rov_used = render_target_cache_->GetPath() ==
RenderTargetCache::Path::kPixelShaderInterlock;
uint32_t resolution_scale = texture_cache_->GetDrawResolutionScale();
uint32_t resolution_scale_x = texture_cache_->GetDrawResolutionScaleX();
uint32_t resolution_scale_y = texture_cache_->GetDrawResolutionScaleY();
// Get the color info register values for each render target. Also, for ROV,
// exclude components that don't exist in the format from the write mask.
@ -3070,10 +3073,10 @@ void D3D12CommandProcessor::UpdateSystemConstantValues(
system_constants_.point_size_min = point_size_min;
system_constants_.point_size_max = point_size_max;
float point_screen_to_ndc_x =
(/* 0.5f * 2.0f * */ float(resolution_scale)) /
(/* 0.5f * 2.0f * */ float(resolution_scale_x)) /
std::max(viewport_info.xy_extent[0], uint32_t(1));
float point_screen_to_ndc_y =
(/* 0.5f * 2.0f * */ float(resolution_scale)) /
(/* 0.5f * 2.0f * */ float(resolution_scale_y)) /
std::max(viewport_info.xy_extent[1], uint32_t(1));
dirty |= system_constants_.point_screen_to_ndc[0] != point_screen_to_ndc_x;
dirty |= system_constants_.point_screen_to_ndc[1] != point_screen_to_ndc_y;
@ -3142,15 +3145,22 @@ void D3D12CommandProcessor::UpdateSystemConstantValues(
dirty |= system_constants_.alpha_to_mask != alpha_to_mask;
system_constants_.alpha_to_mask = alpha_to_mask;
uint32_t edram_tile_dwords_scaled = xenos::kEdramTileWidthSamples *
xenos::kEdramTileHeightSamples *
(resolution_scale_x * resolution_scale_y);
// EDRAM pitch for ROV writing.
if (edram_rov_used) {
uint32_t edram_pitch_tiles =
// Align, then multiply by 32bpp tile size in dwords.
uint32_t edram_32bpp_tile_pitch_dwords_scaled =
((rb_surface_info.surface_pitch *
(rb_surface_info.msaa_samples >= xenos::MsaaSamples::k4X ? 2 : 1)) +
79) /
80;
dirty |= system_constants_.edram_pitch_tiles != edram_pitch_tiles;
system_constants_.edram_pitch_tiles = edram_pitch_tiles;
(xenos::kEdramTileWidthSamples - 1)) /
xenos::kEdramTileWidthSamples * edram_tile_dwords_scaled;
dirty |= system_constants_.edram_32bpp_tile_pitch_dwords_scaled !=
edram_32bpp_tile_pitch_dwords_scaled;
system_constants_.edram_32bpp_tile_pitch_dwords_scaled =
edram_32bpp_tile_pitch_dwords_scaled;
}
// Color exponent bias and output index mapping or ROV render target writing.
@ -3184,7 +3194,7 @@ void D3D12CommandProcessor::UpdateSystemConstantValues(
if (rt_keep_masks[i][0] != UINT32_MAX ||
rt_keep_masks[i][1] != UINT32_MAX) {
uint32_t rt_base_dwords_scaled =
color_info.color_base * 1280 * resolution_scale * resolution_scale;
color_info.color_base * edram_tile_dwords_scaled;
dirty |= system_constants_.edram_rt_base_dwords_scaled[i] !=
rt_base_dwords_scaled;
system_constants_.edram_rt_base_dwords_scaled[i] =
@ -3208,12 +3218,12 @@ void D3D12CommandProcessor::UpdateSystemConstantValues(
}
}
// Interpolator sampling pattern, resolution scale, depth/stencil testing and
// blend constant for ROV.
if (edram_rov_used) {
uint32_t depth_base_dwords = rb_depth_info.depth_base * 1280;
dirty |= system_constants_.edram_depth_base_dwords != depth_base_dwords;
system_constants_.edram_depth_base_dwords = depth_base_dwords;
uint32_t depth_base_dwords_scaled =
rb_depth_info.depth_base * edram_tile_dwords_scaled;
dirty |= system_constants_.edram_depth_base_dwords_scaled !=
depth_base_dwords_scaled;
system_constants_.edram_depth_base_dwords_scaled = depth_base_dwords_scaled;
// For non-polygons, front polygon offset is used, and it's enabled if
// POLY_OFFSET_PARA_ENABLED is set, for polygons, separate front and back
@ -3243,8 +3253,13 @@ void D3D12CommandProcessor::UpdateSystemConstantValues(
poly_offset_back_offset = poly_offset_front_offset;
}
}
// With non-square resolution scaling, make sure the worst-case impact is
// reverted (slope only along the scaled axis), thus max. More bias is
// better than less bias, because less bias means Z fighting with the
// background is more likely.
float poly_offset_scale_factor =
xenos::kPolygonOffsetScaleSubpixelUnit * resolution_scale;
xenos::kPolygonOffsetScaleSubpixelUnit *
std::max(resolution_scale_x, resolution_scale_y);
poly_offset_front_scale *= poly_offset_scale_factor;
poly_offset_back_scale *= poly_offset_scale_factor;
dirty |= system_constants_.edram_poly_offset_front_scale !=

10
src/xenia/gpu/d3d12/d3d12_command_processor.h
View File

@ -10,6 +10,7 @@
#ifndef XENIA_GPU_D3D12_D3D12_COMMAND_PROCESSOR_H_
#define XENIA_GPU_D3D12_D3D12_COMMAND_PROCESSOR_H_
#include <algorithm>
#include <atomic>
#include <deque>
#include <memory>
@ -509,7 +510,14 @@ class D3D12CommandProcessor : public CommandProcessor {
static constexpr uint32_t kSwapTextureWidth = 1280;
static constexpr uint32_t kSwapTextureHeight = 720;
std::pair<uint32_t, uint32_t> GetSwapTextureSize() const {
uint32_t resolution_scale = texture_cache_->GetDrawResolutionScale();
return std::make_pair(
kSwapTextureWidth * texture_cache_->GetDrawResolutionScaleX(),
kSwapTextureHeight * texture_cache_->GetDrawResolutionScaleY());
}
std::pair<uint32_t, uint32_t> GetSwapScreenSize() const {
uint32_t resolution_scale =
std::max(texture_cache_->GetDrawResolutionScaleX(),
texture_cache_->GetDrawResolutionScaleY());
return std::make_pair(kSwapTextureWidth * resolution_scale,
kSwapTextureHeight * resolution_scale);
}

1171
src/xenia/gpu/d3d12/d3d12_render_target_cache.cc
View File

File diff suppressed because it is too large Load Diff

63
src/xenia/gpu/d3d12/d3d12_render_target_cache.h
View File

@ -60,7 +60,8 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
Path GetPath() const override { return path_; }
uint32_t GetResolutionScale() const override { return resolution_scale_; }
uint32_t GetResolutionScaleX() const override { return resolution_scale_x_; }
uint32_t GetResolutionScaleY() const override { return resolution_scale_y_; }
bool Update(bool is_rasterization_done,
uint32_t shader_writes_color_targets) override;
@ -249,7 +250,8 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
bool bindless_resources_used_;
Path path_ = Path::kHostRenderTargets;
uint32_t resolution_scale_ = 1;
uint32_t resolution_scale_x_ = 1;
uint32_t resolution_scale_y_ = 1;
// For host render targets, an EDRAM-sized scratch buffer for:
// - Guest render target data copied from host render targets during copying
@ -290,7 +292,13 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
// Parameter 1 - destination (shared memory or a part of it).
// Parameter 2 - source (EDRAM).
ID3D12RootSignature* resolve_copy_root_signature_ = nullptr;
static const std::pair<const void*, size_t>
struct ResolveCopyShaderCode {
const void* unscaled;
size_t unscaled_size;
const void* scaled;
size_t scaled_size;
};
static const ResolveCopyShaderCode
kResolveCopyShaders[size_t(draw_util::ResolveCopyShaderIndex::kCount)];
ID3D12PipelineState* resolve_copy_pipelines_[size_t(
draw_util::ResolveCopyShaderIndex::kCount)] = {};
@ -410,6 +418,7 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
static const TransferModeInfo kTransferModes[size_t(TransferMode::kCount)];
union TransferShaderKey {
uint32_t key;
struct {
xenos::MsaaSamples dest_msaa_samples : xenos::kMsaaSamplesBits;
uint32_t dest_resource_format : xenos::kRenderTargetFormatBits;
@ -433,7 +442,9 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
static_assert(size_t(TransferMode::kCount) <= (size_t(1) << 3));
TransferMode mode : 3;
};
uint32_t key = 0;
TransferShaderKey() : key(0) { static_assert_size(*this, sizeof(key)); }
struct Hasher {
size_t operator()(const TransferShaderKey& key) const {
return std::hash<uint32_t>{}(key.key);
@ -451,6 +462,7 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
};
union TransferAddressConstant {
uint32_t constant;
struct {
// All in tiles.
uint32_t dest_pitch : xenos::kEdramPitchTilesBits;
@ -466,7 +478,9 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
// destination == source anyway).
int32_t source_to_dest : xenos::kEdramBaseTilesBits;
};
uint32_t constant = 0;
TransferAddressConstant() : constant(0) {
static_assert_size(*this, sizeof(constant));
}
bool operator==(const TransferAddressConstant& other_constant) const {
return constant == other_constant.constant;
}
@ -474,7 +488,6 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
return !(*this == other_constant);
}
};
static_assert(sizeof(TransferAddressConstant) == sizeof(uint32_t));
struct TransferInvocation {
Transfer transfer;
@ -515,6 +528,7 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
};
union HostDepthStoreRectangleConstant {
uint32_t constant;
struct {
// - 1 because the maximum is 0x1FFF / 8, not 0x2000 / 8.
uint32_t x_pixels_div_8 : xenos::kResolveSizeBits - 1 -
@ -524,21 +538,24 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
uint32_t width_pixels_div_8_minus_1 : xenos::kResolveSizeBits - 1 -
xenos::kResolveAlignmentPixelsLog2;
};
uint32_t constant = 0;
HostDepthStoreRectangleConstant() : constant(0) {
static_assert_size(*this, sizeof(constant));
}
};
static_assert(sizeof(HostDepthStoreRectangleConstant) == sizeof(uint32_t));
union HostDepthStoreRenderTargetConstant {
uint32_t constant;
struct {
uint32_t pitch_tiles : xenos::kEdramPitchTilesBits;
// 1 to 3.
uint32_t resolution_scale : 2;
uint32_t resolution_scale_x : 2;
uint32_t resolution_scale_y : 2;
// Whether 2x MSAA is supported natively rather than through 4x.
uint32_t msaa_2x_supported : 1;
};
uint32_t constant = 0;
HostDepthStoreRenderTargetConstant() : constant(0) {
static_assert_size(*this, sizeof(constant));
}
};
static_assert(sizeof(HostDepthStoreRenderTargetConstant) == sizeof(uint32_t));
enum {
kHostDepthStoreRootParameterRectangleConstant,
@ -549,6 +566,7 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
};
union DumpPipelineKey {
uint32_t key;
struct {
xenos::MsaaSamples msaa_samples : 2;
uint32_t resource_format : 4;
@ -556,7 +574,9 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
// change it at most once. Depth buffers have an additional stencil SRV.
uint32_t is_depth : 1;
};
uint32_t key = 0;
DumpPipelineKey() : key(0) { static_assert_size(*this, sizeof(key)); }
struct Hasher {
size_t operator()(const DumpPipelineKey& key) const {
return std::hash<uint32_t>{}(key.key);
@ -583,13 +603,12 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
};
union DumpOffsets {
uint32_t offsets;
struct {
// Absolute index of the first thread group's tile within the source
// texture.
uint32_t first_group_tile_source_relative : xenos::kEdramBaseTilesBits;
uint32_t dispatch_first_tile : xenos::kEdramBaseTilesBits;
uint32_t source_base_tiles : xenos::kEdramBaseTilesBits;
};
uint32_t offsets = 0;
DumpOffsets() : offsets(0) { static_assert_size(*this, sizeof(offsets)); }
bool operator==(const DumpOffsets& other_offsets) const {
return offsets == other_offsets.offsets;
}
@ -597,15 +616,15 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
return !(*this == other_offsets);
}
};
static_assert(sizeof(DumpOffsets) == sizeof(uint32_t));
union DumpPitches {
uint32_t pitches;
struct {
// Both in tiles.
uint32_t source_pitch : xenos::kEdramPitchTilesBits;
uint32_t dest_pitch : xenos::kEdramPitchTilesBits;
uint32_t source_pitch : xenos::kEdramPitchTilesBits;
};
uint32_t pitches = 0;
DumpPitches() : pitches(0) { static_assert_size(*this, sizeof(pitches)); }
bool operator==(const DumpPitches& other_pitches) const {
return pitches == other_pitches.pitches;
}
@ -613,7 +632,6 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
return !(*this == other_pitches);
}
};
static_assert(sizeof(DumpPitches) == sizeof(uint32_t));
enum DumpCbuffer : uint32_t {
kDumpCbufferOffsets,
@ -818,9 +836,6 @@ class D3D12RenderTargetCache final : public RenderTargetCache {
// For rasterizer-ordered view (pixel shader interlock).
static const std::pair<const void*, size_t> kResolveROVClear32bppShaders[3];
static const std::pair<const void*, size_t> kResolveROVClear64bppShaders[3];
ID3D12RootSignature* resolve_rov_clear_root_signature_ = nullptr;
// Clearing 32bpp color or depth.
ID3D12PipelineState* resolve_rov_clear_32bpp_pipeline_ = nullptr;

13
src/xenia/gpu/d3d12/pipeline_cache.cc
View File

@ -96,7 +96,8 @@ PipelineCache::PipelineCache(D3D12CommandProcessor& command_processor,
provider.GetAdapterVendorID(), bindless_resources_used_, edram_rov_used,
render_target_cache_.gamma_render_target_as_srgb(),
render_target_cache_.msaa_2x_supported(),
render_target_cache_.GetResolutionScale(),
render_target_cache_.GetResolutionScaleX(),
render_target_cache_.GetResolutionScaleY(),
provider.GetGraphicsAnalysis() != nullptr);
if (edram_rov_used) {
@ -419,7 +420,8 @@ void PipelineCache::InitializeShaderStorage(
provider.GetAdapterVendorID(), bindless_resources_used_,
edram_rov_used, render_target_cache_.gamma_render_target_as_srgb(),
render_target_cache_.msaa_2x_supported(),
render_target_cache_.GetResolutionScale(),
render_target_cache_.GetResolutionScaleX(),
render_target_cache_.GetResolutionScaleY(),
provider.GetGraphicsAnalysis() != nullptr);
// If needed and possible, create objects needed for DXIL conversion and
// disassembly on this thread.
@ -1879,9 +1881,14 @@ ID3D12PipelineState* PipelineCache::CreateD3D12Pipeline(
description.front_counter_clockwise ? TRUE : FALSE;
state_desc.RasterizerState.DepthBias = description.depth_bias;
state_desc.RasterizerState.DepthBiasClamp = 0.0f;
// With non-square resolution scaling, make sure the worst-case impact is
// reverted (slope only along the scaled axis), thus max. More bias is better
// than less bias, because less bias means Z fighting with the background is
// more likely.
state_desc.RasterizerState.SlopeScaledDepthBias =
description.depth_bias_slope_scaled *
float(render_target_cache_.GetResolutionScale());
float(std::max(render_target_cache_.GetResolutionScaleX(),
render_target_cache_.GetResolutionScaleY()));
state_desc.RasterizerState.DepthClipEnable =
description.depth_clip ? TRUE : FALSE;
uint32_t msaa_sample_count = uint32_t(1)

517
src/xenia/gpu/d3d12/texture_cache.cc
View File

@ -51,8 +51,8 @@ DEFINE_uint32(
"If texture_cache_memory_limit_soft, for instance, is 384, and this is 24, "
"it will be assumed that the game will be using roughly 24 MB of "
"render-to-texture (resolve) targets and 384 - 24 = 360 MB of regular "
"textures - so with 2x resolution scaling, the soft limit will be 360 + 96 "
"MB, and with 3x, it will be 360 + 216 MB.",
"textures - so with 2x2 resolution scaling, the soft limit will be 360 + "
"96 MB, and with 3x3, it will be 360 + 216 MB.",
"GPU");
namespace xe {
@ -61,28 +61,21 @@ namespace d3d12 {
// Generated with `xb buildshaders`.
namespace shaders {
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_ctx1_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxn_rg8_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxt1_rgba8_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxt3_rgba8_cs.h"
@ -90,30 +83,22 @@ namespace shaders {
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxt3aas1111_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxt5_rgba8_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxt5a_r8_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_snorm_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_snorm_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_snorm_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r10g11b11_rgba16_snorm_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_snorm_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_snorm_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_snorm_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r4g4b4a4_b4g4r4a4_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r4g4b4a4_b4g4r4a4_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r11g11b10_rgba16_snorm_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r4g4b4a4_b4g4r4a4_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b5a1_b5g5r5a1_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b5a1_b5g5r5a1_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r4g4b4a4_b4g4r4a4_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b5a1_b5g5r5a1_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b6_b5g6r5_swizzle_rbga_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b6_b5g6r5_swizzle_rbga_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b5a1_b5g5r5a1_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b6_b5g6r5_swizzle_rbga_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g6b5_b5g6r5_2x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g6b5_b5g6r5_3x_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g5b6_b5g6r5_swizzle_rbga_scaled_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g6b5_b5g6r5_cs.h"
#include "xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_r5g6b5_b5g6r5_scaled_cs.h"
} // namespace shaders
// For formats with less than 4 components, assuming the last component is
@ -789,146 +774,96 @@ const char* const TextureCache::dimension_names_[4] = {"1D", "2D", "3D",
"cube"};
const TextureCache::LoadModeInfo TextureCache::load_mode_info_[] = {
{{{shaders::texture_load_8bpb_cs, sizeof(shaders::texture_load_8bpb_cs), 3,
4, 16},
{shaders::texture_load_8bpb_2x_cs,
sizeof(shaders::texture_load_8bpb_2x_cs), 4, 4, 16 * 2},
{shaders::texture_load_8bpb_3x_cs,
sizeof(shaders::texture_load_8bpb_3x_cs), 3, 3, 16 * 3}}},
{{{shaders::texture_load_16bpb_cs, sizeof(shaders::texture_load_16bpb_cs),
4, 4, 16},
{shaders::texture_load_16bpb_2x_cs,
sizeof(shaders::texture_load_16bpb_2x_cs), 4, 4, 16 * 2},
{shaders::texture_load_16bpb_3x_cs,
sizeof(shaders::texture_load_16bpb_3x_cs), 3, 3, 16 * 3}}},
{{{shaders::texture_load_32bpb_cs, sizeof(shaders::texture_load_32bpb_cs),
4, 4, 8},
{shaders::texture_load_32bpb_2x_cs,
sizeof(shaders::texture_load_32bpb_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_32bpb_3x_cs,
sizeof(shaders::texture_load_32bpb_3x_cs), 3, 3, 2 * 3}}},
{{{shaders::texture_load_64bpb_cs, sizeof(shaders::texture_load_64bpb_cs),
4, 4, 4},
{shaders::texture_load_64bpb_2x_cs,
sizeof(shaders::texture_load_64bpb_2x_cs), 4, 4, 4 * 2},
{shaders::texture_load_64bpb_3x_cs,
sizeof(shaders::texture_load_64bpb_3x_cs), 3, 3, 4 * 3}}},
{{{shaders::texture_load_128bpb_cs, sizeof(shaders::texture_load_128bpb_cs),
4, 4, 2},
{shaders::texture_load_128bpb_2x_cs,
sizeof(shaders::texture_load_128bpb_2x_cs), 4, 4, 2 * 2},
{shaders::texture_load_128bpb_3x_cs,
sizeof(shaders::texture_load_128bpb_3x_cs), 4, 4, 2 * 3}}},
{{{shaders::texture_load_r5g5b5a1_b5g5r5a1_cs,
sizeof(shaders::texture_load_r5g5b5a1_b5g5r5a1_cs), 4, 4, 16},
{shaders::texture_load_r5g5b5a1_b5g5r5a1_2x_cs,
sizeof(shaders::texture_load_r5g5b5a1_b5g5r5a1_2x_cs), 4, 4, 16 * 2},
{shaders::texture_load_r5g5b5a1_b5g5r5a1_3x_cs,
sizeof(shaders::texture_load_r5g5b5a1_b5g5r5a1_3x_cs), 3, 3, 16 * 3}}},
{{{shaders::texture_load_r5g6b5_b5g6r5_cs,
sizeof(shaders::texture_load_r5g6b5_b5g6r5_cs), 4, 4, 16},
{shaders::texture_load_r5g6b5_b5g6r5_2x_cs,
sizeof(shaders::texture_load_r5g6b5_b5g6r5_2x_cs), 4, 4, 16 * 2},
{shaders::texture_load_r5g6b5_b5g6r5_3x_cs,
sizeof(shaders::texture_load_r5g6b5_b5g6r5_3x_cs), 3, 3, 16 * 3}}},
{{{shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_cs,
sizeof(shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_cs), 4, 4, 16},
{shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_2x_cs,
sizeof(shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_2x_cs), 4, 4,
16 * 2},
{shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_3x_cs,
sizeof(shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_3x_cs), 3, 3,
16 * 3}}},
{{{shaders::texture_load_r4g4b4a4_b4g4r4a4_cs,
sizeof(shaders::texture_load_r4g4b4a4_b4g4r4a4_cs), 4, 4, 16},
{shaders::texture_load_r4g4b4a4_b4g4r4a4_2x_cs,
sizeof(shaders::texture_load_r4g4b4a4_b4g4r4a4_2x_cs), 4, 4, 16 * 2},
{shaders::texture_load_r4g4b4a4_b4g4r4a4_3x_cs,
sizeof(shaders::texture_load_r4g4b4a4_b4g4r4a4_3x_cs), 3, 3, 16 * 3}}},
{{{shaders::texture_load_r10g11b11_rgba16_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_cs), 4, 4, 8},
{shaders::texture_load_r10g11b11_rgba16_2x_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_r10g11b11_rgba16_3x_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_3x_cs), 3, 3, 2 * 3}}},
{{{shaders::texture_load_r10g11b11_rgba16_snorm_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_snorm_cs), 4, 4, 8},
{shaders::texture_load_r10g11b11_rgba16_snorm_2x_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_snorm_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_r10g11b11_rgba16_snorm_3x_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_snorm_3x_cs), 3, 3,
2 * 3}}},
{{{shaders::texture_load_r11g11b10_rgba16_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_cs), 4, 4, 8},
{shaders::texture_load_r11g11b10_rgba16_2x_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_r11g11b10_rgba16_3x_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_3x_cs), 3, 3, 2 * 3}}},
{{{shaders::texture_load_r11g11b10_rgba16_snorm_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_snorm_cs), 4, 4, 8},
{shaders::texture_load_r11g11b10_rgba16_snorm_2x_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_snorm_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_r11g11b10_rgba16_snorm_3x_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_snorm_3x_cs), 3, 3,
2 * 3}}},
{{{shaders::texture_load_dxt1_rgba8_cs,
sizeof(shaders::texture_load_dxt1_rgba8_cs), 4, 4, 4},
{},
{}}},
{{{shaders::texture_load_dxt3_rgba8_cs,
sizeof(shaders::texture_load_dxt3_rgba8_cs), 4, 4, 2},
{},
{}}},
{{{shaders::texture_load_dxt5_rgba8_cs,
sizeof(shaders::texture_load_dxt5_rgba8_cs), 4, 4, 2},
{},
{}}},
{{{shaders::texture_load_dxn_rg8_cs,
sizeof(shaders::texture_load_dxn_rg8_cs), 4, 4, 2},
{},
{}}},
{{{shaders::texture_load_dxt3a_cs, sizeof(shaders::texture_load_dxt3a_cs),
4, 4, 4},
{},
{}}},
{{{shaders::texture_load_dxt3aas1111_cs,
sizeof(shaders::texture_load_dxt3aas1111_cs), 4, 4, 4},
{},
{}}},
{{{shaders::texture_load_dxt5a_r8_cs,
sizeof(shaders::texture_load_dxt5a_r8_cs), 4, 4, 4},
{},
{}}},
{{{shaders::texture_load_ctx1_cs, sizeof(shaders::texture_load_ctx1_cs), 4,
4, 4},
{},
{}}},
{{{shaders::texture_load_depth_unorm_cs,
sizeof(shaders::texture_load_depth_unorm_cs), 4, 4, 8},
{shaders::texture_load_depth_unorm_2x_cs,
sizeof(shaders::texture_load_depth_unorm_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_depth_unorm_3x_cs,
sizeof(shaders::texture_load_depth_unorm_3x_cs), 3, 3, 2 * 3}}},
{{{shaders::texture_load_depth_float_cs,
sizeof(shaders::texture_load_depth_float_cs), 4, 4, 8},
{shaders::texture_load_depth_float_2x_cs,
sizeof(shaders::texture_load_depth_float_2x_cs), 4, 4, 8 * 2},
{shaders::texture_load_depth_float_3x_cs,
sizeof(shaders::texture_load_depth_float_3x_cs), 3, 3, 2 * 3}}},
{shaders::texture_load_8bpb_cs, sizeof(shaders::texture_load_8bpb_cs),
shaders::texture_load_8bpb_scaled_cs,
sizeof(shaders::texture_load_8bpb_scaled_cs), 3, 4, 16},
{shaders::texture_load_16bpb_cs, sizeof(shaders::texture_load_16bpb_cs),
shaders::texture_load_16bpb_scaled_cs,
sizeof(shaders::texture_load_16bpb_scaled_cs), 4, 4, 16},
{shaders::texture_load_32bpb_cs, sizeof(shaders::texture_load_32bpb_cs),
shaders::texture_load_32bpb_scaled_cs,
sizeof(shaders::texture_load_32bpb_scaled_cs), 4, 4, 8},
{shaders::texture_load_64bpb_cs, sizeof(shaders::texture_load_64bpb_cs),
shaders::texture_load_64bpb_scaled_cs,
sizeof(shaders::texture_load_64bpb_scaled_cs), 4, 4, 4},
{shaders::texture_load_128bpb_cs, sizeof(shaders::texture_load_128bpb_cs),
shaders::texture_load_128bpb_scaled_cs,
sizeof(shaders::texture_load_128bpb_scaled_cs), 4, 4, 2},
{shaders::texture_load_r5g5b5a1_b5g5r5a1_cs,
sizeof(shaders::texture_load_r5g5b5a1_b5g5r5a1_cs),
shaders::texture_load_r5g5b5a1_b5g5r5a1_scaled_cs,
sizeof(shaders::texture_load_r5g5b5a1_b5g5r5a1_scaled_cs), 4, 4, 16},
{shaders::texture_load_r5g6b5_b5g6r5_cs,
sizeof(shaders::texture_load_r5g6b5_b5g6r5_cs),
shaders::texture_load_r5g6b5_b5g6r5_scaled_cs,
sizeof(shaders::texture_load_r5g6b5_b5g6r5_scaled_cs), 4, 4, 16},
{shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_cs,
sizeof(shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_cs),
shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_scaled_cs,
sizeof(shaders::texture_load_r5g5b6_b5g6r5_swizzle_rbga_scaled_cs), 4, 4,
16},
{shaders::texture_load_r4g4b4a4_b4g4r4a4_cs,
sizeof(shaders::texture_load_r4g4b4a4_b4g4r4a4_cs),
shaders::texture_load_r4g4b4a4_b4g4r4a4_scaled_cs,
sizeof(shaders::texture_load_r4g4b4a4_b4g4r4a4_scaled_cs), 4, 4, 16},
{shaders::texture_load_r10g11b11_rgba16_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_cs),
shaders::texture_load_r10g11b11_rgba16_scaled_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_scaled_cs), 4, 4, 8},
{shaders::texture_load_r10g11b11_rgba16_snorm_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_snorm_cs),
shaders::texture_load_r10g11b11_rgba16_snorm_scaled_cs,
sizeof(shaders::texture_load_r10g11b11_rgba16_snorm_scaled_cs), 4, 4, 8},
{shaders::texture_load_r11g11b10_rgba16_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_cs),
shaders::texture_load_r11g11b10_rgba16_scaled_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_scaled_cs), 4, 4, 8},
{shaders::texture_load_r11g11b10_rgba16_snorm_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_snorm_cs),
shaders::texture_load_r11g11b10_rgba16_snorm_scaled_cs,
sizeof(shaders::texture_load_r11g11b10_rgba16_snorm_scaled_cs), 4, 4, 8},
{shaders::texture_load_dxt1_rgba8_cs,
sizeof(shaders::texture_load_dxt1_rgba8_cs), nullptr, 0, 4, 4, 4},
{shaders::texture_load_dxt3_rgba8_cs,
sizeof(shaders::texture_load_dxt3_rgba8_cs), nullptr, 0, 4, 4, 2},
{shaders::texture_load_dxt5_rgba8_cs,
sizeof(shaders::texture_load_dxt5_rgba8_cs), nullptr, 0, 4, 4, 2},
{shaders::texture_load_dxn_rg8_cs, sizeof(shaders::texture_load_dxn_rg8_cs),
nullptr, 0, 4, 4, 2},
{shaders::texture_load_dxt3a_cs, sizeof(shaders::texture_load_dxt3a_cs),
nullptr, 0, 4, 4, 4},
{shaders::texture_load_dxt3aas1111_cs,
sizeof(shaders::texture_load_dxt3aas1111_cs), nullptr, 0, 4, 4, 4},
{shaders::texture_load_dxt5a_r8_cs,
sizeof(shaders::texture_load_dxt5a_r8_cs), nullptr, 0, 4, 4, 4},
{shaders::texture_load_ctx1_cs, sizeof(shaders::texture_load_ctx1_cs),
nullptr, 0, 4, 4, 4},
{shaders::texture_load_depth_unorm_cs,
sizeof(shaders::texture_load_depth_unorm_cs),
shaders::texture_load_depth_unorm_scaled_cs,
sizeof(shaders::texture_load_depth_unorm_scaled_cs), 4, 4, 8},
{shaders::texture_load_depth_float_cs,
sizeof(shaders::texture_load_depth_float_cs),
shaders::texture_load_depth_float_scaled_cs,
sizeof(shaders::texture_load_depth_float_scaled_cs), 4, 4, 8},
};
TextureCache::TextureCache(D3D12CommandProcessor& command_processor,
const RegisterFile& register_file,
D3D12SharedMemory& shared_memory,
bool bindless_resources_used,
uint32_t draw_resolution_scale)
uint32_t draw_resolution_scale_x,
uint32_t draw_resolution_scale_y)
: command_processor_(command_processor),
register_file_(register_file),
shared_memory_(shared_memory),
bindless_resources_used_(bindless_resources_used),
draw_resolution_scale_(draw_resolution_scale) {
assert_true(draw_resolution_scale >= 1);
assert_true(draw_resolution_scale <= 3);
draw_resolution_scale_x_(draw_resolution_scale_x),
draw_resolution_scale_y_(draw_resolution_scale_y) {
assert_true(draw_resolution_scale_x >= 1);
assert_true(draw_resolution_scale_x <= kMaxDrawResolutionScaleAlongAxis);
assert_true(draw_resolution_scale_y >= 1);
assert_true(draw_resolution_scale_y <= kMaxDrawResolutionScaleAlongAxis);
}
TextureCache::~TextureCache() { Shutdown(); }
@ -937,8 +872,7 @@ bool TextureCache::Initialize() {
auto& provider = command_processor_.GetD3D12Context().GetD3D12Provider();
auto device = provider.GetDevice();
if (draw_resolution_scale_ > 1) {
assert_true(draw_resolution_scale_ <= GetMaxDrawResolutionScale(provider));
if (IsDrawResolutionScaled()) {
// Buffers not used yet - no need aliasing barriers to change ownership of
// gigabytes between even and odd buffers.
std::memset(scaled_resolve_1gb_buffer_indices_, UINT8_MAX,
@ -946,7 +880,7 @@ bool TextureCache::Initialize() {
assert_true(scaled_resolve_heaps_.empty());
uint64_t scaled_resolve_address_space_size =
uint64_t(SharedMemory::kBufferSize) *
(draw_resolution_scale_ * draw_resolution_scale_);
(draw_resolution_scale_x_ * draw_resolution_scale_y_);
scaled_resolve_heaps_.resize(size_t(scaled_resolve_address_space_size >>
kScaledResolveHeapSizeLog2));
constexpr uint32_t kScaledResolvePageDwordCount =
@ -1006,9 +940,9 @@ bool TextureCache::Initialize() {
// Create the loading pipelines.
for (uint32_t i = 0; i < uint32_t(LoadMode::kCount); ++i) {
const LoadModeInfo& mode_info = load_mode_info_[i];
const LoadModeInfo& load_mode_info = load_mode_info_[i];
load_pipelines_[i] = ui::d3d12::util::CreateComputePipeline(
device, mode_info.shaders[0].shader, mode_info.shaders[0].shader_size,
device, load_mode_info.shader, load_mode_info.shader_size,
load_root_signature_);
if (load_pipelines_[i] == nullptr) {
XELOGE(
@ -1018,21 +952,17 @@ bool TextureCache::Initialize() {
Shutdown();
return false;
}
if (draw_resolution_scale_ > 1) {
const LoadShaderInfo& scaled_load_shader_info =
mode_info.shaders[draw_resolution_scale_ - 1];
if (scaled_load_shader_info.shader) {
load_pipelines_scaled_[i] = ui::d3d12::util::CreateComputePipeline(
device, scaled_load_shader_info.shader,
scaled_load_shader_info.shader_size, load_root_signature_);
if (load_pipelines_scaled_[i] == nullptr) {
XELOGE(
"D3D12TextureCache: Failed to create the resolution-scaled "
"texture loading pipeline for mode {}",
i);
Shutdown();
return false;
}
if (IsDrawResolutionScaled() && load_mode_info.shader_scaled) {
load_pipelines_scaled_[i] = ui::d3d12::util::CreateComputePipeline(
device, load_mode_info.shader_scaled,
load_mode_info.shader_scaled_size, load_root_signature_);
if (load_pipelines_scaled_[i] == nullptr) {
XELOGE(
"D3D12TextureCache: Failed to create the resolution-scaled texture "
"loading pipeline for mode {}",
i);
Shutdown();
return false;
}
}
}
@ -1096,7 +1026,7 @@ bool TextureCache::Initialize() {
provider.OffsetViewDescriptor(null_srv_descriptor_heap_start_,
uint32_t(NullSRVDescriptorIndex::kCube)));
if (draw_resolution_scale_ > 1) {
if (IsDrawResolutionScaled()) {
scaled_resolve_global_watch_handle_ = shared_memory_.RegisterGlobalWatch(
ScaledResolveGlobalWatchCallbackThunk, this);
}
@ -1183,7 +1113,7 @@ void TextureCache::TextureFetchConstantWritten(uint32_t index) {
void TextureCache::BeginSubmission() {
// ExecuteCommandLists is a full UAV and aliasing barrier.
if (draw_resolution_scale_ > 1) {
if (IsDrawResolutionScaled()) {
size_t scaled_resolve_buffer_count = GetScaledResolveBufferCount();
for (size_t i = 0; i < scaled_resolve_buffer_count; ++i) {
ScaledResolveVirtualBuffer* scaled_resolve_buffer =
@ -1215,7 +1145,7 @@ void TextureCache::BeginFrame() {
// so subtracting 1 from the scale.
uint32_t limit_scaled_resolve_add_mb =
cvars::texture_cache_memory_limit_render_to_texture *
(draw_resolution_scale_ * draw_resolution_scale_ - 1);
(draw_resolution_scale_x_ * draw_resolution_scale_y_ - 1);
uint32_t limit_soft_mb =
cvars::texture_cache_memory_limit_soft + limit_scaled_resolve_add_mb;
uint32_t limit_hard_mb =
@ -1333,7 +1263,7 @@ void TextureCache::RequestTextures(uint32_t used_texture_mask) {
BindingInfoFromFetchConstant(fetch, binding.key, &binding.host_swizzle,
&binding.swizzled_signs);
texture_bindings_in_sync_ |= index_bit;
if (binding.key.IsInvalid()) {
if (!binding.key.is_valid) {
binding.texture = nullptr;
binding.texture_signed = nullptr;
binding.descriptor_index = UINT32_MAX;
@ -1495,7 +1425,7 @@ void TextureCache::WriteActiveTextureBindfulSRV(
texture_bindings_[host_shader_binding.fetch_constant];
uint32_t descriptor_index = UINT32_MAX;
Texture* texture = nullptr;
if (!binding.key.IsInvalid() &&
if (binding.key.is_valid &&
AreDimensionsCompatible(host_shader_binding.dimension,
binding.key.dimension)) {
if (host_shader_binding.is_signed) {
@ -1557,7 +1487,7 @@ uint32_t TextureCache::GetActiveTextureBindlessSRVIndex(
uint32_t descriptor_index = UINT32_MAX;
const TextureBinding& binding =
texture_bindings_[host_shader_binding.fetch_constant];
if (!binding.key.IsInvalid() &&
if (binding.key.is_valid &&
AreDimensionsCompatible(host_shader_binding.dimension,
binding.key.dimension)) {
descriptor_index = host_shader_binding.is_signed
@ -1705,7 +1635,7 @@ void TextureCache::MarkRangeAsResolved(uint32_t start_unscaled,
start_unscaled &= 0x1FFFFFFF;
length_unscaled = std::min(length_unscaled, 0x20000000 - start_unscaled);
if (draw_resolution_scale_ > 1) {
if (IsDrawResolutionScaled()) {
uint32_t page_first = start_unscaled >> 12;
uint32_t page_last = (start_unscaled + length_unscaled - 1) >> 12;
uint32_t block_first = page_first >> 5;
@ -1729,9 +1659,43 @@ void TextureCache::MarkRangeAsResolved(uint32_t start_unscaled,
shared_memory_.RangeWrittenByGpu(start_unscaled, length_unscaled, true);
}
void TextureCache::ClampDrawResolutionScaleToSupportedRange(
uint32_t& scale_x, uint32_t& scale_y,
const ui::d3d12::D3D12Provider& provider) {
if (provider.GetTiledResourcesTier() < D3D12_TILED_RESOURCES_TIER_1) {
scale_x = 1;
scale_y = 1;
return;
}
// Ensure it's not zero.
scale_x = std::max(scale_x, uint32_t(1));
scale_y = std::max(scale_y, uint32_t(1));
scale_x = std::min(scale_x, kMaxDrawResolutionScaleAlongAxis);
scale_y = std::min(scale_y, kMaxDrawResolutionScaleAlongAxis);
// Limit to the virtual address space available for a resource.
uint32_t virtual_address_bits_per_resource =
provider.GetVirtualAddressBitsPerResource();
while (scale_x > 1 || scale_y > 1) {
uint64_t highest_scaled_address =
uint64_t(SharedMemory::kBufferSize) * (scale_x * scale_y) - 1;
if (uint32_t(64) - xe::lzcnt(highest_scaled_address) <=
virtual_address_bits_per_resource) {
break;
}
// When reducing from a square size, prefer decreasing the horizontal
// resolution as vertical resolution difference is visible more clearly in
// perspective.
if (scale_x >= scale_y) {
--scale_x;
} else {
--scale_y;
}
}
}
bool TextureCache::EnsureScaledResolveMemoryCommitted(
uint32_t start_unscaled, uint32_t length_unscaled) {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
if (length_unscaled == 0) {
return true;
@ -1742,12 +1706,11 @@ bool TextureCache::EnsureScaledResolveMemoryCommitted(
return false;
}
uint32_t draw_resolution_scale_square =
draw_resolution_scale_ * draw_resolution_scale_;
uint64_t first_scaled =
uint64_t(start_unscaled) * draw_resolution_scale_square;
uint32_t draw_resolution_scale_area =
draw_resolution_scale_x_ * draw_resolution_scale_y_;
uint64_t first_scaled = uint64_t(start_unscaled) * draw_resolution_scale_area;
uint64_t last_scaled = uint64_t(start_unscaled + (length_unscaled - 1)) *
draw_resolution_scale_square;
draw_resolution_scale_area;
auto& provider = command_processor_.GetD3D12Context().GetD3D12Provider();
auto device = provider.GetDevice();
@ -1773,7 +1736,7 @@ bool TextureCache::EnsureScaledResolveMemoryCommitted(
ui::d3d12::util::FillBufferResourceDesc(
scaled_resolve_buffer_desc,
std::min(uint64_t(1) << 31, uint64_t(SharedMemory::kBufferSize) *
draw_resolution_scale_square -
draw_resolution_scale_area -
(uint64_t(i) << 30)),
D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);
// The first access will be a resolve.
@ -1855,7 +1818,7 @@ bool TextureCache::EnsureScaledResolveMemoryCommitted(
bool TextureCache::MakeScaledResolveRangeCurrent(uint32_t start_unscaled,
uint32_t length_unscaled) {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
if (!length_unscaled || start_unscaled >= SharedMemory::kBufferSize ||
(SharedMemory::kBufferSize - start_unscaled) < length_unscaled) {
@ -1864,12 +1827,11 @@ bool TextureCache::MakeScaledResolveRangeCurrent(uint32_t start_unscaled,
return false;
}
uint32_t draw_resolution_scale_square =
draw_resolution_scale_ * draw_resolution_scale_;
uint64_t start_scaled =
uint64_t(start_unscaled) * draw_resolution_scale_square;
uint32_t draw_resolution_scale_area =
draw_resolution_scale_x_ * draw_resolution_scale_y_;
uint64_t start_scaled = uint64_t(start_unscaled) * draw_resolution_scale_area;
uint64_t length_scaled =
uint64_t(length_unscaled) * draw_resolution_scale_square;
uint64_t(length_unscaled) * draw_resolution_scale_area;
uint64_t last_scaled = start_scaled + (length_scaled - 1);
// Get one or two buffers that can hold the whole range.
@ -1967,7 +1929,7 @@ bool TextureCache::MakeScaledResolveRangeCurrent(uint32_t start_unscaled,
void TextureCache::TransitionCurrentScaledResolveRange(
D3D12_RESOURCE_STATES new_state) {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
ScaledResolveVirtualBuffer& buffer = GetCurrentScaledResolveBuffer();
command_processor_.PushTransitionBarrier(
buffer.resource(), buffer.SetResourceState(new_state), new_state);
@ -1975,7 +1937,7 @@ void TextureCache::TransitionCurrentScaledResolveRange(
void TextureCache::CreateCurrentScaledResolveRangeUintPow2SRV(
D3D12_CPU_DESCRIPTOR_HANDLE handle, uint32_t element_size_bytes_pow2) {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
size_t buffer_index = GetCurrentScaledResolveBufferIndex();
const ScaledResolveVirtualBuffer* buffer =
scaled_resolve_2gb_buffers_[buffer_index];
@ -1993,7 +1955,7 @@ void TextureCache::CreateCurrentScaledResolveRangeUintPow2SRV(
void TextureCache::CreateCurrentScaledResolveRangeUintPow2UAV(
D3D12_CPU_DESCRIPTOR_HANDLE handle, uint32_t element_size_bytes_pow2) {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
size_t buffer_index = GetCurrentScaledResolveBufferIndex();
const ScaledResolveVirtualBuffer* buffer =
scaled_resolve_2gb_buffers_[buffer_index];
@ -2064,7 +2026,7 @@ TextureCache::LoadMode TextureCache::GetLoadMode(TextureKey key) {
if (key.signed_separate) {
return host_format.load_mode_snorm;
}
if (IsDecompressionNeeded(key.format, key.width, key.height)) {
if (IsDecompressionNeeded(key.format, key.GetWidth(), key.GetHeight())) {
return host_format.decompress_mode;
}
return host_format.load_mode;
@ -2109,11 +2071,11 @@ void TextureCache::BindingInfoFromFetchConstant(
return;
}
uint32_t width, height, depth_or_faces;
uint32_t width_minus_1, height_minus_1, depth_or_array_size_minus_1;
uint32_t base_page, mip_page, mip_max_level;
texture_util::GetSubresourcesFromFetchConstant(
fetch, &width, &height, &depth_or_faces, &base_page, &mip_page, nullptr,
&mip_max_level);
fetch, &width_minus_1, &height_minus_1, &depth_or_array_size_minus_1,
&base_page, &mip_page, nullptr, &mip_max_level);
if (base_page == 0 && mip_page == 0) {
// No texture data at all.
return;
@ -2121,11 +2083,11 @@ void TextureCache::BindingInfoFromFetchConstant(
if (fetch.dimension == xenos::DataDimension::k1D) {
bool is_invalid_1d = false;
// TODO(Triang3l): Support long 1D textures.
if (width > xenos::kTexture2DCubeMaxWidthHeight) {
if (width_minus_1 >= xenos::kTexture2DCubeMaxWidthHeight) {
XELOGE(
"1D texture is too wide ({}) - ignoring! Report the game to Xenia "
"developers",
width);
width_minus_1 + 1);
is_invalid_1d = true;
}
assert_false(fetch.tiled);
@ -2154,9 +2116,9 @@ void TextureCache::BindingInfoFromFetchConstant(
key_out.base_page = base_page;
key_out.mip_page = mip_page;
key_out.dimension = fetch.dimension;
key_out.width = width;
key_out.height = height;
key_out.depth = depth_or_faces;
key_out.width_minus_1 = width_minus_1;
key_out.height_minus_1 = height_minus_1;
key_out.depth_or_array_size_minus_1 = depth_or_array_size_minus_1;
key_out.pitch = fetch.pitch;
key_out.mip_max_level = mip_max_level;
key_out.tiled = fetch.tiled;
@ -2164,6 +2126,8 @@ void TextureCache::BindingInfoFromFetchConstant(
key_out.format = format;
key_out.endianness = fetch.endianness;
key_out.is_valid = 1;
if (host_swizzle_out != nullptr) {
uint32_t host_swizzle = 0;
for (uint32_t i = 0; i < 4; ++i) {
@ -2192,8 +2156,8 @@ void TextureCache::LogTextureKeyAction(TextureKey key, const char* action) {
"{} {} {}{}x{}x{} {} {} texture with {} {}packed mip level{}, "
"base at 0x{:08X} (pitch {}), mips at 0x{:08X}",
action, key.tiled ? "tiled" : "linear",
key.scaled_resolve ? "scaled " : "", key.width, key.height, key.depth,
dimension_names_[uint32_t(key.dimension)],
key.scaled_resolve ? "scaled " : "", key.GetWidth(), key.GetHeight(),
key.GetDepthOrArraySize(), dimension_names_[uint32_t(key.dimension)],
FormatInfo::Get(key.format)->name, key.mip_max_level + 1,
key.packed_mips ? "" : "un", key.mip_max_level != 0 ? "s" : "",
key.base_page << 12, key.pitch << 5, key.mip_page << 12);
@ -2206,8 +2170,8 @@ void TextureCache::LogTextureAction(const Texture* texture,
"base at 0x{:08X} (pitch {}, size 0x{:08X}), mips at 0x{:08X} (size "
"0x{:08X})",
action, texture->key.tiled ? "tiled" : "linear",
texture->key.scaled_resolve ? "scaled " : "", texture->key.width,
texture->key.height, texture->key.depth,
texture->key.scaled_resolve ? "scaled " : "", texture->key.GetWidth(),
texture->key.GetHeight(), texture->key.GetDepthOrArraySize(),
dimension_names_[uint32_t(texture->key.dimension)],
FormatInfo::Get(texture->key.format)->name,
texture->key.mip_max_level + 1, texture->key.packed_mips ? "" : "un",
@ -2218,15 +2182,15 @@ void TextureCache::LogTextureAction(const Texture* texture,
TextureCache::Texture* TextureCache::FindOrCreateTexture(TextureKey key) {
// Check if the texture is a scaled resolve texture.
if (draw_resolution_scale_ > 1 && key.tiled) {
if (IsDrawResolutionScaled() && key.tiled) {
LoadMode load_mode = GetLoadMode(key);
if (load_mode != LoadMode::kUnknown &&
load_pipelines_scaled_[uint32_t(load_mode)] != nullptr) {
texture_util::TextureGuestLayout scaled_resolve_guest_layout =
texture_util::GetGuestTextureLayout(
key.dimension, key.pitch, key.width, key.height, key.depth,
key.tiled, key.format, key.packed_mips, key.base_page != 0,
key.mip_max_level);
key.dimension, key.pitch, key.GetWidth(), key.GetHeight(),
key.GetDepthOrArraySize(), key.tiled, key.format, key.packed_mips,
key.base_page != 0, key.mip_max_level);
if ((scaled_resolve_guest_layout.base.level_data_extent_bytes &&
IsRangeScaledResolved(
key.base_page << 12,
@ -2239,18 +2203,20 @@ TextureCache::Texture* TextureCache::FindOrCreateTexture(TextureKey key) {
}
}
}
uint32_t host_width = key.width;
uint32_t host_height = key.height;
uint32_t host_width = key.GetWidth();
uint32_t host_height = key.GetHeight();
if (key.scaled_resolve) {
host_width *= draw_resolution_scale_;
host_height *= draw_resolution_scale_;
host_width *= draw_resolution_scale_x_;
host_height *= draw_resolution_scale_y_;
}
// With 3x resolution scaling, a 2D texture may become bigger than the
// Direct3D 11 limit, and with 2x, a 3D one as well.
uint32_t max_host_width_height = GetMaxHostTextureWidthHeight(key.dimension);
uint32_t max_host_depth = GetMaxHostTextureDepth(key.dimension);
uint32_t max_host_depth_or_array_size =
GetMaxHostTextureDepthOrArraySize(key.dimension);
if (host_width > max_host_width_height ||
host_height > max_host_width_height || key.depth > max_host_depth) {
host_height > max_host_width_height ||
key.GetDepthOrArraySize() > max_host_depth_or_array_size) {
return nullptr;
}
@ -2280,7 +2246,7 @@ TextureCache::Texture* TextureCache::FindOrCreateTexture(TextureKey key) {
desc.Alignment = 0;
desc.Width = host_width;
desc.Height = host_height;
desc.DepthOrArraySize = key.depth;
desc.DepthOrArraySize = key.GetDepthOrArraySize();
desc.MipLevels = key.mip_max_level + 1;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
@ -2321,8 +2287,9 @@ TextureCache::Texture* TextureCache::FindOrCreateTexture(TextureKey key) {
texture->base_resolved = key.scaled_resolve;
texture->mips_resolved = key.scaled_resolve;
texture->guest_layout = texture_util::GetGuestTextureLayout(
key.dimension, key.pitch, key.width, key.height, key.depth, key.tiled,
key.format, key.packed_mips, key.base_page != 0, key.mip_max_level);
key.dimension, key.pitch, key.GetWidth(), key.GetHeight(),
key.GetDepthOrArraySize(), key.tiled, key.format, key.packed_mips,
key.base_page != 0, key.mip_max_level);
// Never try to upload data that doesn't exist.
texture->base_in_sync = !texture->guest_layout.base.level_data_extent_bytes;
texture->mips_in_sync = !texture->guest_layout.mips_total_extent_bytes;
@ -2359,17 +2326,14 @@ bool TextureCache::LoadTextureData(Texture* texture) {
if (load_mode == LoadMode::kUnknown) {
return false;
}
uint32_t texture_resolution_scale =
texture->key.scaled_resolve ? draw_resolution_scale_ : 1;
bool texture_resolution_scaled = texture->key.scaled_resolve;
ID3D12PipelineState* pipeline =
texture_resolution_scale > 1 ? load_pipelines_scaled_[uint32_t(load_mode)]
: load_pipelines_[uint32_t(load_mode)];
texture_resolution_scaled ? load_pipelines_scaled_[uint32_t(load_mode)]
: load_pipelines_[uint32_t(load_mode)];
if (pipeline == nullptr) {
return false;
}
const LoadModeInfo& load_mode_info = load_mode_info_[uint32_t(load_mode)];
const LoadShaderInfo& load_shader_info =
load_mode_info.shaders[texture_resolution_scale - 1];
// Request uploading of the texture data to the shared memory.
// This is also necessary when resolution scale is used - the texture cache
@ -2382,7 +2346,7 @@ bool TextureCache::LoadTextureData(Texture* texture) {
if (!base_in_sync) {
if (!shared_memory_.RequestRange(
texture->key.base_page << 12, texture->GetGuestBaseSize(),
texture->key.scaled_resolve ? nullptr : &base_resolved)) {
texture_resolution_scaled ? nullptr : &base_resolved)) {
return false;
}
}
@ -2390,11 +2354,11 @@ bool TextureCache::LoadTextureData(Texture* texture) {
if (!mips_in_sync) {
if (!shared_memory_.RequestRange(
texture->key.mip_page << 12, texture->GetGuestMipsSize(),
texture->key.scaled_resolve ? nullptr : &mips_resolved)) {
texture_resolution_scaled ? nullptr : &mips_resolved)) {
return false;
}
}
if (texture_resolution_scale > 1) {
if (texture_resolution_scaled) {
// Make sure all heaps are created.
if (!EnsureScaledResolveMemoryCommitted(texture->key.base_page << 12,
texture->GetGuestBaseSize())) {
@ -2409,9 +2373,9 @@ bool TextureCache::LoadTextureData(Texture* texture) {
// Get the guest layout.
xenos::DataDimension dimension = texture->key.dimension;
bool is_3d = dimension == xenos::DataDimension::k3D;
uint32_t width = texture->key.width;
uint32_t height = texture->key.height;
uint32_t depth_or_array_size = texture->key.depth;
uint32_t width = texture->key.GetWidth();
uint32_t height = texture->key.GetHeight();
uint32_t depth_or_array_size = texture->key.GetDepthOrArraySize();
uint32_t depth = is_3d ? depth_or_array_size : 1;
uint32_t array_size = is_3d ? 1 : depth_or_array_size;
xenos::TextureFormat guest_format = texture->key.format;
@ -2425,6 +2389,10 @@ bool TextureCache::LoadTextureData(Texture* texture) {
uint32_t level_packed = texture->guest_layout.packed_level;
uint32_t level_stored_first = std::min(level_first, level_packed);
uint32_t level_stored_last = std::min(level_last, level_packed);
uint32_t texture_resolution_scale_x =
texture_resolution_scaled ? draw_resolution_scale_x_ : 1;
uint32_t texture_resolution_scale_y =
texture_resolution_scaled ? draw_resolution_scale_y_ : 1;
// Get the host layout and the buffer.
UINT64 copy_buffer_size = 0;
@ -2470,15 +2438,16 @@ bool TextureCache::LoadTextureData(Texture* texture) {
host_slice_layout_base.Footprint.Depth = depth;
}
host_slice_layout_base.Footprint.Width = xe::round_up(
host_slice_layout_base.Footprint.Width * texture_resolution_scale,
host_slice_layout_base.Footprint.Width * texture_resolution_scale_x,
UINT(host_block_width));
host_slice_layout_base.Footprint.Height = xe::round_up(
host_slice_layout_base.Footprint.Height * texture_resolution_scale,
host_slice_layout_base.Footprint.Height * texture_resolution_scale_y,
UINT(host_block_height));
host_slice_layout_base.Footprint.RowPitch =
xe::align(xe::round_up(host_slice_layout_base.Footprint.Width /
host_block_width,
load_shader_info.host_x_blocks_per_thread) *
load_mode_info.host_x_blocks_per_thread *
texture_resolution_scale_x) *
host_bytes_per_block,
uint32_t(D3D12_TEXTURE_DATA_PITCH_ALIGNMENT));
host_slice_size_base = xe::align(
@ -2515,15 +2484,16 @@ bool TextureCache::LoadTextureData(Texture* texture) {
std::max(depth >> level, uint32_t(1));
}
host_slice_layout_mip.Footprint.Width = xe::round_up(
host_slice_layout_mip.Footprint.Width * texture_resolution_scale,
host_slice_layout_mip.Footprint.Width * texture_resolution_scale_x,
UINT(host_block_width));
host_slice_layout_mip.Footprint.Height = xe::round_up(
host_slice_layout_mip.Footprint.Height * texture_resolution_scale,
host_slice_layout_mip.Footprint.Height * texture_resolution_scale_y,
UINT(host_block_height));
host_slice_layout_mip.Footprint.RowPitch =
xe::align(xe::round_up(host_slice_layout_mip.Footprint.Width /
host_block_width,
load_shader_info.host_x_blocks_per_thread) *
load_mode_info.host_x_blocks_per_thread *
texture_resolution_scale_x) *
host_bytes_per_block,
uint32_t(D3D12_TEXTURE_DATA_PITCH_ALIGNMENT));
UINT64 host_slice_sizes_mip = xe::align(
@ -2557,7 +2527,7 @@ bool TextureCache::LoadTextureData(Texture* texture) {
// descriptors for base and mips.
// Destination.
uint32_t descriptor_count = 1;
if (texture_resolution_scale > 1) {
if (texture_resolution_scaled) {
// Source - base and mips, one or both.
descriptor_count += (level_first == 0 && level_last != 0) ? 2 : 1;
} else {
@ -2581,25 +2551,25 @@ bool TextureCache::LoadTextureData(Texture* texture) {
descriptors_allocated[descriptor_write_index++];
ui::d3d12::util::CreateBufferTypedUAV(
device, descriptor_dest.first, copy_buffer,
ui::d3d12::util::GetUintPow2DXGIFormat(load_shader_info.uav_bpe_log2),
uint32_t(copy_buffer_size) >> load_shader_info.uav_bpe_log2);
ui::d3d12::util::GetUintPow2DXGIFormat(load_mode_info.uav_bpe_log2),
uint32_t(copy_buffer_size) >> load_mode_info.uav_bpe_log2);
command_list.D3DSetComputeRootDescriptorTable(2, descriptor_dest.second);
// Set up the unscaled source descriptor (scaled needs two descriptors that
// depend on the buffer being current, so they will be set later - for mips,
// after loading the base is done).
if (texture_resolution_scale <= 1) {
if (!texture_resolution_scaled) {
shared_memory_.UseForReading();
ui::d3d12::util::DescriptorCpuGpuHandlePair descriptor_unscaled_source;
if (bindless_resources_used_) {
descriptor_unscaled_source =
command_processor_.GetSharedMemoryUintPow2BindlessSRVHandlePair(
load_shader_info.srv_bpe_log2);
load_mode_info.srv_bpe_log2);
} else {
assert_true(descriptor_write_index < descriptor_count);
descriptor_unscaled_source =
descriptors_allocated[descriptor_write_index++];
shared_memory_.WriteUintPow2SRVDescriptor(
descriptor_unscaled_source.first, load_shader_info.srv_bpe_log2);
descriptor_unscaled_source.first, load_mode_info.srv_bpe_log2);
}
command_list.D3DSetComputeRootDescriptorTable(
1, descriptor_unscaled_source.second);
@ -2609,9 +2579,10 @@ bool TextureCache::LoadTextureData(Texture* texture) {
auto& cbuffer_pool = command_processor_.GetConstantBufferPool();
LoadConstants load_constants;
load_constants.is_tiled_3d_endian = uint32_t(texture->key.tiled) |
(uint32_t(is_3d) << 1) |
(uint32_t(texture->key.endianness) << 2);
load_constants.is_tiled_3d_endian_scale =
uint32_t(texture->key.tiled) | (uint32_t(is_3d) << 1) |
(uint32_t(texture->key.endianness) << 2) |
(texture_resolution_scale_x << 4) | (texture_resolution_scale_y << 6);
// The loop counter can mean two things depending on whether the packed mip
// tail is stored as mip 0, because in this case, it would be ambiguous since
@ -2646,8 +2617,7 @@ bool TextureCache::LoadTextureData(Texture* texture) {
// Set up the base or mips source, also making it accessible if loading from
// scaled resolve memory.
if (texture_resolution_scale > 1 &&
(is_base || !scaled_mips_source_set_up)) {
if (texture_resolution_scaled && (is_base || !scaled_mips_source_set_up)) {
uint32_t guest_size_unscaled =
is_base ? texture->GetGuestBaseSize() : texture->GetGuestMipsSize();
if (!MakeScaledResolveRangeCurrent(guest_address, guest_size_unscaled)) {
@ -2661,7 +2631,7 @@ bool TextureCache::LoadTextureData(Texture* texture) {
ui::d3d12::util::DescriptorCpuGpuHandlePair descriptor_scaled_source =
descriptors_allocated[descriptor_write_index++];
CreateCurrentScaledResolveRangeUintPow2SRV(descriptor_scaled_source.first,
load_shader_info.srv_bpe_log2);
load_mode_info.srv_bpe_log2);
command_list.D3DSetComputeRootDescriptorTable(
1, descriptor_scaled_source.second);
if (!is_base) {
@ -2669,7 +2639,7 @@ bool TextureCache::LoadTextureData(Texture* texture) {
}
}
if (texture_resolution_scale > 1) {
if (texture_resolution_scaled) {
// Offset already applied in the buffer because more than 512 MB can't be
// directly addresses on Nvidia as R32.
load_constants.guest_offset = 0;
@ -2678,7 +2648,8 @@ bool TextureCache::LoadTextureData(Texture* texture) {
}
if (!is_base) {
load_constants.guest_offset +=
texture->guest_layout.mip_offsets_bytes[level];
texture->guest_layout.mip_offsets_bytes[level] *
(texture_resolution_scale_x * texture_resolution_scale_y);
}
const texture_util::TextureGuestLayout::Level& level_guest_layout =
is_base ? texture->guest_layout.base
@ -2709,14 +2680,15 @@ bool TextureCache::LoadTextureData(Texture* texture) {
level_height = std::max(height >> level, uint32_t(1));
level_depth = std::max(depth >> level, uint32_t(1));
}
load_constants.size_blocks[0] =
(level_width + (block_width - 1)) / block_width;
load_constants.size_blocks[1] =
(level_height + (block_height - 1)) / block_height;
load_constants.size_blocks[0] = (level_width + (block_width - 1)) /
block_width * texture_resolution_scale_x;
load_constants.size_blocks[1] = (level_height + (block_height - 1)) /
block_height * texture_resolution_scale_y;
load_constants.size_blocks[2] = level_depth;
load_constants.height_texels = level_height;
// Each thread group processes 32x32x1 guest blocks.
// Each thread group processes 32x32x1 source blocks (resolution-scaled, but
// still compressed if the host needs decompression).
uint32_t group_count_x = (load_constants.size_blocks[0] + 31) >> 5;
uint32_t group_count_y = (load_constants.size_blocks[1] + 31) >> 5;
@ -2745,7 +2717,8 @@ bool TextureCache::LoadTextureData(Texture* texture) {
command_list.D3DDispatch(group_count_x, group_count_y,
load_constants.size_blocks[2]);
load_constants.guest_offset +=
level_guest_layout.array_slice_stride_bytes;
level_guest_layout.array_slice_stride_bytes *
(texture_resolution_scale_x * texture_resolution_scale_y);
load_constants.host_offset += host_slice_size;
}
}
@ -2877,7 +2850,7 @@ uint32_t TextureCache::FindOrCreateTextureDescriptor(Texture& texture,
desc.Texture2DArray.MostDetailedMip = 0;
desc.Texture2DArray.MipLevels = mip_levels;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.ArraySize = texture.key.depth;
desc.Texture2DArray.ArraySize = texture.key.GetDepthOrArraySize();
desc.Texture2DArray.PlaneSlice = 0;
desc.Texture2DArray.ResourceMinLODClamp = 0.0f;
break;
@ -3023,7 +2996,7 @@ void TextureCache::ClearBindings() {
bool TextureCache::IsRangeScaledResolved(uint32_t start_unscaled,
uint32_t length_unscaled) {
if (draw_resolution_scale_ <= 1) {
if (!IsDrawResolutionScaled()) {
return false;
}
@ -3083,7 +3056,7 @@ void TextureCache::ScaledResolveGlobalWatchCallbackThunk(
void TextureCache::ScaledResolveGlobalWatchCallback(uint32_t address_first,
uint32_t address_last,
bool invalidated_by_gpu) {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
if (invalidated_by_gpu) {
// Resolves themselves do exactly the opposite of what this should do.
return;

146
src/xenia/gpu/d3d12/texture_cache.h
View File

@ -62,30 +62,36 @@ class D3D12CommandProcessor;
// because textures are streamed this way anyway.
class TextureCache {
struct TextureKey {
// Dimensions minus 1 are stored similarly to how they're stored in fetch
// constants so fewer bits can be used, while the maximum size (8192 for 2D)
// can still be encoded (a 8192x sky texture is used in 4D530910).
// Physical 4 KB page with the base mip level, disregarding A/C/E address
// range prefix.
uint32_t base_page : 17; // 17 total
xenos::DataDimension dimension : 2; // 19
uint32_t width : 13; // 32
uint32_t width_minus_1 : 13; // 32
uint32_t height : 13; // 45
uint32_t tiled : 1; // 46
uint32_t packed_mips : 1; // 47
uint32_t height_minus_1 : 13; // 45
uint32_t tiled : 1; // 46
uint32_t packed_mips : 1; // 47
// Physical 4 KB page with mip 1 and smaller.
uint32_t mip_page : 17; // 64
// Layers for stacked and 3D, 6 for cube, 1 for other dimensions.
uint32_t depth : 10; // 74
uint32_t pitch : 9; // 83
uint32_t mip_max_level : 4; // 87
xenos::TextureFormat format : 6; // 93
xenos::Endian endianness : 2; // 95
// (Layers for stacked and 3D, 6 for cube, 1 for other dimensions) - 1.
uint32_t depth_or_array_size_minus_1 : 10; // 74
uint32_t pitch : 9; // 83
uint32_t mip_max_level : 4; // 87
xenos::TextureFormat format : 6; // 93
xenos::Endian endianness : 2; // 95
// Whether this texture is signed and has a different host representation
// than an unsigned view of the same guest texture.
uint32_t signed_separate : 1; // 96
// Whether this texture is a 2x-scaled resolve target.
// Whether this texture is a resolution-scaled resolve target.
uint32_t scaled_resolve : 1; // 97
// Least important in ==, so placed last.
uint32_t is_valid : 1; // 98
TextureKey() { MakeInvalid(); }
TextureKey(const TextureKey& key) {
@ -95,16 +101,17 @@ class TextureCache {
std::memcpy(this, &key, sizeof(*this));
return *this;
}
bool IsInvalid() const {
// Zero size is enough for a binding to be invalid (not possible on the
// real GPU since dimensions minus 1 are stored).
return !width;
}
void MakeInvalid() {
// Zero everything, including the padding, for a stable hash.
std::memset(this, 0, sizeof(*this));
}
uint32_t GetWidth() const { return width_minus_1 + 1; }
uint32_t GetHeight() const { return height_minus_1 + 1; }
uint32_t GetDepthOrArraySize() const {
return depth_or_array_size_minus_1 + 1;
}
using Hasher = xe::hash::XXHasher<TextureKey>;
bool operator==(const TextureKey& key) const {
return !std::memcmp(this, &key, sizeof(*this));
@ -124,6 +131,7 @@ class TextureCache {
// Sampler parameters that can be directly converted to a host sampler or used
// for binding checking validity whether samplers are up to date.
union SamplerParameters {
uint32_t value;
struct {
xenos::ClampMode clamp_x : 3; // 3
xenos::ClampMode clamp_y : 3; // 6
@ -137,16 +145,8 @@ class TextureCache {
uint32_t mip_min_level : 4; // 21
// Maximum mip level is in the texture resource itself.
};
uint32_t value;
// Clearing the unused bits.
SamplerParameters() : value(0) {}
SamplerParameters(const SamplerParameters& parameters)
: value(parameters.value) {}
SamplerParameters& operator=(const SamplerParameters& parameters) {
value = parameters.value;
return *this;
}
SamplerParameters() : value(0) { static_assert_size(*this, sizeof(value)); }
bool operator==(const SamplerParameters& parameters) const {
return value == parameters.value;
}
@ -158,7 +158,8 @@ class TextureCache {
TextureCache(D3D12CommandProcessor& command_processor,
const RegisterFile& register_file,
D3D12SharedMemory& shared_memory, bool bindless_resources_used,
uint32_t draw_resolution_scale);
uint32_t draw_resolution_scale_x,
uint32_t draw_resolution_scale_y);
~TextureCache();
bool Initialize();
@ -221,16 +222,20 @@ class TextureCache {
D3D12_CPU_DESCRIPTOR_HANDLE handle) const;
void MarkRangeAsResolved(uint32_t start_unscaled, uint32_t length_unscaled);
static uint32_t GetMaxDrawResolutionScale(
const ui::d3d12::D3D12Provider& provider) {
// 31 because 2 GB buffers are used.
if (provider.GetTiledResourcesTier() < D3D12_TILED_RESOURCES_TIER_1 ||
provider.GetVirtualAddressBitsPerResource() < 31) {
return 1;
}
return kMaxDrawResolutionScale;
// In textures, resolution scaling is done for 8-byte portions of memory for
// 8bpp textures, and for 16-byte portions for textures of higher bit depths
// (these are the sizes of regions where contiguous texels in memory are also
// contiguous in the texture along the horizontal axis, so 64-bit and 128-bit
// loads / stores, for 8bpp and 16bpp+ respectively, can be used for untiling
// regardless of the resolution scale).
static void ClampDrawResolutionScaleToSupportedRange(
uint32_t& scale_x, uint32_t& scale_y,
const ui::d3d12::D3D12Provider& provider);
uint32_t GetDrawResolutionScaleX() const { return draw_resolution_scale_x_; }
uint32_t GetDrawResolutionScaleY() const { return draw_resolution_scale_y_; }
bool IsDrawResolutionScaled() const {
return draw_resolution_scale_x_ > 1 || draw_resolution_scale_y_ > 1;
}
uint32_t GetDrawResolutionScale() const { return draw_resolution_scale_; }
// Ensures the tiles backing the range in the buffers are allocated.
bool EnsureScaledResolveMemoryCommitted(uint32_t start_unscaled,
uint32_t length_unscaled);
@ -249,7 +254,7 @@ class TextureCache {
D3D12_CPU_DESCRIPTOR_HANDLE handle, uint32_t element_size_bytes_pow2);
void TransitionCurrentScaledResolveRange(D3D12_RESOURCE_STATES new_state);
void MarkCurrentScaledResolveRangeUAVWritesCommitNeeded() {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
GetCurrentScaledResolveBuffer().SetUAVBarrierPending();
}
@ -262,7 +267,11 @@ class TextureCache {
xenos::TextureFormat& format_out);
private:
static constexpr uint32_t kMaxDrawResolutionScale = 3;
// Hard limit, originating from the half-pixel offset (two-pixel offset is too
// much, the resolve shaders, being generic for different scales, only
// duplicate the second pixel into the first, not the third), and also due to
// the bit counts used for passing the scale to shaders.
static constexpr uint32_t kMaxDrawResolutionScaleAlongAxis = 3;
enum class LoadMode {
k8bpb,
@ -294,7 +303,7 @@ class TextureCache {
kUnknown = kCount
};
struct LoadShaderInfo {
struct LoadModeInfo {
// Rules of data access in load shaders:
// - Source reading (from the shared memory or the scaled resolve buffer):
// - Guest data may be stored in a sparsely-allocated buffer, or, in
@ -343,11 +352,13 @@ class TextureCache {
// - Resolution scaling enabled:
// - For simplicity, unlike in the shared memory, buffer tile boundaries
// are not aligned to powers of 2 the same way as guest addresses are.
// While for 2x resolution scaling it still happens to be the case
// because `host address = guest address << 1`, for 3x, it's not - a
// 64 KB host tile would represent 7281.777 guest bytes (though we
// scale texels, not bytes, but that's what it would be for k_8
// textures).
// While for 2x2 resolution scaling it still happens to be the case
// because `host scaling unit address = guest scaling unit
// address << 2` (similarly for 2x1 and 1x2), for 3x or x3, it's not -
// a 64 KB host tile would represent 7281.777 guest bytes with 3x3
// (disregarding that sequences of texels that are adjacent in memory
// alongside the horizontal axis, not individual bytes, are scaled,
// but even in that case it's not scaling by 2^n still).
// - The above would affect the `width > pitch` case for linear
// textures, requiring overestimating the width in calculation of the
// range of the tiles to map, while not doing this overestimation on
@ -370,24 +381,26 @@ class TextureCache {
// - host_x_blocks_per_thread specifies how many pixels can be written
// without bounds checking within increments of that amount - the pitch
// of the destination buffer is manually overaligned if needed.
// Shader without resolution scaling.
const void* shader;
size_t shader_size;
// Shader with resolution scaling, if available. These shaders are separate
// so the majority of the textures are not affected by the code needed for
// resolution scale support, and also to check if the format allows
// resolution scaling.
const void* shader_scaled;
size_t shader_scaled_size;
// Log2 of the sizes, in bytes, of the source (guest) SRV and the
// destination (host) UAV accessed by the copying shader, since the shader
// may copy multiple blocks per one invocation.
uint32_t srv_bpe_log2;
uint32_t uav_bpe_log2;
// Number of guest blocks (or texels for uncompressed) along X axis written
// Number of host blocks (or texels for uncompressed) along X axis written
// by every compute shader thread - rows in the upload buffer are padded to
// at least this amount.
uint32_t host_x_blocks_per_thread;
};
struct LoadModeInfo {
// For different drawing resolution scales.
LoadShaderInfo shaders[kMaxDrawResolutionScale];
};
struct HostFormat {
// Format info for the regular case.
// DXGI format (typeless when different signedness or number representation
@ -480,17 +493,18 @@ class TextureCache {
struct LoadConstants {
// vec4 0.
uint32_t is_tiled_3d_endian;
// Base offset in bytes.
uint32_t is_tiled_3d_endian_scale;
// Base offset in bytes, resolution-scaled.
uint32_t guest_offset;
// For tiled textures - row pitch in blocks, aligned to 32.
// For tiled textures - row pitch in blocks, aligned to 32, unscaled.
// For linear textures - row pitch in bytes.
uint32_t guest_pitch_aligned;
// For 3D textures only (ignored otherwise) - aligned to 32.
// For 3D textures only (ignored otherwise) - aligned to 32, unscaled.
uint32_t guest_z_stride_block_rows_aligned;
// vec4 1.
// If this is a packed mip tail, this is aligned to tile dimensions.
// Resolution-scaled.
uint32_t size_blocks[3];
// Base offset in bytes.
uint32_t host_offset;
@ -537,7 +551,8 @@ class TextureCache {
return 0;
}
}
static uint32_t GetMaxHostTextureDepth(xenos::DataDimension dimension) {
static uint32_t GetMaxHostTextureDepthOrArraySize(
xenos::DataDimension dimension) {
switch (dimension) {
case xenos::DataDimension::k1D:
case xenos::DataDimension::k2DOrStacked:
@ -602,7 +617,7 @@ class TextureCache {
: host_format.dxgi_format_resource;
}
static DXGI_FORMAT GetDXGIResourceFormat(TextureKey key) {
return GetDXGIResourceFormat(key.format, key.width, key.height);
return GetDXGIResourceFormat(key.format, key.GetWidth(), key.GetHeight());
}
static DXGI_FORMAT GetDXGIUnormFormat(xenos::TextureFormat format,
uint32_t width, uint32_t height) {
@ -612,7 +627,7 @@ class TextureCache {
: host_format.dxgi_format_unorm;
}
static DXGI_FORMAT GetDXGIUnormFormat(TextureKey key) {
return GetDXGIUnormFormat(key.format, key.width, key.height);
return GetDXGIUnormFormat(key.format, key.GetWidth(), key.GetHeight());
}
static LoadMode GetLoadMode(TextureKey key);
@ -678,7 +693,7 @@ class TextureCache {
void ClearBindings();
size_t GetScaledResolveBufferCount() const {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
// Make sure any range up to 1 GB is accessible through 1 or 2 buffers.
// 2x2 scale buffers - just one 2 GB buffer for all 2 GB.
// 3x3 scale buffers - 4 buffers:
@ -694,7 +709,7 @@ class TextureCache {
// three buffers.
uint64_t address_space_size =
uint64_t(SharedMemory::kBufferSize) *
(draw_resolution_scale_ * draw_resolution_scale_);
(draw_resolution_scale_x_ * draw_resolution_scale_y_);
return size_t((address_space_size - 1) >> 30);
}
// Returns indices of two scaled resolve virtual buffers that the location in
@ -702,7 +717,7 @@ class TextureCache {
// the beginning or the end of the address represented only by one buffer.
std::array<size_t, 2> GetPossibleScaledResolveBufferIndices(
uint64_t address_scaled) const {
assert_true(draw_resolution_scale_ > 1);
assert_true(IsDrawResolutionScaled());
size_t address_gb = size_t(address_scaled >> 30);
size_t max_index = GetScaledResolveBufferCount() - 1;
// In different cases for 3x3:
@ -795,11 +810,12 @@ class TextureCache {
};
uint8_t unsupported_format_features_used_[64];
uint32_t draw_resolution_scale_ = 1;
uint32_t draw_resolution_scale_x_ = 1;
uint32_t draw_resolution_scale_y_ = 1;
// The tiled buffer for resolved data with resolution scaling.
// Because on Direct3D 12 (at least on Windows 10 2004) typed SRV or UAV
// creation fails for offsets above 4 GB, a single tiled 4.5 GB buffer can't
// be used for 3x resolution scaling.
// be used for 3x3 resolution scaling.
// Instead, "sliding window" buffers allowing to access a single range of up
// to 1 GB (or up to 2 GB, depending on the low bits) at any moment are used.
// Parts of 4.5 GB address space can be accessed through 2 GB buffers as:
@ -814,8 +830,8 @@ class TextureCache {
// Size is calculated the same as in GetScaledResolveBufferCount.
ScaledResolveVirtualBuffer*
scaled_resolve_2gb_buffers_[(uint64_t(SharedMemory::kBufferSize) *
(kMaxDrawResolutionScale *
kMaxDrawResolutionScale) -
(kMaxDrawResolutionScaleAlongAxis *
kMaxDrawResolutionScaleAlongAxis) -
1) >>
30] = {};
// Not very big heaps (16 MB) because they are needed pretty sparsely. One
@ -845,8 +861,8 @@ class TextureCache {
// For aliasing barrier placement, last owning buffer index for each of 1 GB.
size_t
scaled_resolve_1gb_buffer_indices_[(uint64_t(SharedMemory::kBufferSize) *
kMaxDrawResolutionScale *
kMaxDrawResolutionScale +
kMaxDrawResolutionScaleAlongAxis *
kMaxDrawResolutionScaleAlongAxis +
((uint32_t(1) << 30) - 1)) >>
30];
// Range used in the last successful MakeScaledResolveRangeCurrent call.

192
src/xenia/gpu/draw_util.cc
View File

@ -189,13 +189,14 @@ bool IsPixelShaderNeededWithRasterization(const Shader& shader,
return false;
}
void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale,
bool origin_bottom_left, uint32_t x_max,
uint32_t y_max, bool allow_reverse_z,
void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale_x,
uint32_t resolution_scale_y, bool origin_bottom_left,
uint32_t x_max, uint32_t y_max, bool allow_reverse_z,
bool convert_z_to_float24, bool full_float24_in_0_to_1,
bool pixel_shader_writes_depth,
ViewportInfo& viewport_info_out) {
assert_not_zero(resolution_scale);
assert_not_zero(resolution_scale_x);
assert_not_zero(resolution_scale_y);
// A vertex position goes the following path:
//
@ -364,8 +365,8 @@ void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale,
// The maximum value is at least the maximum host render target size anyway -
// and a guest pixel is always treated as a whole with resolution scaling.
uint32_t xy_max_unscaled[] = {x_max / resolution_scale,
y_max / resolution_scale};
uint32_t xy_max_unscaled[] = {x_max / resolution_scale_x,
y_max / resolution_scale_y};
assert_not_zero(xy_max_unscaled[0]);
assert_not_zero(xy_max_unscaled[1]);
@ -383,7 +384,8 @@ void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale,
viewport_info_out.xy_offset[i] = 0;
uint32_t extent_axis_unscaled =
std::min(xenos::kTexture2DCubeMaxWidthHeight, xy_max_unscaled[i]);
viewport_info_out.xy_extent[i] = extent_axis_unscaled * resolution_scale;
viewport_info_out.xy_extent[i] =
extent_axis_unscaled * (i ? resolution_scale_y : resolution_scale_x);
float extent_axis_unscaled_float = float(extent_axis_unscaled);
float pixels_to_ndc_axis = 2.0f / extent_axis_unscaled_float;
ndc_scale[i] = scale_xy[i] * pixels_to_ndc_axis;
@ -409,6 +411,8 @@ void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale,
// vertices if we did flooring in host pixels. Instead of flooring, also
// doing truncation for simplicity - since maxing with 0 is done anyway
// (we only return viewports in the positive quarter-plane).
uint32_t axis_resolution_scale =
i ? resolution_scale_y : resolution_scale_x;
float offset_axis = offset_base_xy[i] + offset_add_xy[i];
float scale_axis = scale_xy[i];
float scale_axis_abs = std::abs(scale_xy[i]);
@ -423,8 +427,8 @@ void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale,
uint32_t axis_1_int =
uint32_t(std::min(axis_max_unscaled_float, std::max(0.0f, axis_1)));
uint32_t axis_extent_int = axis_1_int - axis_0_int;
viewport_info_out.xy_offset[i] = axis_0_int * resolution_scale;
viewport_info_out.xy_extent[i] = axis_extent_int * resolution_scale;
viewport_info_out.xy_offset[i] = axis_0_int * axis_resolution_scale;
viewport_info_out.xy_extent[i] = axis_extent_int * axis_resolution_scale;
float ndc_scale_axis;
float ndc_offset_axis;
if (axis_extent_int) {
@ -691,38 +695,19 @@ void GetResolveEdramTileSpan(ResolveEdramPackedInfo edram_info,
const ResolveCopyShaderInfo
resolve_copy_shader_info[size_t(ResolveCopyShaderIndex::kCount)] = {
{"Resolve Copy Fast 32bpp 1x/2xMSAA", 1, false, 4, 4, 6, 3},
{"Resolve Copy Fast 32bpp 4xMSAA", 1, false, 4, 4, 6, 3},
{"Resolve Copy Fast 32bpp 2xRes", 2, false, 4, 4, 4, 3},
{"Resolve Copy Fast 32bpp 3xRes 1x/2xMSAA", 3, false, 3, 3, 4, 3},
{"Resolve Copy Fast 32bpp 3xRes 4xMSAA", 3, false, 3, 3, 4, 3},
{"Resolve Copy Fast 64bpp 1x/2xMSAA", 1, false, 4, 4, 5, 3},
{"Resolve Copy Fast 64bpp 4xMSAA", 1, false, 3, 4, 5, 3},
{"Resolve Copy Fast 64bpp 2xRes", 2, false, 4, 4, 3, 3},
{"Resolve Copy Fast 64bpp 3xRes", 3, false, 3, 3, 3, 3},
{"Resolve Copy Full 8bpp", 1, true, 2, 3, 6, 3},
{"Resolve Copy Full 8bpp 2xRes", 2, false, 4, 3, 4, 3},
{"Resolve Copy Full 8bpp 3xRes", 3, true, 2, 3, 6, 3},
{"Resolve Copy Full 16bpp", 1, true, 2, 3, 5, 3},
{"Resolve Copy Full 16bpp 2xRes", 2, false, 4, 3, 3, 3},
{"Resolve Copy Full 16bpp from 32bpp 3xRes", 3, true, 2, 3, 5, 3},
{"Resolve Copy Full 16bpp from 64bpp 3xRes", 3, false, 3, 3, 5, 3},
{"Resolve Copy Full 32bpp", 1, true, 2, 4, 5, 3},
{"Resolve Copy Full 32bpp 2xRes", 2, false, 4, 4, 3, 3},
{"Resolve Copy Full 32bpp from 32bpp 3xRes", 3, true, 2, 3, 4, 3},
{"Resolve Copy Full 32bpp from 64bpp 3xRes", 3, false, 3, 3, 4, 3},
{"Resolve Copy Full 64bpp", 1, true, 2, 4, 5, 3},
{"Resolve Copy Full 64bpp 2xRes", 2, false, 4, 4, 3, 3},
{"Resolve Copy Full 64bpp from 32bpp 3xRes", 3, true, 2, 3, 3, 3},
{"Resolve Copy Full 64bpp from 64bpp 3xRes", 3, false, 3, 3, 3, 3},
{"Resolve Copy Full 128bpp", 1, true, 2, 4, 4, 3},
{"Resolve Copy Full 128bpp 2xRes", 2, false, 4, 4, 3, 3},
{"Resolve Copy Full 128bpp from 32bpp 3xRes", 3, true, 2, 4, 3, 3},
{"Resolve Copy Full 128bpp from 64bpp 3xRes", 3, false, 3, 4, 3, 3},
{"Resolve Copy Fast 32bpp 1x/2xMSAA", false, 4, 4, 6, 3},
{"Resolve Copy Fast 32bpp 4xMSAA", false, 4, 4, 6, 3},
{"Resolve Copy Fast 64bpp 1x/2xMSAA", false, 4, 4, 5, 3},
{"Resolve Copy Fast 64bpp 4xMSAA", false, 3, 4, 5, 3},
{"Resolve Copy Full 8bpp", true, 2, 3, 6, 3},
{"Resolve Copy Full 16bpp", true, 2, 3, 5, 3},
{"Resolve Copy Full 32bpp", true, 2, 4, 5, 3},
{"Resolve Copy Full 64bpp", true, 2, 4, 5, 3},
{"Resolve Copy Full 128bpp", true, 2, 4, 4, 3},
};
bool GetResolveInfo(const RegisterFile& regs, const Memory& memory,
TraceWriter& trace_writer, uint32_t resolution_scale,
TraceWriter& trace_writer, bool is_resolution_scaled,
bool fixed_16_truncated_to_minus_1_to_1,
ResolveInfo& info_out) {
auto rb_copy_control = regs.Get<reg::RB_COPY_CONTROL>();
@ -1008,7 +993,7 @@ bool GetResolveInfo(const RegisterFile& regs, const Memory& memory,
// Write the color/depth EDRAM info.
bool duplicate_second_pixel =
resolution_scale > 1 &&
is_resolution_scaled &&
cvars::resolve_resolution_scale_duplicate_second_pixel &&
cvars::half_pixel_offset && !regs.Get<reg::PA_SU_VTX_CNTL>().pix_center;
int32_t exp_bias = is_depth ? 0 : rb_copy_dest_info.copy_dest_exp_bias;
@ -1092,8 +1077,9 @@ bool GetResolveInfo(const RegisterFile& regs, const Memory& memory,
}
ResolveCopyShaderIndex ResolveInfo::GetCopyShader(
uint32_t resolution_scale, ResolveCopyShaderConstants& constants_out,
uint32_t& group_count_x_out, uint32_t& group_count_y_out) const {
uint32_t resolution_scale_x, uint32_t resolution_scale_y,
ResolveCopyShaderConstants& constants_out, uint32_t& group_count_x_out,
uint32_t& group_count_y_out) const {
ResolveCopyShaderIndex shader = ResolveCopyShaderIndex::kUnknown;
bool is_depth = IsCopyingDepth();
ResolveEdramPackedInfo edram_info =
@ -1105,109 +1091,34 @@ ResolveCopyShaderIndex ResolveInfo::GetCopyShader(
xenos::IsColorResolveFormatBitwiseEquivalent(
xenos::ColorRenderTargetFormat(color_edram_info.format),
xenos::ColorFormat(copy_dest_info.copy_dest_format)))) {
switch (resolution_scale) {
case 1:
if (edram_info.msaa_samples >= xenos::MsaaSamples::k4X) {
shader = source_is_64bpp ? ResolveCopyShaderIndex::kFast64bpp4xMSAA
: ResolveCopyShaderIndex::kFast32bpp4xMSAA;
} else {
shader = source_is_64bpp ? ResolveCopyShaderIndex::kFast64bpp1x2xMSAA
: ResolveCopyShaderIndex::kFast32bpp1x2xMSAA;
}
break;
case 2:
shader = source_is_64bpp ? ResolveCopyShaderIndex::kFast64bpp2xRes
: ResolveCopyShaderIndex::kFast32bpp2xRes;
break;
case 3:
if (source_is_64bpp) {
shader = ResolveCopyShaderIndex::kFast64bpp3xRes;
} else {
shader = edram_info.msaa_samples >= xenos::MsaaSamples::k4X
? ResolveCopyShaderIndex::kFast32bpp3xRes4xMSAA
: ResolveCopyShaderIndex::kFast32bpp3xRes1x2xMSAA;
}
break;
default:
assert_unhandled_case(resolution_scale);
if (edram_info.msaa_samples >= xenos::MsaaSamples::k4X) {
shader = source_is_64bpp ? ResolveCopyShaderIndex::kFast64bpp4xMSAA
: ResolveCopyShaderIndex::kFast32bpp4xMSAA;
} else {
shader = source_is_64bpp ? ResolveCopyShaderIndex::kFast64bpp1x2xMSAA
: ResolveCopyShaderIndex::kFast32bpp1x2xMSAA;
}
} else {
const FormatInfo& dest_format_info =
*FormatInfo::Get(xenos::TextureFormat(copy_dest_info.copy_dest_format));
switch (resolution_scale) {
case 1:
switch (dest_format_info.bits_per_pixel) {
case 8:
shader = ResolveCopyShaderIndex::kFull8bpp;
break;
case 16:
shader = ResolveCopyShaderIndex::kFull16bpp;
break;
case 32:
shader = ResolveCopyShaderIndex::kFull32bpp;
break;
case 64:
shader = ResolveCopyShaderIndex::kFull64bpp;
break;
case 128:
shader = ResolveCopyShaderIndex::kFull128bpp;
break;
default:
assert_unhandled_case(dest_format_info.bits_per_pixel);
}
switch (dest_format_info.bits_per_pixel) {
case 8:
shader = ResolveCopyShaderIndex::kFull8bpp;
break;
case 2:
switch (dest_format_info.bits_per_pixel) {
case 8:
shader = ResolveCopyShaderIndex::kFull8bpp2xRes;
break;
case 16:
shader = ResolveCopyShaderIndex::kFull16bpp2xRes;
break;
case 32:
shader = ResolveCopyShaderIndex::kFull32bpp2xRes;
break;
case 64:
shader = ResolveCopyShaderIndex::kFull64bpp2xRes;
break;
case 128:
shader = ResolveCopyShaderIndex::kFull128bpp2xRes;
break;
default:
assert_unhandled_case(dest_format_info.bits_per_pixel);
}
case 16:
shader = ResolveCopyShaderIndex::kFull16bpp;
break;
case 3:
switch (dest_format_info.bits_per_pixel) {
case 8:
shader = ResolveCopyShaderIndex::kFull8bpp3xRes;
break;
case 16:
shader = source_is_64bpp
? ResolveCopyShaderIndex::kFull16bppFrom64bpp3xRes
: ResolveCopyShaderIndex::kFull16bppFrom32bpp3xRes;
break;
case 32:
shader = source_is_64bpp
? ResolveCopyShaderIndex::kFull32bppFrom64bpp3xRes
: ResolveCopyShaderIndex::kFull32bppFrom32bpp3xRes;
break;
case 64:
shader = source_is_64bpp
? ResolveCopyShaderIndex::kFull64bppFrom64bpp3xRes
: ResolveCopyShaderIndex::kFull64bppFrom32bpp3xRes;
break;
case 128:
shader = source_is_64bpp
? ResolveCopyShaderIndex::kFull128bppFrom64bpp3xRes
: ResolveCopyShaderIndex::kFull128bppFrom32bpp3xRes;
break;
default:
assert_unhandled_case(dest_format_info.bits_per_pixel);
}
case 32:
shader = ResolveCopyShaderIndex::kFull32bpp;
break;
case 64:
shader = ResolveCopyShaderIndex::kFull64bpp;
break;
case 128:
shader = ResolveCopyShaderIndex::kFull128bpp;
break;
default:
assert_unhandled_case(resolution_scale);
assert_unhandled_case(dest_format_info.bits_per_pixel);
}
}
@ -1218,9 +1129,12 @@ ResolveCopyShaderIndex ResolveInfo::GetCopyShader(
constants_out.dest_base = copy_dest_base;
if (shader != ResolveCopyShaderIndex::kUnknown) {
uint32_t width = address.width_div_8 << xenos::kResolveAlignmentPixelsLog2;
uint32_t height = address.height_div_8
<< xenos::kResolveAlignmentPixelsLog2;
uint32_t width =
(address.width_div_8 << xenos::kResolveAlignmentPixelsLog2) *
resolution_scale_x;
uint32_t height =
(address.height_div_8 << xenos::kResolveAlignmentPixelsLog2) *
resolution_scale_y;
const ResolveCopyShaderInfo& shader_info =
resolve_copy_shader_info[size_t(shader)];
group_count_x_out = (width + ((1 << shader_info.group_size_x_log2) - 1)) >>

109
src/xenia/gpu/draw_util.h
View File

@ -179,9 +179,9 @@ struct ViewportInfo {
// a viewport, plus values to multiply-add the returned position by, usable on
// host graphics APIs such as Direct3D 11+ and Vulkan, also forcing it to the
// Direct3D clip space with 0...W Z rather than -W...W.
void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale,
bool origin_bottom_left, uint32_t x_max,
uint32_t y_max, bool allow_reverse_z,
void GetHostViewportInfo(const RegisterFile& regs, uint32_t resolution_scale_x,
uint32_t resolution_scale_y, bool origin_bottom_left,
uint32_t x_max, uint32_t y_max, bool allow_reverse_z,
bool convert_z_to_float24, bool full_float24_in_0_to_1,
bool pixel_shader_writes_depth,
ViewportInfo& viewport_info_out);
@ -205,6 +205,46 @@ constexpr uint32_t kDivideUpperShift5 = 2;
constexpr uint32_t kDivideScale15 = 0x88888889u;
constexpr uint32_t kDivideUpperShift15 = 3;
inline void GetEdramTileWidthDivideScaleAndUpperShift(
uint32_t resolution_scale_x, uint32_t& divide_scale,
uint32_t& divide_upper_shift) {
switch (resolution_scale_x) {
case 1:
divide_scale = kDivideScale5;
divide_upper_shift = kDivideUpperShift5 + 4;
break;
case 2:
divide_scale = kDivideScale5;
divide_upper_shift = kDivideUpperShift5 + 5;
break;
case 3:
divide_scale = kDivideScale15;
divide_upper_shift = kDivideUpperShift15 + 4;
break;
default:
assert_unhandled_case(resolution_scale_x);
}
}
// Never an identity conversion - can always write conditional move instructions
// to shaders that will be no-ops for conversion from guest to host samples.
// While we don't know the exact guest sample pattern, due to the way
// multisampled render targets are stored in the memory (like 1x2 single-sampled
// pixels with 2x MSAA, or like 2x2 single-sampled pixels with 4x), assuming
// that the sample 0 is the top sample, and the sample 1 is the bottom one.
inline uint32_t GetD3D10SampleIndexForGuest2xMSAA(
uint32_t guest_sample_index, bool native_2x_msaa_supported) {
assert(guest_sample_index <= 1);
if (native_2x_msaa_supported) {
// On Direct3D 10.1 with native 2x MSAA, the top-left sample is 1, and the
// bottom-right sample is 0.
return guest_sample_index ? 0 : 1;
}
// When native 2x MSAA is not supported, using the top-left (0) and the
// bottom-right (3) samples of the guaranteed 4x MSAA.
return guest_sample_index ? 3 : 0;
}
// To avoid passing values that the shader won't understand (even though
// Direct3D 9 shouldn't pass them anyway).
xenos::CopySampleSelect SanitizeCopySampleSelect(
@ -215,6 +255,7 @@ xenos::CopySampleSelect SanitizeCopySampleSelect(
// constants.
union ResolveEdramPackedInfo {
uint32_t packed;
struct {
// With 32bpp/64bpp taken into account.
uint32_t pitch_tiles : xenos::kEdramPitchTilesBits;
@ -228,12 +269,15 @@ union ResolveEdramPackedInfo {
// the impact of the half-pixel offset with resolution scaling.
uint32_t duplicate_second_pixel : 1;
};
uint32_t packed;
ResolveEdramPackedInfo() : packed(0) {
static_assert_size(*this, sizeof(packed));
}
};
static_assert(sizeof(ResolveEdramPackedInfo) <= sizeof(uint32_t),
"ResolveEdramPackedInfo must be packable in uint32_t");
union ResolveAddressPackedInfo {
uint32_t packed;
struct {
// 160x32 is divisible by both the EDRAM tile size (80x16 samples, but for
// simplicity, this is in pixels) and the texture tile size (32x32), so
@ -258,7 +302,9 @@ union ResolveAddressPackedInfo {
xenos::CopySampleSelect copy_sample_select : 3;
};
uint32_t packed;
ResolveAddressPackedInfo() : packed(0) {
static_assert_size(*this, sizeof(packed));
}
};
static_assert(sizeof(ResolveAddressPackedInfo) <= sizeof(uint32_t),
"ResolveAddressPackedInfo must be packable in uint32_t");
@ -271,6 +317,7 @@ void GetResolveEdramTileSpan(ResolveEdramPackedInfo edram_info,
uint32_t& rows_out);
union ResolveCopyDestPitchPackedInfo {
uint32_t packed;
struct {
// 0...16384/32.
uint32_t pitch_aligned_div_32 : xenos::kTexture2DCubeMaxWidthHeightLog2 +
@ -278,43 +325,24 @@ union ResolveCopyDestPitchPackedInfo {
uint32_t height_aligned_div_32 : xenos::kTexture2DCubeMaxWidthHeightLog2 +
2 - xenos::kTextureTileWidthHeightLog2;
};
uint32_t packed;
ResolveCopyDestPitchPackedInfo() : packed(0) {
static_assert_size(*this, sizeof(packed));
}
};
static_assert(sizeof(ResolveCopyDestPitchPackedInfo) <= sizeof(uint32_t),
"ResolveAddressPackedInfo must be packable in uint32_t");
// For backends with Shader Model 5-like compute, host shaders to use to perform
// copying in resolve operations.
enum class ResolveCopyShaderIndex {
kFast32bpp1x2xMSAA,
kFast32bpp4xMSAA,
kFast32bpp2xRes,
kFast32bpp3xRes1x2xMSAA,
kFast32bpp3xRes4xMSAA,
kFast64bpp1x2xMSAA,
kFast64bpp4xMSAA,
kFast64bpp2xRes,
kFast64bpp3xRes,
kFull8bpp,
kFull8bpp2xRes,
kFull8bpp3xRes,
kFull16bpp,
kFull16bpp2xRes,
kFull16bppFrom32bpp3xRes,
kFull16bppFrom64bpp3xRes,
kFull32bpp,
kFull32bpp2xRes,
kFull32bppFrom32bpp3xRes,
kFull32bppFrom64bpp3xRes,
kFull64bpp,
kFull64bpp2xRes,
kFull64bppFrom32bpp3xRes,
kFull64bppFrom64bpp3xRes,
kFull128bpp,
kFull128bpp2xRes,
kFull128bppFrom32bpp3xRes,
kFull128bppFrom64bpp3xRes,
kCount,
kUnknown = kCount,
@ -323,9 +351,6 @@ enum class ResolveCopyShaderIndex {
struct ResolveCopyShaderInfo {
// Debug name of the pipeline state object with this shader.
const char* debug_name;
// Only need to load this shader if the emulator resolution scale == this
// value.
uint32_t resolution_scale;
// Whether the EDRAM source needs be bound as a raw buffer (ByteAddressBuffer
// in Direct3D) since it can load different numbers of 32-bit values at once
// on some hardware. If the host API doesn't support raw buffers, a typed
@ -420,8 +445,9 @@ struct ResolveInfo {
}
ResolveCopyShaderIndex GetCopyShader(
uint32_t resolution_scale, ResolveCopyShaderConstants& constants_out,
uint32_t& group_count_x_out, uint32_t& group_count_y_out) const;
uint32_t resolution_scale_x, uint32_t resolution_scale_y,
ResolveCopyShaderConstants& constants_out, uint32_t& group_count_x_out,
uint32_t& group_count_y_out) const;
bool IsClearingDepth() const {
return rb_copy_control.depth_clear_enable != 0;
@ -453,7 +479,8 @@ struct ResolveInfo {
constants_out.address_info = address;
}
std::pair<uint32_t, uint32_t> GetClearShaderGroupCount() const {
std::pair<uint32_t, uint32_t> GetClearShaderGroupCount(
uint32_t resolution_scale_x, uint32_t resolution_scale_y) const {
// 8 guest MSAA samples per invocation.
uint32_t width_samples_div_8 = address.width_div_8;
uint32_t height_samples_div_8 = address.height_div_8;
@ -466,6 +493,8 @@ struct ResolveInfo {
width_samples_div_8 <<= 1;
}
}
width_samples_div_8 *= resolution_scale_x;
height_samples_div_8 *= resolution_scale_y;
return std::make_pair((width_samples_div_8 + uint32_t(7)) >> 3,
height_samples_div_8);
}
@ -477,10 +506,22 @@ struct ResolveInfo {
// emulated as snorm, with range limited to -1...1, but with correct blending
// within that range.
bool GetResolveInfo(const RegisterFile& regs, const Memory& memory,
TraceWriter& trace_writer, uint32_t resolution_scale,
TraceWriter& trace_writer, bool is_resolution_scaled,
bool fixed_16_truncated_to_minus_1_to_1,
ResolveInfo& info_out);
union ResolveResolutionScaleConstant {
uint32_t packed;
struct {
// 1 to 3.
uint32_t resolution_scale_x : 2;
uint32_t resolution_scale_y : 2;
};
ResolveResolutionScaleConstant() : packed(0) {
static_assert_size(*this, sizeof(packed));
}
};
// Taking user configuration - stretching or letterboxing, overscan region to
// crop to fill while maintaining the aspect ratio - into account, returns the
// area where the frame should be presented in the host window.

7
src/xenia/gpu/dxbc.h
View File

@ -647,6 +647,7 @@ enum class OperandType : uint32_t {
kInputControlPoint = 25,
kInputDomainPoint = 28,
kUnorderedAccessView = 30,
kInputThreadID = 32,
kInputThreadGroupID = 33,
kInputThreadIDInGroup = 34,
kInputCoverageMask = 35,
@ -880,6 +881,9 @@ struct Dest : OperandAddress {
return Dest(OperandType::kUnorderedAccessView, write_mask, index_1d,
index_2d);
}
static Dest VThreadID(uint32_t read_mask) {
return Dest(OperandType::kInputThreadID, read_mask);
}
static Dest VThreadGroupID(uint32_t read_mask) {
return Dest(OperandType::kInputThreadGroupID, read_mask);
}
@ -1052,6 +1056,9 @@ struct Src : OperandAddress {
return Src(OperandType::kUnorderedAccessView, kXYZW, id, lower_bound,
upper_bound);
}
static Src VThreadID(uint32_t swizzle = kXYZW) {
return Src(OperandType::kInputThreadID, swizzle);
}
static Src VThreadGroupID(uint32_t swizzle = kXYZW) {
return Src(OperandType::kInputThreadGroupID, swizzle);
}

28
src/xenia/gpu/dxbc_shader_translator.cc
View File

@ -69,8 +69,8 @@ using namespace ucode;
DxbcShaderTranslator::DxbcShaderTranslator(
ui::GraphicsProvider::GpuVendorID vendor_id, bool bindless_resources_used,
bool edram_rov_used, bool gamma_render_target_as_srgb,
bool msaa_2x_supported, uint32_t draw_resolution_scale,
bool force_emit_source_map)
bool msaa_2x_supported, uint32_t draw_resolution_scale_x,
uint32_t draw_resolution_scale_y, bool force_emit_source_map)
: a_(shader_code_, statistics_),
ao_(shader_object_, statistics_),
vendor_id_(vendor_id),
@ -78,10 +78,13 @@ DxbcShaderTranslator::DxbcShaderTranslator(
edram_rov_used_(edram_rov_used),
gamma_render_target_as_srgb_(gamma_render_target_as_srgb),
msaa_2x_supported_(msaa_2x_supported),
draw_resolution_scale_(draw_resolution_scale),
draw_resolution_scale_x_(draw_resolution_scale_x),
draw_resolution_scale_y_(draw_resolution_scale_y),
emit_source_map_(force_emit_source_map || cvars::dxbc_source_map) {
assert_true(draw_resolution_scale >= 1);
assert_true(draw_resolution_scale <= 3);
assert_true(draw_resolution_scale_x >= 1);
assert_true(draw_resolution_scale_x <= 3);
assert_true(draw_resolution_scale_y >= 1);
assert_true(draw_resolution_scale_y <= 3);
// Don't allocate again and again for the first shader.
shader_code_.reserve(8192);
shader_object_.reserve(16384);
@ -659,13 +662,17 @@ void DxbcShaderTranslator::StartPixelShader() {
in_position_used_ |= 0b0011;
a_.OpRoundNI(dxbc::Dest::R(param_gen_temp, 0b0011),
dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition)));
if (draw_resolution_scale_ > 1) {
uint32_t resolution_scaled_axes =
uint32_t(draw_resolution_scale_x_ > 1) |
(uint32_t(draw_resolution_scale_y_ > 1) << 1);
if (resolution_scaled_axes) {
// Revert resolution scale - after truncating, so if the pixel position
// is passed to tfetch (assuming the game doesn't round it by itself),
// it will be sampled with higher resolution too.
a_.OpMul(dxbc::Dest::R(param_gen_temp, 0b0011),
a_.OpMul(dxbc::Dest::R(param_gen_temp, resolution_scaled_axes),
dxbc::Src::R(param_gen_temp),
dxbc::Src::LF(1.0f / draw_resolution_scale_));
dxbc::Src::LF(1.0f / draw_resolution_scale_x_,
1.0f / draw_resolution_scale_y_, 1.0f, 1.0f));
}
a_.OpMov(dxbc::Dest::R(param_gen_temp, 0b0011),
dxbc::Src::R(param_gen_temp).Abs());
@ -2001,7 +2008,8 @@ const DxbcShaderTranslator::SystemConstantRdef
{"xe_textures_resolved", ShaderRdefTypeIndex::kUint, sizeof(uint32_t)},
{"xe_alpha_test_reference", ShaderRdefTypeIndex::kFloat, sizeof(float)},
{"xe_alpha_to_mask", ShaderRdefTypeIndex::kUint, sizeof(uint32_t)},
{"xe_edram_pitch_tiles", ShaderRdefTypeIndex::kUint, sizeof(uint32_t)},
{"xe_edram_32bpp_tile_pitch_dwords_scaled", ShaderRdefTypeIndex::kUint,
sizeof(uint32_t)},
{"xe_color_exp_bias", ShaderRdefTypeIndex::kFloat4, sizeof(float) * 4},
@ -2010,7 +2018,7 @@ const DxbcShaderTranslator::SystemConstantRdef
{"xe_edram_poly_offset_back", ShaderRdefTypeIndex::kFloat2,
sizeof(float) * 2},
{"xe_edram_depth_base_dwords", ShaderRdefTypeIndex::kUint,
{"xe_edram_depth_base_dwords_scaled", ShaderRdefTypeIndex::kUint,
sizeof(uint32_t), sizeof(float) * 3},
{"xe_edram_stencil", ShaderRdefTypeIndex::kUint4Array2,

23
src/xenia/gpu/dxbc_shader_translator.h
View File

@ -15,6 +15,7 @@
#include <string>
#include <vector>
#include "xenia/base/assert.h"
#include "xenia/base/math.h"
#include "xenia/base/string_buffer.h"
#include "xenia/gpu/dxbc.h"
@ -49,7 +50,8 @@ class DxbcShaderTranslator : public ShaderTranslator {
bool bindless_resources_used, bool edram_rov_used,
bool gamma_render_target_as_srgb = false,
bool msaa_2x_supported = true,
uint32_t draw_resolution_scale = 1,
uint32_t draw_resolution_scale_x = 1,
uint32_t draw_resolution_scale_y = 1,
bool force_emit_source_map = false);
~DxbcShaderTranslator() override;
@ -85,6 +87,7 @@ class DxbcShaderTranslator : public ShaderTranslator {
kFloat24Rounding,
};
uint64_t value;
struct VertexShaderModification {
// Dynamically indexable register count from SQ_PROGRAM_CNTL.
uint32_t dynamic_addressable_register_count : 8;
@ -98,9 +101,10 @@ class DxbcShaderTranslator : public ShaderTranslator {
// Non-ROV - depth / stencil output mode.
DepthStencilMode depth_stencil_mode : 2;
} pixel;
uint64_t value = 0;
Modification(uint64_t modification_value = 0) : value(modification_value) {}
Modification(uint64_t modification_value = 0) : value(modification_value) {
static_assert_size(*this, sizeof(value));
}
};
// Constant buffer bindings in space 0.
@ -262,7 +266,7 @@ class DxbcShaderTranslator : public ShaderTranslator {
// If alpha to mask is enabled, bits 0:7 are sample offsets, and bit 8 must
// be 1.
uint32_t alpha_to_mask;
uint32_t edram_pitch_tiles;
uint32_t edram_32bpp_tile_pitch_dwords_scaled;
float color_exp_bias[4];
@ -281,8 +285,8 @@ class DxbcShaderTranslator : public ShaderTranslator {
float edram_poly_offset_back[2];
};
uint32_t edram_depth_base_dwords;
uint32_t padding_edram_depth_base_dwords[3];
uint32_t edram_depth_base_dwords_scaled;
uint32_t padding_edram_depth_base_dwords_scaled[3];
// In stencil function/operations (they match the layout of the
// function/operations in RB_DEPTHCONTROL):
@ -366,14 +370,14 @@ class DxbcShaderTranslator : public ShaderTranslator {
kTexturesResolved,
kAlphaTestReference,
kAlphaToMask,
kEdramPitchTiles,
kEdram32bppTilePitchDwordsScaled,
kColorExpBias,
kEdramPolyOffsetFront,
kEdramPolyOffsetBack,
kEdramDepthBaseDwords,
kEdramDepthBaseDwordsScaled,
kEdramStencil,
@ -944,7 +948,8 @@ class DxbcShaderTranslator : public ShaderTranslator {
bool msaa_2x_supported_;
// Guest pixel host width / height.
uint32_t draw_resolution_scale_;
uint32_t draw_resolution_scale_x_;
uint32_t draw_resolution_scale_y_;
// Is currently writing the empty depth-only pixel shader, for
// CompleteTranslation.

61
src/xenia/gpu/dxbc_shader_translator_fetch.cc
View File

@ -693,13 +693,14 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
}
// Get offsets applied to the coordinates before sampling.
// `offsets` is used for float4 literal construction,
// FIXME(Triang3l): Offsets need to be applied at the LOD being fetched, not
// at LOD 0. However, since offsets have granularity of 0.5, not 1, on the
// Xbox 360, they can't be passed directly as AOffImmI to the `sample`
// instruction (plus-minus 0.5 offsets are very common in games). But
// offsetting at mip levels is a rare usage case, mostly offsets are used for
// things like shadow maps and blur, where there are no mips.
float offsets[4] = {};
float offsets[3] = {};
// MSDN doesn't list offsets as getCompTexLOD parameters.
if (instr.opcode != FetchOpcode::kGetTextureComputedLod) {
// Add a small epsilon to the offset (1.5/4 the fixed-point texture
@ -770,6 +771,8 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
offsets_not_zero |= 1 << i;
}
}
dxbc::Src offsets_src(
dxbc::Src::LF(offsets[0], offsets[1], offsets[2], 0.0f));
// Load the texture size if needed.
// 1D: X - width.
@ -894,8 +897,11 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
dxbc::Src::R(size_and_is_3d_temp));
}
}
bool revert_resolution_scale = draw_resolution_scale_ > 1 &&
cvars::draw_resolution_scaled_texture_offsets;
uint32_t revert_resolution_scale_axes =
cvars::draw_resolution_scaled_texture_offsets
? uint32_t(draw_resolution_scale_x_ > 1) |
(uint32_t(draw_resolution_scale_y_ > 1) << 1)
: 0;
if (instr.opcode == FetchOpcode::kGetTextureWeights) {
// FIXME(Triang3l): Mip lerp factor needs to be calculated, and the
@ -920,8 +926,7 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
// If needed, apply the resolution scale to the width / height and the
// unnormalized coordinates.
uint32_t resolution_scaled_result_components =
revert_resolution_scale ? used_result_nonzero_components & 0b0011
: 0b0000;
used_result_nonzero_components & revert_resolution_scale_axes;
uint32_t resolution_scaled_coord_components =
instr.attributes.unnormalized_coordinates
? resolution_scaled_result_components
@ -952,7 +957,8 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
a_.OpIf(true, dxbc::Src::R(system_temp_result_, dxbc::Src::kWWWW));
// The texture is resolved - scale the coordinates and the size.
dxbc::Src resolution_scale_src(
dxbc::Src::LF(float(draw_resolution_scale_)));
dxbc::Src::LF(float(draw_resolution_scale_x_),
float(draw_resolution_scale_y_), 1.0f, 1.0f));
if (resolution_scaled_coord_components) {
a_.OpMul(dxbc::Dest::R(system_temp_result_,
resolution_scaled_coord_components),
@ -975,14 +981,14 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
dxbc::Dest::R(system_temp_result_, used_result_nonzero_components));
if (instr.attributes.unnormalized_coordinates) {
if (offsets_needed) {
a_.OpAdd(coord_dest, coord_operand, dxbc::Src::LP(offsets));
a_.OpAdd(coord_dest, coord_operand, offsets_src);
}
} else {
assert_true((size_needed_components & used_result_nonzero_components) ==
used_result_nonzero_components);
if (offsets_needed) {
a_.OpMAd(coord_dest, coord_operand, dxbc::Src::R(size_and_is_3d_temp),
dxbc::Src::LP(offsets));
offsets_src);
} else {
a_.OpMul(coord_dest, coord_operand,
dxbc::Src::R(size_and_is_3d_temp));
@ -1048,8 +1054,7 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
uint32_t normalized_components_with_offsets =
normalized_components & offsets_not_zero;
uint32_t normalized_components_with_scaled_offsets =
revert_resolution_scale ? normalized_components_with_offsets & 0b0011
: 0;
normalized_components_with_offsets & revert_resolution_scale_axes;
uint32_t normalized_components_with_unscaled_offsets =
normalized_components_with_offsets &
~normalized_components_with_scaled_offsets;
@ -1073,20 +1078,23 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
offsetof(SystemConstants, textures_resolved),
dxbc::Src::kXXXX),
dxbc::Src::LU(uint32_t(1) << tfetch_index));
a_.OpMovC(dxbc::Dest::R(coord_and_sampler_temp, 0b1000),
dxbc::Src::R(coord_and_sampler_temp, dxbc::Src::kWWWW),
dxbc::Src::LF(1.0f / draw_resolution_scale_),
dxbc::Src::LF(1.0f));
a_.OpMAd(dxbc::Dest::R(coord_and_sampler_temp,
a_.OpIf(true, dxbc::Src::R(coord_and_sampler_temp, dxbc::Src::kWWWW));
a_.OpAdd(
dxbc::Dest::R(coord_and_sampler_temp,
normalized_components_with_scaled_offsets),
coord_operand,
dxbc::Src::LF(offsets[0] / draw_resolution_scale_x_,
offsets[1] / draw_resolution_scale_y_, 0.0f, 0.0f));
a_.OpElse();
a_.OpAdd(dxbc::Dest::R(coord_and_sampler_temp,
normalized_components_with_scaled_offsets),
dxbc::Src::LP(offsets),
dxbc::Src::R(coord_and_sampler_temp, dxbc::Src::kWWWW),
coord_operand);
coord_operand, offsets_src);
a_.OpEndIf();
}
if (normalized_components_with_unscaled_offsets) {
a_.OpAdd(dxbc::Dest::R(coord_and_sampler_temp,
normalized_components_with_unscaled_offsets),
coord_operand, dxbc::Src::LP(offsets));
coord_operand, offsets_src);
}
if (normalized_components_without_offsets) {
a_.OpMov(dxbc::Dest::R(coord_and_sampler_temp,
@ -1129,7 +1137,7 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
normalized_components_with_offsets);
a_.OpDiv(dxbc::Dest::R(coord_and_sampler_temp,
normalized_components_with_offsets),
dxbc::Src::LP(offsets), dxbc::Src::R(size_and_is_3d_temp));
offsets_src, dxbc::Src::R(size_and_is_3d_temp));
if (normalized_components_with_scaled_offsets) {
// Using coord_and_sampler_temp.w as a temporary for the needed
// resolution scale inverse - sampler not loaded yet.
@ -1139,15 +1147,18 @@ void DxbcShaderTranslator::ProcessTextureFetchInstruction(
offsetof(SystemConstants, textures_resolved),
dxbc::Src::kXXXX),
dxbc::Src::LU(uint32_t(1) << tfetch_index));
a_.OpMovC(dxbc::Dest::R(coord_and_sampler_temp, 0b1000),
dxbc::Src::R(coord_and_sampler_temp, dxbc::Src::kWWWW),
dxbc::Src::LF(1.0f / draw_resolution_scale_),
dxbc::Src::LF(1.0f));
a_.OpIf(true, dxbc::Src::R(coord_and_sampler_temp, dxbc::Src::kWWWW));
a_.OpMAd(dxbc::Dest::R(coord_and_sampler_temp,
normalized_components_with_scaled_offsets),
dxbc::Src::R(coord_and_sampler_temp),
dxbc::Src::R(coord_and_sampler_temp, dxbc::Src::kWWWW),
dxbc::Src::LF(1.0f / draw_resolution_scale_x_,
1.0f / draw_resolution_scale_y_, 1.0f, 1.0f),
coord_operand);
a_.OpElse();
a_.OpAdd(dxbc::Dest::R(coord_and_sampler_temp,
normalized_components_with_scaled_offsets),
coord_operand, dxbc::Src::R(coord_and_sampler_temp));
a_.OpEndIf();
}
if (normalized_components_with_unscaled_offsets) {
a_.OpAdd(dxbc::Dest::R(coord_and_sampler_temp,

101
src/xenia/gpu/dxbc_shader_translator_memexport.cc
View File

@ -8,6 +8,7 @@
*/
#include "xenia/base/assert.h"
#include "xenia/base/math.h"
#include "xenia/gpu/draw_util.h"
#include "xenia/gpu/dxbc_shader_translator.h"
@ -121,52 +122,74 @@ void DxbcShaderTranslator::ExportToMemory() {
// 0 or 0xFFFFFFFF.
bool inner_condition_provided = false;
if (is_pixel_shader()) {
if (draw_resolution_scale_ > 1) {
uint32_t resolution_scaled_axes =
uint32_t(draw_resolution_scale_x_ > 1) |
(uint32_t(draw_resolution_scale_y_ > 1) << 1);
if (resolution_scaled_axes) {
// Only do memexport for one host pixel in a guest pixel.
// For 2x - (1, 1) because it's covered with half-pixel offset that
// For 2x - pixel 1 because it's covered with half-pixel offset that
// becomes full-pixel.
// For 3x - also (1, 1) because it's still covered with half-pixel offset,
// but close to the center.
in_position_used_ |= 0b0011;
// For 3x - also pixel 1 because it's still covered with half-pixel
// offset, but close to the center.
// If X needs resolution scaling, writing 1 or 0 - whether the column is
// the one where memexport should be done - to control_temp.y.
// For Y, doing that to control_temp.z.
// Then, if both axes are resolution-scaled, merging the conditions for
// the two.
in_position_used_ |= resolution_scaled_axes;
a_.OpFToU(
dxbc::Dest::R(control_temp, 0b0110),
dxbc::Dest::R(control_temp, resolution_scaled_axes << 1),
dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition), 0b0100 << 2));
switch (draw_resolution_scale_) {
case 2:
a_.OpAnd(dxbc::Dest::R(control_temp, 0b0110),
dxbc::Src::R(control_temp), dxbc::Src::LU(1));
// No need to do IEq - already 1 for right / bottom, 0 for left / top.
break;
case 3:
// xy % 3 == 1.
for (uint32_t i = 1; i <= 2; ++i) {
a_.OpUMul(dxbc::Dest::R(control_temp, 0b1000), dxbc::Dest::Null(),
dxbc::Src::R(control_temp).Select(i),
dxbc::Dest resolution_scaling_temp_dest(
dxbc::Dest::R(control_temp, 0b1000));
dxbc::Src resolution_scaling_temp_src(
dxbc::Src::R(control_temp, dxbc::Src::kWWWW));
for (uint32_t i = 0; i < 2; ++i) {
if (!(resolution_scaled_axes & (1 << i))) {
continue;
}
// If there's no inner condition in control_temp.x yet, the condition
// for the current axis can go directly to it. Otherwise, need to merge
// with the previous condition, using control_temp.w as an intermediate
// variable.
dxbc::Dest resolution_scaled_axis_result(
inner_condition_provided ? resolution_scaling_temp_dest
: dxbc::Dest::R(control_temp, 0b0001));
dxbc::Src resolution_scaled_axis_src(
dxbc::Src::R(control_temp).Select(1 + i));
uint32_t axis_resolution_scale =
i ? draw_resolution_scale_y_ : draw_resolution_scale_x_;
switch (axis_resolution_scale) {
case 2:
// xy & 1 == 1.
a_.OpAnd(resolution_scaled_axis_result, resolution_scaled_axis_src,
dxbc::Src::LU(1));
// No need to do IEq - already 1 for right / bottom, 0 for left /
// top.
break;
case 3:
// xy % 3 == 1.
a_.OpUMul(resolution_scaling_temp_dest, dxbc::Dest::Null(),
resolution_scaled_axis_src,
dxbc::Src::LU(draw_util::kDivideScale3));
a_.OpUShR(dxbc::Dest::R(control_temp, 0b1000),
dxbc::Src::R(control_temp, dxbc::Src::kWWWW),
a_.OpUShR(resolution_scaling_temp_dest, resolution_scaling_temp_src,
dxbc::Src::LU(draw_util::kDivideUpperShift3));
a_.OpIMAd(dxbc::Dest::R(control_temp, 1 << i),
dxbc::Src::R(control_temp, dxbc::Src::kWWWW),
dxbc::Src::LI(-3), dxbc::Src::R(control_temp).Select(i));
}
a_.OpIEq(dxbc::Dest::R(control_temp, 0b0110),
dxbc::Src::R(control_temp), dxbc::Src::LU(1));
break;
default:
assert_unhandled_case(draw_resolution_scale_);
a_.OpIMAd(resolution_scaling_temp_dest, resolution_scaling_temp_src,
dxbc::Src::LI(-3), resolution_scaled_axis_src);
a_.OpIEq(resolution_scaled_axis_result, resolution_scaling_temp_src,
dxbc::Src::LU(1));
break;
default:
assert_unhandled_case(axis_resolution_scale);
}
if (inner_condition_provided) {
// Merge with the previous condition in control_temp.x.
a_.OpAnd(dxbc::Dest::R(control_temp, 0b0001),
dxbc::Src::R(control_temp, dxbc::Src::kXXXX),
resolution_scaling_temp_src);
}
inner_condition_provided = true;
}
a_.OpAnd(dxbc::Dest::R(control_temp,
inner_condition_provided ? 0b0010 : 0b0001),
dxbc::Src::R(control_temp, dxbc::Src::kYYYY),
dxbc::Src::R(control_temp, dxbc::Src::kZZZZ));
if (inner_condition_provided) {
// Merge with the previous condition in control_temp.x.
a_.OpAnd(dxbc::Dest::R(control_temp, 0b0001),
dxbc::Src::R(control_temp, dxbc::Src::kXXXX),
dxbc::Src::R(control_temp, dxbc::Src::kYYYY));
}
inner_condition_provided = true;
}
// With sample-rate shading (with float24 conversion), only do memexport
// from one sample (as the shader is invoked multiple times for a pixel),

599
src/xenia/gpu/dxbc_shader_translator_om.cc
View File

@ -156,212 +156,379 @@ void DxbcShaderTranslator::StartPixelShader_LoadROVParameters() {
// 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));
}
// For now, while we don't know the encoding of 64bpp render targets when
// interpreted as 32bpp (no game has been seen reinterpreting between the two
// yet), for consistency with the conventional render target logic and to have
// the same resolve logic for both, storing 64bpp color as 40x16 samples
// (multiplied by the resolution scale) per 1280-byte tile. It's also
// convenient to use 40x16 granularity in the calculations here because depth
// render targets have 40-sample halves swapped as opposed to color in each
// tile, and reinterpretation between depth and color is common for depth /
// stencil reloading into the EDRAM (such as in the background of the main
// menu of 4D5307E6).
// Convert the host pixel position to integer to system_temp_rov_params_.xy.
// system_temp_rov_params_.x = X host pixel position as uint
// system_temp_rov_params_.y = Y host pixel position as uint
in_position_used_ |= 0b0011;
a_.OpFToU(dxbc::Dest::R(system_temp_rov_params_, 0b0011),
dxbc::Src::V(uint32_t(InOutRegister::kPSInPosition)));
// 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
a_.OpIShL(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
dxbc::Src::R(system_temp_rov_params_),
LoadSystemConstant(SystemConstants::Index::kSampleCountLog2,
offsetof(SystemConstants, sample_count_log2),
0b0100 << 4));
// 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
a_.OpUMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
LoadSystemConstant(SystemConstants::Index::kEdramPitchTiles,
offsetof(SystemConstants, edram_pitch_tiles),
dxbc::Src::kXXXX),
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
// system_temp_rov_params_.x = X sample 0 position
// system_temp_rov_params_.y = Y sample 0 position
a_.OpIShL(
dxbc::Dest::R(system_temp_rov_params_, 0b0011),
dxbc::Src::R(system_temp_rov_params_),
LoadSystemConstant(SystemConstants::Index::kSampleCountLog2,
offsetof(SystemConstants, sample_count_log2), 0b0100));
// For cases of both color and depth:
// Get 40 x 16 x resolution scale 32bpp half-tile or 40x16 64bpp tile index
// to system_temp_rov_params_.zw, and put the sample index within such a
// region in system_temp_rov_params_.xy.
// Working with 40x16-sample portions for 64bpp and for swapping for depth -
// dividing by 40, not by 80.
// For depth-only:
// Same, but for full 80x16 tiles, not 40x16 half-tiles.
uint32_t tile_or_half_tile_width = 80 * draw_resolution_scale_x_;
uint32_t tile_or_half_tile_width_divide_scale;
uint32_t tile_or_half_tile_width_divide_upper_shift;
draw_util::GetEdramTileWidthDivideScaleAndUpperShift(
draw_resolution_scale_x_, tile_or_half_tile_width_divide_scale,
tile_or_half_tile_width_divide_upper_shift);
if (any_color_targets_written) {
tile_or_half_tile_width >>= 1;
assert_not_zero(tile_or_half_tile_width_divide_upper_shift);
--tile_or_half_tile_width_divide_upper_shift;
}
if (draw_resolution_scale_y_ == 3) {
// Multiplication part of the division by 40|80 x 16 x scale (specifically
// 40|80 * scale width here, and 48 height, or 16 * 3 height).
// system_temp_rov_params_.x = X sample 0 position
// system_temp_rov_params_.y = Y sample 0 position
// system_temp_rov_params_.z = (X * tile_or_half_tile_width_divide_scale) >>
// 32
// system_temp_rov_params_.w = (Y * kDivideScale3) >> 32
a_.OpUMul(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
dxbc::Dest::Null(),
dxbc::Src::R(system_temp_rov_params_, 0b0100 << 4),
dxbc::Src::LU(0, 0, tile_or_half_tile_width_divide_scale,
draw_util::kDivideScale3));
// Shift part of the division by 40|80 x 16 x scale.
// system_temp_rov_params_.x = X sample 0 position
// system_temp_rov_params_.y = Y sample 0 position
// system_temp_rov_params_.z = X half-tile or tile position
// system_temp_rov_params_.w = Y tile position
a_.OpUShR(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
dxbc::Src::R(system_temp_rov_params_),
dxbc::Src::LU(0, 0, tile_or_half_tile_width_divide_upper_shift,
draw_util::kDivideUpperShift3 + 4));
// Take the remainder of the performed division to
// system_temp_rov_params_.xy.
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = Y sample 0 position within the (half-)tile
// system_temp_rov_params_.z = X half-tile or tile position
// system_temp_rov_params_.w = Y tile position
a_.OpIMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0011),
dxbc::Src::R(system_temp_rov_params_, 0b1110),
dxbc::Src::LI(-int32_t(tile_or_half_tile_width),
-16 * draw_resolution_scale_y_, 0, 0),
dxbc::Src::R(system_temp_rov_params_));
} else {
assert_true(draw_resolution_scale_y_ <= 2);
// Multiplication part of the division of X by 40|80 * scale.
// system_temp_rov_params_.x = X sample 0 position
// system_temp_rov_params_.y = Y sample 0 position
// system_temp_rov_params_.z = (X * tile_or_half_tile_width_divide_scale) >>
// 32
a_.OpUMul(dxbc::Dest::R(system_temp_rov_params_, 0b0100),
dxbc::Dest::Null(),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
dxbc::Src::LU(tile_or_half_tile_width_divide_scale));
// Shift part of the division of X by 40 * scale, division of Y by
// 16 * scale as it's power of two in this case.
// system_temp_rov_params_.x = X sample 0 position
// system_temp_rov_params_.y = Y sample 0 position
// system_temp_rov_params_.z = X half-tile or tile position
// system_temp_rov_params_.w = Y tile position
a_.OpUShR(dxbc::Dest::R(system_temp_rov_params_, 0b1100),
dxbc::Src::R(system_temp_rov_params_, 0b0110 << 4),
dxbc::Src::LU(0, 0, tile_or_half_tile_width_divide_upper_shift,
draw_resolution_scale_y_ == 2 ? 5 : 4));
// Take the remainder of the performed division (via multiply-subtract for
// X, via AND for Y which is power-of-two here) to
// system_temp_rov_params_.xy.
// system_temp_rov_params_.x = X sample 0 position within the half-tile or
// tile
// system_temp_rov_params_.y = Y sample 0 position within the (half-)tile
// system_temp_rov_params_.z = X half-tile or tile position
// system_temp_rov_params_.w = Y tile position
a_.OpIMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
dxbc::Src::LI(-int32_t(tile_or_half_tile_width)),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX));
a_.OpAnd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
dxbc::Src::LU((16 * draw_resolution_scale_y_) - 1));
}
// Convert the Y sample 0 position within the half-tile or tile to the dword
// offset of the row within a 80x16 32bpp tile or a 40x16 64bpp half-tile to
// system_temp_rov_params_.y.
// system_temp_rov_params_.x = X sample 0 position within the half-tile or
// tile
// system_temp_rov_params_.y = Y sample 0 row dword offset within the
// 80x16-dword tile
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = Y tile 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 (4D5307E6).
// 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));
dxbc::Src::LU(80 * draw_resolution_scale_x_));
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
a_.OpIAdd(
dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
LoadSystemConstant(SystemConstants::Index::kEdramDepthBaseDwords,
offsetof(SystemConstants, edram_depth_base_dwords),
dxbc::Src::kXXXX));
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),
// Depth, 32bpp color, 64bpp color are all needed.
// X sample 0 position within in the half-tile in system_temp_rov_params_.x,
// for 64bpp, will be used directly as sample X the within the 80x16-dword
// region, but for 32bpp color and depth, 40x16 half-tile index within the
// 80x16 tile - system_temp_rov_params_.z & 1 - will also be taken into
// account when calculating the X (directly for color, flipped for depth).
uint32_t rov_address_temp = PushSystemTemp();
// Multiply the Y tile position by the surface tile pitch in dwords to get
// the address of the origin of the row of tiles within a 32bpp surface in
// dwords (later it needs to be multiplied by 2 for 64bpp).
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = Y sample 0 row dword offset within the
// 80x16-dword tile
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = Y tile row dword origin in a 32bpp surface
a_.OpUMul(
dxbc::Dest::Null(), dxbc::Dest::R(system_temp_rov_params_, 0b1000),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
LoadSystemConstant(
SystemConstants::Index::kEdram32bppTilePitchDwordsScaled,
offsetof(SystemConstants, edram_32bpp_tile_pitch_dwords_scaled),
dxbc::Src::kXXXX));
// Get the 32bpp tile X position within the row of tiles to
// rov_address_temp.x.
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = Y sample 0 row dword offset within the
// 80x16-dword tile
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = Y tile row dword origin in a 32bpp surface
// rov_address_temp.x = X 32bpp tile position
a_.OpUShR(dxbc::Dest::R(rov_address_temp, 0b0001),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
dxbc::Src::LU(1));
// Get the dword offset of the beginning of the row of samples within a row
// of 32bpp 80x16 tiles to rov_address_temp.x.
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = Y sample 0 row dword offset within the
// 80x16-dword tile
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = Y tile row dword origin in a 32bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a row of 32bpp tiles
a_.OpUMAd(
dxbc::Dest::R(rov_address_temp, 0b0001),
dxbc::Src::R(rov_address_temp, dxbc::Src::kXXXX),
dxbc::Src::LU(80 * 16 *
(draw_resolution_scale_x_ * draw_resolution_scale_y_)),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY));
// Get the dword offset of the beginning of the row of samples within a
// 32bpp surface to rov_address_temp.x.
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = Y sample 0 row dword offset within the
// 80x16-dword tile
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = Y tile row dword origin in a 32bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a 32bpp surface
a_.OpIAdd(dxbc::Dest::R(rov_address_temp, 0b0001),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
dxbc::Src::R(rov_address_temp, dxbc::Src::kXXXX));
// Get the dword offset of the beginning of the row of samples within a row
// of 64bpp 80x16 tiles to system_temp_rov_params_.y (last time the
// tile-local Y offset is needed).
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = dword offset of the beginning of the row of
// samples within a row of 64bpp tiles
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = Y tile row dword origin in a 32bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a 32bpp surface
a_.OpUMAd(
dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
dxbc::Src::LU(80 * 16 *
(draw_resolution_scale_x_ * draw_resolution_scale_y_)),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY));
// Get the dword offset of the beginning of the row of samples within a
// 64bpp surface to system_temp_rov_params_.w (last time the Y tile row
// offset is needed).
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = free
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = dword offset of the beginning of the row of
// samples within a 64bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a 32bpp surface
a_.OpUMAd(dxbc::Dest::R(system_temp_rov_params_, 0b1000),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
dxbc::Src::LU(2),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY));
// Get the final offset of the sample 0 within a 64bpp surface to
// system_temp_rov_params_.w.
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.z = X half-tile position
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a 32bpp surface
a_.OpUMAd(dxbc::Dest::R(system_temp_rov_params_, 0b1000),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
dxbc::Src::LU(2),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW));
// Get the half-tile index within the tile to system_temp_rov_params_.y
// (last time the X half-tile position is needed).
// system_temp_rov_params_.x = X sample 0 position within the half-tile
// system_temp_rov_params_.y = half-tile index within the tile
// system_temp_rov_params_.z = free
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a 32bpp surface
a_.OpAnd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
dxbc::Src::LU(1));
// Get the X position within the 32bpp tile to system_temp_rov_params_.z
// (last time the X position within the half-tile is needed).
// system_temp_rov_params_.x = free
// system_temp_rov_params_.y = half-tile index within the tile
// system_temp_rov_params_.z = X sample 0 position within the tile
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface
// rov_address_temp.x = dword offset of the beginning of the row of samples
// within a 32bpp surface
a_.OpUMAd(dxbc::Dest::R(system_temp_rov_params_, 0b0100),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
dxbc::Src::LU(40 * draw_resolution_scale_x_),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX));
// Get the final offset of the sample 0 within a 32bpp color surface to
// system_temp_rov_params_.z (last time the 32bpp row offset is needed).
// system_temp_rov_params_.y = half-tile index within the tile
// system_temp_rov_params_.z = dword sample 0 offset within a 32bpp surface
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface
// rov_address_temp.x = free
a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0100),
dxbc::Src::R(rov_address_temp, dxbc::Src::kXXXX),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ));
// Flip the 40x16 half-tiles for depth / stencil as opposed to 32bpp color -
// get the dword offset to add for flipping to system_temp_rov_params_.y.
// system_temp_rov_params_.y = depth half-tile flipping offset
// system_temp_rov_params_.z = dword sample 0 offset within a 32bpp surface
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface
a_.OpMovC(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
dxbc::Src::LI(-40 * draw_resolution_scale_x_),
dxbc::Src::LI(40 * draw_resolution_scale_x_));
// Flip the 40x16 half-tiles for depth / stencil as opposed to 32bpp color -
// get the final offset of the sample 0 within a 32bpp depth / stencil
// surface to system_temp_rov_params_.y.
// system_temp_rov_params_.y = dword sample 0 offset within depth / stencil
// system_temp_rov_params_.z = dword sample 0 offset within a 32bpp surface
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface
a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY));
// Release rov_address_temp.
PopSystemTemp();
} else {
// Simpler logic for depth-only, not involving half-tile indices (flipping
// half-tiles via comparison).
// Get the dword offset of the beginning of the row of samples within a row
// of 32bpp 80x16 tiles to system_temp_rov_params_.z (last time the X tile
// position is needed).
// system_temp_rov_params_.x = X sample 0 position within the tile
// system_temp_rov_params_.y = Y sample 0 row dword offset within the
// 80x16-dword tile
// system_temp_rov_params_.z = dword offset of the beginning of the row of
// samples within a row of 32bpp tiles
// system_temp_rov_params_.w = Y tile position
a_.OpUMAd(
dxbc::Dest::R(system_temp_rov_params_, 0b0100),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ),
dxbc::Src::LU(80 * 16 *
(draw_resolution_scale_x_ * draw_resolution_scale_y_)),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY));
// Get the dword offset of the beginning of the row of samples within a
// 32bpp surface to system_temp_rov_params_.y (last time anything Y-related
// is needed, as well as the sample row offset within the tile row).
// system_temp_rov_params_.x = X sample 0 position within the tile
// system_temp_rov_params_.y = dword offset of the beginning of the row of
// samples within a 32bpp surface
// system_temp_rov_params_.z = free
// system_temp_rov_params_.w = free
a_.OpUMAd(
dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kWWWW),
LoadSystemConstant(
SystemConstants::Index::kEdram32bppTilePitchDwordsScaled,
offsetof(SystemConstants, edram_32bpp_tile_pitch_dwords_scaled),
dxbc::Src::kXXXX),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kZZZZ));
// Add the tile-local X to the depth offset in system_temp_rov_params_.y.
// system_temp_rov_params_.x = X sample 0 position within the tile
// system_temp_rov_params_.y = dword sample 0 offset within a 32bpp surface
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));
// Flip the 40x16 half-tiles for depth / stencil as opposed to 32bpp color -
// check in which half-tile the pixel is in to system_temp_rov_params_.x.
// system_temp_rov_params_.x = free
// system_temp_rov_params_.y = dword sample 0 offset within a 32bpp surface
// system_temp_rov_params_.z = 0xFFFFFFFF if in the right half-tile, 0
// otherwise
a_.OpUGE(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
dxbc::Src::LU(40 * draw_resolution_scale_x_));
// Flip the 40x16 half-tiles for depth / stencil as opposed to 32bpp color -
// get the dword offset to add for flipping to system_temp_rov_params_.x.
// system_temp_rov_params_.x = depth half-tile flipping offset
// system_temp_rov_params_.y = dword sample 0 offset within a 32bpp surface
a_.OpMovC(dxbc::Dest::R(system_temp_rov_params_, 0b0001),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kXXXX),
dxbc::Src::LI(-40 * draw_resolution_scale_x_),
dxbc::Src::LI(40 * draw_resolution_scale_x_));
// Flip the 40x16 half-tiles for depth / stencil as opposed to 32bpp color -
// get the final offset of the sample 0 within a 32bpp depth / stencil
// surface to system_temp_rov_params_.y.
// system_temp_rov_params_.x = free
// system_temp_rov_params_.y = dword sample 0 offset within depth / stencil
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 = EDRAM depth / stencil address
// system_temp_rov_params_.z = dword sample 0 offset within a 32bpp surface if
// needed
// system_temp_rov_params_.w = dword sample 0 offset within a 64bpp surface if
// needed
a_.OpIAdd(dxbc::Dest::R(system_temp_rov_params_, 0b0010),
dxbc::Src::R(system_temp_rov_params_, dxbc::Src::kYYYY),
LoadSystemConstant(
SystemConstants::Index::kEdramDepthBaseDwordsScaled,
offsetof(SystemConstants, edram_depth_base_dwords_scaled),
dxbc::Src::kXXXX));
// ***************************************************************************
// Sample coverage to system_temp_rov_params_.x.
// ***************************************************************************
@ -1113,13 +1280,13 @@ void DxbcShaderTranslator::ROV_DepthStencilTest() {
// 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).
// Go to the next sample (samples are at +0, +(80*scale_x), +1,
// +(80*scale_x+1), so need to do +(80*scale_x), -(80*scale_x-1),
// +(80*scale_x) and -(80*scale_x+1) 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_))));
dxbc::Src::LI((i & 1) ? -80 * draw_resolution_scale_x_ + 2 - i
: 80 * draw_resolution_scale_x_));
}
if (ROV_IsDepthStencilEarly()) {
@ -2005,9 +2172,6 @@ void DxbcShaderTranslator::CompletePixelShader_WriteToROV() {
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()) {
@ -2033,13 +2197,14 @@ void DxbcShaderTranslator::CompletePixelShader_WriteToROV() {
}
// 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).
// Go to the next sample (samples are at +0, +(80*scale_x), +1,
// +(80*scale_x+1), so need to do +(80*scale_x), -(80*scale_x-1),
// +(80*scale_x) and -(80*scale_x+1) 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));
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) ? -80 * draw_resolution_scale_x_ + 2 - i
: 80 * draw_resolution_scale_x_));
}
}
} else {
@ -2843,14 +3008,16 @@ void DxbcShaderTranslator::CompletePixelShader_WriteToROV() {
// 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).
// Go to the next sample (samples are at +0, +(80*scale_x), +1,
// +(80*scale_x+1), so need to do +(80*scale_x), -(80*scale_x-1),
// +(80*scale_x) and -(80*scale_x+1) after each sample).
int32_t next_sample_distance =
((j & 1) ? -78 - j : 80) * int32_t(resolution_scale_square);
(j & 1) ? -80 * draw_resolution_scale_x_ + 2 - j
: 80 * draw_resolution_scale_x_;
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));
dxbc::Src::LI(0, 0, next_sample_distance, next_sample_distance));
}
// Revert adding the EDRAM bases of the render target to

2
src/xenia/gpu/primitive_processor.cc
View File

@ -331,7 +331,7 @@ bool PrimitiveProcessor::Process(ProcessingResult& result_out) {
break;
case xenos::PrimitiveType::kQuadList:
if (convert_quad_lists_to_triangle_lists_) {
host_primitive_type = xenos::PrimitiveType::kQuadList;
host_primitive_type = xenos::PrimitiveType::kTriangleList;
}
break;
default:

33
src/xenia/gpu/primitive_processor.h
View File

@ -509,6 +509,14 @@ class PrimitiveProcessor {
}
};
// Triangle fan test cases:
// - 4D5307E6 - main menu - game logo, developer logo, backgrounds of the menu
// item list (the whole menu and individual items) - no index buffer.
// - 4E4D87E6 - terrain - with an index buffer and primitive reset (note that
// there, vfetch indices are computed in the vertex shader, involving
// floating-point reciprocal, so this case is very sensitive to rounding,
// and incorrect geometry may occur not because of vertex grouping issues,
// but also due to the behavior of the vertex shader).
// Triangle fans as triangle lists.
// Ordered as (v1, v2, v0), (v2, v3, v0) in Direct3D.
// https://docs.microsoft.com/en-us/windows/desktop/direct3d9/triangle-fans
@ -565,6 +573,8 @@ class PrimitiveProcessor {
uint32_t source_index_count,
const PassthroughIndexTransform& index_transform);
// Quad list test cases:
// - 4D5307E6 - main menu - flying dust on the road - no index buffer.
static constexpr uint32_t GetQuadListTriangleListIndexCount(
uint32_t quad_list_index_count) {
return (quad_list_index_count / 4) * 6;
@ -685,6 +695,7 @@ class PrimitiveProcessor {
kCacheBucketSizeBytes;
union CacheKey {
uint64_t key;
struct {
uint32_t base; // 32 total
uint32_t count : 16; // 48
@ -694,19 +705,23 @@ class PrimitiveProcessor {
// kNone if not changing the type (like only processing the reset index).
xenos::PrimitiveType conversion_guest_primitive_type : 6; // 59
};
uint64_t key = 0;
CacheKey() = default;
CacheKey() : key(0) { static_assert_size(*this, sizeof(key)); }
CacheKey(uint32_t base, uint32_t count, xenos::IndexFormat format,
xenos::Endian endian, bool is_reset_enabled,
xenos::PrimitiveType conversion_guest_primitive_type =
xenos::PrimitiveType::kNone)
: base(base),
count(count),
format(format),
endian(endian),
is_reset_enabled(is_reset_enabled),
conversion_guest_primitive_type(conversion_guest_primitive_type) {}
xenos::PrimitiveType::kNone) {
// Clear unused bits, then set each field explicitly, not via the
// initializer list (which causes `uint64_t key = 0;` to be ignored, and
// also can't contain initializers for aliasing union members).
key = 0;
this->base = base;
this->count = count;
this->format = format;
this->endian = endian;
this->is_reset_enabled = is_reset_enabled;
this->conversion_guest_primitive_type = conversion_guest_primitive_type;
}
struct Hasher {
size_t operator()(const CacheKey& key) const {

76
src/xenia/gpu/registers.h
View File

@ -46,6 +46,7 @@ namespace reg {
*******************************************************************************/
union alignas(uint32_t) COHER_STATUS_HOST {
uint32_t value;
struct {
uint32_t matching_contexts : 8; // +0
uint32_t rb_copy_dest_base_ena : 1; // +8
@ -64,12 +65,12 @@ union alignas(uint32_t) COHER_STATUS_HOST {
uint32_t : 4; // +27
uint32_t status : 1; // +31
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_COHER_STATUS_HOST;
};
static_assert_size(COHER_STATUS_HOST, sizeof(uint32_t));
union alignas(uint32_t) WAIT_UNTIL {
uint32_t value;
struct {
uint32_t : 1; // +0
uint32_t wait_re_vsync : 1; // +1
@ -88,7 +89,6 @@ union alignas(uint32_t) WAIT_UNTIL {
uint32_t : 2; // +18
uint32_t cmdfifo_entries : 4; // +20
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_WAIT_UNTIL;
};
static_assert_size(WAIT_UNTIL, sizeof(uint32_t));
@ -102,6 +102,7 @@ static_assert_size(WAIT_UNTIL, sizeof(uint32_t));
*******************************************************************************/
union alignas(uint32_t) SQ_PROGRAM_CNTL {
uint32_t value;
struct {
// Note from a2xx.xml:
// Only 0x3F worth of valid register values for VS_NUM_REG and PS_NUM_REG,
@ -118,12 +119,12 @@ union alignas(uint32_t) SQ_PROGRAM_CNTL {
uint32_t ps_export_mode : 4; // +27
uint32_t gen_index_vtx : 1; // +31
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_SQ_PROGRAM_CNTL;
};
static_assert_size(SQ_PROGRAM_CNTL, sizeof(uint32_t));
union alignas(uint32_t) SQ_CONTEXT_MISC {
uint32_t value;
struct {
uint32_t inst_pred_optimize : 1; // +0
uint32_t sc_output_screen_xy : 1; // +1
@ -150,19 +151,18 @@ union alignas(uint32_t) SQ_CONTEXT_MISC {
uint32_t yeild_optimize : 1; // +17 sic
uint32_t tx_cache_sel : 1; // +18
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_SQ_CONTEXT_MISC;
};
static_assert_size(SQ_CONTEXT_MISC, sizeof(uint32_t));
union alignas(uint32_t) SQ_INTERPOLATOR_CNTL {
uint32_t value;
struct {
uint32_t param_shade : 16; // +0
// SampleLocation bits - 0 for centroid, 1 for center, if
// SQ_CONTEXT_MISC::sc_sample_cntl is kCentroidsAndCenters.
uint32_t sampling_pattern : 16; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_SQ_INTERPOLATOR_CNTL;
};
static_assert_size(SQ_INTERPOLATOR_CNTL, sizeof(uint32_t));
@ -186,16 +186,17 @@ static_assert_size(SQ_INTERPOLATOR_CNTL, sizeof(uint32_t));
*******************************************************************************/
union alignas(uint32_t) VGT_DMA_SIZE {
uint32_t value;
struct {
uint32_t num_words : 24; // +0
uint32_t : 6; // +24
xenos::Endian swap_mode : 2; // +30
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_DMA_SIZE;
};
union alignas(uint32_t) VGT_DRAW_INITIATOR {
uint32_t value;
// Different than on A2xx and R6xx/R7xx.
struct {
xenos::PrimitiveType prim_type : 6; // +0
@ -207,7 +208,6 @@ union alignas(uint32_t) VGT_DRAW_INITIATOR {
uint32_t : 3; // +13
uint32_t num_indices : 16; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_DRAW_INITIATOR;
};
static_assert_size(VGT_DRAW_INITIATOR, sizeof(uint32_t));
@ -223,6 +223,7 @@ static_assert_size(VGT_DRAW_INITIATOR, sizeof(uint32_t));
// clamping.
union alignas(uint32_t) VGT_MULTI_PRIM_IB_RESET_INDX {
uint32_t value;
struct {
// The upper 8 bits of the value from the index buffer are confirmed to be
// ignored. So, though this specifically is untested (because
@ -234,13 +235,13 @@ union alignas(uint32_t) VGT_MULTI_PRIM_IB_RESET_INDX {
// 0x1FFFFFF, 0xFFFFFFFF all cause primitive reset.
uint32_t reset_indx : 24;
};
uint32_t value;
static constexpr Register register_index =
XE_GPU_REG_VGT_MULTI_PRIM_IB_RESET_INDX;
};
static_assert_size(VGT_MULTI_PRIM_IB_RESET_INDX, sizeof(uint32_t));
union alignas(uint32_t) VGT_INDX_OFFSET {
uint32_t value;
struct {
// Unlike R5xx's VAP_INDEX_OFFSET, which is signed 25-bit, this is 24-bit -
// and signedness doesn't matter as index calculations are done in 24-bit
@ -251,44 +252,43 @@ union alignas(uint32_t) VGT_INDX_OFFSET {
// anyway, and that has no effect on offsets that fit in 24 bits.
uint32_t indx_offset : 24;
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_INDX_OFFSET;
};
static_assert_size(VGT_INDX_OFFSET, sizeof(uint32_t));
union alignas(uint32_t) VGT_MIN_VTX_INDX {
uint32_t value;
struct {
uint32_t min_indx : 24;
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_MIN_VTX_INDX;
};
static_assert_size(VGT_MIN_VTX_INDX, sizeof(uint32_t));
union alignas(uint32_t) VGT_MAX_VTX_INDX {
uint32_t value;
struct {
// Usually 0xFFFF or 0xFFFFFF.
uint32_t max_indx : 24;
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_MAX_VTX_INDX;
};
static_assert_size(VGT_MAX_VTX_INDX, sizeof(uint32_t));
union alignas(uint32_t) VGT_OUTPUT_PATH_CNTL {
uint32_t value;
struct {
xenos::VGTOutputPath path_select : 2; // +0
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_OUTPUT_PATH_CNTL;
};
static_assert_size(VGT_OUTPUT_PATH_CNTL, sizeof(uint32_t));
union alignas(uint32_t) VGT_HOS_CNTL {
uint32_t value;
struct {
xenos::TessellationMode tess_mode : 2; // +0
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_VGT_HOS_CNTL;
};
static_assert_size(VGT_HOS_CNTL, sizeof(uint32_t));
@ -307,29 +307,30 @@ static_assert_size(VGT_HOS_CNTL, sizeof(uint32_t));
*******************************************************************************/
union alignas(uint32_t) PA_SU_POINT_MINMAX {
uint32_t value;
struct {
// Radius, 12.4 fixed point.
uint32_t min_size : 16; // +0
uint32_t max_size : 16; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SU_POINT_MINMAX;
};
static_assert_size(PA_SU_POINT_MINMAX, sizeof(uint32_t));
union alignas(uint32_t) PA_SU_POINT_SIZE {
uint32_t value;
struct {
// 1/2 width or height, 12.4 fixed point.
uint32_t height : 16; // +0
uint32_t width : 16; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SU_POINT_SIZE;
};
static_assert_size(PA_SU_POINT_SIZE, sizeof(uint32_t));
// Setup Unit / Scanline Converter mode cntl
union alignas(uint32_t) PA_SU_SC_MODE_CNTL {
uint32_t value;
struct {
uint32_t cull_front : 1; // +0
uint32_t cull_back : 1; // +1
@ -359,36 +360,36 @@ union alignas(uint32_t) PA_SU_SC_MODE_CNTL {
// WAIT_RB_IDLE_ALL_TRI and WAIT_RB_IDLE_FIRST_TRI_NEW_STATE were added on
// Adreno.
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SU_SC_MODE_CNTL;
};
static_assert_size(PA_SU_SC_MODE_CNTL, sizeof(uint32_t));
// Setup Unit Vertex Control
union alignas(uint32_t) PA_SU_VTX_CNTL {
uint32_t value;
struct {
uint32_t pix_center : 1; // +0 1 = half pixel offset (OpenGL).
uint32_t round_mode : 2; // +1
uint32_t quant_mode : 3; // +3
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SU_VTX_CNTL;
};
static_assert_size(PA_SU_VTX_CNTL, sizeof(uint32_t));
union alignas(uint32_t) PA_SC_MPASS_PS_CNTL {
uint32_t value;
struct {
uint32_t mpass_pix_vec_per_pass : 20; // +0
uint32_t : 11; // +20
uint32_t mpass_ps_ena : 1; // +31
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_MPASS_PS_CNTL;
};
static_assert_size(PA_SC_MPASS_PS_CNTL, sizeof(uint32_t));
// Scanline converter viz query, used by D3D for gpu side conditional rendering
union alignas(uint32_t) PA_SC_VIZ_QUERY {
uint32_t value;
struct {
// the visibility of draws should be evaluated
uint32_t viz_query_ena : 1; // +0
@ -398,13 +399,13 @@ union alignas(uint32_t) PA_SC_VIZ_QUERY {
// not used with d3d
uint32_t kill_pix_post_detail_mask : 1; // +8
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_VIZ_QUERY;
};
static_assert_size(PA_SC_VIZ_QUERY, sizeof(uint32_t));
// Clipper clip control
union alignas(uint32_t) PA_CL_CLIP_CNTL {
uint32_t value;
struct {
uint32_t ucp_ena_0 : 1; // +0
uint32_t ucp_ena_1 : 1; // +1
@ -424,13 +425,13 @@ union alignas(uint32_t) PA_CL_CLIP_CNTL {
uint32_t z_nan_retain : 1; // +23
uint32_t w_nan_retain : 1; // +24
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_CL_CLIP_CNTL;
};
static_assert_size(PA_CL_CLIP_CNTL, sizeof(uint32_t));
// Viewport transform engine control
union alignas(uint32_t) PA_CL_VTE_CNTL {
uint32_t value;
struct {
uint32_t vport_x_scale_ena : 1; // +0
uint32_t vport_x_offset_ena : 1; // +1
@ -444,45 +445,45 @@ union alignas(uint32_t) PA_CL_VTE_CNTL {
uint32_t vtx_w0_fmt : 1; // +10
uint32_t perfcounter_ref : 1; // +11
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_CL_VTE_CNTL;
};
static_assert_size(PA_CL_VTE_CNTL, sizeof(uint32_t));
union alignas(uint32_t) PA_SC_SCREEN_SCISSOR_TL {
uint32_t value;
struct {
int32_t tl_x : 15; // +0
uint32_t : 1; // +15
int32_t tl_y : 15; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_SCREEN_SCISSOR_TL;
};
static_assert_size(PA_SC_SCREEN_SCISSOR_TL, sizeof(uint32_t));
union alignas(uint32_t) PA_SC_SCREEN_SCISSOR_BR {
uint32_t value;
struct {
int32_t br_x : 15; // +0
uint32_t : 1; // +15
int32_t br_y : 15; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_SCREEN_SCISSOR_BR;
};
static_assert_size(PA_SC_SCREEN_SCISSOR_BR, sizeof(uint32_t));
union alignas(uint32_t) PA_SC_WINDOW_OFFSET {
uint32_t value;
struct {
int32_t window_x_offset : 15; // +0
uint32_t : 1; // +15
int32_t window_y_offset : 15; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_WINDOW_OFFSET;
};
static_assert_size(PA_SC_WINDOW_OFFSET, sizeof(uint32_t));
union alignas(uint32_t) PA_SC_WINDOW_SCISSOR_TL {
uint32_t value;
struct {
uint32_t tl_x : 14; // +0
uint32_t : 2; // +14
@ -490,18 +491,17 @@ union alignas(uint32_t) PA_SC_WINDOW_SCISSOR_TL {
uint32_t : 1; // +30
uint32_t window_offset_disable : 1; // +31
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_WINDOW_SCISSOR_TL;
};
static_assert_size(PA_SC_WINDOW_SCISSOR_TL, sizeof(uint32_t));
union alignas(uint32_t) PA_SC_WINDOW_SCISSOR_BR {
uint32_t value;
struct {
uint32_t br_x : 14; // +0
uint32_t : 2; // +14
uint32_t br_y : 14; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_PA_SC_WINDOW_SCISSOR_BR;
};
static_assert_size(PA_SC_WINDOW_SCISSOR_BR, sizeof(uint32_t));
@ -520,27 +520,28 @@ static_assert_size(PA_SC_WINDOW_SCISSOR_BR, sizeof(uint32_t));
*******************************************************************************/
union alignas(uint32_t) RB_MODECONTROL {
uint32_t value;
struct {
xenos::ModeControl edram_mode : 3; // +0
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_MODECONTROL;
};
static_assert_size(RB_MODECONTROL, sizeof(uint32_t));
union alignas(uint32_t) RB_SURFACE_INFO {
uint32_t value;
struct {
uint32_t surface_pitch : 14; // +0 in pixels.
uint32_t : 2; // +14
xenos::MsaaSamples msaa_samples : 2; // +16
uint32_t hiz_pitch : 14; // +18
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_SURFACE_INFO;
};
static_assert_size(RB_SURFACE_INFO, sizeof(uint32_t));
union alignas(uint32_t) RB_COLORCONTROL {
uint32_t value;
struct {
xenos::CompareFunction alpha_func : 3; // +0
uint32_t alpha_test_enable : 1; // +3
@ -585,19 +586,18 @@ union alignas(uint32_t) RB_COLORCONTROL {
uint32_t alpha_to_mask_offset2 : 2; // +28
uint32_t alpha_to_mask_offset3 : 2; // +30
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_COLORCONTROL;
};
static_assert_size(RB_COLORCONTROL, sizeof(uint32_t));
union alignas(uint32_t) RB_COLOR_INFO {
uint32_t value;
struct {
uint32_t color_base : 12; // +0 in tiles.
uint32_t : 4; // +12
xenos::ColorRenderTargetFormat color_format : 4; // +16
int32_t color_exp_bias : 6; // +20
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_COLOR_INFO;
// RB_COLOR[1-3]_INFO also use this format.
static const Register rt_register_indices[4];
@ -605,6 +605,7 @@ union alignas(uint32_t) RB_COLOR_INFO {
static_assert_size(RB_COLOR_INFO, sizeof(uint32_t));
union alignas(uint32_t) RB_COLOR_MASK {
uint32_t value;
struct {
uint32_t write_red0 : 1; // +0
uint32_t write_green0 : 1; // +1
@ -623,12 +624,12 @@ union alignas(uint32_t) RB_COLOR_MASK {
uint32_t write_blue3 : 1; // +14
uint32_t write_alpha3 : 1; // +15
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_COLOR_MASK;
};
static_assert_size(RB_COLOR_MASK, sizeof(uint32_t));
union alignas(uint32_t) RB_BLENDCONTROL {
uint32_t value;
struct {
xenos::BlendFactor color_srcblend : 5; // +0
xenos::BlendOp color_comb_fcn : 3; // +5
@ -639,7 +640,6 @@ union alignas(uint32_t) RB_BLENDCONTROL {
xenos::BlendFactor alpha_destblend : 5; // +24
// BLEND_FORCE_ENABLE and BLEND_FORCE were added on Adreno.
};
uint32_t value;
// RB_BLENDCONTROL[0-3] use this format.
static constexpr Register register_index = XE_GPU_REG_RB_BLENDCONTROL0;
static const Register rt_register_indices[4];
@ -647,6 +647,7 @@ union alignas(uint32_t) RB_BLENDCONTROL {
static_assert_size(RB_BLENDCONTROL, sizeof(uint32_t));
union alignas(uint32_t) RB_DEPTHCONTROL {
uint32_t value;
struct {
uint32_t stencil_enable : 1; // +0
uint32_t z_enable : 1; // +1
@ -664,30 +665,29 @@ union alignas(uint32_t) RB_DEPTHCONTROL {
xenos::StencilOp stencilzpass_bf : 3; // +26
xenos::StencilOp stencilzfail_bf : 3; // +29
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_DEPTHCONTROL;
};
static_assert_size(RB_DEPTHCONTROL, sizeof(uint32_t));
union alignas(uint32_t) RB_STENCILREFMASK {
uint32_t value;
struct {
uint32_t stencilref : 8; // +0
uint32_t stencilmask : 8; // +8
uint32_t stencilwritemask : 8; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_STENCILREFMASK;
// RB_STENCILREFMASK_BF also uses this format.
};
static_assert_size(RB_STENCILREFMASK, sizeof(uint32_t));
union alignas(uint32_t) RB_DEPTH_INFO {
uint32_t value;
struct {
uint32_t depth_base : 12; // +0 in tiles.
uint32_t : 4; // +12
xenos::DepthRenderTargetFormat depth_format : 1; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_DEPTH_INFO;
};
static_assert_size(RB_DEPTH_INFO, sizeof(uint32_t));
@ -695,6 +695,7 @@ static_assert_size(RB_DEPTH_INFO, sizeof(uint32_t));
// Copy registers are very different than on Adreno.
union alignas(uint32_t) RB_COPY_CONTROL {
uint32_t value;
struct {
uint32_t copy_src_select : 3; // +0 Depth is 4.
uint32_t : 1; // +3
@ -705,12 +706,12 @@ union alignas(uint32_t) RB_COPY_CONTROL {
uint32_t : 10; // +10
xenos::CopyCommand copy_command : 2; // +20
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_COPY_CONTROL;
};
static_assert_size(RB_COPY_CONTROL, sizeof(uint32_t));
union alignas(uint32_t) RB_COPY_DEST_INFO {
uint32_t value;
struct {
xenos::Endian128 copy_dest_endian : 3; // +0
uint32_t copy_dest_array : 1; // +3
@ -721,18 +722,17 @@ union alignas(uint32_t) RB_COPY_DEST_INFO {
uint32_t : 2; // +22
uint32_t copy_dest_swap : 1; // +24
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_COPY_DEST_INFO;
};
static_assert_size(RB_COPY_DEST_INFO, sizeof(uint32_t));
union alignas(uint32_t) RB_COPY_DEST_PITCH {
uint32_t value;
struct {
uint32_t copy_dest_pitch : 14; // +0
uint32_t : 2; // +14
uint32_t copy_dest_height : 14; // +16
};
uint32_t value;
static constexpr Register register_index = XE_GPU_REG_RB_COPY_DEST_PITCH;
};
static_assert_size(RB_COPY_DEST_PITCH, sizeof(uint32_t));

29
src/xenia/gpu/render_target_cache.cc
View File

@ -78,9 +78,9 @@ DEFINE_string(
" Choose what is considered the most optimal (currently \"on_copy\").",
"GPU");
DEFINE_int32(
draw_resolution_scale, 1,
"Integer pixel width and height scale used for scaling the rendering "
"resolution opaquely to the game.\n"
draw_resolution_scale_x, 1,
"Integer pixel width scale used for scaling the rendering resolution "
"opaquely to the game.\n"
"1, 2 and 3 may be supported, but support of anything above 1 depends on "
"the device properties, such as whether it supports sparse binding / tiled "
"resources, the number of virtual address bits per resource, and other "
@ -90,6 +90,12 @@ DEFINE_int32(
"because half-pixel offset (which normally doesn't affect coverage when "
"MSAA isn't used) becomes full-pixel.",
"GPU");
DEFINE_int32(
draw_resolution_scale_y, 1,
"Integer pixel width scale used for scaling the rendering resolution "
"opaquely to the game.\n"
"See draw_resolution_scale_x for more information.",
"GPU");
DEFINE_bool(
draw_resolution_scaled_texture_offsets, true,
"Apply offsets from texture fetch instructions taking resolution scale "
@ -396,7 +402,7 @@ bool RenderTargetCache::Update(bool is_rasterization_done,
uint32_t pitch_pixels_tile_aligned_scaled =
pitch_tiles_at_32bpp *
(xenos::kEdramTileWidthSamples >> msaa_samples_x_log2) *
GetResolutionScale();
GetResolutionScaleX();
uint32_t max_render_target_width = GetMaxRenderTargetWidth();
if (pitch_pixels_tile_aligned_scaled > max_render_target_width) {
// TODO(Triang3l): If really needed for some game on some device, clamp
@ -855,14 +861,14 @@ uint32_t RenderTargetCache::GetRenderTargetHeight(
!(xenos::kTexture2DCubeMaxWidthHeight % xenos::kEdramTileHeightSamples),
"Maximum guest render target height is assumed to always be a multiple "
"of an EDRAM tile height");
uint32_t resolution_scale = GetResolutionScale();
uint32_t resolution_scale_y = GetResolutionScaleY();
uint32_t max_height_scaled =
std::min(xenos::kTexture2DCubeMaxWidthHeight * resolution_scale,
std::min(xenos::kTexture2DCubeMaxWidthHeight * resolution_scale_y,
GetMaxRenderTargetHeight());
uint32_t msaa_samples_y_log2 =
uint32_t(msaa_samples >= xenos::MsaaSamples::k2X);
uint32_t tile_height_samples_scaled =
xenos::kEdramTileHeightSamples * resolution_scale;
xenos::kEdramTileHeightSamples * resolution_scale_y;
tile_rows = std::min(tile_rows, (max_height_scaled << msaa_samples_y_log2) /
tile_height_samples_scaled);
assert_not_zero(tile_rows);
@ -993,7 +999,7 @@ bool RenderTargetCache::PrepareHostRenderTargetsResolveClear(
uint32_t pitch_pixels =
pitch_tiles_at_32bpp *
(xenos::kEdramTileWidthSamples >> msaa_samples_x_log2);
uint32_t pitch_pixels_scaled = pitch_pixels * GetResolutionScale();
uint32_t pitch_pixels_scaled = pitch_pixels * GetResolutionScaleX();
uint32_t max_render_target_width = GetMaxRenderTargetWidth();
if (pitch_pixels_scaled > max_render_target_width) {
// TODO(Triang3l): If really needed for some game on some device, clamp the
@ -1139,11 +1145,12 @@ RenderTargetCache::RenderTarget*
RenderTargetCache::PrepareFullEdram1280xRenderTargetForSnapshotRestoration(
xenos::ColorRenderTargetFormat color_format) {
assert_true(GetPath() == Path::kHostRenderTargets);
uint32_t resolution_scale = GetResolutionScale();
uint32_t resolution_scale_x = GetResolutionScaleX();
uint32_t resolution_scale_y = GetResolutionScaleY();
constexpr uint32_t kPitchTilesAt32bpp = 16;
constexpr uint32_t kWidth =
kPitchTilesAt32bpp * xenos::kEdramTileWidthSamples;
if (kWidth * resolution_scale > GetMaxRenderTargetWidth()) {
if (kWidth * resolution_scale_x > GetMaxRenderTargetWidth()) {
return nullptr;
}
// Same render target height is used for 32bpp and 64bpp to allow mixing them.
@ -1159,7 +1166,7 @@ RenderTargetCache::PrepareFullEdram1280xRenderTargetForSnapshotRestoration(
"Using width of the render target for EDRAM snapshot restoration that is "
"expect to fully cover the EDRAM without exceeding the maximum guest "
"render target height.");
if (kHeight * resolution_scale > GetMaxRenderTargetHeight()) {
if (kHeight * resolution_scale_y > GetMaxRenderTargetHeight()) {
return nullptr;
}
RenderTargetKey render_target_key;

47
src/xenia/gpu/render_target_cache.h
View File

@ -26,7 +26,8 @@
#include "xenia/gpu/xenos.h"
DECLARE_bool(depth_transfer_not_equal_test);
DECLARE_int32(draw_resolution_scale);
DECLARE_int32(draw_resolution_scale_x);
DECLARE_int32(draw_resolution_scale_y);
DECLARE_bool(draw_resolution_scaled_texture_offsets);
DECLARE_bool(gamma_render_target_as_srgb);
DECLARE_bool(native_2x_msaa);
@ -167,7 +168,44 @@ class RenderTargetCache {
virtual Path GetPath() const = 0;
virtual uint32_t GetResolutionScale() const = 0;
// Resolution scaling on the EDRAM side is performed by multiplying the EDRAM
// tile size by the resolution scale.
// Note: Only integer scaling factors are provided because fractional ones,
// even with 0.5 granularity, cause significant issues in addition to the ones
// already present with integer scaling. 1.5 (from 1280x720 to 1920x1080) may
// be useful, but it would cause pixel coverage issues with odd dimensions of
// screen-space geometry, most importantly 1x1 that is often the final step in
// reduction algorithms such as average luminance computation in HDR. A
// single-pixel quad, either 0...1 without half-pixel offset or 0.5...1.5 with
// it (covers only the first pixel according the top-left rule), with 1.5x
// resolution scaling, would become 0...1.5 (only the first pixel covered) or
// 0.75...2.25 (only the second). The workaround used in Xenia for 2x and 3x
// resolution scaling for filling the gap caused by the half-pixel offset
// becoming whole-pixel - stretching the second column / row of pixels into
// the first - will not work in this case, as for one-pixel primitives without
// half-pixel offset (covering only the first pixel, but not the second, with
// 1.5x), it will actually cause the pixel to be erased with 1.5x scaling. As
// within one pass there can be geometry both with and without the half-pixel
// offset (not only depending on PA_SU_VTX_CNTL::PIX_CENTER, but also with the
// half-pixel offset possibly reverted manually), the emulator can't decide
// whether the stretching workaround actually needs to be used. So, with 1.5x,
// depending on how the game draws its screen-space effects and on whether the
// workaround is used, in some cases, nothing will just be drawn to the first
// pixel, while in other cases, the effect will be drawn to it, but the
// stretching workaround will replace it with the undefined value in the
// second pixel. Also, with 1.5x, rounding of integer coordinates becomes
// complicated, also in part due to the half-pixel offset. Odd texture sizes
// would need to be rounded down, as according to the top-left rule, a 1.5x1.5
// quad at the 0 or 0.75 origin (after the scaling) will cover only 1 pixel -
// so, if the resulting texture was 2x2 rather than 1x1, undefined pixels
// would participate in filtering. However, 1x1 scissor rounded to 1x1, with
// the half-pixel offset of vertices, would cause the entire 0.75...2.25 quad
// to be discarded.
virtual uint32_t GetResolutionScaleX() const = 0;
virtual uint32_t GetResolutionScaleY() const = 0;
bool IsResolutionScaled() const {
return GetResolutionScaleX() > 1 || GetResolutionScaleY() > 1;
}
// Virtual (both the common code and the implementation may do something
// here), don't call from destructors (does work not needed for shutdown
@ -217,6 +255,7 @@ class RenderTargetCache {
// rest of the EDRAM is transferred.
union RenderTargetKey {
uint32_t key;
struct {
// [0, 2047].
uint32_t base_tiles : xenos::kEdramBaseTilesBits - 1; // 11
@ -228,7 +267,9 @@ class RenderTargetCache {
// Ignoring the blending precision and sRGB.
uint32_t resource_format : xenos::kRenderTargetFormatBits; // 26
};
uint32_t key = 0;
RenderTargetKey() : key(0) { static_assert_size(*this, sizeof(key)); }
struct Hasher {
size_t operator()(const RenderTargetKey& render_target_key) const {
return std::hash<uint32_t>{}(render_target_key.key);

417
src/xenia/gpu/shaders/bytecode/d3d12_5_1/continuous_quad_hs.h generated
View File

@ -28,11 +28,11 @@
// uint xe_textures_resolved; // Offset: 224 Size: 4 [unused]
// float xe_alpha_test_reference; // Offset: 228 Size: 4 [unused]
// uint xe_alpha_to_mask; // Offset: 232 Size: 4 [unused]
// uint xe_edram_pitch_tiles; // Offset: 236 Size: 4 [unused]
// uint xe_edram_32bpp_tile_pitch_dwords_scaled;// Offset: 236 Size: 4 [unused]
// float4 xe_color_exp_bias; // Offset: 240 Size: 16 [unused]
// float2 xe_edram_poly_offset_front; // Offset: 256 Size: 8 [unused]
// float2 xe_edram_poly_offset_back; // Offset: 264 Size: 8 [unused]
// uint xe_edram_depth_base_dwords; // Offset: 272 Size: 4 [unused]
// uint xe_edram_depth_base_dwords_scaled;// Offset: 272 Size: 4 [unused]
// uint4 xe_edram_stencil[2]; // Offset: 288 Size: 32 [unused]
// uint4 xe_edram_rt_base_dwords_scaled;// Offset: 320 Size: 16 [unused]
// uint4 xe_edram_rt_format_flags; // Offset: 336 Size: 16 [unused]
@ -121,21 +121,21 @@ ret
const BYTE continuous_quad_hs[] =
{
68, 88, 66, 67, 235, 115,
46, 207, 211, 220, 116, 112,
161, 205, 93, 240, 127, 133,
74, 91, 1, 0, 0, 0,
220, 13, 0, 0, 6, 0,
68, 88, 66, 67, 109, 174,
137, 67, 82, 213, 246, 48,
97, 232, 232, 104, 109, 96,
97, 35, 1, 0, 0, 0,
240, 13, 0, 0, 6, 0,
0, 0, 56, 0, 0, 0,
168, 10, 0, 0, 220, 10,
0, 0, 16, 11, 0, 0,
212, 11, 0, 0, 64, 13,
188, 10, 0, 0, 240, 10,
0, 0, 36, 11, 0, 0,
232, 11, 0, 0, 84, 13,
0, 0, 82, 68, 69, 70,
104, 10, 0, 0, 1, 0,
124, 10, 0, 0, 1, 0,
0, 0, 120, 0, 0, 0,
1, 0, 0, 0, 60, 0,
0, 0, 1, 5, 83, 72,
0, 5, 4, 0, 62, 10,
0, 5, 4, 0, 82, 10,
0, 0, 19, 19, 68, 37,
60, 0, 0, 0, 24, 0,
0, 0, 40, 0, 0, 0,
@ -295,77 +295,77 @@ const BYTE continuous_quad_hs[] =
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 119, 8,
0, 0, 0, 0, 138, 8,
0, 0, 240, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 140, 8, 0, 0,
0, 0, 156, 8, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 176, 8, 0, 0,
0, 0, 192, 8, 0, 0,
0, 1, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
232, 5, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
203, 8, 0, 0, 8, 1,
219, 8, 0, 0, 8, 1,
0, 0, 8, 0, 0, 0,
0, 0, 0, 0, 232, 5,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 229, 8,
0, 0, 0, 0, 245, 8,
0, 0, 16, 1, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 160, 5, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 0, 9, 0, 0,
0, 0, 23, 9, 0, 0,
32, 1, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
20, 9, 0, 0, 0, 0,
40, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
56, 9, 0, 0, 64, 1,
76, 9, 0, 0, 64, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 124, 9,
0, 0, 0, 0, 144, 9,
0, 0, 80, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 149, 9, 0, 0,
0, 0, 169, 9, 0, 0,
96, 1, 0, 0, 64, 0,
0, 0, 0, 0, 0, 0,
168, 9, 0, 0, 0, 0,
188, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
204, 9, 0, 0, 160, 1,
224, 9, 0, 0, 160, 1,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 228, 9,
0, 0, 0, 0, 248, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 8, 10,
0, 0, 0, 0, 28, 10,
0, 0, 192, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 38, 10, 0, 0,
0, 0, 58, 10, 0, 0,
208, 1, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
140, 8, 0, 0, 0, 0,
156, 8, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
@ -490,35 +490,73 @@ const BYTE continuous_quad_hs[] =
97, 108, 112, 104, 97, 95,
116, 111, 95, 109, 97, 115,
107, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
105, 116, 99, 104, 95, 116,
105, 108, 101, 115, 0, 120,
101, 95, 99, 111, 108, 111,
114, 95, 101, 120, 112, 95,
98, 105, 97, 115, 0, 171,
171, 171, 1, 0, 3, 0,
1, 0, 4, 0, 0, 0,
100, 114, 97, 109, 95, 51,
50, 98, 112, 112, 95, 116,
105, 108, 101, 95, 112, 105,
116, 99, 104, 95, 100, 119,
111, 114, 100, 115, 95, 115,
99, 97, 108, 101, 100, 0,
120, 101, 95, 99, 111, 108,
111, 114, 95, 101, 120, 112,
95, 98, 105, 97, 115, 0,
1, 0, 3, 0, 1, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
111, 108, 121, 95, 111, 102,
102, 115, 101, 116, 95, 102,
114, 111, 110, 116, 0, 120,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 112, 111, 108,
121, 95, 111, 102, 102, 115,
101, 116, 95, 102, 114, 111,
110, 116, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
112, 111, 108, 121, 95, 111,
102, 102, 115, 101, 116, 95,
98, 97, 99, 107, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 112, 111, 108, 121,
95, 111, 102, 102, 115, 101,
116, 95, 98, 97, 99, 107,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 100, 101,
112, 116, 104, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 0, 120, 101,
109, 95, 100, 101, 112, 116,
104, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
115, 116, 101, 110, 99, 105,
108, 0, 1, 0, 19, 0,
1, 0, 4, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 171, 1, 0,
19, 0, 1, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 115, 116, 101, 110, 99,
105, 108, 0, 171, 171, 171,
95, 114, 116, 95, 102, 111,
114, 109, 97, 116, 95, 102,
108, 97, 103, 115, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 114, 116, 95, 99,
108, 97, 109, 112, 0, 171,
1, 0, 3, 0, 1, 0,
4, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
107, 101, 101, 112, 95, 109,
97, 115, 107, 0, 171, 171,
1, 0, 19, 0, 1, 0,
4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -527,190 +565,155 @@ const BYTE continuous_quad_hs[] =
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
98, 97, 115, 101, 95, 100,
119, 111, 114, 100, 115, 95,
115, 99, 97, 108, 101, 100,
0, 171, 1, 0, 19, 0,
1, 0, 4, 0, 0, 0,
98, 108, 101, 110, 100, 95,
102, 97, 99, 116, 111, 114,
115, 95, 111, 112, 115, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 98, 108, 101,
110, 100, 95, 99, 111, 110,
115, 116, 97, 110, 116, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 171, 171,
73, 83, 71, 78, 44, 0,
0, 0, 1, 0, 0, 0,
8, 0, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 102, 111, 114, 109,
97, 116, 95, 102, 108, 97,
103, 115, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
114, 116, 95, 99, 108, 97,
109, 112, 0, 171, 1, 0,
3, 0, 1, 0, 4, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
172, 6, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 107, 101,
101, 112, 95, 109, 97, 115,
107, 0, 171, 171, 1, 0,
19, 0, 1, 0, 4, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 98, 108,
101, 110, 100, 95, 102, 97,
99, 116, 111, 114, 115, 95,
111, 112, 115, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 98, 108, 101, 110, 100,
95, 99, 111, 110, 115, 116,
97, 110, 116, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 171, 171, 73, 83,
1, 1, 0, 0, 88, 69,
86, 69, 82, 84, 69, 88,
73, 68, 0, 171, 79, 83,
71, 78, 44, 0, 0, 0,
1, 0, 0, 0, 8, 0,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 1,
0, 0, 0, 0, 1, 14,
0, 0, 88, 69, 86, 69,
82, 84, 69, 88, 73, 68,
0, 171, 79, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 171, 80, 67, 83, 71,
188, 0, 0, 0, 6, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
152, 0, 0, 0, 0, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 1, 14, 0, 0,
88, 69, 86, 69, 82, 84,
69, 88, 73, 68, 0, 171,
80, 67, 83, 71, 188, 0,
0, 0, 6, 0, 0, 0,
8, 0, 0, 0, 152, 0,
0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 14, 0, 0, 152, 0,
0, 0, 1, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
1, 14, 0, 0, 152, 0,
0, 0, 2, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 2, 0, 0, 0,
1, 14, 0, 0, 152, 0,
0, 0, 3, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
1, 14, 0, 0, 166, 0,
0, 0, 0, 0, 0, 0,
12, 0, 0, 0, 3, 0,
0, 0, 4, 0, 0, 0,
1, 14, 0, 0, 166, 0,
0, 0, 1, 0, 0, 0,
12, 0, 0, 0, 3, 0,
0, 0, 5, 0, 0, 0,
1, 14, 0, 0, 83, 86,
95, 84, 101, 115, 115, 70,
97, 99, 116, 111, 114, 0,
83, 86, 95, 73, 110, 115,
105, 100, 101, 84, 101, 115,
152, 0, 0, 0, 1, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 1, 0,
0, 0, 1, 14, 0, 0,
152, 0, 0, 0, 2, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 2, 0,
0, 0, 1, 14, 0, 0,
152, 0, 0, 0, 3, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 1, 14, 0, 0,
166, 0, 0, 0, 0, 0,
0, 0, 12, 0, 0, 0,
3, 0, 0, 0, 4, 0,
0, 0, 1, 14, 0, 0,
166, 0, 0, 0, 1, 0,
0, 0, 12, 0, 0, 0,
3, 0, 0, 0, 5, 0,
0, 0, 1, 14, 0, 0,
83, 86, 95, 84, 101, 115,
115, 70, 97, 99, 116, 111,
114, 0, 171, 171, 83, 72,
69, 88, 100, 1, 0, 0,
81, 0, 3, 0, 89, 0,
0, 0, 113, 0, 0, 1,
147, 32, 0, 1, 148, 32,
0, 1, 149, 24, 0, 1,
150, 32, 0, 1, 151, 24,
0, 1, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
114, 0, 83, 86, 95, 73,
110, 115, 105, 100, 101, 84,
101, 115, 115, 70, 97, 99,
116, 111, 114, 0, 171, 171,
83, 72, 69, 88, 100, 1,
0, 0, 81, 0, 3, 0,
89, 0, 0, 0, 113, 0,
0, 1, 147, 32, 0, 1,
148, 32, 0, 1, 149, 24,
0, 1, 150, 32, 0, 1,
151, 24, 0, 1, 106, 8,
0, 1, 89, 0, 0, 7,
70, 142, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 115, 0,
0, 1, 153, 0, 0, 2,
4, 0, 0, 0, 95, 0,
0, 2, 0, 112, 1, 0,
103, 0, 0, 4, 18, 32,
16, 0, 0, 0, 0, 0,
11, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
1, 0, 0, 0, 12, 0,
0, 0, 103, 0, 0, 4,
18, 32, 16, 0, 2, 0,
0, 0, 13, 0, 0, 0,
103, 0, 0, 4, 18, 32,
16, 0, 3, 0, 0, 0,
14, 0, 0, 0, 104, 0,
0, 2, 1, 0, 0, 0,
91, 0, 0, 4, 18, 32,
16, 0, 0, 0, 0, 0,
4, 0, 0, 0, 54, 0,
0, 4, 18, 0, 16, 0,
0, 0, 0, 0, 10, 112,
1, 0, 54, 0, 0, 8,
18, 32, 144, 0, 10, 0,
16, 0, 0, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 115, 0, 0, 1,
153, 0, 0, 2, 2, 0,
0, 0, 95, 0, 0, 2,
0, 112, 1, 0, 103, 0,
115, 0, 0, 1, 153, 0,
0, 2, 4, 0, 0, 0,
95, 0, 0, 2, 0, 112,
1, 0, 103, 0, 0, 4,
18, 32, 16, 0, 0, 0,
0, 0, 11, 0, 0, 0,
103, 0, 0, 4, 18, 32,
16, 0, 1, 0, 0, 0,
12, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
4, 0, 0, 0, 15, 0,
2, 0, 0, 0, 13, 0,
0, 0, 103, 0, 0, 4,
18, 32, 16, 0, 5, 0,
0, 0, 16, 0, 0, 0,
18, 32, 16, 0, 3, 0,
0, 0, 14, 0, 0, 0,
104, 0, 0, 2, 1, 0,
0, 0, 91, 0, 0, 4,
18, 32, 16, 0, 4, 0,
0, 0, 2, 0, 0, 0,
18, 32, 16, 0, 0, 0,
0, 0, 4, 0, 0, 0,
54, 0, 0, 4, 18, 0,
16, 0, 0, 0, 0, 0,
10, 112, 1, 0, 54, 0,
0, 9, 18, 32, 208, 0,
4, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 6, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 5, 0,
0, 8, 18, 32, 144, 0,
10, 0, 16, 0, 0, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
62, 0, 0, 1, 115, 0,
0, 1, 153, 0, 0, 2,
2, 0, 0, 0, 95, 0,
0, 2, 0, 112, 1, 0,
103, 0, 0, 4, 18, 32,
16, 0, 4, 0, 0, 0,
15, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
5, 0, 0, 0, 16, 0,
0, 0, 104, 0, 0, 2,
1, 0, 0, 0, 91, 0,
0, 4, 18, 32, 16, 0,
4, 0, 0, 0, 2, 0,
0, 0, 54, 0, 0, 4,
18, 0, 16, 0, 0, 0,
0, 0, 10, 112, 1, 0,
54, 0, 0, 9, 18, 32,
208, 0, 4, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
6, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
5, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 11, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
4, 0, 0, 0, 3, 0,
0, 0, 4, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0
0, 0, 0, 0
};

375
src/xenia/gpu/shaders/bytecode/d3d12_5_1/continuous_triangle_hs.h generated
View File

@ -28,11 +28,11 @@
// uint xe_textures_resolved; // Offset: 224 Size: 4 [unused]
// float xe_alpha_test_reference; // Offset: 228 Size: 4 [unused]
// uint xe_alpha_to_mask; // Offset: 232 Size: 4 [unused]
// uint xe_edram_pitch_tiles; // Offset: 236 Size: 4 [unused]
// uint xe_edram_32bpp_tile_pitch_dwords_scaled;// Offset: 236 Size: 4 [unused]
// float4 xe_color_exp_bias; // Offset: 240 Size: 16 [unused]
// float2 xe_edram_poly_offset_front; // Offset: 256 Size: 8 [unused]
// float2 xe_edram_poly_offset_back; // Offset: 264 Size: 8 [unused]
// uint xe_edram_depth_base_dwords; // Offset: 272 Size: 4 [unused]
// uint xe_edram_depth_base_dwords_scaled;// Offset: 272 Size: 4 [unused]
// uint4 xe_edram_stencil[2]; // Offset: 288 Size: 32 [unused]
// uint4 xe_edram_rt_base_dwords_scaled;// Offset: 320 Size: 16 [unused]
// uint4 xe_edram_rt_format_flags; // Offset: 336 Size: 16 [unused]
@ -112,21 +112,21 @@ ret
const BYTE continuous_triangle_hs[] =
{
68, 88, 66, 67, 101, 66,
223, 231, 73, 98, 52, 221,
50, 47, 236, 69, 147, 250,
231, 1, 1, 0, 0, 0,
76, 13, 0, 0, 6, 0,
68, 88, 66, 67, 150, 55,
56, 98, 126, 111, 114, 179,
197, 7, 10, 15, 70, 32,
249, 93, 1, 0, 0, 0,
96, 13, 0, 0, 6, 0,
0, 0, 56, 0, 0, 0,
168, 10, 0, 0, 220, 10,
0, 0, 16, 11, 0, 0,
164, 11, 0, 0, 176, 12,
188, 10, 0, 0, 240, 10,
0, 0, 36, 11, 0, 0,
184, 11, 0, 0, 196, 12,
0, 0, 82, 68, 69, 70,
104, 10, 0, 0, 1, 0,
124, 10, 0, 0, 1, 0,
0, 0, 120, 0, 0, 0,
1, 0, 0, 0, 60, 0,
0, 0, 1, 5, 83, 72,
0, 5, 4, 0, 62, 10,
0, 5, 4, 0, 82, 10,
0, 0, 19, 19, 68, 37,
60, 0, 0, 0, 24, 0,
0, 0, 40, 0, 0, 0,
@ -286,77 +286,77 @@ const BYTE continuous_triangle_hs[] =
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 119, 8,
0, 0, 0, 0, 138, 8,
0, 0, 240, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 140, 8, 0, 0,
0, 0, 156, 8, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 176, 8, 0, 0,
0, 0, 192, 8, 0, 0,
0, 1, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
232, 5, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
203, 8, 0, 0, 8, 1,
219, 8, 0, 0, 8, 1,
0, 0, 8, 0, 0, 0,
0, 0, 0, 0, 232, 5,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 229, 8,
0, 0, 0, 0, 245, 8,
0, 0, 16, 1, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 160, 5, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 0, 9, 0, 0,
0, 0, 23, 9, 0, 0,
32, 1, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
20, 9, 0, 0, 0, 0,
40, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
56, 9, 0, 0, 64, 1,
76, 9, 0, 0, 64, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 124, 9,
0, 0, 0, 0, 144, 9,
0, 0, 80, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 149, 9, 0, 0,
0, 0, 169, 9, 0, 0,
96, 1, 0, 0, 64, 0,
0, 0, 0, 0, 0, 0,
168, 9, 0, 0, 0, 0,
188, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
204, 9, 0, 0, 160, 1,
224, 9, 0, 0, 160, 1,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 228, 9,
0, 0, 0, 0, 248, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 8, 10,
0, 0, 0, 0, 28, 10,
0, 0, 192, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 38, 10, 0, 0,
0, 0, 58, 10, 0, 0,
208, 1, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
140, 8, 0, 0, 0, 0,
156, 8, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
@ -481,35 +481,73 @@ const BYTE continuous_triangle_hs[] =
97, 108, 112, 104, 97, 95,
116, 111, 95, 109, 97, 115,
107, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
105, 116, 99, 104, 95, 116,
105, 108, 101, 115, 0, 120,
101, 95, 99, 111, 108, 111,
114, 95, 101, 120, 112, 95,
98, 105, 97, 115, 0, 171,
171, 171, 1, 0, 3, 0,
1, 0, 4, 0, 0, 0,
100, 114, 97, 109, 95, 51,
50, 98, 112, 112, 95, 116,
105, 108, 101, 95, 112, 105,
116, 99, 104, 95, 100, 119,
111, 114, 100, 115, 95, 115,
99, 97, 108, 101, 100, 0,
120, 101, 95, 99, 111, 108,
111, 114, 95, 101, 120, 112,
95, 98, 105, 97, 115, 0,
1, 0, 3, 0, 1, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
111, 108, 121, 95, 111, 102,
102, 115, 101, 116, 95, 102,
114, 111, 110, 116, 0, 120,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 112, 111, 108,
121, 95, 111, 102, 102, 115,
101, 116, 95, 102, 114, 111,
110, 116, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
112, 111, 108, 121, 95, 111,
102, 102, 115, 101, 116, 95,
98, 97, 99, 107, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 112, 111, 108, 121,
95, 111, 102, 102, 115, 101,
116, 95, 98, 97, 99, 107,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 100, 101,
112, 116, 104, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 0, 120, 101,
109, 95, 100, 101, 112, 116,
104, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
115, 116, 101, 110, 99, 105,
108, 0, 1, 0, 19, 0,
1, 0, 4, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 171, 1, 0,
19, 0, 1, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 115, 116, 101, 110, 99,
105, 108, 0, 171, 171, 171,
95, 114, 116, 95, 102, 111,
114, 109, 97, 116, 95, 102,
108, 97, 103, 115, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 114, 116, 95, 99,
108, 97, 109, 112, 0, 171,
1, 0, 3, 0, 1, 0,
4, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
107, 101, 101, 112, 95, 109,
97, 115, 107, 0, 171, 171,
1, 0, 19, 0, 1, 0,
4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -518,166 +556,131 @@ const BYTE continuous_triangle_hs[] =
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
98, 97, 115, 101, 95, 100,
119, 111, 114, 100, 115, 95,
115, 99, 97, 108, 101, 100,
0, 171, 1, 0, 19, 0,
1, 0, 4, 0, 0, 0,
98, 108, 101, 110, 100, 95,
102, 97, 99, 116, 111, 114,
115, 95, 111, 112, 115, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 98, 108, 101,
110, 100, 95, 99, 111, 110,
115, 116, 97, 110, 116, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 171, 171,
73, 83, 71, 78, 44, 0,
0, 0, 1, 0, 0, 0,
8, 0, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 102, 111, 114, 109,
97, 116, 95, 102, 108, 97,
103, 115, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
114, 116, 95, 99, 108, 97,
109, 112, 0, 171, 1, 0,
3, 0, 1, 0, 4, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
172, 6, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 107, 101,
101, 112, 95, 109, 97, 115,
107, 0, 171, 171, 1, 0,
19, 0, 1, 0, 4, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 98, 108,
101, 110, 100, 95, 102, 97,
99, 116, 111, 114, 115, 95,
111, 112, 115, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 98, 108, 101, 110, 100,
95, 99, 111, 110, 115, 116,
97, 110, 116, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 171, 171, 73, 83,
1, 1, 0, 0, 88, 69,
86, 69, 82, 84, 69, 88,
73, 68, 0, 171, 79, 83,
71, 78, 44, 0, 0, 0,
1, 0, 0, 0, 8, 0,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 1,
0, 0, 0, 0, 1, 14,
0, 0, 88, 69, 86, 69,
82, 84, 69, 88, 73, 68,
0, 171, 79, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 171, 80, 67, 83, 71,
140, 0, 0, 0, 4, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
104, 0, 0, 0, 0, 0,
0, 0, 13, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 1, 14, 0, 0,
88, 69, 86, 69, 82, 84,
69, 88, 73, 68, 0, 171,
80, 67, 83, 71, 140, 0,
0, 0, 4, 0, 0, 0,
8, 0, 0, 0, 104, 0,
0, 0, 0, 0, 0, 0,
13, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 14, 0, 0, 104, 0,
0, 0, 1, 0, 0, 0,
13, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
1, 14, 0, 0, 104, 0,
0, 0, 2, 0, 0, 0,
13, 0, 0, 0, 3, 0,
0, 0, 2, 0, 0, 0,
1, 14, 0, 0, 118, 0,
0, 0, 0, 0, 0, 0,
14, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
1, 14, 0, 0, 83, 86,
95, 84, 101, 115, 115, 70,
97, 99, 116, 111, 114, 0,
83, 86, 95, 73, 110, 115,
105, 100, 101, 84, 101, 115,
104, 0, 0, 0, 1, 0,
0, 0, 13, 0, 0, 0,
3, 0, 0, 0, 1, 0,
0, 0, 1, 14, 0, 0,
104, 0, 0, 0, 2, 0,
0, 0, 13, 0, 0, 0,
3, 0, 0, 0, 2, 0,
0, 0, 1, 14, 0, 0,
118, 0, 0, 0, 0, 0,
0, 0, 14, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 1, 14, 0, 0,
83, 86, 95, 84, 101, 115,
115, 70, 97, 99, 116, 111,
114, 0, 171, 171, 83, 72,
69, 88, 4, 1, 0, 0,
81, 0, 3, 0, 65, 0,
0, 0, 113, 0, 0, 1,
147, 24, 0, 1, 148, 24,
0, 1, 149, 16, 0, 1,
150, 32, 0, 1, 151, 24,
0, 1, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
114, 0, 83, 86, 95, 73,
110, 115, 105, 100, 101, 84,
101, 115, 115, 70, 97, 99,
116, 111, 114, 0, 171, 171,
83, 72, 69, 88, 4, 1,
0, 0, 81, 0, 3, 0,
65, 0, 0, 0, 113, 0,
0, 1, 147, 24, 0, 1,
148, 24, 0, 1, 149, 16,
0, 1, 150, 32, 0, 1,
151, 24, 0, 1, 106, 8,
0, 1, 89, 0, 0, 7,
70, 142, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
115, 0, 0, 1, 153, 0,
0, 2, 3, 0, 0, 0,
95, 0, 0, 2, 0, 112,
1, 0, 103, 0, 0, 4,
18, 32, 16, 0, 0, 0,
0, 0, 17, 0, 0, 0,
103, 0, 0, 4, 18, 32,
16, 0, 1, 0, 0, 0,
18, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
2, 0, 0, 0, 19, 0,
0, 0, 104, 0, 0, 2,
1, 0, 0, 0, 91, 0,
0, 4, 18, 32, 16, 0,
0, 0, 0, 0, 3, 0,
0, 0, 54, 0, 0, 4,
18, 0, 16, 0, 0, 0,
0, 0, 10, 112, 1, 0,
54, 0, 0, 8, 18, 32,
144, 0, 10, 0, 16, 0,
0, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 115, 0,
0, 1, 153, 0, 0, 2,
3, 0, 0, 0, 95, 0,
0, 2, 0, 112, 1, 0,
103, 0, 0, 4, 18, 32,
16, 0, 0, 0, 0, 0,
17, 0, 0, 0, 103, 0,
0, 0, 62, 0, 0, 1,
115, 0, 0, 1, 103, 0,
0, 4, 18, 32, 16, 0,
1, 0, 0, 0, 18, 0,
0, 0, 103, 0, 0, 4,
18, 32, 16, 0, 2, 0,
0, 0, 19, 0, 0, 0,
104, 0, 0, 2, 1, 0,
0, 0, 91, 0, 0, 4,
18, 32, 16, 0, 0, 0,
0, 0, 3, 0, 0, 0,
54, 0, 0, 4, 18, 0,
16, 0, 0, 0, 0, 0,
10, 112, 1, 0, 54, 0,
0, 8, 18, 32, 144, 0,
10, 0, 16, 0, 0, 0,
3, 0, 0, 0, 20, 0,
0, 0, 54, 0, 0, 7,
18, 32, 16, 0, 3, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
62, 0, 0, 1, 115, 0,
0, 1, 103, 0, 0, 4,
18, 32, 16, 0, 3, 0,
0, 0, 20, 0, 0, 0,
54, 0, 0, 7, 18, 32,
16, 0, 3, 0, 0, 0,
42, 128, 48, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
5, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 5, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 4, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
10, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0
0, 0, 10, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0
};

417
src/xenia/gpu/shaders/bytecode/d3d12_5_1/discrete_quad_hs.h generated
View File

@ -28,11 +28,11 @@
// uint xe_textures_resolved; // Offset: 224 Size: 4 [unused]
// float xe_alpha_test_reference; // Offset: 228 Size: 4 [unused]
// uint xe_alpha_to_mask; // Offset: 232 Size: 4 [unused]
// uint xe_edram_pitch_tiles; // Offset: 236 Size: 4 [unused]
// uint xe_edram_32bpp_tile_pitch_dwords_scaled;// Offset: 236 Size: 4 [unused]
// float4 xe_color_exp_bias; // Offset: 240 Size: 16 [unused]
// float2 xe_edram_poly_offset_front; // Offset: 256 Size: 8 [unused]
// float2 xe_edram_poly_offset_back; // Offset: 264 Size: 8 [unused]
// uint xe_edram_depth_base_dwords; // Offset: 272 Size: 4 [unused]
// uint xe_edram_depth_base_dwords_scaled;// Offset: 272 Size: 4 [unused]
// uint4 xe_edram_stencil[2]; // Offset: 288 Size: 32 [unused]
// uint4 xe_edram_rt_base_dwords_scaled;// Offset: 320 Size: 16 [unused]
// uint4 xe_edram_rt_format_flags; // Offset: 336 Size: 16 [unused]
@ -121,21 +121,21 @@ ret
const BYTE discrete_quad_hs[] =
{
68, 88, 66, 67, 133, 207,
137, 232, 78, 97, 5, 29,
188, 112, 65, 159, 75, 218,
107, 227, 1, 0, 0, 0,
220, 13, 0, 0, 6, 0,
68, 88, 66, 67, 174, 141,
75, 94, 70, 108, 133, 212,
18, 161, 84, 115, 238, 199,
1, 25, 1, 0, 0, 0,
240, 13, 0, 0, 6, 0,
0, 0, 56, 0, 0, 0,
168, 10, 0, 0, 220, 10,
0, 0, 16, 11, 0, 0,
212, 11, 0, 0, 64, 13,
188, 10, 0, 0, 240, 10,
0, 0, 36, 11, 0, 0,
232, 11, 0, 0, 84, 13,
0, 0, 82, 68, 69, 70,
104, 10, 0, 0, 1, 0,
124, 10, 0, 0, 1, 0,
0, 0, 120, 0, 0, 0,
1, 0, 0, 0, 60, 0,
0, 0, 1, 5, 83, 72,
0, 5, 4, 0, 62, 10,
0, 5, 4, 0, 82, 10,
0, 0, 19, 19, 68, 37,
60, 0, 0, 0, 24, 0,
0, 0, 40, 0, 0, 0,
@ -295,77 +295,77 @@ const BYTE discrete_quad_hs[] =
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 119, 8,
0, 0, 0, 0, 138, 8,
0, 0, 240, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 140, 8, 0, 0,
0, 0, 156, 8, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 176, 8, 0, 0,
0, 0, 192, 8, 0, 0,
0, 1, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
232, 5, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
203, 8, 0, 0, 8, 1,
219, 8, 0, 0, 8, 1,
0, 0, 8, 0, 0, 0,
0, 0, 0, 0, 232, 5,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 229, 8,
0, 0, 0, 0, 245, 8,
0, 0, 16, 1, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 160, 5, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 0, 9, 0, 0,
0, 0, 23, 9, 0, 0,
32, 1, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
20, 9, 0, 0, 0, 0,
40, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
56, 9, 0, 0, 64, 1,
76, 9, 0, 0, 64, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 124, 9,
0, 0, 0, 0, 144, 9,
0, 0, 80, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 149, 9, 0, 0,
0, 0, 169, 9, 0, 0,
96, 1, 0, 0, 64, 0,
0, 0, 0, 0, 0, 0,
168, 9, 0, 0, 0, 0,
188, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
204, 9, 0, 0, 160, 1,
224, 9, 0, 0, 160, 1,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 228, 9,
0, 0, 0, 0, 248, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 8, 10,
0, 0, 0, 0, 28, 10,
0, 0, 192, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 38, 10, 0, 0,
0, 0, 58, 10, 0, 0,
208, 1, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
140, 8, 0, 0, 0, 0,
156, 8, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
@ -490,35 +490,73 @@ const BYTE discrete_quad_hs[] =
97, 108, 112, 104, 97, 95,
116, 111, 95, 109, 97, 115,
107, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
105, 116, 99, 104, 95, 116,
105, 108, 101, 115, 0, 120,
101, 95, 99, 111, 108, 111,
114, 95, 101, 120, 112, 95,
98, 105, 97, 115, 0, 171,
171, 171, 1, 0, 3, 0,
1, 0, 4, 0, 0, 0,
100, 114, 97, 109, 95, 51,
50, 98, 112, 112, 95, 116,
105, 108, 101, 95, 112, 105,
116, 99, 104, 95, 100, 119,
111, 114, 100, 115, 95, 115,
99, 97, 108, 101, 100, 0,
120, 101, 95, 99, 111, 108,
111, 114, 95, 101, 120, 112,
95, 98, 105, 97, 115, 0,
1, 0, 3, 0, 1, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
111, 108, 121, 95, 111, 102,
102, 115, 101, 116, 95, 102,
114, 111, 110, 116, 0, 120,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 112, 111, 108,
121, 95, 111, 102, 102, 115,
101, 116, 95, 102, 114, 111,
110, 116, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
112, 111, 108, 121, 95, 111,
102, 102, 115, 101, 116, 95,
98, 97, 99, 107, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 112, 111, 108, 121,
95, 111, 102, 102, 115, 101,
116, 95, 98, 97, 99, 107,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 100, 101,
112, 116, 104, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 0, 120, 101,
109, 95, 100, 101, 112, 116,
104, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
115, 116, 101, 110, 99, 105,
108, 0, 1, 0, 19, 0,
1, 0, 4, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 171, 1, 0,
19, 0, 1, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 115, 116, 101, 110, 99,
105, 108, 0, 171, 171, 171,
95, 114, 116, 95, 102, 111,
114, 109, 97, 116, 95, 102,
108, 97, 103, 115, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 114, 116, 95, 99,
108, 97, 109, 112, 0, 171,
1, 0, 3, 0, 1, 0,
4, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
107, 101, 101, 112, 95, 109,
97, 115, 107, 0, 171, 171,
1, 0, 19, 0, 1, 0,
4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -527,190 +565,155 @@ const BYTE discrete_quad_hs[] =
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
98, 97, 115, 101, 95, 100,
119, 111, 114, 100, 115, 95,
115, 99, 97, 108, 101, 100,
0, 171, 1, 0, 19, 0,
1, 0, 4, 0, 0, 0,
98, 108, 101, 110, 100, 95,
102, 97, 99, 116, 111, 114,
115, 95, 111, 112, 115, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 98, 108, 101,
110, 100, 95, 99, 111, 110,
115, 116, 97, 110, 116, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 171, 171,
73, 83, 71, 78, 44, 0,
0, 0, 1, 0, 0, 0,
8, 0, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 102, 111, 114, 109,
97, 116, 95, 102, 108, 97,
103, 115, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
114, 116, 95, 99, 108, 97,
109, 112, 0, 171, 1, 0,
3, 0, 1, 0, 4, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
172, 6, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 107, 101,
101, 112, 95, 109, 97, 115,
107, 0, 171, 171, 1, 0,
19, 0, 1, 0, 4, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 98, 108,
101, 110, 100, 95, 102, 97,
99, 116, 111, 114, 115, 95,
111, 112, 115, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 98, 108, 101, 110, 100,
95, 99, 111, 110, 115, 116,
97, 110, 116, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 171, 171, 73, 83,
1, 1, 0, 0, 88, 69,
86, 69, 82, 84, 69, 88,
73, 68, 0, 171, 79, 83,
71, 78, 44, 0, 0, 0,
1, 0, 0, 0, 8, 0,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 1,
0, 0, 0, 0, 1, 14,
0, 0, 88, 69, 86, 69,
82, 84, 69, 88, 73, 68,
0, 171, 79, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 171, 80, 67, 83, 71,
188, 0, 0, 0, 6, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
152, 0, 0, 0, 0, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 1, 14, 0, 0,
88, 69, 86, 69, 82, 84,
69, 88, 73, 68, 0, 171,
80, 67, 83, 71, 188, 0,
0, 0, 6, 0, 0, 0,
8, 0, 0, 0, 152, 0,
0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 14, 0, 0, 152, 0,
0, 0, 1, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
1, 14, 0, 0, 152, 0,
0, 0, 2, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 2, 0, 0, 0,
1, 14, 0, 0, 152, 0,
0, 0, 3, 0, 0, 0,
11, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
1, 14, 0, 0, 166, 0,
0, 0, 0, 0, 0, 0,
12, 0, 0, 0, 3, 0,
0, 0, 4, 0, 0, 0,
1, 14, 0, 0, 166, 0,
0, 0, 1, 0, 0, 0,
12, 0, 0, 0, 3, 0,
0, 0, 5, 0, 0, 0,
1, 14, 0, 0, 83, 86,
95, 84, 101, 115, 115, 70,
97, 99, 116, 111, 114, 0,
83, 86, 95, 73, 110, 115,
105, 100, 101, 84, 101, 115,
152, 0, 0, 0, 1, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 1, 0,
0, 0, 1, 14, 0, 0,
152, 0, 0, 0, 2, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 2, 0,
0, 0, 1, 14, 0, 0,
152, 0, 0, 0, 3, 0,
0, 0, 11, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 1, 14, 0, 0,
166, 0, 0, 0, 0, 0,
0, 0, 12, 0, 0, 0,
3, 0, 0, 0, 4, 0,
0, 0, 1, 14, 0, 0,
166, 0, 0, 0, 1, 0,
0, 0, 12, 0, 0, 0,
3, 0, 0, 0, 5, 0,
0, 0, 1, 14, 0, 0,
83, 86, 95, 84, 101, 115,
115, 70, 97, 99, 116, 111,
114, 0, 171, 171, 83, 72,
69, 88, 100, 1, 0, 0,
81, 0, 3, 0, 89, 0,
0, 0, 113, 0, 0, 1,
147, 32, 0, 1, 148, 32,
0, 1, 149, 24, 0, 1,
150, 8, 0, 1, 151, 24,
0, 1, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
114, 0, 83, 86, 95, 73,
110, 115, 105, 100, 101, 84,
101, 115, 115, 70, 97, 99,
116, 111, 114, 0, 171, 171,
83, 72, 69, 88, 100, 1,
0, 0, 81, 0, 3, 0,
89, 0, 0, 0, 113, 0,
0, 1, 147, 32, 0, 1,
148, 32, 0, 1, 149, 24,
0, 1, 150, 8, 0, 1,
151, 24, 0, 1, 106, 8,
0, 1, 89, 0, 0, 7,
70, 142, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 115, 0,
0, 1, 153, 0, 0, 2,
4, 0, 0, 0, 95, 0,
0, 2, 0, 112, 1, 0,
103, 0, 0, 4, 18, 32,
16, 0, 0, 0, 0, 0,
11, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
1, 0, 0, 0, 12, 0,
0, 0, 103, 0, 0, 4,
18, 32, 16, 0, 2, 0,
0, 0, 13, 0, 0, 0,
103, 0, 0, 4, 18, 32,
16, 0, 3, 0, 0, 0,
14, 0, 0, 0, 104, 0,
0, 2, 1, 0, 0, 0,
91, 0, 0, 4, 18, 32,
16, 0, 0, 0, 0, 0,
4, 0, 0, 0, 54, 0,
0, 4, 18, 0, 16, 0,
0, 0, 0, 0, 10, 112,
1, 0, 54, 0, 0, 8,
18, 32, 144, 0, 10, 0,
16, 0, 0, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 115, 0, 0, 1,
153, 0, 0, 2, 2, 0,
0, 0, 95, 0, 0, 2,
0, 112, 1, 0, 103, 0,
115, 0, 0, 1, 153, 0,
0, 2, 4, 0, 0, 0,
95, 0, 0, 2, 0, 112,
1, 0, 103, 0, 0, 4,
18, 32, 16, 0, 0, 0,
0, 0, 11, 0, 0, 0,
103, 0, 0, 4, 18, 32,
16, 0, 1, 0, 0, 0,
12, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
4, 0, 0, 0, 15, 0,
2, 0, 0, 0, 13, 0,
0, 0, 103, 0, 0, 4,
18, 32, 16, 0, 5, 0,
0, 0, 16, 0, 0, 0,
18, 32, 16, 0, 3, 0,
0, 0, 14, 0, 0, 0,
104, 0, 0, 2, 1, 0,
0, 0, 91, 0, 0, 4,
18, 32, 16, 0, 4, 0,
0, 0, 2, 0, 0, 0,
18, 32, 16, 0, 0, 0,
0, 0, 4, 0, 0, 0,
54, 0, 0, 4, 18, 0,
16, 0, 0, 0, 0, 0,
10, 112, 1, 0, 54, 0,
0, 9, 18, 32, 208, 0,
4, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 6, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 5, 0,
0, 8, 18, 32, 144, 0,
10, 0, 16, 0, 0, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
62, 0, 0, 1, 115, 0,
0, 1, 153, 0, 0, 2,
2, 0, 0, 0, 95, 0,
0, 2, 0, 112, 1, 0,
103, 0, 0, 4, 18, 32,
16, 0, 4, 0, 0, 0,
15, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
5, 0, 0, 0, 16, 0,
0, 0, 104, 0, 0, 2,
1, 0, 0, 0, 91, 0,
0, 4, 18, 32, 16, 0,
4, 0, 0, 0, 2, 0,
0, 0, 54, 0, 0, 4,
18, 0, 16, 0, 0, 0,
0, 0, 10, 112, 1, 0,
54, 0, 0, 9, 18, 32,
208, 0, 4, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
6, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
5, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 3, 0, 0, 0,
1, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0
0, 0, 11, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
4, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0
};

375
src/xenia/gpu/shaders/bytecode/d3d12_5_1/discrete_triangle_hs.h generated
View File

@ -28,11 +28,11 @@
// uint xe_textures_resolved; // Offset: 224 Size: 4 [unused]
// float xe_alpha_test_reference; // Offset: 228 Size: 4 [unused]
// uint xe_alpha_to_mask; // Offset: 232 Size: 4 [unused]
// uint xe_edram_pitch_tiles; // Offset: 236 Size: 4 [unused]
// uint xe_edram_32bpp_tile_pitch_dwords_scaled;// Offset: 236 Size: 4 [unused]
// float4 xe_color_exp_bias; // Offset: 240 Size: 16 [unused]
// float2 xe_edram_poly_offset_front; // Offset: 256 Size: 8 [unused]
// float2 xe_edram_poly_offset_back; // Offset: 264 Size: 8 [unused]
// uint xe_edram_depth_base_dwords; // Offset: 272 Size: 4 [unused]
// uint xe_edram_depth_base_dwords_scaled;// Offset: 272 Size: 4 [unused]
// uint4 xe_edram_stencil[2]; // Offset: 288 Size: 32 [unused]
// uint4 xe_edram_rt_base_dwords_scaled;// Offset: 320 Size: 16 [unused]
// uint4 xe_edram_rt_format_flags; // Offset: 336 Size: 16 [unused]
@ -112,21 +112,21 @@ ret
const BYTE discrete_triangle_hs[] =
{
68, 88, 66, 67, 106, 99,
99, 223, 105, 193, 70, 218,
33, 84, 217, 184, 177, 180,
199, 65, 1, 0, 0, 0,
76, 13, 0, 0, 6, 0,
68, 88, 66, 67, 100, 231,
203, 227, 24, 0, 204, 209,
145, 54, 166, 75, 102, 255,
190, 98, 1, 0, 0, 0,
96, 13, 0, 0, 6, 0,
0, 0, 56, 0, 0, 0,
168, 10, 0, 0, 220, 10,
0, 0, 16, 11, 0, 0,
164, 11, 0, 0, 176, 12,
188, 10, 0, 0, 240, 10,
0, 0, 36, 11, 0, 0,
184, 11, 0, 0, 196, 12,
0, 0, 82, 68, 69, 70,
104, 10, 0, 0, 1, 0,
124, 10, 0, 0, 1, 0,
0, 0, 120, 0, 0, 0,
1, 0, 0, 0, 60, 0,
0, 0, 1, 5, 83, 72,
0, 5, 4, 0, 62, 10,
0, 5, 4, 0, 82, 10,
0, 0, 19, 19, 68, 37,
60, 0, 0, 0, 24, 0,
0, 0, 40, 0, 0, 0,
@ -286,77 +286,77 @@ const BYTE discrete_triangle_hs[] =
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 119, 8,
0, 0, 0, 0, 138, 8,
0, 0, 240, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 140, 8, 0, 0,
0, 0, 156, 8, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 176, 8, 0, 0,
0, 0, 192, 8, 0, 0,
0, 1, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
232, 5, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
203, 8, 0, 0, 8, 1,
219, 8, 0, 0, 8, 1,
0, 0, 8, 0, 0, 0,
0, 0, 0, 0, 232, 5,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 229, 8,
0, 0, 0, 0, 245, 8,
0, 0, 16, 1, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 160, 5, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 0, 9, 0, 0,
0, 0, 23, 9, 0, 0,
32, 1, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
20, 9, 0, 0, 0, 0,
40, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
56, 9, 0, 0, 64, 1,
76, 9, 0, 0, 64, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 124, 9,
0, 0, 0, 0, 144, 9,
0, 0, 80, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 149, 9, 0, 0,
0, 0, 169, 9, 0, 0,
96, 1, 0, 0, 64, 0,
0, 0, 0, 0, 0, 0,
168, 9, 0, 0, 0, 0,
188, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
204, 9, 0, 0, 160, 1,
224, 9, 0, 0, 160, 1,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 228, 9,
0, 0, 0, 0, 248, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 8, 10,
0, 0, 0, 0, 28, 10,
0, 0, 192, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 88, 9, 0, 0,
0, 0, 108, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 38, 10, 0, 0,
0, 0, 58, 10, 0, 0,
208, 1, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
140, 8, 0, 0, 0, 0,
156, 8, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
@ -481,35 +481,73 @@ const BYTE discrete_triangle_hs[] =
97, 108, 112, 104, 97, 95,
116, 111, 95, 109, 97, 115,
107, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
105, 116, 99, 104, 95, 116,
105, 108, 101, 115, 0, 120,
101, 95, 99, 111, 108, 111,
114, 95, 101, 120, 112, 95,
98, 105, 97, 115, 0, 171,
171, 171, 1, 0, 3, 0,
1, 0, 4, 0, 0, 0,
100, 114, 97, 109, 95, 51,
50, 98, 112, 112, 95, 116,
105, 108, 101, 95, 112, 105,
116, 99, 104, 95, 100, 119,
111, 114, 100, 115, 95, 115,
99, 97, 108, 101, 100, 0,
120, 101, 95, 99, 111, 108,
111, 114, 95, 101, 120, 112,
95, 98, 105, 97, 115, 0,
1, 0, 3, 0, 1, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
111, 108, 121, 95, 111, 102,
102, 115, 101, 116, 95, 102,
114, 111, 110, 116, 0, 120,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 112, 111, 108,
121, 95, 111, 102, 102, 115,
101, 116, 95, 102, 114, 111,
110, 116, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
112, 111, 108, 121, 95, 111,
102, 102, 115, 101, 116, 95,
98, 97, 99, 107, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 112, 111, 108, 121,
95, 111, 102, 102, 115, 101,
116, 95, 98, 97, 99, 107,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 100, 101,
112, 116, 104, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 0, 120, 101,
109, 95, 100, 101, 112, 116,
104, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
115, 116, 101, 110, 99, 105,
108, 0, 1, 0, 19, 0,
1, 0, 4, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 171, 1, 0,
19, 0, 1, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 115, 116, 101, 110, 99,
105, 108, 0, 171, 171, 171,
95, 114, 116, 95, 102, 111,
114, 109, 97, 116, 95, 102,
108, 97, 103, 115, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 114, 116, 95, 99,
108, 97, 109, 112, 0, 171,
1, 0, 3, 0, 1, 0,
4, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
107, 101, 101, 112, 95, 109,
97, 115, 107, 0, 171, 171,
1, 0, 19, 0, 1, 0,
4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -518,166 +556,131 @@ const BYTE discrete_triangle_hs[] =
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
98, 97, 115, 101, 95, 100,
119, 111, 114, 100, 115, 95,
115, 99, 97, 108, 101, 100,
0, 171, 1, 0, 19, 0,
1, 0, 4, 0, 0, 0,
98, 108, 101, 110, 100, 95,
102, 97, 99, 116, 111, 114,
115, 95, 111, 112, 115, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 98, 108, 101,
110, 100, 95, 99, 111, 110,
115, 116, 97, 110, 116, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 171, 171,
73, 83, 71, 78, 44, 0,
0, 0, 1, 0, 0, 0,
8, 0, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 102, 111, 114, 109,
97, 116, 95, 102, 108, 97,
103, 115, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
114, 116, 95, 99, 108, 97,
109, 112, 0, 171, 1, 0,
3, 0, 1, 0, 4, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
172, 6, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 107, 101,
101, 112, 95, 109, 97, 115,
107, 0, 171, 171, 1, 0,
19, 0, 1, 0, 4, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 98, 108,
101, 110, 100, 95, 102, 97,
99, 116, 111, 114, 115, 95,
111, 112, 115, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 98, 108, 101, 110, 100,
95, 99, 111, 110, 115, 116,
97, 110, 116, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 171, 171, 73, 83,
1, 1, 0, 0, 88, 69,
86, 69, 82, 84, 69, 88,
73, 68, 0, 171, 79, 83,
71, 78, 44, 0, 0, 0,
1, 0, 0, 0, 8, 0,
0, 0, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 1,
0, 0, 0, 0, 1, 14,
0, 0, 88, 69, 86, 69,
82, 84, 69, 88, 73, 68,
0, 171, 79, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 171, 80, 67, 83, 71,
140, 0, 0, 0, 4, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
104, 0, 0, 0, 0, 0,
0, 0, 13, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 1, 14, 0, 0,
88, 69, 86, 69, 82, 84,
69, 88, 73, 68, 0, 171,
80, 67, 83, 71, 140, 0,
0, 0, 4, 0, 0, 0,
8, 0, 0, 0, 104, 0,
0, 0, 0, 0, 0, 0,
13, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 14, 0, 0, 104, 0,
0, 0, 1, 0, 0, 0,
13, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
1, 14, 0, 0, 104, 0,
0, 0, 2, 0, 0, 0,
13, 0, 0, 0, 3, 0,
0, 0, 2, 0, 0, 0,
1, 14, 0, 0, 118, 0,
0, 0, 0, 0, 0, 0,
14, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
1, 14, 0, 0, 83, 86,
95, 84, 101, 115, 115, 70,
97, 99, 116, 111, 114, 0,
83, 86, 95, 73, 110, 115,
105, 100, 101, 84, 101, 115,
104, 0, 0, 0, 1, 0,
0, 0, 13, 0, 0, 0,
3, 0, 0, 0, 1, 0,
0, 0, 1, 14, 0, 0,
104, 0, 0, 0, 2, 0,
0, 0, 13, 0, 0, 0,
3, 0, 0, 0, 2, 0,
0, 0, 1, 14, 0, 0,
118, 0, 0, 0, 0, 0,
0, 0, 14, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 1, 14, 0, 0,
83, 86, 95, 84, 101, 115,
115, 70, 97, 99, 116, 111,
114, 0, 171, 171, 83, 72,
69, 88, 4, 1, 0, 0,
81, 0, 3, 0, 65, 0,
0, 0, 113, 0, 0, 1,
147, 24, 0, 1, 148, 24,
0, 1, 149, 16, 0, 1,
150, 8, 0, 1, 151, 24,
0, 1, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
114, 0, 83, 86, 95, 73,
110, 115, 105, 100, 101, 84,
101, 115, 115, 70, 97, 99,
116, 111, 114, 0, 171, 171,
83, 72, 69, 88, 4, 1,
0, 0, 81, 0, 3, 0,
65, 0, 0, 0, 113, 0,
0, 1, 147, 24, 0, 1,
148, 24, 0, 1, 149, 16,
0, 1, 150, 8, 0, 1,
151, 24, 0, 1, 106, 8,
0, 1, 89, 0, 0, 7,
70, 142, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
115, 0, 0, 1, 153, 0,
0, 2, 3, 0, 0, 0,
95, 0, 0, 2, 0, 112,
1, 0, 103, 0, 0, 4,
18, 32, 16, 0, 0, 0,
0, 0, 17, 0, 0, 0,
103, 0, 0, 4, 18, 32,
16, 0, 1, 0, 0, 0,
18, 0, 0, 0, 103, 0,
0, 4, 18, 32, 16, 0,
2, 0, 0, 0, 19, 0,
0, 0, 104, 0, 0, 2,
1, 0, 0, 0, 91, 0,
0, 4, 18, 32, 16, 0,
0, 0, 0, 0, 3, 0,
0, 0, 54, 0, 0, 4,
18, 0, 16, 0, 0, 0,
0, 0, 10, 112, 1, 0,
54, 0, 0, 8, 18, 32,
144, 0, 10, 0, 16, 0,
0, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 115, 0,
0, 1, 153, 0, 0, 2,
3, 0, 0, 0, 95, 0,
0, 2, 0, 112, 1, 0,
103, 0, 0, 4, 18, 32,
16, 0, 0, 0, 0, 0,
17, 0, 0, 0, 103, 0,
0, 0, 62, 0, 0, 1,
115, 0, 0, 1, 103, 0,
0, 4, 18, 32, 16, 0,
1, 0, 0, 0, 18, 0,
0, 0, 103, 0, 0, 4,
18, 32, 16, 0, 2, 0,
0, 0, 19, 0, 0, 0,
104, 0, 0, 2, 1, 0,
0, 0, 91, 0, 0, 4,
18, 32, 16, 0, 0, 0,
0, 0, 3, 0, 0, 0,
54, 0, 0, 4, 18, 0,
16, 0, 0, 0, 0, 0,
10, 112, 1, 0, 54, 0,
0, 8, 18, 32, 144, 0,
10, 0, 16, 0, 0, 0,
3, 0, 0, 0, 20, 0,
0, 0, 54, 0, 0, 7,
18, 32, 16, 0, 3, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
62, 0, 0, 1, 115, 0,
0, 1, 103, 0, 0, 4,
18, 32, 16, 0, 3, 0,
0, 0, 20, 0, 0, 0,
54, 0, 0, 7, 18, 32,
16, 0, 3, 0, 0, 0,
42, 128, 48, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
5, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 5, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 4, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
10, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
1, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0
0, 0, 10, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0
};

198
src/xenia/gpu/shaders/bytecode/d3d12_5_1/host_depth_store_1xmsaa_cs.h generated
View File

@ -51,27 +51,29 @@ dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 4
dcl_thread_group 8, 8, 1
ubfe r0.x, l(2), l(10), CB1[1][0].x
ubfe r0.y, l(10), l(20), CB0[0][0].x
imul null, r0.y, r0.x, r0.y
ult r0.y, r0.y, vThreadID.x
if_nz r0.y
ubfe r0.x, l(10), l(20), CB0[0][0].x
iadd r0.x, r0.x, l(1)
ubfe r0.y, l(2), l(10), CB1[1][0].x
imul null, r0.x, r0.y, r0.x
uge r0.x, vThreadID.x, r0.x
if_nz r0.x
ret
endif
ushr r1.y, CB0[0][0].x, l(10)
mov r1.x, CB0[0][0].x
bfi r0.yz, l(0, 10, 10, 0), l(0, 3, 3, 0), r1.xxyx, l(0, 0, 0, 0)
ushr r0.y, CB0[0][0].x, l(10)
mov r0.x, CB0[0][0].x
bfi r0.xy, l(10, 10, 0, 0), l(3, 3, 0, 0), r0.xyxx, l(0, 0, 0, 0)
ubfe r0.zw, l(0, 0, 2, 2), l(0, 0, 10, 12), CB1[1][0].xxxx
ishl r1.x, vThreadID.x, l(3)
mov r1.y, vThreadID.y
imad r1.xy, r0.yzyy, r0.xxxx, r1.xyxx
and r0.y, CB1[1][0].x, l(1023)
imul null, r0.xz, r0.xxxx, l(80, 0, 16, 0)
udiv r2.xy, null, r1.xyxx, r0.xzxx
imad r0.y, r2.y, r0.y, r2.x
imad r2.xy, -r2.xyxx, r0.xzxx, r1.xyxx
imul null, r0.z, r0.z, r0.x
imad r1.xy, r0.xyxx, r0.zwzz, r1.xyxx
and r0.x, CB1[1][0].x, l(1023)
imul null, r0.yz, r0.zzwz, l(0, 80, 16, 0)
udiv r2.xy, null, r1.xyxx, r0.yzyy
imad r0.x, r2.y, r0.x, r2.x
imad r0.x, r0.y, r0.z, r0.x
imad r2.xy, -r2.xyxx, r0.yzyy, r1.xyxx
imul null, r0.z, r0.z, r0.y
imad r0.y, r2.y, r0.y, r2.x
imad r0.x, r0.x, r0.z, r0.y
ushr r0.x, r0.x, l(2)
mov r1.zw, l(0,0,0,0)
ld r2.x, r1.xyww, T0[0].xyzw
@ -93,20 +95,20 @@ iadd r1.xyzw, r1.xyzw, l(7, 0, 0, 0)
ld r2.w, r1.xyzw, T0[0].yzwx
store_uav_typed U0[0].xyzw, r0.yyyy, r2.xyzw
ret
// Approximately 42 instruction slots used
// Approximately 44 instruction slots used
#endif
const BYTE host_depth_store_1xmsaa_cs[] =
{
68, 88, 66, 67, 201, 213,
112, 124, 150, 112, 103, 4,
67, 70, 247, 238, 236, 19,
131, 143, 1, 0, 0, 0,
100, 9, 0, 0, 5, 0,
68, 88, 66, 67, 40, 219,
237, 83, 207, 54, 217, 154,
183, 72, 124, 224, 242, 47,
153, 1, 1, 0, 0, 0,
196, 9, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
172, 2, 0, 0, 188, 2,
0, 0, 204, 2, 0, 0,
200, 8, 0, 0, 82, 68,
40, 9, 0, 0, 82, 68,
69, 70, 112, 2, 0, 0,
2, 0, 0, 0, 92, 1,
0, 0, 4, 0, 0, 0,
@ -218,8 +220,8 @@ const BYTE host_depth_store_1xmsaa_cs[] =
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
244, 5, 0, 0, 81, 0,
5, 0, 125, 1, 0, 0,
84, 6, 0, 0, 81, 0,
5, 0, 149, 1, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
@ -247,54 +249,70 @@ const BYTE host_depth_store_1xmsaa_cs[] =
1, 0, 0, 0, 138, 0,
0, 11, 18, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 10, 0, 0, 0,
1, 64, 0, 0, 20, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 138, 0,
0, 11, 34, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 10, 0,
0, 0, 10, 128, 48, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
138, 0, 0, 11, 34, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 10, 0,
0, 0, 1, 64, 0, 0,
20, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 38, 0, 0, 8,
0, 208, 0, 0, 34, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 79, 0,
0, 6, 34, 0, 16, 0,
38, 0, 0, 8, 0, 208,
0, 0, 18, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 2, 0, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
85, 0, 0, 9, 34, 0,
16, 0, 1, 0, 0, 0,
10, 128, 48, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 80, 0, 0, 6,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 2, 0,
10, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
10, 0, 16, 0, 0, 0,
0, 0, 62, 0, 0, 1,
21, 0, 0, 1, 85, 0,
0, 9, 34, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 10, 0, 0, 0,
54, 0, 0, 7, 18, 0,
16, 0, 1, 0, 0, 0,
10, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 20, 98, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 1, 64, 0, 0,
10, 0, 0, 0, 54, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 140, 0, 0, 20,
50, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
10, 0, 0, 0, 10, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 6, 1, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 138, 0,
0, 17, 194, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 2, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
10, 0, 0, 0, 12, 0,
0, 0, 6, 128, 48, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
41, 0, 0, 6, 18, 0,
16, 0, 1, 0, 0, 0,
@ -304,59 +322,59 @@ const BYTE host_depth_store_1xmsaa_cs[] =
16, 0, 1, 0, 0, 0,
26, 0, 2, 0, 35, 0,
0, 9, 50, 0, 16, 0,
1, 0, 0, 0, 150, 5,
1, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
230, 10, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
1, 0, 0, 0, 1, 0,
0, 9, 34, 0, 16, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
255, 3, 0, 0, 38, 0,
0, 11, 0, 208, 0, 0,
82, 0, 16, 0, 0, 0,
0, 0, 6, 0, 16, 0,
98, 0, 16, 0, 0, 0,
0, 0, 166, 11, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
0, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
80, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
78, 0, 0, 8, 50, 0,
16, 0, 2, 0, 0, 0,
0, 208, 0, 0, 70, 0,
16, 0, 1, 0, 0, 0,
134, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
34, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
2, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 35, 0, 0, 10,
50, 0, 16, 0, 2, 0,
0, 0, 70, 0, 16, 128,
65, 0, 0, 0, 2, 0,
0, 0, 134, 0, 16, 0,
0, 0, 0, 0, 70, 0,
16, 0, 1, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 66, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
150, 5, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
2, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 35, 0, 0, 10,
50, 0, 16, 0, 2, 0,
0, 0, 70, 0, 16, 128,
65, 0, 0, 0, 2, 0,
0, 0, 150, 5, 16, 0,
0, 0, 0, 0, 70, 0,
16, 0, 1, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 66, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
34, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
2, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 85, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
@ -474,10 +492,10 @@ const BYTE host_depth_store_1xmsaa_cs[] =
16, 0, 2, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
42, 0, 0, 0, 4, 0,
44, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 17, 0, 0, 0,
0, 0, 18, 0, 0, 0,
5, 0, 0, 0, 2, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,

632
src/xenia/gpu/shaders/bytecode/d3d12_5_1/host_depth_store_2xmsaa_cs.h generated
View File

@ -51,76 +51,77 @@ dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 5
dcl_thread_group 8, 8, 1
ubfe r0.x, l(2), l(10), CB1[1][0].x
ubfe r0.y, l(10), l(20), CB0[0][0].x
imul null, r0.y, r0.x, r0.y
ult r0.y, r0.y, vThreadID.x
if_nz r0.y
ubfe r0.x, l(10), l(20), CB0[0][0].x
iadd r0.x, r0.x, l(1)
ubfe r0.y, l(2), l(10), CB1[1][0].x
imul null, r0.x, r0.y, r0.x
uge r0.x, vThreadID.x, r0.x
if_nz r0.x
ret
endif
ushr r1.y, CB0[0][0].x, l(10)
mov r1.x, CB0[0][0].x
bfi r0.yz, l(0, 10, 10, 0), l(0, 3, 3, 0), r1.xxyx, l(0, 0, 0, 0)
ishl r1.x, vThreadID.x, l(3)
ushr r1.y, vThreadID.y, l(1)
imad r1.xy, r0.yzyy, r0.xxxx, r1.xyxx
ushr r0.y, CB0[0][0].x, l(10)
mov r0.x, CB0[0][0].x
bfi r0.xy, l(10, 10, 0, 0), l(3, 3, 0, 0), r0.xyxx, l(0, 0, 0, 0)
ubfe r1.xyz, l(2, 2, 1, 0), l(10, 12, 14, 0), CB1[1][0].xxxx
ishl r2.x, vThreadID.x, l(3)
ushr r2.y, vThreadID.y, l(1)
imad r0.xy, r0.xyxx, r1.xyxx, r2.xyxx
and r2.y, vThreadID.y, l(1)
and r0.y, CB1[1][0].x, l(1023)
ishl r1.z, r1.y, l(1)
and r1.w, CB1[1][0].x, l(1023)
ishl r0.z, r0.y, l(1)
mov r2.x, l(0)
iadd r0.zw, r1.xxxz, r2.xxxy
imul null, r2.xz, r0.xxxx, l(80, 0, 16, 0)
udiv r3.xy, null, r0.zwzz, r2.xzxx
imad r0.x, r3.y, r0.y, r3.x
imad r0.yz, -r3.xxyx, r2.xxzx, r0.zzwz
imul null, r0.w, r2.z, r2.x
imad r0.y, r0.z, r2.x, r0.y
imad r0.x, r0.x, r0.w, r0.y
ushr r0.x, r0.x, l(2)
ubfe r0.y, l(1), l(12), CB1[1][0].x
movc r0.zw, r2.yyyy, l(0,0,0,3), l(0,0,1,0)
movc r0.y, r0.y, r0.z, r0.w
mov r1.w, l(0)
ldms r2.x, r1.xyww, T0[0].xyzw, r0.y
iadd r3.xyzw, r1.xyxy, l(2, 0, 1, 0)
iadd r2.xz, r0.xxzx, r2.xxyx
imul null, r1.xy, r1.xyxx, l(80, 16, 0, 0)
udiv r3.xy, null, r2.xzxx, r1.xyxx
imad r0.z, r3.y, r1.w, r3.x
imad r2.xz, -r3.xxyx, r1.xxyx, r2.xxzx
imul null, r1.y, r1.y, r1.x
imad r1.x, r2.z, r1.x, r2.x
imad r0.z, r0.z, r1.y, r1.x
ushr r0.z, r0.z, l(2)
movc r1.xy, r2.yyyy, l(0,3,0,0), l(1,0,0,0)
movc r1.x, r1.z, r1.x, r1.y
mov r0.w, l(0)
ldms r2.x, r0.xyww, T0[0].xyzw, r1.x
iadd r3.xyzw, r0.xyxy, l(2, 0, 1, 0)
mov r4.xy, r3.zwzz
mov r4.zw, l(0,0,0,0)
ldms r2.y, r4.xyzw, T0[0].yxzw, r0.y
ldms r2.y, r4.xyzw, T0[0].yxzw, r1.x
mov r3.zw, l(0,0,0,0)
ldms r2.z, r3.xyzw, T0[0].yzxw, r0.y
iadd r3.xyzw, r1.xyxy, l(4, 0, 3, 0)
ldms r2.z, r3.xyzw, T0[0].yzxw, r1.x
iadd r3.xyzw, r0.xyxy, l(4, 0, 3, 0)
mov r4.xy, r3.zwzz
mov r4.zw, l(0,0,0,0)
ldms r2.w, r4.xyzw, T0[0].yzwx, r0.y
store_uav_typed U0[0].xyzw, r0.xxxx, r2.xyzw
iadd r0.z, r0.x, l(1)
mov r3.zw, l(0,0,0,0)
ldms r2.x, r3.xyzw, T0[0].xyzw, r0.y
iadd r3.xyzw, r1.xyxy, l(6, 0, 5, 0)
mov r4.xy, r3.zwzz
mov r4.zw, l(0,0,0,0)
ldms r2.y, r4.xyzw, T0[0].yxzw, r0.y
mov r3.zw, l(0,0,0,0)
ldms r2.z, r3.xyzw, T0[0].yzxw, r0.y
iadd r1.xy, r1.xyxx, l(7, 0, 0, 0)
mov r1.zw, l(0,0,0,0)
ldms r2.w, r1.xyzw, T0[0].yzwx, r0.y
ldms r2.w, r4.xyzw, T0[0].yzwx, r1.x
store_uav_typed U0[0].xyzw, r0.zzzz, r2.xyzw
iadd r0.w, r0.z, l(1)
mov r3.zw, l(0,0,0,0)
ldms r2.x, r3.xyzw, T0[0].xyzw, r1.x
iadd r3.xyzw, r0.xyxy, l(6, 0, 5, 0)
mov r4.xy, r3.zwzz
mov r4.zw, l(0,0,0,0)
ldms r2.y, r4.xyzw, T0[0].yxzw, r1.x
mov r3.zw, l(0,0,0,0)
ldms r2.z, r3.xyzw, T0[0].yzxw, r1.x
iadd r3.xy, r0.xyxx, l(7, 0, 0, 0)
mov r3.zw, l(0,0,0,0)
ldms r2.w, r3.xyzw, T0[0].yzwx, r1.x
store_uav_typed U0[0].xyzw, r0.wwww, r2.xyzw
ret
// Approximately 56 instruction slots used
// Approximately 57 instruction slots used
#endif
const BYTE host_depth_store_2xmsaa_cs[] =
{
68, 88, 66, 67, 15, 231,
223, 186, 190, 135, 229, 39,
211, 185, 26, 121, 39, 17,
25, 229, 1, 0, 0, 0,
52, 11, 0, 0, 5, 0,
68, 88, 66, 67, 238, 111,
30, 240, 147, 73, 122, 32,
177, 28, 116, 35, 239, 195,
44, 205, 1, 0, 0, 0,
104, 11, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
172, 2, 0, 0, 188, 2,
0, 0, 204, 2, 0, 0,
152, 10, 0, 0, 82, 68,
204, 10, 0, 0, 82, 68,
69, 70, 112, 2, 0, 0,
2, 0, 0, 0, 92, 1,
0, 0, 4, 0, 0, 0,
@ -232,8 +233,8 @@ const BYTE host_depth_store_2xmsaa_cs[] =
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
196, 7, 0, 0, 81, 0,
5, 0, 241, 1, 0, 0,
248, 7, 0, 0, 81, 0,
5, 0, 254, 1, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
@ -261,324 +262,333 @@ const BYTE host_depth_store_2xmsaa_cs[] =
1, 0, 0, 0, 138, 0,
0, 11, 18, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 10, 0, 0, 0,
1, 64, 0, 0, 20, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 138, 0,
0, 11, 34, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 10, 0,
0, 0, 10, 128, 48, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
138, 0, 0, 11, 34, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 10, 0,
0, 0, 1, 64, 0, 0,
20, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 38, 0, 0, 8,
0, 208, 0, 0, 34, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 79, 0,
0, 6, 34, 0, 16, 0,
38, 0, 0, 8, 0, 208,
0, 0, 18, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 2, 0, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
85, 0, 0, 9, 34, 0,
16, 0, 1, 0, 0, 0,
10, 128, 48, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 80, 0, 0, 6,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 2, 0,
10, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
10, 0, 16, 0, 0, 0,
0, 0, 62, 0, 0, 1,
21, 0, 0, 1, 85, 0,
0, 9, 34, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 10, 0, 0, 0,
54, 0, 0, 7, 18, 0,
16, 0, 1, 0, 0, 0,
10, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 20, 98, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 1, 64, 0, 0,
10, 0, 0, 0, 54, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 140, 0, 0, 20,
50, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
10, 0, 0, 0, 10, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 6, 1, 16, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 138, 0,
0, 17, 114, 0, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
2, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 10, 0,
0, 0, 12, 0, 0, 0,
14, 0, 0, 0, 0, 0,
0, 0, 6, 128, 48, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
41, 0, 0, 6, 18, 0,
16, 0, 1, 0, 0, 0,
16, 0, 2, 0, 0, 0,
10, 0, 2, 0, 1, 64,
0, 0, 3, 0, 0, 0,
85, 0, 0, 6, 34, 0,
16, 0, 1, 0, 0, 0,
16, 0, 2, 0, 0, 0,
26, 0, 2, 0, 1, 64,
0, 0, 1, 0, 0, 0,
35, 0, 0, 9, 50, 0,
16, 0, 1, 0, 0, 0,
150, 5, 16, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 70, 0,
16, 0, 1, 0, 0, 0,
16, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
1, 0, 0, 0, 70, 0,
16, 0, 2, 0, 0, 0,
1, 0, 0, 6, 34, 0,
16, 0, 2, 0, 0, 0,
26, 0, 2, 0, 1, 64,
0, 0, 1, 0, 0, 0,
1, 0, 0, 9, 34, 0,
16, 0, 0, 0, 0, 0,
1, 0, 0, 9, 130, 0,
16, 0, 1, 0, 0, 0,
10, 128, 48, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 255, 3, 0, 0,
41, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 54, 0,
0, 5, 18, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 194, 0,
16, 0, 0, 0, 0, 0,
6, 8, 16, 0, 1, 0,
0, 0, 6, 4, 16, 0,
30, 0, 0, 7, 82, 0,
16, 0, 2, 0, 0, 0,
6, 2, 16, 0, 0, 0,
0, 0, 6, 1, 16, 0,
2, 0, 0, 0, 38, 0,
0, 11, 0, 208, 0, 0,
82, 0, 16, 0, 2, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
0, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
78, 0, 0, 8, 50, 0,
16, 0, 3, 0, 0, 0,
0, 208, 0, 0, 230, 10,
16, 0, 0, 0, 0, 0,
134, 0, 16, 0, 2, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
3, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 35, 0, 0, 10,
98, 0, 16, 0, 0, 0,
0, 0, 6, 1, 16, 128,
65, 0, 0, 0, 3, 0,
0, 0, 6, 2, 16, 0,
2, 0, 0, 0, 166, 11,
16, 0, 0, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 130, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 35, 0, 0, 9,
34, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 85, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
138, 0, 0, 11, 34, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 1, 64, 0, 0,
12, 0, 0, 0, 10, 128,
48, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 55, 0, 0, 15,
194, 0, 16, 0, 0, 0,
0, 0, 86, 5, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 55, 0, 0, 9,
34, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 54, 0, 0, 5,
130, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 18, 0, 16, 0,
2, 0, 0, 0, 70, 15,
16, 0, 1, 0, 0, 0,
70, 126, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 3, 0,
0, 0, 70, 4, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 5, 50, 0,
16, 0, 4, 0, 0, 0,
230, 10, 16, 0, 3, 0,
0, 0, 54, 0, 0, 8,
194, 0, 16, 0, 4, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 34, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 4, 0, 0, 0,
22, 126, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 54, 0, 0, 8,
194, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 66, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
150, 124, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 3, 0,
0, 0, 70, 4, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 5, 50, 0,
16, 0, 4, 0, 0, 0,
230, 10, 16, 0, 3, 0,
0, 0, 54, 0, 0, 8,
194, 0, 16, 0, 4, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 130, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 4, 0, 0, 0,
150, 115, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 164, 0, 0, 8,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 70, 14, 16, 0,
2, 0, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 54, 0, 0, 8,
194, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 18, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
70, 126, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 3, 0,
0, 0, 70, 4, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 6, 0, 0, 0,
0, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 5, 50, 0,
16, 0, 4, 0, 0, 0,
230, 10, 16, 0, 3, 0,
0, 0, 54, 0, 0, 8,
194, 0, 16, 0, 4, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 34, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 4, 0, 0, 0,
22, 126, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 54, 0, 0, 8,
194, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 46, 0,
0, 10, 66, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
150, 124, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 30, 0, 0, 10,
50, 0, 16, 0, 1, 0,
0, 0, 70, 0, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 7, 0, 0, 0,
0, 0, 80, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 8, 194, 0,
78, 0, 0, 8, 50, 0,
16, 0, 3, 0, 0, 0,
0, 208, 0, 0, 134, 0,
16, 0, 2, 0, 0, 0,
70, 0, 16, 0, 1, 0,
0, 0, 35, 0, 0, 9,
66, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
3, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 35, 0, 0, 10,
82, 0, 16, 0, 2, 0,
0, 0, 6, 1, 16, 128,
65, 0, 0, 0, 3, 0,
0, 0, 6, 1, 16, 0,
1, 0, 0, 0, 6, 2,
16, 0, 2, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 34, 0, 16, 0,
1, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
2, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 35, 0, 0, 9,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 85, 0, 0, 7,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
55, 0, 0, 15, 50, 0,
16, 0, 1, 0, 0, 0,
86, 5, 16, 0, 2, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
55, 0, 0, 9, 18, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
54, 0, 0, 5, 130, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
18, 0, 16, 0, 2, 0,
0, 0, 70, 15, 16, 0,
0, 0, 0, 0, 70, 126,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 3, 0, 0, 0,
70, 4, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 54, 0,
0, 5, 50, 0, 16, 0,
4, 0, 0, 0, 230, 10,
16, 0, 3, 0, 0, 0,
54, 0, 0, 8, 194, 0,
16, 0, 4, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
34, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
4, 0, 0, 0, 22, 126,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
54, 0, 0, 8, 194, 0,
16, 0, 3, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
66, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
3, 0, 0, 0, 150, 124,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 3, 0, 0, 0,
70, 4, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 54, 0,
0, 5, 50, 0, 16, 0,
4, 0, 0, 0, 230, 10,
16, 0, 3, 0, 0, 0,
54, 0, 0, 8, 194, 0,
16, 0, 4, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
130, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
1, 0, 0, 0, 150, 115,
4, 0, 0, 0, 150, 115,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
164, 0, 0, 8, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 0, 0, 0, 0,
70, 14, 16, 0, 2, 0,
0, 0, 62, 0, 0, 1,
83, 84, 65, 84, 148, 0,
0, 0, 56, 0, 0, 0,
5, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 7,
130, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
54, 0, 0, 8, 194, 0,
16, 0, 3, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
18, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
3, 0, 0, 0, 70, 126,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 3, 0, 0, 0,
70, 4, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
6, 0, 0, 0, 0, 0,
0, 0, 5, 0, 0, 0,
0, 0, 0, 0, 54, 0,
0, 5, 50, 0, 16, 0,
4, 0, 0, 0, 230, 10,
16, 0, 3, 0, 0, 0,
54, 0, 0, 8, 194, 0,
16, 0, 4, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
34, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
4, 0, 0, 0, 22, 126,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
54, 0, 0, 8, 194, 0,
16, 0, 3, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 46, 0, 0, 10,
66, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
3, 0, 0, 0, 150, 124,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 10, 50, 0,
16, 0, 3, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 54, 0,
0, 8, 194, 0, 16, 0,
3, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
46, 0, 0, 10, 130, 0,
16, 0, 2, 0, 0, 0,
70, 14, 16, 0, 3, 0,
0, 0, 150, 115, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 164, 0,
0, 8, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
0, 0, 0, 0, 70, 14,
16, 0, 2, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
57, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 17, 0, 0, 0,
7, 0, 0, 0, 2, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 16, 0,
0, 0, 7, 0, 0, 0,
2, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
8, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
13, 0, 0, 0, 2, 0,
0, 0, 0, 0, 13, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -589,5 +599,5 @@ const BYTE host_depth_store_2xmsaa_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0
2, 0, 0, 0
};

226
src/xenia/gpu/shaders/bytecode/d3d12_5_1/host_depth_store_4xmsaa_cs.h generated
View File

@ -51,29 +51,31 @@ dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 5
dcl_thread_group 8, 8, 1
ubfe r0.x, l(2), l(10), CB1[1][0].x
ushr r0.y, vThreadID.x, l(1)
ubfe r0.z, l(10), l(20), CB0[0][0].x
imul null, r0.z, r0.x, r0.z
ult r0.y, r0.z, r0.y
if_nz r0.y
ushr r0.x, vThreadID.x, l(1)
ubfe r0.y, l(10), l(20), CB0[0][0].x
iadd r0.y, r0.y, l(1)
ubfe r0.z, l(2), l(10), CB1[1][0].x
imul null, r0.y, r0.z, r0.y
uge r0.x, r0.x, r0.y
if_nz r0.x
ret
endif
ushr r1.y, CB0[0][0].x, l(10)
mov r1.x, CB0[0][0].x
bfi r0.yz, l(0, 10, 10, 0), l(0, 3, 3, 0), r1.xxyx, l(0, 0, 0, 0)
ushr r0.y, CB0[0][0].x, l(10)
mov r0.x, CB0[0][0].x
bfi r0.xy, l(10, 10, 0, 0), l(3, 3, 0, 0), r0.xyxx, l(0, 0, 0, 0)
ubfe r0.zw, l(0, 0, 2, 2), l(0, 0, 10, 12), CB1[1][0].xxxx
ishl r1.x, vThreadID.x, l(2)
ushr r1.y, vThreadID.y, l(1)
imad r1.xy, r0.yzyy, r0.xxxx, r1.xyxx
bfi r0.yz, l(0, 31, 31, 0), l(0, 1, 1, 0), r1.xxyx, vThreadID.xxyx
and r0.w, CB1[1][0].x, l(1023)
imul null, r2.xy, r0.xxxx, l(80, 16, 0, 0)
udiv r2.zw, null, r0.yyyz, r2.xxxy
imad r0.x, r2.w, r0.w, r2.z
imad r0.yz, -r2.zzwz, r2.xxyx, r0.yyzy
imul null, r0.w, r2.y, r2.x
imad r0.y, r0.z, r2.x, r0.y
imad r0.x, r0.x, r0.w, r0.y
imad r1.xy, r0.xyxx, r0.zwzz, r1.xyxx
bfi r0.xy, l(31, 31, 0, 0), l(1, 1, 0, 0), r1.xyxx, vThreadID.xyxx
and r2.x, CB1[1][0].x, l(1023)
imul null, r0.zw, r0.zzzw, l(0, 0, 80, 16)
udiv r2.yz, null, r0.xxyx, r0.zzwz
imad r2.x, r2.z, r2.x, r2.y
imad r0.xy, -r2.yzyy, r0.zwzz, r0.xyxx
imul null, r0.w, r0.w, r0.z
imad r0.x, r0.y, r0.z, r0.x
imad r0.x, r2.x, r0.w, r0.x
ushr r0.x, r0.x, l(2)
bfi r0.y, l(1), l(1), vThreadID.y, l(0)
iadd r0.zw, r0.yyyx, l(0, 0, 1, 1)
@ -95,20 +97,20 @@ ldms r2.z, r1.xyww, T0[0].yzxw, r0.y
ldms r2.w, r1.xyzw, T0[0].yzwx, r0.z
store_uav_typed U0[0].xyzw, r0.wwww, r2.xyzw
ret
// Approximately 44 instruction slots used
// Approximately 46 instruction slots used
#endif
const BYTE host_depth_store_4xmsaa_cs[] =
{
68, 88, 66, 67, 100, 194,
8, 49, 89, 51, 189, 50,
214, 126, 192, 98, 132, 90,
183, 36, 1, 0, 0, 0,
232, 9, 0, 0, 5, 0,
68, 88, 66, 67, 2, 59,
173, 180, 27, 122, 26, 189,
176, 122, 66, 167, 148, 57,
133, 176, 1, 0, 0, 0,
72, 10, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
172, 2, 0, 0, 188, 2,
0, 0, 204, 2, 0, 0,
76, 9, 0, 0, 82, 68,
172, 9, 0, 0, 82, 68,
69, 70, 112, 2, 0, 0,
2, 0, 0, 0, 92, 1,
0, 0, 4, 0, 0, 0,
@ -220,8 +222,8 @@ const BYTE host_depth_store_4xmsaa_cs[] =
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
120, 6, 0, 0, 81, 0,
5, 0, 158, 1, 0, 0,
216, 6, 0, 0, 81, 0,
5, 0, 182, 1, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
@ -246,62 +248,78 @@ const BYTE host_depth_store_4xmsaa_cs[] =
0, 2, 5, 0, 0, 0,
155, 0, 0, 4, 8, 0,
0, 0, 8, 0, 0, 0,
1, 0, 0, 0, 85, 0,
0, 6, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
2, 0, 1, 64, 0, 0,
1, 0, 0, 0, 138, 0,
0, 11, 18, 0, 16, 0,
0, 11, 34, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 10, 0, 0, 0,
1, 64, 0, 0, 20, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 138, 0,
0, 11, 66, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 10, 0,
0, 0, 10, 128, 48, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
85, 0, 0, 6, 34, 0,
16, 0, 0, 0, 0, 0,
10, 0, 2, 0, 1, 64,
0, 0, 1, 0, 0, 0,
138, 0, 0, 11, 66, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 10, 0,
0, 0, 1, 64, 0, 0,
20, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 38, 0, 0, 8,
0, 208, 0, 0, 66, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 79, 0,
0, 7, 34, 0, 16, 0,
38, 0, 0, 8, 0, 208,
0, 0, 34, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
26, 0, 16, 0, 0, 0,
0, 0, 62, 0, 0, 1,
21, 0, 0, 1, 85, 0,
0, 9, 34, 0, 16, 0,
1, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 80, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
31, 0, 4, 3, 10, 0,
16, 0, 0, 0, 0, 0,
62, 0, 0, 1, 21, 0,
0, 1, 85, 0, 0, 9,
34, 0, 16, 0, 0, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
10, 0, 0, 0, 54, 0,
0, 7, 18, 0, 16, 0,
1, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 140, 0, 0, 20,
98, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 10, 0,
1, 64, 0, 0, 10, 0,
0, 0, 54, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 20, 50, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 10, 0,
0, 0, 10, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
6, 1, 16, 0, 1, 0,
0, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 138, 0, 0, 17,
194, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 10, 0,
0, 0, 12, 0, 0, 0,
6, 128, 48, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 41, 0,
0, 6, 18, 0, 16, 0,
1, 0, 0, 0, 10, 0,
@ -312,69 +330,69 @@ const BYTE host_depth_store_4xmsaa_cs[] =
2, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 9, 50, 0, 16, 0,
1, 0, 0, 0, 150, 5,
1, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
230, 10, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
1, 0, 0, 0, 140, 0,
0, 16, 98, 0, 16, 0,
0, 16, 50, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 31, 0, 0, 0,
31, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
31, 0, 0, 0, 31, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 0,
2, 64, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 6, 1, 16, 0,
1, 0, 0, 0, 6, 1,
0, 0, 0, 0, 0, 0,
0, 0, 70, 0, 16, 0,
1, 0, 0, 0, 70, 0,
2, 0, 1, 0, 0, 9,
130, 0, 16, 0, 0, 0,
18, 0, 16, 0, 2, 0,
0, 0, 10, 128, 48, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
1, 64, 0, 0, 255, 3,
0, 0, 38, 0, 0, 11,
0, 208, 0, 0, 50, 0,
16, 0, 2, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 208, 0, 0, 194, 0,
16, 0, 0, 0, 0, 0,
166, 14, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
80, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 78, 0,
0, 8, 194, 0, 16, 0,
0, 0, 80, 0, 0, 0,
16, 0, 0, 0, 78, 0,
0, 8, 98, 0, 16, 0,
2, 0, 0, 0, 0, 208,
0, 0, 86, 9, 16, 0,
0, 0, 0, 0, 6, 4,
16, 0, 2, 0, 0, 0,
0, 0, 6, 1, 16, 0,
0, 0, 0, 0, 166, 11,
16, 0, 0, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
35, 0, 0, 10, 98, 0,
42, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
2, 0, 0, 0, 26, 0,
16, 0, 2, 0, 0, 0,
35, 0, 0, 10, 50, 0,
16, 0, 0, 0, 0, 0,
166, 11, 16, 128, 65, 0,
150, 5, 16, 128, 65, 0,
0, 0, 2, 0, 0, 0,
6, 1, 16, 0, 2, 0,
0, 0, 86, 6, 16, 0,
230, 10, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 38, 0,
0, 8, 0, 208, 0, 0,
130, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
2, 0, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
35, 0, 0, 9, 34, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
2, 0, 0, 0, 26, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 26, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
85, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
@ -498,10 +516,10 @@ const BYTE host_depth_store_4xmsaa_cs[] =
16, 0, 2, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
44, 0, 0, 0, 5, 0,
46, 0, 0, 0, 5, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 12, 0, 0, 0,
0, 0, 13, 0, 0, 0,
7, 0, 0, 0, 2, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,

1345
src/xenia/gpu/shaders/bytecode/d3d12_5_1/primitive_point_list_gs.h generated
View File

File diff suppressed because it is too large Load Diff

562
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_32bpp_3xres_cs.h generated
View File

@ -1,562 +0,0 @@
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
// Buffer Definitions:
//
// cbuffer XeResolveConstants
// {
//
// uint2 xe_resolve_clear_value; // Offset: 0 Size: 8
// uint xe_resolve_edram_info; // Offset: 8 Size: 4
// uint xe_resolve_address_info; // Offset: 12 Size: 4
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim ID HLSL Bind Count
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_resolve_dest UAV uint4 buf U0 u0 1
// XeResolveConstants cbuffer NA NA CB0 cb0 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Input
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Output
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][1], immediateIndexed, space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 3
dcl_thread_group 8, 8, 1
ubfe r0.xy, l(2, 11, 0, 0), l(10, 7, 0, 0), CB0[0][0].zwzz
uge r0.xz, r0.xxxx, l(2, 0, 1, 0)
and r0.w, r0.x, l(1)
ishl r0.y, r0.y, r0.w
uge r0.y, vThreadID.x, r0.y
if_nz r0.y
ret
endif
ishl r1.x, vThreadID.x, l(3)
ushr r2.y, CB0[0][0].w, l(5)
movc r0.xy, r0.xzxx, l(4,4,0,0), l(3,3,0,0)
mov r2.x, CB0[0][0].w
bfi r0.xy, l(5, 2, 0, 0), r0.xyxx, r2.xyxx, l(0, 0, 0, 0)
mov r1.y, vThreadID.y
iadd r0.xy, r0.xyxx, r1.xyxx
ubfe r0.z, l(12), l(13), CB0[0][0].z
and r1.xy, CB0[0][0].zzzz, l(1023, 4096, 0, 0)
udiv r1.zw, null, r0.xxxy, l(0, 0, 80, 16)
imad r0.w, r1.w, r1.x, r1.z
iadd r0.z, r0.w, r0.z
imad r0.xy, -r1.zwzz, l(80, 16, 0, 0), r0.xyxx
if_nz r1.y
uge r0.w, r0.x, l(40)
movc r0.w, r0.w, l(-40), l(40)
iadd r0.x, r0.w, r0.x
endif
imad r0.x, r0.y, l(80), r0.x
imad r0.x, r0.z, l(1280), r0.x
imul null, r0.x, r0.x, l(9)
ushr r0.x, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.xxxx, CB0[0][0].xxxx
iadd r0.y, r0.x, l(1)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xxxx
iadd r1.xyzw, r0.xxxx, l(2, 3, 4, 5)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xxxx
iadd r1.xyzw, r0.xxxx, l(6, 7, 8, 9)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xxxx
iadd r1.xyzw, r0.xxxx, l(10, 11, 12, 13)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xxxx
iadd r1.xyzw, r0.xxxx, l(14, 15, 16, 17)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xxxx
ret
// Approximately 54 instruction slots used
#endif
const BYTE resolve_clear_32bpp_3xres_cs[] =
{
68, 88, 66, 67, 51, 137,
123, 106, 36, 61, 194, 60,
107, 228, 69, 223, 155, 48,
117, 12, 1, 0, 0, 0,
184, 10, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
64, 2, 0, 0, 80, 2,
0, 0, 96, 2, 0, 0,
28, 10, 0, 0, 82, 68,
69, 70, 4, 2, 0, 0,
1, 0, 0, 0, 176, 0,
0, 0, 2, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
220, 1, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 156, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 100, 101, 115, 116, 0,
88, 101, 82, 101, 115, 111,
108, 118, 101, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 156, 0, 0, 0,
3, 0, 0, 0, 200, 0,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 64, 1, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 2, 0, 0, 0,
96, 1, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
132, 1, 0, 0, 8, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 160, 1,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 196, 1,
0, 0, 12, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 160, 1, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 99, 108, 101, 97, 114,
95, 118, 97, 108, 117, 101,
0, 117, 105, 110, 116, 50,
0, 171, 171, 171, 1, 0,
19, 0, 1, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
87, 1, 0, 0, 120, 101,
95, 114, 101, 115, 111, 108,
118, 101, 95, 101, 100, 114,
97, 109, 95, 105, 110, 102,
111, 0, 100, 119, 111, 114,
100, 0, 0, 0, 19, 0,
1, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 154, 1,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 97, 100, 100, 114, 101,
115, 115, 95, 105, 110, 102,
111, 0, 77, 105, 99, 114,
111, 115, 111, 102, 116, 32,
40, 82, 41, 32, 72, 76,
83, 76, 32, 83, 104, 97,
100, 101, 114, 32, 67, 111,
109, 112, 105, 108, 101, 114,
32, 49, 48, 46, 49, 0,
73, 83, 71, 78, 8, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 79, 83,
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
180, 7, 0, 0, 81, 0,
5, 0, 237, 1, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 156, 8, 0, 7,
70, 238, 49, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 68, 68,
0, 0, 0, 0, 0, 0,
95, 0, 0, 2, 50, 0,
2, 0, 104, 0, 0, 2,
3, 0, 0, 0, 155, 0,
0, 4, 8, 0, 0, 0,
8, 0, 0, 0, 1, 0,
0, 0, 138, 0, 0, 17,
50, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
2, 0, 0, 0, 11, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 10, 0, 0, 0,
7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
230, 138, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 80, 0,
0, 10, 82, 0, 16, 0,
0, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 7,
130, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
41, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 80, 0,
0, 6, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
2, 0, 26, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
41, 0, 0, 6, 18, 0,
16, 0, 1, 0, 0, 0,
10, 0, 2, 0, 1, 64,
0, 0, 3, 0, 0, 0,
85, 0, 0, 9, 34, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 5, 0, 0, 0,
55, 0, 0, 15, 50, 0,
16, 0, 0, 0, 0, 0,
134, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 7, 18, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 17, 50, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 5, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 4, 34, 0,
16, 0, 1, 0, 0, 0,
26, 0, 2, 0, 30, 0,
0, 7, 50, 0, 16, 0,
0, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
70, 0, 16, 0, 1, 0,
0, 0, 138, 0, 0, 11,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
12, 0, 0, 0, 1, 64,
0, 0, 13, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 12, 50, 0, 16, 0,
1, 0, 0, 0, 166, 138,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
255, 3, 0, 0, 0, 16,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 78, 0,
0, 11, 194, 0, 16, 0,
1, 0, 0, 0, 0, 208,
0, 0, 6, 4, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 80, 0,
0, 0, 16, 0, 0, 0,
35, 0, 0, 9, 130, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 35, 0,
0, 13, 50, 0, 16, 0,
0, 0, 0, 0, 230, 10,
16, 128, 65, 0, 0, 0,
1, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
26, 0, 16, 0, 1, 0,
0, 0, 80, 0, 0, 7,
130, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 40, 0, 0, 0,
55, 0, 0, 9, 130, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
216, 255, 255, 255, 1, 64,
0, 0, 40, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 21, 0,
0, 1, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 80, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 0, 5, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 38, 0, 0, 8,
0, 208, 0, 0, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
9, 0, 0, 0, 85, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
0, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
3, 0, 0, 0, 4, 0,
0, 0, 5, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
1, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
166, 10, 16, 0, 1, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 246, 15,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 10, 242, 0, 16, 0,
1, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 6, 0,
0, 0, 7, 0, 0, 0,
8, 0, 0, 0, 9, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 1, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 1, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 1, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
10, 0, 0, 0, 11, 0,
0, 0, 12, 0, 0, 0,
13, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
1, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 1, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 14, 0, 0, 0,
15, 0, 0, 0, 16, 0,
0, 0, 17, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
1, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
166, 10, 16, 0, 1, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 246, 15,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 54, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
15, 0, 0, 0, 8, 0,
0, 0, 2, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 18, 0,
0, 0
};

497
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_32bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_32bpp_scaled_cs.h generated
View File

@ -14,6 +14,13 @@
//
// }
//
// cbuffer XeResolveResolutionScaleConstant
// {
//
// uint xe_resolve_resolution_scale; // Offset: 0 Size: 4
//
// }
//
//
// Resource Bindings:
//
@ -21,6 +28,7 @@
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_resolve_dest UAV uint4 buf U0 u0 1
// XeResolveConstants cbuffer NA NA CB0 cb0 1
// XeResolveResolutionScaleConstant cbuffer NA NA CB1 cb1 1
//
//
//
@ -38,6 +46,7 @@
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][1], immediateIndexed, space=0
dcl_constantbuffer CB1[1:1][1], immediateIndexed, space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 3
@ -45,6 +54,8 @@ dcl_thread_group 8, 8, 1
ubfe r0.xy, l(2, 11, 0, 0), l(10, 7, 0, 0), CB0[0][0].zwzz
uge r0.xz, r0.xxxx, l(2, 0, 1, 0)
and r0.w, r0.x, l(1)
and r1.x, CB1[1][0].x, l(3)
imul null, r0.y, r0.y, r1.x
ishl r0.y, r0.y, r0.w
uge r0.y, vThreadID.x, r0.y
if_nz r0.y
@ -52,100 +63,119 @@ if_nz r0.y
endif
ishl r1.x, vThreadID.x, l(3)
ushr r2.y, CB0[0][0].w, l(5)
movc r0.xy, r0.xzxx, l(4,4,0,0), l(3,3,0,0)
mov r2.x, CB0[0][0].w
bfi r0.xy, l(5, 2, 0, 0), r0.xyxx, r2.xyxx, l(0, 0, 0, 0)
and r0.yw, r2.xxxy, l(0, 31, 0, 3)
ushr r2.y, CB1[1][0].x, l(2)
mov r2.x, CB1[1][0].x
and r1.zw, r2.xxxy, l(0, 0, 3, 3)
imul null, r0.yw, r0.yyyw, r1.zzzw
movc r0.xz, r0.xxzx, l(4,0,4,0), l(3,0,3,0)
ishl r0.xy, r0.ywyy, r0.xzxx
mov r1.y, vThreadID.y
iadd r0.xy, r0.xyxx, r1.xyxx
ubfe r0.z, l(12), l(13), CB0[0][0].z
and r1.xy, CB0[0][0].zzzz, l(1023, 4096, 0, 0)
udiv r1.zw, null, r0.xxxy, l(0, 0, 80, 16)
imad r0.w, r1.w, r1.x, r1.z
imul null, r1.zw, r1.zzzw, l(0, 0, 80, 16)
udiv r2.xy, null, r0.xyxx, r1.zwzz
imad r0.w, r2.y, r1.x, r2.x
iadd r0.z, r0.w, r0.z
imad r0.xy, -r1.zwzz, l(80, 16, 0, 0), r0.xyxx
imad r0.xy, -r2.xyxx, r1.zwzz, r0.xyxx
if_nz r1.y
uge r0.w, r0.x, l(40)
movc r0.w, r0.w, l(-40), l(40)
ushr r0.w, r1.z, l(1)
uge r1.x, r0.x, r0.w
ineg r1.y, r0.w
movc r0.w, r1.x, r1.y, r0.w
iadd r0.x, r0.w, r0.x
endif
imad r0.x, r0.y, l(80), r0.x
imad r0.x, r0.z, l(1280), r0.x
imul null, r0.w, r1.w, r1.z
imad r0.x, r0.y, r1.z, r0.x
imad r0.x, r0.z, r0.w, r0.x
ushr r0.x, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.xxxx, CB0[0][0].xxxx
iadd r0.yzw, r0.xxxx, l(0, 1, 3, 7)
iadd r0.y, r0.x, l(1)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xxxx
iadd r1.xyzw, r0.xxxx, l(2, 4, 5, 6)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r0.zzzz, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xxxx
store_uav_typed U0[0].xyzw, r0.wwww, CB0[0][0].xxxx
ret
// Approximately 39 instruction slots used
// Approximately 44 instruction slots used
#endif
const BYTE resolve_clear_32bpp_2xres_cs[] =
const BYTE resolve_clear_32bpp_scaled_cs[] =
{
68, 88, 66, 67, 140, 19,
54, 17, 139, 47, 113, 249,
181, 109, 144, 226, 191, 108,
237, 69, 1, 0, 0, 0,
128, 8, 0, 0, 5, 0,
68, 88, 66, 67, 151, 173,
156, 244, 183, 241, 226, 31,
214, 214, 54, 114, 10, 217,
153, 194, 1, 0, 0, 0,
104, 9, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
64, 2, 0, 0, 80, 2,
0, 0, 96, 2, 0, 0,
228, 7, 0, 0, 82, 68,
69, 70, 4, 2, 0, 0,
1, 0, 0, 0, 176, 0,
0, 0, 2, 0, 0, 0,
228, 2, 0, 0, 244, 2,
0, 0, 4, 3, 0, 0,
204, 8, 0, 0, 82, 68,
69, 70, 168, 2, 0, 0,
2, 0, 0, 0, 248, 0,
0, 0, 3, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
220, 1, 0, 0, 19, 19,
128, 2, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 0, 4, 0,
180, 0, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 156, 0,
0, 0, 0, 0, 196, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 100, 101, 115, 116, 0,
88, 101, 82, 101, 115, 111,
108, 118, 101, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 156, 0, 0, 0,
3, 0, 0, 0, 200, 0,
0, 0, 215, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
120, 101, 95, 114, 101, 115,
111, 108, 118, 101, 95, 100,
101, 115, 116, 0, 88, 101,
82, 101, 115, 111, 108, 118,
101, 67, 111, 110, 115, 116,
97, 110, 116, 115, 0, 88,
101, 82, 101, 115, 111, 108,
118, 101, 82, 101, 115, 111,
108, 117, 116, 105, 111, 110,
83, 99, 97, 108, 101, 67,
111, 110, 115, 116, 97, 110,
116, 0, 196, 0, 0, 0,
3, 0, 0, 0, 40, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 64, 1, 0, 0,
0, 0, 215, 0, 0, 0,
1, 0, 0, 0, 60, 2,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 160, 1, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 2, 0, 0, 0,
96, 1, 0, 0, 0, 0,
192, 1, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
132, 1, 0, 0, 8, 0,
228, 1, 0, 0, 8, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 160, 1,
2, 0, 0, 0, 0, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 196, 1,
0, 0, 0, 0, 36, 2,
0, 0, 12, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 160, 1, 0, 0,
0, 0, 0, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
@ -160,7 +190,7 @@ const BYTE resolve_clear_32bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
87, 1, 0, 0, 120, 101,
183, 1, 0, 0, 120, 101,
95, 114, 101, 115, 111, 108,
118, 101, 95, 101, 100, 114,
97, 109, 95, 105, 110, 102,
@ -170,30 +200,46 @@ const BYTE resolve_clear_32bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 154, 1,
0, 0, 0, 0, 250, 1,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 97, 100, 100, 114, 101,
115, 115, 95, 105, 110, 102,
111, 0, 77, 105, 99, 114,
111, 115, 111, 102, 116, 32,
40, 82, 41, 32, 72, 76,
83, 76, 32, 83, 104, 97,
100, 101, 114, 32, 67, 111,
109, 112, 105, 108, 101, 114,
32, 49, 48, 46, 49, 0,
73, 83, 71, 78, 8, 0,
111, 0, 100, 2, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
0, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
120, 101, 95, 114, 101, 115,
111, 108, 118, 101, 95, 114,
101, 115, 111, 108, 117, 116,
105, 111, 110, 95, 115, 99,
97, 108, 101, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 73, 83, 71, 78,
8, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
79, 83, 71, 78, 8, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 79, 83,
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
124, 5, 0, 0, 81, 0,
5, 0, 95, 1, 0, 0,
106, 8, 0, 1, 89, 0,
8, 0, 0, 0, 83, 72,
69, 88, 192, 5, 0, 0,
81, 0, 5, 0, 112, 1,
0, 0, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 156, 8, 0, 7,
70, 238, 49, 0, 0, 0,
@ -228,54 +274,88 @@ const BYTE resolve_clear_32bpp_2xres_cs[] =
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
41, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 80, 0,
0, 6, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
2, 0, 26, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
41, 0, 0, 6, 18, 0,
1, 0, 0, 9, 18, 0,
16, 0, 1, 0, 0, 0,
10, 0, 2, 0, 1, 64,
0, 0, 3, 0, 0, 0,
85, 0, 0, 9, 34, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
10, 128, 48, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 5, 0, 0, 0,
55, 0, 0, 15, 50, 0,
16, 0, 0, 0, 0, 0,
134, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 34, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 41, 0, 0, 7,
34, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
80, 0, 0, 6, 34, 0,
16, 0, 0, 0, 0, 0,
10, 0, 2, 0, 26, 0,
16, 0, 0, 0, 0, 0,
31, 0, 4, 3, 26, 0,
16, 0, 0, 0, 0, 0,
62, 0, 0, 1, 21, 0,
0, 1, 41, 0, 0, 6,
18, 0, 16, 0, 1, 0,
0, 0, 10, 0, 2, 0,
1, 64, 0, 0, 3, 0,
0, 0, 85, 0, 0, 9,
34, 0, 16, 0, 2, 0,
0, 0, 58, 128, 48, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 7, 18, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 17, 50, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 5, 0, 0, 0,
2, 0, 0, 0, 0, 0,
1, 64, 0, 0, 5, 0,
0, 0, 54, 0, 0, 7,
18, 0, 16, 0, 2, 0,
0, 0, 58, 128, 48, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 10, 162, 0,
16, 0, 0, 0, 0, 0,
6, 4, 16, 0, 2, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 31, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 85, 0,
0, 9, 34, 0, 16, 0,
2, 0, 0, 0, 10, 128,
48, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 54, 0,
0, 7, 18, 0, 16, 0,
2, 0, 0, 0, 10, 128,
48, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 10,
194, 0, 16, 0, 1, 0,
0, 0, 6, 4, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 162, 0, 16, 0,
0, 0, 0, 0, 86, 13,
16, 0, 0, 0, 0, 0,
166, 14, 16, 0, 1, 0,
0, 0, 55, 0, 0, 15,
82, 0, 16, 0, 0, 0,
0, 0, 6, 2, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 41, 0, 0, 7,
50, 0, 16, 0, 0, 0,
0, 0, 214, 5, 16, 0,
0, 0, 0, 0, 134, 0,
16, 0, 0, 0, 0, 0,
54, 0, 0, 4, 34, 0,
16, 0, 1, 0, 0, 0,
26, 0, 2, 0, 30, 0,
@ -298,138 +378,122 @@ const BYTE resolve_clear_32bpp_2xres_cs[] =
0, 0, 2, 64, 0, 0,
255, 3, 0, 0, 0, 16,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 78, 0,
0, 11, 194, 0, 16, 0,
1, 0, 0, 0, 0, 208,
0, 0, 6, 4, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 38, 0,
0, 11, 0, 208, 0, 0,
194, 0, 16, 0, 1, 0,
0, 0, 166, 14, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 80, 0,
0, 0, 16, 0, 0, 0,
35, 0, 0, 9, 130, 0,
78, 0, 0, 8, 50, 0,
16, 0, 2, 0, 0, 0,
0, 208, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 42, 0,
230, 10, 16, 0, 1, 0,
0, 0, 35, 0, 0, 9,
130, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
2, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 7, 66, 0,
10, 0, 16, 0, 2, 0,
0, 0, 30, 0, 0, 7,
66, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 35, 0,
0, 13, 50, 0, 16, 0,
0, 0, 0, 0, 230, 10,
16, 128, 65, 0, 0, 0,
1, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
35, 0, 0, 10, 50, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
26, 0, 16, 0, 1, 0,
70, 0, 16, 128, 65, 0,
0, 0, 2, 0, 0, 0,
230, 10, 16, 0, 1, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 26, 0, 16, 0,
1, 0, 0, 0, 85, 0,
0, 7, 130, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 80, 0, 0, 7,
18, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
40, 0, 0, 5, 34, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 55, 0, 0, 9,
130, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 40, 0, 0, 0,
55, 0, 0, 9, 130, 0,
16, 0, 0, 0, 0, 0,
1, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
216, 255, 255, 255, 1, 64,
0, 0, 40, 0, 0, 0,
30, 0, 0, 7, 18, 0,
0, 0, 30, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 21, 0,
0, 1, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 80, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
21, 0, 0, 1, 38, 0,
0, 8, 0, 208, 0, 0,
130, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 0, 5, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 226, 0,
1, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 3, 0, 0, 0,
7, 0, 0, 0, 164, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
85, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
0, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
4, 0, 0, 0, 5, 0,
0, 0, 6, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
0, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 1, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 7,
34, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 0, 0, 0, 0,
6, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 44, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 0, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
39, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 11, 0, 0, 0,
7, 0, 0, 0, 2, 0,
16, 0, 0, 0, 13, 0,
0, 0, 2, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -437,16 +501,5 @@ const BYTE resolve_clear_32bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0
0, 0
};

724
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_64bpp_3xres_cs.h generated
View File

@ -1,724 +0,0 @@
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
// Buffer Definitions:
//
// cbuffer XeResolveConstants
// {
//
// uint2 xe_resolve_clear_value; // Offset: 0 Size: 8
// uint xe_resolve_edram_info; // Offset: 8 Size: 4
// uint xe_resolve_address_info; // Offset: 12 Size: 4
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim ID HLSL Bind Count
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_resolve_dest UAV uint4 buf U0 u0 1
// XeResolveConstants cbuffer NA NA CB0 cb0 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Input
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Output
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][1], immediateIndexed, space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 3
dcl_thread_group 8, 8, 1
ubfe r0.xy, l(2, 11, 0, 0), l(10, 7, 0, 0), CB0[0][0].zwzz
uge r0.xz, r0.xxxx, l(2, 0, 1, 0)
and r0.w, r0.x, l(1)
ishl r0.y, r0.y, r0.w
uge r0.y, vThreadID.x, r0.y
if_nz r0.y
ret
endif
ishl r1.x, vThreadID.x, l(3)
ushr r2.y, CB0[0][0].w, l(5)
movc r0.xy, r0.xzxx, l(4,4,0,0), l(3,3,0,0)
mov r2.x, CB0[0][0].w
bfi r0.xy, l(5, 2, 0, 0), r0.xyxx, r2.xyxx, l(0, 0, 0, 0)
mov r1.y, vThreadID.y
iadd r0.xy, r0.xyxx, r1.xyxx
ubfe r0.z, l(12), l(13), CB0[0][0].z
and r0.w, CB0[0][0].z, l(1023)
udiv r1.xy, null, r0.xyxx, l(80, 16, 0, 0)
ishl r1.z, r1.x, l(1)
imad r0.w, r1.y, r0.w, r1.z
iadd r0.z, r0.w, r0.z
imad r0.xy, -r1.xyxx, l(80, 16, 0, 0), r0.xyxx
imad r0.x, r0.y, l(80), r0.x
ishl r0.x, r0.x, l(1)
imad r0.x, r0.z, l(1280), r0.x
imul null, r0.x, r0.x, l(9)
ushr r0.x, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.xxxx, CB0[0][0].xyxy
iadd r0.yz, r0.xxxx, l(0, 1, 3, 0)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xyxy
iadd r0.y, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r0.zzzz, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(4, 5, 6, 7)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(8, 9, 10, 11)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(12, 13, 14, 15)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(16, 17, 18, 19)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(20, 21, 22, 23)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(24, 25, 26, 27)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(28, 29, 30, 31)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(32, 33, 34, 35)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
ret
// Approximately 74 instruction slots used
#endif
const BYTE resolve_clear_64bpp_3xres_cs[] =
{
68, 88, 66, 67, 171, 211,
186, 178, 117, 238, 37, 217,
139, 177, 150, 24, 232, 77,
219, 176, 1, 0, 0, 0,
16, 14, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
64, 2, 0, 0, 80, 2,
0, 0, 96, 2, 0, 0,
116, 13, 0, 0, 82, 68,
69, 70, 4, 2, 0, 0,
1, 0, 0, 0, 176, 0,
0, 0, 2, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
220, 1, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 156, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 100, 101, 115, 116, 0,
88, 101, 82, 101, 115, 111,
108, 118, 101, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 156, 0, 0, 0,
3, 0, 0, 0, 200, 0,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 64, 1, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 2, 0, 0, 0,
96, 1, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
132, 1, 0, 0, 8, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 160, 1,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 196, 1,
0, 0, 12, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 160, 1, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 99, 108, 101, 97, 114,
95, 118, 97, 108, 117, 101,
0, 117, 105, 110, 116, 50,
0, 171, 171, 171, 1, 0,
19, 0, 1, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
87, 1, 0, 0, 120, 101,
95, 114, 101, 115, 111, 108,
118, 101, 95, 101, 100, 114,
97, 109, 95, 105, 110, 102,
111, 0, 100, 119, 111, 114,
100, 0, 0, 0, 19, 0,
1, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 154, 1,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 97, 100, 100, 114, 101,
115, 115, 95, 105, 110, 102,
111, 0, 77, 105, 99, 114,
111, 115, 111, 102, 116, 32,
40, 82, 41, 32, 72, 76,
83, 76, 32, 83, 104, 97,
100, 101, 114, 32, 67, 111,
109, 112, 105, 108, 101, 114,
32, 49, 48, 46, 49, 0,
73, 83, 71, 78, 8, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 79, 83,
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
12, 11, 0, 0, 81, 0,
5, 0, 195, 2, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 156, 8, 0, 7,
70, 238, 49, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 68, 68,
0, 0, 0, 0, 0, 0,
95, 0, 0, 2, 50, 0,
2, 0, 104, 0, 0, 2,
3, 0, 0, 0, 155, 0,
0, 4, 8, 0, 0, 0,
8, 0, 0, 0, 1, 0,
0, 0, 138, 0, 0, 17,
50, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
2, 0, 0, 0, 11, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 10, 0, 0, 0,
7, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
230, 138, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 80, 0,
0, 10, 82, 0, 16, 0,
0, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 7,
130, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
41, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 80, 0,
0, 6, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
2, 0, 26, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
41, 0, 0, 6, 18, 0,
16, 0, 1, 0, 0, 0,
10, 0, 2, 0, 1, 64,
0, 0, 3, 0, 0, 0,
85, 0, 0, 9, 34, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 5, 0, 0, 0,
55, 0, 0, 15, 50, 0,
16, 0, 0, 0, 0, 0,
134, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 7, 18, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 17, 50, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 5, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 4, 34, 0,
16, 0, 1, 0, 0, 0,
26, 0, 2, 0, 30, 0,
0, 7, 50, 0, 16, 0,
0, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
70, 0, 16, 0, 1, 0,
0, 0, 138, 0, 0, 11,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
12, 0, 0, 0, 1, 64,
0, 0, 13, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 9, 130, 0, 16, 0,
0, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
255, 3, 0, 0, 78, 0,
0, 11, 50, 0, 16, 0,
1, 0, 0, 0, 0, 208,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
41, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 9, 130, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 13,
50, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 128,
65, 0, 0, 0, 1, 0,
0, 0, 2, 64, 0, 0,
80, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
80, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
41, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 5,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 38, 0,
0, 8, 0, 208, 0, 0,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 9, 0, 0, 0,
85, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
98, 0, 16, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 0, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 7, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 0, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 0, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 10, 242, 0, 16, 0,
1, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 4, 0,
0, 0, 5, 0, 0, 0,
6, 0, 0, 0, 7, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 1, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
8, 0, 0, 0, 9, 0,
0, 0, 10, 0, 0, 0,
11, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 12, 0, 0, 0,
13, 0, 0, 0, 14, 0,
0, 0, 15, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
166, 10, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 246, 15,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 10, 242, 0, 16, 0,
1, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 16, 0,
0, 0, 17, 0, 0, 0,
18, 0, 0, 0, 19, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 1, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
20, 0, 0, 0, 21, 0,
0, 0, 22, 0, 0, 0,
23, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 24, 0, 0, 0,
25, 0, 0, 0, 26, 0,
0, 0, 27, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
166, 10, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 246, 15,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 10, 242, 0, 16, 0,
1, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 28, 0,
0, 0, 29, 0, 0, 0,
30, 0, 0, 0, 31, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 242, 0,
16, 0, 1, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
32, 0, 0, 0, 33, 0,
0, 0, 34, 0, 0, 0,
35, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 1, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 62, 0, 0, 1,
83, 84, 65, 84, 148, 0,
0, 0, 74, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 21, 0,
0, 0, 7, 0, 0, 0,
2, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 36, 0, 0, 0
};

165
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_64bpp_cs.h generated
View File

@ -59,12 +59,11 @@ mov r1.y, vThreadID.y
iadd r0.xy, r0.xyxx, r1.xyxx
ubfe r0.z, l(12), l(13), CB0[0][0].z
and r0.w, CB0[0][0].z, l(1023)
udiv r1.xy, null, r0.xyxx, l(80, 16, 0, 0)
ishl r1.z, r1.x, l(1)
imad r0.w, r1.y, r0.w, r1.z
udiv r1.xy, null, r0.xyxx, l(40, 16, 0, 0)
imad r0.w, r1.y, r0.w, r1.x
iadd r0.z, r0.w, r0.z
imad r0.xy, -r1.xyxx, l(80, 16, 0, 0), r0.xyxx
imad r0.x, r0.y, l(80), r0.x
imad r0.xy, -r1.xyxx, l(40, 16, 0, 0), r0.xyxx
imad r0.x, r0.y, l(40), r0.x
ishl r0.x, r0.x, l(1)
imad r0.x, r0.z, l(1280), r0.x
ushr r0.x, r0.x, l(2)
@ -75,20 +74,20 @@ iadd r0.y, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r0.zzzz, CB0[0][0].xyxy
ret
// Approximately 33 instruction slots used
// Approximately 32 instruction slots used
#endif
const BYTE resolve_clear_64bpp_cs[] =
{
68, 88, 66, 67, 192, 108,
206, 164, 182, 201, 78, 39,
174, 217, 116, 255, 187, 151,
218, 79, 1, 0, 0, 0,
176, 7, 0, 0, 5, 0,
68, 88, 66, 67, 11, 134,
106, 112, 85, 206, 144, 113,
121, 69, 237, 199, 49, 129,
4, 62, 1, 0, 0, 0,
148, 7, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
64, 2, 0, 0, 80, 2,
0, 0, 96, 2, 0, 0,
20, 7, 0, 0, 82, 68,
248, 6, 0, 0, 82, 68,
69, 70, 4, 2, 0, 0,
1, 0, 0, 0, 176, 0,
0, 0, 2, 0, 0, 0,
@ -182,8 +181,8 @@ const BYTE resolve_clear_64bpp_cs[] =
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
172, 4, 0, 0, 81, 0,
5, 0, 43, 1, 0, 0,
144, 4, 0, 0, 81, 0,
5, 0, 36, 1, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
@ -295,108 +294,104 @@ const BYTE resolve_clear_64bpp_cs[] =
1, 0, 0, 0, 0, 208,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
0, 0, 40, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
41, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 9, 130, 0, 16, 0,
0, 0, 0, 0, 26, 0,
35, 0, 0, 9, 130, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 13,
50, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 128,
65, 0, 0, 0, 1, 0,
0, 0, 2, 64, 0, 0,
80, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 35, 0,
0, 13, 50, 0, 16, 0,
0, 0, 0, 0, 70, 0,
16, 128, 65, 0, 0, 0,
1, 0, 0, 0, 2, 64,
0, 0, 40, 0, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 40, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 41, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
80, 0, 0, 0, 10, 0,
0, 5, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
41, 0, 0, 7, 18, 0,
85, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 5,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 85, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 98, 0,
16, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 164, 0,
2, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 7,
34, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
0, 0, 30, 0, 0, 10,
98, 0, 16, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 0, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 30, 0,
0, 7, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
0, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
86, 5, 16, 0, 0, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 62, 0, 0, 1,
83, 84, 65, 84, 148, 0,
0, 0, 33, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 12, 0,
0, 0, 7, 0, 0, 0,
2, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 0, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 32, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 7, 0,
0, 0, 2, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 1, 0,
0, 0, 2, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -406,6 +401,6 @@ const BYTE resolve_clear_64bpp_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0
0, 0, 0, 0, 4, 0,
0, 0
};

511
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_64bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_clear_64bpp_scaled_cs.h generated
View File

@ -14,6 +14,13 @@
//
// }
//
// cbuffer XeResolveResolutionScaleConstant
// {
//
// uint xe_resolve_resolution_scale; // Offset: 0 Size: 4
//
// }
//
//
// Resource Bindings:
//
@ -21,6 +28,7 @@
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_resolve_dest UAV uint4 buf U0 u0 1
// XeResolveConstants cbuffer NA NA CB0 cb0 1
// XeResolveResolutionScaleConstant cbuffer NA NA CB1 cb1 1
//
//
//
@ -38,6 +46,7 @@
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][1], immediateIndexed, space=0
dcl_constantbuffer CB1[1:1][1], immediateIndexed, space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xy
dcl_temps 3
@ -45,6 +54,8 @@ dcl_thread_group 8, 8, 1
ubfe r0.xy, l(2, 11, 0, 0), l(10, 7, 0, 0), CB0[0][0].zwzz
uge r0.xz, r0.xxxx, l(2, 0, 1, 0)
and r0.w, r0.x, l(1)
and r1.x, CB1[1][0].x, l(3)
imul null, r0.y, r0.y, r1.x
ishl r0.y, r0.y, r0.w
uge r0.y, vThreadID.x, r0.y
if_nz r0.y
@ -52,107 +63,117 @@ if_nz r0.y
endif
ishl r1.x, vThreadID.x, l(3)
ushr r2.y, CB0[0][0].w, l(5)
movc r0.xy, r0.xzxx, l(4,4,0,0), l(3,3,0,0)
mov r2.x, CB0[0][0].w
bfi r0.xy, l(5, 2, 0, 0), r0.xyxx, r2.xyxx, l(0, 0, 0, 0)
and r0.yw, r2.xxxy, l(0, 31, 0, 3)
ushr r2.z, CB1[1][0].x, l(2)
mov r2.y, CB1[1][0].x
and r1.zw, r2.yyyz, l(0, 0, 3, 3)
imul null, r0.yw, r0.yyyw, r1.zzzw
movc r0.xz, r0.xxzx, l(4,0,4,0), l(3,0,3,0)
ishl r0.xy, r0.ywyy, r0.xzxx
mov r1.y, vThreadID.y
iadd r0.xy, r0.xyxx, r1.xyxx
ubfe r0.z, l(12), l(13), CB0[0][0].z
and r0.w, CB0[0][0].z, l(1023)
udiv r1.xy, null, r0.xyxx, l(80, 16, 0, 0)
ishl r1.z, r1.x, l(1)
imad r0.w, r1.y, r0.w, r1.z
imul null, r1.yz, r1.zzwz, l(0, 80, 16, 0)
ushr r1.x, r1.y, l(1)
udiv r2.xy, null, r0.xyxx, r1.xzxx
imad r0.w, r2.y, r0.w, r2.x
iadd r0.z, r0.w, r0.z
imad r0.xy, -r1.xyxx, l(80, 16, 0, 0), r0.xyxx
imad r0.x, r0.y, l(80), r0.x
imad r0.xy, -r2.xyxx, r1.xzxx, r0.xyxx
imul null, r0.w, r1.z, r1.y
imad r0.x, r0.y, r1.x, r0.x
ishl r0.x, r0.x, l(1)
imad r0.x, r0.z, l(1280), r0.x
imad r0.x, r0.z, r0.w, r0.x
ushr r0.x, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.xxxx, CB0[0][0].xyxy
iadd r1.xyzw, r0.xxxx, l(1, 3, 7, 15)
store_uav_typed U0[0].xyzw, r1.xxxx, CB0[0][0].xyxy
iadd r2.xyzw, r0.xxxx, l(2, 4, 5, 6)
store_uav_typed U0[0].xyzw, r2.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r2.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r2.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r2.wwww, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.zzzz, CB0[0][0].xyxy
iadd r2.xyzw, r0.xxxx, l(8, 9, 10, 11)
store_uav_typed U0[0].xyzw, r2.xxxx, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r2.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r2.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r2.wwww, CB0[0][0].xyxy
iadd r0.yzw, r0.xxxx, l(0, 12, 13, 14)
iadd r0.yz, r0.xxxx, l(0, 1, 3, 0)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xyxy
iadd r0.y, r0.x, l(2)
store_uav_typed U0[0].xyzw, r0.yyyy, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r0.zzzz, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r0.wwww, CB0[0][0].xyxy
store_uav_typed U0[0].xyzw, r1.wwww, CB0[0][0].xyxy
ret
// Approximately 46 instruction slots used
// Approximately 42 instruction slots used
#endif
const BYTE resolve_clear_64bpp_2xres_cs[] =
const BYTE resolve_clear_64bpp_scaled_cs[] =
{
68, 88, 66, 67, 83, 196,
195, 117, 81, 175, 248, 206,
212, 200, 214, 225, 96, 167,
204, 10, 1, 0, 0, 0,
208, 9, 0, 0, 5, 0,
68, 88, 66, 67, 226, 249,
231, 177, 11, 141, 42, 153,
99, 45, 131, 104, 152, 194,
26, 176, 1, 0, 0, 0,
112, 9, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
64, 2, 0, 0, 80, 2,
0, 0, 96, 2, 0, 0,
52, 9, 0, 0, 82, 68,
69, 70, 4, 2, 0, 0,
1, 0, 0, 0, 176, 0,
0, 0, 2, 0, 0, 0,
228, 2, 0, 0, 244, 2,
0, 0, 4, 3, 0, 0,
212, 8, 0, 0, 82, 68,
69, 70, 168, 2, 0, 0,
2, 0, 0, 0, 248, 0,
0, 0, 3, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
220, 1, 0, 0, 19, 19,
128, 2, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 0, 4, 0,
180, 0, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 156, 0,
0, 0, 0, 0, 196, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 100, 101, 115, 116, 0,
88, 101, 82, 101, 115, 111,
108, 118, 101, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 156, 0, 0, 0,
3, 0, 0, 0, 200, 0,
0, 0, 215, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
120, 101, 95, 114, 101, 115,
111, 108, 118, 101, 95, 100,
101, 115, 116, 0, 88, 101,
82, 101, 115, 111, 108, 118,
101, 67, 111, 110, 115, 116,
97, 110, 116, 115, 0, 88,
101, 82, 101, 115, 111, 108,
118, 101, 82, 101, 115, 111,
108, 117, 116, 105, 111, 110,
83, 99, 97, 108, 101, 67,
111, 110, 115, 116, 97, 110,
116, 0, 196, 0, 0, 0,
3, 0, 0, 0, 40, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 64, 1, 0, 0,
0, 0, 215, 0, 0, 0,
1, 0, 0, 0, 60, 2,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 160, 1, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 2, 0, 0, 0,
96, 1, 0, 0, 0, 0,
192, 1, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
132, 1, 0, 0, 8, 0,
228, 1, 0, 0, 8, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 160, 1,
2, 0, 0, 0, 0, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 196, 1,
0, 0, 0, 0, 36, 2,
0, 0, 12, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 160, 1, 0, 0,
0, 0, 0, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
@ -167,7 +188,7 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
87, 1, 0, 0, 120, 101,
183, 1, 0, 0, 120, 101,
95, 114, 101, 115, 111, 108,
118, 101, 95, 101, 100, 114,
97, 109, 95, 105, 110, 102,
@ -177,30 +198,46 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 154, 1,
0, 0, 0, 0, 250, 1,
0, 0, 120, 101, 95, 114,
101, 115, 111, 108, 118, 101,
95, 97, 100, 100, 114, 101,
115, 115, 95, 105, 110, 102,
111, 0, 77, 105, 99, 114,
111, 115, 111, 102, 116, 32,
40, 82, 41, 32, 72, 76,
83, 76, 32, 83, 104, 97,
100, 101, 114, 32, 67, 111,
109, 112, 105, 108, 101, 114,
32, 49, 48, 46, 49, 0,
73, 83, 71, 78, 8, 0,
111, 0, 100, 2, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
0, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
120, 101, 95, 114, 101, 115,
111, 108, 118, 101, 95, 114,
101, 115, 111, 108, 117, 116,
105, 111, 110, 95, 115, 99,
97, 108, 101, 0, 77, 105,
99, 114, 111, 115, 111, 102,
116, 32, 40, 82, 41, 32,
72, 76, 83, 76, 32, 83,
104, 97, 100, 101, 114, 32,
67, 111, 109, 112, 105, 108,
101, 114, 32, 49, 48, 46,
49, 0, 73, 83, 71, 78,
8, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
79, 83, 71, 78, 8, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 79, 83,
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 83, 72, 69, 88,
204, 6, 0, 0, 81, 0,
5, 0, 179, 1, 0, 0,
106, 8, 0, 1, 89, 0,
8, 0, 0, 0, 83, 72,
69, 88, 200, 5, 0, 0,
81, 0, 5, 0, 114, 1,
0, 0, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 156, 8, 0, 7,
70, 238, 49, 0, 0, 0,
@ -235,54 +272,88 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
41, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 80, 0,
0, 6, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
2, 0, 26, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
41, 0, 0, 6, 18, 0,
1, 0, 0, 9, 18, 0,
16, 0, 1, 0, 0, 0,
10, 0, 2, 0, 1, 64,
0, 0, 3, 0, 0, 0,
85, 0, 0, 9, 34, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
10, 128, 48, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 5, 0, 0, 0,
55, 0, 0, 15, 50, 0,
16, 0, 0, 0, 0, 0,
134, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 34, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 41, 0, 0, 7,
34, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
80, 0, 0, 6, 34, 0,
16, 0, 0, 0, 0, 0,
10, 0, 2, 0, 26, 0,
16, 0, 0, 0, 0, 0,
31, 0, 4, 3, 26, 0,
16, 0, 0, 0, 0, 0,
62, 0, 0, 1, 21, 0,
0, 1, 41, 0, 0, 6,
18, 0, 16, 0, 1, 0,
0, 0, 10, 0, 2, 0,
1, 64, 0, 0, 3, 0,
0, 0, 85, 0, 0, 9,
34, 0, 16, 0, 2, 0,
0, 0, 58, 128, 48, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 7, 18, 0,
16, 0, 2, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 17, 50, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 5, 0, 0, 0,
2, 0, 0, 0, 0, 0,
1, 64, 0, 0, 5, 0,
0, 0, 54, 0, 0, 7,
18, 0, 16, 0, 2, 0,
0, 0, 58, 128, 48, 0,
0, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 10, 162, 0,
16, 0, 0, 0, 0, 0,
6, 4, 16, 0, 2, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 31, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 85, 0,
0, 9, 66, 0, 16, 0,
2, 0, 0, 0, 10, 128,
48, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 54, 0,
0, 7, 34, 0, 16, 0,
2, 0, 0, 0, 10, 128,
48, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 10,
194, 0, 16, 0, 1, 0,
0, 0, 86, 9, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 3, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 162, 0, 16, 0,
0, 0, 0, 0, 86, 13,
16, 0, 0, 0, 0, 0,
166, 14, 16, 0, 1, 0,
0, 0, 55, 0, 0, 15,
82, 0, 16, 0, 0, 0,
0, 0, 6, 2, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 41, 0, 0, 7,
50, 0, 16, 0, 0, 0,
0, 0, 214, 5, 16, 0,
0, 0, 0, 0, 134, 0,
16, 0, 0, 0, 0, 0,
54, 0, 0, 4, 34, 0,
16, 0, 1, 0, 0, 0,
26, 0, 2, 0, 30, 0,
@ -303,161 +374,81 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
255, 3, 0, 0, 78, 0,
0, 11, 50, 0, 16, 0,
1, 0, 0, 0, 0, 208,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 80, 0, 0, 0,
16, 0, 0, 0, 0, 0,
255, 3, 0, 0, 38, 0,
0, 11, 0, 208, 0, 0,
98, 0, 16, 0, 1, 0,
0, 0, 166, 11, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
41, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 9, 130, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 13,
50, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 128,
65, 0, 0, 0, 1, 0,
0, 0, 2, 64, 0, 0,
80, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
85, 0, 0, 7, 18, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 78, 0,
0, 8, 50, 0, 16, 0,
2, 0, 0, 0, 0, 208,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 134, 0,
16, 0, 1, 0, 0, 0,
35, 0, 0, 9, 130, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 35, 0,
0, 10, 50, 0, 16, 0,
0, 0, 0, 0, 70, 0,
16, 128, 65, 0, 0, 0,
2, 0, 0, 0, 134, 0,
16, 0, 1, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 38, 0, 0, 8,
0, 208, 0, 0, 130, 0,
16, 0, 0, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
80, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
41, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 35, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 42, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 5,
10, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 1, 0, 0, 0,
3, 0, 0, 0, 7, 0,
0, 0, 15, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 10, 242, 0, 16, 0,
2, 0, 0, 0, 6, 0,
0, 0, 0, 0, 41, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 2, 0,
0, 0, 4, 0, 0, 0,
5, 0, 0, 0, 6, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 2, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 1, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
2, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
166, 10, 16, 0, 2, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 246, 15,
16, 0, 2, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 10,
242, 0, 16, 0, 2, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 8, 0, 0, 0,
9, 0, 0, 0, 10, 0,
0, 0, 11, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 85, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 2, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
2, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
166, 10, 16, 0, 2, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 246, 15,
16, 0, 2, 0, 0, 0,
16, 0, 0, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 10, 226, 0, 16, 0,
0, 10, 98, 0, 16, 0,
0, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 12, 0, 0, 0,
13, 0, 0, 0, 14, 0,
0, 0, 1, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -465,33 +456,31 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
164, 0, 0, 10, 242, 224,
33, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
30, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
70, 132, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 164, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 164, 0,
0, 10, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
0, 0, 86, 5, 16, 0,
0, 0, 0, 0, 70, 132,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 10,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 1, 0,
166, 10, 16, 0, 0, 0,
0, 0, 70, 132, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
46, 0, 0, 0, 3, 0,
42, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 14, 0, 0, 0,
6, 0, 0, 0, 2, 0,
0, 0, 16, 0, 0, 0,
12, 0, 0, 0, 2, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -499,7 +488,7 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 3, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -511,5 +500,5 @@ const BYTE resolve_clear_64bpp_2xres_cs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
16, 0, 0, 0
4, 0, 0, 0
};

12
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_1x2xmsaa_cs.h generated
View File

@ -134,7 +134,7 @@ if_nz r1.y
ishr r5.xyzw, r0.zwzw, l(4, 5, 3, 3)
ishr r1.w, r1.y, l(2)
ushr r1.z, r1.z, l(4)
and r1.z, r1.z, l(0x00007ffe)
and r1.z, r1.z, l(2046)
imad r1.z, r1.w, r1.z, r5.x
ushr r3.x, r1.x, l(5)
imad r1.z, r1.z, r3.x, r5.y
@ -214,10 +214,10 @@ ret
const BYTE resolve_fast_32bpp_1x2xmsaa_cs[] =
{
68, 88, 66, 67, 170, 170,
165, 130, 168, 176, 195, 98,
149, 147, 242, 194, 180, 42,
229, 247, 1, 0, 0, 0,
68, 88, 66, 67, 155, 144,
108, 102, 32, 219, 74, 112,
191, 128, 193, 179, 111, 166,
110, 225, 1, 0, 0, 0,
156, 24, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
208, 2, 0, 0, 224, 2,
@ -809,7 +809,7 @@ const BYTE resolve_fast_32bpp_1x2xmsaa_cs[] =
66, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 254, 127, 0, 0,
0, 0, 254, 7, 0, 0,
35, 0, 0, 9, 66, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 1, 0,

2085
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_1x2xmsaa_scaled_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1908
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_3xres_1x2xmsaa_cs.h generated
View File

File diff suppressed because it is too large Load Diff

2037
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_3xres_4xmsaa_cs.h generated
View File

File diff suppressed because it is too large Load Diff

12
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_4xmsaa_cs.h generated
View File

@ -145,7 +145,7 @@ if_nz r1.y
ishr r5.xyzw, r0.zwzw, l(4, 5, 3, 3)
ishr r1.w, r1.y, l(2)
ushr r1.z, r1.z, l(4)
and r1.z, r1.z, l(0x00007ffe)
and r1.z, r1.z, l(2046)
imad r1.z, r1.w, r1.z, r5.x
ushr r3.x, r1.x, l(5)
imad r1.z, r1.z, r3.x, r5.y
@ -225,10 +225,10 @@ ret
const BYTE resolve_fast_32bpp_4xmsaa_cs[] =
{
68, 88, 66, 67, 157, 47,
205, 189, 191, 234, 36, 109,
43, 57, 16, 89, 240, 4,
171, 220, 1, 0, 0, 0,
68, 88, 66, 67, 83, 123,
16, 172, 13, 23, 165, 181,
111, 176, 230, 199, 227, 113,
202, 160, 1, 0, 0, 0,
196, 25, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
208, 2, 0, 0, 224, 2,
@ -869,7 +869,7 @@ const BYTE resolve_fast_32bpp_4xmsaa_cs[] =
0, 7, 66, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 254, 127,
1, 64, 0, 0, 254, 7,
0, 0, 35, 0, 0, 9,
66, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,

1675
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_32bpp_4xmsaa_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

1216
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_64bpp_1x2xmsaa_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1510
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_64bpp_1x2xmsaa_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

1232
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_64bpp_2xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

2366
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_64bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1122
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_64bpp_4xmsaa_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1510
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_fast_64bpp_4xmsaa_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

2783
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_128bpp_cs.h generated
View File

File diff suppressed because it is too large Load Diff

12101
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_128bpp_from_32bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

5741
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_128bpp_from_64bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

4781
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_128bpp_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

4733
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_16bpp_cs.h generated
View File

File diff suppressed because it is too large Load Diff

50463
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_16bpp_from_32bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

24573
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_16bpp_from_64bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

11978
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_16bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_16bpp_scaled_cs.h generated
View File

File diff suppressed because it is too large Load Diff

4735
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_32bpp_cs.h generated
View File

File diff suppressed because it is too large Load Diff

26039
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_32bpp_from_32bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

13057
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_32bpp_from_64bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

11791
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_128bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_32bpp_scaled_cs.h generated
View File

File diff suppressed because it is too large Load Diff

7123
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_64bpp_2xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

4735
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_64bpp_cs.h generated
View File

File diff suppressed because it is too large Load Diff

12292
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_64bpp_from_32bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

6133
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_64bpp_from_64bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

11722
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_32bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_64bpp_scaled_cs.h generated
View File

File diff suppressed because it is too large Load Diff

31704
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_8bpp_3xres_cs.h generated
View File

File diff suppressed because it is too large Load Diff

3317
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_8bpp_cs.h generated
View File

File diff suppressed because it is too large Load Diff

6770
src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_8bpp_2xres_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/resolve_full_8bpp_scaled_cs.h generated
View File

File diff suppressed because it is too large Load Diff

386
src/xenia/gpu/shaders/bytecode/d3d12_5_1/tessellation_adaptive_vs.h generated
View File

@ -28,11 +28,11 @@
// uint xe_textures_resolved; // Offset: 224 Size: 4 [unused]
// float xe_alpha_test_reference; // Offset: 228 Size: 4 [unused]
// uint xe_alpha_to_mask; // Offset: 232 Size: 4 [unused]
// uint xe_edram_pitch_tiles; // Offset: 236 Size: 4 [unused]
// uint xe_edram_32bpp_tile_pitch_dwords_scaled;// Offset: 236 Size: 4 [unused]
// float4 xe_color_exp_bias; // Offset: 240 Size: 16 [unused]
// float2 xe_edram_poly_offset_front; // Offset: 256 Size: 8 [unused]
// float2 xe_edram_poly_offset_back; // Offset: 264 Size: 8 [unused]
// uint xe_edram_depth_base_dwords; // Offset: 272 Size: 4 [unused]
// uint xe_edram_depth_base_dwords_scaled;// Offset: 272 Size: 4 [unused]
// uint4 xe_edram_stencil[2]; // Offset: 288 Size: 32 [unused]
// uint4 xe_edram_rt_base_dwords_scaled;// Offset: 320 Size: 16 [unused]
// uint4 xe_edram_rt_format_flags; // Offset: 336 Size: 16 [unused]
@ -94,21 +94,21 @@ ret
const BYTE tessellation_adaptive_vs[] =
{
68, 88, 66, 67, 70, 199,
99, 28, 252, 60, 232, 131,
32, 27, 138, 155, 32, 225,
78, 128, 1, 0, 0, 0,
176, 13, 0, 0, 5, 0,
68, 88, 66, 67, 223, 69,
21, 252, 96, 81, 180, 155,
11, 146, 181, 238, 118, 211,
188, 154, 1, 0, 0, 0,
196, 13, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
164, 10, 0, 0, 216, 10,
0, 0, 16, 11, 0, 0,
20, 13, 0, 0, 82, 68,
69, 70, 104, 10, 0, 0,
184, 10, 0, 0, 236, 10,
0, 0, 36, 11, 0, 0,
40, 13, 0, 0, 82, 68,
69, 70, 124, 10, 0, 0,
1, 0, 0, 0, 120, 0,
0, 0, 1, 0, 0, 0,
60, 0, 0, 0, 1, 5,
254, 255, 0, 5, 4, 0,
62, 10, 0, 0, 19, 19,
82, 10, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
@ -268,76 +268,76 @@ const BYTE tessellation_adaptive_vs[] =
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
119, 8, 0, 0, 240, 0,
138, 8, 0, 0, 240, 0,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 140, 8,
0, 0, 0, 0, 156, 8,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 176, 8,
0, 0, 0, 0, 192, 8,
0, 0, 0, 1, 0, 0,
8, 0, 0, 0, 0, 0,
0, 0, 232, 5, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 203, 8, 0, 0,
0, 0, 219, 8, 0, 0,
8, 1, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
232, 5, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
229, 8, 0, 0, 16, 1,
245, 8, 0, 0, 16, 1,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 160, 5,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 0, 9,
0, 0, 0, 0, 23, 9,
0, 0, 32, 1, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 20, 9, 0, 0,
0, 0, 40, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 56, 9, 0, 0,
0, 0, 76, 9, 0, 0,
64, 1, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
88, 9, 0, 0, 0, 0,
108, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
124, 9, 0, 0, 80, 1,
144, 9, 0, 0, 80, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 149, 9,
0, 0, 0, 0, 169, 9,
0, 0, 96, 1, 0, 0,
64, 0, 0, 0, 0, 0,
0, 0, 168, 9, 0, 0,
0, 0, 188, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 204, 9, 0, 0,
0, 0, 224, 9, 0, 0,
160, 1, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
228, 9, 0, 0, 0, 0,
248, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
8, 10, 0, 0, 192, 1,
28, 10, 0, 0, 192, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 38, 10,
0, 0, 0, 0, 58, 10,
0, 0, 208, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 140, 8, 0, 0,
0, 0, 156, 8, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
@ -463,34 +463,72 @@ const BYTE tessellation_adaptive_vs[] =
97, 95, 116, 111, 95, 109,
97, 115, 107, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 112, 105, 116, 99, 104,
95, 116, 105, 108, 101, 115,
0, 120, 101, 95, 99, 111,
108, 111, 114, 95, 101, 120,
112, 95, 98, 105, 97, 115,
0, 171, 171, 171, 1, 0,
3, 0, 1, 0, 4, 0,
95, 51, 50, 98, 112, 112,
95, 116, 105, 108, 101, 95,
112, 105, 116, 99, 104, 95,
100, 119, 111, 114, 100, 115,
95, 115, 99, 97, 108, 101,
100, 0, 120, 101, 95, 99,
111, 108, 111, 114, 95, 101,
120, 112, 95, 98, 105, 97,
115, 0, 1, 0, 3, 0,
1, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
172, 6, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 112, 111, 108, 121, 95,
111, 102, 102, 115, 101, 116,
95, 102, 114, 111, 110, 116,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
111, 108, 121, 95, 111, 102,
102, 115, 101, 116, 95, 102,
114, 111, 110, 116, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 112, 111, 108, 121,
95, 111, 102, 102, 115, 101,
116, 95, 98, 97, 99, 107,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 112, 111,
108, 121, 95, 111, 102, 102,
115, 101, 116, 95, 98, 97,
99, 107, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
100, 101, 112, 116, 104, 95,
98, 97, 115, 101, 95, 100,
119, 111, 114, 100, 115, 0,
114, 97, 109, 95, 100, 101,
112, 116, 104, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 95, 115, 99,
97, 108, 101, 100, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 115, 116, 101, 110,
99, 105, 108, 0, 1, 0,
19, 0, 1, 0, 4, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 95, 115, 99,
97, 108, 101, 100, 0, 171,
1, 0, 19, 0, 1, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 115, 116, 101,
110, 99, 105, 108, 0, 171,
97, 109, 95, 114, 116, 95,
102, 111, 114, 109, 97, 116,
95, 102, 108, 97, 103, 115,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 114, 116,
95, 99, 108, 97, 109, 112,
0, 171, 1, 0, 3, 0,
1, 0, 4, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 107, 101, 101, 112,
95, 109, 97, 115, 107, 0,
171, 171, 1, 0, 19, 0,
1, 0, 4, 0, 2, 0,
0, 0, 0, 0, 0, 0,
@ -499,174 +537,139 @@ const BYTE tessellation_adaptive_vs[] =
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 171, 1, 0,
19, 0, 1, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 102, 111,
114, 109, 97, 116, 95, 102,
108, 97, 103, 115, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 114, 116, 95, 99,
108, 97, 109, 112, 0, 171,
1, 0, 3, 0, 1, 0,
4, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
107, 101, 101, 112, 95, 109,
97, 115, 107, 0, 171, 171,
1, 0, 19, 0, 1, 0,
4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
98, 108, 101, 110, 100, 95,
102, 97, 99, 116, 111, 114,
115, 95, 111, 112, 115, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 98, 108, 101,
110, 100, 95, 99, 111, 110,
115, 116, 97, 110, 116, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 171, 171,
73, 83, 71, 78, 44, 0,
116, 95, 98, 108, 101, 110,
100, 95, 102, 97, 99, 116,
111, 114, 115, 95, 111, 112,
115, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 98,
108, 101, 110, 100, 95, 99,
111, 110, 115, 116, 97, 110,
116, 0, 77, 105, 99, 114,
111, 115, 111, 102, 116, 32,
40, 82, 41, 32, 72, 76,
83, 76, 32, 83, 104, 97,
100, 101, 114, 32, 67, 111,
109, 112, 105, 108, 101, 114,
32, 49, 48, 46, 49, 0,
171, 171, 73, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 6, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 1, 0, 0,
83, 86, 95, 86, 101, 114,
116, 101, 120, 73, 68, 0,
79, 83, 71, 78, 48, 0,
0, 0, 1, 0, 0, 0,
8, 0, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
6, 0, 0, 0, 1, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 1, 0, 0, 83, 86,
95, 86, 101, 114, 116, 101,
120, 73, 68, 0, 79, 83,
71, 78, 48, 0, 0, 0,
1, 0, 0, 0, 8, 0,
0, 0, 32, 0, 0, 0,
1, 14, 0, 0, 88, 69,
84, 69, 83, 83, 70, 65,
67, 84, 79, 82, 0, 171,
171, 171, 83, 72, 69, 88,
252, 1, 0, 0, 81, 0,
1, 0, 127, 0, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 14,
0, 0, 88, 69, 84, 69,
83, 83, 70, 65, 67, 84,
79, 82, 0, 171, 171, 171,
83, 72, 69, 88, 252, 1,
0, 0, 81, 0, 1, 0,
127, 0, 0, 0, 106, 8,
0, 1, 89, 0, 0, 7,
70, 142, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
96, 0, 0, 4, 18, 16,
2, 0, 0, 0, 0, 0,
0, 0, 96, 0, 0, 4,
18, 16, 16, 0, 0, 0,
0, 0, 6, 0, 0, 0,
101, 0, 0, 3, 18, 32,
16, 0, 0, 0, 0, 0,
6, 0, 0, 0, 101, 0,
0, 3, 18, 32, 16, 0,
0, 0, 0, 0, 104, 0,
0, 2, 1, 0, 0, 0,
32, 0, 0, 12, 114, 0,
16, 0, 0, 0, 0, 0,
6, 128, 48, 0, 0, 0,
104, 0, 0, 2, 1, 0,
0, 0, 32, 0, 0, 12,
114, 0, 16, 0, 0, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 2, 64,
0, 0, 1, 0, 0, 0,
2, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
60, 0, 0, 7, 50, 0,
2, 64, 0, 0, 1, 0,
0, 0, 2, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 60, 0, 0, 7,
50, 0, 16, 0, 0, 0,
0, 0, 150, 5, 16, 0,
0, 0, 0, 0, 70, 0,
16, 0, 0, 0, 0, 0,
150, 5, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 10, 0, 16, 0,
0, 0, 0, 0, 41, 0,
0, 7, 18, 0, 16, 0,
31, 0, 4, 3, 10, 0,
16, 0, 0, 0, 0, 0,
41, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 16, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
8, 0, 0, 0, 85, 0,
0, 7, 66, 0, 16, 0,
0, 0, 0, 0, 10, 16,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 8, 0,
0, 0, 85, 0, 0, 7,
66, 0, 16, 0, 0, 0,
0, 0, 1, 0, 0, 10,
82, 0, 16, 0, 0, 0,
0, 0, 6, 2, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 255, 0, 255,
0, 0, 0, 0, 255, 0,
255, 0, 0, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 18, 0,
0, 1, 54, 0, 0, 5,
18, 0, 16, 0, 0, 0,
0, 0, 10, 16, 16, 0,
0, 0, 0, 0, 21, 0,
0, 1, 31, 0, 4, 3,
26, 0, 16, 0, 0, 0,
0, 0, 85, 0, 0, 7,
34, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 8, 0, 0, 0,
1, 0, 0, 10, 82, 0,
0, 0, 16, 0, 0, 0,
140, 0, 0, 11, 18, 0,
16, 0, 0, 0, 0, 0,
6, 2, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 255, 0, 255, 0, 0,
0, 0, 255, 0, 255, 0,
0, 0, 0, 0, 30, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 42, 0,
1, 64, 0, 0, 16, 0,
0, 0, 1, 64, 0, 0,
16, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 18, 0, 0, 1,
54, 0, 0, 5, 18, 0,
16, 0, 0, 0, 0, 0,
10, 16, 16, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 21, 0, 0, 1,
31, 0, 4, 3, 26, 0,
16, 0, 0, 0, 0, 0,
85, 0, 0, 7, 34, 0,
0, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
16, 0, 0, 0, 140, 0,
0, 11, 18, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 16, 0, 0, 0,
1, 64, 0, 0, 16, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
21, 0, 0, 1, 0, 0,
0, 7, 18, 0, 16, 0,
0, 0, 128, 63, 52, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 0,
128, 63, 52, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 26, 128,
48, 0, 0, 0, 0, 0,
26, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 51, 0, 0, 9,
18, 32, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 51, 0,
0, 9, 18, 32, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 62, 0, 0, 1,
83, 84, 65, 84, 148, 0,
0, 0, 18, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 18, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 3, 0, 0, 0,
3, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
3, 0, 0, 0, 3, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 2, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -677,5 +680,6 @@ const BYTE tessellation_adaptive_vs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0,
0, 0
};

405
src/xenia/gpu/shaders/bytecode/d3d12_5_1/tessellation_indexed_vs.h generated
View File

@ -28,11 +28,11 @@
// uint xe_textures_resolved; // Offset: 224 Size: 4 [unused]
// float xe_alpha_test_reference; // Offset: 228 Size: 4 [unused]
// uint xe_alpha_to_mask; // Offset: 232 Size: 4 [unused]
// uint xe_edram_pitch_tiles; // Offset: 236 Size: 4 [unused]
// uint xe_edram_32bpp_tile_pitch_dwords_scaled;// Offset: 236 Size: 4 [unused]
// float4 xe_color_exp_bias; // Offset: 240 Size: 16 [unused]
// float2 xe_edram_poly_offset_front; // Offset: 256 Size: 8 [unused]
// float2 xe_edram_poly_offset_back; // Offset: 264 Size: 8 [unused]
// uint xe_edram_depth_base_dwords; // Offset: 272 Size: 4 [unused]
// uint xe_edram_depth_base_dwords_scaled;// Offset: 272 Size: 4 [unused]
// uint4 xe_edram_stencil[2]; // Offset: 288 Size: 32 [unused]
// uint4 xe_edram_rt_base_dwords_scaled;// Offset: 320 Size: 16 [unused]
// uint4 xe_edram_rt_format_flags; // Offset: 336 Size: 16 [unused]
@ -96,21 +96,21 @@ ret
const BYTE tessellation_indexed_vs[] =
{
68, 88, 66, 67, 60, 224,
57, 68, 167, 116, 52, 132,
26, 150, 9, 56, 212, 153,
92, 66, 1, 0, 0, 0,
228, 13, 0, 0, 5, 0,
68, 88, 66, 67, 6, 210,
5, 58, 145, 186, 106, 71,
191, 85, 65, 89, 187, 76,
25, 50, 1, 0, 0, 0,
248, 13, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
164, 10, 0, 0, 216, 10,
0, 0, 12, 11, 0, 0,
72, 13, 0, 0, 82, 68,
69, 70, 104, 10, 0, 0,
184, 10, 0, 0, 236, 10,
0, 0, 32, 11, 0, 0,
92, 13, 0, 0, 82, 68,
69, 70, 124, 10, 0, 0,
1, 0, 0, 0, 120, 0,
0, 0, 1, 0, 0, 0,
60, 0, 0, 0, 1, 5,
254, 255, 0, 5, 4, 0,
62, 10, 0, 0, 19, 19,
82, 10, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
@ -270,76 +270,76 @@ const BYTE tessellation_indexed_vs[] =
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
119, 8, 0, 0, 240, 0,
138, 8, 0, 0, 240, 0,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 140, 8,
0, 0, 0, 0, 156, 8,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 176, 8,
0, 0, 0, 0, 192, 8,
0, 0, 0, 1, 0, 0,
8, 0, 0, 0, 0, 0,
0, 0, 232, 5, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 203, 8, 0, 0,
0, 0, 219, 8, 0, 0,
8, 1, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
232, 5, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
229, 8, 0, 0, 16, 1,
245, 8, 0, 0, 16, 1,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 160, 5,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 0, 9,
0, 0, 0, 0, 23, 9,
0, 0, 32, 1, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 20, 9, 0, 0,
0, 0, 40, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 56, 9, 0, 0,
0, 0, 76, 9, 0, 0,
64, 1, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
88, 9, 0, 0, 0, 0,
108, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
124, 9, 0, 0, 80, 1,
144, 9, 0, 0, 80, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 149, 9,
0, 0, 0, 0, 169, 9,
0, 0, 96, 1, 0, 0,
64, 0, 0, 0, 0, 0,
0, 0, 168, 9, 0, 0,
0, 0, 188, 9, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 204, 9, 0, 0,
0, 0, 224, 9, 0, 0,
160, 1, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
228, 9, 0, 0, 0, 0,
248, 9, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
8, 10, 0, 0, 192, 1,
28, 10, 0, 0, 192, 1,
0, 0, 16, 0, 0, 0,
0, 0, 0, 0, 88, 9,
0, 0, 0, 0, 108, 9,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 38, 10,
0, 0, 0, 0, 58, 10,
0, 0, 208, 1, 0, 0,
16, 0, 0, 0, 0, 0,
0, 0, 140, 8, 0, 0,
0, 0, 156, 8, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
@ -465,34 +465,72 @@ const BYTE tessellation_indexed_vs[] =
97, 95, 116, 111, 95, 109,
97, 115, 107, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 112, 105, 116, 99, 104,
95, 116, 105, 108, 101, 115,
0, 120, 101, 95, 99, 111,
108, 111, 114, 95, 101, 120,
112, 95, 98, 105, 97, 115,
0, 171, 171, 171, 1, 0,
3, 0, 1, 0, 4, 0,
95, 51, 50, 98, 112, 112,
95, 116, 105, 108, 101, 95,
112, 105, 116, 99, 104, 95,
100, 119, 111, 114, 100, 115,
95, 115, 99, 97, 108, 101,
100, 0, 120, 101, 95, 99,
111, 108, 111, 114, 95, 101,
120, 112, 95, 98, 105, 97,
115, 0, 1, 0, 3, 0,
1, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
172, 6, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 112, 111, 108, 121, 95,
111, 102, 102, 115, 101, 116,
95, 102, 114, 111, 110, 116,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 112,
111, 108, 121, 95, 111, 102,
102, 115, 101, 116, 95, 102,
114, 111, 110, 116, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 112, 111, 108, 121,
95, 111, 102, 102, 115, 101,
116, 95, 98, 97, 99, 107,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 112, 111,
108, 121, 95, 111, 102, 102,
115, 101, 116, 95, 98, 97,
99, 107, 0, 120, 101, 95,
101, 100, 114, 97, 109, 95,
100, 101, 112, 116, 104, 95,
98, 97, 115, 101, 95, 100,
119, 111, 114, 100, 115, 0,
114, 97, 109, 95, 100, 101,
112, 116, 104, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 95, 115, 99,
97, 108, 101, 100, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 115, 116, 101, 110,
99, 105, 108, 0, 1, 0,
19, 0, 1, 0, 4, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 98, 97,
115, 101, 95, 100, 119, 111,
114, 100, 115, 95, 115, 99,
97, 108, 101, 100, 0, 171,
1, 0, 19, 0, 1, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 115, 116, 101,
110, 99, 105, 108, 0, 171,
97, 109, 95, 114, 116, 95,
102, 111, 114, 109, 97, 116,
95, 102, 108, 97, 103, 115,
0, 120, 101, 95, 101, 100,
114, 97, 109, 95, 114, 116,
95, 99, 108, 97, 109, 112,
0, 171, 1, 0, 3, 0,
1, 0, 4, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 172, 6,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 107, 101, 101, 112,
95, 109, 97, 115, 107, 0,
171, 171, 1, 0, 19, 0,
1, 0, 4, 0, 2, 0,
0, 0, 0, 0, 0, 0,
@ -501,184 +539,149 @@ const BYTE tessellation_indexed_vs[] =
0, 0, 0, 0, 247, 7,
0, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 114,
116, 95, 98, 97, 115, 101,
95, 100, 119, 111, 114, 100,
115, 95, 115, 99, 97, 108,
101, 100, 0, 171, 1, 0,
19, 0, 1, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
247, 7, 0, 0, 120, 101,
95, 101, 100, 114, 97, 109,
95, 114, 116, 95, 102, 111,
114, 109, 97, 116, 95, 102,
108, 97, 103, 115, 0, 120,
101, 95, 101, 100, 114, 97,
109, 95, 114, 116, 95, 99,
108, 97, 109, 112, 0, 171,
1, 0, 3, 0, 1, 0,
4, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 172, 6, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
107, 101, 101, 112, 95, 109,
97, 115, 107, 0, 171, 171,
1, 0, 19, 0, 1, 0,
4, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 247, 7, 0, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 114, 116, 95,
98, 108, 101, 110, 100, 95,
102, 97, 99, 116, 111, 114,
115, 95, 111, 112, 115, 0,
120, 101, 95, 101, 100, 114,
97, 109, 95, 98, 108, 101,
110, 100, 95, 99, 111, 110,
115, 116, 97, 110, 116, 0,
77, 105, 99, 114, 111, 115,
111, 102, 116, 32, 40, 82,
41, 32, 72, 76, 83, 76,
32, 83, 104, 97, 100, 101,
114, 32, 67, 111, 109, 112,
105, 108, 101, 114, 32, 49,
48, 46, 49, 0, 171, 171,
73, 83, 71, 78, 44, 0,
116, 95, 98, 108, 101, 110,
100, 95, 102, 97, 99, 116,
111, 114, 115, 95, 111, 112,
115, 0, 120, 101, 95, 101,
100, 114, 97, 109, 95, 98,
108, 101, 110, 100, 95, 99,
111, 110, 115, 116, 97, 110,
116, 0, 77, 105, 99, 114,
111, 115, 111, 102, 116, 32,
40, 82, 41, 32, 72, 76,
83, 76, 32, 83, 104, 97,
100, 101, 114, 32, 67, 111,
109, 112, 105, 108, 101, 114,
32, 49, 48, 46, 49, 0,
171, 171, 73, 83, 71, 78,
44, 0, 0, 0, 1, 0,
0, 0, 8, 0, 0, 0,
32, 0, 0, 0, 0, 0,
0, 0, 6, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 1, 0, 0,
83, 86, 95, 86, 101, 114,
116, 101, 120, 73, 68, 0,
79, 83, 71, 78, 44, 0,
0, 0, 1, 0, 0, 0,
8, 0, 0, 0, 32, 0,
0, 0, 0, 0, 0, 0,
6, 0, 0, 0, 1, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
1, 1, 0, 0, 83, 86,
95, 86, 101, 114, 116, 101,
120, 73, 68, 0, 79, 83,
71, 78, 44, 0, 0, 0,
1, 0, 0, 0, 8, 0,
0, 0, 32, 0, 0, 0,
1, 14, 0, 0, 88, 69,
86, 69, 82, 84, 69, 88,
73, 68, 0, 171, 83, 72,
69, 88, 52, 2, 0, 0,
81, 0, 1, 0, 141, 0,
0, 0, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 1, 14,
0, 0, 88, 69, 86, 69,
82, 84, 69, 88, 73, 68,
0, 171, 83, 72, 69, 88,
52, 2, 0, 0, 81, 0,
1, 0, 141, 0, 0, 0,
106, 8, 0, 1, 89, 0,
0, 7, 70, 142, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 96, 0, 0, 4,
18, 16, 16, 0, 0, 0,
0, 0, 6, 0, 0, 0,
101, 0, 0, 3, 18, 32,
16, 0, 0, 0, 0, 0,
104, 0, 0, 2, 1, 0,
0, 0, 32, 0, 0, 12,
114, 0, 16, 0, 0, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
2, 64, 0, 0, 1, 0,
0, 0, 2, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 60, 0, 0, 7,
50, 0, 16, 0, 0, 0,
0, 0, 150, 5, 16, 0,
0, 0, 0, 0, 70, 0,
0, 0, 0, 0, 96, 0,
0, 4, 18, 16, 16, 0,
0, 0, 0, 0, 6, 0,
0, 0, 101, 0, 0, 3,
18, 32, 16, 0, 0, 0,
0, 0, 104, 0, 0, 2,
1, 0, 0, 0, 32, 0,
0, 12, 114, 0, 16, 0,
0, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 2, 64, 0, 0,
1, 0, 0, 0, 2, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 60, 0,
0, 7, 50, 0, 16, 0,
0, 0, 0, 0, 150, 5,
16, 0, 0, 0, 0, 0,
31, 0, 4, 3, 10, 0,
16, 0, 0, 0, 0, 0,
41, 0, 0, 7, 18, 0,
70, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
10, 0, 16, 0, 0, 0,
0, 0, 41, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 16, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 8, 0, 0, 0,
85, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
10, 16, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
8, 0, 0, 0, 85, 0,
0, 7, 66, 0, 16, 0,
8, 0, 0, 0, 1, 0,
0, 10, 82, 0, 16, 0,
0, 0, 0, 0, 6, 2,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 255,
0, 255, 0, 0, 0, 0,
255, 0, 255, 0, 0, 0,
0, 0, 30, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
18, 0, 0, 1, 54, 0,
0, 5, 18, 0, 16, 0,
0, 0, 0, 0, 10, 16,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 8, 0,
0, 0, 1, 0, 0, 10,
82, 0, 16, 0, 0, 0,
0, 0, 6, 2, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 255, 0, 255,
0, 0, 0, 0, 255, 0,
255, 0, 0, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 18, 0,
0, 1, 54, 0, 0, 5,
18, 0, 16, 0, 0, 0,
0, 0, 10, 16, 16, 0,
0, 0, 0, 0, 21, 0,
0, 1, 31, 0, 4, 3,
26, 0, 16, 0, 0, 0,
0, 0, 85, 0, 0, 7,
34, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 16, 0, 0, 0,
140, 0, 0, 11, 18, 0,
21, 0, 0, 1, 31, 0,
4, 3, 26, 0, 16, 0,
0, 0, 0, 0, 85, 0,
0, 7, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 16, 0,
0, 0, 140, 0, 0, 11,
18, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
16, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 21, 0, 0, 1,
30, 0, 0, 9, 18, 0,
16, 0, 0, 0, 1, 64,
0, 0, 16, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 21, 0,
0, 1, 30, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 26, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 255, 255, 255, 0,
83, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 26, 128, 48, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 7, 18, 0,
84, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
255, 255, 255, 0, 83, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
42, 128, 48, 0, 0, 0,
0, 0, 58, 128, 48, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 84, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
0, 0, 1, 0, 0, 0,
86, 0, 0, 5, 18, 32,
16, 0, 0, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 86, 0,
0, 5, 18, 32, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
20, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
7, 0, 0, 0, 2, 0,
10, 0, 16, 0, 0, 0,
0, 0, 62, 0, 0, 1,
83, 84, 65, 84, 148, 0,
0, 0, 20, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 7, 0, 0, 0,
2, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
@ -688,5 +691,5 @@ const BYTE tessellation_indexed_vs[] =
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0
0, 0, 0, 0, 0, 0
};

1519
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_2x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

2363
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_3x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1089
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1058
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_128bpb_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

1367
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_2x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

3546
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_3x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

999
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_cs.h generated
View File

File diff suppressed because it is too large Load Diff

977
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_16bpb_scaled_cs.h generated Normal file
View File

@ -0,0 +1,977 @@
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
// Buffer Definitions:
//
// cbuffer XeTextureLoadConstants
// {
//
// uint xe_texture_load_is_tiled_3d_endian_scale;// Offset: 0 Size: 4
// uint xe_texture_load_guest_offset; // Offset: 4 Size: 4
// uint xe_texture_load_guest_pitch_aligned;// Offset: 8 Size: 4
// uint xe_texture_load_guest_z_stride_block_rows_aligned;// Offset: 12 Size: 4
// uint3 xe_texture_load_size_blocks; // Offset: 16 Size: 12
// uint xe_texture_load_host_offset; // Offset: 28 Size: 4
// uint xe_texture_load_host_pitch; // Offset: 32 Size: 4
// uint xe_texture_load_height_texels;// Offset: 36 Size: 4 [unused]
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim ID HLSL Bind Count
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_texture_load_source texture uint4 buf T0 t0 1
// xe_texture_load_dest UAV uint4 buf U0 u0 1
// XeTextureLoadConstants cbuffer NA NA CB0 cb0 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Input
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Output
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][3], immediateIndexed, space=0
dcl_resource_buffer (uint,uint,uint,uint) T0[0:0], space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xyz
dcl_temps 6
dcl_thread_group 2, 32, 1
ishl r0.x, vThreadID.x, l(4)
mov r0.yz, vThreadID.yyzy
uge r0.yzw, r0.xxyz, CB0[0][1].xxyz
or r0.y, r0.z, r0.y
or r0.y, r0.w, r0.y
if_nz r0.y
ret
endif
ishl r0.y, r0.x, l(1)
imad r0.z, vThreadID.z, CB0[0][1].y, vThreadID.y
imad r0.y, r0.z, CB0[0][2].x, r0.y
iadd r0.y, r0.y, CB0[0][1].w
and r0.z, CB0[0][0].x, l(2)
ubfe r1.xyz, l(2, 2, 2, 0), l(4, 6, 2, 0), CB0[0][0].xxxx
ushr r2.x, r0.x, l(3)
mov r2.y, vThreadID.y
udiv r0.xw, null, r2.xxxy, r1.xxxy
if_nz r0.z
ishr r2.zw, r0.wwww, l(0, 0, 4, 3)
ishr r0.z, vThreadID.z, l(2)
ushr r3.xy, CB0[0][0].wzww, l(4, 5, 0, 0)
imad r1.w, r0.z, r3.x, r2.z
ibfe r3.xz, l(27, 0, 29, 0), l(2, 0, 0, 0), r0.xxxx
imad r1.w, r1.w, r3.y, r3.x
ishl r2.z, r0.w, l(9)
ishr r2.z, r2.z, l(6)
and r2.z, r2.z, l(48)
iadd r0.z, r0.z, r2.w
bfi r2.w, l(1), l(1), r0.z, l(0)
iadd r2.w, r2.w, r3.z
bfi r2.w, l(2), l(1), r2.w, l(0)
bfi r0.z, l(1), l(0), r0.z, r2.w
bfi r3.xy, l(21, 21, 0, 0), l(9, 12, 0, 0), r1.wwww, l(0, 0, 0, 0)
imad r2.zw, r2.zzzz, l(0, 0, 2, 16), r3.xxxy
bfi r2.zw, l(0, 0, 2, 2), l(0, 0, 7, 10), vThreadID.zzzz, r2.zzzw
bfi r1.w, l(1), l(4), r0.w, l(0)
ubfe r3.x, l(3), l(6), r2.z
and r3.y, r0.z, l(6)
bfi r0.z, l(1), l(8), r0.z, l(0)
imad r0.z, r3.x, l(32), r0.z
imad r0.z, r3.y, l(4), r0.z
bfi r2.zw, l(0, 0, 5, 5), l(0, 0, 0, 3), r1.wwww, r2.zzzw
bfi r0.z, l(9), l(3), r0.z, r2.w
bfi r0.z, l(6), l(0), r2.z, r0.z
else
ibfe r2.zw, l(0, 0, 27, 29), l(0, 0, 2, 0), r0.xxxx
ishr r3.xy, r0.wwww, l(5, 2, 0, 0)
ushr r1.w, CB0[0][0].z, l(5)
imad r1.w, r3.x, r1.w, r2.z
bfi r3.xzw, l(4, 0, 4, 4), l(4, 0, 7, 6), r0.wwww, l(0, 0, 0, 0)
bfi r3.xzw, l(24, 0, 24, 24), l(8, 0, 11, 10), r1.wwww, r3.xxzw
ishl r1.w, r0.w, l(7)
and r1.w, r1.w, l(2048)
bfi r1.w, l(12), l(0), r1.w, r3.z
and r2.z, r3.w, l(1792)
iadd r1.w, r1.w, r2.z
and r2.z, r3.y, l(2)
iadd r2.z, r2.w, r2.z
bfi r2.z, l(2), l(6), r2.z, l(0)
iadd r1.w, r1.w, r2.z
bfi r0.z, l(6), l(0), r3.x, r1.w
endif
imad r0.xw, -r0.xxxw, r1.xxxy, r2.xxxy
imul null, r1.w, r1.y, r1.x
imad r0.x, r0.x, r1.y, r0.w
ishl r0.x, r0.x, l(4)
imad r0.x, r0.z, r1.w, r0.x
iadd r0.x, r0.x, CB0[0][0].y
ushr r0.xy, r0.xyxx, l(4, 4, 0, 0)
ld r3.xyzw, r0.xxxx, T0[0].xyzw
ieq r0.z, r1.z, l(1)
if_nz r0.z
ishl r4.xyzw, r3.xyzw, l(8, 8, 8, 8)
and r4.xyzw, r4.xyzw, l(0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00)
ushr r5.xyzw, r3.xyzw, l(8, 8, 8, 8)
and r5.xyzw, r5.xyzw, l(0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff)
iadd r3.xyzw, r4.xyzw, r5.xyzw
endif
store_uav_typed U0[0].xyzw, r0.yyyy, r3.xyzw
iadd r0.w, r0.y, l(1)
ult r1.z, l(1), r1.x
if_nz r1.z
udiv r1.z, null, r2.x, r1.x
imad r1.z, -r1.z, r1.x, r2.x
iadd r1.w, r1.z, l(1)
ieq r1.w, r1.x, r1.w
if_nz r1.w
ishl r1.x, r1.x, l(6)
ishl r1.z, r1.z, l(4)
iadd r1.x, -r1.z, r1.x
else
mov r1.x, l(16)
endif
else
mov r1.x, l(64)
endif
imul null, r1.x, r1.y, r1.x
ushr r1.x, r1.x, l(4)
iadd r0.x, r0.x, r1.x
ld r1.xyzw, r0.xxxx, T0[0].xyzw
if_nz r0.z
ishl r2.xyzw, r1.xyzw, l(8, 8, 8, 8)
and r2.xyzw, r2.xyzw, l(0xff00ff00, 0xff00ff00, 0xff00ff00, 0xff00ff00)
ushr r3.xyzw, r1.xyzw, l(8, 8, 8, 8)
and r3.xyzw, r3.xyzw, l(0x00ff00ff, 0x00ff00ff, 0x00ff00ff, 0x00ff00ff)
iadd r1.xyzw, r2.xyzw, r3.xyzw
endif
store_uav_typed U0[0].xyzw, r0.wwww, r1.xyzw
ret
// Approximately 109 instruction slots used
#endif
const BYTE texture_load_16bpb_scaled_cs[] =
{
68, 88, 66, 67, 81, 210,
211, 210, 188, 152, 146, 59,
242, 122, 231, 17, 215, 172,
246, 100, 1, 0, 0, 0,
0, 19, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
28, 4, 0, 0, 44, 4,
0, 0, 60, 4, 0, 0,
100, 18, 0, 0, 82, 68,
69, 70, 224, 3, 0, 0,
1, 0, 0, 0, 248, 0,
0, 0, 3, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
181, 3, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
180, 0, 0, 0, 2, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 203, 0,
0, 0, 4, 0, 0, 0,
4, 0, 0, 0, 1, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 1, 0,
0, 0, 12, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 224, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 115, 111,
117, 114, 99, 101, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 100, 101, 115,
116, 0, 88, 101, 84, 101,
120, 116, 117, 114, 101, 76,
111, 97, 100, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 224, 0, 0, 0,
8, 0, 0, 0, 16, 1,
0, 0, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 80, 2, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
128, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
164, 2, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 128, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 193, 2,
0, 0, 8, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 128, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 229, 2, 0, 0,
12, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
128, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
23, 3, 0, 0, 16, 0,
0, 0, 12, 0, 0, 0,
2, 0, 0, 0, 60, 3,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 96, 3,
0, 0, 28, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 128, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 124, 3, 0, 0,
32, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
128, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
151, 3, 0, 0, 36, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 128, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 105, 115, 95, 116,
105, 108, 101, 100, 95, 51,
100, 95, 101, 110, 100, 105,
97, 110, 95, 115, 99, 97,
108, 101, 0, 100, 119, 111,
114, 100, 0, 171, 0, 0,
19, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
121, 2, 0, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 103, 117, 101, 115,
116, 95, 111, 102, 102, 115,
101, 116, 0, 120, 101, 95,
116, 101, 120, 116, 117, 114,
101, 95, 108, 111, 97, 100,
95, 103, 117, 101, 115, 116,
95, 112, 105, 116, 99, 104,
95, 97, 108, 105, 103, 110,
101, 100, 0, 120, 101, 95,
116, 101, 120, 116, 117, 114,
101, 95, 108, 111, 97, 100,
95, 103, 117, 101, 115, 116,
95, 122, 95, 115, 116, 114,
105, 100, 101, 95, 98, 108,
111, 99, 107, 95, 114, 111,
119, 115, 95, 97, 108, 105,
103, 110, 101, 100, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 115, 105, 122,
101, 95, 98, 108, 111, 99,
107, 115, 0, 117, 105, 110,
116, 51, 0, 171, 171, 171,
1, 0, 19, 0, 1, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 51, 3, 0, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 104, 111,
115, 116, 95, 111, 102, 102,
115, 101, 116, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 104, 111, 115, 116,
95, 112, 105, 116, 99, 104,
0, 120, 101, 95, 116, 101,
120, 116, 117, 114, 101, 95,
108, 111, 97, 100, 95, 104,
101, 105, 103, 104, 116, 95,
116, 101, 120, 101, 108, 115,
0, 77, 105, 99, 114, 111,
115, 111, 102, 116, 32, 40,
82, 41, 32, 72, 76, 83,
76, 32, 83, 104, 97, 100,
101, 114, 32, 67, 111, 109,
112, 105, 108, 101, 114, 32,
49, 48, 46, 49, 0, 171,
171, 171, 73, 83, 71, 78,
8, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
79, 83, 71, 78, 8, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 83, 72,
69, 88, 32, 14, 0, 0,
81, 0, 5, 0, 136, 3,
0, 0, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 88, 8,
0, 7, 70, 126, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
68, 68, 0, 0, 0, 0,
0, 0, 156, 8, 0, 7,
70, 238, 49, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 68, 68,
0, 0, 0, 0, 0, 0,
95, 0, 0, 2, 114, 0,
2, 0, 104, 0, 0, 2,
6, 0, 0, 0, 155, 0,
0, 4, 2, 0, 0, 0,
32, 0, 0, 0, 1, 0,
0, 0, 41, 0, 0, 6,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 2, 0,
1, 64, 0, 0, 4, 0,
0, 0, 54, 0, 0, 4,
98, 0, 16, 0, 0, 0,
0, 0, 86, 6, 2, 0,
80, 0, 0, 9, 226, 0,
16, 0, 0, 0, 0, 0,
6, 9, 16, 0, 0, 0,
0, 0, 6, 137, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
60, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 60, 0,
0, 7, 34, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
26, 0, 16, 0, 0, 0,
0, 0, 62, 0, 0, 1,
21, 0, 0, 1, 41, 0,
0, 7, 34, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 35, 0, 0, 9,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 2, 0,
26, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 26, 0,
2, 0, 35, 0, 0, 11,
34, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 30, 0,
0, 9, 34, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 1, 0,
0, 9, 66, 0, 16, 0,
0, 0, 0, 0, 10, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 138, 0,
0, 17, 114, 0, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
2, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 4, 0,
0, 0, 6, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 6, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
85, 0, 0, 7, 18, 0,
16, 0, 2, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
3, 0, 0, 0, 54, 0,
0, 4, 34, 0, 16, 0,
2, 0, 0, 0, 26, 0,
2, 0, 78, 0, 0, 8,
146, 0, 16, 0, 0, 0,
0, 0, 0, 208, 0, 0,
6, 4, 16, 0, 2, 0,
0, 0, 6, 4, 16, 0,
1, 0, 0, 0, 31, 0,
4, 3, 42, 0, 16, 0,
0, 0, 0, 0, 42, 0,
0, 10, 194, 0, 16, 0,
2, 0, 0, 0, 246, 15,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
4, 0, 0, 0, 3, 0,
0, 0, 42, 0, 0, 6,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 2, 0,
1, 64, 0, 0, 2, 0,
0, 0, 85, 0, 0, 12,
50, 0, 16, 0, 3, 0,
0, 0, 182, 143, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 4, 0,
0, 0, 5, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 35, 0, 0, 9,
130, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 3, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 139, 0, 0, 15,
82, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
27, 0, 0, 0, 0, 0,
0, 0, 29, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
130, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 26, 0,
16, 0, 3, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 41, 0, 0, 7,
66, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 9, 0, 0, 0,
42, 0, 0, 7, 66, 0,
16, 0, 2, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 1, 64, 0, 0,
6, 0, 0, 0, 1, 0,
0, 7, 66, 0, 16, 0,
2, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
1, 64, 0, 0, 48, 0,
0, 0, 30, 0, 0, 7,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 2, 0, 0, 0,
140, 0, 0, 11, 130, 0,
16, 0, 2, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 30, 0, 0, 7,
130, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
2, 0, 0, 0, 42, 0,
16, 0, 3, 0, 0, 0,
140, 0, 0, 11, 130, 0,
16, 0, 2, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 58, 0,
16, 0, 2, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 140, 0, 0, 11,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
2, 0, 0, 0, 140, 0,
0, 20, 50, 0, 16, 0,
3, 0, 0, 0, 2, 64,
0, 0, 21, 0, 0, 0,
21, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 9, 0,
0, 0, 12, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
35, 0, 0, 12, 194, 0,
16, 0, 2, 0, 0, 0,
166, 10, 16, 0, 2, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
16, 0, 0, 0, 6, 4,
16, 0, 3, 0, 0, 0,
140, 0, 0, 16, 194, 0,
16, 0, 2, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 2, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 7, 0, 0, 0,
10, 0, 0, 0, 166, 10,
2, 0, 166, 14, 16, 0,
2, 0, 0, 0, 140, 0,
0, 11, 130, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
1, 64, 0, 0, 4, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
138, 0, 0, 9, 18, 0,
16, 0, 3, 0, 0, 0,
1, 64, 0, 0, 3, 0,
0, 0, 1, 64, 0, 0,
6, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
1, 0, 0, 7, 34, 0,
16, 0, 3, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
6, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
1, 64, 0, 0, 8, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
35, 0, 0, 9, 66, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 1, 64, 0, 0,
32, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
35, 0, 0, 9, 66, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 3, 0,
0, 0, 1, 64, 0, 0,
4, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
140, 0, 0, 17, 194, 0,
16, 0, 2, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
5, 0, 0, 0, 5, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
3, 0, 0, 0, 246, 15,
16, 0, 1, 0, 0, 0,
166, 14, 16, 0, 2, 0,
0, 0, 140, 0, 0, 11,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
9, 0, 0, 0, 1, 64,
0, 0, 3, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
2, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 42, 0, 16, 0,
2, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
18, 0, 0, 1, 139, 0,
0, 15, 194, 0, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 27, 0,
0, 0, 29, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 42, 0,
0, 10, 50, 0, 16, 0,
3, 0, 0, 0, 246, 15,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 5, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 85, 0, 0, 9,
130, 0, 16, 0, 1, 0,
0, 0, 42, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 64, 0, 0, 5, 0,
0, 0, 35, 0, 0, 9,
130, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
3, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 140, 0, 0, 20,
210, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
4, 0, 0, 0, 2, 64,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 7, 0,
0, 0, 6, 0, 0, 0,
246, 15, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 140, 0,
0, 17, 210, 0, 16, 0,
3, 0, 0, 0, 2, 64,
0, 0, 24, 0, 0, 0,
0, 0, 0, 0, 24, 0,
0, 0, 24, 0, 0, 0,
2, 64, 0, 0, 8, 0,
0, 0, 0, 0, 0, 0,
11, 0, 0, 0, 10, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 6, 14,
16, 0, 3, 0, 0, 0,
41, 0, 0, 7, 130, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
7, 0, 0, 0, 1, 0,
0, 7, 130, 0, 16, 0,
1, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 0, 8,
0, 0, 140, 0, 0, 11,
130, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
12, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
3, 0, 0, 0, 1, 0,
0, 7, 66, 0, 16, 0,
2, 0, 0, 0, 58, 0,
16, 0, 3, 0, 0, 0,
1, 64, 0, 0, 0, 7,
0, 0, 30, 0, 0, 7,
130, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
1, 0, 0, 7, 66, 0,
16, 0, 2, 0, 0, 0,
26, 0, 16, 0, 3, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
2, 0, 0, 0, 58, 0,
16, 0, 2, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 140, 0, 0, 11,
66, 0, 16, 0, 2, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 30, 0,
0, 7, 130, 0, 16, 0,
1, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 140, 0, 0, 11,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
6, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 21, 0,
0, 1, 35, 0, 0, 10,
146, 0, 16, 0, 0, 0,
0, 0, 6, 12, 16, 128,
65, 0, 0, 0, 0, 0,
0, 0, 6, 4, 16, 0,
1, 0, 0, 0, 6, 4,
16, 0, 2, 0, 0, 0,
38, 0, 0, 8, 0, 208,
0, 0, 130, 0, 16, 0,
1, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 41, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 4, 0, 0, 0,
35, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
30, 0, 0, 9, 18, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 26, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
85, 0, 0, 10, 50, 0,
16, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 45, 0,
0, 8, 242, 0, 16, 0,
3, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
70, 126, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
32, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 31, 0,
4, 3, 42, 0, 16, 0,
0, 0, 0, 0, 41, 0,
0, 10, 242, 0, 16, 0,
4, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
2, 64, 0, 0, 8, 0,
0, 0, 8, 0, 0, 0,
8, 0, 0, 0, 8, 0,
0, 0, 1, 0, 0, 10,
242, 0, 16, 0, 4, 0,
0, 0, 70, 14, 16, 0,
4, 0, 0, 0, 2, 64,
0, 0, 0, 255, 0, 255,
0, 255, 0, 255, 0, 255,
0, 255, 0, 255, 0, 255,
85, 0, 0, 10, 242, 0,
16, 0, 5, 0, 0, 0,
70, 14, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
8, 0, 0, 0, 8, 0,
0, 0, 8, 0, 0, 0,
8, 0, 0, 0, 1, 0,
0, 10, 242, 0, 16, 0,
5, 0, 0, 0, 70, 14,
16, 0, 5, 0, 0, 0,
2, 64, 0, 0, 255, 0,
255, 0, 255, 0, 255, 0,
255, 0, 255, 0, 255, 0,
255, 0, 30, 0, 0, 7,
242, 0, 16, 0, 3, 0,
0, 0, 70, 14, 16, 0,
4, 0, 0, 0, 70, 14,
16, 0, 5, 0, 0, 0,
21, 0, 0, 1, 164, 0,
0, 8, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
0, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
30, 0, 0, 7, 130, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 79, 0,
0, 7, 66, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 31, 0, 4, 3,
42, 0, 16, 0, 1, 0,
0, 0, 78, 0, 0, 8,
66, 0, 16, 0, 1, 0,
0, 0, 0, 208, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 35, 0,
0, 10, 66, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 128, 65, 0, 0, 0,
1, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 30, 0, 0, 7,
130, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
32, 0, 0, 7, 130, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 31, 0,
4, 3, 58, 0, 16, 0,
1, 0, 0, 0, 41, 0,
0, 7, 18, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 6, 0,
0, 0, 41, 0, 0, 7,
66, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 4, 0, 0, 0,
30, 0, 0, 8, 18, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 128, 65, 0,
0, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 18, 0, 0, 1,
54, 0, 0, 5, 18, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 16, 0,
0, 0, 21, 0, 0, 1,
18, 0, 0, 1, 54, 0,
0, 5, 18, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 64, 0, 0, 0,
21, 0, 0, 1, 38, 0,
0, 8, 0, 208, 0, 0,
18, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
85, 0, 0, 7, 18, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
4, 0, 0, 0, 30, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 45, 0, 0, 8,
242, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 70, 126,
32, 0, 0, 0, 0, 0,
0, 0, 0, 0, 31, 0,
4, 3, 42, 0, 16, 0,
0, 0, 0, 0, 41, 0,
0, 10, 242, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 8, 0,
0, 0, 8, 0, 0, 0,
8, 0, 0, 0, 8, 0,
0, 0, 1, 0, 0, 10,
242, 0, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 255, 0, 255,
0, 255, 0, 255, 0, 255,
0, 255, 0, 255, 0, 255,
85, 0, 0, 10, 242, 0,
16, 0, 3, 0, 0, 0,
70, 14, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
8, 0, 0, 0, 8, 0,
0, 0, 8, 0, 0, 0,
8, 0, 0, 0, 1, 0,
0, 10, 242, 0, 16, 0,
3, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
2, 64, 0, 0, 255, 0,
255, 0, 255, 0, 255, 0,
255, 0, 255, 0, 255, 0,
255, 0, 30, 0, 0, 7,
242, 0, 16, 0, 1, 0,
0, 0, 70, 14, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
21, 0, 0, 1, 164, 0,
0, 8, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 246, 15, 16, 0,
0, 0, 0, 0, 70, 14,
16, 0, 1, 0, 0, 0,
62, 0, 0, 1, 83, 84,
65, 84, 148, 0, 0, 0,
109, 0, 0, 0, 6, 0,
0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 42, 0, 0, 0,
23, 0, 0, 0, 5, 0,
0, 0, 6, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0
};

1598
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_2x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1071
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1097
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

1510
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_2x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

3775
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_3x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1095
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1097
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_64bpb_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

985
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_2x_cs.h generated
View File

@ -1,985 +0,0 @@
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
// Buffer Definitions:
//
// cbuffer XeTextureLoadConstants
// {
//
// uint xe_texture_load_is_tiled_3d_endian;// Offset: 0 Size: 4
// uint xe_texture_load_guest_offset; // Offset: 4 Size: 4
// uint xe_texture_load_guest_pitch_aligned;// Offset: 8 Size: 4
// uint xe_texture_load_guest_z_stride_block_rows_aligned;// Offset: 12 Size: 4
// uint3 xe_texture_load_size_blocks; // Offset: 16 Size: 12
// uint xe_texture_load_host_offset; // Offset: 28 Size: 4
// uint xe_texture_load_host_pitch; // Offset: 32 Size: 4
// uint xe_texture_load_height_texels;// Offset: 36 Size: 4 [unused]
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim ID HLSL Bind Count
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_texture_load_source texture uint4 buf T0 t0 1
// xe_texture_load_dest UAV uint4 buf U0 u0 1
// XeTextureLoadConstants cbuffer NA NA CB0 cb0 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Input
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Output
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][3], immediateIndexed, space=0
dcl_resource_buffer (uint,uint,uint,uint) T0[0:0], space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xyz
dcl_temps 4
dcl_thread_group 2, 32, 1
ishl r0.x, vThreadID.x, l(4)
mov r0.yz, vThreadID.yyzy
uge r1.xyz, r0.xyzx, CB0[0][1].xyzx
or r0.z, r1.y, r1.x
or r0.z, r1.z, r0.z
if_nz r0.z
ret
endif
ishl r0.yz, r0.xxyx, l(0, 1, 1, 0)
ishl r0.w, CB0[0][1].y, l(1)
imad r0.z, vThreadID.z, r0.w, r0.z
imad r0.y, r0.z, CB0[0][2].x, r0.y
iadd r0.y, r0.y, CB0[0][1].w
ushr r0.z, CB0[0][2].x, l(4)
and r0.w, CB0[0][0].x, l(1)
if_nz r0.w
and r1.x, CB0[0][0].x, l(2)
if_nz r1.x
ishr r1.xyz, vThreadID.yzyy, l(4, 2, 3, 0)
ushr r2.xy, CB0[0][0].wzww, l(4, 5, 0, 0)
imad r1.x, r1.y, r2.x, r1.x
ibfe r1.w, l(27), l(1), vThreadID.x
imad r1.x, r1.x, r2.y, r1.w
ishl r1.w, vThreadID.y, l(8)
ishr r1.w, r1.w, l(6)
iadd r1.y, r1.y, r1.z
and r1.z, r1.y, l(1)
ishr r2.x, r0.x, l(3)
bfi r1.y, l(1), l(1), r1.y, l(0)
iadd r1.y, r1.y, r2.x
bfi r1.y, l(2), l(1), r1.y, l(0)
iadd r1.y, r1.y, r1.z
and r1.zw, r1.wwww, l(0, 0, 16, 8)
bfi r2.xy, l(22, 22, 0, 0), l(8, 11, 0, 0), r1.xxxx, l(0, 0, 0, 0)
imad r1.xz, r1.zzzz, l(2, 0, 16, 0), r2.xxyx
bfi r1.xz, l(5, 0, 5, 0), l(0, 0, 3, 0), r1.wwww, r1.xxzx
bfi r1.xz, l(2, 0, 2, 0), l(6, 0, 9, 0), vThreadID.zzzz, r1.xxzx
ubfe r1.w, l(3), l(6), r1.x
and r2.x, r1.y, l(4)
bfi r1.y, l(2), l(8), r1.y, l(0)
imad r1.y, r1.w, l(32), r1.y
imad r1.y, r2.x, l(4), r1.y
bfi r1.xz, l(1, 0, 1, 0), l(4, 0, 7, 0), vThreadID.yyyy, r1.xxzx
bfi r1.y, l(9), l(3), r1.y, r1.z
bfi r1.x, l(6), l(0), r1.x, r1.y
else
ibfe r1.y, l(27), l(1), vThreadID.x
ishr r1.zw, vThreadID.yyyy, l(0, 0, 5, 2)
ushr r2.x, CB0[0][0].z, l(5)
imad r1.y, r1.z, r2.x, r1.y
ishl r2.xy, vThreadID.yyyy, l(2, 7, 0, 0)
ishl r1.z, r2.x, l(1)
and r1.z, r1.z, l(96)
bfi r2.z, l(25), l(7), r1.y, r1.z
and r2.xy, r2.xyxx, l(8, 2048, 0, 0)
iadd r2.z, r2.z, r2.x
bfi r2.z, l(1), l(4), vThreadID.y, r2.z
ishl r3.xy, r1.zzzz, l(3, 2, 0, 0)
bfi r1.yz, l(0, 25, 25, 0), l(0, 10, 9, 0), r1.yyyy, r3.xxyx
imad r1.yz, r2.xxxx, l(0, 8, 4, 0), r1.yyzy
bfi r1.yz, l(0, 1, 1, 0), l(0, 7, 6, 0), vThreadID.yyyy, r1.yyzy
bfi r1.y, l(12), l(0), r2.y, r1.y
and r1.z, r1.z, l(1792)
iadd r1.y, r1.y, r1.z
and r1.z, r1.w, l(2)
ishr r1.w, r0.x, l(3)
iadd r1.z, r1.w, r1.z
bfi r1.z, l(2), l(6), r1.z, l(0)
iadd r1.y, r1.y, r1.z
bfi r1.x, l(6), l(0), r2.z, r1.y
endif
else
imad r1.y, vThreadID.z, CB0[0][0].w, vThreadID.y
imad r1.x, r1.y, CB0[0][0].z, r0.x
endif
iadd r0.x, r1.x, CB0[0][0].y
ushr r0.xy, r0.xyxx, l(2, 4, 0, 0)
ld r1.xyzw, r0.xxxx, T0[0].xyzw
iadd r2.x, r0.x, l(1)
ld r2.xyzw, r2.xxxx, T0[0].ywxz
mov r3.xy, r1.ywyy
mov r3.zw, r2.xxxy
mov r2.xy, r1.xzxx
bfi r1.xyzw, l(16, 16, 16, 16), l(16, 16, 16, 16), r3.xyzw, r2.xyzw
store_uav_typed U0[0].xyzw, r0.yyyy, r1.xyzw
iadd r1.x, r0.z, r0.y
ushr r2.xyzw, r2.xyzw, l(16, 16, 16, 16)
bfi r2.xyzw, l(16, 16, 16, 16), l(0, 0, 0, 0), r2.xyzw, r3.xyzw
store_uav_typed U0[0].xyzw, r1.xxxx, r2.xyzw
movc r0.w, r0.w, l(16), l(2)
iadd r0.x, r0.w, r0.x
ld r1.xyzw, r0.xxxx, T0[0].xyzw
iadd r0.xy, r0.xyxx, l(1, 1, 0, 0)
ld r2.xyzw, r0.xxxx, T0[0].ywxz
mov r3.xy, r1.ywyy
mov r3.zw, r2.xxxy
mov r2.xy, r1.xzxx
bfi r1.xyzw, l(16, 16, 16, 16), l(16, 16, 16, 16), r3.xyzw, r2.xyzw
store_uav_typed U0[0].xyzw, r0.yyyy, r1.xyzw
iadd r0.x, r0.z, r0.y
ushr r1.xyzw, r2.xyzw, l(16, 16, 16, 16)
bfi r1.xyzw, l(16, 16, 16, 16), l(0, 0, 0, 0), r1.xyzw, r3.xyzw
store_uav_typed U0[0].xyzw, r0.xxxx, r1.xyzw
ret
// Approximately 104 instruction slots used
#endif
const BYTE texture_load_8bpb_2x_cs[] =
{
68, 88, 66, 67, 238, 242,
98, 170, 134, 172, 114, 145,
94, 121, 60, 248, 181, 154,
196, 139, 1, 0, 0, 0,
76, 19, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
24, 4, 0, 0, 40, 4,
0, 0, 56, 4, 0, 0,
176, 18, 0, 0, 82, 68,
69, 70, 220, 3, 0, 0,
1, 0, 0, 0, 248, 0,
0, 0, 3, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
177, 3, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
180, 0, 0, 0, 2, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 203, 0,
0, 0, 4, 0, 0, 0,
4, 0, 0, 0, 1, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 1, 0,
0, 0, 12, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 224, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 115, 111,
117, 114, 99, 101, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 100, 101, 115,
116, 0, 88, 101, 84, 101,
120, 116, 117, 114, 101, 76,
111, 97, 100, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 224, 0, 0, 0,
8, 0, 0, 0, 16, 1,
0, 0, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 80, 2, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
124, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
160, 2, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 124, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 189, 2,
0, 0, 8, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 124, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 225, 2, 0, 0,
12, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
124, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
19, 3, 0, 0, 16, 0,
0, 0, 12, 0, 0, 0,
2, 0, 0, 0, 56, 3,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 92, 3,
0, 0, 28, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 124, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 120, 3, 0, 0,
32, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
124, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
147, 3, 0, 0, 36, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 124, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 105, 115, 95, 116,
105, 108, 101, 100, 95, 51,
100, 95, 101, 110, 100, 105,
97, 110, 0, 100, 119, 111,
114, 100, 0, 171, 171, 171,
0, 0, 19, 0, 1, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 115, 2, 0, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 103, 117,
101, 115, 116, 95, 111, 102,
102, 115, 101, 116, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 103, 117, 101,
115, 116, 95, 112, 105, 116,
99, 104, 95, 97, 108, 105,
103, 110, 101, 100, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 103, 117, 101,
115, 116, 95, 122, 95, 115,
116, 114, 105, 100, 101, 95,
98, 108, 111, 99, 107, 95,
114, 111, 119, 115, 95, 97,
108, 105, 103, 110, 101, 100,
0, 120, 101, 95, 116, 101,
120, 116, 117, 114, 101, 95,
108, 111, 97, 100, 95, 115,
105, 122, 101, 95, 98, 108,
111, 99, 107, 115, 0, 117,
105, 110, 116, 51, 0, 171,
171, 171, 1, 0, 19, 0,
1, 0, 3, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 47, 3,
0, 0, 120, 101, 95, 116,
101, 120, 116, 117, 114, 101,
95, 108, 111, 97, 100, 95,
104, 111, 115, 116, 95, 111,
102, 102, 115, 101, 116, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 104, 111,
115, 116, 95, 112, 105, 116,
99, 104, 0, 120, 101, 95,
116, 101, 120, 116, 117, 114,
101, 95, 108, 111, 97, 100,
95, 104, 101, 105, 103, 104,
116, 95, 116, 101, 120, 101,
108, 115, 0, 77, 105, 99,
114, 111, 115, 111, 102, 116,
32, 40, 82, 41, 32, 72,
76, 83, 76, 32, 83, 104,
97, 100, 101, 114, 32, 67,
111, 109, 112, 105, 108, 101,
114, 32, 49, 48, 46, 49,
0, 171, 171, 171, 73, 83,
71, 78, 8, 0, 0, 0,
0, 0, 0, 0, 8, 0,
0, 0, 79, 83, 71, 78,
8, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
83, 72, 69, 88, 112, 14,
0, 0, 81, 0, 5, 0,
156, 3, 0, 0, 106, 8,
0, 1, 89, 0, 0, 7,
70, 142, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
88, 8, 0, 7, 70, 126,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 68, 68, 0, 0,
0, 0, 0, 0, 156, 8,
0, 7, 70, 238, 49, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
68, 68, 0, 0, 0, 0,
0, 0, 95, 0, 0, 2,
114, 0, 2, 0, 104, 0,
0, 2, 4, 0, 0, 0,
155, 0, 0, 4, 2, 0,
0, 0, 32, 0, 0, 0,
1, 0, 0, 0, 41, 0,
0, 6, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
2, 0, 1, 64, 0, 0,
4, 0, 0, 0, 54, 0,
0, 4, 98, 0, 16, 0,
0, 0, 0, 0, 86, 6,
2, 0, 80, 0, 0, 9,
114, 0, 16, 0, 1, 0,
0, 0, 70, 2, 16, 0,
0, 0, 0, 0, 70, 130,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 60, 0, 0, 7,
66, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
60, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 31, 0,
4, 3, 42, 0, 16, 0,
0, 0, 0, 0, 62, 0,
0, 1, 21, 0, 0, 1,
41, 0, 0, 10, 98, 0,
16, 0, 0, 0, 0, 0,
6, 1, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 41, 0,
0, 9, 130, 0, 16, 0,
0, 0, 0, 0, 26, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 35, 0,
0, 8, 66, 0, 16, 0,
0, 0, 0, 0, 42, 0,
2, 0, 58, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
35, 0, 0, 11, 34, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 30, 0, 0, 9,
34, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 58, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 85, 0, 0, 9,
66, 0, 16, 0, 0, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 4, 0,
0, 0, 1, 0, 0, 9,
130, 0, 16, 0, 0, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 31, 0, 4, 3,
58, 0, 16, 0, 0, 0,
0, 0, 1, 0, 0, 9,
18, 0, 16, 0, 1, 0,
0, 0, 10, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 31, 0, 4, 3,
10, 0, 16, 0, 1, 0,
0, 0, 42, 0, 0, 9,
114, 0, 16, 0, 1, 0,
0, 0, 150, 5, 2, 0,
2, 64, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 85, 0, 0, 12,
50, 0, 16, 0, 2, 0,
0, 0, 182, 143, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 4, 0,
0, 0, 5, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 139, 0, 0, 8,
130, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
27, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
10, 0, 2, 0, 35, 0,
0, 9, 18, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 41, 0,
0, 6, 130, 0, 16, 0,
1, 0, 0, 0, 26, 0,
2, 0, 1, 64, 0, 0,
8, 0, 0, 0, 42, 0,
0, 7, 130, 0, 16, 0,
1, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 6, 0,
0, 0, 30, 0, 0, 7,
34, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
1, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 42, 0,
0, 7, 18, 0, 16, 0,
2, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 3, 0,
0, 0, 140, 0, 0, 11,
34, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 30, 0,
0, 7, 34, 0, 16, 0,
1, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 140, 0, 0, 11,
34, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
2, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 30, 0,
0, 7, 34, 0, 16, 0,
1, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 1, 0, 0, 10,
194, 0, 16, 0, 1, 0,
0, 0, 246, 15, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 16, 0,
0, 0, 8, 0, 0, 0,
140, 0, 0, 20, 50, 0,
16, 0, 2, 0, 0, 0,
2, 64, 0, 0, 22, 0,
0, 0, 22, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
8, 0, 0, 0, 11, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 35, 0, 0, 12,
82, 0, 16, 0, 1, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 16, 0,
0, 0, 0, 0, 0, 0,
6, 1, 16, 0, 2, 0,
0, 0, 140, 0, 0, 17,
82, 0, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
5, 0, 0, 0, 0, 0,
0, 0, 5, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 3, 0,
0, 0, 0, 0, 0, 0,
246, 15, 16, 0, 1, 0,
0, 0, 6, 2, 16, 0,
1, 0, 0, 0, 140, 0,
0, 16, 82, 0, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 6, 0,
0, 0, 0, 0, 0, 0,
9, 0, 0, 0, 0, 0,
0, 0, 166, 10, 2, 0,
6, 2, 16, 0, 1, 0,
0, 0, 138, 0, 0, 9,
130, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
3, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 1, 0, 0, 7,
18, 0, 16, 0, 2, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 4, 0, 0, 0,
140, 0, 0, 11, 34, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 1, 64, 0, 0,
8, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 35, 0, 0, 9,
34, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 32, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 35, 0, 0, 9,
34, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 4, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 140, 0, 0, 16,
82, 0, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 7, 0,
0, 0, 0, 0, 0, 0,
86, 5, 2, 0, 6, 2,
16, 0, 1, 0, 0, 0,
140, 0, 0, 11, 34, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 9, 0,
0, 0, 1, 64, 0, 0,
3, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 140, 0, 0, 11,
18, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
6, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 18, 0,
0, 1, 139, 0, 0, 8,
34, 0, 16, 0, 1, 0,
0, 0, 1, 64, 0, 0,
27, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
10, 0, 2, 0, 42, 0,
0, 9, 194, 0, 16, 0,
1, 0, 0, 0, 86, 5,
2, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 5, 0, 0, 0,
2, 0, 0, 0, 85, 0,
0, 9, 18, 0, 16, 0,
2, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
5, 0, 0, 0, 35, 0,
0, 9, 34, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 2, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 41, 0,
0, 9, 50, 0, 16, 0,
2, 0, 0, 0, 86, 5,
2, 0, 2, 64, 0, 0,
2, 0, 0, 0, 7, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 41, 0,
0, 7, 66, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 1, 0, 0, 7,
66, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 96, 0, 0, 0,
140, 0, 0, 11, 66, 0,
16, 0, 2, 0, 0, 0,
1, 64, 0, 0, 25, 0,
0, 0, 1, 64, 0, 0,
7, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 1, 0, 0, 10,
50, 0, 16, 0, 2, 0,
0, 0, 70, 0, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 8, 0, 0, 0,
0, 8, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 2, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
2, 0, 0, 0, 140, 0,
0, 10, 66, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
1, 64, 0, 0, 4, 0,
0, 0, 26, 0, 2, 0,
42, 0, 16, 0, 2, 0,
0, 0, 41, 0, 0, 10,
50, 0, 16, 0, 3, 0,
0, 0, 166, 10, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 17, 98, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 25, 0, 0, 0,
25, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 10, 0,
0, 0, 9, 0, 0, 0,
0, 0, 0, 0, 86, 5,
16, 0, 1, 0, 0, 0,
6, 1, 16, 0, 3, 0,
0, 0, 35, 0, 0, 12,
98, 0, 16, 0, 1, 0,
0, 0, 6, 0, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
86, 6, 16, 0, 1, 0,
0, 0, 140, 0, 0, 16,
98, 0, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 1, 0, 0, 0,
0, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
7, 0, 0, 0, 6, 0,
0, 0, 0, 0, 0, 0,
86, 5, 2, 0, 86, 6,
16, 0, 1, 0, 0, 0,
140, 0, 0, 11, 34, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 12, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 26, 0,
16, 0, 2, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 1, 0, 0, 7,
66, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 0, 7, 0, 0,
30, 0, 0, 7, 34, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 0,
0, 7, 66, 0, 16, 0,
1, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
1, 64, 0, 0, 2, 0,
0, 0, 42, 0, 0, 7,
130, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 3, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 6, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 34, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 140, 0,
0, 11, 18, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 42, 0, 16, 0,
2, 0, 0, 0, 26, 0,
16, 0, 1, 0, 0, 0,
21, 0, 0, 1, 18, 0,
0, 1, 35, 0, 0, 9,
34, 0, 16, 0, 1, 0,
0, 0, 42, 0, 2, 0,
58, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 26, 0,
2, 0, 35, 0, 0, 11,
18, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
1, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 21, 0,
0, 1, 30, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 26, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 85, 0, 0, 10,
50, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 2, 0, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
45, 0, 0, 8, 242, 0,
16, 0, 1, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 70, 126, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 30, 0, 0, 7,
18, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
45, 0, 0, 8, 242, 0,
16, 0, 2, 0, 0, 0,
6, 0, 16, 0, 2, 0,
0, 0, 214, 120, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 54, 0, 0, 5,
50, 0, 16, 0, 3, 0,
0, 0, 214, 5, 16, 0,
1, 0, 0, 0, 54, 0,
0, 5, 194, 0, 16, 0,
3, 0, 0, 0, 6, 4,
16, 0, 2, 0, 0, 0,
54, 0, 0, 5, 50, 0,
16, 0, 2, 0, 0, 0,
134, 0, 16, 0, 1, 0,
0, 0, 140, 0, 0, 17,
242, 0, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 2, 64,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
70, 14, 16, 0, 3, 0,
0, 0, 70, 14, 16, 0,
2, 0, 0, 0, 164, 0,
0, 8, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 86, 5, 16, 0,
0, 0, 0, 0, 70, 14,
16, 0, 1, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 85, 0,
0, 10, 242, 0, 16, 0,
2, 0, 0, 0, 70, 14,
16, 0, 2, 0, 0, 0,
2, 64, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 140, 0, 0, 17,
242, 0, 16, 0, 2, 0,
0, 0, 2, 64, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
70, 14, 16, 0, 2, 0,
0, 0, 70, 14, 16, 0,
3, 0, 0, 0, 164, 0,
0, 8, 242, 224, 33, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
1, 0, 0, 0, 70, 14,
16, 0, 2, 0, 0, 0,
55, 0, 0, 9, 130, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
16, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
30, 0, 0, 7, 18, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 45, 0,
0, 8, 242, 0, 16, 0,
1, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
70, 126, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
30, 0, 0, 10, 50, 0,
16, 0, 0, 0, 0, 0,
70, 0, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
1, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 45, 0,
0, 8, 242, 0, 16, 0,
2, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
214, 120, 32, 0, 0, 0,
0, 0, 0, 0, 0, 0,
54, 0, 0, 5, 50, 0,
16, 0, 3, 0, 0, 0,
214, 5, 16, 0, 1, 0,
0, 0, 54, 0, 0, 5,
194, 0, 16, 0, 3, 0,
0, 0, 6, 4, 16, 0,
2, 0, 0, 0, 54, 0,
0, 5, 50, 0, 16, 0,
2, 0, 0, 0, 134, 0,
16, 0, 1, 0, 0, 0,
140, 0, 0, 17, 242, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 2, 64, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 70, 14,
16, 0, 3, 0, 0, 0,
70, 14, 16, 0, 2, 0,
0, 0, 164, 0, 0, 8,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 0, 0,
0, 0, 70, 14, 16, 0,
1, 0, 0, 0, 30, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 85, 0, 0, 10,
242, 0, 16, 0, 1, 0,
0, 0, 70, 14, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
140, 0, 0, 17, 242, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 16, 0,
0, 0, 16, 0, 0, 0,
16, 0, 0, 0, 16, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 70, 14,
16, 0, 1, 0, 0, 0,
70, 14, 16, 0, 3, 0,
0, 0, 164, 0, 0, 8,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 70, 14, 16, 0,
1, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 104, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
37, 0, 0, 0, 18, 0,
0, 0, 4, 0, 0, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 7, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0
};

1877
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_3x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1060
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_cs.h generated
View File

File diff suppressed because it is too large Load Diff

922
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_8bpb_scaled_cs.h generated Normal file
View File

@ -0,0 +1,922 @@
#if 0
//
// Generated by Microsoft (R) HLSL Shader Compiler 10.1
//
//
// Buffer Definitions:
//
// cbuffer XeTextureLoadConstants
// {
//
// uint xe_texture_load_is_tiled_3d_endian_scale;// Offset: 0 Size: 4
// uint xe_texture_load_guest_offset; // Offset: 4 Size: 4
// uint xe_texture_load_guest_pitch_aligned;// Offset: 8 Size: 4
// uint xe_texture_load_guest_z_stride_block_rows_aligned;// Offset: 12 Size: 4
// uint3 xe_texture_load_size_blocks; // Offset: 16 Size: 12
// uint xe_texture_load_host_offset; // Offset: 28 Size: 4
// uint xe_texture_load_host_pitch; // Offset: 32 Size: 4
// uint xe_texture_load_height_texels;// Offset: 36 Size: 4 [unused]
//
// }
//
//
// Resource Bindings:
//
// Name Type Format Dim ID HLSL Bind Count
// ------------------------------ ---------- ------- ----------- ------- -------------- ------
// xe_texture_load_source texture uint2 buf T0 t0 1
// xe_texture_load_dest UAV uint4 buf U0 u0 1
// XeTextureLoadConstants cbuffer NA NA CB0 cb0 1
//
//
//
// Input signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Input
//
// Output signature:
//
// Name Index Mask Register SysValue Format Used
// -------------------- ----- ------ -------- -------- ------- ------
// no Output
cs_5_1
dcl_globalFlags refactoringAllowed
dcl_constantbuffer CB0[0:0][3], immediateIndexed, space=0
dcl_resource_buffer (uint,uint,uint,uint) T0[0:0], space=0
dcl_uav_typed_buffer (uint,uint,uint,uint) U0[0:0], space=0
dcl_input vThreadID.xyz
dcl_temps 5
dcl_thread_group 2, 32, 1
ishl r0.x, vThreadID.x, l(4)
mov r0.yz, vThreadID.yyzy
uge r0.yzw, r0.xxyz, CB0[0][1].xxyz
or r0.y, r0.z, r0.y
or r0.y, r0.w, r0.y
if_nz r0.y
ret
endif
imad r0.y, vThreadID.z, CB0[0][1].y, vThreadID.y
imad r0.y, r0.y, CB0[0][2].x, r0.x
iadd r0.y, r0.y, CB0[0][1].w
and r0.z, CB0[0][0].x, l(2)
ubfe r1.xy, l(2, 2, 0, 0), l(4, 6, 0, 0), CB0[0][0].xxxx
ushr r2.x, r0.x, l(3)
mov r2.y, vThreadID.y
udiv r0.xw, null, r2.xxxy, r1.xxxy
if_nz r0.z
ishr r1.zw, r0.wwww, l(0, 0, 4, 3)
ishr r0.z, vThreadID.z, l(2)
ushr r2.zw, CB0[0][0].wwwz, l(0, 0, 4, 5)
imad r1.z, r0.z, r2.z, r1.z
ibfe r3.xy, l(27, 29, 0, 0), l(2, 0, 0, 0), r0.xxxx
imad r1.z, r1.z, r2.w, r3.x
ishl r2.z, r0.w, l(8)
ishr r2.z, r2.z, l(6)
iadd r0.z, r0.z, r1.w
bfi r1.w, l(1), l(1), r0.z, l(0)
iadd r1.w, r1.w, r3.y
bfi r1.w, l(2), l(1), r1.w, l(0)
bfi r0.z, l(1), l(0), r0.z, r1.w
and r2.zw, r2.zzzz, l(0, 0, 16, 8)
bfi r1.zw, l(0, 0, 22, 22), l(0, 0, 8, 11), r1.zzzz, l(0, 0, 0, 0)
imad r1.zw, r2.zzzz, l(0, 0, 2, 16), r1.zzzw
bfi r1.zw, l(0, 0, 5, 5), l(0, 0, 0, 3), r2.wwww, r1.zzzw
bfi r1.zw, l(0, 0, 2, 2), l(0, 0, 6, 9), vThreadID.zzzz, r1.zzzw
ubfe r2.z, l(3), l(6), r1.z
and r2.w, r0.z, l(6)
bfi r0.z, l(1), l(8), r0.z, l(0)
imad r0.z, r2.z, l(32), r0.z
imad r0.z, r2.w, l(4), r0.z
bfi r1.zw, l(0, 0, 1, 1), l(0, 0, 4, 7), r0.wwww, r1.zzzw
bfi r0.z, l(9), l(3), r0.z, r1.w
bfi r0.z, l(6), l(0), r1.z, r0.z
else
ibfe r1.zw, l(0, 0, 27, 29), l(0, 0, 2, 0), r0.xxxx
ishr r2.zw, r0.wwww, l(0, 0, 5, 2)
ushr r3.x, CB0[0][0].z, l(5)
imad r1.z, r2.z, r3.x, r1.z
ishl r3.xy, r0.wwww, l(2, 7, 0, 0)
ishl r2.z, r3.x, l(1)
and r2.z, r2.z, l(96)
bfi r3.z, l(25), l(7), r1.z, r2.z
and r3.xy, r3.xyxx, l(8, 2048, 0, 0)
iadd r3.z, r3.z, r3.x
ishl r4.xy, r2.zzzz, l(3, 2, 0, 0)
bfi r4.xy, l(25, 25, 0, 0), l(10, 9, 0, 0), r1.zzzz, r4.xyxx
imad r3.xw, r3.xxxx, l(8, 0, 0, 4), r4.xxxy
bfi r3.xzw, l(1, 0, 1, 1), l(7, 0, 4, 6), r0.wwww, r3.xxzw
bfi r1.z, l(12), l(0), r3.y, r3.x
and r2.z, r3.w, l(1792)
iadd r1.z, r1.z, r2.z
and r2.z, r2.w, l(2)
iadd r1.w, r1.w, r2.z
bfi r1.w, l(2), l(6), r1.w, l(0)
iadd r1.z, r1.z, r1.w
bfi r0.z, l(6), l(0), r3.z, r1.z
endif
imad r0.xw, -r0.xxxw, r1.xxxy, r2.xxxy
imul null, r1.z, r1.y, r1.x
imad r0.x, r0.x, r1.y, r0.w
ishl r0.x, r0.x, l(3)
imad r0.x, r0.z, r1.z, r0.x
iadd r0.x, r0.x, CB0[0][0].y
ushr r0.xy, r0.xyxx, l(3, 4, 0, 0)
ld r3.xy, r0.xxxx, T0[0].xyzw
ult r0.z, l(1), r1.x
if_nz r0.z
udiv r0.z, null, r2.x, r1.x
imad r0.z, -r0.z, r1.x, r2.x
iadd r0.w, r0.z, l(1)
ieq r0.w, r1.x, r0.w
if_nz r0.w
ishl r0.w, r1.x, l(6)
ishl r0.z, r0.z, l(3)
iadd r0.z, -r0.z, r0.w
else
mov r0.z, l(8)
endif
else
mov r0.z, l(64)
endif
imul null, r0.z, r1.y, r0.z
ushr r0.z, r0.z, l(3)
iadd r0.x, r0.z, r0.x
ld r3.zw, r0.xxxx, T0[0].zwxy
store_uav_typed U0[0].xyzw, r0.yyyy, r3.xyzw
ret
// Approximately 97 instruction slots used
#endif
const BYTE texture_load_8bpb_scaled_cs[] =
{
68, 88, 66, 67, 240, 96,
141, 60, 254, 240, 162, 218,
255, 165, 237, 94, 178, 76,
40, 219, 1, 0, 0, 0,
252, 17, 0, 0, 5, 0,
0, 0, 52, 0, 0, 0,
28, 4, 0, 0, 44, 4,
0, 0, 60, 4, 0, 0,
96, 17, 0, 0, 82, 68,
69, 70, 224, 3, 0, 0,
1, 0, 0, 0, 248, 0,
0, 0, 3, 0, 0, 0,
60, 0, 0, 0, 1, 5,
83, 67, 0, 5, 4, 0,
181, 3, 0, 0, 19, 19,
68, 37, 60, 0, 0, 0,
24, 0, 0, 0, 40, 0,
0, 0, 40, 0, 0, 0,
36, 0, 0, 0, 12, 0,
0, 0, 0, 0, 0, 0,
180, 0, 0, 0, 2, 0,
0, 0, 4, 0, 0, 0,
1, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
1, 0, 0, 0, 4, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 203, 0,
0, 0, 4, 0, 0, 0,
4, 0, 0, 0, 1, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 1, 0,
0, 0, 12, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 224, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 115, 111,
117, 114, 99, 101, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 100, 101, 115,
116, 0, 88, 101, 84, 101,
120, 116, 117, 114, 101, 76,
111, 97, 100, 67, 111, 110,
115, 116, 97, 110, 116, 115,
0, 171, 224, 0, 0, 0,
8, 0, 0, 0, 16, 1,
0, 0, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 80, 2, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
128, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
164, 2, 0, 0, 4, 0,
0, 0, 4, 0, 0, 0,
2, 0, 0, 0, 128, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 193, 2,
0, 0, 8, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 128, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 229, 2, 0, 0,
12, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
128, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
23, 3, 0, 0, 16, 0,
0, 0, 12, 0, 0, 0,
2, 0, 0, 0, 60, 3,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 96, 3,
0, 0, 28, 0, 0, 0,
4, 0, 0, 0, 2, 0,
0, 0, 128, 2, 0, 0,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 124, 3, 0, 0,
32, 0, 0, 0, 4, 0,
0, 0, 2, 0, 0, 0,
128, 2, 0, 0, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 255, 255,
255, 255, 0, 0, 0, 0,
151, 3, 0, 0, 36, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 128, 2,
0, 0, 0, 0, 0, 0,
255, 255, 255, 255, 0, 0,
0, 0, 255, 255, 255, 255,
0, 0, 0, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 105, 115, 95, 116,
105, 108, 101, 100, 95, 51,
100, 95, 101, 110, 100, 105,
97, 110, 95, 115, 99, 97,
108, 101, 0, 100, 119, 111,
114, 100, 0, 171, 0, 0,
19, 0, 1, 0, 1, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
121, 2, 0, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 103, 117, 101, 115,
116, 95, 111, 102, 102, 115,
101, 116, 0, 120, 101, 95,
116, 101, 120, 116, 117, 114,
101, 95, 108, 111, 97, 100,
95, 103, 117, 101, 115, 116,
95, 112, 105, 116, 99, 104,
95, 97, 108, 105, 103, 110,
101, 100, 0, 120, 101, 95,
116, 101, 120, 116, 117, 114,
101, 95, 108, 111, 97, 100,
95, 103, 117, 101, 115, 116,
95, 122, 95, 115, 116, 114,
105, 100, 101, 95, 98, 108,
111, 99, 107, 95, 114, 111,
119, 115, 95, 97, 108, 105,
103, 110, 101, 100, 0, 120,
101, 95, 116, 101, 120, 116,
117, 114, 101, 95, 108, 111,
97, 100, 95, 115, 105, 122,
101, 95, 98, 108, 111, 99,
107, 115, 0, 117, 105, 110,
116, 51, 0, 171, 171, 171,
1, 0, 19, 0, 1, 0,
3, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 51, 3, 0, 0,
120, 101, 95, 116, 101, 120,
116, 117, 114, 101, 95, 108,
111, 97, 100, 95, 104, 111,
115, 116, 95, 111, 102, 102,
115, 101, 116, 0, 120, 101,
95, 116, 101, 120, 116, 117,
114, 101, 95, 108, 111, 97,
100, 95, 104, 111, 115, 116,
95, 112, 105, 116, 99, 104,
0, 120, 101, 95, 116, 101,
120, 116, 117, 114, 101, 95,
108, 111, 97, 100, 95, 104,
101, 105, 103, 104, 116, 95,
116, 101, 120, 101, 108, 115,
0, 77, 105, 99, 114, 111,
115, 111, 102, 116, 32, 40,
82, 41, 32, 72, 76, 83,
76, 32, 83, 104, 97, 100,
101, 114, 32, 67, 111, 109,
112, 105, 108, 101, 114, 32,
49, 48, 46, 49, 0, 171,
171, 171, 73, 83, 71, 78,
8, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
79, 83, 71, 78, 8, 0,
0, 0, 0, 0, 0, 0,
8, 0, 0, 0, 83, 72,
69, 88, 28, 13, 0, 0,
81, 0, 5, 0, 71, 3,
0, 0, 106, 8, 0, 1,
89, 0, 0, 7, 70, 142,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
0, 0, 0, 0, 88, 8,
0, 7, 70, 126, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
68, 68, 0, 0, 0, 0,
0, 0, 156, 8, 0, 7,
70, 238, 49, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 68, 68,
0, 0, 0, 0, 0, 0,
95, 0, 0, 2, 114, 0,
2, 0, 104, 0, 0, 2,
5, 0, 0, 0, 155, 0,
0, 4, 2, 0, 0, 0,
32, 0, 0, 0, 1, 0,
0, 0, 41, 0, 0, 6,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 2, 0,
1, 64, 0, 0, 4, 0,
0, 0, 54, 0, 0, 4,
98, 0, 16, 0, 0, 0,
0, 0, 86, 6, 2, 0,
80, 0, 0, 9, 226, 0,
16, 0, 0, 0, 0, 0,
6, 9, 16, 0, 0, 0,
0, 0, 6, 137, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
60, 0, 0, 7, 34, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 26, 0, 16, 0,
0, 0, 0, 0, 60, 0,
0, 7, 34, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
26, 0, 16, 0, 0, 0,
0, 0, 62, 0, 0, 1,
21, 0, 0, 1, 35, 0,
0, 9, 34, 0, 16, 0,
0, 0, 0, 0, 42, 0,
2, 0, 26, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
26, 0, 2, 0, 35, 0,
0, 11, 34, 0, 16, 0,
0, 0, 0, 0, 26, 0,
16, 0, 0, 0, 0, 0,
10, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
30, 0, 0, 9, 34, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 0, 0,
0, 0, 58, 128, 48, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 9, 66, 0,
16, 0, 0, 0, 0, 0,
10, 128, 48, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
138, 0, 0, 17, 50, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 2, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
4, 0, 0, 0, 6, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 6, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 85, 0, 0, 7,
18, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 3, 0, 0, 0,
54, 0, 0, 4, 34, 0,
16, 0, 2, 0, 0, 0,
26, 0, 2, 0, 78, 0,
0, 8, 146, 0, 16, 0,
0, 0, 0, 0, 0, 208,
0, 0, 6, 4, 16, 0,
2, 0, 0, 0, 6, 4,
16, 0, 1, 0, 0, 0,
31, 0, 4, 3, 42, 0,
16, 0, 0, 0, 0, 0,
42, 0, 0, 10, 194, 0,
16, 0, 1, 0, 0, 0,
246, 15, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
3, 0, 0, 0, 42, 0,
0, 6, 66, 0, 16, 0,
0, 0, 0, 0, 42, 0,
2, 0, 1, 64, 0, 0,
2, 0, 0, 0, 85, 0,
0, 12, 194, 0, 16, 0,
2, 0, 0, 0, 246, 139,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
5, 0, 0, 0, 35, 0,
0, 9, 66, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 139, 0,
0, 15, 50, 0, 16, 0,
3, 0, 0, 0, 2, 64,
0, 0, 27, 0, 0, 0,
29, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
2, 64, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 6, 0, 16, 0,
0, 0, 0, 0, 35, 0,
0, 9, 66, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
3, 0, 0, 0, 41, 0,
0, 7, 66, 0, 16, 0,
2, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 8, 0,
0, 0, 42, 0, 0, 7,
66, 0, 16, 0, 2, 0,
0, 0, 42, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 140, 0,
0, 11, 130, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 130, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 26, 0, 16, 0,
3, 0, 0, 0, 140, 0,
0, 11, 130, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
140, 0, 0, 11, 66, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 1, 0, 0, 10,
194, 0, 16, 0, 2, 0,
0, 0, 166, 10, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 16, 0,
0, 0, 8, 0, 0, 0,
140, 0, 0, 20, 194, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
22, 0, 0, 0, 22, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 8, 0, 0, 0,
11, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 35, 0, 0, 12,
194, 0, 16, 0, 1, 0,
0, 0, 166, 10, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 16, 0, 0, 0,
166, 14, 16, 0, 1, 0,
0, 0, 140, 0, 0, 17,
194, 0, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 5, 0, 0, 0,
5, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 3, 0, 0, 0,
246, 15, 16, 0, 2, 0,
0, 0, 166, 14, 16, 0,
1, 0, 0, 0, 140, 0,
0, 16, 194, 0, 16, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 2, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
6, 0, 0, 0, 9, 0,
0, 0, 166, 10, 2, 0,
166, 14, 16, 0, 1, 0,
0, 0, 138, 0, 0, 9,
66, 0, 16, 0, 2, 0,
0, 0, 1, 64, 0, 0,
3, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 1, 0, 0, 7,
130, 0, 16, 0, 2, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
140, 0, 0, 11, 66, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 1, 0,
0, 0, 1, 64, 0, 0,
8, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 35, 0, 0, 9,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 32, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 35, 0, 0, 9,
66, 0, 16, 0, 0, 0,
0, 0, 58, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 4, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 140, 0, 0, 17,
194, 0, 16, 0, 1, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 2, 64,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 7, 0, 0, 0,
246, 15, 16, 0, 0, 0,
0, 0, 166, 14, 16, 0,
1, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 9, 0, 0, 0,
1, 64, 0, 0, 3, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 58, 0,
16, 0, 1, 0, 0, 0,
140, 0, 0, 11, 66, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 6, 0,
0, 0, 1, 64, 0, 0,
0, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 18, 0, 0, 1,
139, 0, 0, 15, 194, 0,
16, 0, 1, 0, 0, 0,
2, 64, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
27, 0, 0, 0, 29, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0,
0, 0, 0, 0, 6, 0,
16, 0, 0, 0, 0, 0,
42, 0, 0, 10, 194, 0,
16, 0, 2, 0, 0, 0,
246, 15, 16, 0, 0, 0,
0, 0, 2, 64, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 5, 0, 0, 0,
2, 0, 0, 0, 85, 0,
0, 9, 18, 0, 16, 0,
3, 0, 0, 0, 42, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 1, 64, 0, 0,
5, 0, 0, 0, 35, 0,
0, 9, 66, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 41, 0,
0, 10, 50, 0, 16, 0,
3, 0, 0, 0, 246, 15,
16, 0, 0, 0, 0, 0,
2, 64, 0, 0, 2, 0,
0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 41, 0, 0, 7,
66, 0, 16, 0, 2, 0,
0, 0, 10, 0, 16, 0,
3, 0, 0, 0, 1, 64,
0, 0, 1, 0, 0, 0,
1, 0, 0, 7, 66, 0,
16, 0, 2, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 1, 64, 0, 0,
96, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
3, 0, 0, 0, 1, 64,
0, 0, 25, 0, 0, 0,
1, 64, 0, 0, 7, 0,
0, 0, 42, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 2, 0, 0, 0,
1, 0, 0, 10, 50, 0,
16, 0, 3, 0, 0, 0,
70, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
8, 0, 0, 0, 0, 8,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
3, 0, 0, 0, 42, 0,
16, 0, 3, 0, 0, 0,
10, 0, 16, 0, 3, 0,
0, 0, 41, 0, 0, 10,
50, 0, 16, 0, 4, 0,
0, 0, 166, 10, 16, 0,
2, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
140, 0, 0, 17, 50, 0,
16, 0, 4, 0, 0, 0,
2, 64, 0, 0, 25, 0,
0, 0, 25, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 2, 64, 0, 0,
10, 0, 0, 0, 9, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 166, 10,
16, 0, 1, 0, 0, 0,
70, 0, 16, 0, 4, 0,
0, 0, 35, 0, 0, 12,
146, 0, 16, 0, 3, 0,
0, 0, 6, 0, 16, 0,
3, 0, 0, 0, 2, 64,
0, 0, 8, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
6, 4, 16, 0, 4, 0,
0, 0, 140, 0, 0, 17,
210, 0, 16, 0, 3, 0,
0, 0, 2, 64, 0, 0,
1, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0,
1, 0, 0, 0, 2, 64,
0, 0, 7, 0, 0, 0,
0, 0, 0, 0, 4, 0,
0, 0, 6, 0, 0, 0,
246, 15, 16, 0, 0, 0,
0, 0, 6, 14, 16, 0,
3, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 12, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 26, 0, 16, 0,
3, 0, 0, 0, 10, 0,
16, 0, 3, 0, 0, 0,
1, 0, 0, 7, 66, 0,
16, 0, 2, 0, 0, 0,
58, 0, 16, 0, 3, 0,
0, 0, 1, 64, 0, 0,
0, 7, 0, 0, 30, 0,
0, 7, 66, 0, 16, 0,
1, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 2, 0,
0, 0, 1, 0, 0, 7,
66, 0, 16, 0, 2, 0,
0, 0, 58, 0, 16, 0,
2, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
30, 0, 0, 7, 130, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
2, 0, 0, 0, 140, 0,
0, 11, 130, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 2, 0, 0, 0,
1, 64, 0, 0, 6, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 0, 0, 0, 0,
30, 0, 0, 7, 66, 0,
16, 0, 1, 0, 0, 0,
42, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
1, 0, 0, 0, 140, 0,
0, 11, 66, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
1, 64, 0, 0, 0, 0,
0, 0, 42, 0, 16, 0,
3, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
21, 0, 0, 1, 35, 0,
0, 10, 146, 0, 16, 0,
0, 0, 0, 0, 6, 12,
16, 128, 65, 0, 0, 0,
0, 0, 0, 0, 6, 4,
16, 0, 1, 0, 0, 0,
6, 4, 16, 0, 2, 0,
0, 0, 38, 0, 0, 8,
0, 208, 0, 0, 66, 0,
16, 0, 1, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 35, 0,
0, 9, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 58, 0, 16, 0,
0, 0, 0, 0, 41, 0,
0, 7, 18, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 3, 0,
0, 0, 35, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 1, 0, 0, 0,
10, 0, 16, 0, 0, 0,
0, 0, 30, 0, 0, 9,
18, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
0, 0, 0, 0, 26, 128,
48, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 85, 0, 0, 10,
50, 0, 16, 0, 0, 0,
0, 0, 70, 0, 16, 0,
0, 0, 0, 0, 2, 64,
0, 0, 3, 0, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
45, 0, 0, 8, 50, 0,
16, 0, 3, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 70, 126, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 79, 0, 0, 7,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
31, 0, 4, 3, 42, 0,
16, 0, 0, 0, 0, 0,
78, 0, 0, 8, 66, 0,
16, 0, 0, 0, 0, 0,
0, 208, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
10, 0, 16, 0, 1, 0,
0, 0, 35, 0, 0, 10,
66, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 128,
65, 0, 0, 0, 0, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 10, 0,
16, 0, 2, 0, 0, 0,
30, 0, 0, 7, 130, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
1, 0, 0, 0, 32, 0,
0, 7, 130, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 1, 0, 0, 0,
58, 0, 16, 0, 0, 0,
0, 0, 31, 0, 4, 3,
58, 0, 16, 0, 0, 0,
0, 0, 41, 0, 0, 7,
130, 0, 16, 0, 0, 0,
0, 0, 10, 0, 16, 0,
1, 0, 0, 0, 1, 64,
0, 0, 6, 0, 0, 0,
41, 0, 0, 7, 66, 0,
16, 0, 0, 0, 0, 0,
42, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
3, 0, 0, 0, 30, 0,
0, 8, 66, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 128, 65, 0, 0, 0,
0, 0, 0, 0, 58, 0,
16, 0, 0, 0, 0, 0,
18, 0, 0, 1, 54, 0,
0, 5, 66, 0, 16, 0,
0, 0, 0, 0, 1, 64,
0, 0, 8, 0, 0, 0,
21, 0, 0, 1, 18, 0,
0, 1, 54, 0, 0, 5,
66, 0, 16, 0, 0, 0,
0, 0, 1, 64, 0, 0,
64, 0, 0, 0, 21, 0,
0, 1, 38, 0, 0, 8,
0, 208, 0, 0, 66, 0,
16, 0, 0, 0, 0, 0,
26, 0, 16, 0, 1, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 85, 0,
0, 7, 66, 0, 16, 0,
0, 0, 0, 0, 42, 0,
16, 0, 0, 0, 0, 0,
1, 64, 0, 0, 3, 0,
0, 0, 30, 0, 0, 7,
18, 0, 16, 0, 0, 0,
0, 0, 42, 0, 16, 0,
0, 0, 0, 0, 10, 0,
16, 0, 0, 0, 0, 0,
45, 0, 0, 8, 194, 0,
16, 0, 3, 0, 0, 0,
6, 0, 16, 0, 0, 0,
0, 0, 230, 116, 32, 0,
0, 0, 0, 0, 0, 0,
0, 0, 164, 0, 0, 8,
242, 224, 33, 0, 0, 0,
0, 0, 0, 0, 0, 0,
86, 5, 16, 0, 0, 0,
0, 0, 70, 14, 16, 0,
3, 0, 0, 0, 62, 0,
0, 1, 83, 84, 65, 84,
148, 0, 0, 0, 97, 0,
0, 0, 5, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 0, 0,
39, 0, 0, 0, 18, 0,
0, 0, 5, 0, 0, 0,
4, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 4, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 1, 0,
0, 0
};

992
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_ctx1_cs.h generated
View File

File diff suppressed because it is too large Load Diff

2564
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_2x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1998
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_3x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1240
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_cs.h generated
View File

File diff suppressed because it is too large Load Diff

2105
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_32bpb_3x_cs.h → src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_float_scaled_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1862
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_2x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1560
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_3x_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1133
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_cs.h generated
View File

File diff suppressed because it is too large Load Diff

1163
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_depth_unorm_scaled_cs.h generated Normal file
View File

File diff suppressed because it is too large Load Diff

968
src/xenia/gpu/shaders/bytecode/d3d12_5_1/texture_load_dxn_rg8_cs.h generated
View File

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More