From 8e01e2d945e9543465b787e8988c07e51053a715 Mon Sep 17 00:00:00 2001 From: Ben Vanik Date: Sat, 12 Oct 2013 02:29:01 -0700 Subject: [PATCH] Vertex fetching. --- src/xenia/gpu/d3d11/d3d11_graphics_driver.cc | 289 ++- src/xenia/gpu/d3d11/d3d11_graphics_driver.h | 30 +- src/xenia/gpu/d3d11/d3d11_graphics_system.cc | 4 +- src/xenia/gpu/d3d11/d3d11_shader.cc | 55 +- src/xenia/gpu/d3d11/d3d11_shader.h | 11 +- src/xenia/gpu/d3d11/d3d11_shader_cache.cc | 2 +- src/xenia/gpu/d3d11/d3d11_shader_cache.h | 2 +- src/xenia/gpu/d3d11/d3d11_window.cc | 10 +- src/xenia/gpu/graphics_driver.cc | 3 +- src/xenia/gpu/graphics_driver.h | 6 +- src/xenia/gpu/nop/nop_graphics_driver.cc | 7 +- src/xenia/gpu/nop/nop_graphics_driver.h | 2 +- src/xenia/gpu/ring_buffer_worker.cc | 15 +- src/xenia/gpu/shader.cc | 4 - src/xenia/gpu/shader.h | 4 +- src/xenia/gpu/xenos/register_table.inc | 2284 ++++++++++++++++++ src/xenia/gpu/xenos/xenos.h | 84 + src/xenia/types.h | 4 + 18 files changed, 2762 insertions(+), 54 deletions(-) diff --git a/src/xenia/gpu/d3d11/d3d11_graphics_driver.cc b/src/xenia/gpu/d3d11/d3d11_graphics_driver.cc index 2f7dd1b93..c36f867a8 100644 --- a/src/xenia/gpu/d3d11/d3d11_graphics_driver.cc +++ b/src/xenia/gpu/d3d11/d3d11_graphics_driver.cc @@ -10,6 +10,7 @@ #include #include +#include #include @@ -24,13 +25,35 @@ D3D11GraphicsDriver::D3D11GraphicsDriver( GraphicsDriver(memory) { device_ = device; device_->AddRef(); - + device_->GetImmediateContext(&context_); shader_cache_ = new D3D11ShaderCache(device_); + + xe_zero_struct(&state_, sizeof(state_)); + + HRESULT hr; + D3D11_BUFFER_DESC buffer_desc; + xe_zero_struct(&buffer_desc, sizeof(buffer_desc)); + buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + buffer_desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + buffer_desc.ByteWidth = (512 * 4) * sizeof(float); + hr = device_->CreateBuffer( + &buffer_desc, NULL, &state_.constant_buffers.float_constants); + buffer_desc.ByteWidth = (8) * sizeof(int); + hr = device_->CreateBuffer( + &buffer_desc, NULL, &state_.constant_buffers.bool_constants); + buffer_desc.ByteWidth = (32) * sizeof(int); + hr = device_->CreateBuffer( + &buffer_desc, NULL, &state_.constant_buffers.loop_constants); } D3D11GraphicsDriver::~D3D11GraphicsDriver() { + XESAFERELEASE(state_.constant_buffers.float_constants); + XESAFERELEASE(state_.constant_buffers.bool_constants); + XESAFERELEASE(state_.constant_buffers.loop_constants); delete shader_cache_; - device_->Release(); + XESAFERELEASE(context_); + XESAFERELEASE(device_); } void D3D11GraphicsDriver::Initialize() { @@ -70,22 +93,264 @@ void D3D11GraphicsDriver::SetShader( xe_free(source); } - // Prepare for use. - if (shader->Prepare()) { - XELOGGPU("D3D11: failed to prepare shader"); + // Stash for later. + switch (type) { + case XE_GPU_SHADER_TYPE_VERTEX: + state_.vertex_shader = (D3D11VertexShader*)shader; + break; + case XE_GPU_SHADER_TYPE_PIXEL: + state_.pixel_shader = (D3D11PixelShader*)shader; + break; } } -void D3D11GraphicsDriver::DrawIndexed( +void D3D11GraphicsDriver::DrawAutoIndexed( XE_GPU_PRIMITIVE_TYPE prim_type, uint32_t index_count) { + RegisterFile& rf = register_file_; + XELOGGPU("D3D11: draw indexed %d (%d indicies)", prim_type, index_count); - // TODO(benvanik): - // program control - // context misc - // interpolator control - // shader constants / bools / integers - // fetch constants + // Misc state. + UpdateState(); + + // Build constant buffers. + UpdateConstantBuffers(); + + // Bind shaders. + BindShaders(); + + // Switch primitive topology. + // Some are unsupported on D3D11 and must be emulated. + D3D11_PRIMITIVE_TOPOLOGY primitive_topology; + switch (prim_type) { + default: + case XE_GPU_PRIMITIVE_TYPE_POINT_LIST: + primitive_topology = D3D_PRIMITIVE_TOPOLOGY_POINTLIST; + break; + case XE_GPU_PRIMITIVE_TYPE_LINE_LIST: + primitive_topology = D3D_PRIMITIVE_TOPOLOGY_LINELIST; + break; + case XE_GPU_PRIMITIVE_TYPE_LINE_STRIP: + primitive_topology = D3D_PRIMITIVE_TOPOLOGY_LINESTRIP; + break; + case XE_GPU_PRIMITIVE_TYPE_TRIANGLE_LIST: + primitive_topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; + break; + case XE_GPU_PRIMITIVE_TYPE_TRIANGLE_STRIP: + primitive_topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP; + break; + case XE_GPU_PRIMITIVE_TYPE_TRIANGLE_FAN: + case XE_GPU_PRIMITIVE_TYPE_UNKNOWN_07: + case XE_GPU_PRIMITIVE_TYPE_RECTANGLE_LIST: + case XE_GPU_PRIMITIVE_TYPE_LINE_LOOP: + XELOGE("D3D11: unsupported primitive type %d", prim_type); + return; + } + context_->IASetPrimitiveTopology(primitive_topology); + + // Setup all fetchers (vertices/textures). + PrepareFetchers(); + + // Setup index buffer. + PrepareIndexBuffer(); + + // Issue draw. + uint32_t start_index = rf.values[XE_GPU_REG_VGT_INDX_OFFSET].u32; + uint32_t base_vertex = 0; + //context_->DrawIndexed(index_count, start_index, base_vertex); +} + +void D3D11GraphicsDriver::UpdateState() { + //context_->OMSetBlendState(blend_state, blend_factor, sample_mask); + //context_->OMSetDepthStencilState + //context_->RSSetScissorRects + //context_->RSSetState + //context_->RSSetViewports +} + +void D3D11GraphicsDriver::UpdateConstantBuffers() { + RegisterFile& rf = register_file_; + + D3D11_MAPPED_SUBRESOURCE res; + context_->Map( + state_.constant_buffers.float_constants, 0, + D3D11_MAP_WRITE_DISCARD, 0, &res); + memcpy(res.pData, + &rf.values[XE_GPU_REG_SHADER_CONSTANT_000_X], + (512 * 4) * sizeof(float)); + context_->Unmap(state_.constant_buffers.float_constants, 0); + + context_->Map( + state_.constant_buffers.loop_constants, 0, + D3D11_MAP_WRITE_DISCARD, 0, &res); + memcpy(res.pData, + &rf.values[XE_GPU_REG_SHADER_CONSTANT_LOOP_00], + (32) * sizeof(int)); + context_->Unmap(state_.constant_buffers.loop_constants, 0); + + context_->Map( + state_.constant_buffers.bool_constants, 0, + D3D11_MAP_WRITE_DISCARD, 0, &res); + memcpy(res.pData, + &rf.values[XE_GPU_REG_SHADER_CONSTANT_BOOL_000_031], + (8) * sizeof(int)); + context_->Unmap(state_.constant_buffers.bool_constants, 0); +} + +void D3D11GraphicsDriver::BindShaders() { + RegisterFile& rf = register_file_; + xe_gpu_program_cntl_t program_cntl; + program_cntl.dword_0 = rf.values[XE_GPU_REG_SQ_PROGRAM_CNTL].u32; + + // Vertex shader setup. + D3D11VertexShader* vs = state_.vertex_shader; + if (vs) { + if (!vs->is_prepared()) { + // Prepare for use. + if (vs->Prepare(&program_cntl)) { + XELOGGPU("D3D11: failed to prepare vertex shader"); + state_.vertex_shader = NULL; + return; + } + } + + // Bind. + context_->VSSetShader(vs->handle(), NULL, 0); + + // Set constant buffers. + context_->VSSetConstantBuffers( + 0, + sizeof(state_.constant_buffers) / sizeof(ID3D11Buffer*), + (ID3D11Buffer**)&state_.constant_buffers); + + // Setup input layout (as encoded in vertex shader). + context_->IASetInputLayout(vs->input_layout()); + + //context_->VSSetSamplers + //context_->VSSetShaderResources + } + + // Pixel shader setup. + D3D11PixelShader* ps = state_.pixel_shader; + if (ps) { + if (!ps->is_prepared()) { + // Prepare for use. + if (ps->Prepare(&program_cntl)) { + XELOGGPU("D3D11: failed to prepare pixel shader"); + state_.pixel_shader = NULL; + return; + } + } + + // Bind. + context_->PSSetShader(ps->handle(), NULL, 0); + + // Set constant buffers. + context_->PSSetConstantBuffers( + 0, + sizeof(state_.constant_buffers) / sizeof(ID3D11Buffer*), + (ID3D11Buffer**)&state_.constant_buffers); + + //context_->PSSetSamplers + //context_->PSSetShaderResources + } +} + +void D3D11GraphicsDriver::PrepareFetchers() { + RegisterFile& rf = register_file_; + for (int n = 0; n < 32; n++) { + int r = XE_GPU_REG_SHADER_CONSTANT_FETCH_00_0 + n * 6; + xe_gpu_fetch_group_t* group = (xe_gpu_fetch_group_t*)&rf.values[r]; + if (group->type_0 == 0x2) { + PrepareTextureFetcher(n, &group->texture_fetch); + } else { + // TODO(benvanik): verify register numbering. + if (group->type_0 == 0x3) { + PrepareVertexFetcher(n * 3 + 0, &group->vertex_fetch_0); + } + if (group->type_1 == 0x3) { + PrepareVertexFetcher(n * 3 + 1, &group->vertex_fetch_1); + } + if (group->type_2 == 0x3) { + PrepareVertexFetcher(n * 3 + 2, &group->vertex_fetch_2); + } + } + } +} + +void D3D11GraphicsDriver::PrepareVertexFetcher( + int slot, xe_gpu_vertex_fetch_t* fetch) { + uint32_t address = (fetch->address << 2) + address_translation_; + uint32_t size_dwords = fetch->size; + + ID3D11Buffer* buffer = 0; + D3D11_BUFFER_DESC buffer_desc; + xe_zero_struct(&buffer_desc, sizeof(buffer_desc)); + buffer_desc.ByteWidth = size_dwords * 4; + buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + buffer_desc.BindFlags = D3D11_BIND_VERTEX_BUFFER; + buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + device_->CreateBuffer(&buffer_desc, NULL, &buffer); + D3D11_MAPPED_SUBRESOURCE res; + context_->Map(buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &res); + uint32_t* src = (uint32_t*)xe_memory_addr(memory_, address); + uint32_t* dest = (uint32_t*)res.pData; + for (uint32_t n = 0; n < size_dwords; n++) { + union { + uint32_t i; + float f; + } d = {XESWAP32(src[n])}; + XELOGGPU("v%.3d %0.8X %g", n, d.i, d.f); + + dest[n] = XESWAP32(src[n]); + } + context_->Unmap(buffer, 0); + + // TODO(benvanik): fetch from VS. + /*uint32_t stride = 0; + uint32_t offset = 0; + context_->IASetVertexBuffers(slot, 1, &buffer, &stride, &offset);*/ + + buffer->Release(); +} + +void D3D11GraphicsDriver::PrepareTextureFetcher( + int slot, xe_gpu_texture_fetch_t* fetch) { +} + +void D3D11GraphicsDriver::PrepareIndexBuffer() { + RegisterFile& rf = register_file_; + +/* + ID3D11Buffer* buffer = 0; + D3D11_BUFFER_DESC buffer_desc; + xe_zero_struct(&buffer_desc, sizeof(buffer_desc)); + buffer_desc.ByteWidth = size_dwords * 4; + buffer_desc.Usage = D3D11_USAGE_DYNAMIC; + buffer_desc.BindFlags = D3D11_BIND_INDEX_BUFFER; + buffer_desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + device_->CreateBuffer(&buffer_desc, NULL, &buffer); + D3D11_MAPPED_SUBRESOURCE res; + context_->Map(buffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &res); + uint32_t* src = (uint32_t*)xe_memory_addr(memory_, address); + uint32_t* dest = (uint32_t*)res.pData; + for (uint32_t n = 0; n < size_dwords; n++) { + union { + uint32_t i; + float f; + } d = {XESWAP32(src[n])}; + XELOGGPU("v%.3d %0.8X %g", n, d.i, d.f); + + dest[n] = XESWAP32(src[n]); + } + context_->Unmap(buffer, 0); + + DXGI_FORMAT format; + format = DXGI_FORMAT_R16_UINT; + format = DXGI_FORMAT_R32_UINT; + context_->IASetIndexBuffer(buffer, format, 0); + + buffer->Release();*/ } diff --git a/src/xenia/gpu/d3d11/d3d11_graphics_driver.h b/src/xenia/gpu/d3d11/d3d11_graphics_driver.h index 15bab3d53..b49ae0d20 100644 --- a/src/xenia/gpu/d3d11/d3d11_graphics_driver.h +++ b/src/xenia/gpu/d3d11/d3d11_graphics_driver.h @@ -23,7 +23,9 @@ namespace xe { namespace gpu { namespace d3d11 { +class D3D11PixelShader; class D3D11ShaderCache; +class D3D11VertexShader; class D3D11GraphicsDriver : public GraphicsDriver { @@ -40,14 +42,36 @@ public: uint32_t address, uint32_t start, uint32_t length); - virtual void DrawIndexed( + virtual void DrawAutoIndexed( xenos::XE_GPU_PRIMITIVE_TYPE prim_type, uint32_t index_count); private: - ID3D11Device* device_; + void UpdateState(); + void UpdateConstantBuffers(); + void BindShaders(); + void PrepareFetchers(); + void PrepareVertexFetcher( + int slot, xenos::xe_gpu_vertex_fetch_t* fetch); + void PrepareTextureFetcher( + int slot, xenos::xe_gpu_texture_fetch_t* fetch); + void PrepareIndexBuffer(); - D3D11ShaderCache* shader_cache_; +private: + ID3D11Device* device_; + ID3D11DeviceContext* context_; + D3D11ShaderCache* shader_cache_; + + struct { + D3D11VertexShader* vertex_shader; + D3D11PixelShader* pixel_shader; + + struct { + ID3D11Buffer* float_constants; + ID3D11Buffer* bool_constants; + ID3D11Buffer* loop_constants; + } constant_buffers; + } state_; }; diff --git a/src/xenia/gpu/d3d11/d3d11_graphics_system.cc b/src/xenia/gpu/d3d11/d3d11_graphics_system.cc index 2aeb79607..d3266f440 100644 --- a/src/xenia/gpu/d3d11/d3d11_graphics_system.cc +++ b/src/xenia/gpu/d3d11/d3d11_graphics_system.cc @@ -30,8 +30,8 @@ D3D11GraphicsSystem::D3D11GraphicsSystem(const CreationParams* params) : } D3D11GraphicsSystem::~D3D11GraphicsSystem() { - if (device_) device_->Release(); - if (dxgi_factory_) dxgi_factory_->Release(); + XESAFERELEASE(device_); + XESAFERELEASE(dxgi_factory_); delete window_; } diff --git a/src/xenia/gpu/d3d11/d3d11_shader.cc b/src/xenia/gpu/d3d11/d3d11_shader.cc index da3592ade..2f22c779c 100644 --- a/src/xenia/gpu/d3d11/d3d11_shader.cc +++ b/src/xenia/gpu/d3d11/d3d11_shader.cc @@ -27,7 +27,7 @@ D3D11Shader::D3D11Shader( } D3D11Shader::~D3D11Shader() { - device_->Release(); + XESAFERELEASE(device_); } @@ -35,21 +35,48 @@ D3D11VertexShader::D3D11VertexShader( ID3D11Device* device, const uint8_t* src_ptr, size_t length, uint64_t hash) : - handle_(0), + handle_(0), input_layout_(0), D3D11Shader(device, XE_GPU_SHADER_TYPE_VERTEX, src_ptr, length, hash) { } D3D11VertexShader::~D3D11VertexShader() { - if (handle_) handle_->Release(); + XESAFERELEASE(input_layout_); + XESAFERELEASE(handle_); } -int D3D11VertexShader::Prepare() { +int D3D11VertexShader::Prepare(xe_gpu_program_cntl_t* program_cntl) { if (handle_) { return 0; } - // TODO(benvanik): translate/etc. + const void* byte_code = NULL; + size_t byte_code_length = 0; + + // Create shader. + HRESULT hr = device_->CreateVertexShader( + byte_code, byte_code_length, + NULL, + &handle_); + if (FAILED(hr)) { + XELOGE("D3D11: failed to create vertex shader"); + return 1; + } + + // Create input layout. + uint32_t element_count = 0; + D3D11_INPUT_ELEMENT_DESC* element_descs = 0; + hr = device_->CreateInputLayout( + element_descs, + element_count, + byte_code, byte_code_length, + &input_layout_); + if (FAILED(hr)) { + XELOGE("D3D11: failed to create vertex shader input layout"); + return 1; + } + + is_prepared_ = true; return 0; } @@ -64,14 +91,26 @@ D3D11PixelShader::D3D11PixelShader( } D3D11PixelShader::~D3D11PixelShader() { - if (handle_) handle_->Release(); + XESAFERELEASE(handle_); } -int D3D11PixelShader::Prepare() { +int D3D11PixelShader::Prepare(xe_gpu_program_cntl_t* program_cntl) { if (handle_) { return 0; } - // TODO(benvanik): translate/etc. + const void* byte_code = NULL; + size_t byte_code_length = 0; + + // Create shader. + HRESULT hr = device_->CreatePixelShader( + byte_code, byte_code_length, + NULL, + &handle_); + if (FAILED(hr)) { + XELOGE("D3D11: failed to create vertex shader"); + return 1; + } + is_prepared_ = true; return 0; } diff --git a/src/xenia/gpu/d3d11/d3d11_shader.h b/src/xenia/gpu/d3d11/d3d11_shader.h index c459de6a0..1c06358a5 100644 --- a/src/xenia/gpu/d3d11/d3d11_shader.h +++ b/src/xenia/gpu/d3d11/d3d11_shader.h @@ -13,6 +13,7 @@ #include #include +#include #include @@ -46,10 +47,14 @@ public: uint64_t hash); virtual ~D3D11VertexShader(); - virtual int Prepare(); + ID3D11VertexShader* handle() const { return handle_; } + ID3D11InputLayout* input_layout() const { return input_layout_; } + + int Prepare(xenos::xe_gpu_program_cntl_t* program_cntl); private: ID3D11VertexShader* handle_; + ID3D11InputLayout* input_layout_; }; @@ -61,7 +66,9 @@ public: uint64_t hash); virtual ~D3D11PixelShader(); - virtual int Prepare(); + ID3D11PixelShader* handle() const { return handle_; } + + int Prepare(xenos::xe_gpu_program_cntl_t* program_cntl); private: ID3D11PixelShader* handle_; diff --git a/src/xenia/gpu/d3d11/d3d11_shader_cache.cc b/src/xenia/gpu/d3d11/d3d11_shader_cache.cc index f3d907aad..7f6a5a722 100644 --- a/src/xenia/gpu/d3d11/d3d11_shader_cache.cc +++ b/src/xenia/gpu/d3d11/d3d11_shader_cache.cc @@ -30,7 +30,7 @@ D3D11ShaderCache::~D3D11ShaderCache() { Shader* D3D11ShaderCache::CreateCore( xenos::XE_GPU_SHADER_TYPE type, const uint8_t* src_ptr, size_t length, - uint32_t hash) { + uint64_t hash) { switch (type) { case XE_GPU_SHADER_TYPE_VERTEX: return new D3D11VertexShader( diff --git a/src/xenia/gpu/d3d11/d3d11_shader_cache.h b/src/xenia/gpu/d3d11/d3d11_shader_cache.h index b09d9354c..661fb38f8 100644 --- a/src/xenia/gpu/d3d11/d3d11_shader_cache.h +++ b/src/xenia/gpu/d3d11/d3d11_shader_cache.h @@ -31,7 +31,7 @@ protected: virtual Shader* CreateCore( xenos::XE_GPU_SHADER_TYPE type, const uint8_t* src_ptr, size_t length, - uint32_t hash); + uint64_t hash); protected: ID3D11Device* device_; diff --git a/src/xenia/gpu/d3d11/d3d11_window.cc b/src/xenia/gpu/d3d11/d3d11_window.cc index 18ec13e4a..a08ec8c5f 100644 --- a/src/xenia/gpu/d3d11/d3d11_window.cc +++ b/src/xenia/gpu/d3d11/d3d11_window.cc @@ -82,14 +82,14 @@ D3D11Window::D3D11Window( } D3D11Window::~D3D11Window() { - if (render_target_view_) render_target_view_->Release(); if (context_) { context_->ClearState(); - context_->Release(); } - if (swap_chain_) swap_chain_->Release(); - if (device_) device_->Release(); - if (dxgi_factory_) dxgi_factory_->Release(); + XESAFERELEASE(render_target_view_); + XESAFERELEASE(context_); + XESAFERELEASE(swap_chain_); + XESAFERELEASE(device_); + XESAFERELEASE(dxgi_factory_); } void D3D11Window::Swap() { diff --git a/src/xenia/gpu/graphics_driver.cc b/src/xenia/gpu/graphics_driver.cc index e94eff241..662b4f0ef 100644 --- a/src/xenia/gpu/graphics_driver.cc +++ b/src/xenia/gpu/graphics_driver.cc @@ -14,7 +14,8 @@ using namespace xe; using namespace xe::gpu; -GraphicsDriver::GraphicsDriver(xe_memory_ref memory) { +GraphicsDriver::GraphicsDriver(xe_memory_ref memory) : + address_translation_(0) { memory_ = xe_memory_retain(memory); memset(®ister_file_, 0, sizeof(register_file_)); diff --git a/src/xenia/gpu/graphics_driver.h b/src/xenia/gpu/graphics_driver.h index 24755a095..ae1b47b34 100644 --- a/src/xenia/gpu/graphics_driver.h +++ b/src/xenia/gpu/graphics_driver.h @@ -25,6 +25,9 @@ public: xe_memory_ref memory(); xenos::RegisterFile* register_file() { return ®ister_file_; }; + void set_address_translation(uint32_t value) { + address_translation_ = value; + } virtual void Initialize() = 0; @@ -35,7 +38,7 @@ public: uint32_t address, uint32_t start, uint32_t length) = 0; - virtual void DrawIndexed( + virtual void DrawAutoIndexed( xenos::XE_GPU_PRIMITIVE_TYPE prim_type, uint32_t index_count) = 0; @@ -45,6 +48,7 @@ protected: xe_memory_ref memory_; xenos::RegisterFile register_file_; + uint32_t address_translation_; }; diff --git a/src/xenia/gpu/nop/nop_graphics_driver.cc b/src/xenia/gpu/nop/nop_graphics_driver.cc index c0e7f86d9..023efda2c 100644 --- a/src/xenia/gpu/nop/nop_graphics_driver.cc +++ b/src/xenia/gpu/nop/nop_graphics_driver.cc @@ -64,14 +64,9 @@ void NopGraphicsDriver::SetShader( if (source) { xe_free(source); } - - // Prepare for use. - if (shader->Prepare()) { - XELOGGPU("NOP: failed to prepare shader"); - } } -void NopGraphicsDriver::DrawIndexed( +void NopGraphicsDriver::DrawAutoIndexed( XE_GPU_PRIMITIVE_TYPE prim_type, uint32_t index_count) { XELOGGPU("NOP: draw indexed %d (%d indicies)", diff --git a/src/xenia/gpu/nop/nop_graphics_driver.h b/src/xenia/gpu/nop/nop_graphics_driver.h index 0999fc3df..9da009cbb 100644 --- a/src/xenia/gpu/nop/nop_graphics_driver.h +++ b/src/xenia/gpu/nop/nop_graphics_driver.h @@ -39,7 +39,7 @@ public: uint32_t address, uint32_t start, uint32_t length); - virtual void DrawIndexed( + virtual void DrawAutoIndexed( xenos::XE_GPU_PRIMITIVE_TYPE prim_type, uint32_t index_count); diff --git a/src/xenia/gpu/ring_buffer_worker.cc b/src/xenia/gpu/ring_buffer_worker.cc index 669102048..c86c68171 100644 --- a/src/xenia/gpu/ring_buffer_worker.cc +++ b/src/xenia/gpu/ring_buffer_worker.cc @@ -98,6 +98,9 @@ void RingBufferWorker::ExecuteSegment(uint32_t ptr, uint32_t length) { // Adjust pointer base. ptr = (primary_buffer_ptr_ & ~0x1FFFFFFF) | (ptr & 0x1FFFFFFF); + // Tell the driver what to use for translation. + driver_->set_address_translation(primary_buffer_ptr_ & ~0x1FFFFFFF); + #define LOG_DATA(count) \ for (uint32_t __m = 0; __m < count; __m++) { \ XELOGGPU(" %.8X", XEGETUINT32BE(packet_base + 1 * 4 + __m * 4)); \ @@ -200,6 +203,7 @@ void RingBufferWorker::ExecuteSegment(uint32_t ptr, uint32_t length) { XELOGGPU("Packet(%.8X): PM4_INDIRECT_BUFFER %.8X (%dw)", packet, list_ptr, list_length); ExecuteSegment(list_ptr, list_length); + driver_->set_address_translation(primary_buffer_ptr_ & ~0x1FFFFFFF); } break; @@ -252,8 +256,9 @@ void RingBufferWorker::ExecuteSegment(uint32_t ptr, uint32_t length) { uint32_t d1 = XEGETUINT32BE(packet_base + 2 * 4); uint32_t index_count = d1 >> 16; uint32_t prim_type = d1 & 0x3F; - // Not sure what the other bits mean - 'SrcSel=AutoIndex'? - driver_->DrawIndexed( + uint32_t src_sel = (d0 >> 6) & 0x3; + XEASSERT(src_sel == 0x2); // 'SrcSel=AutoIndex' + driver_->DrawAutoIndexed( (XE_GPU_PRIMITIVE_TYPE)prim_type, index_count); } @@ -266,9 +271,9 @@ void RingBufferWorker::ExecuteSegment(uint32_t ptr, uint32_t length) { uint32_t d0 = XEGETUINT32BE(packet_base + 1 * 4); uint32_t index_count = d0 >> 16; uint32_t prim_type = d0 & 0x3F; - // Not sure what the other bits mean - 'SrcSel=AutoIndex'? - // TODO(benvanik): verify this matches DRAW_INDX - driver_->DrawIndexed( + uint32_t src_sel = (d0 >> 6) & 0x3; + XEASSERT(src_sel == 0x2); // 'SrcSel=AutoIndex' + driver_->DrawAutoIndexed( (XE_GPU_PRIMITIVE_TYPE)prim_type, index_count); } diff --git a/src/xenia/gpu/shader.cc b/src/xenia/gpu/shader.cc index bb745daa2..2f355cc35 100644 --- a/src/xenia/gpu/shader.cc +++ b/src/xenia/gpu/shader.cc @@ -41,7 +41,3 @@ Shader::~Shader() { char* Shader::Disassemble() { return DisassembleShader(type_, dwords_, dword_count_); } - -int Shader::Prepare() { - return 0; -} diff --git a/src/xenia/gpu/shader.h b/src/xenia/gpu/shader.h index 5a6e1b985..4dacfa295 100644 --- a/src/xenia/gpu/shader.h +++ b/src/xenia/gpu/shader.h @@ -29,6 +29,7 @@ public: const uint32_t* dwords() const { return dwords_; } size_t dword_count() const { return dword_count_; } uint64_t hash() const { return hash_; } + bool is_prepared() const { return is_prepared_; } // vfetch formats // sampler formats @@ -37,13 +38,12 @@ public: // NOTE: xe_free() the returned string! char* Disassemble(); - virtual int Prepare(); - protected: xenos::XE_GPU_SHADER_TYPE type_; uint32_t* dwords_; size_t dword_count_; uint64_t hash_; + bool is_prepared_; }; diff --git a/src/xenia/gpu/xenos/register_table.inc b/src/xenia/gpu/xenos/register_table.inc index f9587c668..a440627af 100644 --- a/src/xenia/gpu/xenos/register_table.inc +++ b/src/xenia/gpu/xenos/register_table.inc @@ -181,6 +181,2290 @@ XE_GPU_REGISTER(0x2385, float, PA_CL_POINT_Y_RAD) XE_GPU_REGISTER(0x2386, float, PA_CL_POINT_SIZE) XE_GPU_REGISTER(0x2387, float, PA_CL_POINT_CULL_RAD) +XE_GPU_REGISTER(0x4000, float, SHADER_CONSTANT_000_X) +XE_GPU_REGISTER(0x4001, float, SHADER_CONSTANT_000_Y) +XE_GPU_REGISTER(0x4002, float, SHADER_CONSTANT_000_Z) +XE_GPU_REGISTER(0x4003, float, SHADER_CONSTANT_000_W) +XE_GPU_REGISTER(0x4004, float, SHADER_CONSTANT_001_X) +XE_GPU_REGISTER(0x4005, float, SHADER_CONSTANT_001_Y) +XE_GPU_REGISTER(0x4006, float, SHADER_CONSTANT_001_Z) +XE_GPU_REGISTER(0x4007, float, SHADER_CONSTANT_001_W) +XE_GPU_REGISTER(0x4008, float, SHADER_CONSTANT_002_X) +XE_GPU_REGISTER(0x4009, float, SHADER_CONSTANT_002_Y) +XE_GPU_REGISTER(0x400A, float, SHADER_CONSTANT_002_Z) +XE_GPU_REGISTER(0x400B, float, SHADER_CONSTANT_002_W) +XE_GPU_REGISTER(0x400C, float, SHADER_CONSTANT_003_X) +XE_GPU_REGISTER(0x400D, float, SHADER_CONSTANT_003_Y) +XE_GPU_REGISTER(0x400E, float, SHADER_CONSTANT_003_Z) +XE_GPU_REGISTER(0x400F, float, SHADER_CONSTANT_003_W) +XE_GPU_REGISTER(0x4010, float, SHADER_CONSTANT_004_X) +XE_GPU_REGISTER(0x4011, float, SHADER_CONSTANT_004_Y) +XE_GPU_REGISTER(0x4012, float, SHADER_CONSTANT_004_Z) +XE_GPU_REGISTER(0x4013, float, SHADER_CONSTANT_004_W) +XE_GPU_REGISTER(0x4014, float, SHADER_CONSTANT_005_X) +XE_GPU_REGISTER(0x4015, float, SHADER_CONSTANT_005_Y) +XE_GPU_REGISTER(0x4016, float, SHADER_CONSTANT_005_Z) +XE_GPU_REGISTER(0x4017, float, SHADER_CONSTANT_005_W) +XE_GPU_REGISTER(0x4018, float, SHADER_CONSTANT_006_X) +XE_GPU_REGISTER(0x4019, float, SHADER_CONSTANT_006_Y) +XE_GPU_REGISTER(0x401A, float, SHADER_CONSTANT_006_Z) +XE_GPU_REGISTER(0x401B, float, SHADER_CONSTANT_006_W) +XE_GPU_REGISTER(0x401C, float, SHADER_CONSTANT_007_X) +XE_GPU_REGISTER(0x401D, float, SHADER_CONSTANT_007_Y) +XE_GPU_REGISTER(0x401E, float, SHADER_CONSTANT_007_Z) +XE_GPU_REGISTER(0x401F, float, SHADER_CONSTANT_007_W) +XE_GPU_REGISTER(0x4020, float, SHADER_CONSTANT_008_X) +XE_GPU_REGISTER(0x4021, float, SHADER_CONSTANT_008_Y) +XE_GPU_REGISTER(0x4022, float, SHADER_CONSTANT_008_Z) +XE_GPU_REGISTER(0x4023, float, SHADER_CONSTANT_008_W) +XE_GPU_REGISTER(0x4024, float, SHADER_CONSTANT_009_X) +XE_GPU_REGISTER(0x4025, float, SHADER_CONSTANT_009_Y) +XE_GPU_REGISTER(0x4026, float, SHADER_CONSTANT_009_Z) +XE_GPU_REGISTER(0x4027, float, SHADER_CONSTANT_009_W) +XE_GPU_REGISTER(0x4028, float, SHADER_CONSTANT_010_X) +XE_GPU_REGISTER(0x4029, float, SHADER_CONSTANT_010_Y) +XE_GPU_REGISTER(0x402A, float, SHADER_CONSTANT_010_Z) +XE_GPU_REGISTER(0x402B, float, SHADER_CONSTANT_010_W) +XE_GPU_REGISTER(0x402C, float, SHADER_CONSTANT_011_X) +XE_GPU_REGISTER(0x402D, float, SHADER_CONSTANT_011_Y) +XE_GPU_REGISTER(0x402E, float, SHADER_CONSTANT_011_Z) +XE_GPU_REGISTER(0x402F, float, SHADER_CONSTANT_011_W) +XE_GPU_REGISTER(0x4030, float, SHADER_CONSTANT_012_X) +XE_GPU_REGISTER(0x4031, float, SHADER_CONSTANT_012_Y) +XE_GPU_REGISTER(0x4032, float, SHADER_CONSTANT_012_Z) +XE_GPU_REGISTER(0x4033, float, SHADER_CONSTANT_012_W) +XE_GPU_REGISTER(0x4034, float, SHADER_CONSTANT_013_X) +XE_GPU_REGISTER(0x4035, float, SHADER_CONSTANT_013_Y) +XE_GPU_REGISTER(0x4036, float, SHADER_CONSTANT_013_Z) +XE_GPU_REGISTER(0x4037, float, SHADER_CONSTANT_013_W) +XE_GPU_REGISTER(0x4038, float, SHADER_CONSTANT_014_X) +XE_GPU_REGISTER(0x4039, float, SHADER_CONSTANT_014_Y) +XE_GPU_REGISTER(0x403A, float, SHADER_CONSTANT_014_Z) +XE_GPU_REGISTER(0x403B, float, SHADER_CONSTANT_014_W) +XE_GPU_REGISTER(0x403C, float, SHADER_CONSTANT_015_X) +XE_GPU_REGISTER(0x403D, float, SHADER_CONSTANT_015_Y) +XE_GPU_REGISTER(0x403E, float, SHADER_CONSTANT_015_Z) +XE_GPU_REGISTER(0x403F, float, SHADER_CONSTANT_015_W) +XE_GPU_REGISTER(0x4040, float, SHADER_CONSTANT_016_X) +XE_GPU_REGISTER(0x4041, float, SHADER_CONSTANT_016_Y) +XE_GPU_REGISTER(0x4042, float, SHADER_CONSTANT_016_Z) +XE_GPU_REGISTER(0x4043, float, SHADER_CONSTANT_016_W) +XE_GPU_REGISTER(0x4044, float, SHADER_CONSTANT_017_X) +XE_GPU_REGISTER(0x4045, float, SHADER_CONSTANT_017_Y) +XE_GPU_REGISTER(0x4046, float, SHADER_CONSTANT_017_Z) +XE_GPU_REGISTER(0x4047, float, SHADER_CONSTANT_017_W) +XE_GPU_REGISTER(0x4048, float, SHADER_CONSTANT_018_X) +XE_GPU_REGISTER(0x4049, float, SHADER_CONSTANT_018_Y) +XE_GPU_REGISTER(0x404A, float, SHADER_CONSTANT_018_Z) +XE_GPU_REGISTER(0x404B, float, SHADER_CONSTANT_018_W) +XE_GPU_REGISTER(0x404C, float, SHADER_CONSTANT_019_X) +XE_GPU_REGISTER(0x404D, float, SHADER_CONSTANT_019_Y) +XE_GPU_REGISTER(0x404E, float, SHADER_CONSTANT_019_Z) +XE_GPU_REGISTER(0x404F, float, SHADER_CONSTANT_019_W) +XE_GPU_REGISTER(0x4050, float, SHADER_CONSTANT_020_X) +XE_GPU_REGISTER(0x4051, float, SHADER_CONSTANT_020_Y) +XE_GPU_REGISTER(0x4052, float, SHADER_CONSTANT_020_Z) +XE_GPU_REGISTER(0x4053, float, SHADER_CONSTANT_020_W) +XE_GPU_REGISTER(0x4054, float, SHADER_CONSTANT_021_X) +XE_GPU_REGISTER(0x4055, float, SHADER_CONSTANT_021_Y) +XE_GPU_REGISTER(0x4056, float, SHADER_CONSTANT_021_Z) +XE_GPU_REGISTER(0x4057, float, SHADER_CONSTANT_021_W) +XE_GPU_REGISTER(0x4058, float, SHADER_CONSTANT_022_X) +XE_GPU_REGISTER(0x4059, float, SHADER_CONSTANT_022_Y) +XE_GPU_REGISTER(0x405A, float, SHADER_CONSTANT_022_Z) +XE_GPU_REGISTER(0x405B, float, SHADER_CONSTANT_022_W) +XE_GPU_REGISTER(0x405C, float, SHADER_CONSTANT_023_X) +XE_GPU_REGISTER(0x405D, float, SHADER_CONSTANT_023_Y) +XE_GPU_REGISTER(0x405E, float, SHADER_CONSTANT_023_Z) +XE_GPU_REGISTER(0x405F, float, SHADER_CONSTANT_023_W) +XE_GPU_REGISTER(0x4060, float, SHADER_CONSTANT_024_X) +XE_GPU_REGISTER(0x4061, float, SHADER_CONSTANT_024_Y) +XE_GPU_REGISTER(0x4062, float, SHADER_CONSTANT_024_Z) +XE_GPU_REGISTER(0x4063, float, SHADER_CONSTANT_024_W) +XE_GPU_REGISTER(0x4064, float, SHADER_CONSTANT_025_X) +XE_GPU_REGISTER(0x4065, float, SHADER_CONSTANT_025_Y) +XE_GPU_REGISTER(0x4066, float, SHADER_CONSTANT_025_Z) +XE_GPU_REGISTER(0x4067, float, SHADER_CONSTANT_025_W) +XE_GPU_REGISTER(0x4068, float, SHADER_CONSTANT_026_X) +XE_GPU_REGISTER(0x4069, float, SHADER_CONSTANT_026_Y) +XE_GPU_REGISTER(0x406A, float, SHADER_CONSTANT_026_Z) +XE_GPU_REGISTER(0x406B, float, SHADER_CONSTANT_026_W) +XE_GPU_REGISTER(0x406C, float, SHADER_CONSTANT_027_X) +XE_GPU_REGISTER(0x406D, float, SHADER_CONSTANT_027_Y) +XE_GPU_REGISTER(0x406E, float, SHADER_CONSTANT_027_Z) +XE_GPU_REGISTER(0x406F, float, SHADER_CONSTANT_027_W) +XE_GPU_REGISTER(0x4070, float, SHADER_CONSTANT_028_X) +XE_GPU_REGISTER(0x4071, float, SHADER_CONSTANT_028_Y) +XE_GPU_REGISTER(0x4072, float, SHADER_CONSTANT_028_Z) +XE_GPU_REGISTER(0x4073, float, SHADER_CONSTANT_028_W) +XE_GPU_REGISTER(0x4074, float, SHADER_CONSTANT_029_X) +XE_GPU_REGISTER(0x4075, float, SHADER_CONSTANT_029_Y) +XE_GPU_REGISTER(0x4076, float, SHADER_CONSTANT_029_Z) +XE_GPU_REGISTER(0x4077, float, SHADER_CONSTANT_029_W) +XE_GPU_REGISTER(0x4078, float, SHADER_CONSTANT_030_X) +XE_GPU_REGISTER(0x4079, float, SHADER_CONSTANT_030_Y) +XE_GPU_REGISTER(0x407A, float, SHADER_CONSTANT_030_Z) +XE_GPU_REGISTER(0x407B, float, SHADER_CONSTANT_030_W) +XE_GPU_REGISTER(0x407C, float, SHADER_CONSTANT_031_X) +XE_GPU_REGISTER(0x407D, float, SHADER_CONSTANT_031_Y) +XE_GPU_REGISTER(0x407E, float, SHADER_CONSTANT_031_Z) +XE_GPU_REGISTER(0x407F, float, SHADER_CONSTANT_031_W) +XE_GPU_REGISTER(0x4080, float, SHADER_CONSTANT_032_X) +XE_GPU_REGISTER(0x4081, float, SHADER_CONSTANT_032_Y) +XE_GPU_REGISTER(0x4082, float, SHADER_CONSTANT_032_Z) +XE_GPU_REGISTER(0x4083, float, SHADER_CONSTANT_032_W) +XE_GPU_REGISTER(0x4084, float, SHADER_CONSTANT_033_X) +XE_GPU_REGISTER(0x4085, float, SHADER_CONSTANT_033_Y) +XE_GPU_REGISTER(0x4086, float, SHADER_CONSTANT_033_Z) +XE_GPU_REGISTER(0x4087, float, SHADER_CONSTANT_033_W) +XE_GPU_REGISTER(0x4088, float, SHADER_CONSTANT_034_X) +XE_GPU_REGISTER(0x4089, float, SHADER_CONSTANT_034_Y) +XE_GPU_REGISTER(0x408A, float, SHADER_CONSTANT_034_Z) +XE_GPU_REGISTER(0x408B, float, SHADER_CONSTANT_034_W) +XE_GPU_REGISTER(0x408C, float, SHADER_CONSTANT_035_X) +XE_GPU_REGISTER(0x408D, float, SHADER_CONSTANT_035_Y) +XE_GPU_REGISTER(0x408E, float, SHADER_CONSTANT_035_Z) +XE_GPU_REGISTER(0x408F, float, SHADER_CONSTANT_035_W) +XE_GPU_REGISTER(0x4090, float, SHADER_CONSTANT_036_X) +XE_GPU_REGISTER(0x4091, float, SHADER_CONSTANT_036_Y) +XE_GPU_REGISTER(0x4092, float, SHADER_CONSTANT_036_Z) +XE_GPU_REGISTER(0x4093, float, SHADER_CONSTANT_036_W) +XE_GPU_REGISTER(0x4094, float, SHADER_CONSTANT_037_X) +XE_GPU_REGISTER(0x4095, float, SHADER_CONSTANT_037_Y) +XE_GPU_REGISTER(0x4096, float, SHADER_CONSTANT_037_Z) +XE_GPU_REGISTER(0x4097, float, SHADER_CONSTANT_037_W) +XE_GPU_REGISTER(0x4098, float, SHADER_CONSTANT_038_X) +XE_GPU_REGISTER(0x4099, float, SHADER_CONSTANT_038_Y) +XE_GPU_REGISTER(0x409A, float, SHADER_CONSTANT_038_Z) +XE_GPU_REGISTER(0x409B, float, SHADER_CONSTANT_038_W) +XE_GPU_REGISTER(0x409C, float, SHADER_CONSTANT_039_X) +XE_GPU_REGISTER(0x409D, float, SHADER_CONSTANT_039_Y) +XE_GPU_REGISTER(0x409E, float, SHADER_CONSTANT_039_Z) +XE_GPU_REGISTER(0x409F, float, SHADER_CONSTANT_039_W) +XE_GPU_REGISTER(0x40A0, float, SHADER_CONSTANT_040_X) +XE_GPU_REGISTER(0x40A1, float, SHADER_CONSTANT_040_Y) +XE_GPU_REGISTER(0x40A2, float, SHADER_CONSTANT_040_Z) +XE_GPU_REGISTER(0x40A3, float, SHADER_CONSTANT_040_W) +XE_GPU_REGISTER(0x40A4, float, SHADER_CONSTANT_041_X) +XE_GPU_REGISTER(0x40A5, float, SHADER_CONSTANT_041_Y) +XE_GPU_REGISTER(0x40A6, float, SHADER_CONSTANT_041_Z) +XE_GPU_REGISTER(0x40A7, float, SHADER_CONSTANT_041_W) +XE_GPU_REGISTER(0x40A8, float, SHADER_CONSTANT_042_X) +XE_GPU_REGISTER(0x40A9, float, SHADER_CONSTANT_042_Y) +XE_GPU_REGISTER(0x40AA, float, SHADER_CONSTANT_042_Z) +XE_GPU_REGISTER(0x40AB, float, SHADER_CONSTANT_042_W) +XE_GPU_REGISTER(0x40AC, float, SHADER_CONSTANT_043_X) +XE_GPU_REGISTER(0x40AD, float, SHADER_CONSTANT_043_Y) +XE_GPU_REGISTER(0x40AE, float, SHADER_CONSTANT_043_Z) +XE_GPU_REGISTER(0x40AF, float, SHADER_CONSTANT_043_W) +XE_GPU_REGISTER(0x40B0, float, SHADER_CONSTANT_044_X) +XE_GPU_REGISTER(0x40B1, float, SHADER_CONSTANT_044_Y) +XE_GPU_REGISTER(0x40B2, float, SHADER_CONSTANT_044_Z) +XE_GPU_REGISTER(0x40B3, float, SHADER_CONSTANT_044_W) +XE_GPU_REGISTER(0x40B4, float, SHADER_CONSTANT_045_X) +XE_GPU_REGISTER(0x40B5, float, SHADER_CONSTANT_045_Y) +XE_GPU_REGISTER(0x40B6, float, SHADER_CONSTANT_045_Z) +XE_GPU_REGISTER(0x40B7, float, SHADER_CONSTANT_045_W) +XE_GPU_REGISTER(0x40B8, float, SHADER_CONSTANT_046_X) +XE_GPU_REGISTER(0x40B9, float, SHADER_CONSTANT_046_Y) +XE_GPU_REGISTER(0x40BA, float, SHADER_CONSTANT_046_Z) +XE_GPU_REGISTER(0x40BB, float, SHADER_CONSTANT_046_W) +XE_GPU_REGISTER(0x40BC, float, SHADER_CONSTANT_047_X) +XE_GPU_REGISTER(0x40BD, float, SHADER_CONSTANT_047_Y) +XE_GPU_REGISTER(0x40BE, float, SHADER_CONSTANT_047_Z) +XE_GPU_REGISTER(0x40BF, float, SHADER_CONSTANT_047_W) +XE_GPU_REGISTER(0x40C0, float, SHADER_CONSTANT_048_X) +XE_GPU_REGISTER(0x40C1, float, SHADER_CONSTANT_048_Y) +XE_GPU_REGISTER(0x40C2, float, SHADER_CONSTANT_048_Z) +XE_GPU_REGISTER(0x40C3, float, SHADER_CONSTANT_048_W) +XE_GPU_REGISTER(0x40C4, float, SHADER_CONSTANT_049_X) +XE_GPU_REGISTER(0x40C5, float, SHADER_CONSTANT_049_Y) +XE_GPU_REGISTER(0x40C6, float, SHADER_CONSTANT_049_Z) +XE_GPU_REGISTER(0x40C7, float, SHADER_CONSTANT_049_W) +XE_GPU_REGISTER(0x40C8, float, SHADER_CONSTANT_050_X) +XE_GPU_REGISTER(0x40C9, float, SHADER_CONSTANT_050_Y) +XE_GPU_REGISTER(0x40CA, float, SHADER_CONSTANT_050_Z) +XE_GPU_REGISTER(0x40CB, float, SHADER_CONSTANT_050_W) +XE_GPU_REGISTER(0x40CC, float, SHADER_CONSTANT_051_X) +XE_GPU_REGISTER(0x40CD, float, SHADER_CONSTANT_051_Y) +XE_GPU_REGISTER(0x40CE, float, SHADER_CONSTANT_051_Z) +XE_GPU_REGISTER(0x40CF, float, SHADER_CONSTANT_051_W) +XE_GPU_REGISTER(0x40D0, float, SHADER_CONSTANT_052_X) +XE_GPU_REGISTER(0x40D1, float, SHADER_CONSTANT_052_Y) +XE_GPU_REGISTER(0x40D2, float, SHADER_CONSTANT_052_Z) +XE_GPU_REGISTER(0x40D3, float, SHADER_CONSTANT_052_W) +XE_GPU_REGISTER(0x40D4, float, SHADER_CONSTANT_053_X) +XE_GPU_REGISTER(0x40D5, float, SHADER_CONSTANT_053_Y) +XE_GPU_REGISTER(0x40D6, float, SHADER_CONSTANT_053_Z) +XE_GPU_REGISTER(0x40D7, float, SHADER_CONSTANT_053_W) +XE_GPU_REGISTER(0x40D8, float, SHADER_CONSTANT_054_X) +XE_GPU_REGISTER(0x40D9, float, SHADER_CONSTANT_054_Y) +XE_GPU_REGISTER(0x40DA, float, SHADER_CONSTANT_054_Z) +XE_GPU_REGISTER(0x40DB, float, SHADER_CONSTANT_054_W) +XE_GPU_REGISTER(0x40DC, float, SHADER_CONSTANT_055_X) +XE_GPU_REGISTER(0x40DD, float, SHADER_CONSTANT_055_Y) +XE_GPU_REGISTER(0x40DE, float, SHADER_CONSTANT_055_Z) +XE_GPU_REGISTER(0x40DF, float, SHADER_CONSTANT_055_W) +XE_GPU_REGISTER(0x40E0, float, SHADER_CONSTANT_056_X) +XE_GPU_REGISTER(0x40E1, float, SHADER_CONSTANT_056_Y) +XE_GPU_REGISTER(0x40E2, float, SHADER_CONSTANT_056_Z) +XE_GPU_REGISTER(0x40E3, float, SHADER_CONSTANT_056_W) +XE_GPU_REGISTER(0x40E4, float, SHADER_CONSTANT_057_X) +XE_GPU_REGISTER(0x40E5, float, SHADER_CONSTANT_057_Y) +XE_GPU_REGISTER(0x40E6, float, SHADER_CONSTANT_057_Z) +XE_GPU_REGISTER(0x40E7, float, SHADER_CONSTANT_057_W) +XE_GPU_REGISTER(0x40E8, float, SHADER_CONSTANT_058_X) +XE_GPU_REGISTER(0x40E9, float, SHADER_CONSTANT_058_Y) +XE_GPU_REGISTER(0x40EA, float, SHADER_CONSTANT_058_Z) +XE_GPU_REGISTER(0x40EB, float, SHADER_CONSTANT_058_W) +XE_GPU_REGISTER(0x40EC, float, SHADER_CONSTANT_059_X) +XE_GPU_REGISTER(0x40ED, float, SHADER_CONSTANT_059_Y) +XE_GPU_REGISTER(0x40EE, float, SHADER_CONSTANT_059_Z) +XE_GPU_REGISTER(0x40EF, float, SHADER_CONSTANT_059_W) +XE_GPU_REGISTER(0x40F0, float, SHADER_CONSTANT_060_X) +XE_GPU_REGISTER(0x40F1, float, SHADER_CONSTANT_060_Y) +XE_GPU_REGISTER(0x40F2, float, SHADER_CONSTANT_060_Z) +XE_GPU_REGISTER(0x40F3, float, SHADER_CONSTANT_060_W) +XE_GPU_REGISTER(0x40F4, float, SHADER_CONSTANT_061_X) +XE_GPU_REGISTER(0x40F5, float, SHADER_CONSTANT_061_Y) +XE_GPU_REGISTER(0x40F6, float, SHADER_CONSTANT_061_Z) +XE_GPU_REGISTER(0x40F7, float, SHADER_CONSTANT_061_W) +XE_GPU_REGISTER(0x40F8, float, SHADER_CONSTANT_062_X) +XE_GPU_REGISTER(0x40F9, float, SHADER_CONSTANT_062_Y) +XE_GPU_REGISTER(0x40FA, float, SHADER_CONSTANT_062_Z) +XE_GPU_REGISTER(0x40FB, float, SHADER_CONSTANT_062_W) +XE_GPU_REGISTER(0x40FC, float, SHADER_CONSTANT_063_X) +XE_GPU_REGISTER(0x40FD, float, SHADER_CONSTANT_063_Y) +XE_GPU_REGISTER(0x40FE, float, SHADER_CONSTANT_063_Z) +XE_GPU_REGISTER(0x40FF, float, SHADER_CONSTANT_063_W) +XE_GPU_REGISTER(0x4100, float, SHADER_CONSTANT_064_X) +XE_GPU_REGISTER(0x4101, float, SHADER_CONSTANT_064_Y) +XE_GPU_REGISTER(0x4102, float, SHADER_CONSTANT_064_Z) +XE_GPU_REGISTER(0x4103, float, SHADER_CONSTANT_064_W) +XE_GPU_REGISTER(0x4104, float, SHADER_CONSTANT_065_X) +XE_GPU_REGISTER(0x4105, float, SHADER_CONSTANT_065_Y) +XE_GPU_REGISTER(0x4106, float, SHADER_CONSTANT_065_Z) +XE_GPU_REGISTER(0x4107, float, SHADER_CONSTANT_065_W) +XE_GPU_REGISTER(0x4108, float, SHADER_CONSTANT_066_X) +XE_GPU_REGISTER(0x4109, float, SHADER_CONSTANT_066_Y) +XE_GPU_REGISTER(0x410A, float, SHADER_CONSTANT_066_Z) +XE_GPU_REGISTER(0x410B, float, SHADER_CONSTANT_066_W) +XE_GPU_REGISTER(0x410C, float, SHADER_CONSTANT_067_X) +XE_GPU_REGISTER(0x410D, float, SHADER_CONSTANT_067_Y) +XE_GPU_REGISTER(0x410E, float, SHADER_CONSTANT_067_Z) +XE_GPU_REGISTER(0x410F, float, SHADER_CONSTANT_067_W) +XE_GPU_REGISTER(0x4110, float, SHADER_CONSTANT_068_X) +XE_GPU_REGISTER(0x4111, float, SHADER_CONSTANT_068_Y) +XE_GPU_REGISTER(0x4112, float, SHADER_CONSTANT_068_Z) +XE_GPU_REGISTER(0x4113, float, SHADER_CONSTANT_068_W) +XE_GPU_REGISTER(0x4114, float, SHADER_CONSTANT_069_X) +XE_GPU_REGISTER(0x4115, float, SHADER_CONSTANT_069_Y) +XE_GPU_REGISTER(0x4116, float, SHADER_CONSTANT_069_Z) +XE_GPU_REGISTER(0x4117, float, SHADER_CONSTANT_069_W) +XE_GPU_REGISTER(0x4118, float, SHADER_CONSTANT_070_X) +XE_GPU_REGISTER(0x4119, float, SHADER_CONSTANT_070_Y) +XE_GPU_REGISTER(0x411A, float, SHADER_CONSTANT_070_Z) +XE_GPU_REGISTER(0x411B, float, SHADER_CONSTANT_070_W) +XE_GPU_REGISTER(0x411C, float, SHADER_CONSTANT_071_X) +XE_GPU_REGISTER(0x411D, float, SHADER_CONSTANT_071_Y) +XE_GPU_REGISTER(0x411E, float, SHADER_CONSTANT_071_Z) +XE_GPU_REGISTER(0x411F, float, SHADER_CONSTANT_071_W) +XE_GPU_REGISTER(0x4120, float, SHADER_CONSTANT_072_X) +XE_GPU_REGISTER(0x4121, float, SHADER_CONSTANT_072_Y) +XE_GPU_REGISTER(0x4122, float, SHADER_CONSTANT_072_Z) +XE_GPU_REGISTER(0x4123, float, SHADER_CONSTANT_072_W) +XE_GPU_REGISTER(0x4124, float, SHADER_CONSTANT_073_X) +XE_GPU_REGISTER(0x4125, float, SHADER_CONSTANT_073_Y) +XE_GPU_REGISTER(0x4126, float, SHADER_CONSTANT_073_Z) +XE_GPU_REGISTER(0x4127, float, SHADER_CONSTANT_073_W) +XE_GPU_REGISTER(0x4128, float, SHADER_CONSTANT_074_X) +XE_GPU_REGISTER(0x4129, float, SHADER_CONSTANT_074_Y) +XE_GPU_REGISTER(0x412A, float, SHADER_CONSTANT_074_Z) +XE_GPU_REGISTER(0x412B, float, SHADER_CONSTANT_074_W) +XE_GPU_REGISTER(0x412C, float, SHADER_CONSTANT_075_X) +XE_GPU_REGISTER(0x412D, float, SHADER_CONSTANT_075_Y) +XE_GPU_REGISTER(0x412E, float, SHADER_CONSTANT_075_Z) +XE_GPU_REGISTER(0x412F, float, SHADER_CONSTANT_075_W) +XE_GPU_REGISTER(0x4130, float, SHADER_CONSTANT_076_X) +XE_GPU_REGISTER(0x4131, float, SHADER_CONSTANT_076_Y) +XE_GPU_REGISTER(0x4132, float, SHADER_CONSTANT_076_Z) +XE_GPU_REGISTER(0x4133, float, SHADER_CONSTANT_076_W) +XE_GPU_REGISTER(0x4134, float, SHADER_CONSTANT_077_X) +XE_GPU_REGISTER(0x4135, float, SHADER_CONSTANT_077_Y) +XE_GPU_REGISTER(0x4136, float, SHADER_CONSTANT_077_Z) +XE_GPU_REGISTER(0x4137, float, SHADER_CONSTANT_077_W) +XE_GPU_REGISTER(0x4138, float, SHADER_CONSTANT_078_X) +XE_GPU_REGISTER(0x4139, float, SHADER_CONSTANT_078_Y) +XE_GPU_REGISTER(0x413A, float, SHADER_CONSTANT_078_Z) +XE_GPU_REGISTER(0x413B, float, SHADER_CONSTANT_078_W) +XE_GPU_REGISTER(0x413C, float, SHADER_CONSTANT_079_X) +XE_GPU_REGISTER(0x413D, float, SHADER_CONSTANT_079_Y) +XE_GPU_REGISTER(0x413E, float, SHADER_CONSTANT_079_Z) +XE_GPU_REGISTER(0x413F, float, SHADER_CONSTANT_079_W) +XE_GPU_REGISTER(0x4140, float, SHADER_CONSTANT_080_X) +XE_GPU_REGISTER(0x4141, float, SHADER_CONSTANT_080_Y) +XE_GPU_REGISTER(0x4142, float, SHADER_CONSTANT_080_Z) +XE_GPU_REGISTER(0x4143, float, SHADER_CONSTANT_080_W) +XE_GPU_REGISTER(0x4144, float, SHADER_CONSTANT_081_X) +XE_GPU_REGISTER(0x4145, float, SHADER_CONSTANT_081_Y) +XE_GPU_REGISTER(0x4146, float, SHADER_CONSTANT_081_Z) +XE_GPU_REGISTER(0x4147, float, SHADER_CONSTANT_081_W) +XE_GPU_REGISTER(0x4148, float, SHADER_CONSTANT_082_X) +XE_GPU_REGISTER(0x4149, float, SHADER_CONSTANT_082_Y) +XE_GPU_REGISTER(0x414A, float, SHADER_CONSTANT_082_Z) +XE_GPU_REGISTER(0x414B, float, SHADER_CONSTANT_082_W) +XE_GPU_REGISTER(0x414C, float, SHADER_CONSTANT_083_X) +XE_GPU_REGISTER(0x414D, float, SHADER_CONSTANT_083_Y) +XE_GPU_REGISTER(0x414E, float, SHADER_CONSTANT_083_Z) +XE_GPU_REGISTER(0x414F, float, SHADER_CONSTANT_083_W) +XE_GPU_REGISTER(0x4150, float, SHADER_CONSTANT_084_X) +XE_GPU_REGISTER(0x4151, float, SHADER_CONSTANT_084_Y) +XE_GPU_REGISTER(0x4152, float, SHADER_CONSTANT_084_Z) +XE_GPU_REGISTER(0x4153, float, SHADER_CONSTANT_084_W) +XE_GPU_REGISTER(0x4154, float, SHADER_CONSTANT_085_X) +XE_GPU_REGISTER(0x4155, float, SHADER_CONSTANT_085_Y) +XE_GPU_REGISTER(0x4156, float, SHADER_CONSTANT_085_Z) +XE_GPU_REGISTER(0x4157, float, SHADER_CONSTANT_085_W) +XE_GPU_REGISTER(0x4158, float, SHADER_CONSTANT_086_X) +XE_GPU_REGISTER(0x4159, float, SHADER_CONSTANT_086_Y) +XE_GPU_REGISTER(0x415A, float, SHADER_CONSTANT_086_Z) +XE_GPU_REGISTER(0x415B, float, SHADER_CONSTANT_086_W) +XE_GPU_REGISTER(0x415C, float, SHADER_CONSTANT_087_X) +XE_GPU_REGISTER(0x415D, float, SHADER_CONSTANT_087_Y) +XE_GPU_REGISTER(0x415E, float, SHADER_CONSTANT_087_Z) +XE_GPU_REGISTER(0x415F, float, SHADER_CONSTANT_087_W) +XE_GPU_REGISTER(0x4160, float, SHADER_CONSTANT_088_X) +XE_GPU_REGISTER(0x4161, float, SHADER_CONSTANT_088_Y) +XE_GPU_REGISTER(0x4162, float, SHADER_CONSTANT_088_Z) +XE_GPU_REGISTER(0x4163, float, SHADER_CONSTANT_088_W) +XE_GPU_REGISTER(0x4164, float, SHADER_CONSTANT_089_X) +XE_GPU_REGISTER(0x4165, float, SHADER_CONSTANT_089_Y) +XE_GPU_REGISTER(0x4166, float, SHADER_CONSTANT_089_Z) +XE_GPU_REGISTER(0x4167, float, SHADER_CONSTANT_089_W) +XE_GPU_REGISTER(0x4168, float, SHADER_CONSTANT_090_X) +XE_GPU_REGISTER(0x4169, float, SHADER_CONSTANT_090_Y) +XE_GPU_REGISTER(0x416A, float, SHADER_CONSTANT_090_Z) +XE_GPU_REGISTER(0x416B, float, SHADER_CONSTANT_090_W) +XE_GPU_REGISTER(0x416C, float, SHADER_CONSTANT_091_X) +XE_GPU_REGISTER(0x416D, float, SHADER_CONSTANT_091_Y) +XE_GPU_REGISTER(0x416E, float, SHADER_CONSTANT_091_Z) +XE_GPU_REGISTER(0x416F, float, SHADER_CONSTANT_091_W) +XE_GPU_REGISTER(0x4170, float, SHADER_CONSTANT_092_X) +XE_GPU_REGISTER(0x4171, float, SHADER_CONSTANT_092_Y) +XE_GPU_REGISTER(0x4172, float, SHADER_CONSTANT_092_Z) +XE_GPU_REGISTER(0x4173, float, SHADER_CONSTANT_092_W) +XE_GPU_REGISTER(0x4174, float, SHADER_CONSTANT_093_X) +XE_GPU_REGISTER(0x4175, float, SHADER_CONSTANT_093_Y) +XE_GPU_REGISTER(0x4176, float, SHADER_CONSTANT_093_Z) +XE_GPU_REGISTER(0x4177, float, SHADER_CONSTANT_093_W) +XE_GPU_REGISTER(0x4178, float, SHADER_CONSTANT_094_X) +XE_GPU_REGISTER(0x4179, float, SHADER_CONSTANT_094_Y) +XE_GPU_REGISTER(0x417A, float, SHADER_CONSTANT_094_Z) +XE_GPU_REGISTER(0x417B, float, SHADER_CONSTANT_094_W) +XE_GPU_REGISTER(0x417C, float, SHADER_CONSTANT_095_X) +XE_GPU_REGISTER(0x417D, float, SHADER_CONSTANT_095_Y) +XE_GPU_REGISTER(0x417E, float, SHADER_CONSTANT_095_Z) +XE_GPU_REGISTER(0x417F, float, SHADER_CONSTANT_095_W) +XE_GPU_REGISTER(0x4180, float, SHADER_CONSTANT_096_X) +XE_GPU_REGISTER(0x4181, float, SHADER_CONSTANT_096_Y) +XE_GPU_REGISTER(0x4182, float, SHADER_CONSTANT_096_Z) +XE_GPU_REGISTER(0x4183, float, SHADER_CONSTANT_096_W) +XE_GPU_REGISTER(0x4184, float, SHADER_CONSTANT_097_X) +XE_GPU_REGISTER(0x4185, float, SHADER_CONSTANT_097_Y) +XE_GPU_REGISTER(0x4186, float, SHADER_CONSTANT_097_Z) +XE_GPU_REGISTER(0x4187, float, SHADER_CONSTANT_097_W) +XE_GPU_REGISTER(0x4188, float, SHADER_CONSTANT_098_X) +XE_GPU_REGISTER(0x4189, float, SHADER_CONSTANT_098_Y) +XE_GPU_REGISTER(0x418A, float, SHADER_CONSTANT_098_Z) +XE_GPU_REGISTER(0x418B, float, SHADER_CONSTANT_098_W) +XE_GPU_REGISTER(0x418C, float, SHADER_CONSTANT_099_X) +XE_GPU_REGISTER(0x418D, float, SHADER_CONSTANT_099_Y) +XE_GPU_REGISTER(0x418E, float, SHADER_CONSTANT_099_Z) +XE_GPU_REGISTER(0x418F, float, SHADER_CONSTANT_099_W) +XE_GPU_REGISTER(0x4190, float, SHADER_CONSTANT_100_X) +XE_GPU_REGISTER(0x4191, float, SHADER_CONSTANT_100_Y) +XE_GPU_REGISTER(0x4192, float, SHADER_CONSTANT_100_Z) +XE_GPU_REGISTER(0x4193, float, SHADER_CONSTANT_100_W) +XE_GPU_REGISTER(0x4194, float, SHADER_CONSTANT_101_X) +XE_GPU_REGISTER(0x4195, float, SHADER_CONSTANT_101_Y) +XE_GPU_REGISTER(0x4196, float, SHADER_CONSTANT_101_Z) +XE_GPU_REGISTER(0x4197, float, SHADER_CONSTANT_101_W) +XE_GPU_REGISTER(0x4198, float, SHADER_CONSTANT_102_X) +XE_GPU_REGISTER(0x4199, float, SHADER_CONSTANT_102_Y) +XE_GPU_REGISTER(0x419A, float, SHADER_CONSTANT_102_Z) +XE_GPU_REGISTER(0x419B, float, SHADER_CONSTANT_102_W) +XE_GPU_REGISTER(0x419C, float, SHADER_CONSTANT_103_X) +XE_GPU_REGISTER(0x419D, float, SHADER_CONSTANT_103_Y) +XE_GPU_REGISTER(0x419E, float, SHADER_CONSTANT_103_Z) +XE_GPU_REGISTER(0x419F, float, SHADER_CONSTANT_103_W) +XE_GPU_REGISTER(0x41A0, float, SHADER_CONSTANT_104_X) +XE_GPU_REGISTER(0x41A1, float, SHADER_CONSTANT_104_Y) +XE_GPU_REGISTER(0x41A2, float, SHADER_CONSTANT_104_Z) +XE_GPU_REGISTER(0x41A3, float, SHADER_CONSTANT_104_W) +XE_GPU_REGISTER(0x41A4, float, SHADER_CONSTANT_105_X) +XE_GPU_REGISTER(0x41A5, float, SHADER_CONSTANT_105_Y) +XE_GPU_REGISTER(0x41A6, float, SHADER_CONSTANT_105_Z) +XE_GPU_REGISTER(0x41A7, float, SHADER_CONSTANT_105_W) +XE_GPU_REGISTER(0x41A8, float, SHADER_CONSTANT_106_X) +XE_GPU_REGISTER(0x41A9, float, SHADER_CONSTANT_106_Y) +XE_GPU_REGISTER(0x41AA, float, SHADER_CONSTANT_106_Z) +XE_GPU_REGISTER(0x41AB, float, SHADER_CONSTANT_106_W) +XE_GPU_REGISTER(0x41AC, float, SHADER_CONSTANT_107_X) +XE_GPU_REGISTER(0x41AD, float, SHADER_CONSTANT_107_Y) +XE_GPU_REGISTER(0x41AE, float, SHADER_CONSTANT_107_Z) +XE_GPU_REGISTER(0x41AF, float, SHADER_CONSTANT_107_W) +XE_GPU_REGISTER(0x41B0, float, SHADER_CONSTANT_108_X) +XE_GPU_REGISTER(0x41B1, float, SHADER_CONSTANT_108_Y) +XE_GPU_REGISTER(0x41B2, float, SHADER_CONSTANT_108_Z) +XE_GPU_REGISTER(0x41B3, float, SHADER_CONSTANT_108_W) +XE_GPU_REGISTER(0x41B4, float, SHADER_CONSTANT_109_X) +XE_GPU_REGISTER(0x41B5, float, SHADER_CONSTANT_109_Y) +XE_GPU_REGISTER(0x41B6, float, SHADER_CONSTANT_109_Z) +XE_GPU_REGISTER(0x41B7, float, SHADER_CONSTANT_109_W) +XE_GPU_REGISTER(0x41B8, float, SHADER_CONSTANT_110_X) +XE_GPU_REGISTER(0x41B9, float, SHADER_CONSTANT_110_Y) +XE_GPU_REGISTER(0x41BA, float, SHADER_CONSTANT_110_Z) +XE_GPU_REGISTER(0x41BB, float, SHADER_CONSTANT_110_W) +XE_GPU_REGISTER(0x41BC, float, SHADER_CONSTANT_111_X) +XE_GPU_REGISTER(0x41BD, float, SHADER_CONSTANT_111_Y) +XE_GPU_REGISTER(0x41BE, float, SHADER_CONSTANT_111_Z) +XE_GPU_REGISTER(0x41BF, float, SHADER_CONSTANT_111_W) +XE_GPU_REGISTER(0x41C0, float, SHADER_CONSTANT_112_X) +XE_GPU_REGISTER(0x41C1, float, SHADER_CONSTANT_112_Y) +XE_GPU_REGISTER(0x41C2, float, SHADER_CONSTANT_112_Z) +XE_GPU_REGISTER(0x41C3, float, SHADER_CONSTANT_112_W) +XE_GPU_REGISTER(0x41C4, float, SHADER_CONSTANT_113_X) +XE_GPU_REGISTER(0x41C5, float, SHADER_CONSTANT_113_Y) +XE_GPU_REGISTER(0x41C6, float, SHADER_CONSTANT_113_Z) +XE_GPU_REGISTER(0x41C7, float, SHADER_CONSTANT_113_W) +XE_GPU_REGISTER(0x41C8, float, SHADER_CONSTANT_114_X) +XE_GPU_REGISTER(0x41C9, float, SHADER_CONSTANT_114_Y) +XE_GPU_REGISTER(0x41CA, float, SHADER_CONSTANT_114_Z) +XE_GPU_REGISTER(0x41CB, float, SHADER_CONSTANT_114_W) +XE_GPU_REGISTER(0x41CC, float, SHADER_CONSTANT_115_X) +XE_GPU_REGISTER(0x41CD, float, SHADER_CONSTANT_115_Y) +XE_GPU_REGISTER(0x41CE, float, SHADER_CONSTANT_115_Z) +XE_GPU_REGISTER(0x41CF, float, SHADER_CONSTANT_115_W) +XE_GPU_REGISTER(0x41D0, float, SHADER_CONSTANT_116_X) +XE_GPU_REGISTER(0x41D1, float, SHADER_CONSTANT_116_Y) +XE_GPU_REGISTER(0x41D2, float, SHADER_CONSTANT_116_Z) +XE_GPU_REGISTER(0x41D3, float, SHADER_CONSTANT_116_W) +XE_GPU_REGISTER(0x41D4, float, SHADER_CONSTANT_117_X) +XE_GPU_REGISTER(0x41D5, float, SHADER_CONSTANT_117_Y) +XE_GPU_REGISTER(0x41D6, float, SHADER_CONSTANT_117_Z) +XE_GPU_REGISTER(0x41D7, float, SHADER_CONSTANT_117_W) +XE_GPU_REGISTER(0x41D8, float, SHADER_CONSTANT_118_X) +XE_GPU_REGISTER(0x41D9, float, SHADER_CONSTANT_118_Y) +XE_GPU_REGISTER(0x41DA, float, SHADER_CONSTANT_118_Z) +XE_GPU_REGISTER(0x41DB, float, SHADER_CONSTANT_118_W) +XE_GPU_REGISTER(0x41DC, float, SHADER_CONSTANT_119_X) +XE_GPU_REGISTER(0x41DD, float, SHADER_CONSTANT_119_Y) +XE_GPU_REGISTER(0x41DE, float, SHADER_CONSTANT_119_Z) +XE_GPU_REGISTER(0x41DF, float, SHADER_CONSTANT_119_W) +XE_GPU_REGISTER(0x41E0, float, SHADER_CONSTANT_120_X) +XE_GPU_REGISTER(0x41E1, float, SHADER_CONSTANT_120_Y) +XE_GPU_REGISTER(0x41E2, float, SHADER_CONSTANT_120_Z) +XE_GPU_REGISTER(0x41E3, float, SHADER_CONSTANT_120_W) +XE_GPU_REGISTER(0x41E4, float, SHADER_CONSTANT_121_X) +XE_GPU_REGISTER(0x41E5, float, SHADER_CONSTANT_121_Y) +XE_GPU_REGISTER(0x41E6, float, SHADER_CONSTANT_121_Z) +XE_GPU_REGISTER(0x41E7, float, SHADER_CONSTANT_121_W) +XE_GPU_REGISTER(0x41E8, float, SHADER_CONSTANT_122_X) +XE_GPU_REGISTER(0x41E9, float, SHADER_CONSTANT_122_Y) +XE_GPU_REGISTER(0x41EA, float, SHADER_CONSTANT_122_Z) +XE_GPU_REGISTER(0x41EB, float, SHADER_CONSTANT_122_W) +XE_GPU_REGISTER(0x41EC, float, SHADER_CONSTANT_123_X) +XE_GPU_REGISTER(0x41ED, float, SHADER_CONSTANT_123_Y) +XE_GPU_REGISTER(0x41EE, float, SHADER_CONSTANT_123_Z) +XE_GPU_REGISTER(0x41EF, float, SHADER_CONSTANT_123_W) +XE_GPU_REGISTER(0x41F0, float, SHADER_CONSTANT_124_X) +XE_GPU_REGISTER(0x41F1, float, SHADER_CONSTANT_124_Y) +XE_GPU_REGISTER(0x41F2, float, SHADER_CONSTANT_124_Z) +XE_GPU_REGISTER(0x41F3, float, SHADER_CONSTANT_124_W) +XE_GPU_REGISTER(0x41F4, float, SHADER_CONSTANT_125_X) +XE_GPU_REGISTER(0x41F5, float, SHADER_CONSTANT_125_Y) +XE_GPU_REGISTER(0x41F6, float, SHADER_CONSTANT_125_Z) +XE_GPU_REGISTER(0x41F7, float, SHADER_CONSTANT_125_W) +XE_GPU_REGISTER(0x41F8, float, SHADER_CONSTANT_126_X) +XE_GPU_REGISTER(0x41F9, float, SHADER_CONSTANT_126_Y) +XE_GPU_REGISTER(0x41FA, float, SHADER_CONSTANT_126_Z) +XE_GPU_REGISTER(0x41FB, float, SHADER_CONSTANT_126_W) +XE_GPU_REGISTER(0x41FC, float, SHADER_CONSTANT_127_X) +XE_GPU_REGISTER(0x41FD, float, SHADER_CONSTANT_127_Y) +XE_GPU_REGISTER(0x41FE, float, SHADER_CONSTANT_127_Z) +XE_GPU_REGISTER(0x41FF, float, SHADER_CONSTANT_127_W) +XE_GPU_REGISTER(0x4200, float, SHADER_CONSTANT_128_X) +XE_GPU_REGISTER(0x4201, float, SHADER_CONSTANT_128_Y) +XE_GPU_REGISTER(0x4202, float, SHADER_CONSTANT_128_Z) +XE_GPU_REGISTER(0x4203, float, SHADER_CONSTANT_128_W) +XE_GPU_REGISTER(0x4204, float, SHADER_CONSTANT_129_X) +XE_GPU_REGISTER(0x4205, float, SHADER_CONSTANT_129_Y) +XE_GPU_REGISTER(0x4206, float, SHADER_CONSTANT_129_Z) +XE_GPU_REGISTER(0x4207, float, SHADER_CONSTANT_129_W) +XE_GPU_REGISTER(0x4208, float, SHADER_CONSTANT_130_X) +XE_GPU_REGISTER(0x4209, float, SHADER_CONSTANT_130_Y) +XE_GPU_REGISTER(0x420A, float, SHADER_CONSTANT_130_Z) +XE_GPU_REGISTER(0x420B, float, SHADER_CONSTANT_130_W) +XE_GPU_REGISTER(0x420C, float, SHADER_CONSTANT_131_X) +XE_GPU_REGISTER(0x420D, float, SHADER_CONSTANT_131_Y) +XE_GPU_REGISTER(0x420E, float, SHADER_CONSTANT_131_Z) +XE_GPU_REGISTER(0x420F, float, SHADER_CONSTANT_131_W) +XE_GPU_REGISTER(0x4210, float, SHADER_CONSTANT_132_X) +XE_GPU_REGISTER(0x4211, float, SHADER_CONSTANT_132_Y) +XE_GPU_REGISTER(0x4212, float, SHADER_CONSTANT_132_Z) +XE_GPU_REGISTER(0x4213, float, SHADER_CONSTANT_132_W) +XE_GPU_REGISTER(0x4214, float, SHADER_CONSTANT_133_X) +XE_GPU_REGISTER(0x4215, float, SHADER_CONSTANT_133_Y) +XE_GPU_REGISTER(0x4216, float, SHADER_CONSTANT_133_Z) +XE_GPU_REGISTER(0x4217, float, SHADER_CONSTANT_133_W) +XE_GPU_REGISTER(0x4218, float, SHADER_CONSTANT_134_X) +XE_GPU_REGISTER(0x4219, float, SHADER_CONSTANT_134_Y) +XE_GPU_REGISTER(0x421A, float, SHADER_CONSTANT_134_Z) +XE_GPU_REGISTER(0x421B, float, SHADER_CONSTANT_134_W) +XE_GPU_REGISTER(0x421C, float, SHADER_CONSTANT_135_X) +XE_GPU_REGISTER(0x421D, float, SHADER_CONSTANT_135_Y) +XE_GPU_REGISTER(0x421E, float, SHADER_CONSTANT_135_Z) +XE_GPU_REGISTER(0x421F, float, SHADER_CONSTANT_135_W) +XE_GPU_REGISTER(0x4220, float, SHADER_CONSTANT_136_X) +XE_GPU_REGISTER(0x4221, float, SHADER_CONSTANT_136_Y) +XE_GPU_REGISTER(0x4222, float, SHADER_CONSTANT_136_Z) +XE_GPU_REGISTER(0x4223, float, SHADER_CONSTANT_136_W) +XE_GPU_REGISTER(0x4224, float, SHADER_CONSTANT_137_X) +XE_GPU_REGISTER(0x4225, float, SHADER_CONSTANT_137_Y) +XE_GPU_REGISTER(0x4226, float, SHADER_CONSTANT_137_Z) +XE_GPU_REGISTER(0x4227, float, SHADER_CONSTANT_137_W) +XE_GPU_REGISTER(0x4228, float, SHADER_CONSTANT_138_X) +XE_GPU_REGISTER(0x4229, float, SHADER_CONSTANT_138_Y) +XE_GPU_REGISTER(0x422A, float, SHADER_CONSTANT_138_Z) +XE_GPU_REGISTER(0x422B, float, SHADER_CONSTANT_138_W) +XE_GPU_REGISTER(0x422C, float, SHADER_CONSTANT_139_X) +XE_GPU_REGISTER(0x422D, float, SHADER_CONSTANT_139_Y) +XE_GPU_REGISTER(0x422E, float, SHADER_CONSTANT_139_Z) +XE_GPU_REGISTER(0x422F, float, SHADER_CONSTANT_139_W) +XE_GPU_REGISTER(0x4230, float, SHADER_CONSTANT_140_X) +XE_GPU_REGISTER(0x4231, float, SHADER_CONSTANT_140_Y) +XE_GPU_REGISTER(0x4232, float, SHADER_CONSTANT_140_Z) +XE_GPU_REGISTER(0x4233, float, SHADER_CONSTANT_140_W) +XE_GPU_REGISTER(0x4234, float, SHADER_CONSTANT_141_X) +XE_GPU_REGISTER(0x4235, float, SHADER_CONSTANT_141_Y) +XE_GPU_REGISTER(0x4236, float, SHADER_CONSTANT_141_Z) +XE_GPU_REGISTER(0x4237, float, SHADER_CONSTANT_141_W) +XE_GPU_REGISTER(0x4238, float, SHADER_CONSTANT_142_X) +XE_GPU_REGISTER(0x4239, float, SHADER_CONSTANT_142_Y) +XE_GPU_REGISTER(0x423A, float, SHADER_CONSTANT_142_Z) +XE_GPU_REGISTER(0x423B, float, SHADER_CONSTANT_142_W) +XE_GPU_REGISTER(0x423C, float, SHADER_CONSTANT_143_X) +XE_GPU_REGISTER(0x423D, float, SHADER_CONSTANT_143_Y) +XE_GPU_REGISTER(0x423E, float, SHADER_CONSTANT_143_Z) +XE_GPU_REGISTER(0x423F, float, SHADER_CONSTANT_143_W) +XE_GPU_REGISTER(0x4240, float, SHADER_CONSTANT_144_X) +XE_GPU_REGISTER(0x4241, float, SHADER_CONSTANT_144_Y) +XE_GPU_REGISTER(0x4242, float, SHADER_CONSTANT_144_Z) +XE_GPU_REGISTER(0x4243, float, SHADER_CONSTANT_144_W) +XE_GPU_REGISTER(0x4244, float, SHADER_CONSTANT_145_X) +XE_GPU_REGISTER(0x4245, float, SHADER_CONSTANT_145_Y) +XE_GPU_REGISTER(0x4246, float, SHADER_CONSTANT_145_Z) +XE_GPU_REGISTER(0x4247, float, SHADER_CONSTANT_145_W) +XE_GPU_REGISTER(0x4248, float, SHADER_CONSTANT_146_X) +XE_GPU_REGISTER(0x4249, float, SHADER_CONSTANT_146_Y) +XE_GPU_REGISTER(0x424A, float, SHADER_CONSTANT_146_Z) +XE_GPU_REGISTER(0x424B, float, SHADER_CONSTANT_146_W) +XE_GPU_REGISTER(0x424C, float, SHADER_CONSTANT_147_X) +XE_GPU_REGISTER(0x424D, float, SHADER_CONSTANT_147_Y) +XE_GPU_REGISTER(0x424E, float, SHADER_CONSTANT_147_Z) +XE_GPU_REGISTER(0x424F, float, SHADER_CONSTANT_147_W) +XE_GPU_REGISTER(0x4250, float, SHADER_CONSTANT_148_X) +XE_GPU_REGISTER(0x4251, float, SHADER_CONSTANT_148_Y) +XE_GPU_REGISTER(0x4252, float, SHADER_CONSTANT_148_Z) +XE_GPU_REGISTER(0x4253, float, SHADER_CONSTANT_148_W) +XE_GPU_REGISTER(0x4254, float, SHADER_CONSTANT_149_X) +XE_GPU_REGISTER(0x4255, float, SHADER_CONSTANT_149_Y) +XE_GPU_REGISTER(0x4256, float, SHADER_CONSTANT_149_Z) +XE_GPU_REGISTER(0x4257, float, SHADER_CONSTANT_149_W) +XE_GPU_REGISTER(0x4258, float, SHADER_CONSTANT_150_X) +XE_GPU_REGISTER(0x4259, float, SHADER_CONSTANT_150_Y) +XE_GPU_REGISTER(0x425A, float, SHADER_CONSTANT_150_Z) +XE_GPU_REGISTER(0x425B, float, SHADER_CONSTANT_150_W) +XE_GPU_REGISTER(0x425C, float, SHADER_CONSTANT_151_X) +XE_GPU_REGISTER(0x425D, float, SHADER_CONSTANT_151_Y) +XE_GPU_REGISTER(0x425E, float, SHADER_CONSTANT_151_Z) +XE_GPU_REGISTER(0x425F, float, SHADER_CONSTANT_151_W) +XE_GPU_REGISTER(0x4260, float, SHADER_CONSTANT_152_X) +XE_GPU_REGISTER(0x4261, float, SHADER_CONSTANT_152_Y) +XE_GPU_REGISTER(0x4262, float, SHADER_CONSTANT_152_Z) +XE_GPU_REGISTER(0x4263, float, SHADER_CONSTANT_152_W) +XE_GPU_REGISTER(0x4264, float, SHADER_CONSTANT_153_X) +XE_GPU_REGISTER(0x4265, float, SHADER_CONSTANT_153_Y) +XE_GPU_REGISTER(0x4266, float, SHADER_CONSTANT_153_Z) +XE_GPU_REGISTER(0x4267, float, SHADER_CONSTANT_153_W) +XE_GPU_REGISTER(0x4268, float, SHADER_CONSTANT_154_X) +XE_GPU_REGISTER(0x4269, float, SHADER_CONSTANT_154_Y) +XE_GPU_REGISTER(0x426A, float, SHADER_CONSTANT_154_Z) +XE_GPU_REGISTER(0x426B, float, SHADER_CONSTANT_154_W) +XE_GPU_REGISTER(0x426C, float, SHADER_CONSTANT_155_X) +XE_GPU_REGISTER(0x426D, float, SHADER_CONSTANT_155_Y) +XE_GPU_REGISTER(0x426E, float, SHADER_CONSTANT_155_Z) +XE_GPU_REGISTER(0x426F, float, SHADER_CONSTANT_155_W) +XE_GPU_REGISTER(0x4270, float, SHADER_CONSTANT_156_X) +XE_GPU_REGISTER(0x4271, float, SHADER_CONSTANT_156_Y) +XE_GPU_REGISTER(0x4272, float, SHADER_CONSTANT_156_Z) +XE_GPU_REGISTER(0x4273, float, SHADER_CONSTANT_156_W) +XE_GPU_REGISTER(0x4274, float, SHADER_CONSTANT_157_X) +XE_GPU_REGISTER(0x4275, float, SHADER_CONSTANT_157_Y) +XE_GPU_REGISTER(0x4276, float, SHADER_CONSTANT_157_Z) +XE_GPU_REGISTER(0x4277, float, SHADER_CONSTANT_157_W) +XE_GPU_REGISTER(0x4278, float, SHADER_CONSTANT_158_X) +XE_GPU_REGISTER(0x4279, float, SHADER_CONSTANT_158_Y) +XE_GPU_REGISTER(0x427A, float, SHADER_CONSTANT_158_Z) +XE_GPU_REGISTER(0x427B, float, SHADER_CONSTANT_158_W) +XE_GPU_REGISTER(0x427C, float, SHADER_CONSTANT_159_X) +XE_GPU_REGISTER(0x427D, float, SHADER_CONSTANT_159_Y) +XE_GPU_REGISTER(0x427E, float, SHADER_CONSTANT_159_Z) +XE_GPU_REGISTER(0x427F, float, SHADER_CONSTANT_159_W) +XE_GPU_REGISTER(0x4280, float, SHADER_CONSTANT_160_X) +XE_GPU_REGISTER(0x4281, float, SHADER_CONSTANT_160_Y) +XE_GPU_REGISTER(0x4282, float, SHADER_CONSTANT_160_Z) +XE_GPU_REGISTER(0x4283, float, SHADER_CONSTANT_160_W) +XE_GPU_REGISTER(0x4284, float, SHADER_CONSTANT_161_X) +XE_GPU_REGISTER(0x4285, float, SHADER_CONSTANT_161_Y) +XE_GPU_REGISTER(0x4286, float, SHADER_CONSTANT_161_Z) +XE_GPU_REGISTER(0x4287, float, SHADER_CONSTANT_161_W) +XE_GPU_REGISTER(0x4288, float, SHADER_CONSTANT_162_X) +XE_GPU_REGISTER(0x4289, float, SHADER_CONSTANT_162_Y) +XE_GPU_REGISTER(0x428A, float, SHADER_CONSTANT_162_Z) +XE_GPU_REGISTER(0x428B, float, SHADER_CONSTANT_162_W) +XE_GPU_REGISTER(0x428C, float, SHADER_CONSTANT_163_X) +XE_GPU_REGISTER(0x428D, float, SHADER_CONSTANT_163_Y) +XE_GPU_REGISTER(0x428E, float, SHADER_CONSTANT_163_Z) +XE_GPU_REGISTER(0x428F, float, SHADER_CONSTANT_163_W) +XE_GPU_REGISTER(0x4290, float, SHADER_CONSTANT_164_X) +XE_GPU_REGISTER(0x4291, float, SHADER_CONSTANT_164_Y) +XE_GPU_REGISTER(0x4292, float, SHADER_CONSTANT_164_Z) +XE_GPU_REGISTER(0x4293, float, SHADER_CONSTANT_164_W) +XE_GPU_REGISTER(0x4294, float, SHADER_CONSTANT_165_X) +XE_GPU_REGISTER(0x4295, float, SHADER_CONSTANT_165_Y) +XE_GPU_REGISTER(0x4296, float, SHADER_CONSTANT_165_Z) +XE_GPU_REGISTER(0x4297, float, SHADER_CONSTANT_165_W) +XE_GPU_REGISTER(0x4298, float, SHADER_CONSTANT_166_X) +XE_GPU_REGISTER(0x4299, float, SHADER_CONSTANT_166_Y) +XE_GPU_REGISTER(0x429A, float, SHADER_CONSTANT_166_Z) +XE_GPU_REGISTER(0x429B, float, SHADER_CONSTANT_166_W) +XE_GPU_REGISTER(0x429C, float, SHADER_CONSTANT_167_X) +XE_GPU_REGISTER(0x429D, float, SHADER_CONSTANT_167_Y) +XE_GPU_REGISTER(0x429E, float, SHADER_CONSTANT_167_Z) +XE_GPU_REGISTER(0x429F, float, SHADER_CONSTANT_167_W) +XE_GPU_REGISTER(0x42A0, float, SHADER_CONSTANT_168_X) +XE_GPU_REGISTER(0x42A1, float, SHADER_CONSTANT_168_Y) +XE_GPU_REGISTER(0x42A2, float, SHADER_CONSTANT_168_Z) +XE_GPU_REGISTER(0x42A3, float, SHADER_CONSTANT_168_W) +XE_GPU_REGISTER(0x42A4, float, SHADER_CONSTANT_169_X) +XE_GPU_REGISTER(0x42A5, float, SHADER_CONSTANT_169_Y) +XE_GPU_REGISTER(0x42A6, float, SHADER_CONSTANT_169_Z) +XE_GPU_REGISTER(0x42A7, float, SHADER_CONSTANT_169_W) +XE_GPU_REGISTER(0x42A8, float, SHADER_CONSTANT_170_X) +XE_GPU_REGISTER(0x42A9, float, SHADER_CONSTANT_170_Y) +XE_GPU_REGISTER(0x42AA, float, SHADER_CONSTANT_170_Z) +XE_GPU_REGISTER(0x42AB, float, SHADER_CONSTANT_170_W) +XE_GPU_REGISTER(0x42AC, float, SHADER_CONSTANT_171_X) +XE_GPU_REGISTER(0x42AD, float, SHADER_CONSTANT_171_Y) +XE_GPU_REGISTER(0x42AE, float, SHADER_CONSTANT_171_Z) +XE_GPU_REGISTER(0x42AF, float, SHADER_CONSTANT_171_W) +XE_GPU_REGISTER(0x42B0, float, SHADER_CONSTANT_172_X) +XE_GPU_REGISTER(0x42B1, float, SHADER_CONSTANT_172_Y) +XE_GPU_REGISTER(0x42B2, float, SHADER_CONSTANT_172_Z) +XE_GPU_REGISTER(0x42B3, float, SHADER_CONSTANT_172_W) +XE_GPU_REGISTER(0x42B4, float, SHADER_CONSTANT_173_X) +XE_GPU_REGISTER(0x42B5, float, SHADER_CONSTANT_173_Y) +XE_GPU_REGISTER(0x42B6, float, SHADER_CONSTANT_173_Z) +XE_GPU_REGISTER(0x42B7, float, SHADER_CONSTANT_173_W) +XE_GPU_REGISTER(0x42B8, float, SHADER_CONSTANT_174_X) +XE_GPU_REGISTER(0x42B9, float, SHADER_CONSTANT_174_Y) +XE_GPU_REGISTER(0x42BA, float, SHADER_CONSTANT_174_Z) +XE_GPU_REGISTER(0x42BB, float, SHADER_CONSTANT_174_W) +XE_GPU_REGISTER(0x42BC, float, SHADER_CONSTANT_175_X) +XE_GPU_REGISTER(0x42BD, float, SHADER_CONSTANT_175_Y) +XE_GPU_REGISTER(0x42BE, float, SHADER_CONSTANT_175_Z) +XE_GPU_REGISTER(0x42BF, float, SHADER_CONSTANT_175_W) +XE_GPU_REGISTER(0x42C0, float, SHADER_CONSTANT_176_X) +XE_GPU_REGISTER(0x42C1, float, SHADER_CONSTANT_176_Y) +XE_GPU_REGISTER(0x42C2, float, SHADER_CONSTANT_176_Z) +XE_GPU_REGISTER(0x42C3, float, SHADER_CONSTANT_176_W) +XE_GPU_REGISTER(0x42C4, float, SHADER_CONSTANT_177_X) +XE_GPU_REGISTER(0x42C5, float, SHADER_CONSTANT_177_Y) +XE_GPU_REGISTER(0x42C6, float, SHADER_CONSTANT_177_Z) +XE_GPU_REGISTER(0x42C7, float, SHADER_CONSTANT_177_W) +XE_GPU_REGISTER(0x42C8, float, SHADER_CONSTANT_178_X) +XE_GPU_REGISTER(0x42C9, float, SHADER_CONSTANT_178_Y) +XE_GPU_REGISTER(0x42CA, float, SHADER_CONSTANT_178_Z) +XE_GPU_REGISTER(0x42CB, float, SHADER_CONSTANT_178_W) +XE_GPU_REGISTER(0x42CC, float, SHADER_CONSTANT_179_X) +XE_GPU_REGISTER(0x42CD, float, SHADER_CONSTANT_179_Y) +XE_GPU_REGISTER(0x42CE, float, SHADER_CONSTANT_179_Z) +XE_GPU_REGISTER(0x42CF, float, SHADER_CONSTANT_179_W) +XE_GPU_REGISTER(0x42D0, float, SHADER_CONSTANT_180_X) +XE_GPU_REGISTER(0x42D1, float, SHADER_CONSTANT_180_Y) +XE_GPU_REGISTER(0x42D2, float, SHADER_CONSTANT_180_Z) +XE_GPU_REGISTER(0x42D3, float, SHADER_CONSTANT_180_W) +XE_GPU_REGISTER(0x42D4, float, SHADER_CONSTANT_181_X) +XE_GPU_REGISTER(0x42D5, float, SHADER_CONSTANT_181_Y) +XE_GPU_REGISTER(0x42D6, float, SHADER_CONSTANT_181_Z) +XE_GPU_REGISTER(0x42D7, float, SHADER_CONSTANT_181_W) +XE_GPU_REGISTER(0x42D8, float, SHADER_CONSTANT_182_X) +XE_GPU_REGISTER(0x42D9, float, SHADER_CONSTANT_182_Y) +XE_GPU_REGISTER(0x42DA, float, SHADER_CONSTANT_182_Z) +XE_GPU_REGISTER(0x42DB, float, SHADER_CONSTANT_182_W) +XE_GPU_REGISTER(0x42DC, float, SHADER_CONSTANT_183_X) +XE_GPU_REGISTER(0x42DD, float, SHADER_CONSTANT_183_Y) +XE_GPU_REGISTER(0x42DE, float, SHADER_CONSTANT_183_Z) +XE_GPU_REGISTER(0x42DF, float, SHADER_CONSTANT_183_W) +XE_GPU_REGISTER(0x42E0, float, SHADER_CONSTANT_184_X) +XE_GPU_REGISTER(0x42E1, float, SHADER_CONSTANT_184_Y) +XE_GPU_REGISTER(0x42E2, float, SHADER_CONSTANT_184_Z) +XE_GPU_REGISTER(0x42E3, float, SHADER_CONSTANT_184_W) +XE_GPU_REGISTER(0x42E4, float, SHADER_CONSTANT_185_X) +XE_GPU_REGISTER(0x42E5, float, SHADER_CONSTANT_185_Y) +XE_GPU_REGISTER(0x42E6, float, SHADER_CONSTANT_185_Z) +XE_GPU_REGISTER(0x42E7, float, SHADER_CONSTANT_185_W) +XE_GPU_REGISTER(0x42E8, float, SHADER_CONSTANT_186_X) +XE_GPU_REGISTER(0x42E9, float, SHADER_CONSTANT_186_Y) +XE_GPU_REGISTER(0x42EA, float, SHADER_CONSTANT_186_Z) +XE_GPU_REGISTER(0x42EB, float, SHADER_CONSTANT_186_W) +XE_GPU_REGISTER(0x42EC, float, SHADER_CONSTANT_187_X) +XE_GPU_REGISTER(0x42ED, float, SHADER_CONSTANT_187_Y) +XE_GPU_REGISTER(0x42EE, float, SHADER_CONSTANT_187_Z) +XE_GPU_REGISTER(0x42EF, float, SHADER_CONSTANT_187_W) +XE_GPU_REGISTER(0x42F0, float, SHADER_CONSTANT_188_X) +XE_GPU_REGISTER(0x42F1, float, SHADER_CONSTANT_188_Y) +XE_GPU_REGISTER(0x42F2, float, SHADER_CONSTANT_188_Z) +XE_GPU_REGISTER(0x42F3, float, SHADER_CONSTANT_188_W) +XE_GPU_REGISTER(0x42F4, float, SHADER_CONSTANT_189_X) +XE_GPU_REGISTER(0x42F5, float, SHADER_CONSTANT_189_Y) +XE_GPU_REGISTER(0x42F6, float, SHADER_CONSTANT_189_Z) +XE_GPU_REGISTER(0x42F7, float, SHADER_CONSTANT_189_W) +XE_GPU_REGISTER(0x42F8, float, SHADER_CONSTANT_190_X) +XE_GPU_REGISTER(0x42F9, float, SHADER_CONSTANT_190_Y) +XE_GPU_REGISTER(0x42FA, float, SHADER_CONSTANT_190_Z) +XE_GPU_REGISTER(0x42FB, float, SHADER_CONSTANT_190_W) +XE_GPU_REGISTER(0x42FC, float, SHADER_CONSTANT_191_X) +XE_GPU_REGISTER(0x42FD, float, SHADER_CONSTANT_191_Y) +XE_GPU_REGISTER(0x42FE, float, SHADER_CONSTANT_191_Z) +XE_GPU_REGISTER(0x42FF, float, SHADER_CONSTANT_191_W) +XE_GPU_REGISTER(0x4300, float, SHADER_CONSTANT_192_X) +XE_GPU_REGISTER(0x4301, float, SHADER_CONSTANT_192_Y) +XE_GPU_REGISTER(0x4302, float, SHADER_CONSTANT_192_Z) +XE_GPU_REGISTER(0x4303, float, SHADER_CONSTANT_192_W) +XE_GPU_REGISTER(0x4304, float, SHADER_CONSTANT_193_X) +XE_GPU_REGISTER(0x4305, float, SHADER_CONSTANT_193_Y) +XE_GPU_REGISTER(0x4306, float, SHADER_CONSTANT_193_Z) +XE_GPU_REGISTER(0x4307, float, SHADER_CONSTANT_193_W) +XE_GPU_REGISTER(0x4308, float, SHADER_CONSTANT_194_X) +XE_GPU_REGISTER(0x4309, float, SHADER_CONSTANT_194_Y) +XE_GPU_REGISTER(0x430A, float, SHADER_CONSTANT_194_Z) +XE_GPU_REGISTER(0x430B, float, SHADER_CONSTANT_194_W) +XE_GPU_REGISTER(0x430C, float, SHADER_CONSTANT_195_X) +XE_GPU_REGISTER(0x430D, float, SHADER_CONSTANT_195_Y) +XE_GPU_REGISTER(0x430E, float, SHADER_CONSTANT_195_Z) +XE_GPU_REGISTER(0x430F, float, SHADER_CONSTANT_195_W) +XE_GPU_REGISTER(0x4310, float, SHADER_CONSTANT_196_X) +XE_GPU_REGISTER(0x4311, float, SHADER_CONSTANT_196_Y) +XE_GPU_REGISTER(0x4312, float, SHADER_CONSTANT_196_Z) +XE_GPU_REGISTER(0x4313, float, SHADER_CONSTANT_196_W) +XE_GPU_REGISTER(0x4314, float, SHADER_CONSTANT_197_X) +XE_GPU_REGISTER(0x4315, float, SHADER_CONSTANT_197_Y) +XE_GPU_REGISTER(0x4316, float, SHADER_CONSTANT_197_Z) +XE_GPU_REGISTER(0x4317, float, SHADER_CONSTANT_197_W) +XE_GPU_REGISTER(0x4318, float, SHADER_CONSTANT_198_X) +XE_GPU_REGISTER(0x4319, float, SHADER_CONSTANT_198_Y) +XE_GPU_REGISTER(0x431A, float, SHADER_CONSTANT_198_Z) +XE_GPU_REGISTER(0x431B, float, SHADER_CONSTANT_198_W) +XE_GPU_REGISTER(0x431C, float, SHADER_CONSTANT_199_X) +XE_GPU_REGISTER(0x431D, float, SHADER_CONSTANT_199_Y) +XE_GPU_REGISTER(0x431E, float, SHADER_CONSTANT_199_Z) +XE_GPU_REGISTER(0x431F, float, SHADER_CONSTANT_199_W) +XE_GPU_REGISTER(0x4320, float, SHADER_CONSTANT_200_X) +XE_GPU_REGISTER(0x4321, float, SHADER_CONSTANT_200_Y) +XE_GPU_REGISTER(0x4322, float, SHADER_CONSTANT_200_Z) +XE_GPU_REGISTER(0x4323, float, SHADER_CONSTANT_200_W) +XE_GPU_REGISTER(0x4324, float, SHADER_CONSTANT_201_X) +XE_GPU_REGISTER(0x4325, float, SHADER_CONSTANT_201_Y) +XE_GPU_REGISTER(0x4326, float, SHADER_CONSTANT_201_Z) +XE_GPU_REGISTER(0x4327, float, SHADER_CONSTANT_201_W) +XE_GPU_REGISTER(0x4328, float, SHADER_CONSTANT_202_X) +XE_GPU_REGISTER(0x4329, float, SHADER_CONSTANT_202_Y) +XE_GPU_REGISTER(0x432A, float, SHADER_CONSTANT_202_Z) +XE_GPU_REGISTER(0x432B, float, SHADER_CONSTANT_202_W) +XE_GPU_REGISTER(0x432C, float, SHADER_CONSTANT_203_X) +XE_GPU_REGISTER(0x432D, float, SHADER_CONSTANT_203_Y) +XE_GPU_REGISTER(0x432E, float, SHADER_CONSTANT_203_Z) +XE_GPU_REGISTER(0x432F, float, SHADER_CONSTANT_203_W) +XE_GPU_REGISTER(0x4330, float, SHADER_CONSTANT_204_X) +XE_GPU_REGISTER(0x4331, float, SHADER_CONSTANT_204_Y) +XE_GPU_REGISTER(0x4332, float, SHADER_CONSTANT_204_Z) +XE_GPU_REGISTER(0x4333, float, SHADER_CONSTANT_204_W) +XE_GPU_REGISTER(0x4334, float, SHADER_CONSTANT_205_X) +XE_GPU_REGISTER(0x4335, float, SHADER_CONSTANT_205_Y) +XE_GPU_REGISTER(0x4336, float, SHADER_CONSTANT_205_Z) +XE_GPU_REGISTER(0x4337, float, SHADER_CONSTANT_205_W) +XE_GPU_REGISTER(0x4338, float, SHADER_CONSTANT_206_X) +XE_GPU_REGISTER(0x4339, float, SHADER_CONSTANT_206_Y) +XE_GPU_REGISTER(0x433A, float, SHADER_CONSTANT_206_Z) +XE_GPU_REGISTER(0x433B, float, SHADER_CONSTANT_206_W) +XE_GPU_REGISTER(0x433C, float, SHADER_CONSTANT_207_X) +XE_GPU_REGISTER(0x433D, float, SHADER_CONSTANT_207_Y) +XE_GPU_REGISTER(0x433E, float, SHADER_CONSTANT_207_Z) +XE_GPU_REGISTER(0x433F, float, SHADER_CONSTANT_207_W) +XE_GPU_REGISTER(0x4340, float, SHADER_CONSTANT_208_X) +XE_GPU_REGISTER(0x4341, float, SHADER_CONSTANT_208_Y) +XE_GPU_REGISTER(0x4342, float, SHADER_CONSTANT_208_Z) +XE_GPU_REGISTER(0x4343, float, SHADER_CONSTANT_208_W) +XE_GPU_REGISTER(0x4344, float, SHADER_CONSTANT_209_X) +XE_GPU_REGISTER(0x4345, float, SHADER_CONSTANT_209_Y) +XE_GPU_REGISTER(0x4346, float, SHADER_CONSTANT_209_Z) +XE_GPU_REGISTER(0x4347, float, SHADER_CONSTANT_209_W) +XE_GPU_REGISTER(0x4348, float, SHADER_CONSTANT_210_X) +XE_GPU_REGISTER(0x4349, float, SHADER_CONSTANT_210_Y) +XE_GPU_REGISTER(0x434A, float, SHADER_CONSTANT_210_Z) +XE_GPU_REGISTER(0x434B, float, SHADER_CONSTANT_210_W) +XE_GPU_REGISTER(0x434C, float, SHADER_CONSTANT_211_X) +XE_GPU_REGISTER(0x434D, float, SHADER_CONSTANT_211_Y) +XE_GPU_REGISTER(0x434E, float, SHADER_CONSTANT_211_Z) +XE_GPU_REGISTER(0x434F, float, SHADER_CONSTANT_211_W) +XE_GPU_REGISTER(0x4350, float, SHADER_CONSTANT_212_X) +XE_GPU_REGISTER(0x4351, float, SHADER_CONSTANT_212_Y) +XE_GPU_REGISTER(0x4352, float, SHADER_CONSTANT_212_Z) +XE_GPU_REGISTER(0x4353, float, SHADER_CONSTANT_212_W) +XE_GPU_REGISTER(0x4354, float, SHADER_CONSTANT_213_X) +XE_GPU_REGISTER(0x4355, float, SHADER_CONSTANT_213_Y) +XE_GPU_REGISTER(0x4356, float, SHADER_CONSTANT_213_Z) +XE_GPU_REGISTER(0x4357, float, SHADER_CONSTANT_213_W) +XE_GPU_REGISTER(0x4358, float, SHADER_CONSTANT_214_X) +XE_GPU_REGISTER(0x4359, float, SHADER_CONSTANT_214_Y) +XE_GPU_REGISTER(0x435A, float, SHADER_CONSTANT_214_Z) +XE_GPU_REGISTER(0x435B, float, SHADER_CONSTANT_214_W) +XE_GPU_REGISTER(0x435C, float, SHADER_CONSTANT_215_X) +XE_GPU_REGISTER(0x435D, float, SHADER_CONSTANT_215_Y) +XE_GPU_REGISTER(0x435E, float, SHADER_CONSTANT_215_Z) +XE_GPU_REGISTER(0x435F, float, SHADER_CONSTANT_215_W) +XE_GPU_REGISTER(0x4360, float, SHADER_CONSTANT_216_X) +XE_GPU_REGISTER(0x4361, float, SHADER_CONSTANT_216_Y) +XE_GPU_REGISTER(0x4362, float, SHADER_CONSTANT_216_Z) +XE_GPU_REGISTER(0x4363, float, SHADER_CONSTANT_216_W) +XE_GPU_REGISTER(0x4364, float, SHADER_CONSTANT_217_X) +XE_GPU_REGISTER(0x4365, float, SHADER_CONSTANT_217_Y) +XE_GPU_REGISTER(0x4366, float, SHADER_CONSTANT_217_Z) +XE_GPU_REGISTER(0x4367, float, SHADER_CONSTANT_217_W) +XE_GPU_REGISTER(0x4368, float, SHADER_CONSTANT_218_X) +XE_GPU_REGISTER(0x4369, float, SHADER_CONSTANT_218_Y) +XE_GPU_REGISTER(0x436A, float, SHADER_CONSTANT_218_Z) +XE_GPU_REGISTER(0x436B, float, SHADER_CONSTANT_218_W) +XE_GPU_REGISTER(0x436C, float, SHADER_CONSTANT_219_X) +XE_GPU_REGISTER(0x436D, float, SHADER_CONSTANT_219_Y) +XE_GPU_REGISTER(0x436E, float, SHADER_CONSTANT_219_Z) +XE_GPU_REGISTER(0x436F, float, SHADER_CONSTANT_219_W) +XE_GPU_REGISTER(0x4370, float, SHADER_CONSTANT_220_X) +XE_GPU_REGISTER(0x4371, float, SHADER_CONSTANT_220_Y) +XE_GPU_REGISTER(0x4372, float, SHADER_CONSTANT_220_Z) +XE_GPU_REGISTER(0x4373, float, SHADER_CONSTANT_220_W) +XE_GPU_REGISTER(0x4374, float, SHADER_CONSTANT_221_X) +XE_GPU_REGISTER(0x4375, float, SHADER_CONSTANT_221_Y) +XE_GPU_REGISTER(0x4376, float, SHADER_CONSTANT_221_Z) +XE_GPU_REGISTER(0x4377, float, SHADER_CONSTANT_221_W) +XE_GPU_REGISTER(0x4378, float, SHADER_CONSTANT_222_X) +XE_GPU_REGISTER(0x4379, float, SHADER_CONSTANT_222_Y) +XE_GPU_REGISTER(0x437A, float, SHADER_CONSTANT_222_Z) +XE_GPU_REGISTER(0x437B, float, SHADER_CONSTANT_222_W) +XE_GPU_REGISTER(0x437C, float, SHADER_CONSTANT_223_X) +XE_GPU_REGISTER(0x437D, float, SHADER_CONSTANT_223_Y) +XE_GPU_REGISTER(0x437E, float, SHADER_CONSTANT_223_Z) +XE_GPU_REGISTER(0x437F, float, SHADER_CONSTANT_223_W) +XE_GPU_REGISTER(0x4380, float, SHADER_CONSTANT_224_X) +XE_GPU_REGISTER(0x4381, float, SHADER_CONSTANT_224_Y) +XE_GPU_REGISTER(0x4382, float, SHADER_CONSTANT_224_Z) +XE_GPU_REGISTER(0x4383, float, SHADER_CONSTANT_224_W) +XE_GPU_REGISTER(0x4384, float, SHADER_CONSTANT_225_X) +XE_GPU_REGISTER(0x4385, float, SHADER_CONSTANT_225_Y) +XE_GPU_REGISTER(0x4386, float, SHADER_CONSTANT_225_Z) +XE_GPU_REGISTER(0x4387, float, SHADER_CONSTANT_225_W) +XE_GPU_REGISTER(0x4388, float, SHADER_CONSTANT_226_X) +XE_GPU_REGISTER(0x4389, float, SHADER_CONSTANT_226_Y) +XE_GPU_REGISTER(0x438A, float, SHADER_CONSTANT_226_Z) +XE_GPU_REGISTER(0x438B, float, SHADER_CONSTANT_226_W) +XE_GPU_REGISTER(0x438C, float, SHADER_CONSTANT_227_X) +XE_GPU_REGISTER(0x438D, float, SHADER_CONSTANT_227_Y) +XE_GPU_REGISTER(0x438E, float, SHADER_CONSTANT_227_Z) +XE_GPU_REGISTER(0x438F, float, SHADER_CONSTANT_227_W) +XE_GPU_REGISTER(0x4390, float, SHADER_CONSTANT_228_X) +XE_GPU_REGISTER(0x4391, float, SHADER_CONSTANT_228_Y) +XE_GPU_REGISTER(0x4392, float, SHADER_CONSTANT_228_Z) +XE_GPU_REGISTER(0x4393, float, SHADER_CONSTANT_228_W) +XE_GPU_REGISTER(0x4394, float, SHADER_CONSTANT_229_X) +XE_GPU_REGISTER(0x4395, float, SHADER_CONSTANT_229_Y) +XE_GPU_REGISTER(0x4396, float, SHADER_CONSTANT_229_Z) +XE_GPU_REGISTER(0x4397, float, SHADER_CONSTANT_229_W) +XE_GPU_REGISTER(0x4398, float, SHADER_CONSTANT_230_X) +XE_GPU_REGISTER(0x4399, float, SHADER_CONSTANT_230_Y) +XE_GPU_REGISTER(0x439A, float, SHADER_CONSTANT_230_Z) +XE_GPU_REGISTER(0x439B, float, SHADER_CONSTANT_230_W) +XE_GPU_REGISTER(0x439C, float, SHADER_CONSTANT_231_X) +XE_GPU_REGISTER(0x439D, float, SHADER_CONSTANT_231_Y) +XE_GPU_REGISTER(0x439E, float, SHADER_CONSTANT_231_Z) +XE_GPU_REGISTER(0x439F, float, SHADER_CONSTANT_231_W) +XE_GPU_REGISTER(0x43A0, float, SHADER_CONSTANT_232_X) +XE_GPU_REGISTER(0x43A1, float, SHADER_CONSTANT_232_Y) +XE_GPU_REGISTER(0x43A2, float, SHADER_CONSTANT_232_Z) +XE_GPU_REGISTER(0x43A3, float, SHADER_CONSTANT_232_W) +XE_GPU_REGISTER(0x43A4, float, SHADER_CONSTANT_233_X) +XE_GPU_REGISTER(0x43A5, float, SHADER_CONSTANT_233_Y) +XE_GPU_REGISTER(0x43A6, float, SHADER_CONSTANT_233_Z) +XE_GPU_REGISTER(0x43A7, float, SHADER_CONSTANT_233_W) +XE_GPU_REGISTER(0x43A8, float, SHADER_CONSTANT_234_X) +XE_GPU_REGISTER(0x43A9, float, SHADER_CONSTANT_234_Y) +XE_GPU_REGISTER(0x43AA, float, SHADER_CONSTANT_234_Z) +XE_GPU_REGISTER(0x43AB, float, SHADER_CONSTANT_234_W) +XE_GPU_REGISTER(0x43AC, float, SHADER_CONSTANT_235_X) +XE_GPU_REGISTER(0x43AD, float, SHADER_CONSTANT_235_Y) +XE_GPU_REGISTER(0x43AE, float, SHADER_CONSTANT_235_Z) +XE_GPU_REGISTER(0x43AF, float, SHADER_CONSTANT_235_W) +XE_GPU_REGISTER(0x43B0, float, SHADER_CONSTANT_236_X) +XE_GPU_REGISTER(0x43B1, float, SHADER_CONSTANT_236_Y) +XE_GPU_REGISTER(0x43B2, float, SHADER_CONSTANT_236_Z) +XE_GPU_REGISTER(0x43B3, float, SHADER_CONSTANT_236_W) +XE_GPU_REGISTER(0x43B4, float, SHADER_CONSTANT_237_X) +XE_GPU_REGISTER(0x43B5, float, SHADER_CONSTANT_237_Y) +XE_GPU_REGISTER(0x43B6, float, SHADER_CONSTANT_237_Z) +XE_GPU_REGISTER(0x43B7, float, SHADER_CONSTANT_237_W) +XE_GPU_REGISTER(0x43B8, float, SHADER_CONSTANT_238_X) +XE_GPU_REGISTER(0x43B9, float, SHADER_CONSTANT_238_Y) +XE_GPU_REGISTER(0x43BA, float, SHADER_CONSTANT_238_Z) +XE_GPU_REGISTER(0x43BB, float, SHADER_CONSTANT_238_W) +XE_GPU_REGISTER(0x43BC, float, SHADER_CONSTANT_239_X) +XE_GPU_REGISTER(0x43BD, float, SHADER_CONSTANT_239_Y) +XE_GPU_REGISTER(0x43BE, float, SHADER_CONSTANT_239_Z) +XE_GPU_REGISTER(0x43BF, float, SHADER_CONSTANT_239_W) +XE_GPU_REGISTER(0x43C0, float, SHADER_CONSTANT_240_X) +XE_GPU_REGISTER(0x43C1, float, SHADER_CONSTANT_240_Y) +XE_GPU_REGISTER(0x43C2, float, SHADER_CONSTANT_240_Z) +XE_GPU_REGISTER(0x43C3, float, SHADER_CONSTANT_240_W) +XE_GPU_REGISTER(0x43C4, float, SHADER_CONSTANT_241_X) +XE_GPU_REGISTER(0x43C5, float, SHADER_CONSTANT_241_Y) +XE_GPU_REGISTER(0x43C6, float, SHADER_CONSTANT_241_Z) +XE_GPU_REGISTER(0x43C7, float, SHADER_CONSTANT_241_W) +XE_GPU_REGISTER(0x43C8, float, SHADER_CONSTANT_242_X) +XE_GPU_REGISTER(0x43C9, float, SHADER_CONSTANT_242_Y) +XE_GPU_REGISTER(0x43CA, float, SHADER_CONSTANT_242_Z) +XE_GPU_REGISTER(0x43CB, float, SHADER_CONSTANT_242_W) +XE_GPU_REGISTER(0x43CC, float, SHADER_CONSTANT_243_X) +XE_GPU_REGISTER(0x43CD, float, SHADER_CONSTANT_243_Y) +XE_GPU_REGISTER(0x43CE, float, SHADER_CONSTANT_243_Z) +XE_GPU_REGISTER(0x43CF, float, SHADER_CONSTANT_243_W) +XE_GPU_REGISTER(0x43D0, float, SHADER_CONSTANT_244_X) +XE_GPU_REGISTER(0x43D1, float, SHADER_CONSTANT_244_Y) +XE_GPU_REGISTER(0x43D2, float, SHADER_CONSTANT_244_Z) +XE_GPU_REGISTER(0x43D3, float, SHADER_CONSTANT_244_W) +XE_GPU_REGISTER(0x43D4, float, SHADER_CONSTANT_245_X) +XE_GPU_REGISTER(0x43D5, float, SHADER_CONSTANT_245_Y) +XE_GPU_REGISTER(0x43D6, float, SHADER_CONSTANT_245_Z) +XE_GPU_REGISTER(0x43D7, float, SHADER_CONSTANT_245_W) +XE_GPU_REGISTER(0x43D8, float, SHADER_CONSTANT_246_X) +XE_GPU_REGISTER(0x43D9, float, SHADER_CONSTANT_246_Y) +XE_GPU_REGISTER(0x43DA, float, SHADER_CONSTANT_246_Z) +XE_GPU_REGISTER(0x43DB, float, SHADER_CONSTANT_246_W) +XE_GPU_REGISTER(0x43DC, float, SHADER_CONSTANT_247_X) +XE_GPU_REGISTER(0x43DD, float, SHADER_CONSTANT_247_Y) +XE_GPU_REGISTER(0x43DE, float, SHADER_CONSTANT_247_Z) +XE_GPU_REGISTER(0x43DF, float, SHADER_CONSTANT_247_W) +XE_GPU_REGISTER(0x43E0, float, SHADER_CONSTANT_248_X) +XE_GPU_REGISTER(0x43E1, float, SHADER_CONSTANT_248_Y) +XE_GPU_REGISTER(0x43E2, float, SHADER_CONSTANT_248_Z) +XE_GPU_REGISTER(0x43E3, float, SHADER_CONSTANT_248_W) +XE_GPU_REGISTER(0x43E4, float, SHADER_CONSTANT_249_X) +XE_GPU_REGISTER(0x43E5, float, SHADER_CONSTANT_249_Y) +XE_GPU_REGISTER(0x43E6, float, SHADER_CONSTANT_249_Z) +XE_GPU_REGISTER(0x43E7, float, SHADER_CONSTANT_249_W) +XE_GPU_REGISTER(0x43E8, float, SHADER_CONSTANT_250_X) +XE_GPU_REGISTER(0x43E9, float, SHADER_CONSTANT_250_Y) +XE_GPU_REGISTER(0x43EA, float, SHADER_CONSTANT_250_Z) +XE_GPU_REGISTER(0x43EB, float, SHADER_CONSTANT_250_W) +XE_GPU_REGISTER(0x43EC, float, SHADER_CONSTANT_251_X) +XE_GPU_REGISTER(0x43ED, float, SHADER_CONSTANT_251_Y) +XE_GPU_REGISTER(0x43EE, float, SHADER_CONSTANT_251_Z) +XE_GPU_REGISTER(0x43EF, float, SHADER_CONSTANT_251_W) +XE_GPU_REGISTER(0x43F0, float, SHADER_CONSTANT_252_X) +XE_GPU_REGISTER(0x43F1, float, SHADER_CONSTANT_252_Y) +XE_GPU_REGISTER(0x43F2, float, SHADER_CONSTANT_252_Z) +XE_GPU_REGISTER(0x43F3, float, SHADER_CONSTANT_252_W) +XE_GPU_REGISTER(0x43F4, float, SHADER_CONSTANT_253_X) +XE_GPU_REGISTER(0x43F5, float, SHADER_CONSTANT_253_Y) +XE_GPU_REGISTER(0x43F6, float, SHADER_CONSTANT_253_Z) +XE_GPU_REGISTER(0x43F7, float, SHADER_CONSTANT_253_W) +XE_GPU_REGISTER(0x43F8, float, SHADER_CONSTANT_254_X) +XE_GPU_REGISTER(0x43F9, float, SHADER_CONSTANT_254_Y) +XE_GPU_REGISTER(0x43FA, float, SHADER_CONSTANT_254_Z) +XE_GPU_REGISTER(0x43FB, float, SHADER_CONSTANT_254_W) +XE_GPU_REGISTER(0x43FC, float, SHADER_CONSTANT_255_X) +XE_GPU_REGISTER(0x43FD, float, SHADER_CONSTANT_255_Y) +XE_GPU_REGISTER(0x43FE, float, SHADER_CONSTANT_255_Z) +XE_GPU_REGISTER(0x43FF, float, SHADER_CONSTANT_255_W) +XE_GPU_REGISTER(0x4400, float, SHADER_CONSTANT_256_X) +XE_GPU_REGISTER(0x4401, float, SHADER_CONSTANT_256_Y) +XE_GPU_REGISTER(0x4402, float, SHADER_CONSTANT_256_Z) +XE_GPU_REGISTER(0x4403, float, SHADER_CONSTANT_256_W) +XE_GPU_REGISTER(0x4404, float, SHADER_CONSTANT_257_X) +XE_GPU_REGISTER(0x4405, float, SHADER_CONSTANT_257_Y) +XE_GPU_REGISTER(0x4406, float, SHADER_CONSTANT_257_Z) +XE_GPU_REGISTER(0x4407, float, SHADER_CONSTANT_257_W) +XE_GPU_REGISTER(0x4408, float, SHADER_CONSTANT_258_X) +XE_GPU_REGISTER(0x4409, float, SHADER_CONSTANT_258_Y) +XE_GPU_REGISTER(0x440A, float, SHADER_CONSTANT_258_Z) +XE_GPU_REGISTER(0x440B, float, SHADER_CONSTANT_258_W) +XE_GPU_REGISTER(0x440C, float, SHADER_CONSTANT_259_X) +XE_GPU_REGISTER(0x440D, float, SHADER_CONSTANT_259_Y) +XE_GPU_REGISTER(0x440E, float, SHADER_CONSTANT_259_Z) +XE_GPU_REGISTER(0x440F, float, SHADER_CONSTANT_259_W) +XE_GPU_REGISTER(0x4410, float, SHADER_CONSTANT_260_X) +XE_GPU_REGISTER(0x4411, float, SHADER_CONSTANT_260_Y) +XE_GPU_REGISTER(0x4412, float, SHADER_CONSTANT_260_Z) +XE_GPU_REGISTER(0x4413, float, SHADER_CONSTANT_260_W) +XE_GPU_REGISTER(0x4414, float, SHADER_CONSTANT_261_X) +XE_GPU_REGISTER(0x4415, float, SHADER_CONSTANT_261_Y) +XE_GPU_REGISTER(0x4416, float, SHADER_CONSTANT_261_Z) +XE_GPU_REGISTER(0x4417, float, SHADER_CONSTANT_261_W) +XE_GPU_REGISTER(0x4418, float, SHADER_CONSTANT_262_X) +XE_GPU_REGISTER(0x4419, float, SHADER_CONSTANT_262_Y) +XE_GPU_REGISTER(0x441A, float, SHADER_CONSTANT_262_Z) +XE_GPU_REGISTER(0x441B, float, SHADER_CONSTANT_262_W) +XE_GPU_REGISTER(0x441C, float, SHADER_CONSTANT_263_X) +XE_GPU_REGISTER(0x441D, float, SHADER_CONSTANT_263_Y) +XE_GPU_REGISTER(0x441E, float, SHADER_CONSTANT_263_Z) +XE_GPU_REGISTER(0x441F, float, SHADER_CONSTANT_263_W) +XE_GPU_REGISTER(0x4420, float, SHADER_CONSTANT_264_X) +XE_GPU_REGISTER(0x4421, float, SHADER_CONSTANT_264_Y) +XE_GPU_REGISTER(0x4422, float, SHADER_CONSTANT_264_Z) +XE_GPU_REGISTER(0x4423, float, SHADER_CONSTANT_264_W) +XE_GPU_REGISTER(0x4424, float, SHADER_CONSTANT_265_X) +XE_GPU_REGISTER(0x4425, float, SHADER_CONSTANT_265_Y) +XE_GPU_REGISTER(0x4426, float, SHADER_CONSTANT_265_Z) +XE_GPU_REGISTER(0x4427, float, SHADER_CONSTANT_265_W) +XE_GPU_REGISTER(0x4428, float, SHADER_CONSTANT_266_X) +XE_GPU_REGISTER(0x4429, float, SHADER_CONSTANT_266_Y) +XE_GPU_REGISTER(0x442A, float, SHADER_CONSTANT_266_Z) +XE_GPU_REGISTER(0x442B, float, SHADER_CONSTANT_266_W) +XE_GPU_REGISTER(0x442C, float, SHADER_CONSTANT_267_X) +XE_GPU_REGISTER(0x442D, float, SHADER_CONSTANT_267_Y) +XE_GPU_REGISTER(0x442E, float, SHADER_CONSTANT_267_Z) +XE_GPU_REGISTER(0x442F, float, SHADER_CONSTANT_267_W) +XE_GPU_REGISTER(0x4430, float, SHADER_CONSTANT_268_X) +XE_GPU_REGISTER(0x4431, float, SHADER_CONSTANT_268_Y) +XE_GPU_REGISTER(0x4432, float, SHADER_CONSTANT_268_Z) +XE_GPU_REGISTER(0x4433, float, SHADER_CONSTANT_268_W) +XE_GPU_REGISTER(0x4434, float, SHADER_CONSTANT_269_X) +XE_GPU_REGISTER(0x4435, float, SHADER_CONSTANT_269_Y) +XE_GPU_REGISTER(0x4436, float, SHADER_CONSTANT_269_Z) +XE_GPU_REGISTER(0x4437, float, SHADER_CONSTANT_269_W) +XE_GPU_REGISTER(0x4438, float, SHADER_CONSTANT_270_X) +XE_GPU_REGISTER(0x4439, float, SHADER_CONSTANT_270_Y) +XE_GPU_REGISTER(0x443A, float, SHADER_CONSTANT_270_Z) +XE_GPU_REGISTER(0x443B, float, SHADER_CONSTANT_270_W) +XE_GPU_REGISTER(0x443C, float, SHADER_CONSTANT_271_X) +XE_GPU_REGISTER(0x443D, float, SHADER_CONSTANT_271_Y) +XE_GPU_REGISTER(0x443E, float, SHADER_CONSTANT_271_Z) +XE_GPU_REGISTER(0x443F, float, SHADER_CONSTANT_271_W) +XE_GPU_REGISTER(0x4440, float, SHADER_CONSTANT_272_X) +XE_GPU_REGISTER(0x4441, float, SHADER_CONSTANT_272_Y) +XE_GPU_REGISTER(0x4442, float, SHADER_CONSTANT_272_Z) +XE_GPU_REGISTER(0x4443, float, SHADER_CONSTANT_272_W) +XE_GPU_REGISTER(0x4444, float, SHADER_CONSTANT_273_X) +XE_GPU_REGISTER(0x4445, float, SHADER_CONSTANT_273_Y) +XE_GPU_REGISTER(0x4446, float, SHADER_CONSTANT_273_Z) +XE_GPU_REGISTER(0x4447, float, SHADER_CONSTANT_273_W) +XE_GPU_REGISTER(0x4448, float, SHADER_CONSTANT_274_X) +XE_GPU_REGISTER(0x4449, float, SHADER_CONSTANT_274_Y) +XE_GPU_REGISTER(0x444A, float, SHADER_CONSTANT_274_Z) +XE_GPU_REGISTER(0x444B, float, SHADER_CONSTANT_274_W) +XE_GPU_REGISTER(0x444C, float, SHADER_CONSTANT_275_X) +XE_GPU_REGISTER(0x444D, float, SHADER_CONSTANT_275_Y) +XE_GPU_REGISTER(0x444E, float, SHADER_CONSTANT_275_Z) +XE_GPU_REGISTER(0x444F, float, SHADER_CONSTANT_275_W) +XE_GPU_REGISTER(0x4450, float, SHADER_CONSTANT_276_X) +XE_GPU_REGISTER(0x4451, float, SHADER_CONSTANT_276_Y) +XE_GPU_REGISTER(0x4452, float, SHADER_CONSTANT_276_Z) +XE_GPU_REGISTER(0x4453, float, SHADER_CONSTANT_276_W) +XE_GPU_REGISTER(0x4454, float, SHADER_CONSTANT_277_X) +XE_GPU_REGISTER(0x4455, float, SHADER_CONSTANT_277_Y) +XE_GPU_REGISTER(0x4456, float, SHADER_CONSTANT_277_Z) +XE_GPU_REGISTER(0x4457, float, SHADER_CONSTANT_277_W) +XE_GPU_REGISTER(0x4458, float, SHADER_CONSTANT_278_X) +XE_GPU_REGISTER(0x4459, float, SHADER_CONSTANT_278_Y) +XE_GPU_REGISTER(0x445A, float, SHADER_CONSTANT_278_Z) +XE_GPU_REGISTER(0x445B, float, SHADER_CONSTANT_278_W) +XE_GPU_REGISTER(0x445C, float, SHADER_CONSTANT_279_X) +XE_GPU_REGISTER(0x445D, float, SHADER_CONSTANT_279_Y) +XE_GPU_REGISTER(0x445E, float, SHADER_CONSTANT_279_Z) +XE_GPU_REGISTER(0x445F, float, SHADER_CONSTANT_279_W) +XE_GPU_REGISTER(0x4460, float, SHADER_CONSTANT_280_X) +XE_GPU_REGISTER(0x4461, float, SHADER_CONSTANT_280_Y) +XE_GPU_REGISTER(0x4462, float, SHADER_CONSTANT_280_Z) +XE_GPU_REGISTER(0x4463, float, SHADER_CONSTANT_280_W) +XE_GPU_REGISTER(0x4464, float, SHADER_CONSTANT_281_X) +XE_GPU_REGISTER(0x4465, float, SHADER_CONSTANT_281_Y) +XE_GPU_REGISTER(0x4466, float, SHADER_CONSTANT_281_Z) +XE_GPU_REGISTER(0x4467, float, SHADER_CONSTANT_281_W) +XE_GPU_REGISTER(0x4468, float, SHADER_CONSTANT_282_X) +XE_GPU_REGISTER(0x4469, float, SHADER_CONSTANT_282_Y) +XE_GPU_REGISTER(0x446A, float, SHADER_CONSTANT_282_Z) +XE_GPU_REGISTER(0x446B, float, SHADER_CONSTANT_282_W) +XE_GPU_REGISTER(0x446C, float, SHADER_CONSTANT_283_X) +XE_GPU_REGISTER(0x446D, float, SHADER_CONSTANT_283_Y) +XE_GPU_REGISTER(0x446E, float, SHADER_CONSTANT_283_Z) +XE_GPU_REGISTER(0x446F, float, SHADER_CONSTANT_283_W) +XE_GPU_REGISTER(0x4470, float, SHADER_CONSTANT_284_X) +XE_GPU_REGISTER(0x4471, float, SHADER_CONSTANT_284_Y) +XE_GPU_REGISTER(0x4472, float, SHADER_CONSTANT_284_Z) +XE_GPU_REGISTER(0x4473, float, SHADER_CONSTANT_284_W) +XE_GPU_REGISTER(0x4474, float, SHADER_CONSTANT_285_X) +XE_GPU_REGISTER(0x4475, float, SHADER_CONSTANT_285_Y) +XE_GPU_REGISTER(0x4476, float, SHADER_CONSTANT_285_Z) +XE_GPU_REGISTER(0x4477, float, SHADER_CONSTANT_285_W) +XE_GPU_REGISTER(0x4478, float, SHADER_CONSTANT_286_X) +XE_GPU_REGISTER(0x4479, float, SHADER_CONSTANT_286_Y) +XE_GPU_REGISTER(0x447A, float, SHADER_CONSTANT_286_Z) +XE_GPU_REGISTER(0x447B, float, SHADER_CONSTANT_286_W) +XE_GPU_REGISTER(0x447C, float, SHADER_CONSTANT_287_X) +XE_GPU_REGISTER(0x447D, float, SHADER_CONSTANT_287_Y) +XE_GPU_REGISTER(0x447E, float, SHADER_CONSTANT_287_Z) +XE_GPU_REGISTER(0x447F, float, SHADER_CONSTANT_287_W) +XE_GPU_REGISTER(0x4480, float, SHADER_CONSTANT_288_X) +XE_GPU_REGISTER(0x4481, float, SHADER_CONSTANT_288_Y) +XE_GPU_REGISTER(0x4482, float, SHADER_CONSTANT_288_Z) +XE_GPU_REGISTER(0x4483, float, SHADER_CONSTANT_288_W) +XE_GPU_REGISTER(0x4484, float, SHADER_CONSTANT_289_X) +XE_GPU_REGISTER(0x4485, float, SHADER_CONSTANT_289_Y) +XE_GPU_REGISTER(0x4486, float, SHADER_CONSTANT_289_Z) +XE_GPU_REGISTER(0x4487, float, SHADER_CONSTANT_289_W) +XE_GPU_REGISTER(0x4488, float, SHADER_CONSTANT_290_X) +XE_GPU_REGISTER(0x4489, float, SHADER_CONSTANT_290_Y) +XE_GPU_REGISTER(0x448A, float, SHADER_CONSTANT_290_Z) +XE_GPU_REGISTER(0x448B, float, SHADER_CONSTANT_290_W) +XE_GPU_REGISTER(0x448C, float, SHADER_CONSTANT_291_X) +XE_GPU_REGISTER(0x448D, float, SHADER_CONSTANT_291_Y) +XE_GPU_REGISTER(0x448E, float, SHADER_CONSTANT_291_Z) +XE_GPU_REGISTER(0x448F, float, SHADER_CONSTANT_291_W) +XE_GPU_REGISTER(0x4490, float, SHADER_CONSTANT_292_X) +XE_GPU_REGISTER(0x4491, float, SHADER_CONSTANT_292_Y) +XE_GPU_REGISTER(0x4492, float, SHADER_CONSTANT_292_Z) +XE_GPU_REGISTER(0x4493, float, SHADER_CONSTANT_292_W) +XE_GPU_REGISTER(0x4494, float, SHADER_CONSTANT_293_X) +XE_GPU_REGISTER(0x4495, float, SHADER_CONSTANT_293_Y) +XE_GPU_REGISTER(0x4496, float, SHADER_CONSTANT_293_Z) +XE_GPU_REGISTER(0x4497, float, SHADER_CONSTANT_293_W) +XE_GPU_REGISTER(0x4498, float, SHADER_CONSTANT_294_X) +XE_GPU_REGISTER(0x4499, float, SHADER_CONSTANT_294_Y) +XE_GPU_REGISTER(0x449A, float, SHADER_CONSTANT_294_Z) +XE_GPU_REGISTER(0x449B, float, SHADER_CONSTANT_294_W) +XE_GPU_REGISTER(0x449C, float, SHADER_CONSTANT_295_X) +XE_GPU_REGISTER(0x449D, float, SHADER_CONSTANT_295_Y) +XE_GPU_REGISTER(0x449E, float, SHADER_CONSTANT_295_Z) +XE_GPU_REGISTER(0x449F, float, SHADER_CONSTANT_295_W) +XE_GPU_REGISTER(0x44A0, float, SHADER_CONSTANT_296_X) +XE_GPU_REGISTER(0x44A1, float, SHADER_CONSTANT_296_Y) +XE_GPU_REGISTER(0x44A2, float, SHADER_CONSTANT_296_Z) +XE_GPU_REGISTER(0x44A3, float, SHADER_CONSTANT_296_W) +XE_GPU_REGISTER(0x44A4, float, SHADER_CONSTANT_297_X) +XE_GPU_REGISTER(0x44A5, float, SHADER_CONSTANT_297_Y) +XE_GPU_REGISTER(0x44A6, float, SHADER_CONSTANT_297_Z) +XE_GPU_REGISTER(0x44A7, float, SHADER_CONSTANT_297_W) +XE_GPU_REGISTER(0x44A8, float, SHADER_CONSTANT_298_X) +XE_GPU_REGISTER(0x44A9, float, SHADER_CONSTANT_298_Y) +XE_GPU_REGISTER(0x44AA, float, SHADER_CONSTANT_298_Z) +XE_GPU_REGISTER(0x44AB, float, SHADER_CONSTANT_298_W) +XE_GPU_REGISTER(0x44AC, float, SHADER_CONSTANT_299_X) +XE_GPU_REGISTER(0x44AD, float, SHADER_CONSTANT_299_Y) +XE_GPU_REGISTER(0x44AE, float, SHADER_CONSTANT_299_Z) +XE_GPU_REGISTER(0x44AF, float, SHADER_CONSTANT_299_W) +XE_GPU_REGISTER(0x44B0, float, SHADER_CONSTANT_300_X) +XE_GPU_REGISTER(0x44B1, float, SHADER_CONSTANT_300_Y) +XE_GPU_REGISTER(0x44B2, float, SHADER_CONSTANT_300_Z) +XE_GPU_REGISTER(0x44B3, float, SHADER_CONSTANT_300_W) +XE_GPU_REGISTER(0x44B4, float, SHADER_CONSTANT_301_X) +XE_GPU_REGISTER(0x44B5, float, SHADER_CONSTANT_301_Y) +XE_GPU_REGISTER(0x44B6, float, SHADER_CONSTANT_301_Z) +XE_GPU_REGISTER(0x44B7, float, SHADER_CONSTANT_301_W) +XE_GPU_REGISTER(0x44B8, float, SHADER_CONSTANT_302_X) +XE_GPU_REGISTER(0x44B9, float, SHADER_CONSTANT_302_Y) +XE_GPU_REGISTER(0x44BA, float, SHADER_CONSTANT_302_Z) +XE_GPU_REGISTER(0x44BB, float, SHADER_CONSTANT_302_W) +XE_GPU_REGISTER(0x44BC, float, SHADER_CONSTANT_303_X) +XE_GPU_REGISTER(0x44BD, float, SHADER_CONSTANT_303_Y) +XE_GPU_REGISTER(0x44BE, float, SHADER_CONSTANT_303_Z) +XE_GPU_REGISTER(0x44BF, float, SHADER_CONSTANT_303_W) +XE_GPU_REGISTER(0x44C0, float, SHADER_CONSTANT_304_X) +XE_GPU_REGISTER(0x44C1, float, SHADER_CONSTANT_304_Y) +XE_GPU_REGISTER(0x44C2, float, SHADER_CONSTANT_304_Z) +XE_GPU_REGISTER(0x44C3, float, SHADER_CONSTANT_304_W) +XE_GPU_REGISTER(0x44C4, float, SHADER_CONSTANT_305_X) +XE_GPU_REGISTER(0x44C5, float, SHADER_CONSTANT_305_Y) +XE_GPU_REGISTER(0x44C6, float, SHADER_CONSTANT_305_Z) +XE_GPU_REGISTER(0x44C7, float, SHADER_CONSTANT_305_W) +XE_GPU_REGISTER(0x44C8, float, SHADER_CONSTANT_306_X) +XE_GPU_REGISTER(0x44C9, float, SHADER_CONSTANT_306_Y) +XE_GPU_REGISTER(0x44CA, float, SHADER_CONSTANT_306_Z) +XE_GPU_REGISTER(0x44CB, float, SHADER_CONSTANT_306_W) +XE_GPU_REGISTER(0x44CC, float, SHADER_CONSTANT_307_X) +XE_GPU_REGISTER(0x44CD, float, SHADER_CONSTANT_307_Y) +XE_GPU_REGISTER(0x44CE, float, SHADER_CONSTANT_307_Z) +XE_GPU_REGISTER(0x44CF, float, SHADER_CONSTANT_307_W) +XE_GPU_REGISTER(0x44D0, float, SHADER_CONSTANT_308_X) +XE_GPU_REGISTER(0x44D1, float, SHADER_CONSTANT_308_Y) +XE_GPU_REGISTER(0x44D2, float, SHADER_CONSTANT_308_Z) +XE_GPU_REGISTER(0x44D3, float, SHADER_CONSTANT_308_W) +XE_GPU_REGISTER(0x44D4, float, SHADER_CONSTANT_309_X) +XE_GPU_REGISTER(0x44D5, float, SHADER_CONSTANT_309_Y) +XE_GPU_REGISTER(0x44D6, float, SHADER_CONSTANT_309_Z) +XE_GPU_REGISTER(0x44D7, float, SHADER_CONSTANT_309_W) +XE_GPU_REGISTER(0x44D8, float, SHADER_CONSTANT_310_X) +XE_GPU_REGISTER(0x44D9, float, SHADER_CONSTANT_310_Y) +XE_GPU_REGISTER(0x44DA, float, SHADER_CONSTANT_310_Z) +XE_GPU_REGISTER(0x44DB, float, SHADER_CONSTANT_310_W) +XE_GPU_REGISTER(0x44DC, float, SHADER_CONSTANT_311_X) +XE_GPU_REGISTER(0x44DD, float, SHADER_CONSTANT_311_Y) +XE_GPU_REGISTER(0x44DE, float, SHADER_CONSTANT_311_Z) +XE_GPU_REGISTER(0x44DF, float, SHADER_CONSTANT_311_W) +XE_GPU_REGISTER(0x44E0, float, SHADER_CONSTANT_312_X) +XE_GPU_REGISTER(0x44E1, float, SHADER_CONSTANT_312_Y) +XE_GPU_REGISTER(0x44E2, float, SHADER_CONSTANT_312_Z) +XE_GPU_REGISTER(0x44E3, float, SHADER_CONSTANT_312_W) +XE_GPU_REGISTER(0x44E4, float, SHADER_CONSTANT_313_X) +XE_GPU_REGISTER(0x44E5, float, SHADER_CONSTANT_313_Y) +XE_GPU_REGISTER(0x44E6, float, SHADER_CONSTANT_313_Z) +XE_GPU_REGISTER(0x44E7, float, SHADER_CONSTANT_313_W) +XE_GPU_REGISTER(0x44E8, float, SHADER_CONSTANT_314_X) +XE_GPU_REGISTER(0x44E9, float, SHADER_CONSTANT_314_Y) +XE_GPU_REGISTER(0x44EA, float, SHADER_CONSTANT_314_Z) +XE_GPU_REGISTER(0x44EB, float, SHADER_CONSTANT_314_W) +XE_GPU_REGISTER(0x44EC, float, SHADER_CONSTANT_315_X) +XE_GPU_REGISTER(0x44ED, float, SHADER_CONSTANT_315_Y) +XE_GPU_REGISTER(0x44EE, float, SHADER_CONSTANT_315_Z) +XE_GPU_REGISTER(0x44EF, float, SHADER_CONSTANT_315_W) +XE_GPU_REGISTER(0x44F0, float, SHADER_CONSTANT_316_X) +XE_GPU_REGISTER(0x44F1, float, SHADER_CONSTANT_316_Y) +XE_GPU_REGISTER(0x44F2, float, SHADER_CONSTANT_316_Z) +XE_GPU_REGISTER(0x44F3, float, SHADER_CONSTANT_316_W) +XE_GPU_REGISTER(0x44F4, float, SHADER_CONSTANT_317_X) +XE_GPU_REGISTER(0x44F5, float, SHADER_CONSTANT_317_Y) +XE_GPU_REGISTER(0x44F6, float, SHADER_CONSTANT_317_Z) +XE_GPU_REGISTER(0x44F7, float, SHADER_CONSTANT_317_W) +XE_GPU_REGISTER(0x44F8, float, SHADER_CONSTANT_318_X) +XE_GPU_REGISTER(0x44F9, float, SHADER_CONSTANT_318_Y) +XE_GPU_REGISTER(0x44FA, float, SHADER_CONSTANT_318_Z) +XE_GPU_REGISTER(0x44FB, float, SHADER_CONSTANT_318_W) +XE_GPU_REGISTER(0x44FC, float, SHADER_CONSTANT_319_X) +XE_GPU_REGISTER(0x44FD, float, SHADER_CONSTANT_319_Y) +XE_GPU_REGISTER(0x44FE, float, SHADER_CONSTANT_319_Z) +XE_GPU_REGISTER(0x44FF, float, SHADER_CONSTANT_319_W) +XE_GPU_REGISTER(0x4500, float, SHADER_CONSTANT_320_X) +XE_GPU_REGISTER(0x4501, float, SHADER_CONSTANT_320_Y) +XE_GPU_REGISTER(0x4502, float, SHADER_CONSTANT_320_Z) +XE_GPU_REGISTER(0x4503, float, SHADER_CONSTANT_320_W) +XE_GPU_REGISTER(0x4504, float, SHADER_CONSTANT_321_X) +XE_GPU_REGISTER(0x4505, float, SHADER_CONSTANT_321_Y) +XE_GPU_REGISTER(0x4506, float, SHADER_CONSTANT_321_Z) +XE_GPU_REGISTER(0x4507, float, SHADER_CONSTANT_321_W) +XE_GPU_REGISTER(0x4508, float, SHADER_CONSTANT_322_X) +XE_GPU_REGISTER(0x4509, float, SHADER_CONSTANT_322_Y) +XE_GPU_REGISTER(0x450A, float, SHADER_CONSTANT_322_Z) +XE_GPU_REGISTER(0x450B, float, SHADER_CONSTANT_322_W) +XE_GPU_REGISTER(0x450C, float, SHADER_CONSTANT_323_X) +XE_GPU_REGISTER(0x450D, float, SHADER_CONSTANT_323_Y) +XE_GPU_REGISTER(0x450E, float, SHADER_CONSTANT_323_Z) +XE_GPU_REGISTER(0x450F, float, SHADER_CONSTANT_323_W) +XE_GPU_REGISTER(0x4510, float, SHADER_CONSTANT_324_X) +XE_GPU_REGISTER(0x4511, float, SHADER_CONSTANT_324_Y) +XE_GPU_REGISTER(0x4512, float, SHADER_CONSTANT_324_Z) +XE_GPU_REGISTER(0x4513, float, SHADER_CONSTANT_324_W) +XE_GPU_REGISTER(0x4514, float, SHADER_CONSTANT_325_X) +XE_GPU_REGISTER(0x4515, float, SHADER_CONSTANT_325_Y) +XE_GPU_REGISTER(0x4516, float, SHADER_CONSTANT_325_Z) +XE_GPU_REGISTER(0x4517, float, SHADER_CONSTANT_325_W) +XE_GPU_REGISTER(0x4518, float, SHADER_CONSTANT_326_X) +XE_GPU_REGISTER(0x4519, float, SHADER_CONSTANT_326_Y) +XE_GPU_REGISTER(0x451A, float, SHADER_CONSTANT_326_Z) +XE_GPU_REGISTER(0x451B, float, SHADER_CONSTANT_326_W) +XE_GPU_REGISTER(0x451C, float, SHADER_CONSTANT_327_X) +XE_GPU_REGISTER(0x451D, float, SHADER_CONSTANT_327_Y) +XE_GPU_REGISTER(0x451E, float, SHADER_CONSTANT_327_Z) +XE_GPU_REGISTER(0x451F, float, SHADER_CONSTANT_327_W) +XE_GPU_REGISTER(0x4520, float, SHADER_CONSTANT_328_X) +XE_GPU_REGISTER(0x4521, float, SHADER_CONSTANT_328_Y) +XE_GPU_REGISTER(0x4522, float, SHADER_CONSTANT_328_Z) +XE_GPU_REGISTER(0x4523, float, SHADER_CONSTANT_328_W) +XE_GPU_REGISTER(0x4524, float, SHADER_CONSTANT_329_X) +XE_GPU_REGISTER(0x4525, float, SHADER_CONSTANT_329_Y) +XE_GPU_REGISTER(0x4526, float, SHADER_CONSTANT_329_Z) +XE_GPU_REGISTER(0x4527, float, SHADER_CONSTANT_329_W) +XE_GPU_REGISTER(0x4528, float, SHADER_CONSTANT_330_X) +XE_GPU_REGISTER(0x4529, float, SHADER_CONSTANT_330_Y) +XE_GPU_REGISTER(0x452A, float, SHADER_CONSTANT_330_Z) +XE_GPU_REGISTER(0x452B, float, SHADER_CONSTANT_330_W) +XE_GPU_REGISTER(0x452C, float, SHADER_CONSTANT_331_X) +XE_GPU_REGISTER(0x452D, float, SHADER_CONSTANT_331_Y) +XE_GPU_REGISTER(0x452E, float, SHADER_CONSTANT_331_Z) +XE_GPU_REGISTER(0x452F, float, SHADER_CONSTANT_331_W) +XE_GPU_REGISTER(0x4530, float, SHADER_CONSTANT_332_X) +XE_GPU_REGISTER(0x4531, float, SHADER_CONSTANT_332_Y) +XE_GPU_REGISTER(0x4532, float, SHADER_CONSTANT_332_Z) +XE_GPU_REGISTER(0x4533, float, SHADER_CONSTANT_332_W) +XE_GPU_REGISTER(0x4534, float, SHADER_CONSTANT_333_X) +XE_GPU_REGISTER(0x4535, float, SHADER_CONSTANT_333_Y) +XE_GPU_REGISTER(0x4536, float, SHADER_CONSTANT_333_Z) +XE_GPU_REGISTER(0x4537, float, SHADER_CONSTANT_333_W) +XE_GPU_REGISTER(0x4538, float, SHADER_CONSTANT_334_X) +XE_GPU_REGISTER(0x4539, float, SHADER_CONSTANT_334_Y) +XE_GPU_REGISTER(0x453A, float, SHADER_CONSTANT_334_Z) +XE_GPU_REGISTER(0x453B, float, SHADER_CONSTANT_334_W) +XE_GPU_REGISTER(0x453C, float, SHADER_CONSTANT_335_X) +XE_GPU_REGISTER(0x453D, float, SHADER_CONSTANT_335_Y) +XE_GPU_REGISTER(0x453E, float, SHADER_CONSTANT_335_Z) +XE_GPU_REGISTER(0x453F, float, SHADER_CONSTANT_335_W) +XE_GPU_REGISTER(0x4540, float, SHADER_CONSTANT_336_X) +XE_GPU_REGISTER(0x4541, float, SHADER_CONSTANT_336_Y) +XE_GPU_REGISTER(0x4542, float, SHADER_CONSTANT_336_Z) +XE_GPU_REGISTER(0x4543, float, SHADER_CONSTANT_336_W) +XE_GPU_REGISTER(0x4544, float, SHADER_CONSTANT_337_X) +XE_GPU_REGISTER(0x4545, float, SHADER_CONSTANT_337_Y) +XE_GPU_REGISTER(0x4546, float, SHADER_CONSTANT_337_Z) +XE_GPU_REGISTER(0x4547, float, SHADER_CONSTANT_337_W) +XE_GPU_REGISTER(0x4548, float, SHADER_CONSTANT_338_X) +XE_GPU_REGISTER(0x4549, float, SHADER_CONSTANT_338_Y) +XE_GPU_REGISTER(0x454A, float, SHADER_CONSTANT_338_Z) +XE_GPU_REGISTER(0x454B, float, SHADER_CONSTANT_338_W) +XE_GPU_REGISTER(0x454C, float, SHADER_CONSTANT_339_X) +XE_GPU_REGISTER(0x454D, float, SHADER_CONSTANT_339_Y) +XE_GPU_REGISTER(0x454E, float, SHADER_CONSTANT_339_Z) +XE_GPU_REGISTER(0x454F, float, SHADER_CONSTANT_339_W) +XE_GPU_REGISTER(0x4550, float, SHADER_CONSTANT_340_X) +XE_GPU_REGISTER(0x4551, float, SHADER_CONSTANT_340_Y) +XE_GPU_REGISTER(0x4552, float, SHADER_CONSTANT_340_Z) +XE_GPU_REGISTER(0x4553, float, SHADER_CONSTANT_340_W) +XE_GPU_REGISTER(0x4554, float, SHADER_CONSTANT_341_X) +XE_GPU_REGISTER(0x4555, float, SHADER_CONSTANT_341_Y) +XE_GPU_REGISTER(0x4556, float, SHADER_CONSTANT_341_Z) +XE_GPU_REGISTER(0x4557, float, SHADER_CONSTANT_341_W) +XE_GPU_REGISTER(0x4558, float, SHADER_CONSTANT_342_X) +XE_GPU_REGISTER(0x4559, float, SHADER_CONSTANT_342_Y) +XE_GPU_REGISTER(0x455A, float, SHADER_CONSTANT_342_Z) +XE_GPU_REGISTER(0x455B, float, SHADER_CONSTANT_342_W) +XE_GPU_REGISTER(0x455C, float, SHADER_CONSTANT_343_X) +XE_GPU_REGISTER(0x455D, float, SHADER_CONSTANT_343_Y) +XE_GPU_REGISTER(0x455E, float, SHADER_CONSTANT_343_Z) +XE_GPU_REGISTER(0x455F, float, SHADER_CONSTANT_343_W) +XE_GPU_REGISTER(0x4560, float, SHADER_CONSTANT_344_X) +XE_GPU_REGISTER(0x4561, float, SHADER_CONSTANT_344_Y) +XE_GPU_REGISTER(0x4562, float, SHADER_CONSTANT_344_Z) +XE_GPU_REGISTER(0x4563, float, SHADER_CONSTANT_344_W) +XE_GPU_REGISTER(0x4564, float, SHADER_CONSTANT_345_X) +XE_GPU_REGISTER(0x4565, float, SHADER_CONSTANT_345_Y) +XE_GPU_REGISTER(0x4566, float, SHADER_CONSTANT_345_Z) +XE_GPU_REGISTER(0x4567, float, SHADER_CONSTANT_345_W) +XE_GPU_REGISTER(0x4568, float, SHADER_CONSTANT_346_X) +XE_GPU_REGISTER(0x4569, float, SHADER_CONSTANT_346_Y) +XE_GPU_REGISTER(0x456A, float, SHADER_CONSTANT_346_Z) +XE_GPU_REGISTER(0x456B, float, SHADER_CONSTANT_346_W) +XE_GPU_REGISTER(0x456C, float, SHADER_CONSTANT_347_X) +XE_GPU_REGISTER(0x456D, float, SHADER_CONSTANT_347_Y) +XE_GPU_REGISTER(0x456E, float, SHADER_CONSTANT_347_Z) +XE_GPU_REGISTER(0x456F, float, SHADER_CONSTANT_347_W) +XE_GPU_REGISTER(0x4570, float, SHADER_CONSTANT_348_X) +XE_GPU_REGISTER(0x4571, float, SHADER_CONSTANT_348_Y) +XE_GPU_REGISTER(0x4572, float, SHADER_CONSTANT_348_Z) +XE_GPU_REGISTER(0x4573, float, SHADER_CONSTANT_348_W) +XE_GPU_REGISTER(0x4574, float, SHADER_CONSTANT_349_X) +XE_GPU_REGISTER(0x4575, float, SHADER_CONSTANT_349_Y) +XE_GPU_REGISTER(0x4576, float, SHADER_CONSTANT_349_Z) +XE_GPU_REGISTER(0x4577, float, SHADER_CONSTANT_349_W) +XE_GPU_REGISTER(0x4578, float, SHADER_CONSTANT_350_X) +XE_GPU_REGISTER(0x4579, float, SHADER_CONSTANT_350_Y) +XE_GPU_REGISTER(0x457A, float, SHADER_CONSTANT_350_Z) +XE_GPU_REGISTER(0x457B, float, SHADER_CONSTANT_350_W) +XE_GPU_REGISTER(0x457C, float, SHADER_CONSTANT_351_X) +XE_GPU_REGISTER(0x457D, float, SHADER_CONSTANT_351_Y) +XE_GPU_REGISTER(0x457E, float, SHADER_CONSTANT_351_Z) +XE_GPU_REGISTER(0x457F, float, SHADER_CONSTANT_351_W) +XE_GPU_REGISTER(0x4580, float, SHADER_CONSTANT_352_X) +XE_GPU_REGISTER(0x4581, float, SHADER_CONSTANT_352_Y) +XE_GPU_REGISTER(0x4582, float, SHADER_CONSTANT_352_Z) +XE_GPU_REGISTER(0x4583, float, SHADER_CONSTANT_352_W) +XE_GPU_REGISTER(0x4584, float, SHADER_CONSTANT_353_X) +XE_GPU_REGISTER(0x4585, float, SHADER_CONSTANT_353_Y) +XE_GPU_REGISTER(0x4586, float, SHADER_CONSTANT_353_Z) +XE_GPU_REGISTER(0x4587, float, SHADER_CONSTANT_353_W) +XE_GPU_REGISTER(0x4588, float, SHADER_CONSTANT_354_X) +XE_GPU_REGISTER(0x4589, float, SHADER_CONSTANT_354_Y) +XE_GPU_REGISTER(0x458A, float, SHADER_CONSTANT_354_Z) +XE_GPU_REGISTER(0x458B, float, SHADER_CONSTANT_354_W) +XE_GPU_REGISTER(0x458C, float, SHADER_CONSTANT_355_X) +XE_GPU_REGISTER(0x458D, float, SHADER_CONSTANT_355_Y) +XE_GPU_REGISTER(0x458E, float, SHADER_CONSTANT_355_Z) +XE_GPU_REGISTER(0x458F, float, SHADER_CONSTANT_355_W) +XE_GPU_REGISTER(0x4590, float, SHADER_CONSTANT_356_X) +XE_GPU_REGISTER(0x4591, float, SHADER_CONSTANT_356_Y) +XE_GPU_REGISTER(0x4592, float, SHADER_CONSTANT_356_Z) +XE_GPU_REGISTER(0x4593, float, SHADER_CONSTANT_356_W) +XE_GPU_REGISTER(0x4594, float, SHADER_CONSTANT_357_X) +XE_GPU_REGISTER(0x4595, float, SHADER_CONSTANT_357_Y) +XE_GPU_REGISTER(0x4596, float, SHADER_CONSTANT_357_Z) +XE_GPU_REGISTER(0x4597, float, SHADER_CONSTANT_357_W) +XE_GPU_REGISTER(0x4598, float, SHADER_CONSTANT_358_X) +XE_GPU_REGISTER(0x4599, float, SHADER_CONSTANT_358_Y) +XE_GPU_REGISTER(0x459A, float, SHADER_CONSTANT_358_Z) +XE_GPU_REGISTER(0x459B, float, SHADER_CONSTANT_358_W) +XE_GPU_REGISTER(0x459C, float, SHADER_CONSTANT_359_X) +XE_GPU_REGISTER(0x459D, float, SHADER_CONSTANT_359_Y) +XE_GPU_REGISTER(0x459E, float, SHADER_CONSTANT_359_Z) +XE_GPU_REGISTER(0x459F, float, SHADER_CONSTANT_359_W) +XE_GPU_REGISTER(0x45A0, float, SHADER_CONSTANT_360_X) +XE_GPU_REGISTER(0x45A1, float, SHADER_CONSTANT_360_Y) +XE_GPU_REGISTER(0x45A2, float, SHADER_CONSTANT_360_Z) +XE_GPU_REGISTER(0x45A3, float, SHADER_CONSTANT_360_W) +XE_GPU_REGISTER(0x45A4, float, SHADER_CONSTANT_361_X) +XE_GPU_REGISTER(0x45A5, float, SHADER_CONSTANT_361_Y) +XE_GPU_REGISTER(0x45A6, float, SHADER_CONSTANT_361_Z) +XE_GPU_REGISTER(0x45A7, float, SHADER_CONSTANT_361_W) +XE_GPU_REGISTER(0x45A8, float, SHADER_CONSTANT_362_X) +XE_GPU_REGISTER(0x45A9, float, SHADER_CONSTANT_362_Y) +XE_GPU_REGISTER(0x45AA, float, SHADER_CONSTANT_362_Z) +XE_GPU_REGISTER(0x45AB, float, SHADER_CONSTANT_362_W) +XE_GPU_REGISTER(0x45AC, float, SHADER_CONSTANT_363_X) +XE_GPU_REGISTER(0x45AD, float, SHADER_CONSTANT_363_Y) +XE_GPU_REGISTER(0x45AE, float, SHADER_CONSTANT_363_Z) +XE_GPU_REGISTER(0x45AF, float, SHADER_CONSTANT_363_W) +XE_GPU_REGISTER(0x45B0, float, SHADER_CONSTANT_364_X) +XE_GPU_REGISTER(0x45B1, float, SHADER_CONSTANT_364_Y) +XE_GPU_REGISTER(0x45B2, float, SHADER_CONSTANT_364_Z) +XE_GPU_REGISTER(0x45B3, float, SHADER_CONSTANT_364_W) +XE_GPU_REGISTER(0x45B4, float, SHADER_CONSTANT_365_X) +XE_GPU_REGISTER(0x45B5, float, SHADER_CONSTANT_365_Y) +XE_GPU_REGISTER(0x45B6, float, SHADER_CONSTANT_365_Z) +XE_GPU_REGISTER(0x45B7, float, SHADER_CONSTANT_365_W) +XE_GPU_REGISTER(0x45B8, float, SHADER_CONSTANT_366_X) +XE_GPU_REGISTER(0x45B9, float, SHADER_CONSTANT_366_Y) +XE_GPU_REGISTER(0x45BA, float, SHADER_CONSTANT_366_Z) +XE_GPU_REGISTER(0x45BB, float, SHADER_CONSTANT_366_W) +XE_GPU_REGISTER(0x45BC, float, SHADER_CONSTANT_367_X) +XE_GPU_REGISTER(0x45BD, float, SHADER_CONSTANT_367_Y) +XE_GPU_REGISTER(0x45BE, float, SHADER_CONSTANT_367_Z) +XE_GPU_REGISTER(0x45BF, float, SHADER_CONSTANT_367_W) +XE_GPU_REGISTER(0x45C0, float, SHADER_CONSTANT_368_X) +XE_GPU_REGISTER(0x45C1, float, SHADER_CONSTANT_368_Y) +XE_GPU_REGISTER(0x45C2, float, SHADER_CONSTANT_368_Z) +XE_GPU_REGISTER(0x45C3, float, SHADER_CONSTANT_368_W) +XE_GPU_REGISTER(0x45C4, float, SHADER_CONSTANT_369_X) +XE_GPU_REGISTER(0x45C5, float, SHADER_CONSTANT_369_Y) +XE_GPU_REGISTER(0x45C6, float, SHADER_CONSTANT_369_Z) +XE_GPU_REGISTER(0x45C7, float, SHADER_CONSTANT_369_W) +XE_GPU_REGISTER(0x45C8, float, SHADER_CONSTANT_370_X) +XE_GPU_REGISTER(0x45C9, float, SHADER_CONSTANT_370_Y) +XE_GPU_REGISTER(0x45CA, float, SHADER_CONSTANT_370_Z) +XE_GPU_REGISTER(0x45CB, float, SHADER_CONSTANT_370_W) +XE_GPU_REGISTER(0x45CC, float, SHADER_CONSTANT_371_X) +XE_GPU_REGISTER(0x45CD, float, SHADER_CONSTANT_371_Y) +XE_GPU_REGISTER(0x45CE, float, SHADER_CONSTANT_371_Z) +XE_GPU_REGISTER(0x45CF, float, SHADER_CONSTANT_371_W) +XE_GPU_REGISTER(0x45D0, float, SHADER_CONSTANT_372_X) +XE_GPU_REGISTER(0x45D1, float, SHADER_CONSTANT_372_Y) +XE_GPU_REGISTER(0x45D2, float, SHADER_CONSTANT_372_Z) +XE_GPU_REGISTER(0x45D3, float, SHADER_CONSTANT_372_W) +XE_GPU_REGISTER(0x45D4, float, SHADER_CONSTANT_373_X) +XE_GPU_REGISTER(0x45D5, float, SHADER_CONSTANT_373_Y) +XE_GPU_REGISTER(0x45D6, float, SHADER_CONSTANT_373_Z) +XE_GPU_REGISTER(0x45D7, float, SHADER_CONSTANT_373_W) +XE_GPU_REGISTER(0x45D8, float, SHADER_CONSTANT_374_X) +XE_GPU_REGISTER(0x45D9, float, SHADER_CONSTANT_374_Y) +XE_GPU_REGISTER(0x45DA, float, SHADER_CONSTANT_374_Z) +XE_GPU_REGISTER(0x45DB, float, SHADER_CONSTANT_374_W) +XE_GPU_REGISTER(0x45DC, float, SHADER_CONSTANT_375_X) +XE_GPU_REGISTER(0x45DD, float, SHADER_CONSTANT_375_Y) +XE_GPU_REGISTER(0x45DE, float, SHADER_CONSTANT_375_Z) +XE_GPU_REGISTER(0x45DF, float, SHADER_CONSTANT_375_W) +XE_GPU_REGISTER(0x45E0, float, SHADER_CONSTANT_376_X) +XE_GPU_REGISTER(0x45E1, float, SHADER_CONSTANT_376_Y) +XE_GPU_REGISTER(0x45E2, float, SHADER_CONSTANT_376_Z) +XE_GPU_REGISTER(0x45E3, float, SHADER_CONSTANT_376_W) +XE_GPU_REGISTER(0x45E4, float, SHADER_CONSTANT_377_X) +XE_GPU_REGISTER(0x45E5, float, SHADER_CONSTANT_377_Y) +XE_GPU_REGISTER(0x45E6, float, SHADER_CONSTANT_377_Z) +XE_GPU_REGISTER(0x45E7, float, SHADER_CONSTANT_377_W) +XE_GPU_REGISTER(0x45E8, float, SHADER_CONSTANT_378_X) +XE_GPU_REGISTER(0x45E9, float, SHADER_CONSTANT_378_Y) +XE_GPU_REGISTER(0x45EA, float, SHADER_CONSTANT_378_Z) +XE_GPU_REGISTER(0x45EB, float, SHADER_CONSTANT_378_W) +XE_GPU_REGISTER(0x45EC, float, SHADER_CONSTANT_379_X) +XE_GPU_REGISTER(0x45ED, float, SHADER_CONSTANT_379_Y) +XE_GPU_REGISTER(0x45EE, float, SHADER_CONSTANT_379_Z) +XE_GPU_REGISTER(0x45EF, float, SHADER_CONSTANT_379_W) +XE_GPU_REGISTER(0x45F0, float, SHADER_CONSTANT_380_X) +XE_GPU_REGISTER(0x45F1, float, SHADER_CONSTANT_380_Y) +XE_GPU_REGISTER(0x45F2, float, SHADER_CONSTANT_380_Z) +XE_GPU_REGISTER(0x45F3, float, SHADER_CONSTANT_380_W) +XE_GPU_REGISTER(0x45F4, float, SHADER_CONSTANT_381_X) +XE_GPU_REGISTER(0x45F5, float, SHADER_CONSTANT_381_Y) +XE_GPU_REGISTER(0x45F6, float, SHADER_CONSTANT_381_Z) +XE_GPU_REGISTER(0x45F7, float, SHADER_CONSTANT_381_W) +XE_GPU_REGISTER(0x45F8, float, SHADER_CONSTANT_382_X) +XE_GPU_REGISTER(0x45F9, float, SHADER_CONSTANT_382_Y) +XE_GPU_REGISTER(0x45FA, float, SHADER_CONSTANT_382_Z) +XE_GPU_REGISTER(0x45FB, float, SHADER_CONSTANT_382_W) +XE_GPU_REGISTER(0x45FC, float, SHADER_CONSTANT_383_X) +XE_GPU_REGISTER(0x45FD, float, SHADER_CONSTANT_383_Y) +XE_GPU_REGISTER(0x45FE, float, SHADER_CONSTANT_383_Z) +XE_GPU_REGISTER(0x45FF, float, SHADER_CONSTANT_383_W) +XE_GPU_REGISTER(0x4600, float, SHADER_CONSTANT_384_X) +XE_GPU_REGISTER(0x4601, float, SHADER_CONSTANT_384_Y) +XE_GPU_REGISTER(0x4602, float, SHADER_CONSTANT_384_Z) +XE_GPU_REGISTER(0x4603, float, SHADER_CONSTANT_384_W) +XE_GPU_REGISTER(0x4604, float, SHADER_CONSTANT_385_X) +XE_GPU_REGISTER(0x4605, float, SHADER_CONSTANT_385_Y) +XE_GPU_REGISTER(0x4606, float, SHADER_CONSTANT_385_Z) +XE_GPU_REGISTER(0x4607, float, SHADER_CONSTANT_385_W) +XE_GPU_REGISTER(0x4608, float, SHADER_CONSTANT_386_X) +XE_GPU_REGISTER(0x4609, float, SHADER_CONSTANT_386_Y) +XE_GPU_REGISTER(0x460A, float, SHADER_CONSTANT_386_Z) +XE_GPU_REGISTER(0x460B, float, SHADER_CONSTANT_386_W) +XE_GPU_REGISTER(0x460C, float, SHADER_CONSTANT_387_X) +XE_GPU_REGISTER(0x460D, float, SHADER_CONSTANT_387_Y) +XE_GPU_REGISTER(0x460E, float, SHADER_CONSTANT_387_Z) +XE_GPU_REGISTER(0x460F, float, SHADER_CONSTANT_387_W) +XE_GPU_REGISTER(0x4610, float, SHADER_CONSTANT_388_X) +XE_GPU_REGISTER(0x4611, float, SHADER_CONSTANT_388_Y) +XE_GPU_REGISTER(0x4612, float, SHADER_CONSTANT_388_Z) +XE_GPU_REGISTER(0x4613, float, SHADER_CONSTANT_388_W) +XE_GPU_REGISTER(0x4614, float, SHADER_CONSTANT_389_X) +XE_GPU_REGISTER(0x4615, float, SHADER_CONSTANT_389_Y) +XE_GPU_REGISTER(0x4616, float, SHADER_CONSTANT_389_Z) +XE_GPU_REGISTER(0x4617, float, SHADER_CONSTANT_389_W) +XE_GPU_REGISTER(0x4618, float, SHADER_CONSTANT_390_X) +XE_GPU_REGISTER(0x4619, float, SHADER_CONSTANT_390_Y) +XE_GPU_REGISTER(0x461A, float, SHADER_CONSTANT_390_Z) +XE_GPU_REGISTER(0x461B, float, SHADER_CONSTANT_390_W) +XE_GPU_REGISTER(0x461C, float, SHADER_CONSTANT_391_X) +XE_GPU_REGISTER(0x461D, float, SHADER_CONSTANT_391_Y) +XE_GPU_REGISTER(0x461E, float, SHADER_CONSTANT_391_Z) +XE_GPU_REGISTER(0x461F, float, SHADER_CONSTANT_391_W) +XE_GPU_REGISTER(0x4620, float, SHADER_CONSTANT_392_X) +XE_GPU_REGISTER(0x4621, float, SHADER_CONSTANT_392_Y) +XE_GPU_REGISTER(0x4622, float, SHADER_CONSTANT_392_Z) +XE_GPU_REGISTER(0x4623, float, SHADER_CONSTANT_392_W) +XE_GPU_REGISTER(0x4624, float, SHADER_CONSTANT_393_X) +XE_GPU_REGISTER(0x4625, float, SHADER_CONSTANT_393_Y) +XE_GPU_REGISTER(0x4626, float, SHADER_CONSTANT_393_Z) +XE_GPU_REGISTER(0x4627, float, SHADER_CONSTANT_393_W) +XE_GPU_REGISTER(0x4628, float, SHADER_CONSTANT_394_X) +XE_GPU_REGISTER(0x4629, float, SHADER_CONSTANT_394_Y) +XE_GPU_REGISTER(0x462A, float, SHADER_CONSTANT_394_Z) +XE_GPU_REGISTER(0x462B, float, SHADER_CONSTANT_394_W) +XE_GPU_REGISTER(0x462C, float, SHADER_CONSTANT_395_X) +XE_GPU_REGISTER(0x462D, float, SHADER_CONSTANT_395_Y) +XE_GPU_REGISTER(0x462E, float, SHADER_CONSTANT_395_Z) +XE_GPU_REGISTER(0x462F, float, SHADER_CONSTANT_395_W) +XE_GPU_REGISTER(0x4630, float, SHADER_CONSTANT_396_X) +XE_GPU_REGISTER(0x4631, float, SHADER_CONSTANT_396_Y) +XE_GPU_REGISTER(0x4632, float, SHADER_CONSTANT_396_Z) +XE_GPU_REGISTER(0x4633, float, SHADER_CONSTANT_396_W) +XE_GPU_REGISTER(0x4634, float, SHADER_CONSTANT_397_X) +XE_GPU_REGISTER(0x4635, float, SHADER_CONSTANT_397_Y) +XE_GPU_REGISTER(0x4636, float, SHADER_CONSTANT_397_Z) +XE_GPU_REGISTER(0x4637, float, SHADER_CONSTANT_397_W) +XE_GPU_REGISTER(0x4638, float, SHADER_CONSTANT_398_X) +XE_GPU_REGISTER(0x4639, float, SHADER_CONSTANT_398_Y) +XE_GPU_REGISTER(0x463A, float, SHADER_CONSTANT_398_Z) +XE_GPU_REGISTER(0x463B, float, SHADER_CONSTANT_398_W) +XE_GPU_REGISTER(0x463C, float, SHADER_CONSTANT_399_X) +XE_GPU_REGISTER(0x463D, float, SHADER_CONSTANT_399_Y) +XE_GPU_REGISTER(0x463E, float, SHADER_CONSTANT_399_Z) +XE_GPU_REGISTER(0x463F, float, SHADER_CONSTANT_399_W) +XE_GPU_REGISTER(0x4640, float, SHADER_CONSTANT_400_X) +XE_GPU_REGISTER(0x4641, float, SHADER_CONSTANT_400_Y) +XE_GPU_REGISTER(0x4642, float, SHADER_CONSTANT_400_Z) +XE_GPU_REGISTER(0x4643, float, SHADER_CONSTANT_400_W) +XE_GPU_REGISTER(0x4644, float, SHADER_CONSTANT_401_X) +XE_GPU_REGISTER(0x4645, float, SHADER_CONSTANT_401_Y) +XE_GPU_REGISTER(0x4646, float, SHADER_CONSTANT_401_Z) +XE_GPU_REGISTER(0x4647, float, SHADER_CONSTANT_401_W) +XE_GPU_REGISTER(0x4648, float, SHADER_CONSTANT_402_X) +XE_GPU_REGISTER(0x4649, float, SHADER_CONSTANT_402_Y) +XE_GPU_REGISTER(0x464A, float, SHADER_CONSTANT_402_Z) +XE_GPU_REGISTER(0x464B, float, SHADER_CONSTANT_402_W) +XE_GPU_REGISTER(0x464C, float, SHADER_CONSTANT_403_X) +XE_GPU_REGISTER(0x464D, float, SHADER_CONSTANT_403_Y) +XE_GPU_REGISTER(0x464E, float, SHADER_CONSTANT_403_Z) +XE_GPU_REGISTER(0x464F, float, SHADER_CONSTANT_403_W) +XE_GPU_REGISTER(0x4650, float, SHADER_CONSTANT_404_X) +XE_GPU_REGISTER(0x4651, float, SHADER_CONSTANT_404_Y) +XE_GPU_REGISTER(0x4652, float, SHADER_CONSTANT_404_Z) +XE_GPU_REGISTER(0x4653, float, SHADER_CONSTANT_404_W) +XE_GPU_REGISTER(0x4654, float, SHADER_CONSTANT_405_X) +XE_GPU_REGISTER(0x4655, float, SHADER_CONSTANT_405_Y) +XE_GPU_REGISTER(0x4656, float, SHADER_CONSTANT_405_Z) +XE_GPU_REGISTER(0x4657, float, SHADER_CONSTANT_405_W) +XE_GPU_REGISTER(0x4658, float, SHADER_CONSTANT_406_X) +XE_GPU_REGISTER(0x4659, float, SHADER_CONSTANT_406_Y) +XE_GPU_REGISTER(0x465A, float, SHADER_CONSTANT_406_Z) +XE_GPU_REGISTER(0x465B, float, SHADER_CONSTANT_406_W) +XE_GPU_REGISTER(0x465C, float, SHADER_CONSTANT_407_X) +XE_GPU_REGISTER(0x465D, float, SHADER_CONSTANT_407_Y) +XE_GPU_REGISTER(0x465E, float, SHADER_CONSTANT_407_Z) +XE_GPU_REGISTER(0x465F, float, SHADER_CONSTANT_407_W) +XE_GPU_REGISTER(0x4660, float, SHADER_CONSTANT_408_X) +XE_GPU_REGISTER(0x4661, float, SHADER_CONSTANT_408_Y) +XE_GPU_REGISTER(0x4662, float, SHADER_CONSTANT_408_Z) +XE_GPU_REGISTER(0x4663, float, SHADER_CONSTANT_408_W) +XE_GPU_REGISTER(0x4664, float, SHADER_CONSTANT_409_X) +XE_GPU_REGISTER(0x4665, float, SHADER_CONSTANT_409_Y) +XE_GPU_REGISTER(0x4666, float, SHADER_CONSTANT_409_Z) +XE_GPU_REGISTER(0x4667, float, SHADER_CONSTANT_409_W) +XE_GPU_REGISTER(0x4668, float, SHADER_CONSTANT_410_X) +XE_GPU_REGISTER(0x4669, float, SHADER_CONSTANT_410_Y) +XE_GPU_REGISTER(0x466A, float, SHADER_CONSTANT_410_Z) +XE_GPU_REGISTER(0x466B, float, SHADER_CONSTANT_410_W) +XE_GPU_REGISTER(0x466C, float, SHADER_CONSTANT_411_X) +XE_GPU_REGISTER(0x466D, float, SHADER_CONSTANT_411_Y) +XE_GPU_REGISTER(0x466E, float, SHADER_CONSTANT_411_Z) +XE_GPU_REGISTER(0x466F, float, SHADER_CONSTANT_411_W) +XE_GPU_REGISTER(0x4670, float, SHADER_CONSTANT_412_X) +XE_GPU_REGISTER(0x4671, float, SHADER_CONSTANT_412_Y) +XE_GPU_REGISTER(0x4672, float, SHADER_CONSTANT_412_Z) +XE_GPU_REGISTER(0x4673, float, SHADER_CONSTANT_412_W) +XE_GPU_REGISTER(0x4674, float, SHADER_CONSTANT_413_X) +XE_GPU_REGISTER(0x4675, float, SHADER_CONSTANT_413_Y) +XE_GPU_REGISTER(0x4676, float, SHADER_CONSTANT_413_Z) +XE_GPU_REGISTER(0x4677, float, SHADER_CONSTANT_413_W) +XE_GPU_REGISTER(0x4678, float, SHADER_CONSTANT_414_X) +XE_GPU_REGISTER(0x4679, float, SHADER_CONSTANT_414_Y) +XE_GPU_REGISTER(0x467A, float, SHADER_CONSTANT_414_Z) +XE_GPU_REGISTER(0x467B, float, SHADER_CONSTANT_414_W) +XE_GPU_REGISTER(0x467C, float, SHADER_CONSTANT_415_X) +XE_GPU_REGISTER(0x467D, float, SHADER_CONSTANT_415_Y) +XE_GPU_REGISTER(0x467E, float, SHADER_CONSTANT_415_Z) +XE_GPU_REGISTER(0x467F, float, SHADER_CONSTANT_415_W) +XE_GPU_REGISTER(0x4680, float, SHADER_CONSTANT_416_X) +XE_GPU_REGISTER(0x4681, float, SHADER_CONSTANT_416_Y) +XE_GPU_REGISTER(0x4682, float, SHADER_CONSTANT_416_Z) +XE_GPU_REGISTER(0x4683, float, SHADER_CONSTANT_416_W) +XE_GPU_REGISTER(0x4684, float, SHADER_CONSTANT_417_X) +XE_GPU_REGISTER(0x4685, float, SHADER_CONSTANT_417_Y) +XE_GPU_REGISTER(0x4686, float, SHADER_CONSTANT_417_Z) +XE_GPU_REGISTER(0x4687, float, SHADER_CONSTANT_417_W) +XE_GPU_REGISTER(0x4688, float, SHADER_CONSTANT_418_X) +XE_GPU_REGISTER(0x4689, float, SHADER_CONSTANT_418_Y) +XE_GPU_REGISTER(0x468A, float, SHADER_CONSTANT_418_Z) +XE_GPU_REGISTER(0x468B, float, SHADER_CONSTANT_418_W) +XE_GPU_REGISTER(0x468C, float, SHADER_CONSTANT_419_X) +XE_GPU_REGISTER(0x468D, float, SHADER_CONSTANT_419_Y) +XE_GPU_REGISTER(0x468E, float, SHADER_CONSTANT_419_Z) +XE_GPU_REGISTER(0x468F, float, SHADER_CONSTANT_419_W) +XE_GPU_REGISTER(0x4690, float, SHADER_CONSTANT_420_X) +XE_GPU_REGISTER(0x4691, float, SHADER_CONSTANT_420_Y) +XE_GPU_REGISTER(0x4692, float, SHADER_CONSTANT_420_Z) +XE_GPU_REGISTER(0x4693, float, SHADER_CONSTANT_420_W) +XE_GPU_REGISTER(0x4694, float, SHADER_CONSTANT_421_X) +XE_GPU_REGISTER(0x4695, float, SHADER_CONSTANT_421_Y) +XE_GPU_REGISTER(0x4696, float, SHADER_CONSTANT_421_Z) +XE_GPU_REGISTER(0x4697, float, SHADER_CONSTANT_421_W) +XE_GPU_REGISTER(0x4698, float, SHADER_CONSTANT_422_X) +XE_GPU_REGISTER(0x4699, float, SHADER_CONSTANT_422_Y) +XE_GPU_REGISTER(0x469A, float, SHADER_CONSTANT_422_Z) +XE_GPU_REGISTER(0x469B, float, SHADER_CONSTANT_422_W) +XE_GPU_REGISTER(0x469C, float, SHADER_CONSTANT_423_X) +XE_GPU_REGISTER(0x469D, float, SHADER_CONSTANT_423_Y) +XE_GPU_REGISTER(0x469E, float, SHADER_CONSTANT_423_Z) +XE_GPU_REGISTER(0x469F, float, SHADER_CONSTANT_423_W) +XE_GPU_REGISTER(0x46A0, float, SHADER_CONSTANT_424_X) +XE_GPU_REGISTER(0x46A1, float, SHADER_CONSTANT_424_Y) +XE_GPU_REGISTER(0x46A2, float, SHADER_CONSTANT_424_Z) +XE_GPU_REGISTER(0x46A3, float, SHADER_CONSTANT_424_W) +XE_GPU_REGISTER(0x46A4, float, SHADER_CONSTANT_425_X) +XE_GPU_REGISTER(0x46A5, float, SHADER_CONSTANT_425_Y) +XE_GPU_REGISTER(0x46A6, float, SHADER_CONSTANT_425_Z) +XE_GPU_REGISTER(0x46A7, float, SHADER_CONSTANT_425_W) +XE_GPU_REGISTER(0x46A8, float, SHADER_CONSTANT_426_X) +XE_GPU_REGISTER(0x46A9, float, SHADER_CONSTANT_426_Y) +XE_GPU_REGISTER(0x46AA, float, SHADER_CONSTANT_426_Z) +XE_GPU_REGISTER(0x46AB, float, SHADER_CONSTANT_426_W) +XE_GPU_REGISTER(0x46AC, float, SHADER_CONSTANT_427_X) +XE_GPU_REGISTER(0x46AD, float, SHADER_CONSTANT_427_Y) +XE_GPU_REGISTER(0x46AE, float, SHADER_CONSTANT_427_Z) +XE_GPU_REGISTER(0x46AF, float, SHADER_CONSTANT_427_W) +XE_GPU_REGISTER(0x46B0, float, SHADER_CONSTANT_428_X) +XE_GPU_REGISTER(0x46B1, float, SHADER_CONSTANT_428_Y) +XE_GPU_REGISTER(0x46B2, float, SHADER_CONSTANT_428_Z) +XE_GPU_REGISTER(0x46B3, float, SHADER_CONSTANT_428_W) +XE_GPU_REGISTER(0x46B4, float, SHADER_CONSTANT_429_X) +XE_GPU_REGISTER(0x46B5, float, SHADER_CONSTANT_429_Y) +XE_GPU_REGISTER(0x46B6, float, SHADER_CONSTANT_429_Z) +XE_GPU_REGISTER(0x46B7, float, SHADER_CONSTANT_429_W) +XE_GPU_REGISTER(0x46B8, float, SHADER_CONSTANT_430_X) +XE_GPU_REGISTER(0x46B9, float, SHADER_CONSTANT_430_Y) +XE_GPU_REGISTER(0x46BA, float, SHADER_CONSTANT_430_Z) +XE_GPU_REGISTER(0x46BB, float, SHADER_CONSTANT_430_W) +XE_GPU_REGISTER(0x46BC, float, SHADER_CONSTANT_431_X) +XE_GPU_REGISTER(0x46BD, float, SHADER_CONSTANT_431_Y) +XE_GPU_REGISTER(0x46BE, float, SHADER_CONSTANT_431_Z) +XE_GPU_REGISTER(0x46BF, float, SHADER_CONSTANT_431_W) +XE_GPU_REGISTER(0x46C0, float, SHADER_CONSTANT_432_X) +XE_GPU_REGISTER(0x46C1, float, SHADER_CONSTANT_432_Y) +XE_GPU_REGISTER(0x46C2, float, SHADER_CONSTANT_432_Z) +XE_GPU_REGISTER(0x46C3, float, SHADER_CONSTANT_432_W) +XE_GPU_REGISTER(0x46C4, float, SHADER_CONSTANT_433_X) +XE_GPU_REGISTER(0x46C5, float, SHADER_CONSTANT_433_Y) +XE_GPU_REGISTER(0x46C6, float, SHADER_CONSTANT_433_Z) +XE_GPU_REGISTER(0x46C7, float, SHADER_CONSTANT_433_W) +XE_GPU_REGISTER(0x46C8, float, SHADER_CONSTANT_434_X) +XE_GPU_REGISTER(0x46C9, float, SHADER_CONSTANT_434_Y) +XE_GPU_REGISTER(0x46CA, float, SHADER_CONSTANT_434_Z) +XE_GPU_REGISTER(0x46CB, float, SHADER_CONSTANT_434_W) +XE_GPU_REGISTER(0x46CC, float, SHADER_CONSTANT_435_X) +XE_GPU_REGISTER(0x46CD, float, SHADER_CONSTANT_435_Y) +XE_GPU_REGISTER(0x46CE, float, SHADER_CONSTANT_435_Z) +XE_GPU_REGISTER(0x46CF, float, SHADER_CONSTANT_435_W) +XE_GPU_REGISTER(0x46D0, float, SHADER_CONSTANT_436_X) +XE_GPU_REGISTER(0x46D1, float, SHADER_CONSTANT_436_Y) +XE_GPU_REGISTER(0x46D2, float, SHADER_CONSTANT_436_Z) +XE_GPU_REGISTER(0x46D3, float, SHADER_CONSTANT_436_W) +XE_GPU_REGISTER(0x46D4, float, SHADER_CONSTANT_437_X) +XE_GPU_REGISTER(0x46D5, float, SHADER_CONSTANT_437_Y) +XE_GPU_REGISTER(0x46D6, float, SHADER_CONSTANT_437_Z) +XE_GPU_REGISTER(0x46D7, float, SHADER_CONSTANT_437_W) +XE_GPU_REGISTER(0x46D8, float, SHADER_CONSTANT_438_X) +XE_GPU_REGISTER(0x46D9, float, SHADER_CONSTANT_438_Y) +XE_GPU_REGISTER(0x46DA, float, SHADER_CONSTANT_438_Z) +XE_GPU_REGISTER(0x46DB, float, SHADER_CONSTANT_438_W) +XE_GPU_REGISTER(0x46DC, float, SHADER_CONSTANT_439_X) +XE_GPU_REGISTER(0x46DD, float, SHADER_CONSTANT_439_Y) +XE_GPU_REGISTER(0x46DE, float, SHADER_CONSTANT_439_Z) +XE_GPU_REGISTER(0x46DF, float, SHADER_CONSTANT_439_W) +XE_GPU_REGISTER(0x46E0, float, SHADER_CONSTANT_440_X) +XE_GPU_REGISTER(0x46E1, float, SHADER_CONSTANT_440_Y) +XE_GPU_REGISTER(0x46E2, float, SHADER_CONSTANT_440_Z) +XE_GPU_REGISTER(0x46E3, float, SHADER_CONSTANT_440_W) +XE_GPU_REGISTER(0x46E4, float, SHADER_CONSTANT_441_X) +XE_GPU_REGISTER(0x46E5, float, SHADER_CONSTANT_441_Y) +XE_GPU_REGISTER(0x46E6, float, SHADER_CONSTANT_441_Z) +XE_GPU_REGISTER(0x46E7, float, SHADER_CONSTANT_441_W) +XE_GPU_REGISTER(0x46E8, float, SHADER_CONSTANT_442_X) +XE_GPU_REGISTER(0x46E9, float, SHADER_CONSTANT_442_Y) +XE_GPU_REGISTER(0x46EA, float, SHADER_CONSTANT_442_Z) +XE_GPU_REGISTER(0x46EB, float, SHADER_CONSTANT_442_W) +XE_GPU_REGISTER(0x46EC, float, SHADER_CONSTANT_443_X) +XE_GPU_REGISTER(0x46ED, float, SHADER_CONSTANT_443_Y) +XE_GPU_REGISTER(0x46EE, float, SHADER_CONSTANT_443_Z) +XE_GPU_REGISTER(0x46EF, float, SHADER_CONSTANT_443_W) +XE_GPU_REGISTER(0x46F0, float, SHADER_CONSTANT_444_X) +XE_GPU_REGISTER(0x46F1, float, SHADER_CONSTANT_444_Y) +XE_GPU_REGISTER(0x46F2, float, SHADER_CONSTANT_444_Z) +XE_GPU_REGISTER(0x46F3, float, SHADER_CONSTANT_444_W) +XE_GPU_REGISTER(0x46F4, float, SHADER_CONSTANT_445_X) +XE_GPU_REGISTER(0x46F5, float, SHADER_CONSTANT_445_Y) +XE_GPU_REGISTER(0x46F6, float, SHADER_CONSTANT_445_Z) +XE_GPU_REGISTER(0x46F7, float, SHADER_CONSTANT_445_W) +XE_GPU_REGISTER(0x46F8, float, SHADER_CONSTANT_446_X) +XE_GPU_REGISTER(0x46F9, float, SHADER_CONSTANT_446_Y) +XE_GPU_REGISTER(0x46FA, float, SHADER_CONSTANT_446_Z) +XE_GPU_REGISTER(0x46FB, float, SHADER_CONSTANT_446_W) +XE_GPU_REGISTER(0x46FC, float, SHADER_CONSTANT_447_X) +XE_GPU_REGISTER(0x46FD, float, SHADER_CONSTANT_447_Y) +XE_GPU_REGISTER(0x46FE, float, SHADER_CONSTANT_447_Z) +XE_GPU_REGISTER(0x46FF, float, SHADER_CONSTANT_447_W) +XE_GPU_REGISTER(0x4700, float, SHADER_CONSTANT_448_X) +XE_GPU_REGISTER(0x4701, float, SHADER_CONSTANT_448_Y) +XE_GPU_REGISTER(0x4702, float, SHADER_CONSTANT_448_Z) +XE_GPU_REGISTER(0x4703, float, SHADER_CONSTANT_448_W) +XE_GPU_REGISTER(0x4704, float, SHADER_CONSTANT_449_X) +XE_GPU_REGISTER(0x4705, float, SHADER_CONSTANT_449_Y) +XE_GPU_REGISTER(0x4706, float, SHADER_CONSTANT_449_Z) +XE_GPU_REGISTER(0x4707, float, SHADER_CONSTANT_449_W) +XE_GPU_REGISTER(0x4708, float, SHADER_CONSTANT_450_X) +XE_GPU_REGISTER(0x4709, float, SHADER_CONSTANT_450_Y) +XE_GPU_REGISTER(0x470A, float, SHADER_CONSTANT_450_Z) +XE_GPU_REGISTER(0x470B, float, SHADER_CONSTANT_450_W) +XE_GPU_REGISTER(0x470C, float, SHADER_CONSTANT_451_X) +XE_GPU_REGISTER(0x470D, float, SHADER_CONSTANT_451_Y) +XE_GPU_REGISTER(0x470E, float, SHADER_CONSTANT_451_Z) +XE_GPU_REGISTER(0x470F, float, SHADER_CONSTANT_451_W) +XE_GPU_REGISTER(0x4710, float, SHADER_CONSTANT_452_X) +XE_GPU_REGISTER(0x4711, float, SHADER_CONSTANT_452_Y) +XE_GPU_REGISTER(0x4712, float, SHADER_CONSTANT_452_Z) +XE_GPU_REGISTER(0x4713, float, SHADER_CONSTANT_452_W) +XE_GPU_REGISTER(0x4714, float, SHADER_CONSTANT_453_X) +XE_GPU_REGISTER(0x4715, float, SHADER_CONSTANT_453_Y) +XE_GPU_REGISTER(0x4716, float, SHADER_CONSTANT_453_Z) +XE_GPU_REGISTER(0x4717, float, SHADER_CONSTANT_453_W) +XE_GPU_REGISTER(0x4718, float, SHADER_CONSTANT_454_X) +XE_GPU_REGISTER(0x4719, float, SHADER_CONSTANT_454_Y) +XE_GPU_REGISTER(0x471A, float, SHADER_CONSTANT_454_Z) +XE_GPU_REGISTER(0x471B, float, SHADER_CONSTANT_454_W) +XE_GPU_REGISTER(0x471C, float, SHADER_CONSTANT_455_X) +XE_GPU_REGISTER(0x471D, float, SHADER_CONSTANT_455_Y) +XE_GPU_REGISTER(0x471E, float, SHADER_CONSTANT_455_Z) +XE_GPU_REGISTER(0x471F, float, SHADER_CONSTANT_455_W) +XE_GPU_REGISTER(0x4720, float, SHADER_CONSTANT_456_X) +XE_GPU_REGISTER(0x4721, float, SHADER_CONSTANT_456_Y) +XE_GPU_REGISTER(0x4722, float, SHADER_CONSTANT_456_Z) +XE_GPU_REGISTER(0x4723, float, SHADER_CONSTANT_456_W) +XE_GPU_REGISTER(0x4724, float, SHADER_CONSTANT_457_X) +XE_GPU_REGISTER(0x4725, float, SHADER_CONSTANT_457_Y) +XE_GPU_REGISTER(0x4726, float, SHADER_CONSTANT_457_Z) +XE_GPU_REGISTER(0x4727, float, SHADER_CONSTANT_457_W) +XE_GPU_REGISTER(0x4728, float, SHADER_CONSTANT_458_X) +XE_GPU_REGISTER(0x4729, float, SHADER_CONSTANT_458_Y) +XE_GPU_REGISTER(0x472A, float, SHADER_CONSTANT_458_Z) +XE_GPU_REGISTER(0x472B, float, SHADER_CONSTANT_458_W) +XE_GPU_REGISTER(0x472C, float, SHADER_CONSTANT_459_X) +XE_GPU_REGISTER(0x472D, float, SHADER_CONSTANT_459_Y) +XE_GPU_REGISTER(0x472E, float, SHADER_CONSTANT_459_Z) +XE_GPU_REGISTER(0x472F, float, SHADER_CONSTANT_459_W) +XE_GPU_REGISTER(0x4730, float, SHADER_CONSTANT_460_X) +XE_GPU_REGISTER(0x4731, float, SHADER_CONSTANT_460_Y) +XE_GPU_REGISTER(0x4732, float, SHADER_CONSTANT_460_Z) +XE_GPU_REGISTER(0x4733, float, SHADER_CONSTANT_460_W) +XE_GPU_REGISTER(0x4734, float, SHADER_CONSTANT_461_X) +XE_GPU_REGISTER(0x4735, float, SHADER_CONSTANT_461_Y) +XE_GPU_REGISTER(0x4736, float, SHADER_CONSTANT_461_Z) +XE_GPU_REGISTER(0x4737, float, SHADER_CONSTANT_461_W) +XE_GPU_REGISTER(0x4738, float, SHADER_CONSTANT_462_X) +XE_GPU_REGISTER(0x4739, float, SHADER_CONSTANT_462_Y) +XE_GPU_REGISTER(0x473A, float, SHADER_CONSTANT_462_Z) +XE_GPU_REGISTER(0x473B, float, SHADER_CONSTANT_462_W) +XE_GPU_REGISTER(0x473C, float, SHADER_CONSTANT_463_X) +XE_GPU_REGISTER(0x473D, float, SHADER_CONSTANT_463_Y) +XE_GPU_REGISTER(0x473E, float, SHADER_CONSTANT_463_Z) +XE_GPU_REGISTER(0x473F, float, SHADER_CONSTANT_463_W) +XE_GPU_REGISTER(0x4740, float, SHADER_CONSTANT_464_X) +XE_GPU_REGISTER(0x4741, float, SHADER_CONSTANT_464_Y) +XE_GPU_REGISTER(0x4742, float, SHADER_CONSTANT_464_Z) +XE_GPU_REGISTER(0x4743, float, SHADER_CONSTANT_464_W) +XE_GPU_REGISTER(0x4744, float, SHADER_CONSTANT_465_X) +XE_GPU_REGISTER(0x4745, float, SHADER_CONSTANT_465_Y) +XE_GPU_REGISTER(0x4746, float, SHADER_CONSTANT_465_Z) +XE_GPU_REGISTER(0x4747, float, SHADER_CONSTANT_465_W) +XE_GPU_REGISTER(0x4748, float, SHADER_CONSTANT_466_X) +XE_GPU_REGISTER(0x4749, float, SHADER_CONSTANT_466_Y) +XE_GPU_REGISTER(0x474A, float, SHADER_CONSTANT_466_Z) +XE_GPU_REGISTER(0x474B, float, SHADER_CONSTANT_466_W) +XE_GPU_REGISTER(0x474C, float, SHADER_CONSTANT_467_X) +XE_GPU_REGISTER(0x474D, float, SHADER_CONSTANT_467_Y) +XE_GPU_REGISTER(0x474E, float, SHADER_CONSTANT_467_Z) +XE_GPU_REGISTER(0x474F, float, SHADER_CONSTANT_467_W) +XE_GPU_REGISTER(0x4750, float, SHADER_CONSTANT_468_X) +XE_GPU_REGISTER(0x4751, float, SHADER_CONSTANT_468_Y) +XE_GPU_REGISTER(0x4752, float, SHADER_CONSTANT_468_Z) +XE_GPU_REGISTER(0x4753, float, SHADER_CONSTANT_468_W) +XE_GPU_REGISTER(0x4754, float, SHADER_CONSTANT_469_X) +XE_GPU_REGISTER(0x4755, float, SHADER_CONSTANT_469_Y) +XE_GPU_REGISTER(0x4756, float, SHADER_CONSTANT_469_Z) +XE_GPU_REGISTER(0x4757, float, SHADER_CONSTANT_469_W) +XE_GPU_REGISTER(0x4758, float, SHADER_CONSTANT_470_X) +XE_GPU_REGISTER(0x4759, float, SHADER_CONSTANT_470_Y) +XE_GPU_REGISTER(0x475A, float, SHADER_CONSTANT_470_Z) +XE_GPU_REGISTER(0x475B, float, SHADER_CONSTANT_470_W) +XE_GPU_REGISTER(0x475C, float, SHADER_CONSTANT_471_X) +XE_GPU_REGISTER(0x475D, float, SHADER_CONSTANT_471_Y) +XE_GPU_REGISTER(0x475E, float, SHADER_CONSTANT_471_Z) +XE_GPU_REGISTER(0x475F, float, SHADER_CONSTANT_471_W) +XE_GPU_REGISTER(0x4760, float, SHADER_CONSTANT_472_X) +XE_GPU_REGISTER(0x4761, float, SHADER_CONSTANT_472_Y) +XE_GPU_REGISTER(0x4762, float, SHADER_CONSTANT_472_Z) +XE_GPU_REGISTER(0x4763, float, SHADER_CONSTANT_472_W) +XE_GPU_REGISTER(0x4764, float, SHADER_CONSTANT_473_X) +XE_GPU_REGISTER(0x4765, float, SHADER_CONSTANT_473_Y) +XE_GPU_REGISTER(0x4766, float, SHADER_CONSTANT_473_Z) +XE_GPU_REGISTER(0x4767, float, SHADER_CONSTANT_473_W) +XE_GPU_REGISTER(0x4768, float, SHADER_CONSTANT_474_X) +XE_GPU_REGISTER(0x4769, float, SHADER_CONSTANT_474_Y) +XE_GPU_REGISTER(0x476A, float, SHADER_CONSTANT_474_Z) +XE_GPU_REGISTER(0x476B, float, SHADER_CONSTANT_474_W) +XE_GPU_REGISTER(0x476C, float, SHADER_CONSTANT_475_X) +XE_GPU_REGISTER(0x476D, float, SHADER_CONSTANT_475_Y) +XE_GPU_REGISTER(0x476E, float, SHADER_CONSTANT_475_Z) +XE_GPU_REGISTER(0x476F, float, SHADER_CONSTANT_475_W) +XE_GPU_REGISTER(0x4770, float, SHADER_CONSTANT_476_X) +XE_GPU_REGISTER(0x4771, float, SHADER_CONSTANT_476_Y) +XE_GPU_REGISTER(0x4772, float, SHADER_CONSTANT_476_Z) +XE_GPU_REGISTER(0x4773, float, SHADER_CONSTANT_476_W) +XE_GPU_REGISTER(0x4774, float, SHADER_CONSTANT_477_X) +XE_GPU_REGISTER(0x4775, float, SHADER_CONSTANT_477_Y) +XE_GPU_REGISTER(0x4776, float, SHADER_CONSTANT_477_Z) +XE_GPU_REGISTER(0x4777, float, SHADER_CONSTANT_477_W) +XE_GPU_REGISTER(0x4778, float, SHADER_CONSTANT_478_X) +XE_GPU_REGISTER(0x4779, float, SHADER_CONSTANT_478_Y) +XE_GPU_REGISTER(0x477A, float, SHADER_CONSTANT_478_Z) +XE_GPU_REGISTER(0x477B, float, SHADER_CONSTANT_478_W) +XE_GPU_REGISTER(0x477C, float, SHADER_CONSTANT_479_X) +XE_GPU_REGISTER(0x477D, float, SHADER_CONSTANT_479_Y) +XE_GPU_REGISTER(0x477E, float, SHADER_CONSTANT_479_Z) +XE_GPU_REGISTER(0x477F, float, SHADER_CONSTANT_479_W) +XE_GPU_REGISTER(0x4780, float, SHADER_CONSTANT_480_X) +XE_GPU_REGISTER(0x4781, float, SHADER_CONSTANT_480_Y) +XE_GPU_REGISTER(0x4782, float, SHADER_CONSTANT_480_Z) +XE_GPU_REGISTER(0x4783, float, SHADER_CONSTANT_480_W) +XE_GPU_REGISTER(0x4784, float, SHADER_CONSTANT_481_X) +XE_GPU_REGISTER(0x4785, float, SHADER_CONSTANT_481_Y) +XE_GPU_REGISTER(0x4786, float, SHADER_CONSTANT_481_Z) +XE_GPU_REGISTER(0x4787, float, SHADER_CONSTANT_481_W) +XE_GPU_REGISTER(0x4788, float, SHADER_CONSTANT_482_X) +XE_GPU_REGISTER(0x4789, float, SHADER_CONSTANT_482_Y) +XE_GPU_REGISTER(0x478A, float, SHADER_CONSTANT_482_Z) +XE_GPU_REGISTER(0x478B, float, SHADER_CONSTANT_482_W) +XE_GPU_REGISTER(0x478C, float, SHADER_CONSTANT_483_X) +XE_GPU_REGISTER(0x478D, float, SHADER_CONSTANT_483_Y) +XE_GPU_REGISTER(0x478E, float, SHADER_CONSTANT_483_Z) +XE_GPU_REGISTER(0x478F, float, SHADER_CONSTANT_483_W) +XE_GPU_REGISTER(0x4790, float, SHADER_CONSTANT_484_X) +XE_GPU_REGISTER(0x4791, float, SHADER_CONSTANT_484_Y) +XE_GPU_REGISTER(0x4792, float, SHADER_CONSTANT_484_Z) +XE_GPU_REGISTER(0x4793, float, SHADER_CONSTANT_484_W) +XE_GPU_REGISTER(0x4794, float, SHADER_CONSTANT_485_X) +XE_GPU_REGISTER(0x4795, float, SHADER_CONSTANT_485_Y) +XE_GPU_REGISTER(0x4796, float, SHADER_CONSTANT_485_Z) +XE_GPU_REGISTER(0x4797, float, SHADER_CONSTANT_485_W) +XE_GPU_REGISTER(0x4798, float, SHADER_CONSTANT_486_X) +XE_GPU_REGISTER(0x4799, float, SHADER_CONSTANT_486_Y) +XE_GPU_REGISTER(0x479A, float, SHADER_CONSTANT_486_Z) +XE_GPU_REGISTER(0x479B, float, SHADER_CONSTANT_486_W) +XE_GPU_REGISTER(0x479C, float, SHADER_CONSTANT_487_X) +XE_GPU_REGISTER(0x479D, float, SHADER_CONSTANT_487_Y) +XE_GPU_REGISTER(0x479E, float, SHADER_CONSTANT_487_Z) +XE_GPU_REGISTER(0x479F, float, SHADER_CONSTANT_487_W) +XE_GPU_REGISTER(0x47A0, float, SHADER_CONSTANT_488_X) +XE_GPU_REGISTER(0x47A1, float, SHADER_CONSTANT_488_Y) +XE_GPU_REGISTER(0x47A2, float, SHADER_CONSTANT_488_Z) +XE_GPU_REGISTER(0x47A3, float, SHADER_CONSTANT_488_W) +XE_GPU_REGISTER(0x47A4, float, SHADER_CONSTANT_489_X) +XE_GPU_REGISTER(0x47A5, float, SHADER_CONSTANT_489_Y) +XE_GPU_REGISTER(0x47A6, float, SHADER_CONSTANT_489_Z) +XE_GPU_REGISTER(0x47A7, float, SHADER_CONSTANT_489_W) +XE_GPU_REGISTER(0x47A8, float, SHADER_CONSTANT_490_X) +XE_GPU_REGISTER(0x47A9, float, SHADER_CONSTANT_490_Y) +XE_GPU_REGISTER(0x47AA, float, SHADER_CONSTANT_490_Z) +XE_GPU_REGISTER(0x47AB, float, SHADER_CONSTANT_490_W) +XE_GPU_REGISTER(0x47AC, float, SHADER_CONSTANT_491_X) +XE_GPU_REGISTER(0x47AD, float, SHADER_CONSTANT_491_Y) +XE_GPU_REGISTER(0x47AE, float, SHADER_CONSTANT_491_Z) +XE_GPU_REGISTER(0x47AF, float, SHADER_CONSTANT_491_W) +XE_GPU_REGISTER(0x47B0, float, SHADER_CONSTANT_492_X) +XE_GPU_REGISTER(0x47B1, float, SHADER_CONSTANT_492_Y) +XE_GPU_REGISTER(0x47B2, float, SHADER_CONSTANT_492_Z) +XE_GPU_REGISTER(0x47B3, float, SHADER_CONSTANT_492_W) +XE_GPU_REGISTER(0x47B4, float, SHADER_CONSTANT_493_X) +XE_GPU_REGISTER(0x47B5, float, SHADER_CONSTANT_493_Y) +XE_GPU_REGISTER(0x47B6, float, SHADER_CONSTANT_493_Z) +XE_GPU_REGISTER(0x47B7, float, SHADER_CONSTANT_493_W) +XE_GPU_REGISTER(0x47B8, float, SHADER_CONSTANT_494_X) +XE_GPU_REGISTER(0x47B9, float, SHADER_CONSTANT_494_Y) +XE_GPU_REGISTER(0x47BA, float, SHADER_CONSTANT_494_Z) +XE_GPU_REGISTER(0x47BB, float, SHADER_CONSTANT_494_W) +XE_GPU_REGISTER(0x47BC, float, SHADER_CONSTANT_495_X) +XE_GPU_REGISTER(0x47BD, float, SHADER_CONSTANT_495_Y) +XE_GPU_REGISTER(0x47BE, float, SHADER_CONSTANT_495_Z) +XE_GPU_REGISTER(0x47BF, float, SHADER_CONSTANT_495_W) +XE_GPU_REGISTER(0x47C0, float, SHADER_CONSTANT_496_X) +XE_GPU_REGISTER(0x47C1, float, SHADER_CONSTANT_496_Y) +XE_GPU_REGISTER(0x47C2, float, SHADER_CONSTANT_496_Z) +XE_GPU_REGISTER(0x47C3, float, SHADER_CONSTANT_496_W) +XE_GPU_REGISTER(0x47C4, float, SHADER_CONSTANT_497_X) +XE_GPU_REGISTER(0x47C5, float, SHADER_CONSTANT_497_Y) +XE_GPU_REGISTER(0x47C6, float, SHADER_CONSTANT_497_Z) +XE_GPU_REGISTER(0x47C7, float, SHADER_CONSTANT_497_W) +XE_GPU_REGISTER(0x47C8, float, SHADER_CONSTANT_498_X) +XE_GPU_REGISTER(0x47C9, float, SHADER_CONSTANT_498_Y) +XE_GPU_REGISTER(0x47CA, float, SHADER_CONSTANT_498_Z) +XE_GPU_REGISTER(0x47CB, float, SHADER_CONSTANT_498_W) +XE_GPU_REGISTER(0x47CC, float, SHADER_CONSTANT_499_X) +XE_GPU_REGISTER(0x47CD, float, SHADER_CONSTANT_499_Y) +XE_GPU_REGISTER(0x47CE, float, SHADER_CONSTANT_499_Z) +XE_GPU_REGISTER(0x47CF, float, SHADER_CONSTANT_499_W) +XE_GPU_REGISTER(0x47D0, float, SHADER_CONSTANT_500_X) +XE_GPU_REGISTER(0x47D1, float, SHADER_CONSTANT_500_Y) +XE_GPU_REGISTER(0x47D2, float, SHADER_CONSTANT_500_Z) +XE_GPU_REGISTER(0x47D3, float, SHADER_CONSTANT_500_W) +XE_GPU_REGISTER(0x47D4, float, SHADER_CONSTANT_501_X) +XE_GPU_REGISTER(0x47D5, float, SHADER_CONSTANT_501_Y) +XE_GPU_REGISTER(0x47D6, float, SHADER_CONSTANT_501_Z) +XE_GPU_REGISTER(0x47D7, float, SHADER_CONSTANT_501_W) +XE_GPU_REGISTER(0x47D8, float, SHADER_CONSTANT_502_X) +XE_GPU_REGISTER(0x47D9, float, SHADER_CONSTANT_502_Y) +XE_GPU_REGISTER(0x47DA, float, SHADER_CONSTANT_502_Z) +XE_GPU_REGISTER(0x47DB, float, SHADER_CONSTANT_502_W) +XE_GPU_REGISTER(0x47DC, float, SHADER_CONSTANT_503_X) +XE_GPU_REGISTER(0x47DD, float, SHADER_CONSTANT_503_Y) +XE_GPU_REGISTER(0x47DE, float, SHADER_CONSTANT_503_Z) +XE_GPU_REGISTER(0x47DF, float, SHADER_CONSTANT_503_W) +XE_GPU_REGISTER(0x47E0, float, SHADER_CONSTANT_504_X) +XE_GPU_REGISTER(0x47E1, float, SHADER_CONSTANT_504_Y) +XE_GPU_REGISTER(0x47E2, float, SHADER_CONSTANT_504_Z) +XE_GPU_REGISTER(0x47E3, float, SHADER_CONSTANT_504_W) +XE_GPU_REGISTER(0x47E4, float, SHADER_CONSTANT_505_X) +XE_GPU_REGISTER(0x47E5, float, SHADER_CONSTANT_505_Y) +XE_GPU_REGISTER(0x47E6, float, SHADER_CONSTANT_505_Z) +XE_GPU_REGISTER(0x47E7, float, SHADER_CONSTANT_505_W) +XE_GPU_REGISTER(0x47E8, float, SHADER_CONSTANT_506_X) +XE_GPU_REGISTER(0x47E9, float, SHADER_CONSTANT_506_Y) +XE_GPU_REGISTER(0x47EA, float, SHADER_CONSTANT_506_Z) +XE_GPU_REGISTER(0x47EB, float, SHADER_CONSTANT_506_W) +XE_GPU_REGISTER(0x47EC, float, SHADER_CONSTANT_507_X) +XE_GPU_REGISTER(0x47ED, float, SHADER_CONSTANT_507_Y) +XE_GPU_REGISTER(0x47EE, float, SHADER_CONSTANT_507_Z) +XE_GPU_REGISTER(0x47EF, float, SHADER_CONSTANT_507_W) +XE_GPU_REGISTER(0x47F0, float, SHADER_CONSTANT_508_X) +XE_GPU_REGISTER(0x47F1, float, SHADER_CONSTANT_508_Y) +XE_GPU_REGISTER(0x47F2, float, SHADER_CONSTANT_508_Z) +XE_GPU_REGISTER(0x47F3, float, SHADER_CONSTANT_508_W) +XE_GPU_REGISTER(0x47F4, float, SHADER_CONSTANT_509_X) +XE_GPU_REGISTER(0x47F5, float, SHADER_CONSTANT_509_Y) +XE_GPU_REGISTER(0x47F6, float, SHADER_CONSTANT_509_Z) +XE_GPU_REGISTER(0x47F7, float, SHADER_CONSTANT_509_W) +XE_GPU_REGISTER(0x47F8, float, SHADER_CONSTANT_510_X) +XE_GPU_REGISTER(0x47F9, float, SHADER_CONSTANT_510_Y) +XE_GPU_REGISTER(0x47FA, float, SHADER_CONSTANT_510_Z) +XE_GPU_REGISTER(0x47FB, float, SHADER_CONSTANT_510_W) +XE_GPU_REGISTER(0x47FC, float, SHADER_CONSTANT_511_X) +XE_GPU_REGISTER(0x47FD, float, SHADER_CONSTANT_511_Y) +XE_GPU_REGISTER(0x47FE, float, SHADER_CONSTANT_511_Z) +XE_GPU_REGISTER(0x47FF, float, SHADER_CONSTANT_511_W) + +XE_GPU_REGISTER(0x4800, dword, SHADER_CONSTANT_FETCH_00_0) +XE_GPU_REGISTER(0x4801, dword, SHADER_CONSTANT_FETCH_00_1) +XE_GPU_REGISTER(0x4802, dword, SHADER_CONSTANT_FETCH_00_2) +XE_GPU_REGISTER(0x4803, dword, SHADER_CONSTANT_FETCH_00_3) +XE_GPU_REGISTER(0x4804, dword, SHADER_CONSTANT_FETCH_00_4) +XE_GPU_REGISTER(0x4805, dword, SHADER_CONSTANT_FETCH_00_5) +XE_GPU_REGISTER(0x4806, dword, SHADER_CONSTANT_FETCH_01_0) +XE_GPU_REGISTER(0x4807, dword, SHADER_CONSTANT_FETCH_01_1) +XE_GPU_REGISTER(0x4808, dword, SHADER_CONSTANT_FETCH_01_2) +XE_GPU_REGISTER(0x4809, dword, SHADER_CONSTANT_FETCH_01_3) +XE_GPU_REGISTER(0x480A, dword, SHADER_CONSTANT_FETCH_01_4) +XE_GPU_REGISTER(0x480B, dword, SHADER_CONSTANT_FETCH_01_5) +XE_GPU_REGISTER(0x480C, dword, SHADER_CONSTANT_FETCH_02_0) +XE_GPU_REGISTER(0x480D, dword, SHADER_CONSTANT_FETCH_02_1) +XE_GPU_REGISTER(0x480E, dword, SHADER_CONSTANT_FETCH_02_2) +XE_GPU_REGISTER(0x480F, dword, SHADER_CONSTANT_FETCH_02_3) +XE_GPU_REGISTER(0x4810, dword, SHADER_CONSTANT_FETCH_02_4) +XE_GPU_REGISTER(0x4811, dword, SHADER_CONSTANT_FETCH_02_5) +XE_GPU_REGISTER(0x4812, dword, SHADER_CONSTANT_FETCH_03_0) +XE_GPU_REGISTER(0x4813, dword, SHADER_CONSTANT_FETCH_03_1) +XE_GPU_REGISTER(0x4814, dword, SHADER_CONSTANT_FETCH_03_2) +XE_GPU_REGISTER(0x4815, dword, SHADER_CONSTANT_FETCH_03_3) +XE_GPU_REGISTER(0x4816, dword, SHADER_CONSTANT_FETCH_03_4) +XE_GPU_REGISTER(0x4817, dword, SHADER_CONSTANT_FETCH_03_5) +XE_GPU_REGISTER(0x4818, dword, SHADER_CONSTANT_FETCH_04_0) +XE_GPU_REGISTER(0x4819, dword, SHADER_CONSTANT_FETCH_04_1) +XE_GPU_REGISTER(0x481A, dword, SHADER_CONSTANT_FETCH_04_2) +XE_GPU_REGISTER(0x481B, dword, SHADER_CONSTANT_FETCH_04_3) +XE_GPU_REGISTER(0x481C, dword, SHADER_CONSTANT_FETCH_04_4) +XE_GPU_REGISTER(0x481D, dword, SHADER_CONSTANT_FETCH_04_5) +XE_GPU_REGISTER(0x481E, dword, SHADER_CONSTANT_FETCH_05_0) +XE_GPU_REGISTER(0x481F, dword, SHADER_CONSTANT_FETCH_05_1) +XE_GPU_REGISTER(0x4820, dword, SHADER_CONSTANT_FETCH_05_2) +XE_GPU_REGISTER(0x4821, dword, SHADER_CONSTANT_FETCH_05_3) +XE_GPU_REGISTER(0x4822, dword, SHADER_CONSTANT_FETCH_05_4) +XE_GPU_REGISTER(0x4823, dword, SHADER_CONSTANT_FETCH_05_5) +XE_GPU_REGISTER(0x4824, dword, SHADER_CONSTANT_FETCH_06_0) +XE_GPU_REGISTER(0x4825, dword, SHADER_CONSTANT_FETCH_06_1) +XE_GPU_REGISTER(0x4826, dword, SHADER_CONSTANT_FETCH_06_2) +XE_GPU_REGISTER(0x4827, dword, SHADER_CONSTANT_FETCH_06_3) +XE_GPU_REGISTER(0x4828, dword, SHADER_CONSTANT_FETCH_06_4) +XE_GPU_REGISTER(0x4829, dword, SHADER_CONSTANT_FETCH_06_5) +XE_GPU_REGISTER(0x482A, dword, SHADER_CONSTANT_FETCH_07_0) +XE_GPU_REGISTER(0x482B, dword, SHADER_CONSTANT_FETCH_07_1) +XE_GPU_REGISTER(0x482C, dword, SHADER_CONSTANT_FETCH_07_2) +XE_GPU_REGISTER(0x482D, dword, SHADER_CONSTANT_FETCH_07_3) +XE_GPU_REGISTER(0x482E, dword, SHADER_CONSTANT_FETCH_07_4) +XE_GPU_REGISTER(0x482F, dword, SHADER_CONSTANT_FETCH_07_5) +XE_GPU_REGISTER(0x4830, dword, SHADER_CONSTANT_FETCH_08_0) +XE_GPU_REGISTER(0x4831, dword, SHADER_CONSTANT_FETCH_08_1) +XE_GPU_REGISTER(0x4832, dword, SHADER_CONSTANT_FETCH_08_2) +XE_GPU_REGISTER(0x4833, dword, SHADER_CONSTANT_FETCH_08_3) +XE_GPU_REGISTER(0x4834, dword, SHADER_CONSTANT_FETCH_08_4) +XE_GPU_REGISTER(0x4835, dword, SHADER_CONSTANT_FETCH_08_5) +XE_GPU_REGISTER(0x4836, dword, SHADER_CONSTANT_FETCH_09_0) +XE_GPU_REGISTER(0x4837, dword, SHADER_CONSTANT_FETCH_09_1) +XE_GPU_REGISTER(0x4838, dword, SHADER_CONSTANT_FETCH_09_2) +XE_GPU_REGISTER(0x4839, dword, SHADER_CONSTANT_FETCH_09_3) +XE_GPU_REGISTER(0x483A, dword, SHADER_CONSTANT_FETCH_09_4) +XE_GPU_REGISTER(0x483B, dword, SHADER_CONSTANT_FETCH_09_5) +XE_GPU_REGISTER(0x483C, dword, SHADER_CONSTANT_FETCH_10_0) +XE_GPU_REGISTER(0x483D, dword, SHADER_CONSTANT_FETCH_10_1) +XE_GPU_REGISTER(0x483E, dword, SHADER_CONSTANT_FETCH_10_2) +XE_GPU_REGISTER(0x483F, dword, SHADER_CONSTANT_FETCH_10_3) +XE_GPU_REGISTER(0x4840, dword, SHADER_CONSTANT_FETCH_10_4) +XE_GPU_REGISTER(0x4841, dword, SHADER_CONSTANT_FETCH_10_5) +XE_GPU_REGISTER(0x4842, dword, SHADER_CONSTANT_FETCH_11_0) +XE_GPU_REGISTER(0x4843, dword, SHADER_CONSTANT_FETCH_11_1) +XE_GPU_REGISTER(0x4844, dword, SHADER_CONSTANT_FETCH_11_2) +XE_GPU_REGISTER(0x4845, dword, SHADER_CONSTANT_FETCH_11_3) +XE_GPU_REGISTER(0x4846, dword, SHADER_CONSTANT_FETCH_11_4) +XE_GPU_REGISTER(0x4847, dword, SHADER_CONSTANT_FETCH_11_5) +XE_GPU_REGISTER(0x4848, dword, SHADER_CONSTANT_FETCH_12_0) +XE_GPU_REGISTER(0x4849, dword, SHADER_CONSTANT_FETCH_12_1) +XE_GPU_REGISTER(0x484A, dword, SHADER_CONSTANT_FETCH_12_2) +XE_GPU_REGISTER(0x484B, dword, SHADER_CONSTANT_FETCH_12_3) +XE_GPU_REGISTER(0x484C, dword, SHADER_CONSTANT_FETCH_12_4) +XE_GPU_REGISTER(0x484D, dword, SHADER_CONSTANT_FETCH_12_5) +XE_GPU_REGISTER(0x484E, dword, SHADER_CONSTANT_FETCH_13_0) +XE_GPU_REGISTER(0x484F, dword, SHADER_CONSTANT_FETCH_13_1) +XE_GPU_REGISTER(0x4850, dword, SHADER_CONSTANT_FETCH_13_2) +XE_GPU_REGISTER(0x4851, dword, SHADER_CONSTANT_FETCH_13_3) +XE_GPU_REGISTER(0x4852, dword, SHADER_CONSTANT_FETCH_13_4) +XE_GPU_REGISTER(0x4853, dword, SHADER_CONSTANT_FETCH_13_5) +XE_GPU_REGISTER(0x4854, dword, SHADER_CONSTANT_FETCH_14_0) +XE_GPU_REGISTER(0x4855, dword, SHADER_CONSTANT_FETCH_14_1) +XE_GPU_REGISTER(0x4856, dword, SHADER_CONSTANT_FETCH_14_2) +XE_GPU_REGISTER(0x4857, dword, SHADER_CONSTANT_FETCH_14_3) +XE_GPU_REGISTER(0x4858, dword, SHADER_CONSTANT_FETCH_14_4) +XE_GPU_REGISTER(0x4859, dword, SHADER_CONSTANT_FETCH_14_5) +XE_GPU_REGISTER(0x485A, dword, SHADER_CONSTANT_FETCH_15_0) +XE_GPU_REGISTER(0x485B, dword, SHADER_CONSTANT_FETCH_15_1) +XE_GPU_REGISTER(0x485C, dword, SHADER_CONSTANT_FETCH_15_2) +XE_GPU_REGISTER(0x485D, dword, SHADER_CONSTANT_FETCH_15_3) +XE_GPU_REGISTER(0x485E, dword, SHADER_CONSTANT_FETCH_15_4) +XE_GPU_REGISTER(0x485F, dword, SHADER_CONSTANT_FETCH_15_5) +XE_GPU_REGISTER(0x4860, dword, SHADER_CONSTANT_FETCH_16_0) +XE_GPU_REGISTER(0x4861, dword, SHADER_CONSTANT_FETCH_16_1) +XE_GPU_REGISTER(0x4862, dword, SHADER_CONSTANT_FETCH_16_2) +XE_GPU_REGISTER(0x4863, dword, SHADER_CONSTANT_FETCH_16_3) +XE_GPU_REGISTER(0x4864, dword, SHADER_CONSTANT_FETCH_16_4) +XE_GPU_REGISTER(0x4865, dword, SHADER_CONSTANT_FETCH_16_5) +XE_GPU_REGISTER(0x4866, dword, SHADER_CONSTANT_FETCH_17_0) +XE_GPU_REGISTER(0x4867, dword, SHADER_CONSTANT_FETCH_17_1) +XE_GPU_REGISTER(0x4868, dword, SHADER_CONSTANT_FETCH_17_2) +XE_GPU_REGISTER(0x4869, dword, SHADER_CONSTANT_FETCH_17_3) +XE_GPU_REGISTER(0x486A, dword, SHADER_CONSTANT_FETCH_17_4) +XE_GPU_REGISTER(0x486B, dword, SHADER_CONSTANT_FETCH_17_5) +XE_GPU_REGISTER(0x486C, dword, SHADER_CONSTANT_FETCH_18_0) +XE_GPU_REGISTER(0x486D, dword, SHADER_CONSTANT_FETCH_18_1) +XE_GPU_REGISTER(0x486E, dword, SHADER_CONSTANT_FETCH_18_2) +XE_GPU_REGISTER(0x486F, dword, SHADER_CONSTANT_FETCH_18_3) +XE_GPU_REGISTER(0x4870, dword, SHADER_CONSTANT_FETCH_18_4) +XE_GPU_REGISTER(0x4871, dword, SHADER_CONSTANT_FETCH_18_5) +XE_GPU_REGISTER(0x4872, dword, SHADER_CONSTANT_FETCH_19_0) +XE_GPU_REGISTER(0x4873, dword, SHADER_CONSTANT_FETCH_19_1) +XE_GPU_REGISTER(0x4874, dword, SHADER_CONSTANT_FETCH_19_2) +XE_GPU_REGISTER(0x4875, dword, SHADER_CONSTANT_FETCH_19_3) +XE_GPU_REGISTER(0x4876, dword, SHADER_CONSTANT_FETCH_19_4) +XE_GPU_REGISTER(0x4877, dword, SHADER_CONSTANT_FETCH_19_5) +XE_GPU_REGISTER(0x4878, dword, SHADER_CONSTANT_FETCH_20_0) +XE_GPU_REGISTER(0x4879, dword, SHADER_CONSTANT_FETCH_20_1) +XE_GPU_REGISTER(0x487A, dword, SHADER_CONSTANT_FETCH_20_2) +XE_GPU_REGISTER(0x487B, dword, SHADER_CONSTANT_FETCH_20_3) +XE_GPU_REGISTER(0x487C, dword, SHADER_CONSTANT_FETCH_20_4) +XE_GPU_REGISTER(0x487D, dword, SHADER_CONSTANT_FETCH_20_5) +XE_GPU_REGISTER(0x487E, dword, SHADER_CONSTANT_FETCH_21_0) +XE_GPU_REGISTER(0x487F, dword, SHADER_CONSTANT_FETCH_21_1) +XE_GPU_REGISTER(0x4880, dword, SHADER_CONSTANT_FETCH_21_2) +XE_GPU_REGISTER(0x4881, dword, SHADER_CONSTANT_FETCH_21_3) +XE_GPU_REGISTER(0x4882, dword, SHADER_CONSTANT_FETCH_21_4) +XE_GPU_REGISTER(0x4883, dword, SHADER_CONSTANT_FETCH_21_5) +XE_GPU_REGISTER(0x4884, dword, SHADER_CONSTANT_FETCH_22_0) +XE_GPU_REGISTER(0x4885, dword, SHADER_CONSTANT_FETCH_22_1) +XE_GPU_REGISTER(0x4886, dword, SHADER_CONSTANT_FETCH_22_2) +XE_GPU_REGISTER(0x4887, dword, SHADER_CONSTANT_FETCH_22_3) +XE_GPU_REGISTER(0x4888, dword, SHADER_CONSTANT_FETCH_22_4) +XE_GPU_REGISTER(0x4889, dword, SHADER_CONSTANT_FETCH_22_5) +XE_GPU_REGISTER(0x488A, dword, SHADER_CONSTANT_FETCH_23_0) +XE_GPU_REGISTER(0x488B, dword, SHADER_CONSTANT_FETCH_23_1) +XE_GPU_REGISTER(0x488C, dword, SHADER_CONSTANT_FETCH_23_2) +XE_GPU_REGISTER(0x488D, dword, SHADER_CONSTANT_FETCH_23_3) +XE_GPU_REGISTER(0x488E, dword, SHADER_CONSTANT_FETCH_23_4) +XE_GPU_REGISTER(0x488F, dword, SHADER_CONSTANT_FETCH_23_5) +XE_GPU_REGISTER(0x4890, dword, SHADER_CONSTANT_FETCH_24_0) +XE_GPU_REGISTER(0x4891, dword, SHADER_CONSTANT_FETCH_24_1) +XE_GPU_REGISTER(0x4892, dword, SHADER_CONSTANT_FETCH_24_2) +XE_GPU_REGISTER(0x4893, dword, SHADER_CONSTANT_FETCH_24_3) +XE_GPU_REGISTER(0x4894, dword, SHADER_CONSTANT_FETCH_24_4) +XE_GPU_REGISTER(0x4895, dword, SHADER_CONSTANT_FETCH_24_5) +XE_GPU_REGISTER(0x4896, dword, SHADER_CONSTANT_FETCH_25_0) +XE_GPU_REGISTER(0x4897, dword, SHADER_CONSTANT_FETCH_25_1) +XE_GPU_REGISTER(0x4898, dword, SHADER_CONSTANT_FETCH_25_2) +XE_GPU_REGISTER(0x4899, dword, SHADER_CONSTANT_FETCH_25_3) +XE_GPU_REGISTER(0x489A, dword, SHADER_CONSTANT_FETCH_25_4) +XE_GPU_REGISTER(0x489B, dword, SHADER_CONSTANT_FETCH_25_5) +XE_GPU_REGISTER(0x489C, dword, SHADER_CONSTANT_FETCH_26_0) +XE_GPU_REGISTER(0x489D, dword, SHADER_CONSTANT_FETCH_26_1) +XE_GPU_REGISTER(0x489E, dword, SHADER_CONSTANT_FETCH_26_2) +XE_GPU_REGISTER(0x489F, dword, SHADER_CONSTANT_FETCH_26_3) +XE_GPU_REGISTER(0x48A0, dword, SHADER_CONSTANT_FETCH_26_4) +XE_GPU_REGISTER(0x48A1, dword, SHADER_CONSTANT_FETCH_26_5) +XE_GPU_REGISTER(0x48A2, dword, SHADER_CONSTANT_FETCH_27_0) +XE_GPU_REGISTER(0x48A3, dword, SHADER_CONSTANT_FETCH_27_1) +XE_GPU_REGISTER(0x48A4, dword, SHADER_CONSTANT_FETCH_27_2) +XE_GPU_REGISTER(0x48A5, dword, SHADER_CONSTANT_FETCH_27_3) +XE_GPU_REGISTER(0x48A6, dword, SHADER_CONSTANT_FETCH_27_4) +XE_GPU_REGISTER(0x48A7, dword, SHADER_CONSTANT_FETCH_27_5) +XE_GPU_REGISTER(0x48A8, dword, SHADER_CONSTANT_FETCH_28_0) +XE_GPU_REGISTER(0x48A9, dword, SHADER_CONSTANT_FETCH_28_1) +XE_GPU_REGISTER(0x48AA, dword, SHADER_CONSTANT_FETCH_28_2) +XE_GPU_REGISTER(0x48AB, dword, SHADER_CONSTANT_FETCH_28_3) +XE_GPU_REGISTER(0x48AC, dword, SHADER_CONSTANT_FETCH_28_4) +XE_GPU_REGISTER(0x48AD, dword, SHADER_CONSTANT_FETCH_28_5) +XE_GPU_REGISTER(0x48AE, dword, SHADER_CONSTANT_FETCH_29_0) +XE_GPU_REGISTER(0x48AF, dword, SHADER_CONSTANT_FETCH_29_1) +XE_GPU_REGISTER(0x48B0, dword, SHADER_CONSTANT_FETCH_29_2) +XE_GPU_REGISTER(0x48B1, dword, SHADER_CONSTANT_FETCH_29_3) +XE_GPU_REGISTER(0x48B2, dword, SHADER_CONSTANT_FETCH_29_4) +XE_GPU_REGISTER(0x48B3, dword, SHADER_CONSTANT_FETCH_29_5) +XE_GPU_REGISTER(0x48B4, dword, SHADER_CONSTANT_FETCH_30_0) +XE_GPU_REGISTER(0x48B5, dword, SHADER_CONSTANT_FETCH_30_1) +XE_GPU_REGISTER(0x48B6, dword, SHADER_CONSTANT_FETCH_30_2) +XE_GPU_REGISTER(0x48B7, dword, SHADER_CONSTANT_FETCH_30_3) +XE_GPU_REGISTER(0x48B8, dword, SHADER_CONSTANT_FETCH_30_4) +XE_GPU_REGISTER(0x48B9, dword, SHADER_CONSTANT_FETCH_30_5) +XE_GPU_REGISTER(0x48BA, dword, SHADER_CONSTANT_FETCH_31_0) +XE_GPU_REGISTER(0x48BB, dword, SHADER_CONSTANT_FETCH_31_1) +XE_GPU_REGISTER(0x48BC, dword, SHADER_CONSTANT_FETCH_31_2) +XE_GPU_REGISTER(0x48BD, dword, SHADER_CONSTANT_FETCH_31_3) +XE_GPU_REGISTER(0x48BE, dword, SHADER_CONSTANT_FETCH_31_4) +XE_GPU_REGISTER(0x48BF, dword, SHADER_CONSTANT_FETCH_31_5) + +XE_GPU_REGISTER(0x4900, dword, SHADER_CONSTANT_BOOL_000_031) +XE_GPU_REGISTER(0x4901, dword, SHADER_CONSTANT_BOOL_032_063) +XE_GPU_REGISTER(0x4902, dword, SHADER_CONSTANT_BOOL_064_095) +XE_GPU_REGISTER(0x4903, dword, SHADER_CONSTANT_BOOL_096_127) +XE_GPU_REGISTER(0x4904, dword, SHADER_CONSTANT_BOOL_128_159) +XE_GPU_REGISTER(0x4905, dword, SHADER_CONSTANT_BOOL_160_191) +XE_GPU_REGISTER(0x4906, dword, SHADER_CONSTANT_BOOL_192_223) +XE_GPU_REGISTER(0x4907, dword, SHADER_CONSTANT_BOOL_224_255) + +XE_GPU_REGISTER(0x4908, dword, SHADER_CONSTANT_LOOP_00) +XE_GPU_REGISTER(0x4909, dword, SHADER_CONSTANT_LOOP_01) +XE_GPU_REGISTER(0x490A, dword, SHADER_CONSTANT_LOOP_02) +XE_GPU_REGISTER(0x490B, dword, SHADER_CONSTANT_LOOP_03) +XE_GPU_REGISTER(0x490C, dword, SHADER_CONSTANT_LOOP_04) +XE_GPU_REGISTER(0x490D, dword, SHADER_CONSTANT_LOOP_05) +XE_GPU_REGISTER(0x490E, dword, SHADER_CONSTANT_LOOP_06) +XE_GPU_REGISTER(0x490F, dword, SHADER_CONSTANT_LOOP_07) +XE_GPU_REGISTER(0x4910, dword, SHADER_CONSTANT_LOOP_08) +XE_GPU_REGISTER(0x4911, dword, SHADER_CONSTANT_LOOP_09) +XE_GPU_REGISTER(0x4912, dword, SHADER_CONSTANT_LOOP_10) +XE_GPU_REGISTER(0x4913, dword, SHADER_CONSTANT_LOOP_11) +XE_GPU_REGISTER(0x4914, dword, SHADER_CONSTANT_LOOP_12) +XE_GPU_REGISTER(0x4915, dword, SHADER_CONSTANT_LOOP_13) +XE_GPU_REGISTER(0x4916, dword, SHADER_CONSTANT_LOOP_14) +XE_GPU_REGISTER(0x4917, dword, SHADER_CONSTANT_LOOP_15) +XE_GPU_REGISTER(0x4918, dword, SHADER_CONSTANT_LOOP_16) +XE_GPU_REGISTER(0x4919, dword, SHADER_CONSTANT_LOOP_17) +XE_GPU_REGISTER(0x491A, dword, SHADER_CONSTANT_LOOP_18) +XE_GPU_REGISTER(0x491B, dword, SHADER_CONSTANT_LOOP_19) +XE_GPU_REGISTER(0x491C, dword, SHADER_CONSTANT_LOOP_20) +XE_GPU_REGISTER(0x491D, dword, SHADER_CONSTANT_LOOP_21) +XE_GPU_REGISTER(0x491E, dword, SHADER_CONSTANT_LOOP_22) +XE_GPU_REGISTER(0x491F, dword, SHADER_CONSTANT_LOOP_23) +XE_GPU_REGISTER(0x4920, dword, SHADER_CONSTANT_LOOP_24) +XE_GPU_REGISTER(0x4921, dword, SHADER_CONSTANT_LOOP_25) +XE_GPU_REGISTER(0x4922, dword, SHADER_CONSTANT_LOOP_26) +XE_GPU_REGISTER(0x4923, dword, SHADER_CONSTANT_LOOP_27) +XE_GPU_REGISTER(0x4924, dword, SHADER_CONSTANT_LOOP_28) +XE_GPU_REGISTER(0x4925, dword, SHADER_CONSTANT_LOOP_29) +XE_GPU_REGISTER(0x4926, dword, SHADER_CONSTANT_LOOP_30) +XE_GPU_REGISTER(0x4927, dword, SHADER_CONSTANT_LOOP_31) + // Ignored because I have no clue what these are. // XE_GPU_REGISTER(0x8D00, dword, UNKNOWN_8D00) // XE_GPU_REGISTER(0x8D01, dword, UNKNOWN_8D01) diff --git a/src/xenia/gpu/xenos/xenos.h b/src/xenia/gpu/xenos/xenos.h index 7dff662c1..e0ee4e4b3 100644 --- a/src/xenia/gpu/xenos/xenos.h +++ b/src/xenia/gpu/xenos/xenos.h @@ -42,6 +42,90 @@ typedef enum { XE_GPU_PRIMITIVE_TYPE_LINE_LOOP = 0x0C, } XE_GPU_PRIMITIVE_TYPE; +// XE_GPU_REG_SQ_PROGRAM_CNTL +typedef union { + XEPACKEDSTRUCTANONYMOUS({ + uint32_t vs_regs : 8; + uint32_t ps_regs : 8; + uint32_t vs_resource : 1; + uint32_t ps_resource : 1; + uint32_t param_gen : 1; + uint32_t unknown0 : 1; + uint32_t vs_export_count : 4; + uint32_t vs_export_mode : 3; + uint32_t ps_export_depth : 1; + uint32_t ps_export_count : 3; + uint32_t gen_index_vtx : 1; + }); + XEPACKEDSTRUCTANONYMOUS({ + uint32_t dword_0; + }); +} xe_gpu_program_cntl_t; + +// XE_GPU_REG_SHADER_CONSTANT_FETCH_* +XEPACKEDUNION(xe_gpu_vertex_fetch_t, { + XEPACKEDSTRUCTANONYMOUS({ + uint32_t type : 2; + uint32_t address : 30; + uint32_t unk0 : 2; + uint32_t size : 24; + uint32_t unk1 : 6; + }); + XEPACKEDSTRUCTANONYMOUS({ + uint32_t dword_0; + uint32_t dword_1; + }); +}); + +// XE_GPU_REG_SHADER_CONSTANT_FETCH_* +XEPACKEDUNION(xe_gpu_texture_fetch_t, { + XEPACKEDSTRUCTANONYMOUS({ + uint32_t unk0; + uint32_t unk1; + uint32_t unk2; + uint32_t unk3; + uint32_t unk4; + uint32_t unk5; + }); + XEPACKEDSTRUCTANONYMOUS({ + uint32_t dword_0; + uint32_t dword_1; + uint32_t dword_2; + uint32_t dword_3; + uint32_t dword_4; + uint32_t dword_5; + }); +}); + +// XE_GPU_REG_SHADER_CONSTANT_FETCH_* +XEPACKEDUNION(xe_gpu_fetch_group_t, { + xe_gpu_texture_fetch_t texture_fetch; + XEPACKEDSTRUCTANONYMOUS({ + xe_gpu_vertex_fetch_t vertex_fetch_0; + xe_gpu_vertex_fetch_t vertex_fetch_1; + xe_gpu_vertex_fetch_t vertex_fetch_2; + }); + XEPACKEDSTRUCTANONYMOUS({ + uint32_t dword_0; + uint32_t dword_1; + uint32_t dword_2; + uint32_t dword_3; + uint32_t dword_4; + uint32_t dword_5; + }); + XEPACKEDSTRUCTANONYMOUS({ + uint32_t type_0 : 2; + uint32_t : 30; + uint32_t : 32; + uint32_t type_1 : 2; + uint32_t : 30; + uint32_t : 32; + uint32_t type_2 : 2; + uint32_t : 30; + uint32_t : 32; + }); +}); + } // namespace xenos } // namespace gpu diff --git a/src/xenia/types.h b/src/xenia/types.h index a70ee5061..a213dc205 100644 --- a/src/xenia/types.h +++ b/src/xenia/types.h @@ -119,6 +119,10 @@ typedef XECACHEALIGN volatile void xe_aligned_void_t; #endif // GNUC #endif // !MIN +#if XE_PLATFORM(WIN32) +#define XESAFERELEASE(p) if (p) { p->Release(); } +#endif // WIN32 + #define XEBITMASK(a, b) (((unsigned) -1 >> (31 - (b))) & ~((1U << (a)) - 1)) #define XESELECTBITS(value, a, b) ((value & XEBITMASK(a, b)) >> a)