diff --git a/src/games/endfield/addon.cpp b/src/games/endfield/addon.cpp index de6ec8693d..bf699d5fd6 100644 --- a/src/games/endfield/addon.cpp +++ b/src/games/endfield/addon.cpp @@ -5,9 +5,13 @@ #define ImTextureID ImU64 -#define DEBUG_LEVEL_0 +// #define DEBUG_LEVEL_0 +#include +#include #include +#include +#include #include #include @@ -16,10 +20,12 @@ #include "../../mods/shader.hpp" #include "../../mods/swapchain.hpp" +#include "../../utils/bitwise.hpp" #include "../../utils/data.hpp" +#include "../../utils/hash.hpp" #include "../../utils/random.hpp" -#include "../../utils/resource.hpp" #include "../../utils/settings.hpp" +#include "../../utils/state.hpp" #include "../../utils/swapchain.hpp" #include "./shared.h" @@ -44,6 +50,112 @@ bool UsingSwapchainUtil() { || UsingSwapchainUpgrade()); } +void ApplySwapChainEncodingTarget(float encoding_value) { + const bool is_hdr10 = encoding_value == 4.f; + const bool is_scrgb = encoding_value == 5.f; + + if (is_hdr10) { + renodx::mods::swapchain::target_format = reshade::api::format::r10g10b10a2_unorm; + renodx::mods::swapchain::target_color_space = reshade::api::color_space::hdr10_st2084; + renodx::mods::swapchain::use_resize_buffer = false; + } else if (is_scrgb) { + renodx::mods::swapchain::target_format = reshade::api::format::r16g16b16a16_float; + renodx::mods::swapchain::target_color_space = reshade::api::color_space::extended_srgb_linear; + renodx::mods::swapchain::use_resize_buffer = false; + } else { + renodx::mods::swapchain::target_format = reshade::api::format::r8g8b8a8_unorm; + renodx::mods::swapchain::target_color_space = reshade::api::color_space::srgb_nonlinear; + renodx::mods::swapchain::use_resize_buffer = true; + } + + renodx::utils::device_proxy::SetTargetFormat(renodx::mods::swapchain::target_format); + renodx::utils::device_proxy::SetTargetColorSpace(renodx::mods::swapchain::target_color_space); + shader_injection.swap_chain_encoding_color_space = is_hdr10 ? 1.f : 0.f; +} + +// Helper to update resolution-based uniform variables in ReShade effects +void UpdateReshadeResolutionUniforms(reshade::api::effect_runtime* runtime, uint32_t width, uint32_t height) { + float fwidth = static_cast(width); + float fheight = static_cast(height); + + // Enumerate all uniform variables and update those with resolution-related source annotations + runtime->enumerate_uniform_variables(nullptr, [fwidth, fheight](reshade::api::effect_runtime* rt, reshade::api::effect_uniform_variable variable) { + char source[64] = {}; + if (rt->get_annotation_string_from_uniform_variable(variable, "source", source)) { + // Update BUFFER_WIDTH uniform + if (std::strcmp(source, "bufwidth") == 0) { + rt->set_uniform_value_float(variable, fwidth); + } + // Update BUFFER_HEIGHT uniform + else if (std::strcmp(source, "bufheight") == 0) { + rt->set_uniform_value_float(variable, fheight); + } + // Update reciprocal width (1.0 / BUFFER_WIDTH) + else if (std::strcmp(source, "rcpwidth") == 0 || std::strcmp(source, "bufwidth_rcp") == 0) { + rt->set_uniform_value_float(variable, 1.0f / fwidth); + } + // Update reciprocal height (1.0 / BUFFER_HEIGHT) + else if (std::strcmp(source, "rcpheight") == 0 || std::strcmp(source, "bufheight_rcp") == 0) { + rt->set_uniform_value_float(variable, 1.0f / fheight); + } + // Update BUFFER_RCP_WIDTH (alternative naming convention) + else if (std::strcmp(source, "buffer_rcp_width") == 0) { + rt->set_uniform_value_float(variable, 1.0f / fwidth); + } + // Update BUFFER_RCP_HEIGHT (alternative naming convention) + else if (std::strcmp(source, "buffer_rcp_height") == 0) { + rt->set_uniform_value_float(variable, 1.0f / fheight); + } + // Update pixel size (float2 with 1/width, 1/height) + else if (std::strcmp(source, "pixelsize") == 0) { + float pixel_size[2] = { 1.0f / fwidth, 1.0f / fheight }; + rt->set_uniform_value_float(variable, pixel_size, 2); + } + // Update screen size (float2 with width, height) + else if (std::strcmp(source, "screensize") == 0) { + float screen_size[2] = { fwidth, fheight }; + rt->set_uniform_value_float(variable, screen_size, 2); + } + } + }); +} + +// Track the last known RTV resolution to detect resolution changes +static uint32_t last_rtv_width = 0; +static uint32_t last_rtv_height = 0; + +// Flag to track if we're currently executing our bypass render +// This prevents ReShade from rendering during normal present while allowing our bypass to work +static bool bypass_render_active = false; + +// Deferred Tech Test preset application (avoids crash from UpdateSetting inside on_change_value) +static int pending_tech_test_preset = -1; // -1 = none, 0 = restore defaults, 1 = apply tech test +static float prev_tech_test_look = -1.f; // impossible initial value forces first-frame detection + +// Callback to disable effects during normal present when bypass is enabled +// This prevents double-rendering (once via bypass, once via normal present) +void OnReshadeBeginEffects(reshade::api::effect_runtime* runtime, + reshade::api::command_list* cmd_list, + reshade::api::resource_view rtv, + reshade::api::resource_view rtv_srgb) { + // Only intercept if bypass is enabled AND we're not currently in bypass render + // When bypass is disabled (current_render_reshade_before_ui == 0), let ReShade render normally + if (current_render_reshade_before_ui != 0.f && !bypass_render_active) { + runtime->set_effects_state(false); + } +} + +// Callback to re-enable effects after present (keeps effects available for bypass) +void OnReshadeFinishEffects(reshade::api::effect_runtime* runtime, + reshade::api::command_list* cmd_list, + reshade::api::resource_view rtv, + reshade::api::resource_view rtv_srgb) { + // Only re-enable if bypass is enabled AND we disabled them + if (current_render_reshade_before_ui != 0.f && !bypass_render_active) { + runtime->set_effects_state(true); + } +} + bool ExecuteReshadeEffects(reshade::api::command_list* cmd_list) { if (current_render_reshade_before_ui == 0.f) return true; if (!UsingSwapchainUtil()) return true; @@ -52,25 +164,404 @@ bool ExecuteReshadeEffects(reshade::api::command_list* cmd_list) { if (cmd_list_data == nullptr) return true; if (cmd_list_data->current_render_targets.empty()) return true; + // Get the ORIGINAL RTV from deferred lighting - do NOT use the clone here + // The clone is at swapchain resolution (e.g., 3840x2160) but we want to render + // ReShade effects at the pre-upscale resolution auto rtv0 = cmd_list_data->current_render_targets[0]; if (rtv0.handle == 0) return true; - if (UsingSwapchainUpgrade()) { - auto* info = renodx::utils::resource::GetResourceViewInfo(rtv0); - if (info->clone.handle != 0u) { - rtv0 = info->clone; - } - } - - auto* data = renodx::utils::data::Get(cmd_list->get_device()); + auto* device = cmd_list->get_device(); + auto* data = renodx::utils::data::Get(device); if (data == nullptr) return true; + + // Get the render target resolution + auto resource = device->get_resource_from_view(rtv0); + auto resource_desc = device->get_resource_desc(resource); + uint32_t rtv_width = resource_desc.texture.width; + uint32_t rtv_height = resource_desc.texture.height; + const std::shared_lock lock(data->mutex); for (auto* runtime : data->effect_runtimes) { + if (rtv_width != last_rtv_width || rtv_height != last_rtv_height) { +#ifdef DEBUG_LEVEL_0 + uint32_t swapchain_width = 0, swapchain_height = 0; + runtime->get_screenshot_width_and_height(&swapchain_width, &swapchain_height); + + std::stringstream ss; + ss << "[Endfield] ExecuteReshadeEffects: Rendering at RTV=" << rtv_width << "x" << rtv_height + << " (Swapchain=" << swapchain_width << "x" << swapchain_height << ")"; + reshade::log::message(reshade::log::level::info, ss.str().c_str()); +#endif + + last_rtv_width = rtv_width; + last_rtv_height = rtv_height; + } + + UpdateReshadeResolutionUniforms(runtime, rtv_width, rtv_height); + bypass_render_active = true; + runtime->set_effects_state(true); runtime->render_effects(cmd_list, rtv0, rtv0); + bypass_render_active = false; } return true; } +// Hotkey state tracking +bool ui_toggle_key_was_pressed = false; +int ui_toggle_hotkey = 0; +bool hotkey_input_active = false; + +// Heuristic tracking for UID UI +bool is_ping_input_candidate = false; +bool is_ping_drawn = false; +bool is_uid_input_candidate = false; +uint32_t draw_call_vertex_count = 0; // Track vertex count from draw calls (not draw_indexed) + +struct __declspec(uuid("019bf1c8-074a-7e13-b353-54ce3ceec3de")) VfxCommandListData { + reshade::api::resource_view pixel_srv_t0 = {0u}; +}; + +struct VfxBoostMatch { + uint32_t shader_crc; + uint32_t texture_crc; +}; + +constexpr VfxBoostMatch vfx_boost_matches[] = { + {0x97BF4335u, 0x512923BCu}, + {0x4D4DDEBEu, 0xFA6BD53Au}, + {0x50898C70u, 0x1A45F4EBu}, + {0x1BF3323Du, 0xF38B0BAAu}, +}; + +std::shared_mutex vfx_handle_mutex; +std::unordered_map vfx_handle_shaders; + +void OnInitVfxResource( + reshade::api::device* /*device*/, + const reshade::api::resource_desc& desc, + const reshade::api::subresource_data* initial_data, + reshade::api::resource_usage /*initial_state*/, + reshade::api::resource resource) { + if (resource.handle == 0u + || initial_data == nullptr + || initial_data->data == nullptr + || desc.type != reshade::api::resource_type::texture_2d + || desc.texture.format != reshade::api::format::bc7_unorm_srgb + || desc.texture.width != 256u + || desc.texture.height != 256u) { + return; + } + + const auto source_size = initial_data->slice_pitch != 0u + ? initial_data->slice_pitch + : reshade::api::format_slice_pitch( + desc.texture.format, + initial_data->row_pitch != 0u + ? initial_data->row_pitch + : reshade::api::format_row_pitch(desc.texture.format, desc.texture.width), + desc.texture.height); + if (source_size != 65536u) return; + + const auto texture_crc = renodx::utils::hash::ComputeCRC32( + static_cast(initial_data->data), source_size); + const auto match = std::ranges::find(vfx_boost_matches, texture_crc, &VfxBoostMatch::texture_crc); + if (match == std::end(vfx_boost_matches)) return; + + const std::lock_guard lock(vfx_handle_mutex); + vfx_handle_shaders[resource.handle] = match->shader_crc; +} + +void OnDestroyVfxResource(reshade::api::device* /*device*/, reshade::api::resource resource) { + const std::lock_guard lock(vfx_handle_mutex); + vfx_handle_shaders.erase(resource.handle); +} + +void OnInitVfxResourceView( + reshade::api::device* /*device*/, + reshade::api::resource resource, + reshade::api::resource_usage /*usage*/, + const reshade::api::resource_view_desc& /*desc*/, + reshade::api::resource_view view) { + const std::lock_guard lock(vfx_handle_mutex); + const auto match = vfx_handle_shaders.find(resource.handle); + if (match != vfx_handle_shaders.end()) { + vfx_handle_shaders[view.handle] = match->second; + } +} + +void OnDestroyVfxResourceView(reshade::api::device* /*device*/, reshade::api::resource_view view) { + const std::lock_guard lock(vfx_handle_mutex); + vfx_handle_shaders.erase(view.handle); +} + +void OnInitVfxCommandList(reshade::api::command_list* cmd_list) { + renodx::utils::data::Create(cmd_list); +} + +void OnDestroyVfxCommandList(reshade::api::command_list* cmd_list) { + renodx::utils::data::Delete(cmd_list); +} + +void OnResetVfxCommandList(reshade::api::command_list* cmd_list) { + auto* data = renodx::utils::data::Get(cmd_list); + if (data != nullptr) { + data->pixel_srv_t0 = {0u}; + } +} + +void OnPushVfxDescriptors( + reshade::api::command_list* cmd_list, + reshade::api::shader_stage stages, + reshade::api::pipeline_layout /*layout*/, + uint32_t layout_param, + const reshade::api::descriptor_table_update& update) { + if (layout_param != 1u + || update.type != reshade::api::descriptor_type::shader_resource_view + || update.binding != 0u + || update.count == 0u + || !renodx::utils::bitwise::HasFlag(stages, reshade::api::shader_stage::pixel)) { + return; + } + + auto* data = renodx::utils::data::Get(cmd_list); + if (data == nullptr) return; + data->pixel_srv_t0 = static_cast(update.descriptors)[0]; +} + +bool IsVisible(float value) { + return value >= 0.5f; +} + +reshade::api::rect IntersectRects(const reshade::api::rect& lhs, const reshade::api::rect& rhs) { + return { + .left = std::max(lhs.left, rhs.left), + .top = std::max(lhs.top, rhs.top), + .right = std::min(lhs.right, rhs.right), + .bottom = std::min(lhs.bottom, rhs.bottom), + }; +} + +bool DrawTextRegion( + reshade::api::command_list* cmd_list, + uint32_t index_count, + uint32_t instance_count, + uint32_t first_index, + int32_t vertex_offset, + uint32_t first_instance, + bool keep_latency_text) { + auto* current_state = renodx::utils::state::GetCurrentState(cmd_list); + if (current_state == nullptr || current_state->viewports.empty()) return false; + + const auto previous_state = *current_state; + const auto& viewport = current_state->viewports[0]; + const int32_t left = static_cast(viewport.x); + const int32_t top = static_cast(viewport.y); + const int32_t right = static_cast(viewport.x + viewport.width); + const int32_t bottom = static_cast(viewport.y + viewport.height); + if (right <= left || bottom <= top) return false; + + constexpr float kTextSplitFromHeight = 192.f / 2160.f; + const int32_t split_x = left + static_cast((bottom - top) * kTextSplitFromHeight + 0.5f); + reshade::api::rect clip_rect = keep_latency_text + ? reshade::api::rect{.left = left, .top = top, .right = split_x, .bottom = bottom} + : reshade::api::rect{.left = split_x, .top = top, .right = right, .bottom = bottom}; + + if (!current_state->scissor_rects.empty()) { + clip_rect = IntersectRects(clip_rect, current_state->scissor_rects[0]); + } + if (clip_rect.right <= clip_rect.left || clip_rect.bottom <= clip_rect.top) return true; + + cmd_list->bind_scissor_rects(0, 1, &clip_rect); + cmd_list->draw_indexed(index_count, instance_count, first_index, vertex_offset, first_instance); + previous_state.Apply(cmd_list); + return true; +} + +// on_draw callback for ping/latency bar shader (0xF1B0E28A) +bool OnPingDraw(reshade::api::command_list* cmd_list) { + if (is_ping_input_candidate) { + is_ping_drawn = true; + } else { + is_ping_drawn = false; + } + return true; +} + +bool OnUIDDraw(reshade::api::command_list* cmd_list) { + if (is_uid_input_candidate) { + if (!IsVisible(shader_injection.status_text_opacity) && + !IsVisible(shader_injection.latency_text_opacity)) { + return false; + } + } + return true; +} + +bool OnUiVisibilityDraw(reshade::api::command_list* cmd_list) { + return shader_injection.ui_visibility >= 0.5f; +} + +bool OnUidOrUiVisibilityDraw(reshade::api::command_list* cmd_list) { + if (shader_injection.ui_visibility < 0.5f) return false; + return OnUIDDraw(cmd_list); +} + +bool KeepOriginalShader(reshade::api::command_list* cmd_list) { + return false; +} + +void RestoreVFXBoostShader( + reshade::api::command_list* cmd_list, + renodx::utils::shader::CommandListData* shader_state) { + if (shader_state == nullptr) return; + + auto* pixel_state = renodx::utils::shader::GetCurrentPixelState(shader_state); + if (pixel_state->pipeline.handle == 0u) return; + cmd_list->bind_pipeline(pixel_state->applied_stage, pixel_state->pipeline); +} + +bool ReplaceVFXBoostShader(reshade::api::command_list* cmd_list) { + auto* shader_state = renodx::utils::shader::GetCurrentState(cmd_list); + if (shader_state == nullptr) return false; + if (shader_injection.perchannelblowout < 0.5f) { + RestoreVFXBoostShader(cmd_list, shader_state); + return false; + } + + auto* data = renodx::utils::data::Get(cmd_list); + if (data == nullptr || data->pixel_srv_t0.handle == 0u) { + RestoreVFXBoostShader(cmd_list, shader_state); + return false; + } + + const auto shader_crc = renodx::utils::shader::GetCurrentPixelShaderHash(shader_state); + const std::shared_lock lock(vfx_handle_mutex); + const auto match = vfx_handle_shaders.find(data->pixel_srv_t0.handle); + const bool should_replace = match != vfx_handle_shaders.end() && match->second == shader_crc; + if (!should_replace) { + RestoreVFXBoostShader(cmd_list, shader_state); + } + return should_replace; +} + +bool ReplaceImprovedGTAOShader(reshade::api::command_list* cmd_list) { + return shader_injection.improved_gtao >= 0.5f + || shader_injection.disable_game_ao >= 0.5f; +} + +bool ReplaceDisableGTAOShader(reshade::api::command_list* cmd_list) { + return shader_injection.disable_game_ao >= 0.5f; +} + +void RegisterUiVisibilityBypassShader(uint32_t crc) { + auto it = custom_shaders.find(crc); + if (it == custom_shaders.end()) { + renodx::mods::shader::CustomShader cs{}; + cs.crc32 = crc; + cs.on_draw = OnUiVisibilityDraw; + cs.on_replace = KeepOriginalShader; + custom_shaders.emplace(crc, std::move(cs)); + return; + } + + it->second.on_draw = OnUiVisibilityDraw; + it->second.on_replace = KeepOriginalShader; +} + +void RegisterUidBypassShader(uint32_t crc) { + auto it = custom_shaders.find(crc); + if (it == custom_shaders.end()) { + renodx::mods::shader::CustomShader cs{}; + cs.crc32 = crc; + cs.on_draw = OnUidOrUiVisibilityDraw; + cs.on_replace = KeepOriginalShader; + custom_shaders.emplace(crc, std::move(cs)); + return; + } + + it->second.on_draw = OnUidOrUiVisibilityDraw; + it->second.on_replace = KeepOriginalShader; +} + + +// Helper function to get key name from virtual key code +std::string GetKeyName(int keycode) { + if (keycode == 0 || keycode >= 256) return ""; + + static const char* keyboard_keys[256] = { + "", "Left Mouse", "Right Mouse", "Cancel", "Middle Mouse", "X1 Mouse", "X2 Mouse", "", "Backspace", "Tab", "", "", "Clear", "Enter", "", "", + "Shift", "Control", "Alt", "Pause", "Caps Lock", "", "", "", "", "", "", "Escape", "", "", "", "", + "Space", "Page Up", "Page Down", "End", "Home", "Left Arrow", "Up Arrow", "Right Arrow", "Down Arrow", "Select", "", "", "Print Screen", "Insert", "Delete", "Help", + "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "", "", "", "", "", "", + "", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", + "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "Left Windows", "Right Windows", "Apps", "", "Sleep", + "Numpad 0", "Numpad 1", "Numpad 2", "Numpad 3", "Numpad 4", "Numpad 5", "Numpad 6", "Numpad 7", "Numpad 8", "Numpad 9", "Numpad *", "Numpad +", "", "Numpad -", "Numpad Decimal", "Numpad /", + "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", + "F17", "F18", "F19", "F20", "F21", "F22", "F23", "F24", "", "", "", "", "", "", "", "", + "Num Lock", "Scroll Lock", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "Left Shift", "Right Shift", "Left Control", "Right Control", "Left Menu", "Right Menu", "Browser Back", "Browser Forward", "Browser Refresh", "Browser Stop", "Browser Search", "Browser Favorites", "Browser Home", "Volume Mute", "Volume Down", "Volume Up", + "Next Track", "Previous Track", "Media Stop", "Media Play/Pause", "Mail", "Media Select", "Launch App 1", "Launch App 2", "", "", "OEM ;", "OEM +", "OEM ,", "OEM -", "OEM .", "OEM /", + "OEM ~", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "OEM [", "OEM \\", "OEM ]", "OEM '", "OEM 8", + "", "", "OEM <", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "Attn", "CrSel", "ExSel", "Erase EOF", "Play", "Zoom", "", "PA1", "OEM Clear", "" + }; + + return keyboard_keys[keycode]; +} + +int GetLastKeyPressedImGui() { + + struct KeyMapping { + ImGuiKey imgui_key; + int vk_code; + }; + + static const KeyMapping kKeyMappings[] = { + // Function keys + {ImGuiKey_F1, VK_F1}, {ImGuiKey_F2, VK_F2}, {ImGuiKey_F3, VK_F3}, {ImGuiKey_F4, VK_F4}, + {ImGuiKey_F5, VK_F5}, {ImGuiKey_F6, VK_F6}, {ImGuiKey_F7, VK_F7}, {ImGuiKey_F8, VK_F8}, + {ImGuiKey_F9, VK_F9}, {ImGuiKey_F10, VK_F10}, {ImGuiKey_F11, VK_F11}, {ImGuiKey_F12, VK_F12}, + // Navigation keys + {ImGuiKey_Insert, VK_INSERT}, {ImGuiKey_Delete, VK_DELETE}, {ImGuiKey_Home, VK_HOME}, {ImGuiKey_End, VK_END}, + {ImGuiKey_PageUp, VK_PRIOR}, {ImGuiKey_PageDown, VK_NEXT}, + // Arrow keys + {ImGuiKey_LeftArrow, VK_LEFT}, {ImGuiKey_RightArrow, VK_RIGHT}, {ImGuiKey_UpArrow, VK_UP}, {ImGuiKey_DownArrow, VK_DOWN}, + // Special keys + {ImGuiKey_Backspace, VK_BACK}, {ImGuiKey_Space, VK_SPACE}, {ImGuiKey_Enter, VK_RETURN}, + {ImGuiKey_Escape, VK_ESCAPE}, {ImGuiKey_Tab, VK_TAB}, + {ImGuiKey_Pause, VK_PAUSE}, {ImGuiKey_ScrollLock, VK_SCROLL}, {ImGuiKey_PrintScreen, VK_SNAPSHOT}, + // Numpad + {ImGuiKey_Keypad0, VK_NUMPAD0}, {ImGuiKey_Keypad1, VK_NUMPAD1}, {ImGuiKey_Keypad2, VK_NUMPAD2}, + {ImGuiKey_Keypad3, VK_NUMPAD3}, {ImGuiKey_Keypad4, VK_NUMPAD4}, {ImGuiKey_Keypad5, VK_NUMPAD5}, + {ImGuiKey_Keypad6, VK_NUMPAD6}, {ImGuiKey_Keypad7, VK_NUMPAD7}, {ImGuiKey_Keypad8, VK_NUMPAD8}, + {ImGuiKey_Keypad9, VK_NUMPAD9}, {ImGuiKey_KeypadDecimal, VK_DECIMAL}, + {ImGuiKey_KeypadDivide, VK_DIVIDE}, {ImGuiKey_KeypadMultiply, VK_MULTIPLY}, + {ImGuiKey_KeypadSubtract, VK_SUBTRACT}, {ImGuiKey_KeypadAdd, VK_ADD}, {ImGuiKey_KeypadEnter, VK_RETURN}, + // Letters + {ImGuiKey_A, 'A'}, {ImGuiKey_B, 'B'}, {ImGuiKey_C, 'C'}, {ImGuiKey_D, 'D'}, {ImGuiKey_E, 'E'}, + {ImGuiKey_F, 'F'}, {ImGuiKey_G, 'G'}, {ImGuiKey_H, 'H'}, {ImGuiKey_I, 'I'}, {ImGuiKey_J, 'J'}, + {ImGuiKey_K, 'K'}, {ImGuiKey_L, 'L'}, {ImGuiKey_M, 'M'}, {ImGuiKey_N, 'N'}, {ImGuiKey_O, 'O'}, + {ImGuiKey_P, 'P'}, {ImGuiKey_Q, 'Q'}, {ImGuiKey_R, 'R'}, {ImGuiKey_S, 'S'}, {ImGuiKey_T, 'T'}, + {ImGuiKey_U, 'U'}, {ImGuiKey_V, 'V'}, {ImGuiKey_W, 'W'}, {ImGuiKey_X, 'X'}, {ImGuiKey_Y, 'Y'}, {ImGuiKey_Z, 'Z'}, + // Numbers + {ImGuiKey_0, '0'}, {ImGuiKey_1, '1'}, {ImGuiKey_2, '2'}, {ImGuiKey_3, '3'}, {ImGuiKey_4, '4'}, + {ImGuiKey_5, '5'}, {ImGuiKey_6, '6'}, {ImGuiKey_7, '7'}, {ImGuiKey_8, '8'}, {ImGuiKey_9, '9'}, + // Punctuation + {ImGuiKey_GraveAccent, VK_OEM_3}, {ImGuiKey_Minus, VK_OEM_MINUS}, {ImGuiKey_Equal, VK_OEM_PLUS}, + {ImGuiKey_LeftBracket, VK_OEM_4}, {ImGuiKey_RightBracket, VK_OEM_6}, {ImGuiKey_Backslash, VK_OEM_5}, + {ImGuiKey_Semicolon, VK_OEM_1}, {ImGuiKey_Apostrophe, VK_OEM_7}, + {ImGuiKey_Comma, VK_OEM_COMMA}, {ImGuiKey_Period, VK_OEM_PERIOD}, {ImGuiKey_Slash, VK_OEM_2}, + }; + + for (const auto& mapping : kKeyMappings) { + if (ImGui::IsKeyPressed(mapping.imgui_key, false)) { + return mapping.vk_code; + } + } + return 0; +} + renodx::utils::settings::Settings settings = { new renodx::utils::settings::Setting{ .key = "SettingsMode", @@ -90,7 +581,7 @@ renodx::utils::settings::Settings settings = { .can_reset = false, .label = "Tone Mapper", .section = "Tone Mapping", - .tooltip = "Sets the tone mapper type", + .tooltip = "Sets the tone mapper type. True Vanilla requires going back to the LOGIN MENU for all the changes to have an effect.", .labels = {"Vanilla", "RenoDRT"}, .is_visible = []() { return current_settings_mode >= 1; }, }, @@ -203,33 +694,30 @@ renodx::utils::settings::Settings settings = { .tooltip = "Hue retention strength.", .min = 0.f, .max = 100.f, - .is_enabled = []() { return shader_injection.tone_map_type >= 1; }, .parse = [](float value) { return value * 0.01f; }, .is_visible = []() { return false;}, }, new renodx::utils::settings::Setting{ .key = "ToneMapHueShift", .binding = &shader_injection.tone_map_hue_shift, - .default_value = 100.f, + .default_value = 85.f, .label = "Hue Shift", .section = "Tone Mapping", .tooltip = "Hue-shift emulation strength.", .min = 0.f, .max = 100.f, - .is_enabled = []() { return shader_injection.tone_map_type >= 1; }, .parse = [](float value) { return value * 0.01f; }, .is_visible = []() { return current_settings_mode >= 1; }, }, new renodx::utils::settings::Setting{ .key = "ToneMapPerChannelBlowout", .binding = &shader_injection.tone_map_blowout, - .default_value = 50.f, + .default_value = 75.f, .label = "Per Channel Blowout", .section = "Tone Mapping", .tooltip = "Per Channel Blowout strength.", .min = 0.f, .max = 100.f, - .is_enabled = []() { return shader_injection.tone_map_type >= 1; }, .parse = [](float value) { return value * 0.01f; }, .is_visible = []() { return current_settings_mode >= 1; }, }, @@ -360,14 +848,24 @@ renodx::utils::settings::Settings settings = { .tooltip = "Toggle UID text visibility", .labels = {"Hidden", "Visible"}, }, - new renodx::utils::settings::Setting{ + new renodx::utils::settings::Setting{ + .key = "UIOpacityLatencyText", + .binding = &shader_injection.latency_text_opacity, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 0.f, + .label = "Latency Text", + .section = "User Interface & Video", + .tooltip = "Toggle latency text visibility", + .labels = {"Hidden", "Visible"}, + }, + new renodx::utils::settings::Setting{ .key = "UIOpacityPingText", .binding = &shader_injection.ping_text_opacity, .value_type = renodx::utils::settings::SettingValueType::INTEGER, .default_value = 0.f, - .label = "Ping Text", + .label = "Latency Bar", .section = "User Interface & Video", - .tooltip = "Toggle ping text visibility", + .tooltip = "Toggle latency bar visibility", .labels = {"Hidden", "Visible"}, }, new renodx::utils::settings::Setting{ @@ -377,9 +875,71 @@ renodx::utils::settings::Settings settings = { .default_value = 1.f, .label = "UI Visibility", .section = "User Interface & Video", - .tooltip = "Toggle UI visibility for screenshots", + .tooltip = "Toggle UI visibility for screenshots (use hotkey for quick toggle)", .labels = {"Hidden", "Visible"}, }, + new renodx::utils::settings::Setting{ + .key = "UIVisibilityHotkey", + .value_type = renodx::utils::settings::SettingValueType::CUSTOM, + .default_value = 0.f, + .label = "UI Toggle Hotkey", + .section = "User Interface & Video", + .tooltip = "Click in the field and press any key to set the hotkey, or press Backspace/Delete to clear", + .on_draw = []() { + static bool key_was_pressed = false; + bool changed = false; + + // Get current key name for display + std::string key_name = ui_toggle_hotkey != 0 ? GetKeyName(ui_toggle_hotkey) : ""; + char buf[64] = {0}; + if (!key_name.empty()) { + size_t copy_len = (key_name.size() < sizeof(buf) - 1) ? key_name.size() : sizeof(buf) - 1; + memcpy(buf, key_name.c_str(), copy_len); + } + + // Create the input text widget + ImGui::InputTextWithHint( + "UI Toggle Hotkey", + "Click to set keyboard shortcut", + buf, + sizeof(buf), + ImGuiInputTextFlags_ReadOnly | ImGuiInputTextFlags_NoUndoRedo | ImGuiInputTextFlags_NoHorizontalScroll + ); + + // Check if widget is active and capture key presses + if (ImGui::IsItemActive()) { + hotkey_input_active = true; + int key_pressed = GetLastKeyPressedImGui(); + + if (key_pressed != 0 && !key_was_pressed) { + if (key_pressed == VK_BACK || key_pressed == VK_DELETE) { + ui_toggle_hotkey = 0; + changed = true; + } else if (key_pressed != VK_ESCAPE) { + ui_toggle_hotkey = key_pressed; + changed = true; + } + + if (changed) { + reshade::set_config_value(nullptr, renodx::utils::settings::global_name.c_str(), "UIVisibilityHotkey", ui_toggle_hotkey); + } + key_was_pressed = true; + } else if (key_pressed == 0) { + key_was_pressed = false; + } + } else { + hotkey_input_active = false; + key_was_pressed = false; + } + + if (ImGui::IsItemHovered(ImGuiHoveredFlags_ForTooltip)) { + ImGui::SetTooltip("Click and press any key to set hotkey.\nPress Backspace or Delete to clear."); + } + + return changed; + }, + .is_global = true, + }, new renodx::utils::settings::Setting{ .key = "VideoAutoHDR", .binding = &shader_injection.tone_map_hdr_video, @@ -440,6 +1000,17 @@ renodx::utils::settings::Settings settings = { .max = 100.f, .parse = [](float value) { return value * 0.01f; }, }, + new renodx::utils::settings::Setting{ + .key = "ChromaticAberrationStrength", + .binding = &shader_injection.chromatic_aberration_strength, + .default_value = 50.f, + .label = "Chromatic Aberration", + .section = "Effects", + .tooltip = "Controls the intensity of chromatic aberration effect.", + .min = 0.f, + .max = 100.f, + .parse = [](float value) { return value * 0.01f; }, + }, new renodx::utils::settings::Setting{ .key = "BloomStrength", .binding = &shader_injection.bloom_strength, @@ -451,6 +1022,16 @@ renodx::utils::settings::Settings settings = { .tooltip = "Adjusts the intensity of bloom effects.", .min = 0.f, .max = 100.f, + }, + new renodx::utils::settings::Setting{ + .value_type = renodx::utils::settings::SettingValueType::CUSTOM, + .label = std::string("Reshade shader bypass, applies on_drawn after game's deferred lighting pass. Only properly works with DLAA/TAAU 100 scaling atm"), + .on_draw = []() { + ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 0.0f, 0.0f, 1.0f)); + ImGui::TextWrapped("Reshade shader bypass, applies on_drawn after game's deferred lighting pass. Only properly works with DLAA/TAAU 100 scaling atm"); + ImGui::PopStyleColor(); + return false; + }, }, new renodx::utils::settings::Setting{ .key = "RenderReshadeBeforeUI", @@ -462,6 +1043,26 @@ renodx::utils::settings::Settings settings = { .tooltip = "Executes ReShade effects before UI is drawn.", .labels = {"Off", "On"}, }, + new renodx::utils::settings::Setting{ + .key = "DisableGameAO", + .binding = &shader_injection.disable_game_ao, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 0.f, + .label = "Disable Game GTAO", + .section = "Effects", + .tooltip = "Disables the game's built-in GTAO (Ground Truth Ambient Occlusion).\nUseful when using ReShade-based AO instead.", + .labels = {"Off", "On"}, + }, + new renodx::utils::settings::Setting{ + .key = "VFXBoost", + .binding = &shader_injection.perchannelblowout, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 0.f, + .label = "VFX Boost (Experimental)", + .section = "Rendering Improvements", + .tooltip = "Boosts the luminance of supported VFX shaders for brighter highlights.\nExperimental: this may have unintended effects.", + .labels = {"Original", "Enhanced"}, + }, new renodx::utils::settings::Setting{ .key = "HDRSun", .binding = &shader_injection.sun_intensity, @@ -483,8 +1084,8 @@ renodx::utils::settings::Settings settings = { .labels = {"Off", "Vanilla", "2x", "3x"}, }, new renodx::utils::settings::Setting{ - .key = "AO_INTENSITY", - .binding = &shader_injection.ao_intensity, + .key = "SHADOW_HARDENING", + .binding = &shader_injection.shadow_hardening, .value_type = renodx::utils::settings::SettingValueType::INTEGER, .default_value = 1.f, .label = "Improved Shadows", @@ -493,6 +1094,71 @@ renodx::utils::settings::Settings settings = { .labels = {"Off", "On"}, .is_visible = []() { return current_settings_mode >= 1; }, }, + new renodx::utils::settings::Setting{ + .key = "FAKE_CLOUD_SHADOWS", + .binding = &shader_injection.fake_cloud_shadows, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 1.f, + .label = "Vanilla Fake Cloud Shadows", + .section = "Rendering Improvements", + .tooltip = "Toggles fake cloud shadows", + .labels = {"Off", "On / Vanilla"}, + .is_visible = []() { return current_settings_mode >= 1; }, + }, + new renodx::utils::settings::Setting{ + .key = "FogModification", + .binding = &shader_injection.fog_modification, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 0.f, + .label = "Hue-Preserving Fog", + .section = "Rendering Improvements", + .tooltip = "Toggles alternative hue-preserving fog", + .labels = {"Original", "Alt"}, + }, + new renodx::utils::settings::Setting{ + .key = "CubemapAmbientLink", + .binding = &shader_injection.cubemap_ambient_link, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 1.f, + .label = "Cubemap Ambient Link", + .section = "Rendering Improvements", + .tooltip = "Modulates cubemap reflections by ambient luminance", + .labels = {"Off", "On"}, + }, + new renodx::utils::settings::Setting{ + .key = "GlassTransparency", + .binding = &shader_injection.glass_transparency, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 1.f, + .label = "Glass Transparency", + .section = "Rendering Improvements", + .tooltip = "Improves glass rendering to look more transparent and less cloudy/glowing", + .labels = {"Vanilla", "Improved"}, + }, + new renodx::utils::settings::Setting{ + .key = "ImprovedSSR", + .binding = &shader_injection.improved_ssr, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 1.f, + .label = "SSR Quality", + .section = "Rendering Improvements", + .tooltip = "Controls the game's SSR denoiser behavior.\n" + "Vanilla: Original denoiser.\n" + "Improved: Sharper reflections on smooth surfaces (metals, glass)\n" + " while retaining proper diffusion on rough surfaces (wood, stone).\n" + " Temporal smoothing is preserved to minimize firefly artifacts.", + .labels = {"Vanilla", "Improved"}, + }, + new renodx::utils::settings::Setting{ + .key = "ImprovedGTAO", + .binding = &shader_injection.improved_gtao, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 1.f, + .label = "GTAO + Visibility Bitmask + Deferred AO Modulation", + .section = "Rendering Improvements", + .tooltip = "Improves vanilla GTAO with visibility bitmask and AO modulation on direct lights (spotlights, point lights).", + .labels = {"Original", "Improved"}, + }, new renodx::utils::settings::Setting{ .key = "SwapChainCustomColorSpace", .binding = &shader_injection.swap_chain_custom_color_space, @@ -514,6 +1180,20 @@ renodx::utils::settings::Settings settings = { }, .is_visible = []() { return settings[0]->GetValue() >= 1; }, }, + new renodx::utils::settings::Setting{ + .key = "SwapChainEncoding", + .binding = &shader_injection.swap_chain_encoding, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 4.f, + .label = "Encoding", + .section = "Display Output", + .labels = {"None", "SRGB", "2.2", "2.4", "HDR10", "scRGB"}, + .on_change_value = [](float previous, float current) { + ApplySwapChainEncodingTarget(current); + }, + .is_global = true, + .is_visible = []() { return current_settings_mode >= 1; }, + }, new renodx::utils::settings::Setting{ .key = "IntermediateDecoding", .binding = &shader_injection.intermediate_encoding, @@ -554,6 +1234,19 @@ renodx::utils::settings::Settings settings = { .parse = [](float value) { return value - 1.f; }, .is_visible = []() { return false; }, }, + new renodx::utils::settings::Setting{ + .key = "TechTestLook", + .binding = &shader_injection.tech_test_look, + .value_type = renodx::utils::settings::SettingValueType::INTEGER, + .default_value = 0.f, + .label = "Tech Test Look", + .section = "Alternative Grading", + .tooltip = "Activates visual adjustments to match the 2024 tech test aesthetic", + .labels = {"Off", "On"}, + .on_change_value = [](float previous, float current) { + if (current >= 1.f) pending_tech_test_preset = 1; + }, + }, new renodx::utils::settings::Setting{ .value_type = renodx::utils::settings::SettingValueType::BUTTON, .label = "Discord", @@ -576,12 +1269,17 @@ renodx::utils::settings::Settings settings = { }, new renodx::utils::settings::Setting{ .value_type = renodx::utils::settings::SettingValueType::TEXT, - .label = "- Addon maintained by Spiwar & Forge.", + .label = "- Addon developed by Spiwar & Forge.", + .section = "About", + }, + new renodx::utils::settings::Setting{ + .value_type = renodx::utils::settings::SettingValueType::TEXT, + .label = "- Maintained by Rat for Arknights: Endfield 1.4.4", .section = "About", }, new renodx::utils::settings::Setting{ .value_type = renodx::utils::settings::SettingValueType::TEXT, - .label = "- Made for Arknights: Endfield 1.0", + .label = std::string("- Special thanks to both Musa & Miru for helping with the addon"), .section = "About", }, new renodx::utils::settings::Setting{ @@ -597,11 +1295,22 @@ renodx::utils::settings::Settings settings = { }; void OnPresetOff() { - // renodx::utils::settings::UpdateSetting("toneMapType", 0.f); - // renodx::utils::settings::UpdateSetting("toneMapPeakNits", 203.f); - // renodx::utils::settings::UpdateSetting("toneMapGameNits", 203.f); - // renodx::utils::settings::UpdateSetting("toneMapUINits", 203.f); - // renodx::utils::settings::UpdateSetting("toneMapGammaCorrection", 0); + renodx::utils::settings::UpdateSetting("ToneMapType", 0.f); + renodx::utils::settings::UpdateSetting("ToneMapPeakNits", 203.f); + renodx::utils::settings::UpdateSetting("ToneMapGameNits", 203.f); + renodx::utils::settings::UpdateSetting("ToneMapUINits", 203.f); + renodx::utils::settings::UpdateSetting("ToneMapGammaCorrection", 1.f); + renodx::utils::settings::UpdateSetting("GammaCorrection", 1.f); + renodx::utils::settings::UpdateSetting("SwapChainGammaCorrection", 1.f); + renodx::utils::settings::UpdateSetting("HDRSun", 0.f); + renodx::utils::settings::UpdateSetting("Godrays", 1.f); + renodx::utils::settings::UpdateSetting("SHADOW_HARDENING", 0.f); + renodx::utils::settings::UpdateSetting("FogModification", 0.f); + renodx::utils::settings::UpdateSetting("CubemapAmbientLink", 0.f); + renodx::utils::settings::UpdateSetting("GlassTransparency", 0.f); + renodx::utils::settings::UpdateSetting("ImprovedSSR", 0.f); + renodx::utils::settings::UpdateSetting("ImprovedGTAO", 0.f); + renodx::utils::settings::UpdateSetting("TechTestLook", 0.f); // renodx::utils::settings::UpdateSetting("colorGradeExposure", 1.f); // renodx::utils::settings::UpdateSetting("colorGradeHighlights", 50.f); // renodx::utils::settings::UpdateSetting("colorGradeShadows", 50.f); @@ -611,6 +1320,104 @@ void OnPresetOff() { // renodx::utils::settings::UpdateSetting("colorGradeLUTScaling", 0.f); } +// OnDraw handler to track vertex count from draw calls +bool OnDraw( + reshade::api::command_list* cmd_list, + uint32_t vertex_count, + uint32_t instance_count, + uint32_t first_vertex, + uint32_t first_instance) { + draw_call_vertex_count = vertex_count; + shader_injection.latency_bar_draw_opacity = 1.f; + return false; +} + +// OnDrawIndexed event handler for heuristic-based ping/UID detection +bool OnDrawIndexed( + reshade::api::command_list* cmd_list, + uint32_t index_count, + uint32_t instance_count, + uint32_t first_index, + int32_t vertex_offset, + uint32_t first_instance) { + auto* shader_state = renodx::utils::shader::GetCurrentState(cmd_list); + const uint32_t vertex_shader_hash = shader_state != nullptr + ? renodx::utils::shader::GetCurrentVertexShaderHash(shader_state) + : 0u; + const uint32_t pixel_shader_hash = shader_state != nullptr + ? renodx::utils::shader::GetCurrentPixelShaderHash(shader_state) + : 0u; + + if (!IsVisible(shader_injection.ui_visibility) + && (vertex_shader_hash == 0x1529ADE6u || pixel_shader_hash == 0x1529ADE6u + || vertex_shader_hash == 0xEB8D2859u || pixel_shader_hash == 0xEB8D2859u)) { + draw_call_vertex_count = 0; + return true; + } + + // Constants for ping/latency bar detection + constexpr uint32_t PING_INDEX_COUNT = 18; + constexpr uint32_t PING_FIRST_INDEX = 0; + constexpr int32_t PING_VERTEX_OFFSET = 0; + constexpr uint32_t PING_VERTEX_SHADER_HASH = 0xF4EF16E9u; + constexpr uint32_t PING_PIXEL_SHADER_HASH = 0xF1B0E28Au; + + // Detect ping/latency bar + const bool ping_geometry_candidate = (index_count == PING_INDEX_COUNT) && + (first_index == PING_FIRST_INDEX) && + (vertex_offset == PING_VERTEX_OFFSET); + const bool latency_bar_draw_candidate = ping_geometry_candidate && + (vertex_shader_hash == PING_VERTEX_SHADER_HASH) && + (pixel_shader_hash == PING_PIXEL_SHADER_HASH); + is_ping_input_candidate = latency_bar_draw_candidate && (draw_call_vertex_count == 0); + shader_injection.latency_bar_draw_opacity = latency_bar_draw_candidate + ? shader_injection.ping_text_opacity + : 1.f; + + if (latency_bar_draw_candidate) { + if (is_ping_input_candidate) { + is_ping_drawn = true; + } + draw_call_vertex_count = 0; + return !IsVisible(shader_injection.ping_text_opacity); + } + + // Constants for UID text detection + constexpr uint32_t UID_FIRST_INDEX = 18; + constexpr uint32_t UID_MIN_INDEX_COUNT = 100; + constexpr int32_t UID_VERTEX_OFFSET = 12; + + // Detect UID text after the ping or post-combat shader + const bool uid_geometry_candidate = (first_index == UID_FIRST_INDEX) && + (index_count > UID_MIN_INDEX_COUNT) && + (vertex_offset == UID_VERTEX_OFFSET); + const bool uid_shader_candidate = pixel_shader_hash == 0xC2B8AB6Bu; + is_uid_input_candidate = uid_geometry_candidate && (is_ping_drawn || uid_shader_candidate); + + // Reset vertex count after processing + draw_call_vertex_count = 0; + + if (!is_uid_input_candidate) { + return false; + } + if (!IsVisible(shader_injection.ui_visibility)) return true; + + const bool show_uid_text = IsVisible(shader_injection.status_text_opacity); + const bool show_latency_text = IsVisible(shader_injection.latency_text_opacity); + if (show_uid_text && show_latency_text) return false; + if (!show_uid_text && !show_latency_text) return true; + + DrawTextRegion( + cmd_list, + index_count, + instance_count, + first_index, + vertex_offset, + first_instance, + show_latency_text); + return true; +} + void OnPresent(reshade::api::command_queue* queue, reshade::api::swapchain* swapchain, const reshade::api::rect* source_rect, @@ -622,6 +1429,52 @@ void OnPresent(reshade::api::command_queue* queue, shader_injection.custom_flip_uv_y = 1.f; } + // Compute UI aspect ratio from swapchain for dynamic latency bar detection + auto bb = device->get_resource_desc(swapchain->get_current_back_buffer()); + if (bb.type != reshade::api::resource_type::unknown) { + shader_injection.ui_aspect_ratio = static_cast(bb.texture.height) / static_cast(bb.texture.width); + } + + // Reset heuristic tracking flags for ping/UID detection + is_ping_input_candidate = false; + is_uid_input_candidate = false; + is_ping_drawn = false; + draw_call_vertex_count = 0; + shader_injection.latency_bar_draw_opacity = 1.f; + + // Detect Tech Test state changes from preset loads, game startup, or manual toggle + float current_tech_test = shader_injection.tech_test_look; + if (current_tech_test != prev_tech_test_look) { + if (current_tech_test >= 1.f) pending_tech_test_preset = 1; + prev_tech_test_look = current_tech_test; + } + + // Apply deferred Tech Test preset (safe context, outside settings callback) + if (pending_tech_test_preset == 1) { + renodx::utils::settings::UpdateSetting("GammaCorrection", 2.f); + renodx::utils::settings::UpdateSetting("SwapChainGammaCorrection", 2.f); + renodx::utils::settings::UpdateSetting("ToneMapPerChannelBlowout", 75.f); + renodx::utils::settings::UpdateSetting("ColorGradeExposure", 0.75f); + renodx::utils::settings::UpdateSetting("ColorGradeHighlights", 50.f); + renodx::utils::settings::UpdateSetting("ColorGradeShadows", 80.f); + renodx::utils::settings::UpdateSetting("ColorGradeContrast", 55.f); + renodx::utils::settings::UpdateSetting("ColorGradeSaturation", 35.f); + renodx::utils::settings::UpdateSetting("ColorGradeHighlightSaturation", 100.f); + renodx::utils::settings::UpdateSetting("ColorGradeBlowout", 30.f); + pending_tech_test_preset = -1; + } + + // Check UI visibility hotkey (skip if user is currently setting a new hotkey) + if (ui_toggle_hotkey != 0 && !hotkey_input_active) { + bool key_down = (GetAsyncKeyState(ui_toggle_hotkey) & 0x8000) != 0; + if (key_down && !ui_toggle_key_was_pressed) { + // Toggle UI visibility + shader_injection.ui_visibility = (shader_injection.ui_visibility == 0.f) ? 1.f : 0.f; + // Update the setting value to keep UI in sync + renodx::utils::settings::UpdateSetting("UIVisibility", shader_injection.ui_visibility); + } + ui_toggle_key_was_pressed = key_down; + } } bool initialized = false; @@ -641,7 +1494,6 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) { renodx::mods::shader::expected_constant_buffer_space = 50; renodx::mods::shader::expected_constant_buffer_index = 13; renodx::mods::shader::allow_multiple_push_constants = true; - renodx::mods::swapchain::expected_constant_buffer_index = 13; renodx::mods::swapchain::expected_constant_buffer_space = 50; renodx::mods::swapchain::use_resource_cloning = true; @@ -704,30 +1556,11 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) { settings.push_back(setting); } + // Initialize SwapChainEncoding-related settings { - auto* setting = new renodx::utils::settings::Setting{ - .key = "SwapChainEncoding", - .binding = &shader_injection.swap_chain_encoding, - .value_type = renodx::utils::settings::SettingValueType::INTEGER, - .default_value = 4.f, - .label = "Encoding", - .section = "Display Output", - .labels = {"None", "SRGB", "2.2", "2.4", "HDR10", "scRGB"}, - .is_enabled = []() { return shader_injection.tone_map_type >= 1; }, - .on_change_value = [](float previous, float current) { - bool is_hdr10 = current == 4; - shader_injection.swap_chain_encoding_color_space = (is_hdr10 ? 1.f : 0.f); - // return void - }, - .is_global = true, - .is_visible = []() { return false; }, - }; - renodx::utils::settings::LoadSetting(renodx::utils::settings::global_name, setting); - bool is_hdr10 = setting->GetValue() == 4; - renodx::mods::swapchain::SetUseHDR10(is_hdr10); - renodx::mods::swapchain::use_resize_buffer = setting->GetValue() < 4; - shader_injection.swap_chain_encoding_color_space = is_hdr10 ? 1.f : 0.f; - settings.push_back(setting); + float encoding_value = 4.f; // default + reshade::get_config_value(nullptr, renodx::utils::settings::global_name.c_str(), "SwapChainEncoding", encoding_value); + ApplySwapChainEncodingTarget(encoding_value); } { @@ -745,14 +1578,25 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) { bool use_device_proxy = setting->GetValue() == 1.f; renodx::mods::swapchain::use_device_proxy = use_device_proxy; renodx::mods::swapchain::set_color_space = !use_device_proxy; - if (use_device_proxy) { - reshade::register_event(OnPresent); - } else { + if (!use_device_proxy) { shader_injection.custom_flip_uv_y = 0.f; } + reshade::register_event(OnPresent); + // Register callbacks to ALWAYS disable ReShade during normal present + // This ensures ReShade only ever renders at internal resolution via bypass + reshade::register_event(OnReshadeBeginEffects); + reshade::register_event(OnReshadeFinishEffects); settings.push_back(setting); } + // Load UI visibility hotkey from saved config + { + int saved_hotkey = 0; + if (reshade::get_config_value(nullptr, renodx::utils::settings::global_name.c_str(), "UIVisibilityHotkey", saved_hotkey)) { + ui_toggle_hotkey = saved_hotkey; + } + } + { auto* setting = new renodx::utils::settings::Setting{ .key = "SwapChainDeviceProxyBaseWaitIdle", @@ -789,73 +1633,144 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) { renodx::mods::swapchain::swap_chain_upgrade_targets.push_back({ - .old_format = reshade::api::format::r8g8b8a8_typeless, - .new_format = reshade::api::format::r16g16b16a16_float, - .ignore_size = false, - .use_resource_view_cloning = true, - .aspect_ratio = static_cast(renodx::mods::swapchain::SwapChainUpgradeTarget::BACK_BUFFER), - .usage_include = reshade::api::resource_usage::render_target, + .old_format = reshade::api::format::r8g8b8a8_typeless, + .new_format = reshade::api::format::r16g16b16a16_float, + .ignore_size = false, + //.use_resource_view_cloning = true, + .aspect_ratio = static_cast(renodx::mods::swapchain::SwapChainUpgradeTarget::BACK_BUFFER), + .aspect_ratio_tolerance = 0.02f, + .usage_include = reshade::api::resource_usage::render_target, }); + // Need aspect ratio upgrade or grass will be broken renodx::mods::swapchain::swap_chain_upgrade_targets.push_back({ .old_format = reshade::api::format::r8g8b8a8_unorm, .new_format = reshade::api::format::r16g16b16a16_float, .ignore_size = false, - .use_resource_view_cloning = true, + //.use_resource_view_cloning = true, .aspect_ratio = static_cast(renodx::mods::swapchain::SwapChainUpgradeTarget::BACK_BUFFER), + .aspect_ratio_tolerance = 0.02f, .usage_include = reshade::api::resource_usage::render_target, }); + /* renodx::mods::swapchain::swap_chain_upgrade_targets.push_back({ .old_format = reshade::api::format::r10g10b10a2_unorm, .new_format = reshade::api::format::r16g16b16a16_float, .ignore_size = false, - .use_resource_view_cloning = true, + //.use_resource_view_cloning = true, .aspect_ratio = static_cast(renodx::mods::swapchain::SwapChainUpgradeTarget::BACK_BUFFER), + .aspect_ratio_tolerance = 0.02f, .usage_include = reshade::api::resource_usage::render_target, }); - + */ + // Grass/foliage deferred shaders for ReShade AO const uint32_t target_crcs[] = { - 0x00C16AFBu, - 0x039C28DAu, - 0x086097D2u, - 0x09270FDAu, - 0x0E520F06u, - 0x10076711u, - 0x21241B7Au, - 0x51359B4Du, - 0x53875523u, - 0x53D50BD5u, - 0x57737D9Fu, - 0x5FC0BD3Cu, - 0x6166487Au, - 0x61908D50u, - 0x64CEB255u, - 0x6A76C719u, - 0x86420EBCu, - 0x9790A50Cu, - 0x9AA3FC1Fu, - 0xA6501734u, - 0xA6E6ABE6u, - 0xA8213A68u, - 0xAFDCA263u, - 0xAFECA8F4u, - 0xBCD91195u, - 0xD5BC74ACu, - 0xE0058043u, - 0xF8FA587Fu, + 0x4BF704A4u, + 0xEFA7F46Fu, + 0x66F41E33u, + 0x7F533976u, + 0x82083D15u, + 0xACD57C4Du, + 0xC181EA40u, + 0xEE78E1BAu, }; for (uint32_t crc : target_crcs) { - if (custom_shaders.find(crc) != custom_shaders.end()) { - custom_shaders[crc].on_drawn = ExecuteReshadeEffects; + // Ensure an entry exists for the shader hash even if we don't have compiled HLSL + auto it = custom_shaders.find(crc); + if (it == custom_shaders.end()) { + renodx::mods::shader::CustomShader cs{}; + cs.crc32 = crc; + cs.on_drawn = ExecuteReshadeEffects; + custom_shaders.emplace(crc, std::move(cs)); + } else { + it->second.on_drawn = ExecuteReshadeEffects; + } + } + + for (const auto& match : vfx_boost_matches) { + auto it = custom_shaders.find(match.shader_crc); + if (it != custom_shaders.end()) { + it->second.on_replace = ReplaceVFXBoostShader; + } + } + + // Improved GTAO shaders + const uint32_t improved_gtao_crcs[] = { + 0x43A0000Bu, + 0xDD16F0F8u, + }; + for (uint32_t crc : improved_gtao_crcs) { + auto it = custom_shaders.find(crc); + if (it != custom_shaders.end()) { + it->second.on_replace = ReplaceImprovedGTAOShader; + } + } + + { + auto it = custom_shaders.find(0xA683B186u); + if (it != custom_shaders.end()) { + it->second.on_replace = ReplaceDisableGTAOShader; + } + } + + // UI visibility shaders + const uint32_t ui_visibility_bypass_crcs[] = { + 0xD98315D9u, + 0x7B466CC5u, + 0x483894D1u, + 0xB7010B10u, + 0xC954C30Bu, + 0xE4D1754Au, + 0xFB0D02ADu, + 0x3A8D5F08u, + 0xF16C9B1Fu, + 0xD4922925u, + 0x0FB686BDu, + }; + for (uint32_t crc : ui_visibility_bypass_crcs) { + RegisterUiVisibilityBypassShader(crc); + } + + // Post-combat UID shader + RegisterUidBypassShader(0xC2B8AB6Bu); + + // Ping/latency bar shader + { + auto it = custom_shaders.find(0xF1B0E28Au); + if (it != custom_shaders.end()) { + it->second.on_draw = OnPingDraw; } } + // Register draw and draw_indexed events for heuristic ping/UID detection + reshade::register_event(OnInitVfxCommandList); + reshade::register_event(OnResetVfxCommandList); + reshade::register_event(OnDestroyVfxCommandList); + reshade::register_event(OnInitVfxResource); + reshade::register_event(OnDestroyVfxResource); + reshade::register_event(OnInitVfxResourceView); + reshade::register_event(OnDestroyVfxResourceView); + reshade::register_event(OnPushVfxDescriptors); + reshade::register_event(OnDraw); + reshade::register_event(OnDrawIndexed); initialized = true; } break; case DLL_PROCESS_DETACH: + reshade::unregister_event(OnInitVfxCommandList); + reshade::unregister_event(OnResetVfxCommandList); + reshade::unregister_event(OnDestroyVfxCommandList); + reshade::unregister_event(OnInitVfxResource); + reshade::unregister_event(OnDestroyVfxResource); + reshade::unregister_event(OnInitVfxResourceView); + reshade::unregister_event(OnDestroyVfxResourceView); + reshade::unregister_event(OnPushVfxDescriptors); + reshade::unregister_event(OnDraw); + reshade::unregister_event(OnDrawIndexed); reshade::unregister_event(OnPresent); + reshade::unregister_event(OnReshadeBeginEffects); + reshade::unregister_event(OnReshadeFinishEffects); reshade::unregister_addon(h_module); break; } @@ -863,6 +1778,7 @@ BOOL APIENTRY DllMain(HMODULE h_module, DWORD fdw_reason, LPVOID lpv_reserved) { renodx::utils::settings::Use(fdw_reason, &settings, &OnPresetOff); renodx::mods::swapchain::Use(fdw_reason, &shader_injection); renodx::mods::shader::Use(fdw_reason, custom_shaders, &shader_injection); + renodx::utils::state::Use(fdw_reason); renodx::utils::random::binds.push_back(&shader_injection.custom_random); renodx::utils::random::Use(fdw_reason); diff --git a/src/games/endfield/ao/0xB4CAAAA7.cso b/src/games/endfield/ao/0xB4CAAAA7.cso new file mode 100644 index 0000000000..4516c1885c Binary files /dev/null and b/src/games/endfield/ao/0xB4CAAAA7.cso differ diff --git a/src/games/endfield/ao/gtao-main_0x43A0000B.cs_5_0.hlsl b/src/games/endfield/ao/gtao-main_0x43A0000B.cs_5_0.hlsl new file mode 100644 index 0000000000..252e8abfc5 --- /dev/null +++ b/src/games/endfield/ao/gtao-main_0x43A0000B.cs_5_0.hlsl @@ -0,0 +1,449 @@ +// ---- Created with 3Dmigoto v1.4.1 on Tue Feb 10 15:11:49 2026 +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[5]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[16]; +} + + +#include "../shared.h" + +#define cmp - + +// --- Visibility Bitmask helpers (XeGTAO) --- +static const float BM_HALF_PI = 1.5707963267948966; +static const float BM_PI = 3.1415926535897932; +static const float BM_NUM_BITS = 32.0; + +float BM_FastSqrt(float x) { + return asfloat(0x1fbd1df5 + (asint(x) >> 1)); +} + +float BM_FastACos(float inX) { + float x = abs(inX); + float res = -0.156583 * x + BM_HALF_PI; + res *= BM_FastSqrt(1.0 - x); + return (inX >= 0) ? res : BM_PI - res; +} + +uint BM_UpdateSectors(float minHorizon, float maxHorizon, uint bm) { + int startBit = (int)(minHorizon * BM_NUM_BITS); + int numBits = max((int)(round((maxHorizon - minHorizon) * BM_NUM_BITS)), 0); + startBit = clamp(startBit, 0, 31); + numBits = clamp(numBits, 0, 32 - startBit); + if (numBits > 0) { + uint mask = ((1u << (uint)numBits) - 1u) << (uint)startBit; + bm |= mask; + } + return bm; +} + +void BM_ProcessSample(float3 deltaPos, float3 viewVec, float samplingDir, float n, float thickness, inout uint bm) { + float3 deltaPosBack = deltaPos - viewVec * thickness; + float2 frontBackH = float2( + BM_FastACos(dot(normalize(deltaPos), viewVec)), + BM_FastACos(dot(normalize(deltaPosBack), viewVec)) + ); + float2 N = float2(n, n); + frontBackH = saturate((samplingDir * -frontBackH - N + BM_HALF_PI) / BM_PI); + frontBackH = (samplingDir >= 0.0) ? frontBackH.yx : frontBackH.xy; + frontBackH = smoothstep(0.0, 1.0, frontBackH); + bm = BM_UpdateSectors(frontBackH.x, frontBackH.y, bm); +} +// --- End Visibility Bitmask helpers --- + +RWTexture2D u0 : register(u0); +RWTexture2D u1 : register(u1); + +[numthreads(8, 8, 1)] +void main(uint3 vThreadID : SV_DispatchThreadID) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16; + + // Select original or improved GTAO settings + bool use_improved = IMPROVED_GTAO >= 0.5; + float _ao_radius = use_improved ? AO_RADIUS : cb1[0].x; + float _ao_radius_scale = use_improved ? AO_RADIUS_SCALE : cb1[0].y; + float _ao_falloff_range = use_improved ? AO_FALLOFF_RANGE : cb1[0].z; + float _ao_distribution_power = use_improved ? AO_DISTRIBUTION_POWER : cb1[0].w; + float _ao_thin_occluder = use_improved ? AO_THIN_OCCLUDER : cb1[1].x; + float _ao_gamma = use_improved ? AO_GAMMA : cb1[1].y; + float _ao_mip_bias = use_improved ? AO_MIP_BIAS : cb1[1].w; + float _ao_thickness = use_improved ? AO_THICKNESS : 1.3; + float _ao_direction_count = use_improved ? AO_DIRECTION_COUNT : 3.0; + float _ao_normal_attenuation = use_improved ? AO_NORMAL_ATTENUATION : 0.05; + float _ao_max_mip = use_improved ? 4.0 : cb1[3].x - 1.0; + bool _ao_bitmask = use_improved && (AO_BITMASK >= 0.5); + + r0.xy = vThreadID.yx; + r0.zw = float2(32, 0); + while (true) { + r1.x = cmp(0 >= (uint)r0.z); + if (r1.x != 0) break; + r1.xy = (int2)r0.zz & (int2)r0.yx; + r1.xy = min(uint2(1,1), (uint2)r1.xy); + r1.z = (int)r0.z * (int)r0.z; + r1.w = (int)r1.x * 3; + r1.w = (int)r1.y ^ (int)r1.w; + r0.w = mad((int)r1.z, (int)r1.w, (int)r0.w); + r1.x = cmp((int)r1.x == 1); + r1.zw = (int2)-r0.yx + int2(63,63); + r1.xz = r1.xx ? r1.zw : r0.yx; + r0.xy = r1.yy ? r0.xy : r1.xz; + r0.z = (uint)r0.z >> 1; + } + r0.x = (uint)cb1[1].z; + r0.x = (int)r0.x & 63; + r0.x = mad(288, (int)r0.x, (int)r0.w); + r0.x = (uint)r0.x; + r0.xy = r0.xx * float2(0.754877687,0.569840312) + float2(0.5,0.5); + r0.xy = frac(r0.xy); + r0.zw = (uint2)vThreadID.xy; + float2 edge_uv = cb1[4].zw * r0.zw; + float4 edge_gather = t1.Gather(s0_s, edge_uv); + float4 edge_diagonal = t1.Gather(s0_s, edge_uv, int2(1, 1)); + float4 edge_delta = float4(edge_gather.x, edge_diagonal.z, edge_gather.z, edge_diagonal.x) - edge_gather.y; + float4 edge_pair = edge_delta.yyww - edge_delta.xxzz; + edge_pair = edge_pair * float4(0.5,-0.5,0.5,-0.5) + edge_delta; + float4 edge_strength = min(abs(edge_pair), abs(edge_delta)); + edge_strength = edge_strength / (0.0109999999 * edge_gather.y); + edge_strength = saturate(1.25 - edge_strength); + edge_strength = round(2.9000001 * edge_strength); + float edge_packed = dot(edge_strength, float4(0.250980407,0.0627451017,0.0156862754,0.00392156886)); + u1[vThreadID.xy] = edge_packed.xxxx; + r1.xyzw = float4(0.5,0.5,0.5,0.5) + r0.zwzw; + r2.xy = cb1[4].zw * r1.zw; + r2.zw = t0.SampleLevel(s0_s, r2.xy, 0).xy; + r2.zw = r2.zw * float2(2,2) + float2(-1,-1); + r3.x = dot(float2(1,1), abs(r2.zw)); + r3.y = 1 + -r3.x; + r3.w = cmp(r3.y < 0); + r4.xy = cmp(r2.zw >= float2(0,0)); + r4.zw = float2(1,1) + -abs(r2.wz); + r4.xy = r4.xy ? float2(1,1) : float2(-1,-1); + r4.xy = r4.zw * r4.xy; + r3.xz = r3.ww ? r4.xy : r2.zw; + r2.z = dot(r3.xyz, r3.xyz); + r2.z = rsqrt(r2.z); + r3.xyz = r3.xyz * r2.zzz; + r4.xyz = cb0[1].xyz * r3.yyy; + r3.xyw = cb0[0].xyz * r3.xxx + r4.xyz; + r3.xyz = cb0[2].xyz * r3.zzz + r3.xyw; + r0.zw = cb1[4].zw * r0.zw; + r0.z = t1.Gather(s0_s, r0.zw).y; + r4.z = 0.999989986 * r0.z; + r0.zw = r2.xy * float2(2,2) + float2(-1,-1); + r2.xy = cb0[13].xy * r0.ww; + r0.zw = cb0[12].xy * r0.zz + r2.xy; + r0.zw = cb0[14].xy + r0.zw; + r0.zw = cb0[15].xy + r0.zw; + r4.xy = r0.zw * r4.zz; + r4.w = -r4.y; + r0.z = dot(-r4.xzw, -r4.xzw); + r0.z = rsqrt(r0.z); + r2.xyz = -r4.xwz * r0.zzz; + + // Distance-based thickness scaling: increase thickness linearly with depth + // to prevent over-attenuation of AO on distant objects. + // No scaling within 100 units (near-field), then ramps at 0.02 per unit beyond. + float viewDist = length(float3(r4.x, r4.w, r4.z)); + bool use_distance_scaling = use_improved; + float scaledThickness = use_distance_scaling + ? _ao_thickness * (1.0 + max(0.0, viewDist - 100.0) * 0.02) + : _ao_thickness; + + r0.z = _ao_radius * _ao_radius_scale; + r0.w = _ao_falloff_range * r0.z; + r2.w = -1 / r0.w; + r4.y = -_ao_falloff_range + 1; + r4.y = r4.y * r0.z; + r0.w = r4.y / r0.w; + r0.w = 1 + r0.w; + r5.xy = r1.zw * cb1[4].zw + cb1[4].zw; + r5.xy = r5.xy * float2(2,2) + float2(-1,-1); + r4.y = cb0[13].x * r5.y; + r4.y = cb0[12].x * r5.x + r4.y; + r4.y = cb0[14].x + r4.y; + r4.y = cb0[15].x + r4.y; + r4.y = r4.y * r4.z + -r4.x; + r0.z = r0.z / r4.y; + r4.y = scaledThickness / r0.z; + r5.x = 10 + -r0.z; + r5.x = saturate(0.00999999978 * r5.x); + r5.x = 0.5 * r5.x; + r5.y = _ao_thin_occluder + 1; + r6.z = 0; + r3.w = -r3.z; + r7.x = r5.x; + r7.y = 0; + while (true) { + r3.z = cmp(r7.y >= _ao_direction_count); + if (r3.z != 0) break; + r3.z = r7.y + r0.x; + r3.z = (3.14159265 / _ao_direction_count) * r3.z; + sincos(r3.z, r8.x, r6.x); + r6.y = r8.x; + r8.xyzw = r6.xyxy * r0.zzzz; + r3.z = dot(r6.xy, r2.xy); + r6.xyw = -r2.xyz * r3.zzz + r6.xyz; + r9.xyz = r6.wxy * r2.yzx; + r9.xyz = r6.ywx * r2.zxy + -r9.xyz; + r3.z = dot(r9.xyz, r9.xyz); + r3.z = rsqrt(r3.z); + r9.xyz = r9.xyz * r3.zzz; + r3.z = dot(r3.xyw, r9.xyz); + r9.xyz = -r9.xyz * r3.zzz + r3.xyw; + r3.z = dot(r9.xyz, r9.xyz); + r3.z = sqrt(r3.z); + r5.z = dot(r9.xyz, r2.xyz); + r5.z = saturate(r5.z / r3.z); + r5.w = dot(r6.xyw, r9.xyz); + r6.x = cmp(0 < r5.w); + r5.w = cmp(r5.w < 0); + r5.w = (int)-r6.x + (int)r5.w; + r5.w = (int)r5.w; + r6.x = r5.z * -0.156582996 + 1.57079601; + r6.y = 1 + -r5.z; + r6.y = asfloat(asuint(r6.y) >> 1); + r6.y = asfloat(asint(r6.y) + 0x1fbd1df5); + r6.x = r6.x * r6.y; + r6.x = max(0, r6.x); + r6.x = min(3.14159298, r6.x); + r6.y = r6.x * r5.w; + r9.xy = r5.ww * r6.xx + float2(1.57079637,-1.57079637); + r9.xy = cos(r9.xy); + uint bitmask = 0u; + r6.w = r7.y * 0.618034005 + r0.y; + r6.w = frac(r6.w); + r6.w = 0.333333343 * r6.w; + r6.w = log2(r6.w); + r6.w = _ao_distribution_power * r6.w; + r6.w = exp2(r6.w); + r6.w = r6.w + r4.y; + r9.zw = r8.zw * r6.ww; + r6.w = dot(r9.zw, r9.zw); + r6.w = sqrt(r6.w); + r6.w = log2(r6.w); + r6.w = -_ao_mip_bias + r6.w; + r6.w = max(0, r6.w); + r6.w = min(_ao_max_mip, r6.w); + r9.zw = round(r9.zw); + r9.zw = cb1[4].zw * r9.zw; + r10.xy = r1.zw * cb1[4].zw + r9.zw; + r11.w = t1.SampleLevel(s0_s, r10.xy, r6.w).x; + r10.xy = r10.xy * float2(2,2) + float2(-1,-1); + r10.yz = cb0[13].xy * r10.yy; + r10.xy = cb0[12].xy * r10.xx + r10.yz; + r10.xy = cb0[14].xy + r10.xy; + r10.xy = cb0[15].xy + r10.xy; + r11.xy = r10.xy * r11.ww; + r9.zw = r1.zw * cb1[4].zw + -r9.zw; + r10.w = t1.SampleLevel(s0_s, r9.zw, r6.w).x; + r9.zw = r9.zw * float2(2,2) + float2(-1,-1); + r12.xy = cb0[13].xy * r9.ww; + r9.zw = cb0[12].xy * r9.zz + r12.xy; + r9.zw = cb0[14].xy + r9.zw; + r9.zw = cb0[15].xy + r9.zw; + r10.xy = r9.zw * r10.ww; + r11.z = -r11.y; + r11.xyz = r11.xzw + -r4.xwz; + r10.z = -r10.y; + r10.xyz = r10.xzw + -r4.xwz; + // Bitmask: process step 0 samples + if (_ao_bitmask) { + BM_ProcessSample(r11.xyz, r2.xyz, -1.0, r6.y, scaledThickness, bitmask); + BM_ProcessSample(r10.xyz, r2.xyz, 1.0, r6.y, scaledThickness, bitmask); + } + r6.w = dot(r11.xyz, r11.xyz); + r6.w = sqrt(r6.w); + r12.xyz = r11.xyz / r6.www; + r6.w = dot(r12.xyz, r2.xyz); + r11.w = r11.z * r5.y; + r9.z = dot(r11.xyw, r11.xyw); + r9.z = sqrt(r9.z); + r9.z = saturate(r9.z * r2.w + r0.w); + r6.w = r6.w + -r9.x; + r6.w = r9.z * r6.w + r9.x; + r6.w = max(r9.x, r6.w); + r9.z = dot(r10.xyz, r10.xyz); + r9.z = sqrt(r9.z); + r11.xyz = r10.xyz / r9.zzz; + r9.z = dot(r11.xyz, r2.xyz); + r10.w = r10.z * r5.y; + r9.w = dot(r10.xyw, r10.xyw); + r9.w = sqrt(r9.w); + r9.w = saturate(r9.w * r2.w + r0.w); + r9.z = r9.z + -r9.y; + r9.z = r9.w * r9.z + r9.y; + r9.z = max(r9.y, r9.z); + r7.yzw = float3(1,3,6) + r7.yyy; + r10.xyzw = r7.zzww * float4(0.618034005,0.618034005,0.618034005,0.618034005) + r0.yyyy; + r10.xyzw = frac(r10.xyzw); + r10.xyzw = float4(1,1,2,2) + r10.xyzw; + r10.xyzw = float4(0.333333343,0.333333343,0.333333343,0.333333343) * r10.xyzw; + r10.xyzw = log2(r10.xyzw); + r10.xyzw = _ao_distribution_power * r10.xyzw; + r10.xyzw = exp2(r10.xyzw); + r10.xyzw = r10.xyzw + r4.yyyy; + r8.xyzw = r10.xyzw * r8.xyzw; + r7.z = dot(r8.xy, r8.xy); + r7.z = sqrt(r7.z); + r7.z = log2(r7.z); + r7.z = -_ao_mip_bias + r7.z; + r7.z = max(0, r7.z); + r7.z = min(_ao_max_mip, r7.z); + r10.xyzw = round(r8.xyzw); + r10.xyzw = cb1[4].zwzw * r10.xyzw; + r11.xyzw = r1.zwzw * cb1[4].zwzw + r10.xyzw; + r12.w = t1.SampleLevel(s0_s, r11.xy, r7.z).x; + r13.xyzw = r11.xyzw * float4(2,2,2,2) + float4(-1,-1,-1,-1); + r14.xyzw = cb0[13].xyxy * r13.yyww; + r13.xyzw = cb0[12].xyxy * r13.xxzz + r14.xyzw; + r13.xyzw = cb0[14].xyxy + r13.xyzw; + r13.xyzw = cb0[15].xyxy + r13.xyzw; + r12.xy = r13.xy * r12.ww; + r10.xyzw = r1.xyzw * cb1[4].zwzw + -r10.xyzw; + r14.w = t1.SampleLevel(s0_s, r10.xy, r7.z).x; + r15.xyzw = r10.xyzw * float4(2,2,2,2) + float4(-1,-1,-1,-1); + r16.xyzw = cb0[13].xyxy * r15.yyww; + r15.xyzw = cb0[12].xyxy * r15.xxzz + r16.xyzw; + r15.xyzw = cb0[14].xyxy + r15.xyzw; + r15.xyzw = cb0[15].xyxy + r15.xyzw; + r14.xy = r15.xy * r14.ww; + r12.z = -r12.y; + r12.xyz = r12.xzw + -r4.xwz; + r14.z = -r14.y; + r14.xyz = r14.xzw + -r4.xwz; + // Bitmask: process step 1 samples + if (_ao_bitmask) { + BM_ProcessSample(r12.xyz, r2.xyz, -1.0, r6.y, scaledThickness, bitmask); + BM_ProcessSample(r14.xyz, r2.xyz, 1.0, r6.y, scaledThickness, bitmask); + } + r7.z = dot(r12.xyz, r12.xyz); + r7.z = sqrt(r7.z); + r16.xyz = r12.xyz / r7.zzz; + r7.z = dot(r16.xyz, r2.xyz); + r12.w = r12.z * r5.y; + r7.w = dot(r12.xyw, r12.xyw); + r7.w = sqrt(r7.w); + r7.w = saturate(r7.w * r2.w + r0.w); + r7.z = r7.z + -r9.x; + r7.z = r7.w * r7.z + r9.x; + r6.w = max(r7.z, r6.w); + r7.z = dot(r14.xyz, r14.xyz); + r7.z = sqrt(r7.z); + r12.xyz = r14.xyz / r7.zzz; + r7.z = dot(r12.xyz, r2.xyz); + r14.w = r14.z * r5.y; + r7.w = dot(r14.xyw, r14.xyw); + r7.w = sqrt(r7.w); + r7.w = saturate(r7.w * r2.w + r0.w); + r7.z = r7.z + -r9.y; + r7.z = r7.w * r7.z + r9.y; + r7.z = max(r9.z, r7.z); + r7.w = dot(r8.zw, r8.zw); + r7.w = sqrt(r7.w); + r7.w = log2(r7.w); + r7.w = -_ao_mip_bias + r7.w; + r7.w = max(0, r7.w); + r7.w = min(_ao_max_mip, r7.w); + r8.w = t1.SampleLevel(s0_s, r11.zw, r7.w).x; + r8.xy = r13.zw * r8.ww; + r10.w = t1.SampleLevel(s0_s, r10.zw, r7.w).x; + r10.xy = r15.zw * r10.ww; + r8.z = -r8.y; + r8.xyz = r8.xzw + -r4.xwz; + r10.z = -r10.y; + r10.xyz = r10.xzw + -r4.xwz; + // Bitmask: process step 2 samples + if (_ao_bitmask) { + BM_ProcessSample(r8.xyz, r2.xyz, -1.0, r6.y, scaledThickness, bitmask); + BM_ProcessSample(r10.xyz, r2.xyz, 1.0, r6.y, scaledThickness, bitmask); + } + r7.w = dot(r8.xyz, r8.xyz); + r7.w = sqrt(r7.w); + r11.xyz = r8.xyz / r7.www; + r7.w = dot(r11.xyz, r2.xyz); + r8.w = r8.z * r5.y; + r8.x = dot(r8.xyw, r8.xyw); + r8.x = sqrt(r8.x); + r8.x = saturate(r8.x * r2.w + r0.w); + r7.w = r7.w + -r9.x; + r7.w = r8.x * r7.w + r9.x; + r6.w = max(r7.w, r6.w); + r7.w = dot(r10.xyz, r10.xyz); + r7.w = sqrt(r7.w); + r8.xyz = r10.xyz / r7.www; + r7.w = dot(r8.xyz, r2.xyz); + r10.w = r10.z * r5.y; + r8.x = dot(r10.xyw, r10.xyw); + r8.x = sqrt(r8.x); + r8.x = saturate(r8.x * r2.w + r0.w); + r7.w = r7.w + -r9.y; + r7.w = r8.x * r7.w + r9.y; + r7.z = max(r7.z, r7.w); + // Visibility accumulation: bitmask vs arc integration + if (_ao_bitmask) { + r7.x += (1.0 - (float)countbits(bitmask) / 32.0); + } else { + r7.w = abs(r7.z) * -0.156582996 + 1.57079601; + r8.x = 1 + -abs(r7.z); + r8.x = asfloat(asuint(r8.x) >> 1); + r8.x = asfloat(asint(r8.x) + 0x1fbd1df5); + r8.y = r8.x * r7.w; + r8.z = abs(r6.w) * -0.156582996 + 1.57079601; + r8.w = 1 + -abs(r6.w); + r8.w = asfloat(asuint(r8.w) >> 1); + r8.w = asfloat(asint(r8.w) + 0x1fbd1df5); + r9.x = r8.z * r8.w; + r7.z = cmp(r7.z >= 0); + r7.w = -r7.w * r8.x + 3.14159298; + r7.z = r7.z ? r8.y : r7.w; + r7.z = max(0, r7.z); + r7.z = min(3.14159298, r7.z); + r7.w = -2 * r7.z; + r8.x = sin(r6.y); + r6.w = cmp(r6.w >= 0); + r8.y = -r8.z * r8.w + 3.14159298; + r6.w = r6.w ? r9.x : r8.y; + r6.w = max(0, r6.w); + r6.w = min(3.14159298, r6.w); + r6.w = r6.w + r6.w; + r8.y = 1 + -r3.z; + r3.z = r8.y * _ao_normal_attenuation + r3.z; + r7.w = r7.w * r8.x + r5.z; + r6.y = r7.z * -2 + -r6.y; + r6.y = cos(r6.y); + r6.y = r7.w + -r6.y; + r5.z = r6.w * r8.x + r5.z; + r5.w = -r5.w * r6.x + r6.w; + r5.w = cos(r5.w); + r5.z = r5.z + -r5.w; + r5.z = r6.y + r5.z; + r3.z = r5.z * r3.z; + r7.x = r3.z * 0.25 + r7.x; + } + } + r0.x = (1.0 / _ao_direction_count) * r7.x; + r0.x = log2(abs(r0.x)); + r0.x = _ao_gamma * r0.x; + r0.x = exp2(r0.x); + r0.x = max(0.0299999993, r0.x); + r0.x = 0.666666687 * r0.x; + r0.x = min(1, r0.x); + if (shader_injection.disable_game_ao >= 0.5f) { + r0.x = 1.0f; + } + u0[vThreadID.xy] = r0.xxxx; + return; +} diff --git a/src/games/endfield/ao/gtao-spatial-avg_0xA683B186.cs_5_0.hlsl b/src/games/endfield/ao/gtao-spatial-avg_0xA683B186.cs_5_0.hlsl new file mode 100644 index 0000000000..7c81c9be64 --- /dev/null +++ b/src/games/endfield/ao/gtao-spatial-avg_0xA683B186.cs_5_0.hlsl @@ -0,0 +1,43 @@ +// ---- Created with 3Dmigoto v1.4.1 on Tue Feb 10 15:11:49 2026 +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb0 : register(b0) +{ + float4 cb0[1]; +} + + +#include "../shared.h" + +#define cmp - + +RWTexture2D u0 : register(u0); + +[numthreads(8, 8, 1)] +void main(uint3 vThreadID : SV_DispatchThreadID) +{ + float4 r0,r1; + r0.xy = (uint2)vThreadID.xy; + r0.xy = float2(0.5,0.5) + r0.xy; + r0.zw = r0.xy * cb0[0].zw + -cb0[0].zw; + r0.z = t0.SampleLevel(s0_s, r0.zw, 0).x; + r1.xy = cb0[0].zw * r0.xy; + r0.xy = r0.xy * cb0[0].zw + cb0[0].zw; + r0.x = t0.SampleLevel(s0_s, r0.xy, 0).x; + r0.y = t0.SampleLevel(s0_s, r1.xy, 0).x; + r1.xyzw = cb0[0].zwzw * float4(1,-1,-1,1) + r1.xyxy; + r0.y = r0.y + r0.z; + r0.z = t0.SampleLevel(s0_s, r1.xy, 0).x; + r0.w = t0.SampleLevel(s0_s, r1.zw, 0).x; + r0.y = r0.y + r0.z; + r0.y = r0.y + r0.w; + r0.x = r0.y + r0.x; + r0.x = 0.200000003 * r0.x; + if (shader_injection.disable_game_ao >= 0.5f) { + r0.x = 1.0f; + } + u0[vThreadID.xy] = r0.xxxx; + return; +} diff --git a/src/games/endfield/ao/gtao-temporal_0xDD16F0F8.cs_5_0.hlsl b/src/games/endfield/ao/gtao-temporal_0xDD16F0F8.cs_5_0.hlsl new file mode 100644 index 0000000000..2ef023b5c6 --- /dev/null +++ b/src/games/endfield/ao/gtao-temporal_0xDD16F0F8.cs_5_0.hlsl @@ -0,0 +1,122 @@ +// ---- Created with 3Dmigoto v1.4.1 on Tue Feb 10 15:11:49 2026 +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb0 : register(b0) +{ + float4 cb0[5]; +} + + +#include "../shared.h" + +#define cmp - + +RWTexture2D u0 : register(u0); + +[numthreads(8, 8, 1)] +void main(uint3 vThreadID : SV_DispatchThreadID) +{ + float4 r0,r1,r2,r3,r4; + r0.xy = (uint2)vThreadID.xy; + r0.xy = float2(0.5,0.5) + r0.xy; + r0.zw = cb0[4].zw * r0.xy; + r1.xy = t2.SampleLevel(s0_s, r0.zw, 0).xy; + r1.zw = abs(r1.xy) * float2(2,2) + float2(-1,-1); + r1.zw = r1.zw * r1.zw; + r1.zw = r1.zw * r1.zw; + r1.xy = float2(-0.5,-0.5) + r1.xy; + r2.xy = cmp(float2(0,0) < r1.xy); + r1.xy = cmp(r1.xy < float2(0,0)); + r1.xy = (int2)-r2.xy + (int2)r1.xy; + r1.xy = (int2)r1.xy; + r1.xy = r1.zw * r1.xy; + r1.zw = r0.xy * cb0[4].zw + -r1.xy; + if (IMPROVED_GTAO >= 0.5) { + // Manual bilinear interpolation for previous AO (reduces wobble/ghosting) + // Only interpolate AO (.x), keep depth (.y) point-sampled + float2 texelPos = r1.zw * cb0[4].xy - 0.5; + float2 f = frac(texelPos); + float2 base = (floor(texelPos) + 0.5) * cb0[4].zw; + float ao00 = t3.SampleLevel(s0_s, base, 0).x; + float ao10 = t3.SampleLevel(s0_s, base + float2(cb0[4].z, 0), 0).x; + float ao01 = t3.SampleLevel(s0_s, base + float2(0, cb0[4].w), 0).x; + float ao11 = t3.SampleLevel(s0_s, base + cb0[4].zw, 0).x; + r2.x = lerp(lerp(ao00, ao10, f.x), lerp(ao01, ao11, f.x), f.y); + r2.y = t3.SampleLevel(s0_s, r1.zw, 0).y; // depth: point-sampled + } else { + r2.xy = t3.SampleLevel(s0_s, r1.zw, 0).xy; + } + r2.z = t0.SampleLevel(s0_s, r0.zw, 0).x; + r2.z = 0.00999999978 * r2.z; + r3.y = min(1, r2.z); + r3.x = t1.SampleLevel(s0_s, r0.zw, 0).x; + r2.zw = cmp(r1.zw < float2(0,0)); + r2.z = (int)r2.w | (int)r2.z; + r1.zw = cmp(float2(1,1) < r1.zw); + r1.z = (int)r1.w | (int)r1.z; + r1.z = (int)r1.z | (int)r2.z; + if (r1.z != 0) { + r3.z = 0; + } else { + r1.xy = cb0[4].xy * r1.xy; + r1.x = dot(r1.xy, r1.xy); + r1.x = sqrt(r1.x); + r1.x = cb0[2].z * -r1.x; + r1.x = 1.44269502 * r1.x; + r1.x = exp2(r1.x); + r1.x = 0.970000029 * r1.x; + r1.y = r3.y + -r2.y; + r1.y = -1442.69507 * abs(r1.y); + r1.y = exp2(r1.y); + r3.z = r1.x * r1.y; + } + r1.x = cmp(0.000000 == cb0[2].y); + if (r1.x == 0) { + r1.xy = r0.xy * cb0[4].zw + -cb0[4].zw; + r1.x = t1.SampleLevel(s0_s, r1.xy, 0).x; + r4.xyzw = cb0[4].zwzw * float4(0,-1,1,-1) + r0.zwzw; + r1.y = t1.SampleLevel(s0_s, r4.xy, 0).x; + r1.z = t1.SampleLevel(s0_s, r4.zw, 0).x; + r4.xyzw = cb0[4].zwzw * float4(-1,0,1,0) + r0.zwzw; + r1.w = t1.SampleLevel(s0_s, r4.xy, 0).x; + r2.y = t1.SampleLevel(s0_s, r4.zw, 0).x; + r4.xyzw = cb0[4].zwzw * float4(-1,1,0,1) + r0.zwzw; + r0.z = t1.SampleLevel(s0_s, r4.xy, 0).x; + r0.w = t1.SampleLevel(s0_s, r4.zw, 0).x; + r0.xy = r0.xy * cb0[4].zw + cb0[4].zw; + r0.x = t1.SampleLevel(s0_s, r0.xy, 0).x; + r0.y = min(r1.w, r3.x); + r2.z = min(r2.y, r0.w); + r0.y = min(r2.z, r0.y); + r0.y = min(r1.y, r0.y); + r2.z = min(r1.x, r1.z); + r2.w = min(r0.z, r0.x); + r2.z = min(r2.z, r2.w); + r0.y = min(r2.z, r0.y); + r1.w = max(r1.w, r3.x); + r0.w = max(r2.y, r0.w); + r0.w = max(r1.w, r0.w); + r1.x = max(r1.x, r1.z); + r0.x = max(r0.z, r0.x); + r0.xw = max(r1.xy, r0.xw); + r0.x = max(r0.w, r0.x); + r0.y = max(r2.x, r0.y); + r0.x = min(r0.y, r0.x); + r0.x = r0.x + -r3.x; + r3.x = r3.z * r0.x + r3.x; + } + if (shader_injection.disable_game_ao >= 0.5f) { + r3.x = 1.0f; + } + r3.w = 0; + u0[vThreadID.xy] = r3.xyzw; + return; +} diff --git a/src/games/endfield/bloom/0x2CF2F67B.cso b/src/games/endfield/bloom/0x2CF2F67B.cso new file mode 100644 index 0000000000..c48a392a35 Binary files /dev/null and b/src/games/endfield/bloom/0x2CF2F67B.cso differ diff --git a/src/games/endfield/bloom/0x948BF835.cso b/src/games/endfield/bloom/0x948BF835.cso new file mode 100644 index 0000000000..9cfbb444c7 Binary files /dev/null and b/src/games/endfield/bloom/0x948BF835.cso differ diff --git a/src/games/endfield/bloom/bloom-prefilter_0x2B198371.cs_5_0.hlsl b/src/games/endfield/bloom/bloom-prefilter_0xB3082097.cs_5_0.hlsl similarity index 96% rename from src/games/endfield/bloom/bloom-prefilter_0x2B198371.cs_5_0.hlsl rename to src/games/endfield/bloom/bloom-prefilter_0xB3082097.cs_5_0.hlsl index 265fbb663c..6d26c318b2 100644 --- a/src/games/endfield/bloom/bloom-prefilter_0x2B198371.cs_5_0.hlsl +++ b/src/games/endfield/bloom/bloom-prefilter_0xB3082097.cs_5_0.hlsl @@ -22,7 +22,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; // cb0[82].zw = sample offset scale // cb0[109].x = bloom intensity multiplier } @@ -61,7 +61,7 @@ void main(uint3 vThreadID : SV_DispatchThreadID) while (true) { r1.w = cmp((int)r0.w >= 13); if (r1.w != 0) break; - r2.xy = icb[r0.w+0].xy * cb0[82].zw; + r2.xy = icb[r0.w+0].xy * cb0[0].zw; r2.xy = r0.xy * cb1[0].zw + r2.xy; r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; r1.w = max(r2.x, r2.y); @@ -76,7 +76,7 @@ void main(uint3 vThreadID : SV_DispatchThreadID) r1.w = r2.w / r1.w; r2.xyz = r2.xyz * r1.www; - r2.xyz = cb0[109].xxx * r2.xyz * (BLOOM_STRENGTH / 50.0f); + r2.xyz = cb0[27].xxx * r2.xyz * (BLOOM_STRENGTH / 50.0f); r1.w = dot(r2.xyz, float3(0.212672904,0.715152204,0.0721750036)); r1.w = 1 + r1.w; @@ -99,4 +99,4 @@ void main(uint3 vThreadID : SV_DispatchThreadID) r0.xyzw = r1.xyzw * r0.xxxx; u0[vThreadID.xy] = r0.xyzw; return; -} \ No newline at end of file +} diff --git a/src/games/endfield/common.hlsl b/src/games/endfield/common.hlsl index e01e5651d8..155e1126f4 100644 --- a/src/games/endfield/common.hlsl +++ b/src/games/endfield/common.hlsl @@ -1,4 +1,5 @@ #include "./shared.h" +#include "../../shaders/color/macleod_boynton.hlsl" static inline float3 AutoHDRVideo(float3 sdr_video) { if (RENODX_TONE_MAP_TYPE == 0.f || RENODX_TONE_MAP_HDR_VIDEO == 0.f) { @@ -47,6 +48,158 @@ float3 HueAndChrominanceOKLab( return incorrect_color; } +float3 CorrectHueAndPurityMBGated( + float3 target_color_bt709, + float3 reference_color_bt709, + float hue_strength = 1.f, + float hue_t_ramp_start = 0.5f, + float hue_t_ramp_end = 1.f, + float purity_strength = 1.f, + float curve_gamma = 1.f, + float2 mb_white_override = float2(-1.f, -1.f), + float t_min = 1e-6f) { + static const float kNearWhiteEpsilon = 1e-14f; + if (purity_strength <= 0.f && hue_strength <= 0.f) { + return target_color_bt709; + } + + float3 target_color_bt2020 = renodx::color::bt2020::from::BT709(target_color_bt709); + float3 reference_color_bt2020 = renodx::color::bt2020::from::BT709(reference_color_bt709); + + float3 target_mb = renodx::color::macleod_boynton::from::BT2020(target_color_bt2020); + float3 reference_mb = renodx::color::macleod_boynton::from::BT2020(reference_color_bt2020); + + if (target_mb.z <= t_min) { + return target_color_bt709; + } + + float hue_blend = saturate(hue_strength) * + saturate(renodx::math::DivideSafe(target_mb.z - hue_t_ramp_start, + hue_t_ramp_end - hue_t_ramp_start, 0.f)); + + float2 white = (mb_white_override.x >= 0.f && mb_white_override.y >= 0.f) + ? mb_white_override + : renodx::color::macleod_boynton::from::D65XY(); + + float2 target_direction = target_mb.xy - white; + float2 reference_direction = reference_mb.xy - white; + + float target_len_sq = dot(target_direction, target_direction); + float reference_len_sq = dot(reference_direction, reference_direction); + + if (target_len_sq < kNearWhiteEpsilon && reference_len_sq < kNearWhiteEpsilon) { + return target_color_bt709; + } + + float target_len = sqrt(max(target_len_sq, 0.f)); + float reference_len = sqrt(max(reference_len_sq, 0.f)); + + float purity_blend = pow(saturate(purity_strength), max(curve_gamma, 1e-6f)); + float applied_purity = lerp(target_len, reference_len, purity_blend); + + float2 target_unit = (target_len_sq > kNearWhiteEpsilon) + ? target_direction * rsqrt(target_len_sq) + : float2(0.f, 0.f); + float2 reference_unit = (reference_len_sq > kNearWhiteEpsilon) + ? reference_direction * rsqrt(reference_len_sq) + : target_unit; + if (target_len_sq <= kNearWhiteEpsilon) { + target_unit = reference_unit; + } + + float2 blended_unit = target_unit; + if (hue_blend > 0.f) { + blended_unit = lerp(target_unit, reference_unit, hue_blend); + float blended_len_sq = dot(blended_unit, blended_unit); + if (blended_len_sq <= kNearWhiteEpsilon) { + blended_unit = (hue_blend >= 0.5f) ? reference_unit : target_unit; + blended_len_sq = dot(blended_unit, blended_unit); + } + blended_unit *= rsqrt(max(blended_len_sq, 1e-20f)); + } + + float2 final_mb_xy = white + blended_unit * max(applied_purity, 0.f); + float3 final_bt2020 = renodx::color::bt2020::from::MacLeodBoynton(final_mb_xy, target_mb.z); + return renodx::color::bt709::from::BT2020(final_bt2020); +} + +float3 ApplyMBLowHueThenHighHueAndPurity( + float3 target_bt709, + float3 low_hue_reference_bt709, + float3 high_reference_bt709, + float high_hue_strength = 1.f, + float hue_t_ramp_start = 0.5f, + float hue_t_ramp_end = 1.f, + float curve_gamma = 1.f, + float2 mb_white_override = float2(-1.f, -1.f), + float t_min = 1e-6f) { + const float kNearWhiteEpsilon = 1e-14f; + + float3 target_bt2020 = renodx::color::bt2020::from::BT709(target_bt709); + float3 low_reference_bt2020 = renodx::color::bt2020::from::BT709(low_hue_reference_bt709); + float3 high_reference_bt2020 = renodx::color::bt2020::from::BT709(high_reference_bt709); + + float3 target_mb = renodx::color::macleod_boynton::from::BT2020(target_bt2020); + float3 low_reference_mb = renodx::color::macleod_boynton::from::BT2020(low_reference_bt2020); + float3 high_reference_mb = renodx::color::macleod_boynton::from::BT2020(high_reference_bt2020); + + if (target_mb.z <= t_min) { + return target_bt709; + } + + float2 white = (mb_white_override.x >= 0.f && mb_white_override.y >= 0.f) + ? mb_white_override + : renodx::color::macleod_boynton::from::D65XY(); + + float2 target_direction = target_mb.xy - white; + float2 low_reference_direction = low_reference_mb.xy - white; + float2 high_reference_direction = high_reference_mb.xy - white; + + float target_len_sq = dot(target_direction, target_direction); + float low_len_sq = dot(low_reference_direction, low_reference_direction); + float high_len_sq = dot(high_reference_direction, high_reference_direction); + + float2 low_unit = float2(0.f, 0.f); + if (low_len_sq > kNearWhiteEpsilon) { + low_unit = low_reference_direction * rsqrt(low_len_sq); + } else if (target_len_sq > kNearWhiteEpsilon) { + low_unit = target_direction * rsqrt(target_len_sq); + } else if (high_len_sq > kNearWhiteEpsilon) { + low_unit = high_reference_direction * rsqrt(high_len_sq); + } + + float2 high_unit = (high_len_sq > kNearWhiteEpsilon) + ? high_reference_direction * rsqrt(high_len_sq) + : low_unit; + + float hue_blend = saturate(high_hue_strength) * + saturate(renodx::math::DivideSafe(target_mb.z - hue_t_ramp_start, + hue_t_ramp_end - hue_t_ramp_start, 0.f)); + + float2 hue_unit = lerp(low_unit, high_unit, hue_blend); + + float hue_len_sq = dot(hue_unit, hue_unit); + if (hue_len_sq <= kNearWhiteEpsilon) { + if (target_len_sq <= kNearWhiteEpsilon) { + return target_bt709; + } + float target_len = sqrt(max(target_len_sq, 0.f)); + float high_len = sqrt(max(high_len_sq, 0.f)); + float applied_purity = pow(max(high_len, 0.f), max(curve_gamma, 1e-6f)); + float2 target_unit = target_direction * rsqrt(target_len_sq); + float2 final_mb_xy = white + target_unit * max(applied_purity, 0.f); + float3 final_bt2020 = renodx::color::bt2020::from::MacLeodBoynton(final_mb_xy, target_mb.z); + return renodx::color::bt709::from::BT2020(final_bt2020); + } + + hue_unit *= rsqrt(hue_len_sq); + float high_len = sqrt(max(high_len_sq, 0.f)); + float applied_purity = pow(max(high_len, 0.f), max(curve_gamma, 1e-6f)); + float2 final_mb_xy = white + hue_unit * max(applied_purity, 0.f); + float3 final_bt2020 = renodx::color::bt2020::from::MacLeodBoynton(final_mb_xy, target_mb.z); + return renodx::color::bt709::from::BT2020(final_bt2020); +} + float3 ApplyHermiteSplineByMaxChannel(float3 input, float peak_ratio, float white_clip = 100.f) { float max_channel = renodx::math::Max(input); @@ -55,6 +208,14 @@ float3 ApplyHermiteSplineByMaxChannel(float3 input, float peak_ratio, float whit float3 tonemapped = input * scale; return tonemapped; } +float3 ApplyNeutwoByMaxChannel(float3 input, float peak_ratio, float white_clip = 100.f) { + float max_channel = renodx::math::Max(input); + + float mapped_peak = renodx::tonemap::Neutwo(max_channel, peak_ratio, white_clip); + float scale = renodx::math::DivideSafe(mapped_peak, max_channel, 1.f); + float3 tonemapped = input * scale; + return tonemapped; +} struct UserGradingConfig { float exposure; @@ -144,6 +305,53 @@ float3 ApplyExposureContrastFlareHighlightsShadowsByLuminance(float3 untonemappe float3 ApplySaturationBlowoutHueCorrectionHighlightSaturation(float3 tonemapped, float3 hue_reference_color, float y, UserGradingConfig config) { float3 color = tonemapped; if (config.saturation != 1.f || config.dechroma != 0.f || config.hue_emulation_strength != 0.f || config.chrominance_emulation_strength != 0.f || config.highlight_saturation != 0.f) { + if (config.hue_emulation_strength != 0.0 || config.chrominance_emulation_strength != 0.0) { + color = CorrectHueAndPurityMBGated( + color, + hue_reference_color, + config.hue_emulation_strength, + 0.5f, + 1.f, + config.chrominance_emulation_strength, + 1.f); + } + + float mb_scale = max(config.saturation, 0.f); + + if (config.dechroma != 0.f) { + float dechroma_scale = lerp(1.f, 0.f, saturate(pow(y / (10000.f / 100.f), (1.f - config.dechroma)))); + mb_scale *= max(dechroma_scale, 0.f); + } + + if (config.highlight_saturation != 0.f) { + float percent_max = saturate(y * 100.f / 10000.f); + float highlight_saturation_strength = 100.f; + float highlight_saturation_change = pow(1.f - percent_max, highlight_saturation_strength * abs(config.highlight_saturation)); + if (config.highlight_saturation < 0) { + highlight_saturation_change = (2.f - highlight_saturation_change); + } + mb_scale *= max(highlight_saturation_change, 0.f); + } + + if (abs(mb_scale - 1.f) > 1e-6f) { + float3 color_bt2020 = renodx::color::bt2020::from::BT709(color); + float3 color_mb = renodx::color::macleod_boynton::from::BT2020(color_bt2020); + float2 white = renodx::color::macleod_boynton::from::D65XY(); + float2 direction = color_mb.xy - white; + float len_sq = dot(direction, direction); + if (len_sq > 1e-14f) { + float len = sqrt(len_sq); + float scaled_len = len * mb_scale; + float2 scaled_xy = white + direction * (scaled_len / len); + color_bt2020 = renodx::color::bt2020::from::MacLeodBoynton(scaled_xy, color_mb.z); + } + color = renodx::color::bt709::from::BT2020(color_bt2020); + } + + color = renodx::color::bt709::clamp::AP1(color); + + /* Old OKlab stuff + float3 perceptual_new = renodx::color::oklab::from::BT709(color); // hue and chrominance emulation @@ -193,6 +401,65 @@ float3 ApplySaturationBlowoutHueCorrectionHighlightSaturation(float3 tonemapped, color = renodx::color::bt709::from::OkLab(perceptual_new); color = renodx::color::bt709::clamp::AP1(color); + + */ } return color; -} \ No newline at end of file +} + +struct LUTSampleResult { + float3 graded; + float y; + float3 graded_ap1; +}; + +LUTSampleResult LUTSAMPLE( + SamplerState lut_sampler, + float3 lut_size, + Texture2D lut_texture, + float3 sample_input) { + [branch] + if (shader_injection.tone_map_type != 0.f) { + UserGradingConfig cg_config = CreateColorGradeConfig(); + float sample_input_y = renodx::color::y::from::BT709(sample_input); + sample_input = ApplyExposureContrastFlareHighlightsShadowsByLuminance( + sample_input, sample_input_y, cg_config); + } + + renodx::lut::Config lut_config = renodx::lut::config::Create( + lut_sampler, + shader_injection.color_grade_strength, + 0.f, + renodx::lut::config::type::ARRI_C1000_NO_CUT, + renodx::lut::config::type::LINEAR, + lut_size); + + LUTSampleResult result; + result.graded = renodx::lut::Sample(lut_texture, lut_config, sample_input); + result.y = renodx::color::y::from::BT709(result.graded); + result.graded_ap1 = renodx::color::ap1::from::BT709(result.graded); + return result; +} + +float3 SDRGRADE(LUTSampleResult lut_sample) { + return lut_sample.graded; +} + +float3 HDRGRADE(LUTSampleResult lut_sample) { + float3 graded = lut_sample.graded; + float3 graded_ap1 = lut_sample.graded_ap1; + float y = lut_sample.y; + + float3 hue_chrominance_reference_color = + renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); + + UserGradingConfig cg_config = CreateColorGradeConfig(); + + float3 output = ApplySaturationBlowoutHueCorrectionHighlightSaturation( + graded, hue_chrominance_reference_color, y, cg_config); + output = renodx::color::bt2020::from::BT709(output); + output = renodx::tonemap::neutwo::MaxChannel( + output, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits, 65.f); + output = renodx::color::bt709::from::BT2020(output); + return output; +} diff --git a/src/games/endfield/deferred-lighting/0x0175FC4A.cso b/src/games/endfield/deferred-lighting/0x0175FC4A.cso new file mode 100644 index 0000000000..845ca65a56 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x0175FC4A.cso differ diff --git a/src/games/endfield/deferred-lighting/0x0608CFD6.cso b/src/games/endfield/deferred-lighting/0x0608CFD6.cso new file mode 100644 index 0000000000..eebeb85814 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x0608CFD6.cso differ diff --git a/src/games/endfield/deferred-lighting/0x08A44A93.cso b/src/games/endfield/deferred-lighting/0x08A44A93.cso new file mode 100644 index 0000000000..8c8dbe5830 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x08A44A93.cso differ diff --git a/src/games/endfield/deferred-lighting/0x09E3521F.cso b/src/games/endfield/deferred-lighting/0x09E3521F.cso new file mode 100644 index 0000000000..83cb426aef Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x09E3521F.cso differ diff --git a/src/games/endfield/deferred-lighting/0x162B46D9.cso b/src/games/endfield/deferred-lighting/0x162B46D9.cso new file mode 100644 index 0000000000..0c5725821f Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x162B46D9.cso differ diff --git a/src/games/endfield/deferred-lighting/0x18F24DBB.cso b/src/games/endfield/deferred-lighting/0x18F24DBB.cso new file mode 100644 index 0000000000..600880e514 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x18F24DBB.cso differ diff --git a/src/games/endfield/deferred-lighting/0x1D75F314.cso b/src/games/endfield/deferred-lighting/0x1D75F314.cso new file mode 100644 index 0000000000..a6631b1b85 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x1D75F314.cso differ diff --git a/src/games/endfield/deferred-lighting/0x1F7F3376.cso b/src/games/endfield/deferred-lighting/0x1F7F3376.cso new file mode 100644 index 0000000000..e98b38e1aa Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x1F7F3376.cso differ diff --git a/src/games/endfield/deferred-lighting/0x27B5CC3B.cso b/src/games/endfield/deferred-lighting/0x27B5CC3B.cso new file mode 100644 index 0000000000..3960c84509 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x27B5CC3B.cso differ diff --git a/src/games/endfield/deferred-lighting/0x2A4AA5B9.cso b/src/games/endfield/deferred-lighting/0x2A4AA5B9.cso new file mode 100644 index 0000000000..6ea5fed7ed Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x2A4AA5B9.cso differ diff --git a/src/games/endfield/deferred-lighting/0x3300FBDA.cso b/src/games/endfield/deferred-lighting/0x3300FBDA.cso new file mode 100644 index 0000000000..f36836cd0e Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x3300FBDA.cso differ diff --git a/src/games/endfield/deferred-lighting/0x3923F97E.cso b/src/games/endfield/deferred-lighting/0x3923F97E.cso new file mode 100644 index 0000000000..a210202f25 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x3923F97E.cso differ diff --git a/src/games/endfield/deferred-lighting/0x470E14EE.cso b/src/games/endfield/deferred-lighting/0x470E14EE.cso new file mode 100644 index 0000000000..e5d57802b9 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x470E14EE.cso differ diff --git a/src/games/endfield/deferred-lighting/0x4BF704A4.cso b/src/games/endfield/deferred-lighting/0x4BF704A4.cso new file mode 100644 index 0000000000..0f628cebb1 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x4BF704A4.cso differ diff --git a/src/games/endfield/deferred-lighting/0x4C421100.cso b/src/games/endfield/deferred-lighting/0x4C421100.cso new file mode 100644 index 0000000000..d4f1708991 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x4C421100.cso differ diff --git a/src/games/endfield/deferred-lighting/0x4FA33192.cso b/src/games/endfield/deferred-lighting/0x4FA33192.cso new file mode 100644 index 0000000000..23692501c7 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x4FA33192.cso differ diff --git a/src/games/endfield/deferred-lighting/0x509F5926.cso b/src/games/endfield/deferred-lighting/0x509F5926.cso new file mode 100644 index 0000000000..5f56301023 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x509F5926.cso differ diff --git a/src/games/endfield/deferred-lighting/0x523B9E43.cso b/src/games/endfield/deferred-lighting/0x523B9E43.cso new file mode 100644 index 0000000000..7b1e28b0a9 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x523B9E43.cso differ diff --git a/src/games/endfield/deferred-lighting/0x523DDB41.cso b/src/games/endfield/deferred-lighting/0x523DDB41.cso new file mode 100644 index 0000000000..55668e3642 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x523DDB41.cso differ diff --git a/src/games/endfield/deferred-lighting/0x5BEF30AE.cso b/src/games/endfield/deferred-lighting/0x5BEF30AE.cso new file mode 100644 index 0000000000..d41496171a Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x5BEF30AE.cso differ diff --git a/src/games/endfield/deferred-lighting/0x60A0503D.cso b/src/games/endfield/deferred-lighting/0x60A0503D.cso new file mode 100644 index 0000000000..67ff8b07d3 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x60A0503D.cso differ diff --git a/src/games/endfield/deferred-lighting/0x6412C588.cso b/src/games/endfield/deferred-lighting/0x6412C588.cso new file mode 100644 index 0000000000..590b7ffa8f Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x6412C588.cso differ diff --git a/src/games/endfield/deferred-lighting/0x66F41E33.cso b/src/games/endfield/deferred-lighting/0x66F41E33.cso new file mode 100644 index 0000000000..204e1f0c8e Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x66F41E33.cso differ diff --git a/src/games/endfield/deferred-lighting/0x69A9A3A2.cso b/src/games/endfield/deferred-lighting/0x69A9A3A2.cso new file mode 100644 index 0000000000..e10d33087a Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x69A9A3A2.cso differ diff --git a/src/games/endfield/deferred-lighting/0x6A7F47F5.cso b/src/games/endfield/deferred-lighting/0x6A7F47F5.cso new file mode 100644 index 0000000000..aea9cc4532 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x6A7F47F5.cso differ diff --git a/src/games/endfield/deferred-lighting/0x773D0A68.cso b/src/games/endfield/deferred-lighting/0x773D0A68.cso new file mode 100644 index 0000000000..f217afaf27 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x773D0A68.cso differ diff --git a/src/games/endfield/deferred-lighting/0x7F533976.cso b/src/games/endfield/deferred-lighting/0x7F533976.cso new file mode 100644 index 0000000000..f2a9d78000 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x7F533976.cso differ diff --git a/src/games/endfield/deferred-lighting/0x82083D15.cso b/src/games/endfield/deferred-lighting/0x82083D15.cso new file mode 100644 index 0000000000..1a29fa53ea Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x82083D15.cso differ diff --git a/src/games/endfield/deferred-lighting/0x82E0E0DA.cso b/src/games/endfield/deferred-lighting/0x82E0E0DA.cso new file mode 100644 index 0000000000..e0dcc614fe Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x82E0E0DA.cso differ diff --git a/src/games/endfield/deferred-lighting/0x8C4B48EB.cso b/src/games/endfield/deferred-lighting/0x8C4B48EB.cso new file mode 100644 index 0000000000..4306f3cd2d Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x8C4B48EB.cso differ diff --git a/src/games/endfield/deferred-lighting/0x8D5C466E.cso b/src/games/endfield/deferred-lighting/0x8D5C466E.cso new file mode 100644 index 0000000000..5b97fb88ed Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x8D5C466E.cso differ diff --git a/src/games/endfield/deferred-lighting/0x8E45AB83.cso b/src/games/endfield/deferred-lighting/0x8E45AB83.cso new file mode 100644 index 0000000000..3f3f3cab50 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x8E45AB83.cso differ diff --git a/src/games/endfield/deferred-lighting/0x8FEB8406.cso b/src/games/endfield/deferred-lighting/0x8FEB8406.cso new file mode 100644 index 0000000000..f6447facd4 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x8FEB8406.cso differ diff --git a/src/games/endfield/deferred-lighting/0x990EFD89.cso b/src/games/endfield/deferred-lighting/0x990EFD89.cso new file mode 100644 index 0000000000..1fcdc164ce Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x990EFD89.cso differ diff --git a/src/games/endfield/deferred-lighting/0x9EBC19FB.cso b/src/games/endfield/deferred-lighting/0x9EBC19FB.cso new file mode 100644 index 0000000000..d7f8b9816e Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x9EBC19FB.cso differ diff --git a/src/games/endfield/deferred-lighting/0x9FEC1C1B.cso b/src/games/endfield/deferred-lighting/0x9FEC1C1B.cso new file mode 100644 index 0000000000..20fc4ff241 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0x9FEC1C1B.cso differ diff --git a/src/games/endfield/deferred-lighting/0xA5B8112F.cso b/src/games/endfield/deferred-lighting/0xA5B8112F.cso new file mode 100644 index 0000000000..27ec628f1f Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xA5B8112F.cso differ diff --git a/src/games/endfield/deferred-lighting/0xA98FCD8A.cso b/src/games/endfield/deferred-lighting/0xA98FCD8A.cso new file mode 100644 index 0000000000..b24d8248af Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xA98FCD8A.cso differ diff --git a/src/games/endfield/deferred-lighting/0xACD57C4D.cso b/src/games/endfield/deferred-lighting/0xACD57C4D.cso new file mode 100644 index 0000000000..23f5428521 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xACD57C4D.cso differ diff --git a/src/games/endfield/deferred-lighting/0xADB65273.cso b/src/games/endfield/deferred-lighting/0xADB65273.cso new file mode 100644 index 0000000000..42e7708893 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xADB65273.cso differ diff --git a/src/games/endfield/deferred-lighting/0xB017F103.cso b/src/games/endfield/deferred-lighting/0xB017F103.cso new file mode 100644 index 0000000000..e9bd6031c1 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xB017F103.cso differ diff --git a/src/games/endfield/deferred-lighting/0xB2137813.cso b/src/games/endfield/deferred-lighting/0xB2137813.cso new file mode 100644 index 0000000000..41edf06092 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xB2137813.cso differ diff --git a/src/games/endfield/deferred-lighting/0xB36BFB47.cso b/src/games/endfield/deferred-lighting/0xB36BFB47.cso new file mode 100644 index 0000000000..9e4f5c9a51 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xB36BFB47.cso differ diff --git a/src/games/endfield/deferred-lighting/0xBE1C389F.cso b/src/games/endfield/deferred-lighting/0xBE1C389F.cso new file mode 100644 index 0000000000..5d3a2ac619 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xBE1C389F.cso differ diff --git a/src/games/endfield/deferred-lighting/0xC181EA40.cso b/src/games/endfield/deferred-lighting/0xC181EA40.cso new file mode 100644 index 0000000000..bd93a02d65 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xC181EA40.cso differ diff --git a/src/games/endfield/deferred-lighting/0xCDB8DB9F.cso b/src/games/endfield/deferred-lighting/0xCDB8DB9F.cso new file mode 100644 index 0000000000..2ad69af4f6 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xCDB8DB9F.cso differ diff --git a/src/games/endfield/deferred-lighting/0xD91B7CA0.cso b/src/games/endfield/deferred-lighting/0xD91B7CA0.cso new file mode 100644 index 0000000000..b16a47fd7c Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xD91B7CA0.cso differ diff --git a/src/games/endfield/deferred-lighting/0xDDFFCC65.cso b/src/games/endfield/deferred-lighting/0xDDFFCC65.cso new file mode 100644 index 0000000000..a9c2e2ce4f Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xDDFFCC65.cso differ diff --git a/src/games/endfield/deferred-lighting/0xDEA84D39.cso b/src/games/endfield/deferred-lighting/0xDEA84D39.cso new file mode 100644 index 0000000000..a734247e54 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xDEA84D39.cso differ diff --git a/src/games/endfield/deferred-lighting/0xE31759A4.cso b/src/games/endfield/deferred-lighting/0xE31759A4.cso new file mode 100644 index 0000000000..0b5ff26ed7 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xE31759A4.cso differ diff --git a/src/games/endfield/deferred-lighting/0xEB195F90.cso b/src/games/endfield/deferred-lighting/0xEB195F90.cso new file mode 100644 index 0000000000..e18cb7d502 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xEB195F90.cso differ diff --git a/src/games/endfield/deferred-lighting/0xED0BAEAD.cso b/src/games/endfield/deferred-lighting/0xED0BAEAD.cso new file mode 100644 index 0000000000..d687c867dd Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xED0BAEAD.cso differ diff --git a/src/games/endfield/deferred-lighting/0xEE78E1BA.cso b/src/games/endfield/deferred-lighting/0xEE78E1BA.cso new file mode 100644 index 0000000000..c210b62b24 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xEE78E1BA.cso differ diff --git a/src/games/endfield/deferred-lighting/0xEFA7F46F.cso b/src/games/endfield/deferred-lighting/0xEFA7F46F.cso new file mode 100644 index 0000000000..adac120cc3 Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xEFA7F46F.cso differ diff --git a/src/games/endfield/deferred-lighting/0xFB48A847.cso b/src/games/endfield/deferred-lighting/0xFB48A847.cso new file mode 100644 index 0000000000..9a165161bf Binary files /dev/null and b/src/games/endfield/deferred-lighting/0xFB48A847.cso differ diff --git a/src/games/endfield/deferred-lighting/Notes for future.txt b/src/games/endfield/deferred-lighting/Notes for future.txt new file mode 100644 index 0000000000..1fdac84eba --- /dev/null +++ b/src/games/endfield/deferred-lighting/Notes for future.txt @@ -0,0 +1,91 @@ +// Why AO dont apply to grass / enviroment under spotlights / direct lights + +The issue was that r1.xyz (the accumulated direct light from spotlights, point lights, etc. computed in the light loop) was never multiplied by the AO value. The original shader only applies AO to r3.xyz (the indirect/specular/SSR contribution), not to the direct light accumulator. + +In the original shader flow: + +r8.xzw / r13.xyz = AO values (single-bounce / multiscatter) +r3.xyz is modulated by AO at line ~1401-1402: mul r6.xyw, r8.xzxw, r6.xyxw and mad r3.xyz, r3.xyzx, r13.xyzx, r6.xywx +r1.xyz goes straight to the final output un-attenuated: add r1.xyz, r1.xyzx, r3.xyzx +So the cb0[112].x gate was a red herring — it was already 1 for the main directional light pass. The real problem was that the light loop output bypassed AO entirely. Grass, being mainly lit by direct lights (spotlights included), showed zero AO effect because its dominant lighting term was never occluded. + +The fix: mul r1.xyz, r1.xyzx, r8.xzwx right after the AO block — applying the same single-bounce AO to the direct light contribution. + +// Screenspaced shadows are RIP becasue sun angle is used... Doesnt match spotlight angles + + + +Environment deferred (0x1E8A471E.ps_5_0.asm:257-260) — After T10 sample, applies 4x (saturate(x*4 - 3)) when SHADOW_HARDENING >= 1.0. Uses new temp r36 (dcl_temps bumped 36→37). + +Grass/foliage deferred (0xD3FA93FC.ps_5_0.asm:165-169) — After T10 sample, applies pow(x, 4) power curve when SHADOW_HARDENING >= 1.0. Uses new temp r37 (dcl_temps bumped 37→38). + +Both ASM patches use movc for branchless conditional selection — if the toggle is off, the original shadow value passes through unchanged. The crude 4x gives environment the strong contrast you liked, while pow(4) preserves grass/foliage shadow boundaries (0→0, 1→1 fixed points). + + + +// BRDF // + +The BRDF is Unity's standard Cook-Torrance with GGX distribution + Smith height-correlated visibility + Schlick Fresnel + multiscattering energy compensation term + +1. Material Setup - metallic workflow: F0 = albedo⋅m+0.04⋅(1−m) + + +r1.z = -r1.x * 0.0399999991 + 0.0399999991; // dielectricF0 = 0.04 * (1 - metallic) +r9.xyz = r9.xyz * r1.xxx + r1.zzz; // F0 = albedo * metallic + dielectricF0 + + +2. GGX NDF (D term) + +r2.z = r0.z * r1.x + -r0.z; // NdotH² * (α² - 1) = NdotH * α² - NdotH +r0.z = r2.z * r0.z + 1; // denom = NdotH² * (α² - 1) + 1 +// ... +r0.z = r0.z * r0.z; // denom² +r0.z = r1.x / r0.z; // D = α² / denom² + +3. Schlick Fresnel (F term) + +r2.z = saturate(dot(r8.xyz, r15.xyz)); // VdotH +r2.z = 1 + -r2.z; // (1 - VdotH) +r4.w = r2.z * r2.z; // (1 - VdotH)² +r4.w = r4.w * r4.w; // (1 - VdotH)⁴ +r6.w = r4.w * r2.z; // (1 - VdotH)⁵ +r2.z = -r4.w * r2.z + 1; // 1 - (1-VdotH)⁵ +r15.xyz = r9.xyz * r2.zzz + r6.www; // F0*(1-(1-VdotH)⁵) + (1-VdotH)⁵ + +4. Smith Height-Correlated Visibility (V term) + +r16.xy = -r10.zy * r1.xx + r10.zy; // NdotV/L * (1 - α²) +r16.xy = r16.xy * r10.zy + r1.xx; // NdotV/L² * (1-α²) + α² +r16.xy = sqrt(r16.xy); // √(...) +r16.xy = r16.xy * r10.yz; // NdotL/V * √(...) +r1.x = r16.x + r16.y; // sum of both terms +r1.x = 9.99999975e-05 + r1.x; // ε +r1.x = 0.5 / r1.x; // V = 0.5 / sum +r0.z = r1.x * r0.z; // D * V +r15.xyz = r15.xyz * r0.zzz; // specular = D * V * F + +5. Multiscattering Energy Compensation + +// Multiscattering: from lines ~283-300 +r14.xyz = float3(1,1,1) + -r9.xyz; +r14.xyz = r14.xyz * float3(0.0476190485,...) + r9.xyz; // 1/21 blend +// ... sample BRDF LUT from t9 ... +r16.xyz = r14.xyz * r14.xyz; +r16.xyz = r16.xyz * r0.zzz; // Fms squared * LUT +r14.xyz = -r14.xyz * r8.www + float3(1,1,1); +r14.xyz = r16.xyz / r14.xyz; // Ems / (1 - Fms*Eavg) +r14.xyz = r15.xyz + r14.xyz; // specular + multiscatter + +6. BRDF LUT Texture + +r16.xyzw = r10.zwyw * float4(0.96875,...) + float4(0.015625,...); // UV with half-texel offset +r0.z = t9.SampleLevel(s1_s, r16.xy, 0).x; // sample(NdotL_or_V, roughness) +r1.x = t9.SampleLevel(s1_s, r16.zw, 0).x; // sample(NdotV, roughness) + +​D: GGX / Trowbridge-Reitz +F: Schlick +G/V: Smith height-correlated (exact sqrt form, not the fast approximation) +Energy conservation: Kulla-Conty multiscattering via rational polynomial + 1D BRDF LUT (t9) +IBL: Cubemap probes with DDGI-style cascaded 3D irradiance probes (t15–t20) +Dielectric F0: 0.04 (standard) + diff --git a/src/games/endfield/glass/0x10F48E71.cso b/src/games/endfield/glass/0x10F48E71.cso new file mode 100644 index 0000000000..6804aab19e Binary files /dev/null and b/src/games/endfield/glass/0x10F48E71.cso differ diff --git a/src/games/endfield/glass/0x48C2ED6A.cso b/src/games/endfield/glass/0x48C2ED6A.cso new file mode 100644 index 0000000000..bdbd4e551b Binary files /dev/null and b/src/games/endfield/glass/0x48C2ED6A.cso differ diff --git a/src/games/endfield/glass/0x63D71B7E.cso b/src/games/endfield/glass/0x63D71B7E.cso new file mode 100644 index 0000000000..4845ec93af Binary files /dev/null and b/src/games/endfield/glass/0x63D71B7E.cso differ diff --git a/src/games/endfield/glass/0x6CC74479.cso b/src/games/endfield/glass/0x6CC74479.cso new file mode 100644 index 0000000000..07c4b8c4e3 Binary files /dev/null and b/src/games/endfield/glass/0x6CC74479.cso differ diff --git a/src/games/endfield/glass/0x84E5DFA1.cso b/src/games/endfield/glass/0x84E5DFA1.cso new file mode 100644 index 0000000000..b5abfe040b Binary files /dev/null and b/src/games/endfield/glass/0x84E5DFA1.cso differ diff --git a/src/games/endfield/glass/0x93A1901D.cso b/src/games/endfield/glass/0x93A1901D.cso new file mode 100644 index 0000000000..a25e8788e1 Binary files /dev/null and b/src/games/endfield/glass/0x93A1901D.cso differ diff --git a/src/games/endfield/glass/0x96F91C3D.cso b/src/games/endfield/glass/0x96F91C3D.cso new file mode 100644 index 0000000000..49505ba37c Binary files /dev/null and b/src/games/endfield/glass/0x96F91C3D.cso differ diff --git a/src/games/endfield/glass/0xC7F04612.cso b/src/games/endfield/glass/0xC7F04612.cso new file mode 100644 index 0000000000..e400dcb7e8 Binary files /dev/null and b/src/games/endfield/glass/0xC7F04612.cso differ diff --git a/src/games/endfield/glass/0xD6BA37BD.cso b/src/games/endfield/glass/0xD6BA37BD.cso new file mode 100644 index 0000000000..fa38a76c39 Binary files /dev/null and b/src/games/endfield/glass/0xD6BA37BD.cso differ diff --git a/src/games/endfield/glass/0xE82F718F.cso b/src/games/endfield/glass/0xE82F718F.cso new file mode 100644 index 0000000000..9329604e75 Binary files /dev/null and b/src/games/endfield/glass/0xE82F718F.cso differ diff --git a/src/games/endfield/glass/0xEC75B2AD.cso b/src/games/endfield/glass/0xEC75B2AD.cso new file mode 100644 index 0000000000..1a69b883d2 Binary files /dev/null and b/src/games/endfield/glass/0xEC75B2AD.cso differ diff --git a/src/games/endfield/glass/0xFB0D073D.cso b/src/games/endfield/glass/0xFB0D073D.cso new file mode 100644 index 0000000000..063985b2ae Binary files /dev/null and b/src/games/endfield/glass/0xFB0D073D.cso differ diff --git a/src/games/endfield/others/blit_0x7CF14F74.ps_5_0.hlsl b/src/games/endfield/others/blit_0x7CF14F74.ps_5_0.hlsl index e2102d5efc..fa0924d945 100644 --- a/src/games/endfield/others/blit_0x7CF14F74.ps_5_0.hlsl +++ b/src/games/endfield/others/blit_0x7CF14F74.ps_5_0.hlsl @@ -122,6 +122,43 @@ float3 ApplyRCAS( return pix; } +// Color Calibration: Temperature 6500K → 6750K + magenta offset 0.03 + +float3 ApplyColorCalibration(float3 color) +{ + float3 adapted; + adapted.r = dot(color, float3( 1.00113f, -0.00212f, -0.01555f)); + adapted.g = dot(color, float3(-0.00031f, 1.00047f, 0.00113f)); + adapted.b = dot(color, float3(-0.00018f, 0.00445f, 1.03436f)); + + float3 lms; + lms.x = dot(adapted, float3(0.4122214708f, 0.5363325363f, 0.0514459929f)); + lms.y = dot(adapted, float3(0.2119034982f, 0.6806995451f, 0.1073969566f)); + lms.z = dot(adapted, float3(0.0883024619f, 0.2817188376f, 0.6299787005f)); + + lms = sign(lms) * pow(abs(lms), 1.0f / 3.0f); + + float3 lab; + lab.x = dot(lms, float3( 0.2104542553f, 0.7936177850f, -0.0040720468f)); + lab.y = dot(lms, float3( 1.9779984951f, -2.4285922050f, 0.4505937099f)); + lab.z = dot(lms, float3( 0.0259040371f, 0.7827717662f, -0.8086757660f)); + + lab.y += 0.0015f; + + lms.x = lab.x + 0.3963377774f * lab.y + 0.2158037573f * lab.z; + lms.y = lab.x - 0.1055613458f * lab.y - 0.0638541728f * lab.z; + lms.z = lab.x - 0.0894841775f * lab.y - 1.2914855480f * lab.z; + + lms = lms * lms * lms; + + float3 result; + result.r = dot(lms, float3( 4.0767416621f, -3.3077115913f, 0.2309699292f)); + result.g = dot(lms, float3(-1.2684380046f, 2.6097574011f, -0.3413193965f)); + result.b = dot(lms, float3(-0.0041960863f, -0.7034186147f, 1.7076147010f)); + + return result; +} + void main( float4 v0 : SV_Position0, float2 v1 : TEXCOORD0, @@ -137,6 +174,11 @@ void main( if (shader_injection.fx_rcas_sharpening >= 1.0f) { r0.xyz = ApplyRCAS(r0.xyz, v1.xy, t0, s0_s); } + + // Apply color calibration (temp 6750K + magenta 0.03) — Tech Test Look + if (TECH_TEST_LOOK > 0.5f) { + r0.xyz = ApplyColorCalibration(r0.xyz); + } o0.xyz = r0.xyz; o0.w = 0; diff --git a/src/games/endfield/others/lutbuilder_0x88BD6DCA.ps_5_0.hlsl b/src/games/endfield/others/lutbuilder_0x88BD6DCA.ps_5_0.hlsl index a117bc6657..d2bfc2174a 100644 --- a/src/games/endfield/others/lutbuilder_0x88BD6DCA.ps_5_0.hlsl +++ b/src/games/endfield/others/lutbuilder_0x88BD6DCA.ps_5_0.hlsl @@ -25,7 +25,20 @@ cbuffer cb0 : register(b0) { // 3Dmigoto declarations #define cmp - -#include "../shared.h" +#include "../common.hlsl" + +static float ACESLikeScalar(float value) { + static const float a = 278.5085; + static const float b = 10.7772; + static const float c = 293.6045; + static const float d = 88.7122; + static const float e = 80.6889; + const float divergence_point = 0.267010625; + + float tonemapped = (value * (a * value + b)) / (value * (c * value + d) + e); + float linear_extension = 0.9174704430474515 * value - 0.06355161968502177; + return (value < divergence_point) ? tonemapped : linear_extension; +} void main( float4 v0: SV_Position0, @@ -233,32 +246,34 @@ void main( r0.xyz = r1.xyz * r0.xxx; // ACES approximation (color * (a*color + b)) / (color * (c*color + d) + e) -#if 0 - r1.xyz = r0.xyz * float3(2.93604493, 2.93604493, 2.93604493) + float3(0.887121975, 0.887121975, 0.887121975); - r1.xyz = r0.xyz * r1.xyz + float3(0.806888998, 0.806888998, 0.806888998); - r1.xyz = float3(1, 1, 1) / r1.xyz; - r1.xyz = max(float3(9.99999975e-005, 9.99999975e-005, 9.99999975e-005), r1.xyz); - r2.xyz = r0.xyz * float3(2.78508496, 2.78508496, 2.78508496) + float3(0.107772, 0.107772, 0.107772); - r2.xyz = r2.xyz * r0.xyz; - r0.yzw = r2.xyz * r1.xyz; - r0.yzw = min(float3(1, 1, 1), r0.yzw); -#else - float3 untonemapped = r0.rgb; - static const float a = 278.5085; - static const float b = 10.7772; - static const float c = 293.6045; - static const float d = 88.7122; - static const float e = 80.6889; - - float3 tonemapped = (untonemapped * (a * untonemapped + b)) / (untonemapped * (c * untonemapped + d) + e); - - const float divergence_point = 0.267010625; - float3 linear_extension = 0.9174704430474515 * untonemapped - 0.06355161968502177; + if (RENODX_TONE_MAP_TYPE == 0.f) { + r1.xyz = r0.xyz * float3(2.93604493, 2.93604493, 2.93604493) + float3(0.887121975, 0.887121975, 0.887121975); + r1.xyz = r0.xyz * r1.xyz + float3(0.806888998, 0.806888998, 0.806888998); + r1.xyz = float3(1, 1, 1) / r1.xyz; + r1.xyz = max(float3(9.99999975e-005, 9.99999975e-005, 9.99999975e-005), r1.xyz); + r2.xyz = r0.xyz * float3(2.78508496, 2.78508496, 2.78508496) + float3(0.107772, 0.107772, 0.107772); + r2.xyz = r2.xyz * r0.xyz; + r0.yzw = r2.xyz * r1.xyz; + r0.yzw = min(float3(1, 1, 1), r0.yzw); + } else { + float3 untonemapped = r0.rgb; + float3 per_channel_tonemapped = float3( + ACESLikeScalar(untonemapped.x), + ACESLikeScalar(untonemapped.y), + ACESLikeScalar(untonemapped.z)); - tonemapped = renodx::math::Select(untonemapped < divergence_point, tonemapped, linear_extension); + float luminance_in = renodx::color::y::from::BT709(untonemapped); + float luminance_tonemapped = ACESLikeScalar(luminance_in); + float3 luminance_tonemapped_color = renodx::color::correct::Luminance( + untonemapped, + luminance_in, + luminance_tonemapped); - r0.yzw = tonemapped; -#endif + r0.yzw = ApplyMBLowHueThenHighHueAndPurity( + luminance_tonemapped_color, + untonemapped, + per_channel_tonemapped); + } r0.x = dot(r0.xyz, float3(0.272228986, 0.674081981, 0.0536894985)); r0.x = -0.5 + r0.x; @@ -270,14 +285,14 @@ void main( r1.x = dot(float3(1.70505154, -0.621790707, -0.083258681), r0.yzw); r1.y = dot(float3(-0.130257145, 1.14080286, -0.0105481902), r0.yzw); r1.z = dot(float3(-0.0240032692, -0.128968775, 1.15297163), r0.yzw); -#if 0 - r0.y = max(r1.x, r1.y); - r0.y = max(r0.y, r1.z); - r0.y = max(9.99999975e-006, r0.y); - r0.yzw = saturate(r1.xyz / r0.yyy); -#else - r0.yzw = r1.xyz; -#endif + if (RENODX_TONE_MAP_TYPE == 0.f) { + r0.y = max(r1.x, r1.y); + r0.y = max(r0.y, r1.z); + r0.y = max(9.99999975e-006, r0.y); + r0.yzw = saturate(r1.xyz / r0.yyy); + } else { + r0.yzw = r1.xyz; + } r0.yzw = r0.yzw + -r1.xyz; o0.xyz = (r0.xxx * r0.yzw + r1.xyz); o0.w = 1; diff --git a/src/games/endfield/others/skybox2_0x4CE535E1.ps_5_0.hlsl b/src/games/endfield/others/skybox2_0x4CE535E1.ps_5_0.hlsl new file mode 100644 index 0000000000..cf9a08d222 --- /dev/null +++ b/src/games/endfield/others/skybox2_0x4CE535E1.ps_5_0.hlsl @@ -0,0 +1,975 @@ +#include "../shared.h" + +Texture2D t7 : register(t7); + +Texture2D t6 : register(t6); + +Texture2D t5 : register(t5); + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture3D t0 : register(t0); + +SamplerState s6_s : register(s6); + +SamplerState s5_s : register(s5); + +SamplerState s4_s : register(s4); + +SamplerState s3_s : register(s3); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb2 : register(b2) +{ + float4 cb2[45]; +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[105]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[45]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, // Screen position + float3 v1 : TEXCOORD0, // World position + float2 v2 : TEXCOORD1, // Unused + float3 v3 : TEXCOORD2, // Motion vector data 1 + float3 v4 : TEXCOORD3, // Motion vector data 2 + float3 v5 : TEXCOORD4, // Unused + out float4 o0 : SV_Target0, // Final color output + out float4 o1 : SV_Target1) // Motion vectors output +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18; + uint4 bitmask, uiDest; + float4 fDest; + + // ============================================================================ + // VIEW DIRECTION AND DISTANCE CALCULATION + // ============================================================================ + r0.xyz = -cb0[44].xyz + v1.xyz; + r0.w = dot(r0.xyz, r0.xyz); + r1.x = max(9.99999994e-009, r0.w); + r1.x = rsqrt(r1.x); + r1.yzw = r1.xxx * r0.xyz; + r2.x = r1.x * r0.w; + r2.y = dot(abs(r1.yzw), float3(1,1,1)); + r2.y = 1 / r2.y; + r2.zw = r2.yy * r1.yw; + r2.z = r2.z + r2.w; + r2.y = r1.y * r2.y + -r2.w; + r3.xy = float2(1,1) + r2.zy; + r2.yz = float2(0.5,0.5) * r3.xy; + r2.yzw = t1.SampleLevel(s0_s, r2.yz, 0).xyz; + r3.x = saturate(r1.z * 10 + 1); + // ========================================================================== + // PROCEDURAL SUN DISK CALCULATION + // ========================================================================== + // cb2[44].xyz = sun direction + // cb2[43].x = sun size/falloff exponent + // cb2[42].xyz = sun color, cb2[42].w = sun intensity + r3.y = saturate(dot(-cb2[44].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) + r3.y = log2(r3.y); + // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) + float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; + r3.y = cb2[43].x * sunSizeMultiplier * r3.y; // Apply sun size exponent + r3.y = exp2(r3.y); + r3.z = r3.y * r3.y + 1; + r3.y = -r3.y * 1.98000002 + 1.98010004; + r3.w = log2(cb2[42].w); + r3.zw = float2(0.0100164423,0.649999976) * r3.zw; + r3.w = exp2(r3.w); + r3.w = 8 * r3.w; + r3.y = log2(r3.y); + r3.y = r3.w * r3.y; + r3.y = exp2(r3.y); + r3.y = max(9.99999975e-005, r3.y); + r3.y = r3.z / r3.y; + r3.z = r1.y / r1.w; + r3.w = cmp(abs(r3.z) < 1); + r4.x = 1 / abs(r3.z); + r4.x = r3.w ? abs(r3.z) : r4.x; + r4.y = r4.x * r4.x; + r4.z = r4.y * 0.0872929022 + -0.301894993; + r4.y = r4.z * r4.y + 1; + r4.z = r4.y * r4.x; + r4.x = -r4.y * r4.x + 1.57079637; + r3.w = r3.w ? r4.z : r4.x; + r4.x = abs(r1.z) * 0.0468878001 + -0.203471005; + r4.x = r4.x * abs(r1.z) + 1.57079601; + r4.y = 1 + -abs(r1.z); + r4.y = sqrt(r4.y); + r4.z = r4.x * r4.y; + r3.z = cmp(r3.z < 0); + r3.z = r3.z ? -r3.w : r3.w; + r5.xy = cmp(r1.yz >= float2(0,0)); + r3.w = r5.x ? 3.1415925 : -3.1415925; + r4.w = cmp(r1.w < 0); + r4.w = r4.w ? 1.000000 : 0; + r6.x = r3.w * r4.w + r3.z; + r3.z = -r4.x * r4.y + 3.14159274; + r3.z = r5.y ? r4.z : r3.z; + r6.y = 1.57079637 + -r3.z; + r3.zw = r6.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); + r3.z = -cb2[41].w * 0.00277777785 + r3.z; + r4.x = 1 + r3.z; + r4.y = r3.w * 2 + -1; + // ============================================================================ + // CLOUD/ATMOSPHERE TEXTURE SAMPLING + // ============================================================================ + r4.xyzw = t2.SampleBias(s1_s, r4.xy, cb1[26].x).xyzw; + r5.xzw = float3(-0.5,-0.5,-0.5) + r4.xyz; + r4.xyz = r5.xzw * cb2[40].yyy + float3(0.5,0.5,0.5); + r6.xyzw = cb2[38].xyzw * r4.xyzw; + r3.z = max(r6.x, r6.y); + r4.xyzw = -r4.xyzw * cb2[38].xyzw + r3.zzzz; + r4.xyzw = cb2[40].xxxx * r4.xyzw + r6.xyzw; + r4.xyzw = cb2[39].xyzw * r4.xyzw; + r3.z = r5.y ? 1.000000 : 0; + r5.x = r4.w * r3.z; + r5.x = saturate(r5.x); + // ============================================================================ + // SUN SPECULAR HIGHLIGHT WITH SMOOTHSTEP + // ============================================================================ + r3.w = -0.5 + r3.y; + r3.w = saturate(r3.w + r3.w); + r4.w = r3.w * -2 + 3; + r3.w = r3.w * r3.w; + r3.w = r4.w * r3.w; + r4.w = r3.w * r3.y; + r3.y = -r3.w * r3.y + r3.y; + r3.y = cb2[43].y * r3.y + r4.w; // Sun brightness + r5.yzw = cb2[42].xyz * r3.yyy; // Apply sun color + r5.yzw = cb2[43].www * r5.yzw; // Sun intensity multiplier + r5.yzw = cb2[44].www * r5.yzw; // Sun shadow/occlusion + r5.yzw = max(float3(0,0,0), r5.yzw); + // HDR Sun toggle + if (SUN_INTENSITY > 0.5f) { + // Calculate sun-view alignment (1 = looking directly at sun center) + float sunDot = saturate(dot(-cb2[44].xyz, -r1.yzw)); + + // === HORIZON REDDENING === + // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) + float sunHeight = saturate(cb2[44].y + 0.1f); // Shift so effect starts slightly above horizon + + // Warm shift when sun is low (more red/orange near horizon) + float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange + float3(1.0f, 0.95f, 0.9f), // High sun: nearly white + sunHeight); + + // === LIMB DARKENING === + // Real stars appear darker at edges due to optical depth through atmosphere + // Use a soft power curve - center is brightest, edges darken + float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges + + // === CHROMATIC SUN EDGE === + // Core is white-hot, edges transition to yellow/orange + float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center + float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge + + // Blend from edge color to core color based on how centered we are + float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core + float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); + + // === COMBINE SUN DISK === + // Apply limb darkening and chromatic color to base sun + r5.yzw = r5.yzw * limbDarkening * chromaticColor * horizonTint; + + // Boost the sun intensity for HDR + r5.yzw = r5.yzw * 5.0f; + + // === CORONA GLOW === + // Inner corona (tight glow) + float coronaInner = pow(sunDot, 64.0f); + // Outer corona (wide soft glow) + float coronaOuter = pow(sunDot, 8.0f); + + // Corona colors - also affected by horizon + float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon + float3(1.0f, 0.7f, 0.3f), // Normal inner + sunHeight); + float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon + float3(1.0f, 0.5f, 0.2f), // Normal outer + sunHeight); + + float3 corona = coronaInner * coronaColorInner * 2.0f + + coronaOuter * coronaColorOuter * 0.5f; + + // Modulate corona by sun color/intensity from game + corona *= cb2[42].xyz * cb2[42].w; + corona *= cb2[44].w; // Sun shadow/occlusion + + // Add corona to sun + r5.yzw += corona; + + // === DESATURATE SUN (50%) === + float sunLuma = dot(r5.yzw, float3(0.2126f, 0.7152f, 0.0722f)); + r5.yzw = lerp(r5.yzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); + + // === BLOOM BOOST === + r5.yzw *= 10.0f; + + } else { + // Vanilla clamp + r5.yzw = min(float3(3,3,3), r5.yzw); + } + + // Combine skybox, sun specular, and clouds + r2.yzw = r2.yzw * r3.xxx + r5.yzw; + r3.xyw = r4.xyz * r3.zzz + -r2.yzw; + r2.yzw = r5.xxx * r3.xyw + r2.yzw; + // ============================================================================ + // VOLUMETRIC LIGHT SHAFT SYSTEM 1 (conditional) + // ============================================================================ + r3.xy = cmp(float2(0.75,0.75) < cb2[0].xy); + if (r3.x != 0) { + r3.x = 1 / cb2[27].x; + r3.w = cb2[27].w + cb2[27].x; + r4.w = rsqrt(r0.w); + r5.yzw = r4.www * r0.xyz; + // ============================================================================ + // SPHERICAL LIGHT SOURCE INTERSECTION (cb2[15] = light position) + // ============================================================================ + r4.w = dot(r5.yzw, cb2[15].xyz); + r6.x = cb2[19].x * cb2[19].x + -1; + r6.x = r4.w * r4.w + r6.x; + r6.y = max(0, r6.x); + r6.y = sqrt(r6.y); + r4.w = -r6.y + r4.w; + r6.yzw = r5.yzw * r4.www + -cb2[15].xyz; + r6.yzw = r6.yzw / cb2[19].xxx; + r4.w = dot(cb2[15].xyz, cb2[15].xyz); + r4.w = rsqrt(r4.w); + r7.xyz = cb2[15].xyz * r4.www; + r4.w = saturate(dot(r5.yzw, r7.xyz)); + r4.w = r6.x * r4.w; + r4.w = max(0, r4.w); + r4.w = cmp(0 < r4.w); + r6.x = r4.w ? 1.000000 : 0; + r7.x = dot(cb2[21].xyz, cb2[15].xyz); + r7.y = dot(cb2[21].xyz, r5.yzw); + r7.x = abs(r7.x) / abs(r7.y); + r7.xyz = r5.yzw * r7.xxx + -cb2[15].xyz; + r7.w = dot(r7.xyz, r7.xyz); + r7.w = sqrt(r7.w); + r8.xyz = r7.xyz / r7.www; + r7.x = dot(cb2[21].xyz, r7.xyz); + r7.x = cmp(abs(r7.x) < 0.00100000005); + r7.x = r7.x ? 1.000000 : 0; + r7.x = r7.w * r7.x; + r7.y = r7.x * cb2[19].z + cb2[19].w; + r7.z = dot(r6.yzw, cb2[21].xyz); + r9.xyz = -cb2[21].xyz * r7.zzz + r6.yzw; + r8.w = dot(r9.xyz, r9.xyz); + r8.w = rsqrt(r8.w); + r9.xyz = r9.xyz * r8.www; + r8.w = dot(r9.xyz, cb2[25].xyz); + r9.w = cmp(0 < r8.w); + r8.w = cmp(r8.w < 0); + r8.w = (int)-r9.w + (int)r8.w; + r8.w = (int)r8.w; + r9.w = saturate(-r8.w); + r9.x = dot(r9.xyz, cb2[23].xyz); + r9.y = 1 + -abs(r9.x); + r9.y = sqrt(r9.y); + r9.z = abs(r9.x) * -0.0187292993 + 0.0742610022; + r9.z = r9.z * abs(r9.x) + -0.212114394; + r9.z = r9.z * abs(r9.x) + 1.57072878; + r10.x = r9.z * r9.y; + r10.x = r10.x * -2 + 3.14159274; + r9.x = cmp(r9.x < -r9.x); + r9.x = r9.x ? r10.x : 0; + r9.x = r9.z * r9.y + r9.x; + r8.w = r9.x * r8.w; + r9.x = r8.w * 0.159154937 + r9.w; + r8.w = r7.z * r7.z; + r8.w = r8.w * -0.222222224 + -0.277777791; + r9.y = r8.w * -r7.z + 0.50000006; + r10.xyzw = t3.SampleBias(s2_s, r9.xy, cb1[26].x).xyzw; + r6.y = saturate(dot(cb2[17].xyz, r6.yzw)); + r6.y = saturate(r6.y * cb2[1].x + cb2[1].z); + r9.xyz = t5.SampleBias(s4_s, r9.xy, cb1[26].x).xyz; + r9.xyz = cb2[9].xyz * r9.xyz; + r10.xyz = r10.xyz * r6.yyy + r9.xyz; + r9.xyzw = r10.xyzw * r6.xxxx; + r6.z = saturate(1 + -r7.y); + r6.z = r6.z * r7.y; + r6.w = cmp(0 < r6.z); + r6.z = cmp(r6.z < 0); + r6.z = (int)-r6.w + (int)r6.z; + r6.z = (int)r6.z; + r6.w = dot(r5.yzw, r8.xyz); + r7.z = cmp(0 < -r6.w); + r6.w = cmp(-r6.w < 0); + r6.w = (int)-r7.z + (int)r6.w; + r6.w = (int)r6.w; + r6.zw = saturate(r6.zw); + r6.w = -1 + r6.w; + r6.x = r6.x * r6.w + 1; + r6.x = r6.z * r6.x; + r6.z = dot(r8.xyz, cb2[25].xyz); + r6.w = cmp(0 < r6.z); + r6.z = cmp(r6.z < 0); + r6.z = (int)-r6.w + (int)r6.z; + r6.z = (int)r6.z; + r6.w = dot(cb2[17].xyz, r8.xyz); + r6.w = saturate(-r6.w); + r7.z = saturate(-r6.z); + r8.x = dot(r8.xyz, cb2[23].xyz); + r8.y = 1 + -abs(r8.x); + r8.y = sqrt(r8.y); + r8.z = abs(r8.x) * -0.0187292993 + 0.0742610022; + r8.z = r8.z * abs(r8.x) + -0.212114394; + r8.z = r8.z * abs(r8.x) + 1.57072878; + r8.w = r8.z * r8.y; + r8.w = r8.w * -2 + 3.14159274; + r8.x = cmp(r8.x < -r8.x); + r8.x = r8.x ? r8.w : 0; + r8.x = r8.z * r8.y + r8.x; + r6.z = r8.x * r6.z; + r7.x = r6.z * 0.159154937 + r7.z; + r8.xyzw = t7.SampleBias(s6_s, r7.xy, cb1[26].x).xyzw; + r8.xyzw = cb2[7].xyzw * r8.xyzw; + r6.z = -r6.w * r6.w + 1; + r6.z = sqrt(r6.z); + r6.z = -r7.w * r6.z + cb2[19].x; + r6.z = cb2[19].y * r6.z; + r6.z = r6.z / cb2[0].z; + r6.z = saturate(1 + r6.z); + r6.z = 1 + -r6.z; + r6.w = dot(cb2[17].xyz, cb2[21].xyz); + r6.w = 0.400000006 + abs(r6.w); + r6.w = min(1, r6.w); + r6.z = r6.z * r6.w; + r7.xyzw = r8.xyzw * r6.zzzz; + r7.xyz = r7.xyz * r7.www; + r7.xyz = r7.xyz * r6.xxx; + r8.xyz = r9.xyz * r10.www + r7.xyz; + r6.x = r7.w * r6.x; + r4.w = r4.w ? 0 : 1; + r8.w = r6.x * r4.w + r9.w; + r4.w = saturate(r5.z); + r4.w = -1 + r4.w; + r4.w = cb2[29].w * r4.w + 1; + r7.xyzw = cb2[5].xyzw * r8.xyzw; + r8.xyzw = r7.xyzw * r4.wwww; + r6.x = dot(r5.yzw, r5.yzw); + r6.x = max(1.17549435e-038, r6.x); + r6.x = rsqrt(r6.x); + r5.yzw = r6.xxx * r5.yzw; + r6.x = dot(cb2[17].xyz, cb2[17].xyz); + r6.x = max(1.17549435e-038, r6.x); + r6.x = rsqrt(r6.x); + r6.xzw = cb2[17].xyz * r6.xxx; + r9.xyz = -cb2[13].xyz + cb0[44].xyz; + r9.w = dot(r5.yzw, r9.xyz); + r9.x = dot(r9.xyz, r9.xyz); + r9.y = -r3.w * r3.w + r9.x; + r9.y = r9.w * r9.w + -r9.y; + r9.z = cmp(0 < r9.y); + r9.y = sqrt(r9.y); + r10.x = -r9.w + -r9.y; + r10.x = max(0, r10.x); + r9.y = -r9.w + r9.y; + r10.y = r9.y + -r10.x; + r10.xy = r9.zz ? r10.xy : 0; + if (r9.z != 0) { + r9.x = -cb2[27].w * cb2[27].w + r9.x; + r9.x = r9.w * r9.w + -r9.x; + r9.y = cmp(0 < r9.x); + r9.x = sqrt(r9.x); + r9.x = -r9.w + -r9.x; + r9.x = max(0, r9.x); + r9.x = r9.y ? r9.x : 0; + r9.z = cmp(0 < r9.x); + r9.x = r9.x + -r10.x; + r9.x = min(r10.y, r9.x); + r9.x = r9.z ? r9.x : r10.y; + r9.x = r9.y ? r9.x : r10.y; + r9.y = cmp(0 < r9.x); + if (r9.y != 0) { + r9.x = r9.x / cb2[27].y; + r9.y = dot(-r5.yzw, r6.xzw); + r10.yzw = cb2[27].zzz * float3(0.000244140625,0.0012673497,0.00266802101); + r11.xyz = r5.yzw * r10.xxx + cb0[44].xyz; + r12.xyz = r9.xxx * r5.yzw; + r11.xyz = r12.xyz * float3(0.5,0.5,0.5) + r11.xyz; + r12.xyz = float3(0.5,0.5,0.5) * r6.xzw; + r13.xyz = r11.xyz; + r14.xyz = float3(0,0,0); + r9.zw = float2(0,0); + while (true) { + r10.x = (int)r9.w; + r10.x = cmp(r10.x >= cb2[27].y); + if (r10.x != 0) break; + r15.xyz = -cb2[13].xyz + r13.xyz; + r10.x = dot(r15.xyz, r15.xyz); + r11.w = sqrt(r10.x); + r11.w = -cb2[27].w + r11.w; + r11.w = r11.w * r3.x; + r11.w = cb2[28].y * -r11.w; + r11.w = 1.44269502 * r11.w; + r11.w = exp2(r11.w); + r11.w = r11.w * r9.x; + r11.w = min(3.40282347e+038, r11.w); + r9.z = r11.w + r9.z; + r12.w = dot(r6.xzw, r15.xyz); + r10.x = -r3.w * r3.w + r10.x; + r10.x = r12.w * r12.w + -r10.x; + r13.w = cmp(0 < r10.x); + r10.x = sqrt(r10.x); + r14.w = -r12.w + r10.x; + r10.x = -r12.w + -r10.x; + r10.x = max(0, r10.x); + r10.x = r14.w + -r10.x; + r10.x = r13.w ? r10.x : 0; + r10.x = r10.x / cb2[28].x; + r15.xyz = r12.xyz * r10.xxx + r13.xyz; + r16.xyz = r15.xyz; + r12.w = 0; + r13.w = 0; + while (true) { + r14.w = (int)r13.w; + r14.w = cmp(r14.w >= cb2[28].x); + if (r14.w != 0) break; + r17.xyz = -cb2[13].xyz + r16.xyz; + r18.xyz = r6.xzw * r10.xxx + r16.xyz; + r14.w = dot(r17.xyz, r17.xyz); + r14.w = sqrt(r14.w); + r14.w = -cb2[27].w + r14.w; + r14.w = max(0, r14.w); + r14.w = r14.w * r3.x; + r14.w = cb2[28].y * -r14.w; + r14.w = 1.44269502 * r14.w; + r14.w = exp2(r14.w); + r14.w = r14.w + r12.w; + r15.w = (int)r13.w + 1; + r16.xyz = r18.xyz; + r12.w = r14.w; + r13.w = r15.w; + continue; + } + r10.x = r12.w * r10.x + r9.z; + r15.xyz = r10.yzw * r10.xxx; + r15.xyz = float3(-1.44269502,-1.44269502,-1.44269502) * r15.xyz; + r15.xyz = exp2(r15.xyz); + r14.xyz = r15.xyz * r11.www + r14.xyz; + r13.xyz = r5.yzw * r9.xxx + r13.xyz; + r9.w = (int)r9.w + 1; + } + r3.x = r9.y * r9.y + 1; + r3.x = 0.0596831031 * r3.x; + r5.yzw = r14.xyz * r3.xxx; + r5.yzw = r5.yzw * r10.yzw; + } else { + r5.yzw = float3(0,0,0); + } + } else { + r5.yzw = float3(0,0,0); + } + r9.xyw = cb2[28].zzz * r5.zwy; + r3.x = cmp(r9.x >= r9.y); + r3.x = r3.x ? 1.000000 : 0; + r10.xy = r9.yx; + r10.zw = float2(-1,0.666666687); + r11.xy = r5.zw * cb2[28].zz + -r10.xy; + r11.zw = float2(1,-1); + r10.xyzw = r3.xxxx * r11.xyzw + r10.xyzw; + r3.x = cmp(r9.w >= r10.x); + r3.x = r3.x ? 1.000000 : 0; + r9.xyz = r10.xyw; + r10.xyw = r9.wyx; + r10.xyzw = r10.xyzw + -r9.xyzw; + r9.xyzw = r3.xxxx * r10.xyzw + r9.xyzw; + r3.x = min(r9.w, r9.y); + r3.x = r9.x + -r3.x; + r3.w = r9.w + -r9.y; + r5.y = r3.x * 6 + 9.99999975e-005; + r3.w = r3.w / r5.y; + r3.w = r9.z + r3.w; + r3.w = cb2[28].w + abs(r3.w); + r5.yzw = float3(1,0.666666687,0.333333343) + r3.www; + r5.yzw = frac(r5.yzw); + r5.yzw = r5.yzw * float3(6,6,6) + float3(-3,-3,-3); + r5.yzw = saturate(float3(-1,-1,-1) + abs(r5.yzw)); + r3.w = 9.99999975e-005 + r9.x; + r3.x = r3.x / r3.w; + r5.yzw = float3(-1,-1,-1) + r5.yzw; + r5.yzw = r3.xxx * r5.yzw + float3(1,1,1); + r6.xzw = r5.yzw * r9.xxx; + r3.x = cmp(cb2[2].x >= 0.5); + r3.x = r3.x ? 1.000000 : 0; + r9.yz = cmp(float2(1.5,0.5) >= cb2[2].xx); + r9.yz = r9.yz ? float2(1,1) : 0; + r3.x = -r3.x * r9.y + 1; + r3.x = -r8.w * r3.x + 1; + r3.w = dot(r8.xyz, float3(0.212672904,0.715152204,0.0721750036)); + r7.xyz = r7.xyz * r4.www + -r3.www; + r7.xyz = cb1[104].www * r7.xyz + r3.www; + r7.xyz = cb1[104].xyz * r7.xyz; + r3.w = -r7.w * r4.w + 1; + r3.w = -r3.w * r9.z + 1; + r7.xyz = r7.xyz * r3.www; + r7.xyz = r2.yzw * r3.xxx + r7.xyz; + r6.xyz = r6.xzw * r6.yyy; + r5.yzw = r5.yzw * r9.xxx + -r6.xyz; + r5.yzw = cb2[29].yyy * r5.yzw + r6.xyz; + r2.yzw = r5.yzw * r4.www + r7.xyz; + } + if (r3.y != 0) { + r3.x = 1 / cb2[30].x; + r3.y = cb2[30].w + cb2[30].x; + r3.w = rsqrt(r0.w); + r5.yzw = r3.www * r0.xyz; + r0.x = dot(r5.yzw, cb2[16].xyz); + r0.z = cb2[20].x * cb2[20].x + -1; + r0.z = r0.x * r0.x + r0.z; + r3.w = max(0, r0.z); + r3.w = sqrt(r3.w); + r0.x = -r3.w + r0.x; + r6.xyz = r5.yzw * r0.xxx + -cb2[16].xyz; + r6.xyz = r6.xyz / cb2[20].xxx; + r0.x = dot(r6.xyz, cb2[22].xyz); + r7.xyz = -cb2[22].xyz * r0.xxx + r6.xyz; + r3.w = dot(r7.xyz, r7.xyz); + r3.w = rsqrt(r3.w); + r7.xyz = r7.xyz * r3.www; + r3.w = dot(r7.xyz, cb2[26].xyz); + r4.w = cmp(0 < r3.w); + r3.w = cmp(r3.w < 0); + r3.w = (int)-r4.w + (int)r3.w; + r3.w = (int)r3.w; + r4.w = saturate(-r3.w); + r6.w = dot(r7.xyz, cb2[24].xyz); + r7.x = 1 + -abs(r6.w); + r7.x = sqrt(r7.x); + r7.y = abs(r6.w) * -0.0187292993 + 0.0742610022; + r7.y = r7.y * abs(r6.w) + -0.212114394; + r7.y = r7.y * abs(r6.w) + 1.57072878; + r7.z = r7.y * r7.x; + r7.z = r7.z * -2 + 3.14159274; + r6.w = cmp(r6.w < -r6.w); + r6.w = r6.w ? r7.z : 0; + r6.w = r7.y * r7.x + r6.w; + r3.w = r6.w * r3.w; + r7.x = r3.w * 0.159154937 + r4.w; + r3.w = r0.x * r0.x; + r3.w = r3.w * -0.222222224 + -0.277777791; + r7.y = r3.w * -r0.x + 0.50000006; + r8.xyzw = t4.SampleBias(s3_s, r7.xy, cb1[26].x).xyzw; + r0.x = saturate(dot(cb2[18].xyz, r6.xyz)); + r0.x = saturate(r0.x * cb2[1].y + cb2[1].w); + r6.xyz = t6.SampleBias(s5_s, r7.xy, cb1[26].x).xyz; + r6.xyz = cb2[10].xyz * r6.xyz; + r8.xyz = r8.xyz * r0.xxx + r6.xyz; + r3.w = dot(cb2[16].xyz, cb2[16].xyz); + r3.w = rsqrt(r3.w); + r6.xyz = cb2[16].xyz * r3.www; + r3.w = saturate(dot(r5.yzw, r6.xyz)); + r0.z = r3.w * r0.z; + r0.z = max(0, r0.z); + r0.z = cmp(0 < r0.z); + r0.z = r0.z ? 1.000000 : 0; + r6.xyzw = r8.xyzw * r0.zzzz; + r6.xyz = r6.xyz * r8.www; + r0.z = saturate(r5.z); + r0.z = -1 + r0.z; + r0.z = cb2[32].w * r0.z + 1; + r6.xyzw = cb2[6].xyzw * r6.xyzw; + r7.xyzw = r6.xyzw * r0.zzzz; + r3.w = dot(r5.yzw, r5.yzw); + r3.w = max(1.17549435e-038, r3.w); + r3.w = rsqrt(r3.w); + r5.yzw = r5.yzw * r3.www; + r3.w = dot(cb2[18].xyz, cb2[18].xyz); + r3.w = max(1.17549435e-038, r3.w); + r3.w = rsqrt(r3.w); + r6.xyz = cb2[18].xyz * r3.www; + r8.xyz = -cb2[14].xyz + cb0[44].xyz; + r3.w = dot(r5.yzw, r8.xyz); + r4.w = dot(r8.xyz, r8.xyz); + r8.x = -r3.y * r3.y + r4.w; + r8.x = r3.w * r3.w + -r8.x; + r8.y = cmp(0 < r8.x); + r8.x = sqrt(r8.x); + r8.z = -r8.x + -r3.w; + r9.x = max(0, r8.z); + r8.x = r8.x + -r3.w; + r9.y = r8.x + -r9.x; + r8.xz = r8.yy ? r9.xy : 0; + if (r8.y != 0) { + r4.w = -cb2[30].w * cb2[30].w + r4.w; + r4.w = r3.w * r3.w + -r4.w; + r8.y = cmp(0 < r4.w); + r4.w = sqrt(r4.w); + r3.w = -r4.w + -r3.w; + r3.w = max(0, r3.w); + r3.w = r8.y ? r3.w : 0; + r4.w = cmp(0 < r3.w); + r3.w = r3.w + -r8.x; + r3.w = min(r8.z, r3.w); + r3.w = r4.w ? r3.w : r8.z; + r3.w = r8.y ? r3.w : r8.z; + r4.w = cmp(0 < r3.w); + if (r4.w != 0) { + r3.w = r3.w / cb2[30].y; + r4.w = dot(-r5.yzw, r6.xyz); + r8.yzw = cb2[30].zzz * float3(0.000244140625,0.0012673497,0.00266802101); + r9.xyz = r5.yzw * r8.xxx + cb0[44].xyz; + r10.xyz = r5.yzw * r3.www; + r9.xyz = r10.xyz * float3(0.5,0.5,0.5) + r9.xyz; + r10.xyz = float3(0.5,0.5,0.5) * r6.xyz; + r11.xyz = r9.xyz; + r12.xyz = float3(0,0,0); + r8.x = 0; + r9.w = 0; + while (true) { + r10.w = (int)r9.w; + r10.w = cmp(r10.w >= cb2[30].y); + if (r10.w != 0) break; + r13.xyz = -cb2[14].xyz + r11.xyz; + r10.w = dot(r13.xyz, r13.xyz); + r11.w = sqrt(r10.w); + r11.w = -cb2[30].w + r11.w; + r11.w = r11.w * r3.x; + r11.w = cb2[31].y * -r11.w; + r11.w = 1.44269502 * r11.w; + r11.w = exp2(r11.w); + r11.w = r11.w * r3.w; + r11.w = min(3.40282347e+038, r11.w); + r8.x = r11.w + r8.x; + r12.w = dot(r6.xyz, r13.xyz); + r10.w = -r3.y * r3.y + r10.w; + r10.w = r12.w * r12.w + -r10.w; + r13.x = cmp(0 < r10.w); + r10.w = sqrt(r10.w); + r13.y = -r12.w + r10.w; + r10.w = -r12.w + -r10.w; + r10.w = max(0, r10.w); + r10.w = r13.y + -r10.w; + r10.w = r13.x ? r10.w : 0; + r10.w = r10.w / cb2[31].x; + r13.xyz = r10.xyz * r10.www + r11.xyz; + r14.xyz = r13.xyz; + r12.w = 0; + r13.w = 0; + while (true) { + r14.w = (int)r13.w; + r14.w = cmp(r14.w >= cb2[31].x); + if (r14.w != 0) break; + r15.xyz = -cb2[14].xyz + r14.xyz; + r16.xyz = r6.xyz * r10.www + r14.xyz; + r14.w = dot(r15.xyz, r15.xyz); + r14.w = sqrt(r14.w); + r14.w = -cb2[30].w + r14.w; + r14.w = max(0, r14.w); + r14.w = r14.w * r3.x; + r14.w = cb2[31].y * -r14.w; + r14.w = 1.44269502 * r14.w; + r14.w = exp2(r14.w); + r14.w = r14.w + r12.w; + r15.x = (int)r13.w + 1; + r14.xyz = r16.xyz; + r12.w = r14.w; + r13.w = r15.x; + continue; + } + r10.w = r12.w * r10.w + r8.x; + r13.xyz = r10.www * r8.yzw; + r13.xyz = float3(-1.44269502,-1.44269502,-1.44269502) * r13.xyz; + r13.xyz = exp2(r13.xyz); + r12.xyz = r13.xyz * r11.www + r12.xyz; + r11.xyz = r5.yzw * r3.www + r11.xyz; + r9.w = (int)r9.w + 1; + } + r3.x = r4.w * r4.w + 1; + r3.x = 0.0596831031 * r3.x; + r3.xyw = r12.xyz * r3.xxx; + r3.xyw = r3.xyw * r8.yzw; + } else { + r3.xyw = float3(0,0,0); + } + } else { + r3.xyw = float3(0,0,0); + } + r8.xyw = cb2[31].zzz * r3.ywx; + r3.x = cmp(r8.x >= r8.y); + r3.x = r3.x ? 1.000000 : 0; + r9.xy = r8.yx; + r9.zw = float2(-1,0.666666687); + r10.xy = r3.yw * cb2[31].zz + -r9.xy; + r10.zw = float2(1,-1); + r9.xyzw = r3.xxxx * r10.xyzw + r9.xyzw; + r3.x = cmp(r8.w >= r9.x); + r3.x = r3.x ? 1.000000 : 0; + r8.xyz = r9.xyw; + r9.xyw = r8.wyx; + r9.xyzw = r9.xyzw + -r8.xyzw; + r8.xyzw = r3.xxxx * r9.xyzw + r8.xyzw; + r3.x = min(r8.w, r8.y); + r3.x = r8.x + -r3.x; + r3.y = r8.w + -r8.y; + r3.w = r3.x * 6 + 9.99999975e-005; + r3.y = r3.y / r3.w; + r3.y = r8.z + r3.y; + r3.y = cb2[31].w + abs(r3.y); + r5.yzw = float3(1,0.666666687,0.333333343) + r3.yyy; + r5.yzw = frac(r5.yzw); + r5.yzw = r5.yzw * float3(6,6,6) + float3(-3,-3,-3); + r5.yzw = saturate(float3(-1,-1,-1) + abs(r5.yzw)); + r3.y = 9.99999975e-005 + r8.x; + r3.x = r3.x / r3.y; + r5.yzw = float3(-1,-1,-1) + r5.yzw; + r3.xyw = r3.xxx * r5.yzw + float3(1,1,1); + r5.yzw = r3.xyw * r8.xxx; + r4.w = cmp(cb2[2].y >= 0.5); + r4.w = r4.w ? 1.000000 : 0; + r6.xy = cmp(float2(1.5,0.5) >= cb2[2].yy); + r6.xy = r6.xy ? float2(1,1) : 0; + r4.w = -r4.w * r6.x + 1; + r4.w = -r7.w * r4.w + 1; + r6.x = -r6.w * r0.z + 1; + r6.x = -r6.x * r6.y + 1; + r6.xyz = r7.xyz * r6.xxx; + r6.xyz = r2.yzw * r4.www + r6.xyz; + r5.yzw = r5.yzw * r0.xxx; + r3.xyw = r3.xyw * r8.xxx + -r5.yzw; + r3.xyw = cb2[32].yyy * r3.xyw + r5.yzw; + r2.yzw = r3.xyw * r0.zzz + r6.xyz; + } + r3.xyz = r4.xyz * r3.zzz + -r2.yzw; + r2.yzw = r5.xxx * r3.xyz + r2.yzw; + r0.x = v1.y * cb1[74].w + cb1[75].w; + r0.z = r2.x * cb1[72].w + -cb1[71].w; + r0.xz = max(float2(0.00999999978,0), r0.xz); + r3.x = -1.44269502 * r0.x; + r3.x = exp2(r3.x); + r3.x = 1 + -r3.x; + r0.x = r3.x / r0.x; + r3.x = v1.y * cb1[74].w + cb1[76].w; + r3.x = 1.44269502 * r3.x; + r3.x = exp2(r3.x); + r0.x = r3.x * r0.x; + r0.x = -r0.z * r0.x; + r3.xyz = cb1[73].xyz * r0.xxx; + r3.xyz = float3(1.44269502,1.44269502,1.44269502) * r3.xyz; + r3.xyz = exp2(r3.xyz); + r0.x = dot(r1.yzw, cb1[72].xyz); + r0.z = cb1[73].w * cb1[73].w + 1; + r3.w = dot(r0.xx, cb1[73].ww); + r0.z = -r3.w + r0.z; + r3.w = cmp(0 < cb1[83].z); + if (r3.w != 0) { + r4.xy = (uint2)v0.xy; + r4.z = 7 & asint(cb1[26].w); + r5.xyz = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); + r3.w = mad((int)r5.y, (int)r5.z, (int)r5.x); + r4.z = mad((int)r5.z, (int)r3.w, (int)r5.y); + r4.w = mad((int)r3.w, (int)r4.z, (int)r5.z); + r5.x = mad((int)r4.z, (int)r4.w, (int)r3.w); + r6.x = -cb0[0].z; + r6.y = -cb0[1].z; + r6.z = -cb0[2].z; + r3.w = dot(r1.yzw, r6.xyz); + r5.z = cmp(5.96046448e-008 < r3.w); + r3.w = 1 / r3.w; + r3.w = r5.z ? r3.w : 0; + r3.w = cb1[83].w * r3.w; + r5.z = 1 / r2.x; + r5.w = r5.z * r3.w; + r6.x = r5.w * r0.y + cb0[44].y; + r5.w = -r5.w * r0.y + r0.y; + r3.w = -r3.w * r5.z + 1; + r5.z = r3.w * r2.x; + r6.y = cb1[77].z * r5.w; + r5.w = cb1[80].x * r5.w; + r5.w = max(-127, r5.w); + r6.z = -cb1[77].x + r6.x; + r6.z = cb1[77].z * r6.z; + r6.yz = max(float2(-127,-127), r6.yz); + r6.z = exp2(-r6.z); + r6.z = cb1[77].y * r6.z; + r6.w = cmp(5.96046448e-008 < abs(r6.y)); + r7.x = exp2(-r6.y); + r7.x = 1 + -r7.x; + r7.x = r7.x / r6.y; + r6.y = -r6.y * 0.240226507 + 0.693147182; + r6.y = r6.w ? r7.x : r6.y; + r6.x = -cb1[80].z + r6.x; + r6.x = cb1[80].x * r6.x; + r6.x = max(-127, r6.x); + r6.x = exp2(-r6.x); + r6.x = cb1[80].y * r6.x; + r6.w = cmp(5.96046448e-008 < abs(r5.w)); + r7.x = exp2(-r5.w); + r7.x = 1 + -r7.x; + r7.x = r7.x / r5.w; + r5.w = -r5.w * 0.240226507 + 0.693147182; + r5.w = r6.w ? r7.x : r5.w; + r5.w = r6.x * r5.w; + r5.w = r6.z * r6.y + r5.w; + r6.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r5.z = r5.w * r5.z; + r5.z = exp2(-r5.z); + r5.z = min(1, r5.z); + r5.z = max(cb1[79].w, r5.z); + r5.z = r5.z + r6.y; + r5.z = r5.z + r6.x; + r5.z = min(1, r5.z); + r5.y = mad((int)r4.w, (int)r5.x, (int)r4.z); + r4.zw = (uint2)r5.xy >> int2(16,16); + r4.xyzw = (uint4)r4.xyzw; + r4.zw = r4.zw * float2(3.05180438e-005,3.05180438e-005) + float2(-1,-1); + r4.xy = r4.zw * cb1[87].ww + r4.xy; + r4.xy = cb1[85].xy * r4.xy; + r4.w = v0.w * cb1[84].x + cb1[84].y; + r4.w = log2(r4.w); + r4.w = cb1[84].z * r4.w; + r4.z = r4.w / cb1[83].z; + r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; + r5.x = -cb1[86].z + v0.w; + r5.x = saturate(1000000 * r5.x); + r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; + r4.xyzw = r5.xxxx * r4.xyzw + float4(0,0,0,1); + r5.x = 1 + -r5.z; + r5.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r5.y = log2(r5.y); + r5.y = cb1[82].w * r5.y; + r5.y = exp2(r5.y); + r6.yzw = cb1[82].xyz * r5.yyy; + r3.w = r3.w * r2.x + -cb1[81].w; + r3.w = max(0, r3.w); + r3.w = r5.w * r3.w; + r3.w = exp2(-r3.w); + r3.w = min(1, r3.w); + r3.w = 1 + -r3.w; + r6.yzw = r6.yzw * r3.www; + r3.w = 1 + -r6.x; + r6.xyz = r6.yzw * r3.www; + r5.xyw = cb1[79].xyz * r5.xxx + r6.xyz; + r4.xyz = r5.xyw * r4.www + r4.xyz; + r3.w = r4.w * r5.z; + } else { + r4.w = cb1[77].z * r0.y; + r4.w = max(-127, r4.w); + r0.y = cb1[80].x * r0.y; + r0.y = max(-127, r0.y); + r5.x = -cb1[77].x + cb0[44].y; + r5.x = cb1[77].z * r5.x; + r5.x = max(-127, r5.x); + r5.x = exp2(-r5.x); + r5.x = cb1[77].y * r5.x; + r5.y = cmp(5.96046448e-008 < abs(r4.w)); + r5.z = exp2(-r4.w); + r5.z = 1 + -r5.z; + r5.z = r5.z / r4.w; + r4.w = -r4.w * 0.240226507 + 0.693147182; + r4.w = r5.y ? r5.z : r4.w; + r5.y = -cb1[80].z + cb0[44].y; + r5.y = cb1[80].x * r5.y; + r5.y = max(-127, r5.y); + r5.y = exp2(-r5.y); + r5.y = cb1[80].y * r5.y; + r5.z = cmp(5.96046448e-008 < abs(r0.y)); + r5.w = exp2(-r0.y); + r5.w = 1 + -r5.w; + r5.w = r5.w / r0.y; + r0.y = -r0.y * 0.240226507 + 0.693147182; + r0.y = r5.z ? r5.w : r0.y; + r0.y = r5.y * r0.y; + r0.y = r5.x * r4.w + r0.y; + r5.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r2.x = r0.y * r2.x; + r2.x = exp2(-r2.x); + r2.x = min(1, r2.x); + r2.x = max(cb1[79].w, r2.x); + r2.x = r2.x + r5.y; + r2.x = r2.x + r5.x; + r3.w = min(1, r2.x); + r2.x = 1 + -r3.w; + r1.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r1.y = log2(r1.y); + r1.y = cb1[82].w * r1.y; + r1.y = exp2(r1.y); + r1.yzw = cb1[82].xyz * r1.yyy; + r0.w = r0.w * r1.x + -cb1[81].w; + r0.w = max(0, r0.w); + r0.y = r0.y * r0.w; + r0.y = exp2(-r0.y); + r0.y = min(1, r0.y); + r0.y = 1 + -r0.y; + r1.xyz = r1.yzw * r0.yyy; + r0.y = 1 + -r5.x; + r1.xyz = r1.xyz * r0.yyy; + r4.xyz = cb1[79].xyz * r2.xxx + r1.xyz; + } + r0.y = dot(r2.yzw, float3(0.212672904,0.715152204,0.0721750036)); + r1.xyz = r2.yzw + -r0.yyy; + r1.xyz = cb1[104].www * r1.xyz + r0.yyy; + r1.xyz = cb1[104].xyz * r1.xyz; + r2.xyz = r3.xyz * r3.www; + r0.x = r0.x * r0.x + 1; + r0.x = 0.0596831031 * r0.x; + r0.xyw = cb1[74].xyz * r0.xxx + cb1[76].xyz; + r1.w = -cb1[73].w * cb1[73].w + 1; + r2.w = 12.566371 * r0.z; + r0.z = sqrt(r0.z); + r0.z = r2.w * r0.z; + r0.z = max(0.00100000005, r0.z); + r0.z = r1.w / r0.z; + r0.xyz = saturate(cb1[75].xyz * r0.zzz + r0.xyw); + r0.xyz = float3(255,255,255) * r0.xyz; + r3.xyz = float3(1,1,1) + -r3.xyz; + r0.xyz = r3.xyz * r0.xyz; + r0.xyz = r0.xyz * r3.www + r4.xyz; + o0.xyz = r1.xyz * r2.xyz + r0.xyz; + + // ========================================================================== + // SKYBOX DESATURATION (50%) ??? Tech Test Look + // ========================================================================== + if (TECH_TEST_LOOK > 0.5f) { + float skyboxLuma = dot(o0.xyz, float3(0.2126f, 0.7152f, 0.0722f)); + o0.xyz = lerp(o0.xyz, float3(skyboxLuma, skyboxLuma, skyboxLuma), 0.5f); + } + + r0.x = max(9.99999994e-009, v3.z); + r0.xy = v3.xy / r0.xx; + r0.z = max(9.99999994e-009, v4.z); + r0.zw = v4.xy / r0.zz; + r0.xy = r0.xy + -r0.zw; + r1.xy = float2(0.5,-0.5) * r0.xy; + r1.xy = sqrt(abs(r1.xy)); + r1.xy = sqrt(r1.xy); + r0.z = -r0.y; + r0.yw = cmp(float2(0,0) < r0.xz); + r0.xz = cmp(r0.xz < float2(0,0)); + r0.xy = (int2)-r0.yw + (int2)r0.xz; + r0.xy = (int2)r0.xy; + r0.xy = r1.xy * r0.xy; + o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); + o0.w = 1; + o1.zw = float2(0,0); + return; +} diff --git a/src/games/endfield/others/skybox2_0xEC809E79.ps_5_0.hlsl b/src/games/endfield/others/skybox2_0xEC809E79.ps_5_0.hlsl deleted file mode 100644 index 6b9daf3e12..0000000000 --- a/src/games/endfield/others/skybox2_0xEC809E79.ps_5_0.hlsl +++ /dev/null @@ -1,923 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 03:07:27 2026 - -#include "../shared.h" - -Texture2D t7 : register(t7); - -Texture2D t6 : register(t6); - -Texture2D t5 : register(t5); - -Texture2D t4 : register(t4); - -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture3D t0 : register(t0); - -SamplerState s6_s : register(s6); - -SamplerState s5_s : register(s5); - -SamplerState s4_s : register(s4); - -SamplerState s3_s : register(s3); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[52]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[185]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, // Screen position - float4 v1 : TEXCOORD0, // World position - float4 v2 : TEXCOORD1, // Unused - float4 v3 : TEXCOORD2, // Motion vector data 1 - float4 v4 : TEXCOORD3, // Motion vector data 2 - float3 v5 : TEXCOORD4, // Unused - out float4 o0 : SV_Target0, // Final color output - out float4 o1 : SV_Target1) // Motion vectors output -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16; - uint4 bitmask, uiDest; - float4 fDest; - - // ============================================================================ - // VIEW DIRECTION AND DISTANCE CALCULATION - // ============================================================================ - r0.xyz = -cb0[44].xyz + v1.xyz; - r0.w = dot(r0.xyz, r0.xyz); - r1.x = max(9.99999994e-09, r0.w); - r1.x = rsqrt(r1.x); - r1.yzw = r1.xxx * r0.xyz; - r1.x = r1.x * r0.w; - r2.x = dot(abs(r1.yzw), float3(1,1,1)); - r2.x = 1 / r2.x; - r2.yz = r2.xx * r1.yw; - r2.y = r2.y + r2.z; - r2.x = r1.y * r2.x + -r2.z; - r3.xy = float2(1,1) + r2.yx; - r2.xy = float2(0.5,0.5) * r3.xy; - r2.xyz = t1.SampleLevel(s0_s, r2.xy, 0).xyz; - r2.w = saturate(r1.z * 10 + 1); - - // ========================================================================== - // PROCEDURAL SUN DISK CALCULATION - // ========================================================================== - // cb1[11].xyz = sun direction - // cb1[10].x = sun size/falloff exponent - // cb1[9].xyz = sun color, cb1[9].w = sun intensity - r3.x = saturate(dot(-cb1[11].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) - r3.x = log2(r3.x); - - // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) - float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; - r3.x = cb1[10].x * sunSizeMultiplier * r3.x; // Apply sun size exponent - - r3.x = exp2(r3.x); - r3.y = r3.x * r3.x + 1; - r3.x = -r3.x * 1.98000002 + 1.98010004; - r3.z = log2(cb1[9].w); - r3.yz = float2(0.0100164423,0.649999976) * r3.yz; - r3.z = exp2(r3.z); - r3.z = 8 * r3.z; - r3.x = log2(r3.x); - r3.x = r3.z * r3.x; - r3.x = exp2(r3.x); - r3.x = max(9.99999975e-05, r3.x); - r3.x = r3.y / r3.x; - r3.y = r1.y / r1.w; - r3.z = cmp(abs(r3.y) < 1); - r3.w = 1 / abs(r3.y); - r3.w = r3.z ? abs(r3.y) : r3.w; - r4.x = r3.w * r3.w; - r4.y = r4.x * 0.0872929022 + -0.301894993; - r4.x = r4.y * r4.x + 1; - r4.y = r4.x * r3.w; - r3.w = -r4.x * r3.w + 1.57079637; - r3.z = r3.z ? r4.y : r3.w; - r3.w = abs(r1.z) * 0.0468878001 + -0.203471005; - r3.w = r3.w * abs(r1.z) + 1.57079601; - r4.x = 1 + -abs(r1.z); - r4.x = sqrt(r4.x); - r4.y = r4.x * r3.w; - r3.y = cmp(r3.y < 0); - r3.y = r3.y ? -r3.z : r3.z; - r4.zw = cmp(r1.yz >= float2(0,0)); - r3.z = r4.z ? 3.1415925 : -3.1415925; - r4.z = cmp(r1.w < 0); - r4.z = r4.z ? 1.000000 : 0; - r5.x = r3.z * r4.z + r3.y; - r3.y = -r3.w * r4.x + 3.14159274; - r3.y = r4.w ? r4.y : r3.y; - r5.y = 1.57079637 + -r3.y; - r3.yz = r5.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); - r3.y = -cb1[8].w * 0.00277777785 + r3.y; - - // ============================================================================ - // CLOUD/ATMOSPHERE TEXTURE SAMPLING - // ============================================================================ - r4.x = 1 + r3.y; - r4.y = r3.z * 2 + -1; - r5.xyzw = t2.SampleBias(s1_s, r4.xy, cb0[108].x).xyzw; - r3.yzw = float3(-0.5,-0.5,-0.5) + r5.xyz; - r5.xyz = r3.yzw * cb1[7].yyy + float3(0.5,0.5,0.5); - r6.xyzw = cb1[5].xyzw * r5.xyzw; - r3.y = max(r6.x, r6.y); - r5.xyzw = -r5.xyzw * cb1[5].xyzw + r3.yyyy; - r5.xyzw = cb1[7].xxxx * r5.xyzw + r6.xyzw; - r5.xyzw = cb1[6].xyzw * r5.xyzw; - r3.y = r4.w ? 1.000000 : 0; - r4.x = r5.w * r3.y; - r4.x = saturate(r4.x); - - // ============================================================================ - // SUN SPECULAR HIGHLIGHT WITH SMOOTHSTEP - // ============================================================================ - r3.z = -0.5 + r3.x; - r3.z = saturate(r3.z + r3.z); - r3.w = r3.z * -2 + 3; - r3.z = r3.z * r3.z; - r3.z = r3.w * r3.z; - r3.w = r3.z * r3.x; - r3.x = -r3.z * r3.x + r3.x; - r3.x = cb1[10].y * r3.x + r3.w; - r3.xzw = cb1[9].xyz * r3.xxx; - r3.xzw = cb1[10].www * r3.xzw; - r3.xzw = cb1[11].www * r3.xzw; - r3.xzw = max(float3(0,0,0), r3.xzw); - - // HDR Sun toggle - if (SUN_INTENSITY > 0.5f) { - // Calculate sun-view alignment (1 = looking directly at sun center) - float sunDot = saturate(dot(-cb1[11].xyz, -r1.yzw)); - - // === HORIZON REDDENING === - // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) - float sunHeight = saturate(cb1[11].y + 0.1f); // Shift so effect starts slightly above horizon - - // Warm shift when sun is low (more red/orange near horizon) - float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange - float3(1.0f, 0.95f, 0.9f), // High sun: nearly white - sunHeight); - - // === LIMB DARKENING === - // Real stars appear darker at edges due to optical depth through atmosphere - // Use a soft power curve - center is brightest, edges darken - float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges - - // === CHROMATIC SUN EDGE === - // Core is white-hot, edges transition to yellow/orange - float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center - float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge - - // Blend from edge color to core color based on how centered we are - float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core - float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); - - // === COMBINE SUN DISK === - // Apply limb darkening and chromatic color to base sun - r3.xzw = r3.xzw * limbDarkening * chromaticColor * horizonTint; - - // Boost the sun intensity for HDR - r3.xzw = r3.xzw * 5.0f; - - // === CORONA GLOW === - // Inner corona (tight glow) - float coronaInner = pow(sunDot, 64.0f); - // Outer corona (wide soft glow) - float coronaOuter = pow(sunDot, 8.0f); - - // Corona colors - also affected by horizon - float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon - float3(1.0f, 0.7f, 0.3f), // Normal inner - sunHeight); - float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon - float3(1.0f, 0.5f, 0.2f), // Normal outer - sunHeight); - - float3 corona = coronaInner * coronaColorInner * 2.0f - + coronaOuter * coronaColorOuter * 0.5f; - - // Modulate corona by sun color/intensity from game - corona *= cb1[9].xyz * cb1[9].w; - corona *= cb1[11].w; // Sun shadow/occlusion - - // Add corona to sun - r3.xzw += corona; - - // === DESATURATE SUN (50%) === - float sunLuma = dot(r3.xzw, float3(0.2126f, 0.7152f, 0.0722f)); - r3.xzw = lerp(r3.xzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); - - // === BLOOM BOOST === - r3.xzw *= 10.0f; - - } else { - // Vanilla clamp - r3.xzw = min(float3(3,3,3), r3.xzw); - } - - // Combine skybox, sun specular, and clouds - r2.xyz = r2.xyz * r2.www + r3.xzw; - r3.xzw = r5.xyz * r3.yyy + -r2.xyz; - r2.xyz = r4.xxx * r3.xzw + r2.xyz; - - // ============================================================================ - // VOLUMETRIC LIGHT SHAFT SYSTEM 1 (conditional) - // ============================================================================ - r3.xz = cmp(float2(0.5,0.5) < cb1[20].xy); - if (r3.x != 0) { - r2.w = 1 / cb1[46].x; - r3.x = cb1[46].w + cb1[46].x; - r3.w = rsqrt(r0.w); - r4.yzw = r3.www * r0.xyz; - - // ============================================================================ - // SPHERICAL LIGHT SOURCE INTERSECTION (cb1[23] = light position) - // ============================================================================ - r3.w = dot(r4.yzw, cb1[23].xyz); - r5.w = cb1[27].x * cb1[27].x + -1; - r5.w = r3.w * r3.w + r5.w; - r6.x = max(0, r5.w); - r6.x = sqrt(r6.x); - r3.w = -r6.x + r3.w; - r6.xyz = r4.yzw * r3.www + -cb1[23].xyz; - r6.xyz = r6.xyz / cb1[27].xxx; - r3.w = dot(cb1[23].xyz, cb1[23].xyz); - r3.w = rsqrt(r3.w); - r7.xyz = cb1[23].xyz * r3.www; - r3.w = saturate(dot(r4.yzw, r7.xyz)); - r3.w = r5.w * r3.w; - r3.w = max(0, r3.w); - r3.w = cmp(0 < r3.w); - r3.w = r3.w ? 1.000000 : 0; - r5.w = dot(cb1[29].xyz, cb1[23].xyz); - r6.w = dot(cb1[29].xyz, r4.yzw); - r5.w = abs(r5.w) / abs(r6.w); - r7.xyz = r4.yzw * r5.www + -cb1[23].xyz; - r5.w = dot(r7.xyz, r7.xyz); - r5.w = sqrt(r5.w); - r8.xyz = r7.xyz / r5.www; - r6.w = dot(cb1[29].xyz, r7.xyz); - r6.w = cmp(abs(r6.w) < 0.00100000005); - r6.w = r6.w ? 1.000000 : 0; - r6.w = r6.w * r5.w; - r7.y = r6.w * cb1[27].z + cb1[27].w; - r6.w = dot(r6.xyz, cb1[29].xyz); - r9.xyz = -cb1[29].xyz * r6.www + r6.xyz; - r7.z = dot(r9.xyz, r9.xyz); - r7.z = rsqrt(r7.z); - r9.xyz = r9.xyz * r7.zzz; - r7.z = dot(r9.xyz, cb1[33].xyz); - r7.w = cmp(0 < r7.z); - r7.z = cmp(r7.z < 0); - r7.z = (int)-r7.w + (int)r7.z; - r7.z = (int)r7.z; - r7.w = saturate(-r7.z); - r8.w = dot(r9.xyz, cb1[31].xyz); - r9.x = 1 + -abs(r8.w); - r9.x = sqrt(r9.x); - r9.y = abs(r8.w) * -0.0187292993 + 0.0742610022; - r9.y = r9.y * abs(r8.w) + -0.212114394; - r9.y = r9.y * abs(r8.w) + 1.57072878; - r9.z = r9.y * r9.x; - r9.z = r9.z * -2 + 3.14159274; - r8.w = cmp(r8.w < -r8.w); - r8.w = r8.w ? r9.z : 0; - r8.w = r9.y * r9.x + r8.w; - r7.z = r8.w * r7.z; - r9.x = r7.z * 0.159154937 + r7.w; - r7.z = r6.w * r6.w; - r7.z = r7.z * -0.222222224 + -0.277777791; - r9.y = r7.z * -r6.w + 0.50000006; - r10.xyzw = t3.SampleBias(s2_s, r9.xy, cb0[108].x).xyzw; - r6.x = saturate(dot(cb1[25].xyz, r6.xyz)); - r6.x = saturate(r6.x * cb1[45].x + cb1[45].z); - r6.yzw = t5.SampleBias(s4_s, r9.xy, cb0[108].x).xyz; - r6.yzw = cb1[41].xyz * r6.yzw; - r6.yzw = r10.xyz * r6.xxx + r6.yzw; - r6.yzw = r6.yzw * r3.www; - r7.z = dot(r8.xyz, cb1[33].xyz); - r7.w = cmp(0 < r7.z); - r7.z = cmp(r7.z < 0); - r7.z = (int)-r7.w + (int)r7.z; - r7.z = (int)r7.z; - r7.w = dot(cb1[25].xyz, r8.xyz); - r7.w = saturate(-r7.w); - r8.w = saturate(-r7.z); - r9.x = dot(r8.xyz, cb1[31].xyz); - r9.y = 1 + -abs(r9.x); - r9.y = sqrt(r9.y); - r9.z = abs(r9.x) * -0.0187292993 + 0.0742610022; - r9.z = r9.z * abs(r9.x) + -0.212114394; - r9.z = r9.z * abs(r9.x) + 1.57072878; - r9.w = r9.z * r9.y; - r9.w = r9.w * -2 + 3.14159274; - r9.x = cmp(r9.x < -r9.x); - r9.x = r9.x ? r9.w : 0; - r9.x = r9.z * r9.y + r9.x; - r7.z = r9.x * r7.z; - r7.x = r7.z * 0.159154937 + r8.w; - r9.xyzw = t7.SampleBias(s6_s, r7.xy, cb0[108].x).xyzw; - r9.xyzw = cb1[39].xyzw * r9.xyzw; - r7.x = -r7.w * r7.w + 1; - r7.x = sqrt(r7.x); - r5.w = -r5.w * r7.x + cb1[27].x; - r5.w = cb1[27].y * r5.w; - r5.w = r5.w / cb1[20].z; - r5.w = saturate(1 + r5.w); - r5.w = 1 + -r5.w; - r7.x = dot(cb1[25].xyz, cb1[29].xyz); - r7.x = 0.400000006 + abs(r7.x); - r7.x = min(1, r7.x); - r5.w = r7.x * r5.w; - r9.xyzw = r9.xyzw * r5.wwww; - r7.xzw = r9.xyz * r9.www; - r5.w = saturate(1 + -r7.y); - r5.w = r5.w * r7.y; - r7.y = cmp(0 < r5.w); - r5.w = cmp(r5.w < 0); - r5.w = (int)-r7.y + (int)r5.w; - r5.w = (int)r5.w; - r5.w = saturate(r5.w); - r7.y = dot(r4.yzw, r8.xyz); - r8.x = cmp(0 < -r7.y); - r7.y = cmp(-r7.y < 0); - r7.y = (int)-r8.x + (int)r7.y; - r7.y = (int)r7.y; - r7.y = saturate(r7.y); - r7.y = -1 + r7.y; - r3.w = r3.w * r7.y + 1; - r3.w = r5.w * r3.w; - r7.xyz = r7.xzw * r3.www; - r6.yzw = r6.yzw * r10.www + r7.xyz; - r3.w = saturate(r4.z); - r3.w = -1 + r3.w; - r3.w = cb1[48].w * r3.w + 1; - r5.w = dot(r4.yzw, r4.yzw); - r5.w = max(1.17549435e-38, r5.w); - r5.w = rsqrt(r5.w); - r4.yzw = r5.www * r4.yzw; - r5.w = dot(cb1[25].xyz, cb1[25].xyz); - r5.w = max(1.17549435e-38, r5.w); - r5.w = rsqrt(r5.w); - r7.xyz = cb1[25].xyz * r5.www; - r8.xyz = -cb1[21].xyz + cb0[44].xyz; - r5.w = dot(r4.yzw, r8.xyz); - r7.w = dot(r8.xyz, r8.xyz); - r8.x = -r3.x * r3.x + r7.w; - r8.x = r5.w * r5.w + -r8.x; - r8.y = cmp(0 < r8.x); - r8.x = sqrt(r8.x); - r8.z = -r8.x + -r5.w; - r9.x = max(0, r8.z); - r8.x = r8.x + -r5.w; - r9.y = r8.x + -r9.x; - r8.xz = r8.yy ? r9.xy : 0; - if (r8.y != 0) { - r7.w = -cb1[46].w * cb1[46].w + r7.w; - r7.w = r5.w * r5.w + -r7.w; - r8.y = cmp(0 < r7.w); - r7.w = sqrt(r7.w); - r5.w = -r7.w + -r5.w; - r5.w = max(0, r5.w); - r5.w = r8.y ? r5.w : 0; - r7.w = cmp(0 < r5.w); - r5.w = r5.w + -r8.x; - r5.w = min(r8.z, r5.w); - r5.w = r7.w ? r5.w : r8.z; - r5.w = r8.y ? r5.w : r8.z; - r7.w = cmp(0 < r5.w); - if (r7.w != 0) { - r5.w = r5.w / cb1[46].y; - r7.w = dot(-r4.yzw, r7.xyz); - r8.yzw = cb1[46].zzz * float3(0.000244140625,0.0012673497,0.00266802101); - r9.xyz = r4.yzw * r8.xxx + cb0[44].xyz; - r10.xyz = r5.www * r4.yzw; - r9.xyz = r10.xyz * float3(0.5,0.5,0.5) + r9.xyz; - r10.xyz = float3(0.5,0.5,0.5) * r7.xyz; - r11.xyz = r9.xyz; - r12.xyz = float3(0,0,0); - r8.x = 0; - r9.w = 0; - while (true) { - r10.w = (int)r9.w; - r10.w = cmp(r10.w >= cb1[46].y); - if (r10.w != 0) break; - r13.xyz = -cb1[21].xyz + r11.xyz; - r10.w = dot(r13.xyz, r13.xyz); - r11.w = sqrt(r10.w); - r11.w = -cb1[46].w + r11.w; - r11.w = r11.w * r2.w; - r11.w = cb1[47].y * -r11.w; - r11.w = 1.44269502 * r11.w; - r11.w = exp2(r11.w); - r11.w = r11.w * r5.w; - r11.w = min(3.40282347e+38, r11.w); - r8.x = r11.w + r8.x; - r12.w = dot(r7.xyz, r13.xyz); - r10.w = -r3.x * r3.x + r10.w; - r10.w = r12.w * r12.w + -r10.w; - r13.x = cmp(0 < r10.w); - r10.w = sqrt(r10.w); - r13.y = -r12.w + r10.w; - r10.w = -r12.w + -r10.w; - r10.w = max(0, r10.w); - r10.w = r13.y + -r10.w; - r10.w = r13.x ? r10.w : 0; - r10.w = r10.w / cb1[47].x; - r13.xyz = r10.xyz * r10.www + r11.xyz; - r14.xyz = r13.xyz; - r12.w = 0; - r13.w = 0; - while (true) { - r14.w = (int)r13.w; - r14.w = cmp(r14.w >= cb1[47].x); - if (r14.w != 0) break; - r15.xyz = -cb1[21].xyz + r14.xyz; - r16.xyz = r7.xyz * r10.www + r14.xyz; - r14.w = dot(r15.xyz, r15.xyz); - r14.w = sqrt(r14.w); - r14.w = -cb1[46].w + r14.w; - r14.w = max(0, r14.w); - r14.w = r14.w * r2.w; - r14.w = cb1[47].y * -r14.w; - r14.w = 1.44269502 * r14.w; - r14.w = exp2(r14.w); - r14.w = r14.w + r12.w; - r15.x = (int)r13.w + 1; - r14.xyz = r16.xyz; - r12.w = r14.w; - r13.w = r15.x; - continue; - } - r10.w = r12.w * r10.w + r8.x; - r13.xyz = r10.www * r8.yzw; - r13.xyz = float3(-1.44269502,-1.44269502,-1.44269502) * r13.xyz; - r13.xyz = exp2(r13.xyz); - r12.xyz = r13.xyz * r11.www + r12.xyz; - r11.xyz = r4.yzw * r5.www + r11.xyz; - r9.w = (int)r9.w + 1; - } - r2.w = r7.w * r7.w + 1; - r2.w = 0.0596831031 * r2.w; - r4.yzw = r12.xyz * r2.www; - r4.yzw = r4.yzw * r8.yzw; - } else { - r4.yzw = float3(0,0,0); - } - } else { - r4.yzw = float3(0,0,0); - } - r7.xyw = cb1[47].zzz * r4.zwy; - r2.w = cmp(r7.x >= r7.y); - r2.w = r2.w ? 1.000000 : 0; - r8.xy = r7.yx; - r8.zw = float2(-1,0.666666687); - r9.xy = r4.zw * cb1[47].zz + -r8.xy; - r9.zw = float2(1,-1); - r8.xyzw = r2.wwww * r9.xyzw + r8.xyzw; - r2.w = cmp(r7.w >= r8.x); - r2.w = r2.w ? 1.000000 : 0; - r7.xyz = r8.xyw; - r8.xyw = r7.wyx; - r8.xyzw = r8.xyzw + -r7.xyzw; - r7.xyzw = r2.wwww * r8.xyzw + r7.xyzw; - r2.w = min(r7.w, r7.y); - r2.w = r7.x + -r2.w; - r3.x = r7.w + -r7.y; - r4.y = r2.w * 6 + 9.99999975e-05; - r3.x = r3.x / r4.y; - r3.x = r7.z + r3.x; - r3.x = cb1[47].w + abs(r3.x); - r4.yzw = float3(1,0.666666687,0.333333343) + r3.xxx; - r4.yzw = frac(r4.yzw); - r4.yzw = r4.yzw * float3(6,6,6) + float3(-3,-3,-3); - r4.yzw = saturate(float3(-1,-1,-1) + abs(r4.yzw)); - r3.x = 9.99999975e-05 + r7.x; - r2.w = r2.w / r3.x; - r4.yzw = float3(-1,-1,-1) + r4.yzw; - r4.yzw = r2.www * r4.yzw + float3(1,1,1); - r7.yzw = r4.yzw * r7.xxx; - r6.yzw = cb1[37].xyz * r6.yzw; - r7.yzw = r7.yzw * r6.xxx; - r4.yzw = r4.yzw * r7.xxx + -r7.yzw; - r4.yzw = cb1[48].yyy * r4.yzw + r7.yzw; - r4.yzw = r4.yzw * r3.www; - r4.yzw = r6.yzw * r3.www + r4.yzw; - r2.w = dot(r4.yzw, float3(0.212672904,0.715152204,0.0721750036)); - r4.yzw = r4.yzw + -r2.www; - r4.yzw = cb0[184].www * r4.yzw + r2.www; - r2.xyz = r4.yzw * cb0[184].xyz + r2.xyz; - } - if (r3.z != 0) { - r2.w = 1 / cb1[49].x; - r3.x = cb1[49].w + cb1[49].x; - r0.w = rsqrt(r0.w); - r0.xzw = r0.xyz * r0.www; - r3.z = dot(r0.xzw, cb1[24].xyz); - r3.w = cb1[28].x * cb1[28].x + -1; - r3.w = r3.z * r3.z + r3.w; - r4.y = max(0, r3.w); - r4.y = sqrt(r4.y); - r3.z = -r4.y + r3.z; - r4.yzw = r0.xzw * r3.zzz + -cb1[24].xyz; - r4.yzw = r4.yzw / cb1[28].xxx; - r3.z = dot(r4.yzw, cb1[30].xyz); - r6.xyz = -cb1[30].xyz * r3.zzz + r4.yzw; - r5.w = dot(r6.xyz, r6.xyz); - r5.w = rsqrt(r5.w); - r6.xyz = r6.xyz * r5.www; - r5.w = dot(r6.xyz, cb1[34].xyz); - r6.w = cmp(0 < r5.w); - r5.w = cmp(r5.w < 0); - r5.w = (int)-r6.w + (int)r5.w; - r5.w = (int)r5.w; - r6.w = saturate(-r5.w); - r6.x = dot(r6.xyz, cb1[32].xyz); - r6.y = 1 + -abs(r6.x); - r6.y = sqrt(r6.y); - r6.z = abs(r6.x) * -0.0187292993 + 0.0742610022; - r6.z = r6.z * abs(r6.x) + -0.212114394; - r6.z = r6.z * abs(r6.x) + 1.57072878; - r7.x = r6.z * r6.y; - r7.x = r7.x * -2 + 3.14159274; - r6.x = cmp(r6.x < -r6.x); - r6.x = r6.x ? r7.x : 0; - r6.x = r6.z * r6.y + r6.x; - r5.w = r6.x * r5.w; - r6.x = r5.w * 0.159154937 + r6.w; - r5.w = r3.z * r3.z; - r5.w = r5.w * -0.222222224 + -0.277777791; - r6.y = r5.w * -r3.z + 0.50000006; - r7.xyzw = t4.SampleBias(s3_s, r6.xy, cb0[108].x).xyzw; - r3.z = saturate(dot(cb1[26].xyz, r4.yzw)); - r3.z = saturate(r3.z * cb1[45].y + cb1[45].w); - r4.yzw = t6.SampleBias(s5_s, r6.xy, cb0[108].x).xyz; - r4.yzw = cb1[42].xyz * r4.yzw; - r4.yzw = r7.xyz * r3.zzz + r4.yzw; - r5.w = dot(cb1[24].xyz, cb1[24].xyz); - r5.w = rsqrt(r5.w); - r6.xyz = cb1[24].xyz * r5.www; - r5.w = saturate(dot(r0.xzw, r6.xyz)); - r3.w = r5.w * r3.w; - r3.w = max(0, r3.w); - r3.w = cmp(0 < r3.w); - r3.w = r3.w ? 1.000000 : 0; - r4.yzw = r4.yzw * r3.www; - r4.yzw = r4.yzw * r7.www; - r3.w = saturate(r0.z); - r3.w = -1 + r3.w; - r3.w = cb1[51].w * r3.w + 1; - r5.w = dot(r0.xzw, r0.xzw); - r5.w = max(1.17549435e-38, r5.w); - r5.w = rsqrt(r5.w); - r0.xzw = r5.www * r0.xzw; - r5.w = dot(cb1[26].xyz, cb1[26].xyz); - r5.w = max(1.17549435e-38, r5.w); - r5.w = rsqrt(r5.w); - r6.xyz = cb1[26].xyz * r5.www; - r7.xyz = -cb1[22].xyz + cb0[44].xyz; - r5.w = dot(r0.xzw, r7.xyz); - r6.w = dot(r7.xyz, r7.xyz); - r7.x = -r3.x * r3.x + r6.w; - r7.x = r5.w * r5.w + -r7.x; - r7.y = cmp(0 < r7.x); - r7.x = sqrt(r7.x); - r7.z = -r7.x + -r5.w; - r8.x = max(0, r7.z); - r7.x = r7.x + -r5.w; - r8.y = r7.x + -r8.x; - r7.xz = r7.yy ? r8.xy : 0; - if (r7.y != 0) { - r6.w = -cb1[49].w * cb1[49].w + r6.w; - r6.w = r5.w * r5.w + -r6.w; - r7.y = cmp(0 < r6.w); - r6.w = sqrt(r6.w); - r5.w = -r6.w + -r5.w; - r5.w = max(0, r5.w); - r5.w = r7.y ? r5.w : 0; - r6.w = cmp(0 < r5.w); - r5.w = r5.w + -r7.x; - r5.w = min(r7.z, r5.w); - r5.w = r6.w ? r5.w : r7.z; - r5.w = r7.y ? r5.w : r7.z; - r6.w = cmp(0 < r5.w); - if (r6.w != 0) { - r5.w = r5.w / cb1[49].y; - r6.w = dot(-r0.xzw, r6.xyz); - r7.yzw = cb1[49].zzz * float3(0.000244140625,0.0012673497,0.00266802101); - r8.xyz = r0.xzw * r7.xxx + cb0[44].xyz; - r9.xyz = r5.www * r0.xzw; - r8.xyz = r9.xyz * float3(0.5,0.5,0.5) + r8.xyz; - r9.xyz = float3(0.5,0.5,0.5) * r6.xyz; - r10.xyz = r8.xyz; - r11.xyz = float3(0,0,0); - r7.x = 0; - r8.w = 0; - while (true) { - r9.w = (int)r8.w; - r9.w = cmp(r9.w >= cb1[49].y); - if (r9.w != 0) break; - r12.xyz = -cb1[22].xyz + r10.xyz; - r9.w = dot(r12.xyz, r12.xyz); - r10.w = sqrt(r9.w); - r10.w = -cb1[49].w + r10.w; - r10.w = r10.w * r2.w; - r10.w = cb1[50].y * -r10.w; - r10.w = 1.44269502 * r10.w; - r10.w = exp2(r10.w); - r10.w = r10.w * r5.w; - r10.w = min(3.40282347e+38, r10.w); - r7.x = r10.w + r7.x; - r11.w = dot(r6.xyz, r12.xyz); - r9.w = -r3.x * r3.x + r9.w; - r9.w = r11.w * r11.w + -r9.w; - r12.x = cmp(0 < r9.w); - r9.w = sqrt(r9.w); - r12.y = -r11.w + r9.w; - r9.w = -r11.w + -r9.w; - r9.w = max(0, r9.w); - r9.w = r12.y + -r9.w; - r9.w = r12.x ? r9.w : 0; - r9.w = r9.w / cb1[50].x; - r12.xyz = r9.xyz * r9.www + r10.xyz; - r13.xyz = r12.xyz; - r11.w = 0; - r12.w = 0; - while (true) { - r13.w = (int)r12.w; - r13.w = cmp(r13.w >= cb1[50].x); - if (r13.w != 0) break; - r14.xyz = -cb1[22].xyz + r13.xyz; - r15.xyz = r6.xyz * r9.www + r13.xyz; - r13.w = dot(r14.xyz, r14.xyz); - r13.w = sqrt(r13.w); - r13.w = -cb1[49].w + r13.w; - r13.w = max(0, r13.w); - r13.w = r13.w * r2.w; - r13.w = cb1[50].y * -r13.w; - r13.w = 1.44269502 * r13.w; - r13.w = exp2(r13.w); - r13.w = r13.w + r11.w; - r14.x = (int)r12.w + 1; - r13.xyz = r15.xyz; - r11.w = r13.w; - r12.w = r14.x; - continue; - } - r9.w = r11.w * r9.w + r7.x; - r12.xyz = r9.www * r7.yzw; - r12.xyz = float3(-1.44269502,-1.44269502,-1.44269502) * r12.xyz; - r12.xyz = exp2(r12.xyz); - r11.xyz = r12.xyz * r10.www + r11.xyz; - r10.xyz = r0.xzw * r5.www + r10.xyz; - r8.w = (int)r8.w + 1; - } - r0.x = r6.w * r6.w + 1; - r0.x = 0.0596831031 * r0.x; - r0.xzw = r11.xyz * r0.xxx; - r0.xzw = r0.xzw * r7.yzw; - } else { - r0.xzw = float3(0,0,0); - } - } else { - r0.xzw = float3(0,0,0); - } - r6.xyw = cb1[50].zzz * r0.zwx; - r0.x = cmp(r6.x >= r6.y); - r0.x = r0.x ? 1.000000 : 0; - r7.xy = r6.yx; - r7.zw = float2(-1,0.666666687); - r8.xy = r0.zw * cb1[50].zz + -r7.xy; - r8.zw = float2(1,-1); - r7.xyzw = r0.xxxx * r8.xyzw + r7.xyzw; - r0.x = cmp(r6.w >= r7.x); - r0.x = r0.x ? 1.000000 : 0; - r6.xyz = r7.xyw; - r7.xyw = r6.wyx; - r7.xyzw = r7.xyzw + -r6.xyzw; - r6.xyzw = r0.xxxx * r7.xyzw + r6.xyzw; - r0.x = min(r6.w, r6.y); - r0.x = r6.x + -r0.x; - r0.z = r6.w + -r6.y; - r0.w = r0.x * 6 + 9.99999975e-05; - r0.z = r0.z / r0.w; - r0.z = r6.z + r0.z; - r0.z = cb1[50].w + abs(r0.z); - r6.yzw = float3(1,0.666666687,0.333333343) + r0.zzz; - r6.yzw = frac(r6.yzw); - r6.yzw = r6.yzw * float3(6,6,6) + float3(-3,-3,-3); - r6.yzw = saturate(float3(-1,-1,-1) + abs(r6.yzw)); - r0.z = 9.99999975e-05 + r6.x; - r0.x = r0.x / r0.z; - r6.yzw = float3(-1,-1,-1) + r6.yzw; - r0.xzw = r0.xxx * r6.yzw + float3(1,1,1); - r6.yzw = r0.xzw * r6.xxx; - r4.yzw = cb1[38].xyz * r4.yzw; - r6.yzw = r6.yzw * r3.zzz; - r0.xzw = r0.xzw * r6.xxx + -r6.yzw; - r0.xzw = cb1[51].yyy * r0.xzw + r6.yzw; - r0.xzw = r0.xzw * r3.www; - r0.xzw = r4.yzw * r3.www + r0.xzw; - r2.xyz = r2.xyz + r0.xzw; - } - r0.xzw = r5.xyz * r3.yyy + -r2.xyz; - r0.xzw = r4.xxx * r0.xzw + r2.xyz; - r2.x = v1.y * cb0[156].w + cb0[157].w; - r2.y = r1.x * cb0[154].w + -cb0[153].w; - r2.xy = max(float2(0.00999999978,0), r2.xy); - r2.z = -1.44269502 * r2.x; - r2.z = exp2(r2.z); - r2.z = 1 + -r2.z; - r2.x = r2.z / r2.x; - r2.z = v1.y * cb0[156].w + cb0[158].w; - r2.z = 1.44269502 * r2.z; - r2.z = exp2(r2.z); - r2.x = r2.x * r2.z; - r2.x = -r2.y * r2.x; - r2.xyz = cb0[155].xyz * r2.xxx; - r2.xyz = float3(1.44269502,1.44269502,1.44269502) * r2.xyz; - r2.xyz = exp2(r2.xyz); - r2.w = dot(r1.yzw, cb0[154].xyz); - r3.x = cb0[155].w * cb0[155].w + 1; - r3.y = dot(r2.ww, cb0[155].ww); - r3.x = r3.x + -r3.y; - r3.y = cmp(0 < cb0[163].z); - if (r3.y != 0) { - r4.xy = (uint2)v0.xy; - r4.z = 7 & asint(cb0[108].w); - r3.yzw = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); - r3.y = mad((int)r3.z, (int)r3.w, (int)r3.y); - r3.z = mad((int)r3.w, (int)r3.y, (int)r3.z); - r3.w = mad((int)r3.y, (int)r3.z, (int)r3.w); - r5.x = mad((int)r3.z, (int)r3.w, (int)r3.y); - r6.x = -cb0[0].z; - r6.y = -cb0[1].z; - r6.z = -cb0[2].z; - r1.y = dot(r1.yzw, r6.xyz); - r1.z = cmp(5.96046448e-08 < r1.y); - r1.y = 1 / r1.y; - r1.y = r1.z ? r1.y : 0; - r1.y = cb0[163].w * r1.y; - r1.z = 1 / r1.x; - r1.w = r1.y * r1.z; - r3.y = r1.w * r0.y + cb0[44].y; - r1.w = -r1.w * r0.y + r0.y; - r4.z = cb0[159].z * r1.w; - r1.w = cb0[162].x * r1.w; - r1.w = max(-127, r1.w); - r4.w = -cb0[159].x + r3.y; - r4.w = cb0[159].z * r4.w; - r4.zw = max(float2(-127,-127), r4.zw); - r4.w = exp2(-r4.w); - r4.w = cb0[159].y * r4.w; - r5.z = cmp(5.96046448e-08 < abs(r4.z)); - r5.w = exp2(-r4.z); - r5.w = 1 + -r5.w; - r5.w = r5.w / r4.z; - r4.z = -r4.z * 0.240226507 + 0.693147182; - r4.z = r5.z ? r5.w : r4.z; - r3.y = -cb0[162].z + r3.y; - r3.y = cb0[162].x * r3.y; - r3.y = max(-127, r3.y); - r3.y = exp2(-r3.y); - r3.y = cb0[162].y * r3.y; - r5.z = cmp(5.96046448e-08 < abs(r1.w)); - r5.w = exp2(-r1.w); - r5.w = 1 + -r5.w; - r5.w = r5.w / r1.w; - r1.w = -r1.w * 0.240226507 + 0.693147182; - r1.w = r5.z ? r5.w : r1.w; - r1.w = r3.y * r1.w; - r1.w = r4.w * r4.z + r1.w; - r1.y = -r1.y * r1.z + 1; - r1.y = r1.y * r1.x; - r1.y = r1.w * r1.y; - r1.y = exp2(-r1.y); - r1.y = min(1, r1.y); - r1.y = max(cb0[161].w, r1.y); - r1.zw = saturate(r1.xx * cb0[160].yw + cb0[160].xz); - r1.y = r1.y + r1.z; - r1.y = r1.y + r1.w; - r1.y = min(1, r1.y); - r1.zw = (uint2)r4.xy; - r5.y = mad((int)r3.w, (int)r5.x, (int)r3.z); - r3.yz = (uint2)r5.xy >> int2(16,16); - r3.yz = (uint2)r3.yz; - r3.yz = r3.yz * float2(3.05180438e-05,3.05180438e-05) + float2(-1,-1); - r1.zw = r3.yz * cb0[167].ww + r1.zw; - r4.xy = cb0[165].xy * r1.zw; - r1.z = v0.w * cb0[164].x + cb0[164].y; - r1.z = log2(r1.z); - r1.z = cb0[164].z * r1.z; - r4.z = r1.z / cb0[163].z; - r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; - r1.z = -cb0[166].z + v0.w; - r1.z = saturate(1000000 * r1.z); - r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; - r4.xyzw = r1.zzzz * r4.xyzw + float4(0,0,0,1); - r1.z = 1 + -r1.y; - r3.yzw = cb0[161].xyz * r1.zzz; - r3.yzw = r3.yzw * r4.www + r4.xyz; - r1.y = r4.w * r1.y; - } else { - r1.z = cb0[159].z * r0.y; - r0.y = cb0[162].x * r0.y; - r0.y = max(-127, r0.y); - r1.w = -cb0[159].x + cb0[44].y; - r1.w = cb0[159].z * r1.w; - r1.zw = max(float2(-127,-127), r1.zw); - r1.w = exp2(-r1.w); - r1.w = cb0[159].y * r1.w; - r4.x = cmp(5.96046448e-08 < abs(r1.z)); - r4.y = exp2(-r1.z); - r4.y = 1 + -r4.y; - r4.y = r4.y / r1.z; - r1.z = -r1.z * 0.240226507 + 0.693147182; - r1.z = r4.x ? r4.y : r1.z; - r4.x = -cb0[162].z + cb0[44].y; - r4.x = cb0[162].x * r4.x; - r4.x = max(-127, r4.x); - r4.x = exp2(-r4.x); - r4.x = cb0[162].y * r4.x; - r4.y = cmp(5.96046448e-08 < abs(r0.y)); - r4.z = exp2(-r0.y); - r4.z = 1 + -r4.z; - r4.z = r4.z / r0.y; - r0.y = -r0.y * 0.240226507 + 0.693147182; - r0.y = r4.y ? r4.z : r0.y; - r0.y = r4.x * r0.y; - r0.y = r1.w * r1.z + r0.y; - r0.y = r0.y * r1.x; - r0.y = exp2(-r0.y); - r0.y = min(1, r0.y); - r0.y = max(cb0[161].w, r0.y); - r1.xz = saturate(r1.xx * cb0[160].yw + cb0[160].xz); - r0.y = r1.x + r0.y; - r0.y = r0.y + r1.z; - r1.y = min(1, r0.y); - r0.y = 1 + -r1.y; - r3.yzw = cb0[161].xyz * r0.yyy; - } - r0.y = dot(r0.xzw, float3(0.212672904,0.715152204,0.0721750036)); - r0.xzw = r0.xzw + -r0.yyy; - r0.xyz = cb0[184].www * r0.xzw + r0.yyy; - r0.xyz = cb0[184].xyz * r0.xyz; - r1.xzw = r2.xyz * r1.yyy; - r0.w = r2.w * r2.w + 1; - r0.w = 0.0596831031 * r0.w; - r4.xyz = cb0[156].xyz * r0.www + cb0[158].xyz; - r0.w = -cb0[155].w * cb0[155].w + 1; - r2.w = 12.566371 * r3.x; - r3.x = sqrt(r3.x); - r2.w = r3.x * r2.w; - r2.w = max(0.00100000005, r2.w); - r0.w = r0.w / r2.w; - r4.xyz = saturate(cb0[157].xyz * r0.www + r4.xyz); - r4.xyz = float3(255,255,255) * r4.xyz; - r2.xyz = float3(1,1,1) + -r2.xyz; - r2.xyz = r4.xyz * r2.xyz; - r2.xyz = r2.xyz * r1.yyy + r3.yzw; - o0.xyz = r0.xyz * r1.xzw + r2.xyz; - r0.x = max(9.99999994e-09, v3.z); - r0.xy = v3.xy / r0.xx; - r0.z = max(9.99999994e-09, v4.z); - r0.zw = v4.xy / r0.zz; - r0.xy = r0.xy + -r0.zw; - r1.xy = float2(0.5,-0.5) * r0.xy; - r1.xy = sqrt(abs(r1.xy)); - r1.xy = sqrt(r1.xy); - r0.z = -r0.y; - r0.yw = cmp(float2(0,0) < r0.xz); - r0.xz = cmp(r0.xz < float2(0,0)); - r0.xy = (int2)-r0.yw + (int2)r0.xz; - r0.xy = (int2)r0.xy; - r0.xy = r1.xy * r0.xy; - o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); - o0.w = 1; - o1.zw = float2(0,0); - return; -} \ No newline at end of file diff --git a/src/games/endfield/others/skybox3_0x98A8BB43.ps_5_0.hlsl b/src/games/endfield/others/skybox3_0x98A8BB43.ps_5_0.hlsl new file mode 100644 index 0000000000..250eeae6c3 --- /dev/null +++ b/src/games/endfield/others/skybox3_0x98A8BB43.ps_5_0.hlsl @@ -0,0 +1,708 @@ +#include "../shared.h" + +// ============================================================================ +// SKYBOX / SKY RENDERING SHADER +// ============================================================================ +// Textures: +// t0: 3D LUT for volumetric fog/scattering +// t1: Environment/fallback sky cubemap lookup +// t2: Main skybox texture (4096x2048 equirectangular) +// t3: Reflection probe 1 texture +// t4: Reflection probe 2 texture +// t5: Reflection probe 1 detail/tint +// t6: Reflection probe 2 detail/tint +// ============================================================================ + +Texture2D t7 : register(t7); + +Texture2D t6 : register(t6); + +Texture2D t5 : register(t5); + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture3D t0 : register(t0); + +SamplerState s6_s : register(s6); + +SamplerState s5_s : register(s5); + +SamplerState s4_s : register(s4); + +SamplerState s3_s : register(s3); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb2 : register(b2) +{ + float4 cb2[45]; +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[105]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[45]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float3 v1 : TEXCOORD0, + float2 v2 : TEXCOORD1, + float3 v3 : TEXCOORD2, + float3 v4 : TEXCOORD3, + float3 v5 : TEXCOORD4, + out float4 o0 : SV_Target0, + out float4 o1 : SV_Target1) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10; + uint4 bitmask, uiDest; + float4 fDest; + + // ========================================================================== + // VIEW DIRECTION CALCULATION + // ========================================================================== + r0.xyz = -cb0[44].xyz + v1.xyz; + r0.w = dot(r0.xyz, r0.xyz); + r1.x = max(9.99999994e-009, r0.w); + r1.x = rsqrt(r1.x); + r1.yzw = r1.xxx * r0.xyz; + r2.x = r1.x * r0.w; + // ========================================================================== + // OCTAHEDRAL / CUBEMAP UV MAPPING FOR t1 (fallback environment) + // ========================================================================== + r2.y = dot(abs(r1.yzw), float3(1,1,1)); + r2.y = 1 / r2.y; + r2.zw = r2.yy * r1.yw; + r2.z = r2.z + r2.w; + r2.y = r1.y * r2.y + -r2.w; + r3.xy = float2(1,1) + r2.zy; + r2.yz = float2(0.5,0.5) * r3.xy; + r2.yzw = t1.SampleLevel(s0_s, r2.yz, 0).xyz; + r3.x = saturate(r1.z * 10 + 1); + // ========================================================================== + // PROCEDURAL SUN DISK CALCULATION + // ========================================================================== + // cb2[44].xyz = sun direction + // cb2[43].x = sun size/falloff exponent + // cb2[42].xyz = sun color, cb2[42].w = sun intensity + r3.y = saturate(dot(-cb2[44].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) + r3.y = log2(r3.y); + // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) + float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; + r3.y = cb2[43].x * sunSizeMultiplier * r3.y; // Apply sun size exponent + r3.y = exp2(r3.y); + r3.z = r3.y * r3.y + 1; // Soft falloff numerator + r3.y = -r3.y * 1.98000002 + 1.98010004; // Soft falloff denominator + r3.w = log2(cb2[42].w); // Sun intensity + r3.zw = float2(0.0100164423,0.649999976) * r3.zw; + r3.w = exp2(r3.w); + r3.w = 8 * r3.w; + r3.y = log2(r3.y); + r3.y = r3.w * r3.y; + r3.y = exp2(r3.y); + r3.y = max(9.99999975e-005, r3.y); + r3.y = r3.z / r3.y; // Final sun disk intensity + // ========================================================================== + // EQUIRECTANGULAR SKYBOX UV CALCULATION (for t2: 4096x2048) + // ========================================================================== + r3.z = r1.y / r1.w; + r3.w = cmp(abs(r3.z) < 1); + r4.x = 1 / abs(r3.z); + r4.x = r3.w ? abs(r3.z) : r4.x; + r4.y = r4.x * r4.x; + r4.z = r4.y * 0.0872929022 + -0.301894993; + r4.y = r4.z * r4.y + 1; + r4.z = r4.y * r4.x; + r4.x = -r4.y * r4.x + 1.57079637; + r3.w = r3.w ? r4.z : r4.x; + r4.x = abs(r1.z) * 0.0468878001 + -0.203471005; + r4.x = r4.x * abs(r1.z) + 1.57079601; + r4.y = 1 + -abs(r1.z); + r4.y = sqrt(r4.y); + r4.z = r4.x * r4.y; + r3.z = cmp(r3.z < 0); + r3.z = r3.z ? -r3.w : r3.w; + r5.xy = cmp(r1.yz >= float2(0,0)); + r3.w = r5.x ? 3.1415925 : -3.1415925; + r4.w = cmp(r1.w < 0); + r4.w = r4.w ? 1.000000 : 0; + r6.x = r3.w * r4.w + r3.z; + r3.z = -r4.x * r4.y + 3.14159274; + r3.z = r5.y ? r4.z : r3.z; + r6.y = 1.57079637 + -r3.z; + r3.zw = r6.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); + r3.z = -cb2[41].w * 0.00277777785 + r3.z; + r4.x = 1 + r3.z; + r4.y = r3.w * 2 + -1; + // ========================================================================== + // SKYBOX TEXTURE SAMPLE (t2: 4096x2048 equirectangular) + // ========================================================================== + r4.xyzw = t2.SampleBias(s1_s, r4.xy, cb1[26].x).xyzw; + r5.xzw = float3(-0.5,-0.5,-0.5) + r4.xyz; + r4.xyz = r5.xzw * cb2[40].yyy + float3(0.5,0.5,0.5); + r6.xyzw = cb2[38].xyzw * r4.xyzw; + r3.z = max(r6.x, r6.y); + r4.xyzw = -r4.xyzw * cb2[38].xyzw + r3.zzzz; + r4.xyzw = cb2[40].xxxx * r4.xyzw + r6.xyzw; + r4.xyzw = cb2[39].xyzw * r4.xyzw; + r3.z = r5.y ? 1.000000 : 0; + r5.x = r4.w * r3.z; + r5.x = saturate(r5.x); + // ========================================================================== + // SUN DISK BLENDING + // ========================================================================== + // Smoothstep for sun edge falloff + r3.w = -0.5 + r3.y; + r3.w = saturate(r3.w + r3.w); + r4.w = r3.w * -2 + 3; + r3.w = r3.w * r3.w; + r3.w = r4.w * r3.w; + r4.w = r3.w * r3.y; + r3.y = -r3.w * r3.y + r3.y; + r3.y = cb2[43].y * r3.y + r4.w; // Sun brightness + r5.yzw = cb2[42].xyz * r3.yyy; // Apply sun color + r5.yzw = cb2[43].www * r5.yzw; // Sun intensity multiplier + r5.yzw = cb2[44].www * r5.yzw; // Sun shadow/occlusion + r5.yzw = max(float3(0,0,0), r5.yzw); + // HDR Sun toggle + if (SUN_INTENSITY > 0.5f) { + // Calculate sun-view alignment (1 = looking directly at sun center) + float sunDot = saturate(dot(-cb2[44].xyz, -r1.yzw)); + + // === HORIZON REDDENING === + // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) + float sunHeight = saturate(cb2[44].y + 0.1f); // Shift so effect starts slightly above horizon + + // Warm shift when sun is low (more red/orange near horizon) + float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange + float3(1.0f, 0.95f, 0.9f), // High sun: nearly white + sunHeight); + + // === LIMB DARKENING === + // Real stars appear darker at edges due to optical depth through atmosphere + // Use a soft power curve - center is brightest, edges darken + float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges + + // === CHROMATIC SUN EDGE === + // Core is white-hot, edges transition to yellow/orange + float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center + float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge + + // Blend from edge color to core color based on how centered we are + float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core + float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); + + // === COMBINE SUN DISK === + // Apply limb darkening and chromatic color to base sun + r5.yzw = r5.yzw * limbDarkening * chromaticColor * horizonTint; + + // Boost the sun intensity for HDR + r5.yzw = r5.yzw * 5.0f; + + // === CORONA GLOW === + // Inner corona (tight glow) + float coronaInner = pow(sunDot, 64.0f); + // Outer corona (wide soft glow) + float coronaOuter = pow(sunDot, 8.0f); + + // Corona colors - also affected by horizon + float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon + float3(1.0f, 0.7f, 0.3f), // Normal inner + sunHeight); + float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon + float3(1.0f, 0.5f, 0.2f), // Normal outer + sunHeight); + + float3 corona = coronaInner * coronaColorInner * 2.0f + + coronaOuter * coronaColorOuter * 0.5f; + + // Modulate corona by sun color/intensity from game + corona *= cb2[42].xyz * cb2[42].w; + corona *= cb2[44].w; // Sun shadow/occlusion + + // Add corona to sun + r5.yzw += corona; + + // === DESATURATE SUN (50%) === + float sunLuma = dot(r5.yzw, float3(0.2126f, 0.7152f, 0.0722f)); + r5.yzw = lerp(r5.yzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); + + // === BLOOM BOOST === + r5.yzw *= 10.0f; + + } else { + // Vanilla clamp + r5.yzw = min(float3(3,3,3), r5.yzw); + } + + // Blend environment + sun + skybox + r2.yzw = r2.yzw * r3.xxx + r5.yzw; + r3.xyw = r4.xyz * r3.zzz + -r2.yzw; + r2.yzw = r5.xxx * r3.xyw + r2.yzw; + // ========================================================================== + // REFLECTION PROBE 1 (cb2[0].x enables this) + // ========================================================================== + r3.xy = cmp(float2(0.75,0.75) < cb2[0].xy); + if (r3.x != 0) { + r3.x = rsqrt(r0.w); + r5.yzw = r3.xxx * r0.yxz; + r3.x = dot(r5.zyw, cb2[15].xyz); + r3.w = cb2[19].x * cb2[19].x + -1; + r3.w = r3.x * r3.x + r3.w; + r4.w = max(0, r3.w); + r4.w = sqrt(r4.w); + r3.x = -r4.w + r3.x; + r6.xyz = r5.zyw * r3.xxx + -cb2[15].xyz; + r6.xyz = r6.xyz / cb2[19].xxx; + r3.x = dot(cb2[15].xyz, cb2[15].xyz); + r3.x = rsqrt(r3.x); + r7.xyz = cb2[15].xyz * r3.xxx; + r3.x = saturate(dot(r5.zyw, r7.xyz)); + r3.x = r3.w * r3.x; + r3.x = max(0, r3.x); + r3.x = cmp(0 < r3.x); + r3.w = r3.x ? 1.000000 : 0; + r4.w = dot(cb2[21].xyz, cb2[15].xyz); + r6.w = dot(cb2[21].yxz, r5.yzw); + r4.w = abs(r4.w) / abs(r6.w); + r7.xyz = r5.zyw * r4.www + -cb2[15].xyz; + r4.w = dot(r7.xyz, r7.xyz); + r4.w = sqrt(r4.w); + r8.xyz = r7.xyz / r4.www; + r6.w = dot(cb2[21].xyz, r7.xyz); + r6.w = cmp(abs(r6.w) < 0.00100000005); + r6.w = r6.w ? 1.000000 : 0; + r6.w = r6.w * r4.w; + r7.y = r6.w * cb2[19].z + cb2[19].w; + r6.w = dot(r6.xyz, cb2[21].xyz); + r9.xyz = -cb2[21].xyz * r6.www + r6.xyz; + r7.z = dot(r9.xyz, r9.xyz); + r7.z = rsqrt(r7.z); + r9.xyz = r9.xyz * r7.zzz; + r7.z = dot(r9.xyz, cb2[25].xyz); + r7.w = cmp(0 < r7.z); + r7.z = cmp(r7.z < 0); + r7.z = (int)-r7.w + (int)r7.z; + r7.z = (int)r7.z; + r7.w = saturate(-r7.z); + r8.w = dot(r9.xyz, cb2[23].xyz); + r9.x = 1 + -abs(r8.w); + r9.x = sqrt(r9.x); + r9.y = abs(r8.w) * -0.0187292993 + 0.0742610022; + r9.y = r9.y * abs(r8.w) + -0.212114394; + r9.y = r9.y * abs(r8.w) + 1.57072878; + r9.z = r9.y * r9.x; + r9.z = r9.z * -2 + 3.14159274; + r8.w = cmp(r8.w < -r8.w); + r8.w = r8.w ? r9.z : 0; + r8.w = r9.y * r9.x + r8.w; + r7.z = r8.w * r7.z; + r9.x = r7.z * 0.159154937 + r7.w; + r7.z = r6.w * r6.w; + r7.z = r7.z * -0.222222224 + -0.277777791; + r9.y = r7.z * -r6.w + 0.50000006; + r10.xyzw = t3.SampleBias(s2_s, r9.xy, cb1[26].x).xyzw; + r6.x = saturate(dot(cb2[17].xyz, r6.xyz)); + r6.x = saturate(r6.x * cb2[1].x + cb2[1].z); + r6.yzw = t5.SampleBias(s4_s, r9.xy, cb1[26].x).xyz; + r6.yzw = cb2[9].xyz * r6.yzw; + r10.xyz = r10.xyz * r6.xxx + r6.yzw; + r6.xyzw = r10.xyzw * r3.wwww; + r7.z = saturate(1 + -r7.y); + r7.z = r7.z * r7.y; + r7.w = cmp(0 < r7.z); + r7.z = cmp(r7.z < 0); + r7.z = (int)-r7.w + (int)r7.z; + r7.z = (int)r7.z; + r7.z = saturate(r7.z); + r5.z = dot(r5.zyw, r8.xyz); + r5.w = cmp(0 < -r5.z); + r5.z = cmp(-r5.z < 0); + r5.z = (int)-r5.w + (int)r5.z; + r5.z = (int)r5.z; + r5.yz = saturate(r5.yz); + r5.z = -1 + r5.z; + r3.w = r3.w * r5.z + 1; + r3.w = r7.z * r3.w; + r5.z = dot(r8.xyz, cb2[25].xyz); + r5.w = cmp(0 < r5.z); + r5.z = cmp(r5.z < 0); + r5.z = (int)-r5.w + (int)r5.z; + r5.z = (int)r5.z; + r5.w = dot(cb2[17].xyz, r8.xyz); + r5.w = saturate(-r5.w); + r7.z = saturate(-r5.z); + r7.w = dot(r8.xyz, cb2[23].xyz); + r8.x = 1 + -abs(r7.w); + r8.x = sqrt(r8.x); + r8.y = abs(r7.w) * -0.0187292993 + 0.0742610022; + r8.y = r8.y * abs(r7.w) + -0.212114394; + r8.y = r8.y * abs(r7.w) + 1.57072878; + r8.z = r8.y * r8.x; + r8.z = r8.z * -2 + 3.14159274; + r7.w = cmp(r7.w < -r7.w); + r7.w = r7.w ? r8.z : 0; + r7.w = r8.y * r8.x + r7.w; + r5.z = r7.w * r5.z; + r7.x = r5.z * 0.159154937 + r7.z; + r7.xyzw = t7.SampleBias(s6_s, r7.xy, cb1[26].x).xyzw; + r7.xyzw = cb2[7].xyzw * r7.xyzw; + r5.z = -r5.w * r5.w + 1; + r5.z = sqrt(r5.z); + r4.w = -r4.w * r5.z + cb2[19].x; + r4.w = cb2[19].y * r4.w; + r4.w = r4.w / cb2[0].z; + r4.w = saturate(1 + r4.w); + r4.w = 1 + -r4.w; + r5.z = dot(cb2[17].xyz, cb2[21].xyz); + r5.z = 0.400000006 + abs(r5.z); + r5.z = min(1, r5.z); + r4.w = r5.z * r4.w; + r7.xyzw = r7.xyzw * r4.wwww; + r7.xyz = r7.xyz * r7.www; + r7.xyz = r7.xyz * r3.www; + r8.xyz = r6.xyz * r10.www + r7.xyz; + r3.w = r7.w * r3.w; + r3.x = r3.x ? 0 : 1; + r8.w = r3.w * r3.x + r6.w; + r6.xyzw = cb2[5].xyzw * r8.xyzw; + r3.x = -1 + r5.y; + r3.x = cb2[29].w * r3.x + 1; + r7.xyzw = r6.xyzw * r3.xxxx; + r3.w = cmp(cb2[2].x >= 0.5); + r3.w = r3.w ? 1.000000 : 0; + r5.yz = cmp(float2(1.5,0.5) >= cb2[2].xx); + r5.yz = r5.yz ? float2(1,1) : 0; + r3.w = -r3.w * r5.y + 1; + r3.w = -r7.w * r3.w + 1; + r4.w = dot(r7.xyz, float3(0.212672904,0.715152204,0.0721750036)); + r6.xyz = r6.xyz * r3.xxx + -r4.www; + r6.xyz = cb1[104].www * r6.xyz + r4.www; + r6.xyz = cb1[104].xyz * r6.xyz; + r3.x = -r6.w * r3.x + 1; + r3.x = -r3.x * r5.z + 1; + r5.yzw = r6.xyz * r3.xxx; + r2.yzw = r2.yzw * r3.www + r5.yzw; + } + // ========================================================================== + // REFLECTION PROBE 2 (cb2[0].y enables this) + // ========================================================================== + if (r3.y != 0) { + r3.x = rsqrt(r0.w); + r3.xyw = r3.xxx * r0.yxz; + r0.x = dot(r3.yxw, cb2[16].xyz); + r0.z = cb2[20].x * cb2[20].x + -1; + r0.z = r0.x * r0.x + r0.z; + r4.w = max(0, r0.z); + r4.w = sqrt(r4.w); + r0.x = -r4.w + r0.x; + r5.yzw = r3.yxw * r0.xxx + -cb2[16].xyz; + r5.yzw = r5.yzw / cb2[20].xxx; + r0.x = dot(r5.yzw, cb2[22].xyz); + r6.xyz = -cb2[22].xyz * r0.xxx + r5.yzw; + r4.w = dot(r6.xyz, r6.xyz); + r4.w = rsqrt(r4.w); + r6.xyz = r6.xyz * r4.www; + r4.w = dot(r6.xyz, cb2[26].xyz); + r6.w = cmp(0 < r4.w); + r4.w = cmp(r4.w < 0); + r4.w = (int)-r6.w + (int)r4.w; + r4.w = (int)r4.w; + r6.w = saturate(-r4.w); + r6.x = dot(r6.xyz, cb2[24].xyz); + r6.y = 1 + -abs(r6.x); + r6.y = sqrt(r6.y); + r6.z = abs(r6.x) * -0.0187292993 + 0.0742610022; + r6.z = r6.z * abs(r6.x) + -0.212114394; + r6.z = r6.z * abs(r6.x) + 1.57072878; + r7.x = r6.z * r6.y; + r7.x = r7.x * -2 + 3.14159274; + r6.x = cmp(r6.x < -r6.x); + r6.x = r6.x ? r7.x : 0; + r6.x = r6.z * r6.y + r6.x; + r4.w = r6.x * r4.w; + r6.x = r4.w * 0.159154937 + r6.w; + r4.w = r0.x * r0.x; + r4.w = r4.w * -0.222222224 + -0.277777791; + r6.y = r4.w * -r0.x + 0.50000006; + r7.xyzw = t4.SampleBias(s3_s, r6.xy, cb1[26].x).xyzw; + r0.x = saturate(dot(cb2[18].xyz, r5.yzw)); + r0.x = saturate(r0.x * cb2[1].y + cb2[1].w); + r5.yzw = t6.SampleBias(s5_s, r6.xy, cb1[26].x).xyz; + r5.yzw = cb2[10].xyz * r5.yzw; + r7.xyz = r7.xyz * r0.xxx + r5.yzw; + r0.x = dot(cb2[16].xyz, cb2[16].xyz); + r0.x = rsqrt(r0.x); + r5.yzw = cb2[16].xyz * r0.xxx; + r0.x = saturate(dot(r3.yxw, r5.yzw)); + r0.x = r0.z * r0.x; + r0.x = max(0, r0.x); + r0.x = cmp(0 < r0.x); + r0.x = r0.x ? 1.000000 : 0; + r6.xyzw = r7.xyzw * r0.xxxx; + r6.xyz = r6.xyz * r7.www; + r6.xyzw = cb2[6].xyzw * r6.xyzw; + r3.x = saturate(r3.x); + r0.x = -1 + r3.x; + r0.x = cb2[32].w * r0.x + 1; + r7.xyzw = r6.xyzw * r0.xxxx; + r0.z = cmp(cb2[2].y >= 0.5); + r0.z = r0.z ? 1.000000 : 0; + r3.xy = cmp(float2(1.5,0.5) >= cb2[2].yy); + r3.xy = r3.xy ? float2(1,1) : 0; + r0.z = -r0.z * r3.x + 1; + r0.z = -r7.w * r0.z + 1; + r0.x = -r6.w * r0.x + 1; + r0.x = -r0.x * r3.y + 1; + r3.xyw = r7.xyz * r0.xxx; + r2.yzw = r2.yzw * r0.zzz + r3.xyw; + } + // Final skybox blend + r3.xyz = r4.xyz * r3.zzz + -r2.yzw; + r2.yzw = r5.xxx * r3.xyz + r2.yzw; + // ========================================================================== + // ATMOSPHERIC FOG / SCATTERING (Height-based exponential fog) + // ========================================================================== + r0.x = v1.y * cb1[74].w + cb1[75].w; + r0.z = r2.x * cb1[72].w + -cb1[71].w; + r0.xz = max(float2(0.00999999978,0), r0.xz); + r3.x = -1.44269502 * r0.x; + r3.x = exp2(r3.x); + r3.x = 1 + -r3.x; + r0.x = r3.x / r0.x; + r3.x = v1.y * cb1[74].w + cb1[76].w; + r3.x = 1.44269502 * r3.x; + r3.x = exp2(r3.x); + r0.x = r3.x * r0.x; + r0.x = -r0.z * r0.x; + r3.xyz = cb1[73].xyz * r0.xxx; + r3.xyz = float3(1.44269502,1.44269502,1.44269502) * r3.xyz; + r3.xyz = exp2(r3.xyz); + r0.x = dot(r1.yzw, cb1[72].xyz); + r0.z = cb1[73].w * cb1[73].w + 1; + r3.w = dot(r0.xx, cb1[73].ww); + r0.z = -r3.w + r0.z; + // ========================================================================== + // VOLUMETRIC FOG SAMPLING (t0: 3D fog volume) + // ========================================================================== + r3.w = cmp(0 < cb1[83].z); + if (r3.w != 0) { + r4.xy = (uint2)v0.xy; + r4.z = 7 & asint(cb1[26].w); + r5.xyz = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); + r3.w = mad((int)r5.y, (int)r5.z, (int)r5.x); + r4.z = mad((int)r5.z, (int)r3.w, (int)r5.y); + r4.w = mad((int)r3.w, (int)r4.z, (int)r5.z); + r5.x = mad((int)r4.z, (int)r4.w, (int)r3.w); + r6.x = -cb0[0].z; + r6.y = -cb0[1].z; + r6.z = -cb0[2].z; + r3.w = dot(r1.yzw, r6.xyz); + r5.z = cmp(5.96046448e-008 < r3.w); + r3.w = 1 / r3.w; + r3.w = r5.z ? r3.w : 0; + r3.w = cb1[83].w * r3.w; + r5.z = 1 / r2.x; + r5.w = r5.z * r3.w; + r6.x = r5.w * r0.y + cb0[44].y; + r5.w = -r5.w * r0.y + r0.y; + r3.w = -r3.w * r5.z + 1; + r5.z = r3.w * r2.x; + r6.y = cb1[77].z * r5.w; + r5.w = cb1[80].x * r5.w; + r5.w = max(-127, r5.w); + r6.z = -cb1[77].x + r6.x; + r6.z = cb1[77].z * r6.z; + r6.yz = max(float2(-127,-127), r6.yz); + r6.z = exp2(-r6.z); + r6.z = cb1[77].y * r6.z; + r6.w = cmp(5.96046448e-008 < abs(r6.y)); + r7.x = exp2(-r6.y); + r7.x = 1 + -r7.x; + r7.x = r7.x / r6.y; + r6.y = -r6.y * 0.240226507 + 0.693147182; + r6.y = r6.w ? r7.x : r6.y; + r6.x = -cb1[80].z + r6.x; + r6.x = cb1[80].x * r6.x; + r6.x = max(-127, r6.x); + r6.x = exp2(-r6.x); + r6.x = cb1[80].y * r6.x; + r6.w = cmp(5.96046448e-008 < abs(r5.w)); + r7.x = exp2(-r5.w); + r7.x = 1 + -r7.x; + r7.x = r7.x / r5.w; + r5.w = -r5.w * 0.240226507 + 0.693147182; + r5.w = r6.w ? r7.x : r5.w; + r5.w = r6.x * r5.w; + r5.w = r6.z * r6.y + r5.w; + r6.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r5.z = r5.w * r5.z; + r5.z = exp2(-r5.z); + r5.z = min(1, r5.z); + r5.z = max(cb1[79].w, r5.z); + r5.z = r5.z + r6.y; + r5.z = r5.z + r6.x; + r5.z = min(1, r5.z); + r5.y = mad((int)r4.w, (int)r5.x, (int)r4.z); + r4.zw = (uint2)r5.xy >> int2(16,16); + r4.xyzw = (uint4)r4.xyzw; + r4.zw = r4.zw * float2(3.05180438e-005,3.05180438e-005) + float2(-1,-1); + r4.xy = r4.zw * cb1[87].ww + r4.xy; + r4.xy = cb1[85].xy * r4.xy; + r4.w = v0.w * cb1[84].x + cb1[84].y; + r4.w = log2(r4.w); + r4.w = cb1[84].z * r4.w; + r4.z = r4.w / cb1[83].z; + r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; + r5.x = -cb1[86].z + v0.w; + r5.x = saturate(1000000 * r5.x); + r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; + r4.xyzw = r5.xxxx * r4.xyzw + float4(0,0,0,1); + r5.x = 1 + -r5.z; + r5.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r5.y = log2(r5.y); + r5.y = cb1[82].w * r5.y; + r5.y = exp2(r5.y); + r6.yzw = cb1[82].xyz * r5.yyy; + r3.w = r3.w * r2.x + -cb1[81].w; + r3.w = max(0, r3.w); + r3.w = r5.w * r3.w; + r3.w = exp2(-r3.w); + r3.w = min(1, r3.w); + r3.w = 1 + -r3.w; + r6.yzw = r6.yzw * r3.www; + r3.w = 1 + -r6.x; + r6.xyz = r6.yzw * r3.www; + r5.xyw = cb1[79].xyz * r5.xxx + r6.xyz; + r4.xyz = r5.xyw * r4.www + r4.xyz; + r3.w = r4.w * r5.z; + } else { + r4.w = cb1[77].z * r0.y; + r4.w = max(-127, r4.w); + r0.y = cb1[80].x * r0.y; + r0.y = max(-127, r0.y); + r5.x = -cb1[77].x + cb0[44].y; + r5.x = cb1[77].z * r5.x; + r5.x = max(-127, r5.x); + r5.x = exp2(-r5.x); + r5.x = cb1[77].y * r5.x; + r5.y = cmp(5.96046448e-008 < abs(r4.w)); + r5.z = exp2(-r4.w); + r5.z = 1 + -r5.z; + r5.z = r5.z / r4.w; + r4.w = -r4.w * 0.240226507 + 0.693147182; + r4.w = r5.y ? r5.z : r4.w; + r5.y = -cb1[80].z + cb0[44].y; + r5.y = cb1[80].x * r5.y; + r5.y = max(-127, r5.y); + r5.y = exp2(-r5.y); + r5.y = cb1[80].y * r5.y; + r5.z = cmp(5.96046448e-008 < abs(r0.y)); + r5.w = exp2(-r0.y); + r5.w = 1 + -r5.w; + r5.w = r5.w / r0.y; + r0.y = -r0.y * 0.240226507 + 0.693147182; + r0.y = r5.z ? r5.w : r0.y; + r0.y = r5.y * r0.y; + r0.y = r5.x * r4.w + r0.y; + r5.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r2.x = r0.y * r2.x; + r2.x = exp2(-r2.x); + r2.x = min(1, r2.x); + r2.x = max(cb1[79].w, r2.x); + r2.x = r2.x + r5.y; + r2.x = r2.x + r5.x; + r3.w = min(1, r2.x); + r2.x = 1 + -r3.w; + r1.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r1.y = log2(r1.y); + r1.y = cb1[82].w * r1.y; + r1.y = exp2(r1.y); + r1.yzw = cb1[82].xyz * r1.yyy; + r0.w = r0.w * r1.x + -cb1[81].w; + r0.w = max(0, r0.w); + r0.y = r0.y * r0.w; + r0.y = exp2(-r0.y); + r0.y = min(1, r0.y); + r0.y = 1 + -r0.y; + r1.xyz = r1.yzw * r0.yyy; + r0.y = 1 + -r5.x; + r1.xyz = r1.xyz * r0.yyy; + r4.xyz = cb1[79].xyz * r2.xxx + r1.xyz; + } + // ========================================================================== + // FINAL COLOR GRADING + // ========================================================================== + // Desaturation based on luminance + r0.y = dot(r2.yzw, float3(0.212672904,0.715152204,0.0721750036)); // Luminance + r1.xyz = r2.yzw + -r0.yyy; + r1.xyz = cb1[104].www * r1.xyz + r0.yyy; // Saturation control + r1.xyz = cb1[104].xyz * r1.xyz; // Color tint/exposure + r2.xyz = r3.xyz * r3.www; + r0.x = r0.x * r0.x + 1; + r0.x = 0.0596831031 * r0.x; + r0.xyw = cb1[74].xyz * r0.xxx + cb1[76].xyz; + r1.w = -cb1[73].w * cb1[73].w + 1; + r2.w = 12.566371 * r0.z; + r0.z = sqrt(r0.z); + r0.z = r2.w * r0.z; + r0.z = max(0.00100000005, r0.z); + r0.z = r1.w / r0.z; + r0.xyz = saturate(cb1[75].xyz * r0.zzz + r0.xyw); + r0.xyz = float3(255,255,255) * r0.xyz; + r3.xyz = float3(1,1,1) + -r3.xyz; + r0.xyz = r3.xyz * r0.xyz; + r0.xyz = r0.xyz * r3.www + r4.xyz; + o0.xyz = r1.xyz * r2.xyz + r0.xyz; + + // ========================================================================== + // SKYBOX DESATURATION (50%) - Tech Test Look + // ========================================================================== + if (TECH_TEST_LOOK > 0.5f) { + float skyboxLuma = dot(o0.xyz, float3(0.2126f, 0.7152f, 0.0722f)); + o0.xyz = lerp(o0.xyz, float3(skyboxLuma, skyboxLuma, skyboxLuma), 0.5f); + } + + // ========================================================================== + // VELOCITY BUFFER OUTPUT (for motion blur / TAA) + // ========================================================================== + r0.x = max(9.99999994e-009, v3.z); + r0.xy = v3.xy / r0.xx; + r0.z = max(9.99999994e-009, v4.z); + r0.zw = v4.xy / r0.zz; + r0.xy = r0.xy + -r0.zw; + r1.xy = float2(0.5,-0.5) * r0.xy; + r1.xy = sqrt(abs(r1.xy)); + r1.xy = sqrt(r1.xy); + r0.z = -r0.y; + r0.yw = cmp(float2(0,0) < r0.xz); + r0.xz = cmp(r0.xz < float2(0,0)); + r0.xy = (int2)-r0.yw + (int2)r0.xz; + r0.xy = (int2)r0.xy; + r0.xy = r1.xy * r0.xy; + o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); + o0.w = 1; + o1.zw = float2(0,0); + return; +} diff --git a/src/games/endfield/others/skybox4_0x9D430106.ps_5_0.hlsl b/src/games/endfield/others/skybox4_0x9D430106.ps_5_0.hlsl new file mode 100644 index 0000000000..ffc48e8c64 --- /dev/null +++ b/src/games/endfield/others/skybox4_0x9D430106.ps_5_0.hlsl @@ -0,0 +1,692 @@ +#include "../shared.h" + +// ============================================================================ +// SKYBOX / SKY RENDERING SHADER +// ============================================================================ +// Textures: +// t0: 3D LUT for volumetric fog/scattering +// t1: Environment/fallback sky cubemap lookup +// t2: Main skybox texture (4096x2048 equirectangular) +// t3: Reflection probe 1 texture +// t4: Reflection probe 2 texture +// t5: Reflection probe 1 detail/tint +// t6: Reflection probe 2 detail/tint +// ============================================================================ + +Texture2D t6 : register(t6); + +Texture2D t5 : register(t5); + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture3D t0 : register(t0); + +SamplerState s5_s : register(s5); + +SamplerState s4_s : register(s4); + +SamplerState s3_s : register(s3); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb2 : register(b2) +{ + float4 cb2[45]; +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[105]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[45]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float3 v1 : TEXCOORD0, + float2 v2 : TEXCOORD1, + float3 v3 : TEXCOORD2, + float3 v4 : TEXCOORD3, + float3 v5 : TEXCOORD4, + out float4 o0 : SV_Target0, + out float4 o1 : SV_Target1) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; + uint4 bitmask, uiDest; + float4 fDest; + + // ========================================================================== + // VIEW DIRECTION CALCULATION + // ========================================================================== + r0.xyz = -cb0[44].xyz + v1.xyz; + r0.w = dot(r0.xyz, r0.xyz); + r1.x = max(9.99999994e-009, r0.w); + r1.x = rsqrt(r1.x); + r1.yzw = r1.xxx * r0.xyz; + r2.x = r1.x * r0.w; + // ========================================================================== + // OCTAHEDRAL / CUBEMAP UV MAPPING FOR t1 (fallback environment) + // ========================================================================== + r2.y = dot(abs(r1.yzw), float3(1,1,1)); + r2.y = 1 / r2.y; + r2.zw = r2.yy * r1.yw; + r2.z = r2.z + r2.w; + r2.y = r1.y * r2.y + -r2.w; + r3.xy = float2(1,1) + r2.zy; + r2.yz = float2(0.5,0.5) * r3.xy; + r2.yzw = t1.SampleLevel(s0_s, r2.yz, 0).xyz; + r3.x = 1.57079637 * r1.z; + r3.y = saturate(r1.z * 10 + 1); + // ========================================================================== + // PROCEDURAL SUN DISK CALCULATION + // ========================================================================== + // cb2[44].xyz = sun direction + // cb2[43].x = sun size/falloff exponent + // cb2[42].xyz = sun color, cb2[42].w = sun intensity + r3.z = saturate(dot(-cb2[44].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) + r3.z = log2(r3.z); + // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) + float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; + r3.z = cb2[43].x * sunSizeMultiplier * r3.z; // Apply sun size exponent + r3.z = exp2(r3.z); + r3.w = r3.z * r3.z + 1; // Soft falloff numerator + r3.w = 0.0100164423 * r3.w; + r3.z = -r3.z * 1.98000002 + 1.98010004; // Soft falloff denominator + r4.x = log2(cb2[42].w); // Sun intensity + r4.x = 0.649999976 * r4.x; + r4.x = exp2(r4.x); + r4.x = 8 * r4.x; + r3.z = log2(r3.z); + r3.z = r4.x * r3.z; + r3.z = exp2(r3.z); + r3.z = max(9.99999975e-005, r3.z); + r3.z = r3.w / r3.z; // Final sun disk intensity + // ========================================================================== + // EQUIRECTANGULAR SKYBOX UV CALCULATION (for t2: 4096x2048) + // ========================================================================== + r3.w = cb2[41].z * cb1[20].x; + r4.xy = r3.ww * float2(20,20) + float2(0,0.5); + r4.xy = frac(r4.xy); + r4.xy = float2(-0.5,-0.5) + r4.xy; + r3.x = sin(r3.x); + r5.xz = cb2[41].xy * r3.xx; + r5.y = 0; + r3.x = cb2[41].w * 0.0174532942; + sincos(r3.x, r3.x, r6.x); + r7.x = -r3.x; + r7.y = r6.x; + r6.x = dot(r7.yx, r1.yw); + r7.z = r3.x; + r6.z = dot(r7.zy, r1.yw); + r6.y = r1.z; + r7.xyz = r5.xyz * r4.xxx + r6.xyz; + r3.x = dot(r7.xyz, r7.xyz); + r3.x = rsqrt(r3.x); + r7.xyz = r7.xyz * r3.xxx; + r3.x = r7.x / r7.z; + r3.w = cmp(abs(r3.x) < 1); + r4.z = 1 / abs(r3.x); + r4.z = r3.w ? abs(r3.x) : r4.z; + r4.w = r4.z * r4.z; + r5.w = r4.w * 0.0872929022 + -0.301894993; + r4.w = r5.w * r4.w + 1; + r5.w = r4.w * r4.z; + r4.z = -r4.w * r4.z + 1.57079637; + r3.w = r3.w ? r5.w : r4.z; + r4.z = abs(r7.y) * 0.0468878001 + -0.203471005; + r4.z = r4.z * abs(r7.y) + 1.57079601; + r4.w = 1 + -abs(r7.y); + r4.w = sqrt(r4.w); + r5.w = r4.z * r4.w; + r3.x = cmp(r3.x < 0); + r3.x = r3.x ? -r3.w : r3.w; + r7.xy = cmp(r7.xy >= float2(0,0)); + r3.w = r7.x ? 3.1415925 : -3.1415925; + r6.w = cmp(r7.z < 0); + r6.w = r6.w ? 1.000000 : 0; + r8.x = r3.w * r6.w + r3.x; + r3.x = -r4.z * r4.w + 3.14159274; + r3.x = r7.y ? r5.w : r3.x; + r8.y = 1.57079637 + -r3.x; + r7.xy = r8.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); + r7.z = r7.y * 2 + -1; + // ========================================================================== + // SKYBOX TEXTURE SAMPLE (t2: 4096x2048 equirectangular) + // ========================================================================== + r7.xyzw = t2.SampleBias(s1_s, r7.xz, cb1[26].x).xyzw; + r4.yzw = r5.xyz * r4.yyy + r6.xyz; + r3.x = dot(r4.yzw, r4.yzw); + r3.x = rsqrt(r3.x); + r4.yzw = r4.yzw * r3.xxx; + r3.x = r4.y / r4.w; + r3.w = cmp(abs(r3.x) < 1); + r5.x = 1 / abs(r3.x); + r5.x = r3.w ? abs(r3.x) : r5.x; + r5.y = r5.x * r5.x; + r5.z = r5.y * 0.0872929022 + -0.301894993; + r5.y = r5.z * r5.y + 1; + r5.z = r5.y * r5.x; + r5.x = -r5.y * r5.x + 1.57079637; + r3.w = r3.w ? r5.z : r5.x; + r5.x = abs(r4.z) * 0.0468878001 + -0.203471005; + r5.x = r5.x * abs(r4.z) + 1.57079601; + r5.y = 1 + -abs(r4.z); + r5.y = sqrt(r5.y); + r5.z = r5.x * r5.y; + r3.x = cmp(r3.x < 0); + r3.x = r3.x ? -r3.w : r3.w; + r4.yz = cmp(r4.yz >= float2(0,0)); + r3.w = r4.y ? 3.1415925 : -3.1415925; + r4.y = cmp(r4.w < 0); + r4.y = r4.y ? 1.000000 : 0; + r8.x = r3.w * r4.y + r3.x; + r3.x = -r5.x * r5.y + 3.14159274; + r3.x = r4.z ? r5.z : r3.x; + r8.y = 1.57079637 + -r3.x; + r5.xy = r8.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); + r5.z = r5.y * 2 + -1; + r5.xyzw = t2.SampleBias(s1_s, r5.xz, cb1[26].x).xyzw; + r3.x = r4.x + r4.x; + r4.xyzw = r5.xyzw + -r7.xyzw; + r4.xyzw = abs(r3.xxxx) * r4.xyzw + r7.xyzw; + r5.xyz = float3(-0.5,-0.5,-0.5) + r4.xyz; + r4.xyz = r5.xyz * cb2[40].yyy + float3(0.5,0.5,0.5); + r5.xyzw = cb2[38].xyzw * r4.xyzw; + r3.x = max(r5.x, r5.y); + r4.xyzw = -r4.xyzw * cb2[38].xyzw + r3.xxxx; + r4.xyzw = cb2[40].xxxx * r4.xyzw + r5.xyzw; + r4.xyzw = cb2[39].xyzw * r4.xyzw; + r3.x = cmp(r6.y >= 0); + r3.x = r3.x ? 1.000000 : 0; + r5.x = r4.w * r3.x; + r5.x = saturate(r5.x); + // ========================================================================== + // SUN DISK BLENDING + // ========================================================================== + // Smoothstep for sun edge falloff + r3.w = -0.5 + r3.z; + r3.w = saturate(r3.w + r3.w); + r4.w = r3.w * -2 + 3; + r3.w = r3.w * r3.w; + r3.w = r4.w * r3.w; + r4.w = r3.w * r3.z; + r3.z = -r3.w * r3.z + r3.z; + r3.z = cb2[43].y * r3.z + r4.w; // Sun brightness + r5.yzw = cb2[42].xyz * r3.zzz; // Apply sun color + r5.yzw = cb2[43].www * r5.yzw; // Sun intensity multiplier + r5.yzw = cb2[44].www * r5.yzw; // Sun shadow/occlusion + r5.yzw = max(float3(0,0,0), r5.yzw); + // HDR Sun toggle + if (SUN_INTENSITY > 0.5f) { + // Calculate sun-view alignment (1 = looking directly at sun center) + float sunDot = saturate(dot(-cb2[44].xyz, -r1.yzw)); + + // === HORIZON REDDENING === + // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) + float sunHeight = saturate(cb2[44].y + 0.1f); // Shift so effect starts slightly above horizon + + // Warm shift when sun is low (more red/orange near horizon) + float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange + float3(1.0f, 0.95f, 0.9f), // High sun: nearly white + sunHeight); + + // === LIMB DARKENING === + // Real stars appear darker at edges due to optical depth through atmosphere + // Use a soft power curve - center is brightest, edges darken + float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges + + // === CHROMATIC SUN EDGE === + // Core is white-hot, edges transition to yellow/orange + float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center + float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge + + // Blend from edge color to core color based on how centered we are + float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core + float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); + + // === COMBINE SUN DISK === + // Apply limb darkening and chromatic color to base sun + r5.yzw = r5.yzw * limbDarkening * chromaticColor * horizonTint; + + // Boost the sun intensity for HDR + r5.yzw = r5.yzw * 5.0f; + + // === CORONA GLOW === + // Inner corona (tight glow) + float coronaInner = pow(sunDot, 64.0f); + // Outer corona (wide soft glow) + float coronaOuter = pow(sunDot, 8.0f); + + // Corona colors - also affected by horizon + float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon + float3(1.0f, 0.7f, 0.3f), // Normal inner + sunHeight); + float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon + float3(1.0f, 0.5f, 0.2f), // Normal outer + sunHeight); + + float3 corona = coronaInner * coronaColorInner * 2.0f + + coronaOuter * coronaColorOuter * 0.5f; + + // Modulate corona by sun color/intensity from game + corona *= cb2[42].xyz * cb2[42].w; + corona *= cb2[44].w; // Sun shadow/occlusion + + // Add corona to sun + r5.yzw += corona; + + // === DESATURATE SUN (50%) === + float sunLuma = dot(r5.yzw, float3(0.2126f, 0.7152f, 0.0722f)); + r5.yzw = lerp(r5.yzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); + + // === BLOOM BOOST === + r5.yzw *= 10.0f; + + } else { + // Vanilla clamp + r5.yzw = min(float3(3,3,3), r5.yzw); + } + + // Blend environment + sun + skybox + r2.yzw = r2.yzw * r3.yyy + r5.yzw; + r3.yzw = r4.xyz * r3.xxx + -r2.yzw; + r2.yzw = r5.xxx * r3.yzw + r2.yzw; + // ========================================================================== + // REFLECTION PROBE 1 (cb2[0].x enables this) + // ========================================================================== + r3.yz = cmp(float2(0.75,0.75) < cb2[0].xy); + if (r3.y != 0) { + r3.y = rsqrt(r0.w); + r5.yzw = r3.yyy * r0.yxz; + r3.y = dot(r5.zyw, cb2[15].xyz); + r3.w = cb2[19].x * cb2[19].x + -1; + r3.w = r3.y * r3.y + r3.w; + r4.w = max(0, r3.w); + r4.w = sqrt(r4.w); + r3.y = -r4.w + r3.y; + r6.xyz = r5.zyw * r3.yyy + -cb2[15].xyz; + r6.xyz = r6.xyz / cb2[19].xxx; + r3.y = dot(r6.xyz, cb2[21].xyz); + r7.xyz = -cb2[21].xyz * r3.yyy + r6.xyz; + r4.w = dot(r7.xyz, r7.xyz); + r4.w = rsqrt(r4.w); + r7.xyz = r7.xyz * r4.www; + r4.w = dot(r7.xyz, cb2[25].xyz); + r6.w = cmp(0 < r4.w); + r4.w = cmp(r4.w < 0); + r4.w = (int)-r6.w + (int)r4.w; + r4.w = (int)r4.w; + r6.w = saturate(-r4.w); + r7.x = dot(r7.xyz, cb2[23].xyz); + r7.y = 1 + -abs(r7.x); + r7.y = sqrt(r7.y); + r7.z = abs(r7.x) * -0.0187292993 + 0.0742610022; + r7.z = r7.z * abs(r7.x) + -0.212114394; + r7.z = r7.z * abs(r7.x) + 1.57072878; + r7.w = r7.z * r7.y; + r7.w = r7.w * -2 + 3.14159274; + r7.x = cmp(r7.x < -r7.x); + r7.x = r7.x ? r7.w : 0; + r7.x = r7.z * r7.y + r7.x; + r4.w = r7.x * r4.w; + r7.x = r4.w * 0.159154937 + r6.w; + r4.w = r3.y * r3.y; + r4.w = r4.w * -0.222222224 + -0.277777791; + r7.y = r4.w * -r3.y + 0.50000006; + r8.xyzw = t3.SampleBias(s2_s, r7.xy, cb1[26].x).xyzw; + r3.y = saturate(dot(cb2[17].xyz, r6.xyz)); + r3.y = saturate(r3.y * cb2[1].x + cb2[1].z); + r6.xyz = t5.SampleBias(s4_s, r7.xy, cb1[26].x).xyz; + r6.xyz = cb2[9].xyz * r6.xyz; + r8.xyz = r8.xyz * r3.yyy + r6.xyz; + r3.y = dot(cb2[15].xyz, cb2[15].xyz); + r3.y = rsqrt(r3.y); + r6.xyz = cb2[15].xyz * r3.yyy; + r3.y = saturate(dot(r5.zyw, r6.xyz)); + r3.y = r3.w * r3.y; + r3.y = max(0, r3.y); + r3.y = cmp(0 < r3.y); + r3.y = r3.y ? 1.000000 : 0; + r6.xyzw = r8.xyzw * r3.yyyy; + r6.xyz = r6.xyz * r8.www; + r6.xyzw = cb2[5].xyzw * r6.xyzw; + r5.y = saturate(r5.y); + r3.y = -1 + r5.y; + r3.y = cb2[29].w * r3.y + 1; + r7.xyzw = r6.xyzw * r3.yyyy; + r3.w = cmp(cb2[2].x >= 0.5); + r3.w = r3.w ? 1.000000 : 0; + r5.yz = cmp(float2(1.5,0.5) >= cb2[2].xx); + r5.yz = r5.yz ? float2(1,1) : 0; + r3.w = -r3.w * r5.y + 1; + r3.w = -r7.w * r3.w + 1; + r4.w = dot(r7.xyz, float3(0.212672904,0.715152204,0.0721750036)); + r6.xyz = r6.xyz * r3.yyy + -r4.www; + r6.xyz = cb1[104].www * r6.xyz + r4.www; + r6.xyz = cb1[104].xyz * r6.xyz; + r3.y = -r6.w * r3.y + 1; + r3.y = -r3.y * r5.z + 1; + r5.yzw = r6.xyz * r3.yyy; + r2.yzw = r2.yzw * r3.www + r5.yzw; + } + // ========================================================================== + // REFLECTION PROBE 2 (cb2[0].y enables this) + // ========================================================================== + if (r3.z != 0) { + r3.y = rsqrt(r0.w); + r3.yzw = r3.yyy * r0.yxz; + r0.x = dot(r3.zyw, cb2[16].xyz); + r0.z = cb2[20].x * cb2[20].x + -1; + r0.z = r0.x * r0.x + r0.z; + r4.w = max(0, r0.z); + r4.w = sqrt(r4.w); + r0.x = -r4.w + r0.x; + r5.yzw = r3.zyw * r0.xxx + -cb2[16].xyz; + r5.yzw = r5.yzw / cb2[20].xxx; + r0.x = dot(r5.yzw, cb2[22].xyz); + r6.xyz = -cb2[22].xyz * r0.xxx + r5.yzw; + r4.w = dot(r6.xyz, r6.xyz); + r4.w = rsqrt(r4.w); + r6.xyz = r6.xyz * r4.www; + r4.w = dot(r6.xyz, cb2[26].xyz); + r6.w = cmp(0 < r4.w); + r4.w = cmp(r4.w < 0); + r4.w = (int)-r6.w + (int)r4.w; + r4.w = (int)r4.w; + r6.w = saturate(-r4.w); + r6.x = dot(r6.xyz, cb2[24].xyz); + r6.y = 1 + -abs(r6.x); + r6.y = sqrt(r6.y); + r6.z = abs(r6.x) * -0.0187292993 + 0.0742610022; + r6.z = r6.z * abs(r6.x) + -0.212114394; + r6.z = r6.z * abs(r6.x) + 1.57072878; + r7.x = r6.z * r6.y; + r7.x = r7.x * -2 + 3.14159274; + r6.x = cmp(r6.x < -r6.x); + r6.x = r6.x ? r7.x : 0; + r6.x = r6.z * r6.y + r6.x; + r4.w = r6.x * r4.w; + r6.x = r4.w * 0.159154937 + r6.w; + r4.w = r0.x * r0.x; + r4.w = r4.w * -0.222222224 + -0.277777791; + r6.y = r4.w * -r0.x + 0.50000006; + r7.xyzw = t4.SampleBias(s3_s, r6.xy, cb1[26].x).xyzw; + r0.x = saturate(dot(cb2[18].xyz, r5.yzw)); + r0.x = saturate(r0.x * cb2[1].y + cb2[1].w); + r5.yzw = t6.SampleBias(s5_s, r6.xy, cb1[26].x).xyz; + r5.yzw = cb2[10].xyz * r5.yzw; + r7.xyz = r7.xyz * r0.xxx + r5.yzw; + r0.x = dot(cb2[16].xyz, cb2[16].xyz); + r0.x = rsqrt(r0.x); + r5.yzw = cb2[16].xyz * r0.xxx; + r0.x = saturate(dot(r3.zyw, r5.yzw)); + r0.x = r0.z * r0.x; + r0.x = max(0, r0.x); + r0.x = cmp(0 < r0.x); + r0.x = r0.x ? 1.000000 : 0; + r6.xyzw = r7.xyzw * r0.xxxx; + r6.xyz = r6.xyz * r7.www; + r6.xyzw = cb2[6].xyzw * r6.xyzw; + r3.y = saturate(r3.y); + r0.x = -1 + r3.y; + r0.x = cb2[32].w * r0.x + 1; + r7.xyzw = r6.xyzw * r0.xxxx; + r0.z = cmp(cb2[2].y >= 0.5); + r0.z = r0.z ? 1.000000 : 0; + r3.yz = cmp(float2(1.5,0.5) >= cb2[2].yy); + r3.yz = r3.yz ? float2(1,1) : 0; + r0.z = -r0.z * r3.y + 1; + r0.z = -r7.w * r0.z + 1; + r0.x = -r6.w * r0.x + 1; + r0.x = -r0.x * r3.z + 1; + r3.yzw = r7.xyz * r0.xxx; + r2.yzw = r2.yzw * r0.zzz + r3.yzw; + } + // Final skybox blend + r3.xyz = r4.xyz * r3.xxx + -r2.yzw; + r2.yzw = r5.xxx * r3.xyz + r2.yzw; + // ========================================================================== + // ATMOSPHERIC FOG / SCATTERING (Height-based exponential fog) + // ========================================================================== + r0.x = v1.y * cb1[74].w + cb1[75].w; + r0.z = r2.x * cb1[72].w + -cb1[71].w; + r0.xz = max(float2(0.00999999978,0), r0.xz); + r3.x = -1.44269502 * r0.x; + r3.x = exp2(r3.x); + r3.x = 1 + -r3.x; + r0.x = r3.x / r0.x; + r3.x = v1.y * cb1[74].w + cb1[76].w; + r3.x = 1.44269502 * r3.x; + r3.x = exp2(r3.x); + r0.x = r3.x * r0.x; + r0.x = -r0.z * r0.x; + r3.xyz = cb1[73].xyz * r0.xxx; + r3.xyz = float3(1.44269502,1.44269502,1.44269502) * r3.xyz; + r3.xyz = exp2(r3.xyz); + r0.x = dot(r1.yzw, cb1[72].xyz); + r0.z = cb1[73].w * cb1[73].w + 1; + r3.w = dot(r0.xx, cb1[73].ww); + r0.z = -r3.w + r0.z; + // ========================================================================== + // VOLUMETRIC FOG SAMPLING (t0: 3D fog volume) + // ========================================================================== + r3.w = cmp(0 < cb1[83].z); + if (r3.w != 0) { + r4.xy = (uint2)v0.xy; + r4.z = 7 & asint(cb1[26].w); + r5.xyz = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); + r3.w = mad((int)r5.y, (int)r5.z, (int)r5.x); + r4.z = mad((int)r5.z, (int)r3.w, (int)r5.y); + r4.w = mad((int)r3.w, (int)r4.z, (int)r5.z); + r5.x = mad((int)r4.z, (int)r4.w, (int)r3.w); + r6.x = -cb0[0].z; + r6.y = -cb0[1].z; + r6.z = -cb0[2].z; + r3.w = dot(r1.yzw, r6.xyz); + r5.z = cmp(5.96046448e-008 < r3.w); + r3.w = 1 / r3.w; + r3.w = r5.z ? r3.w : 0; + r3.w = cb1[83].w * r3.w; + r5.z = 1 / r2.x; + r5.w = r5.z * r3.w; + r6.x = r5.w * r0.y + cb0[44].y; + r5.w = -r5.w * r0.y + r0.y; + r3.w = -r3.w * r5.z + 1; + r5.z = r3.w * r2.x; + r6.y = cb1[77].z * r5.w; + r5.w = cb1[80].x * r5.w; + r5.w = max(-127, r5.w); + r6.z = -cb1[77].x + r6.x; + r6.z = cb1[77].z * r6.z; + r6.yz = max(float2(-127,-127), r6.yz); + r6.z = exp2(-r6.z); + r6.z = cb1[77].y * r6.z; + r6.w = cmp(5.96046448e-008 < abs(r6.y)); + r7.x = exp2(-r6.y); + r7.x = 1 + -r7.x; + r7.x = r7.x / r6.y; + r6.y = -r6.y * 0.240226507 + 0.693147182; + r6.y = r6.w ? r7.x : r6.y; + r6.x = -cb1[80].z + r6.x; + r6.x = cb1[80].x * r6.x; + r6.x = max(-127, r6.x); + r6.x = exp2(-r6.x); + r6.x = cb1[80].y * r6.x; + r6.w = cmp(5.96046448e-008 < abs(r5.w)); + r7.x = exp2(-r5.w); + r7.x = 1 + -r7.x; + r7.x = r7.x / r5.w; + r5.w = -r5.w * 0.240226507 + 0.693147182; + r5.w = r6.w ? r7.x : r5.w; + r5.w = r6.x * r5.w; + r5.w = r6.z * r6.y + r5.w; + r6.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r5.z = r5.w * r5.z; + r5.z = exp2(-r5.z); + r5.z = min(1, r5.z); + r5.z = max(cb1[79].w, r5.z); + r5.z = r5.z + r6.y; + r5.z = r5.z + r6.x; + r5.z = min(1, r5.z); + r5.y = mad((int)r4.w, (int)r5.x, (int)r4.z); + r4.zw = (uint2)r5.xy >> int2(16,16); + r4.xyzw = (uint4)r4.xyzw; + r4.zw = r4.zw * float2(3.05180438e-005,3.05180438e-005) + float2(-1,-1); + r4.xy = r4.zw * cb1[87].ww + r4.xy; + r4.xy = cb1[85].xy * r4.xy; + r4.w = v0.w * cb1[84].x + cb1[84].y; + r4.w = log2(r4.w); + r4.w = cb1[84].z * r4.w; + r4.z = r4.w / cb1[83].z; + r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; + r5.x = -cb1[86].z + v0.w; + r5.x = saturate(1000000 * r5.x); + r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; + r4.xyzw = r5.xxxx * r4.xyzw + float4(0,0,0,1); + r5.x = 1 + -r5.z; + r5.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r5.y = log2(r5.y); + r5.y = cb1[82].w * r5.y; + r5.y = exp2(r5.y); + r6.yzw = cb1[82].xyz * r5.yyy; + r3.w = r3.w * r2.x + -cb1[81].w; + r3.w = max(0, r3.w); + r3.w = r5.w * r3.w; + r3.w = exp2(-r3.w); + r3.w = min(1, r3.w); + r3.w = 1 + -r3.w; + r6.yzw = r6.yzw * r3.www; + r3.w = 1 + -r6.x; + r6.xyz = r6.yzw * r3.www; + r5.xyw = cb1[79].xyz * r5.xxx + r6.xyz; + r4.xyz = r5.xyw * r4.www + r4.xyz; + r3.w = r4.w * r5.z; + } else { + r4.w = cb1[77].z * r0.y; + r4.w = max(-127, r4.w); + r0.y = cb1[80].x * r0.y; + r0.y = max(-127, r0.y); + r5.x = -cb1[77].x + cb0[44].y; + r5.x = cb1[77].z * r5.x; + r5.x = max(-127, r5.x); + r5.x = exp2(-r5.x); + r5.x = cb1[77].y * r5.x; + r5.y = cmp(5.96046448e-008 < abs(r4.w)); + r5.z = exp2(-r4.w); + r5.z = 1 + -r5.z; + r5.z = r5.z / r4.w; + r4.w = -r4.w * 0.240226507 + 0.693147182; + r4.w = r5.y ? r5.z : r4.w; + r5.y = -cb1[80].z + cb0[44].y; + r5.y = cb1[80].x * r5.y; + r5.y = max(-127, r5.y); + r5.y = exp2(-r5.y); + r5.y = cb1[80].y * r5.y; + r5.z = cmp(5.96046448e-008 < abs(r0.y)); + r5.w = exp2(-r0.y); + r5.w = 1 + -r5.w; + r5.w = r5.w / r0.y; + r0.y = -r0.y * 0.240226507 + 0.693147182; + r0.y = r5.z ? r5.w : r0.y; + r0.y = r5.y * r0.y; + r0.y = r5.x * r4.w + r0.y; + r5.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r2.x = r0.y * r2.x; + r2.x = exp2(-r2.x); + r2.x = min(1, r2.x); + r2.x = max(cb1[79].w, r2.x); + r2.x = r2.x + r5.y; + r2.x = r2.x + r5.x; + r3.w = min(1, r2.x); + r2.x = 1 + -r3.w; + r1.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r1.y = log2(r1.y); + r1.y = cb1[82].w * r1.y; + r1.y = exp2(r1.y); + r1.yzw = cb1[82].xyz * r1.yyy; + r0.w = r0.w * r1.x + -cb1[81].w; + r0.w = max(0, r0.w); + r0.y = r0.y * r0.w; + r0.y = exp2(-r0.y); + r0.y = min(1, r0.y); + r0.y = 1 + -r0.y; + r1.xyz = r1.yzw * r0.yyy; + r0.y = 1 + -r5.x; + r1.xyz = r1.xyz * r0.yyy; + r4.xyz = cb1[79].xyz * r2.xxx + r1.xyz; + } + // ========================================================================== + // FINAL COLOR GRADING + // ========================================================================== + // Desaturation based on luminance + r0.y = dot(r2.yzw, float3(0.212672904,0.715152204,0.0721750036)); // Luminance + r1.xyz = r2.yzw + -r0.yyy; + r1.xyz = cb1[104].www * r1.xyz + r0.yyy; // Saturation control + r1.xyz = cb1[104].xyz * r1.xyz; // Color tint/exposure + r2.xyz = r3.xyz * r3.www; + r0.x = r0.x * r0.x + 1; + r0.x = 0.0596831031 * r0.x; + r0.xyw = cb1[74].xyz * r0.xxx + cb1[76].xyz; + r1.w = -cb1[73].w * cb1[73].w + 1; + r2.w = 12.566371 * r0.z; + r0.z = sqrt(r0.z); + r0.z = r2.w * r0.z; + r0.z = max(0.00100000005, r0.z); + r0.z = r1.w / r0.z; + r0.xyz = saturate(cb1[75].xyz * r0.zzz + r0.xyw); + r0.xyz = float3(255,255,255) * r0.xyz; + r3.xyz = float3(1,1,1) + -r3.xyz; + r0.xyz = r3.xyz * r0.xyz; + r0.xyz = r0.xyz * r3.www + r4.xyz; + o0.xyz = r1.xyz * r2.xyz + r0.xyz; + + // ========================================================================== + // SKYBOX DESATURATION (50%) - Tech Test Look + // ========================================================================== + if (TECH_TEST_LOOK > 0.5f) { + float skyboxLuma = dot(o0.xyz, float3(0.2126f, 0.7152f, 0.0722f)); + o0.xyz = lerp(o0.xyz, float3(skyboxLuma, skyboxLuma, skyboxLuma), 0.5f); + } + + // ========================================================================== + // VELOCITY BUFFER OUTPUT (for motion blur / TAA) + // ========================================================================== + r0.x = max(9.99999994e-009, v3.z); + r0.xy = v3.xy / r0.xx; + r0.z = max(9.99999994e-009, v4.z); + r0.zw = v4.xy / r0.zz; + r0.xy = r0.xy + -r0.zw; + r1.xy = float2(0.5,-0.5) * r0.xy; + r1.xy = sqrt(abs(r1.xy)); + r1.xy = sqrt(r1.xy); + r0.z = -r0.y; + r0.yw = cmp(float2(0,0) < r0.xz); + r0.xz = cmp(r0.xz < float2(0,0)); + r0.xy = (int2)-r0.yw + (int2)r0.xz; + r0.xy = (int2)r0.xy; + r0.xy = r1.xy * r0.xy; + o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); + o0.w = 1; + o1.zw = float2(0,0); + return; +} diff --git a/src/games/endfield/others/skybox5_0xCD4FEF5A.ps_5_0.hlsl b/src/games/endfield/others/skybox5_0xCD4FEF5A.ps_5_0.hlsl new file mode 100644 index 0000000000..654ab99c37 --- /dev/null +++ b/src/games/endfield/others/skybox5_0xCD4FEF5A.ps_5_0.hlsl @@ -0,0 +1,928 @@ +#include "../shared.h" + +Texture2D t6 : register(t6); + +Texture2D t5 : register(t5); + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture3D t0 : register(t0); + +SamplerState s5_s : register(s5); + +SamplerState s4_s : register(s4); + +SamplerState s3_s : register(s3); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb2 : register(b2) +{ + float4 cb2[45]; +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[105]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[45]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, // Screen position + float3 v1 : TEXCOORD0, // World position + float2 v2 : TEXCOORD1, // Unused + float3 v3 : TEXCOORD2, // Motion vector data 1 + float3 v4 : TEXCOORD3, // Motion vector data 2 + float3 v5 : TEXCOORD4, // Unused + out float4 o0 : SV_Target0, // Final color output + out float4 o1 : SV_Target1) // Motion vectors output +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16; + uint4 bitmask, uiDest; + float4 fDest; + + // ============================================================================ + // VIEW DIRECTION AND DISTANCE CALCULATION + // ============================================================================ + r0.xyz = -cb0[44].xyz + v1.xyz; + r0.w = dot(r0.xyz, r0.xyz); + r1.x = max(9.99999994e-009, r0.w); + r1.x = rsqrt(r1.x); + r1.yzw = r1.xxx * r0.xyz; + r2.x = r1.x * r0.w; + r2.y = dot(abs(r1.yzw), float3(1,1,1)); + r2.y = 1 / r2.y; + r2.zw = r2.yy * r1.yw; + r2.z = r2.z + r2.w; + r2.y = r1.y * r2.y + -r2.w; + r3.xy = float2(1,1) + r2.zy; + r2.yz = float2(0.5,0.5) * r3.xy; + r2.yzw = t1.SampleLevel(s0_s, r2.yz, 0).xyz; + r3.x = saturate(r1.z * 10 + 1); + // ========================================================================== + // PROCEDURAL SUN DISK CALCULATION + // ========================================================================== + // cb2[44].xyz = sun direction + // cb2[43].x = sun size/falloff exponent + // cb2[42].xyz = sun color, cb2[42].w = sun intensity + r3.y = saturate(dot(-cb2[44].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) + r3.y = log2(r3.y); + // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) + float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; + r3.y = cb2[43].x * sunSizeMultiplier * r3.y; // Apply sun size exponent + r3.y = exp2(r3.y); + r3.z = r3.y * r3.y + 1; + r3.y = -r3.y * 1.98000002 + 1.98010004; + r3.w = log2(cb2[42].w); + r3.zw = float2(0.0100164423,0.649999976) * r3.zw; + r3.w = exp2(r3.w); + r3.w = 8 * r3.w; + r3.y = log2(r3.y); + r3.y = r3.w * r3.y; + r3.y = exp2(r3.y); + r3.y = max(9.99999975e-005, r3.y); + r3.y = r3.z / r3.y; + // ============================================================================ + // SUN SPECULAR HIGHLIGHT WITH SMOOTHSTEP + // ============================================================================ + r3.z = -0.5 + r3.y; + r3.z = saturate(r3.z + r3.z); + r3.w = r3.z * -2 + 3; + r3.z = r3.z * r3.z; + r3.z = r3.w * r3.z; + r3.w = r3.z * r3.y; + r3.y = -r3.z * r3.y + r3.y; + r3.y = cb2[43].y * r3.y + r3.w; // Sun brightness + r3.yzw = cb2[42].xyz * r3.yyy; // Apply sun color + r3.yzw = cb2[43].www * r3.yzw; // Sun intensity multiplier + r3.yzw = cb2[44].www * r3.yzw; // Sun shadow/occlusion + r3.yzw = max(float3(0,0,0), r3.yzw); + // HDR Sun toggle + if (SUN_INTENSITY > 0.5f) { + // Calculate sun-view alignment (1 = looking directly at sun center) + float sunDot = saturate(dot(-cb2[44].xyz, -r1.yzw)); + + // === HORIZON REDDENING === + // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) + float sunHeight = saturate(cb2[44].y + 0.1f); // Shift so effect starts slightly above horizon + + // Warm shift when sun is low (more red/orange near horizon) + float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange + float3(1.0f, 0.95f, 0.9f), // High sun: nearly white + sunHeight); + + // === LIMB DARKENING === + // Real stars appear darker at edges due to optical depth through atmosphere + // Use a soft power curve - center is brightest, edges darken + float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges + + // === CHROMATIC SUN EDGE === + // Core is white-hot, edges transition to yellow/orange + float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center + float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge + + // Blend from edge color to core color based on how centered we are + float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core + float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); + + // === COMBINE SUN DISK === + // Apply limb darkening and chromatic color to base sun + r3.yzw = r3.yzw * limbDarkening * chromaticColor * horizonTint; + + // Boost the sun intensity for HDR + r3.yzw = r3.yzw * 5.0f; + + // === CORONA GLOW === + // Inner corona (tight glow) + float coronaInner = pow(sunDot, 64.0f); + // Outer corona (wide soft glow) + float coronaOuter = pow(sunDot, 8.0f); + + // Corona colors - also affected by horizon + float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon + float3(1.0f, 0.7f, 0.3f), // Normal inner + sunHeight); + float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon + float3(1.0f, 0.5f, 0.2f), // Normal outer + sunHeight); + + float3 corona = coronaInner * coronaColorInner * 2.0f + + coronaOuter * coronaColorOuter * 0.5f; + + // Modulate corona by sun color/intensity from game + corona *= cb2[42].xyz * cb2[42].w; + corona *= cb2[44].w; // Sun shadow/occlusion + + // Add corona to sun + r3.yzw += corona; + + // === DESATURATE SUN (50%) === + float sunLuma = dot(r3.yzw, float3(0.2126f, 0.7152f, 0.0722f)); + r3.yzw = lerp(r3.yzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); + + // === BLOOM BOOST === + r3.yzw *= 10.0f; + + } else { + // Vanilla clamp + r3.yzw = min(float3(3,3,3), r3.yzw); + } + + // Combine skybox, sun specular, and clouds + r2.yzw = r2.yzw * r3.xxx + r3.yzw; + // ============================================================================ + // VOLUMETRIC LIGHT SHAFT SYSTEM 1 (conditional) + // ============================================================================ + r3.xy = cmp(float2(0.75,0.75) < cb2[0].xy); + if (r3.x != 0) { + r3.x = 1 / cb2[27].x; + r3.z = cb2[27].w + cb2[27].x; + r3.w = rsqrt(r0.w); + r4.xyz = r3.www * r0.xyz; + // ============================================================================ + // SPHERICAL LIGHT SOURCE INTERSECTION (cb2[15] = light position) + // ============================================================================ + r3.w = dot(r4.xyz, cb2[15].xyz); + r4.w = cb2[19].x * cb2[19].x + -1; + r4.w = r3.w * r3.w + r4.w; + r5.x = max(0, r4.w); + r5.x = sqrt(r5.x); + r3.w = -r5.x + r3.w; + r5.xyz = r4.xyz * r3.www + -cb2[15].xyz; + r5.xyz = r5.xyz / cb2[19].xxx; + r3.w = dot(cb2[15].xyz, cb2[15].xyz); + r3.w = rsqrt(r3.w); + r6.xyz = cb2[15].xyz * r3.www; + r3.w = saturate(dot(r4.xyz, r6.xyz)); + r3.w = r4.w * r3.w; + r3.w = max(0, r3.w); + r3.w = cmp(0 < r3.w); + r4.w = r3.w ? 1.000000 : 0; + r5.w = dot(cb2[21].xyz, cb2[15].xyz); + r6.x = dot(cb2[21].xyz, r4.xyz); + r5.w = abs(r5.w) / abs(r6.x); + r6.xyz = r4.xyz * r5.www + -cb2[15].xyz; + r5.w = dot(r6.xyz, r6.xyz); + r5.w = sqrt(r5.w); + r7.xyz = r6.xyz / r5.www; + r6.x = dot(cb2[21].xyz, r6.xyz); + r6.x = cmp(abs(r6.x) < 0.00100000005); + r6.x = r6.x ? 1.000000 : 0; + r6.x = r6.x * r5.w; + r6.y = r6.x * cb2[19].z + cb2[19].w; + r6.z = dot(r5.xyz, cb2[21].xyz); + r8.xyz = -cb2[21].xyz * r6.zzz + r5.xyz; + r6.w = dot(r8.xyz, r8.xyz); + r6.w = rsqrt(r6.w); + r8.xyz = r8.xyz * r6.www; + r6.w = dot(r8.xyz, cb2[25].xyz); + r7.w = cmp(0 < r6.w); + r6.w = cmp(r6.w < 0); + r6.w = (int)-r7.w + (int)r6.w; + r6.w = (int)r6.w; + r7.w = saturate(-r6.w); + r8.x = dot(r8.xyz, cb2[23].xyz); + r8.y = 1 + -abs(r8.x); + r8.y = sqrt(r8.y); + r8.z = abs(r8.x) * -0.0187292993 + 0.0742610022; + r8.z = r8.z * abs(r8.x) + -0.212114394; + r8.z = r8.z * abs(r8.x) + 1.57072878; + r8.w = r8.z * r8.y; + r8.w = r8.w * -2 + 3.14159274; + r8.x = cmp(r8.x < -r8.x); + r8.x = r8.x ? r8.w : 0; + r8.x = r8.z * r8.y + r8.x; + r6.w = r8.x * r6.w; + r8.x = r6.w * 0.159154937 + r7.w; + r6.w = r6.z * r6.z; + r6.w = r6.w * -0.222222224 + -0.277777791; + r8.y = r6.w * -r6.z + 0.50000006; + // ============================================================================ + // CLOUD/ATMOSPHERE TEXTURE SAMPLING + // ============================================================================ + r9.xyzw = t2.SampleBias(s1_s, r8.xy, cb1[26].x).xyzw; + r5.x = saturate(dot(cb2[17].xyz, r5.xyz)); + r5.x = saturate(r5.x * cb2[1].x + cb2[1].z); + r8.xyz = t4.SampleBias(s3_s, r8.xy, cb1[26].x).xyz; + r8.xyz = cb2[9].xyz * r8.xyz; + r9.xyz = r9.xyz * r5.xxx + r8.xyz; + r8.xyzw = r9.xyzw * r4.wwww; + r5.y = saturate(1 + -r6.y); + r5.y = r5.y * r6.y; + r5.z = cmp(0 < r5.y); + r5.y = cmp(r5.y < 0); + r5.y = (int)-r5.z + (int)r5.y; + r5.y = (int)r5.y; + r5.z = dot(r4.xyz, r7.xyz); + r6.z = cmp(0 < -r5.z); + r5.z = cmp(-r5.z < 0); + r5.z = (int)-r6.z + (int)r5.z; + r5.z = (int)r5.z; + r5.yz = saturate(r5.yz); + r5.z = -1 + r5.z; + r4.w = r4.w * r5.z + 1; + r4.w = r5.y * r4.w; + r5.y = dot(r7.xyz, cb2[25].xyz); + r5.z = cmp(0 < r5.y); + r5.y = cmp(r5.y < 0); + r5.y = (int)-r5.z + (int)r5.y; + r5.y = (int)r5.y; + r5.z = dot(cb2[17].xyz, r7.xyz); + r5.z = saturate(-r5.z); + r6.z = saturate(-r5.y); + r6.w = dot(r7.xyz, cb2[23].xyz); + r7.x = 1 + -abs(r6.w); + r7.x = sqrt(r7.x); + r7.y = abs(r6.w) * -0.0187292993 + 0.0742610022; + r7.y = r7.y * abs(r6.w) + -0.212114394; + r7.y = r7.y * abs(r6.w) + 1.57072878; + r7.z = r7.y * r7.x; + r7.z = r7.z * -2 + 3.14159274; + r6.w = cmp(r6.w < -r6.w); + r6.w = r6.w ? r7.z : 0; + r6.w = r7.y * r7.x + r6.w; + r5.y = r6.w * r5.y; + r6.x = r5.y * 0.159154937 + r6.z; + r6.xyzw = t6.SampleBias(s5_s, r6.xy, cb1[26].x).xyzw; + r6.xyzw = cb2[7].xyzw * r6.xyzw; + r5.y = -r5.z * r5.z + 1; + r5.y = sqrt(r5.y); + r5.y = -r5.w * r5.y + cb2[19].x; + r5.y = cb2[19].y * r5.y; + r5.y = r5.y / cb2[0].z; + r5.y = saturate(1 + r5.y); + r5.y = 1 + -r5.y; + r5.z = dot(cb2[17].xyz, cb2[21].xyz); + r5.z = 0.400000006 + abs(r5.z); + r5.z = min(1, r5.z); + r5.y = r5.y * r5.z; + r6.xyzw = r6.xyzw * r5.yyyy; + r5.yzw = r6.xyz * r6.www; + r5.yzw = r5.yzw * r4.www; + r7.xyz = r8.xyz * r9.www + r5.yzw; + r4.w = r6.w * r4.w; + r3.w = r3.w ? 0 : 1; + r7.w = r4.w * r3.w + r8.w; + r3.w = saturate(r4.y); + r3.w = -1 + r3.w; + r3.w = cb2[29].w * r3.w + 1; + r6.xyzw = cb2[5].xyzw * r7.xyzw; + r7.xyzw = r6.xyzw * r3.wwww; + r4.w = dot(r4.xyz, r4.xyz); + r4.w = max(1.17549435e-038, r4.w); + r4.w = rsqrt(r4.w); + r4.xyz = r4.xyz * r4.www; + r4.w = dot(cb2[17].xyz, cb2[17].xyz); + r4.w = max(1.17549435e-038, r4.w); + r4.w = rsqrt(r4.w); + r5.yzw = cb2[17].xyz * r4.www; + r8.xyz = -cb2[13].xyz + cb0[44].xyz; + r4.w = dot(r4.xyz, r8.xyz); + r8.x = dot(r8.xyz, r8.xyz); + r8.y = -r3.z * r3.z + r8.x; + r8.y = r4.w * r4.w + -r8.y; + r8.z = cmp(0 < r8.y); + r8.y = sqrt(r8.y); + r8.w = -r8.y + -r4.w; + r9.x = max(0, r8.w); + r8.y = r8.y + -r4.w; + r9.y = r8.y + -r9.x; + r8.yw = r8.zz ? r9.xy : 0; + if (r8.z != 0) { + r8.x = -cb2[27].w * cb2[27].w + r8.x; + r8.x = r4.w * r4.w + -r8.x; + r8.z = cmp(0 < r8.x); + r8.x = sqrt(r8.x); + r4.w = -r8.x + -r4.w; + r4.w = max(0, r4.w); + r4.w = r8.z ? r4.w : 0; + r8.x = cmp(0 < r4.w); + r4.w = r4.w + -r8.y; + r4.w = min(r8.w, r4.w); + r4.w = r8.x ? r4.w : r8.w; + r4.w = r8.z ? r4.w : r8.w; + r8.x = cmp(0 < r4.w); + if (r8.x != 0) { + r4.w = r4.w / cb2[27].y; + r8.x = dot(-r4.xyz, r5.yzw); + r9.xyz = cb2[27].zzz * float3(0.000244140625,0.0012673497,0.00266802101); + r8.yzw = r4.xyz * r8.yyy + cb0[44].xyz; + r10.xyz = r4.xyz * r4.www; + r8.yzw = r10.xyz * float3(0.5,0.5,0.5) + r8.yzw; + r10.xyz = float3(0.5,0.5,0.5) * r5.yzw; + r11.xyz = r8.yzw; + r12.xyz = float3(0,0,0); + r9.w = 0; + r10.w = 0; + while (true) { + r11.w = (int)r10.w; + r11.w = cmp(r11.w >= cb2[27].y); + if (r11.w != 0) break; + r13.xyz = -cb2[13].xyz + r11.xyz; + r11.w = dot(r13.xyz, r13.xyz); + r12.w = sqrt(r11.w); + r12.w = -cb2[27].w + r12.w; + r12.w = r12.w * r3.x; + r12.w = cb2[28].y * -r12.w; + r12.w = 1.44269502 * r12.w; + r12.w = exp2(r12.w); + r12.w = r12.w * r4.w; + r12.w = min(3.40282347e+038, r12.w); + r9.w = r12.w + r9.w; + r13.x = dot(r5.yzw, r13.xyz); + r11.w = -r3.z * r3.z + r11.w; + r11.w = r13.x * r13.x + -r11.w; + r13.y = cmp(0 < r11.w); + r11.w = sqrt(r11.w); + r13.z = -r13.x + r11.w; + r11.w = -r13.x + -r11.w; + r11.w = max(0, r11.w); + r11.w = r13.z + -r11.w; + r11.w = r13.y ? r11.w : 0; + r11.w = r11.w / cb2[28].x; + r13.xyz = r10.xyz * r11.www + r11.xyz; + r14.xyz = r13.xyz; + r13.w = 0; + r14.w = 0; + while (true) { + r15.x = (int)r14.w; + r15.x = cmp(r15.x >= cb2[28].x); + if (r15.x != 0) break; + r15.xyz = -cb2[13].xyz + r14.xyz; + r16.xyz = r5.yzw * r11.www + r14.xyz; + r15.x = dot(r15.xyz, r15.xyz); + r15.x = sqrt(r15.x); + r15.x = -cb2[27].w + r15.x; + r15.x = max(0, r15.x); + r15.x = r15.x * r3.x; + r15.x = cb2[28].y * -r15.x; + r15.x = 1.44269502 * r15.x; + r15.x = exp2(r15.x); + r15.x = r15.x + r13.w; + r15.y = (int)r14.w + 1; + r14.xyz = r16.xyz; + r13.w = r15.x; + r14.w = r15.y; + continue; + } + r11.w = r13.w * r11.w + r9.w; + r13.xyz = r11.www * r9.xyz; + r13.xyz = float3(-1.44269502,-1.44269502,-1.44269502) * r13.xyz; + r13.xyz = exp2(r13.xyz); + r12.xyz = r13.xyz * r12.www + r12.xyz; + r11.xyz = r4.xyz * r4.www + r11.xyz; + r10.w = (int)r10.w + 1; + } + r3.x = r8.x * r8.x + 1; + r3.x = 0.0596831031 * r3.x; + r4.xyz = r12.xyz * r3.xxx; + r4.xyz = r4.xyz * r9.xyz; + } else { + r4.xyz = float3(0,0,0); + } + } else { + r4.xyz = float3(0,0,0); + } + r8.xyw = cb2[28].zzz * r4.yzx; + r3.x = cmp(r8.x >= r8.y); + r3.x = r3.x ? 1.000000 : 0; + r9.xy = r8.yx; + r9.zw = float2(-1,0.666666687); + r4.xy = r4.yz * cb2[28].zz + -r9.xy; + r4.zw = float2(1,-1); + r4.xyzw = r3.xxxx * r4.xyzw + r9.xyzw; + r3.x = cmp(r8.w >= r4.x); + r3.x = r3.x ? 1.000000 : 0; + r8.xyz = r4.xyw; + r4.xyw = r8.wyx; + r4.xyzw = r4.xyzw + -r8.xyzw; + r4.xyzw = r3.xxxx * r4.xyzw + r8.xyzw; + r3.x = min(r4.w, r4.y); + r3.x = r4.x + -r3.x; + r3.z = r4.w + -r4.y; + r4.y = r3.x * 6 + 9.99999975e-005; + r3.z = r3.z / r4.y; + r3.z = r4.z + r3.z; + r3.z = cb2[28].w + abs(r3.z); + r4.yzw = float3(1,0.666666687,0.333333343) + r3.zzz; + r4.yzw = frac(r4.yzw); + r4.yzw = r4.yzw * float3(6,6,6) + float3(-3,-3,-3); + r4.yzw = saturate(float3(-1,-1,-1) + abs(r4.yzw)); + r3.z = 9.99999975e-005 + r4.x; + r3.x = r3.x / r3.z; + r4.yzw = float3(-1,-1,-1) + r4.yzw; + r4.yzw = r3.xxx * r4.yzw + float3(1,1,1); + r5.yzw = r4.yzw * r4.xxx; + r3.x = cmp(cb2[2].x >= 0.5); + r3.x = r3.x ? 1.000000 : 0; + r8.xy = cmp(float2(1.5,0.5) >= cb2[2].xx); + r8.xy = r8.xy ? float2(1,1) : 0; + r3.x = -r3.x * r8.x + 1; + r3.x = -r7.w * r3.x + 1; + r3.z = dot(r7.xyz, float3(0.212672904,0.715152204,0.0721750036)); + r6.xyz = r6.xyz * r3.www + -r3.zzz; + r6.xyz = cb1[104].www * r6.xyz + r3.zzz; + r6.xyz = cb1[104].xyz * r6.xyz; + r3.z = -r6.w * r3.w + 1; + r3.z = -r3.z * r8.y + 1; + r6.xyz = r6.xyz * r3.zzz; + r6.xyz = r2.yzw * r3.xxx + r6.xyz; + r5.xyz = r5.yzw * r5.xxx; + r4.xyz = r4.yzw * r4.xxx + -r5.xyz; + r4.xyz = cb2[29].yyy * r4.xyz + r5.xyz; + r2.yzw = r4.xyz * r3.www + r6.xyz; + } + if (r3.y != 0) { + r3.x = 1 / cb2[30].x; + r3.y = cb2[30].w + cb2[30].x; + r3.z = rsqrt(r0.w); + r4.xyz = r3.zzz * r0.xyz; + r0.x = dot(r4.xyz, cb2[16].xyz); + r0.z = cb2[20].x * cb2[20].x + -1; + r0.z = r0.x * r0.x + r0.z; + r3.z = max(0, r0.z); + r3.z = sqrt(r3.z); + r0.x = -r3.z + r0.x; + r5.xyz = r4.xyz * r0.xxx + -cb2[16].xyz; + r5.xyz = r5.xyz / cb2[20].xxx; + r0.x = dot(r5.xyz, cb2[22].xyz); + r6.xyz = -cb2[22].xyz * r0.xxx + r5.xyz; + r3.z = dot(r6.xyz, r6.xyz); + r3.z = rsqrt(r3.z); + r6.xyz = r6.xyz * r3.zzz; + r3.z = dot(r6.xyz, cb2[26].xyz); + r3.w = cmp(0 < r3.z); + r3.z = cmp(r3.z < 0); + r3.z = (int)-r3.w + (int)r3.z; + r3.z = (int)r3.z; + r3.w = saturate(-r3.z); + r4.w = dot(r6.xyz, cb2[24].xyz); + r5.w = 1 + -abs(r4.w); + r5.w = sqrt(r5.w); + r6.x = abs(r4.w) * -0.0187292993 + 0.0742610022; + r6.x = r6.x * abs(r4.w) + -0.212114394; + r6.x = r6.x * abs(r4.w) + 1.57072878; + r6.y = r6.x * r5.w; + r6.y = r6.y * -2 + 3.14159274; + r4.w = cmp(r4.w < -r4.w); + r4.w = r4.w ? r6.y : 0; + r4.w = r6.x * r5.w + r4.w; + r3.z = r4.w * r3.z; + r6.x = r3.z * 0.159154937 + r3.w; + r3.z = r0.x * r0.x; + r3.z = r3.z * -0.222222224 + -0.277777791; + r6.y = r3.z * -r0.x + 0.50000006; + r7.xyzw = t3.SampleBias(s2_s, r6.xy, cb1[26].x).xyzw; + r0.x = saturate(dot(cb2[18].xyz, r5.xyz)); + r0.x = saturate(r0.x * cb2[1].y + cb2[1].w); + r5.xyz = t5.SampleBias(s4_s, r6.xy, cb1[26].x).xyz; + r5.xyz = cb2[10].xyz * r5.xyz; + r7.xyz = r7.xyz * r0.xxx + r5.xyz; + r3.z = dot(cb2[16].xyz, cb2[16].xyz); + r3.z = rsqrt(r3.z); + r5.xyz = cb2[16].xyz * r3.zzz; + r3.z = saturate(dot(r4.xyz, r5.xyz)); + r0.z = r3.z * r0.z; + r0.z = max(0, r0.z); + r0.z = cmp(0 < r0.z); + r0.z = r0.z ? 1.000000 : 0; + r5.xyzw = r7.xyzw * r0.zzzz; + r5.xyz = r5.xyz * r7.www; + r0.z = saturate(r4.y); + r0.z = -1 + r0.z; + r0.z = cb2[32].w * r0.z + 1; + r5.xyzw = cb2[6].xyzw * r5.xyzw; + r6.xyzw = r5.xyzw * r0.zzzz; + r3.z = dot(r4.xyz, r4.xyz); + r3.z = max(1.17549435e-038, r3.z); + r3.z = rsqrt(r3.z); + r4.xyz = r4.xyz * r3.zzz; + r3.z = dot(cb2[18].xyz, cb2[18].xyz); + r3.z = max(1.17549435e-038, r3.z); + r3.z = rsqrt(r3.z); + r5.xyz = cb2[18].xyz * r3.zzz; + r7.xyz = -cb2[14].xyz + cb0[44].xyz; + r3.z = dot(r4.xyz, r7.xyz); + r3.w = dot(r7.xyz, r7.xyz); + r4.w = -r3.y * r3.y + r3.w; + r4.w = r3.z * r3.z + -r4.w; + r7.x = cmp(0 < r4.w); + r4.w = sqrt(r4.w); + r7.y = -r4.w + -r3.z; + r8.x = max(0, r7.y); + r4.w = r4.w + -r3.z; + r8.y = r4.w + -r8.x; + r7.yz = r7.xx ? r8.xy : 0; + if (r7.x != 0) { + r3.w = -cb2[30].w * cb2[30].w + r3.w; + r3.w = r3.z * r3.z + -r3.w; + r4.w = cmp(0 < r3.w); + r3.w = sqrt(r3.w); + r3.z = -r3.z + -r3.w; + r3.z = max(0, r3.z); + r3.z = r4.w ? r3.z : 0; + r3.w = cmp(0 < r3.z); + r3.z = r3.z + -r7.y; + r3.z = min(r7.z, r3.z); + r3.z = r3.w ? r3.z : r7.z; + r3.z = r4.w ? r3.z : r7.z; + r3.w = cmp(0 < r3.z); + if (r3.w != 0) { + r3.z = r3.z / cb2[30].y; + r3.w = dot(-r4.xyz, r5.xyz); + r7.xzw = cb2[30].zzz * float3(0.000244140625,0.0012673497,0.00266802101); + r8.xyz = r4.xyz * r7.yyy + cb0[44].xyz; + r9.xyz = r4.xyz * r3.zzz; + r8.xyz = r9.xyz * float3(0.5,0.5,0.5) + r8.xyz; + r9.xyz = float3(0.5,0.5,0.5) * r5.xyz; + r10.xyz = r8.xyz; + r11.xyz = float3(0,0,0); + r4.w = 0; + r7.y = 0; + while (true) { + r8.w = (int)r7.y; + r8.w = cmp(r8.w >= cb2[30].y); + if (r8.w != 0) break; + r12.xyz = -cb2[14].xyz + r10.xyz; + r8.w = dot(r12.xyz, r12.xyz); + r9.w = sqrt(r8.w); + r9.w = -cb2[30].w + r9.w; + r9.w = r9.w * r3.x; + r9.w = cb2[31].y * -r9.w; + r9.w = 1.44269502 * r9.w; + r9.w = exp2(r9.w); + r9.w = r9.w * r3.z; + r9.w = min(3.40282347e+038, r9.w); + r4.w = r9.w + r4.w; + r10.w = dot(r5.xyz, r12.xyz); + r8.w = -r3.y * r3.y + r8.w; + r8.w = r10.w * r10.w + -r8.w; + r11.w = cmp(0 < r8.w); + r8.w = sqrt(r8.w); + r12.x = -r10.w + r8.w; + r8.w = -r10.w + -r8.w; + r8.w = max(0, r8.w); + r8.w = r12.x + -r8.w; + r8.w = r11.w ? r8.w : 0; + r8.w = r8.w / cb2[31].x; + r12.xyz = r9.xyz * r8.www + r10.xyz; + r13.xyz = r12.xyz; + r10.w = 0; + r11.w = 0; + while (true) { + r12.w = (int)r11.w; + r12.w = cmp(r12.w >= cb2[31].x); + if (r12.w != 0) break; + r14.xyz = -cb2[14].xyz + r13.xyz; + r15.xyz = r5.xyz * r8.www + r13.xyz; + r12.w = dot(r14.xyz, r14.xyz); + r12.w = sqrt(r12.w); + r12.w = -cb2[30].w + r12.w; + r12.w = max(0, r12.w); + r12.w = r12.w * r3.x; + r12.w = cb2[31].y * -r12.w; + r12.w = 1.44269502 * r12.w; + r12.w = exp2(r12.w); + r12.w = r12.w + r10.w; + r13.w = (int)r11.w + 1; + r13.xyz = r15.xyz; + r10.w = r12.w; + r11.w = r13.w; + continue; + } + r8.w = r10.w * r8.w + r4.w; + r12.xyz = r8.www * r7.xzw; + r12.xyz = float3(-1.44269502,-1.44269502,-1.44269502) * r12.xyz; + r12.xyz = exp2(r12.xyz); + r11.xyz = r12.xyz * r9.www + r11.xyz; + r10.xyz = r4.xyz * r3.zzz + r10.xyz; + r7.y = (int)r7.y + 1; + } + r3.x = r3.w * r3.w + 1; + r3.x = 0.0596831031 * r3.x; + r3.xyz = r11.xyz * r3.xxx; + r3.xyz = r3.xyz * r7.xzw; + } else { + r3.xyz = float3(0,0,0); + } + } else { + r3.xyz = float3(0,0,0); + } + r4.xyw = cb2[31].zzz * r3.yzx; + r3.x = cmp(r4.x >= r4.y); + r3.x = r3.x ? 1.000000 : 0; + r7.xy = r4.yx; + r7.zw = float2(-1,0.666666687); + r8.xy = r3.yz * cb2[31].zz + -r7.xy; + r8.zw = float2(1,-1); + r3.xyzw = r3.xxxx * r8.xyzw + r7.xyzw; + r5.x = cmp(r4.w >= r3.x); + r5.x = r5.x ? 1.000000 : 0; + r4.xyz = r3.xyw; + r3.xyw = r4.wyx; + r3.xyzw = r3.xyzw + -r4.xyzw; + r3.xyzw = r5.xxxx * r3.xyzw + r4.xyzw; + r4.x = min(r3.w, r3.y); + r4.x = -r4.x + r3.x; + r3.y = r3.w + -r3.y; + r3.w = r4.x * 6 + 9.99999975e-005; + r3.y = r3.y / r3.w; + r3.y = r3.z + r3.y; + r3.y = cb2[31].w + abs(r3.y); + r3.yzw = float3(1,0.666666687,0.333333343) + r3.yyy; + r3.yzw = frac(r3.yzw); + r3.yzw = r3.yzw * float3(6,6,6) + float3(-3,-3,-3); + r3.yzw = saturate(float3(-1,-1,-1) + abs(r3.yzw)); + r4.y = 9.99999975e-005 + r3.x; + r4.x = r4.x / r4.y; + r3.yzw = float3(-1,-1,-1) + r3.yzw; + r3.yzw = r4.xxx * r3.yzw + float3(1,1,1); + r4.xyz = r3.yzw * r3.xxx; + r4.w = cmp(cb2[2].y >= 0.5); + r4.w = r4.w ? 1.000000 : 0; + r5.xy = cmp(float2(1.5,0.5) >= cb2[2].yy); + r5.xy = r5.xy ? float2(1,1) : 0; + r4.w = -r4.w * r5.x + 1; + r4.w = -r6.w * r4.w + 1; + r5.x = -r5.w * r0.z + 1; + r5.x = -r5.x * r5.y + 1; + r5.xyz = r6.xyz * r5.xxx; + r5.xyz = r2.yzw * r4.www + r5.xyz; + r4.xyz = r4.xyz * r0.xxx; + r3.xyz = r3.yzw * r3.xxx + -r4.xyz; + r3.xyz = cb2[32].yyy * r3.xyz + r4.xyz; + r2.yzw = r3.xyz * r0.zzz + r5.xyz; + } + r0.x = v1.y * cb1[74].w + cb1[75].w; + r0.z = r2.x * cb1[72].w + -cb1[71].w; + r0.xz = max(float2(0.00999999978,0), r0.xz); + r3.x = -1.44269502 * r0.x; + r3.x = exp2(r3.x); + r3.x = 1 + -r3.x; + r0.x = r3.x / r0.x; + r3.x = v1.y * cb1[74].w + cb1[76].w; + r3.x = 1.44269502 * r3.x; + r3.x = exp2(r3.x); + r0.x = r3.x * r0.x; + r0.x = -r0.z * r0.x; + r3.xyz = cb1[73].xyz * r0.xxx; + r3.xyz = float3(1.44269502,1.44269502,1.44269502) * r3.xyz; + r3.xyz = exp2(r3.xyz); + r0.x = dot(r1.yzw, cb1[72].xyz); + r0.z = cb1[73].w * cb1[73].w + 1; + r3.w = dot(r0.xx, cb1[73].ww); + r0.z = -r3.w + r0.z; + r3.w = cmp(0 < cb1[83].z); + if (r3.w != 0) { + r4.xy = (uint2)v0.xy; + r4.z = 7 & asint(cb1[26].w); + r5.xyz = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); + r3.w = mad((int)r5.y, (int)r5.z, (int)r5.x); + r4.z = mad((int)r5.z, (int)r3.w, (int)r5.y); + r4.w = mad((int)r3.w, (int)r4.z, (int)r5.z); + r5.x = mad((int)r4.z, (int)r4.w, (int)r3.w); + r6.x = -cb0[0].z; + r6.y = -cb0[1].z; + r6.z = -cb0[2].z; + r3.w = dot(r1.yzw, r6.xyz); + r5.z = cmp(5.96046448e-008 < r3.w); + r3.w = 1 / r3.w; + r3.w = r5.z ? r3.w : 0; + r3.w = cb1[83].w * r3.w; + r5.z = 1 / r2.x; + r5.w = r5.z * r3.w; + r6.x = r5.w * r0.y + cb0[44].y; + r5.w = -r5.w * r0.y + r0.y; + r3.w = -r3.w * r5.z + 1; + r5.z = r3.w * r2.x; + r6.y = cb1[77].z * r5.w; + r5.w = cb1[80].x * r5.w; + r5.w = max(-127, r5.w); + r6.z = -cb1[77].x + r6.x; + r6.z = cb1[77].z * r6.z; + r6.yz = max(float2(-127,-127), r6.yz); + r6.z = exp2(-r6.z); + r6.z = cb1[77].y * r6.z; + r6.w = cmp(5.96046448e-008 < abs(r6.y)); + r7.x = exp2(-r6.y); + r7.x = 1 + -r7.x; + r7.x = r7.x / r6.y; + r6.y = -r6.y * 0.240226507 + 0.693147182; + r6.y = r6.w ? r7.x : r6.y; + r6.x = -cb1[80].z + r6.x; + r6.x = cb1[80].x * r6.x; + r6.x = max(-127, r6.x); + r6.x = exp2(-r6.x); + r6.x = cb1[80].y * r6.x; + r6.w = cmp(5.96046448e-008 < abs(r5.w)); + r7.x = exp2(-r5.w); + r7.x = 1 + -r7.x; + r7.x = r7.x / r5.w; + r5.w = -r5.w * 0.240226507 + 0.693147182; + r5.w = r6.w ? r7.x : r5.w; + r5.w = r6.x * r5.w; + r5.w = r6.z * r6.y + r5.w; + r6.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r5.z = r5.w * r5.z; + r5.z = exp2(-r5.z); + r5.z = min(1, r5.z); + r5.z = max(cb1[79].w, r5.z); + r5.z = r5.z + r6.y; + r5.z = r5.z + r6.x; + r5.z = min(1, r5.z); + r5.y = mad((int)r4.w, (int)r5.x, (int)r4.z); + r4.zw = (uint2)r5.xy >> int2(16,16); + r4.xyzw = (uint4)r4.xyzw; + r4.zw = r4.zw * float2(3.05180438e-005,3.05180438e-005) + float2(-1,-1); + r4.xy = r4.zw * cb1[87].ww + r4.xy; + r4.xy = cb1[85].xy * r4.xy; + r4.w = v0.w * cb1[84].x + cb1[84].y; + r4.w = log2(r4.w); + r4.w = cb1[84].z * r4.w; + r4.z = r4.w / cb1[83].z; + r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; + r5.x = -cb1[86].z + v0.w; + r5.x = saturate(1000000 * r5.x); + r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; + r4.xyzw = r5.xxxx * r4.xyzw + float4(0,0,0,1); + r5.x = 1 + -r5.z; + r5.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r5.y = log2(r5.y); + r5.y = cb1[82].w * r5.y; + r5.y = exp2(r5.y); + r6.yzw = cb1[82].xyz * r5.yyy; + r3.w = r3.w * r2.x + -cb1[81].w; + r3.w = max(0, r3.w); + r3.w = r5.w * r3.w; + r3.w = exp2(-r3.w); + r3.w = min(1, r3.w); + r3.w = 1 + -r3.w; + r6.yzw = r6.yzw * r3.www; + r3.w = 1 + -r6.x; + r6.xyz = r6.yzw * r3.www; + r5.xyw = cb1[79].xyz * r5.xxx + r6.xyz; + r4.xyz = r5.xyw * r4.www + r4.xyz; + r3.w = r4.w * r5.z; + } else { + r4.w = cb1[77].z * r0.y; + r4.w = max(-127, r4.w); + r0.y = cb1[80].x * r0.y; + r0.y = max(-127, r0.y); + r5.x = -cb1[77].x + cb0[44].y; + r5.x = cb1[77].z * r5.x; + r5.x = max(-127, r5.x); + r5.x = exp2(-r5.x); + r5.x = cb1[77].y * r5.x; + r5.y = cmp(5.96046448e-008 < abs(r4.w)); + r5.z = exp2(-r4.w); + r5.z = 1 + -r5.z; + r5.z = r5.z / r4.w; + r4.w = -r4.w * 0.240226507 + 0.693147182; + r4.w = r5.y ? r5.z : r4.w; + r5.y = -cb1[80].z + cb0[44].y; + r5.y = cb1[80].x * r5.y; + r5.y = max(-127, r5.y); + r5.y = exp2(-r5.y); + r5.y = cb1[80].y * r5.y; + r5.z = cmp(5.96046448e-008 < abs(r0.y)); + r5.w = exp2(-r0.y); + r5.w = 1 + -r5.w; + r5.w = r5.w / r0.y; + r0.y = -r0.y * 0.240226507 + 0.693147182; + r0.y = r5.z ? r5.w : r0.y; + r0.y = r5.y * r0.y; + r0.y = r5.x * r4.w + r0.y; + r5.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r2.x = r0.y * r2.x; + r2.x = exp2(-r2.x); + r2.x = min(1, r2.x); + r2.x = max(cb1[79].w, r2.x); + r2.x = r2.x + r5.y; + r2.x = r2.x + r5.x; + r3.w = min(1, r2.x); + r2.x = 1 + -r3.w; + r1.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r1.y = log2(r1.y); + r1.y = cb1[82].w * r1.y; + r1.y = exp2(r1.y); + r1.yzw = cb1[82].xyz * r1.yyy; + r0.w = r0.w * r1.x + -cb1[81].w; + r0.w = max(0, r0.w); + r0.y = r0.y * r0.w; + r0.y = exp2(-r0.y); + r0.y = min(1, r0.y); + r0.y = 1 + -r0.y; + r1.xyz = r1.yzw * r0.yyy; + r0.y = 1 + -r5.x; + r1.xyz = r1.xyz * r0.yyy; + r4.xyz = cb1[79].xyz * r2.xxx + r1.xyz; + } + r0.y = dot(r2.yzw, float3(0.212672904,0.715152204,0.0721750036)); + r1.xyz = r2.yzw + -r0.yyy; + r1.xyz = cb1[104].www * r1.xyz + r0.yyy; + r1.xyz = cb1[104].xyz * r1.xyz; + r2.xyz = r3.xyz * r3.www; + r0.x = r0.x * r0.x + 1; + r0.x = 0.0596831031 * r0.x; + r0.xyw = cb1[74].xyz * r0.xxx + cb1[76].xyz; + r1.w = -cb1[73].w * cb1[73].w + 1; + r2.w = 12.566371 * r0.z; + r0.z = sqrt(r0.z); + r0.z = r2.w * r0.z; + r0.z = max(0.00100000005, r0.z); + r0.z = r1.w / r0.z; + r0.xyz = saturate(cb1[75].xyz * r0.zzz + r0.xyw); + r0.xyz = float3(255,255,255) * r0.xyz; + r3.xyz = float3(1,1,1) + -r3.xyz; + r0.xyz = r3.xyz * r0.xyz; + r0.xyz = r0.xyz * r3.www + r4.xyz; + o0.xyz = r1.xyz * r2.xyz + r0.xyz; + + // ========================================================================== + // SKYBOX DESATURATION (50%) ??? Tech Test Look + // ========================================================================== + if (TECH_TEST_LOOK > 0.5f) { + float skyboxLuma = dot(o0.xyz, float3(0.2126f, 0.7152f, 0.0722f)); + o0.xyz = lerp(o0.xyz, float3(skyboxLuma, skyboxLuma, skyboxLuma), 0.5f); + } + + r0.x = max(9.99999994e-009, v3.z); + r0.xy = v3.xy / r0.xx; + r0.z = max(9.99999994e-009, v4.z); + r0.zw = v4.xy / r0.zz; + r0.xy = r0.xy + -r0.zw; + r1.xy = float2(0.5,-0.5) * r0.xy; + r1.xy = sqrt(abs(r1.xy)); + r1.xy = sqrt(r1.xy); + r0.z = -r0.y; + r0.yw = cmp(float2(0,0) < r0.xz); + r0.xz = cmp(r0.xz < float2(0,0)); + r0.xy = (int2)-r0.yw + (int2)r0.xz; + r0.xy = (int2)r0.xy; + r0.xy = r1.xy * r0.xy; + o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); + o0.w = 1; + o1.zw = float2(0,0); + return; +} diff --git a/src/games/endfield/others/skybox_0x270E5BA5.ps_5_0.hlsl b/src/games/endfield/others/skybox_0x270E5BA5.ps_5_0.hlsl new file mode 100644 index 0000000000..43e2ac072d --- /dev/null +++ b/src/games/endfield/others/skybox_0x270E5BA5.ps_5_0.hlsl @@ -0,0 +1,637 @@ +#include "../shared.h" + +// ============================================================================ +// SKYBOX / SKY RENDERING SHADER +// ============================================================================ +// Textures: +// t0: 3D LUT for volumetric fog/scattering +// t1: Environment/fallback sky cubemap lookup +// t2: Main skybox texture (4096x2048 equirectangular) +// t3: Reflection probe 1 texture +// t4: Reflection probe 2 texture +// t5: Reflection probe 1 detail/tint +// t6: Reflection probe 2 detail/tint +// ============================================================================ + +Texture2D t6 : register(t6); + +Texture2D t5 : register(t5); + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture3D t0 : register(t0); + +SamplerState s5_s : register(s5); + +SamplerState s4_s : register(s4); + +SamplerState s3_s : register(s3); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb2 : register(b2) +{ + float4 cb2[45]; +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[105]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[45]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float3 v1 : TEXCOORD0, + float2 v2 : TEXCOORD1, + float3 v3 : TEXCOORD2, + float3 v4 : TEXCOORD3, + float3 v5 : TEXCOORD4, + out float4 o0 : SV_Target0, + out float4 o1 : SV_Target1) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; + uint4 bitmask, uiDest; + float4 fDest; + + // ========================================================================== + // VIEW DIRECTION CALCULATION + // ========================================================================== + r0.xyz = -cb0[44].xyz + v1.xyz; + r0.w = dot(r0.xyz, r0.xyz); + r1.x = max(9.99999994e-009, r0.w); + r1.x = rsqrt(r1.x); + r1.yzw = r1.xxx * r0.xyz; + r2.x = r1.x * r0.w; + // ========================================================================== + // OCTAHEDRAL / CUBEMAP UV MAPPING FOR t1 (fallback environment) + // ========================================================================== + r2.y = dot(abs(r1.yzw), float3(1,1,1)); + r2.y = 1 / r2.y; + r2.zw = r2.yy * r1.yw; + r2.z = r2.z + r2.w; + r2.y = r1.y * r2.y + -r2.w; + r3.xy = float2(1,1) + r2.zy; + r2.yz = float2(0.5,0.5) * r3.xy; + r2.yzw = t1.SampleLevel(s0_s, r2.yz, 0).xyz; + r3.x = saturate(r1.z * 10 + 1); + // ========================================================================== + // PROCEDURAL SUN DISK CALCULATION + // ========================================================================== + // cb2[44].xyz = sun direction + // cb2[43].x = sun size/falloff exponent + // cb2[42].xyz = sun color, cb2[42].w = sun intensity + r3.y = saturate(dot(-cb2[44].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) + r3.y = log2(r3.y); + // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) + float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; + r3.y = cb2[43].x * sunSizeMultiplier * r3.y; // Apply sun size exponent + r3.y = exp2(r3.y); + r3.z = r3.y * r3.y + 1; // Soft falloff numerator + r3.y = -r3.y * 1.98000002 + 1.98010004; // Soft falloff denominator + r3.w = log2(cb2[42].w); // Sun intensity + r3.zw = float2(0.0100164423,0.649999976) * r3.zw; + r3.w = exp2(r3.w); + r3.w = 8 * r3.w; + r3.y = log2(r3.y); + r3.y = r3.w * r3.y; + r3.y = exp2(r3.y); + r3.y = max(9.99999975e-005, r3.y); + r3.y = r3.z / r3.y; // Final sun disk intensity + // ========================================================================== + // EQUIRECTANGULAR SKYBOX UV CALCULATION (for t2: 4096x2048) + // ========================================================================== + r3.z = r1.y / r1.w; + r3.w = cmp(abs(r3.z) < 1); + r4.x = 1 / abs(r3.z); + r4.x = r3.w ? abs(r3.z) : r4.x; + r4.y = r4.x * r4.x; + r4.z = r4.y * 0.0872929022 + -0.301894993; + r4.y = r4.z * r4.y + 1; + r4.z = r4.y * r4.x; + r4.x = -r4.y * r4.x + 1.57079637; + r3.w = r3.w ? r4.z : r4.x; + r4.x = abs(r1.z) * 0.0468878001 + -0.203471005; + r4.x = r4.x * abs(r1.z) + 1.57079601; + r4.y = 1 + -abs(r1.z); + r4.y = sqrt(r4.y); + r4.z = r4.x * r4.y; + r3.z = cmp(r3.z < 0); + r3.z = r3.z ? -r3.w : r3.w; + r5.xy = cmp(r1.yz >= float2(0,0)); + r3.w = r5.x ? 3.1415925 : -3.1415925; + r4.w = cmp(r1.w < 0); + r4.w = r4.w ? 1.000000 : 0; + r6.x = r3.w * r4.w + r3.z; + r3.z = -r4.x * r4.y + 3.14159274; + r3.z = r5.y ? r4.z : r3.z; + r6.y = 1.57079637 + -r3.z; + r3.zw = r6.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); + r3.z = -cb2[41].w * 0.00277777785 + r3.z; + r4.x = 1 + r3.z; + r4.y = r3.w * 2 + -1; + // ========================================================================== + // SKYBOX TEXTURE SAMPLE (t2: 4096x2048 equirectangular) + // ========================================================================== + r4.xyzw = t2.SampleBias(s1_s, r4.xy, cb1[26].x).xyzw; + r5.xzw = float3(-0.5,-0.5,-0.5) + r4.xyz; + r4.xyz = r5.xzw * cb2[40].yyy + float3(0.5,0.5,0.5); + r6.xyzw = cb2[38].xyzw * r4.xyzw; + r3.z = max(r6.x, r6.y); + r4.xyzw = -r4.xyzw * cb2[38].xyzw + r3.zzzz; + r4.xyzw = cb2[40].xxxx * r4.xyzw + r6.xyzw; + r4.xyzw = cb2[39].xyzw * r4.xyzw; + r3.z = r5.y ? 1.000000 : 0; + r5.x = r4.w * r3.z; + r5.x = saturate(r5.x); + // ========================================================================== + // SUN DISK BLENDING + // ========================================================================== + // Smoothstep for sun edge falloff + r3.w = -0.5 + r3.y; + r3.w = saturate(r3.w + r3.w); + r4.w = r3.w * -2 + 3; + r3.w = r3.w * r3.w; + r3.w = r4.w * r3.w; + r4.w = r3.w * r3.y; + r3.y = -r3.w * r3.y + r3.y; + r3.y = cb2[43].y * r3.y + r4.w; // Sun brightness + r5.yzw = cb2[42].xyz * r3.yyy; // Apply sun color + r5.yzw = cb2[43].www * r5.yzw; // Sun intensity multiplier + r5.yzw = cb2[44].www * r5.yzw; // Sun shadow/occlusion + r5.yzw = max(float3(0,0,0), r5.yzw); + // HDR Sun toggle + if (SUN_INTENSITY > 0.5f) { + // Calculate sun-view alignment (1 = looking directly at sun center) + float sunDot = saturate(dot(-cb2[44].xyz, -r1.yzw)); + + // === HORIZON REDDENING === + // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) + float sunHeight = saturate(cb2[44].y + 0.1f); // Shift so effect starts slightly above horizon + + // Warm shift when sun is low (more red/orange near horizon) + float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange + float3(1.0f, 0.95f, 0.9f), // High sun: nearly white + sunHeight); + + // === LIMB DARKENING === + // Real stars appear darker at edges due to optical depth through atmosphere + // Use a soft power curve - center is brightest, edges darken + float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges + + // === CHROMATIC SUN EDGE === + // Core is white-hot, edges transition to yellow/orange + float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center + float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge + + // Blend from edge color to core color based on how centered we are + float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core + float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); + + // === COMBINE SUN DISK === + // Apply limb darkening and chromatic color to base sun + r5.yzw = r5.yzw * limbDarkening * chromaticColor * horizonTint; + + // Boost the sun intensity for HDR + r5.yzw = r5.yzw * 5.0f; + + // === CORONA GLOW === + // Inner corona (tight glow) + float coronaInner = pow(sunDot, 64.0f); + // Outer corona (wide soft glow) + float coronaOuter = pow(sunDot, 8.0f); + + // Corona colors - also affected by horizon + float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon + float3(1.0f, 0.7f, 0.3f), // Normal inner + sunHeight); + float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon + float3(1.0f, 0.5f, 0.2f), // Normal outer + sunHeight); + + float3 corona = coronaInner * coronaColorInner * 2.0f + + coronaOuter * coronaColorOuter * 0.5f; + + // Modulate corona by sun color/intensity from game + corona *= cb2[42].xyz * cb2[42].w; + corona *= cb2[44].w; // Sun shadow/occlusion + + // Add corona to sun + r5.yzw += corona; + + // === DESATURATE SUN (50%) === + float sunLuma = dot(r5.yzw, float3(0.2126f, 0.7152f, 0.0722f)); + r5.yzw = lerp(r5.yzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); + + // === BLOOM BOOST === + r5.yzw *= 10.0f; + + } else { + // Vanilla clamp + r5.yzw = min(float3(3,3,3), r5.yzw); + } + + // Blend environment + sun + skybox + r2.yzw = r2.yzw * r3.xxx + r5.yzw; + r3.xyw = r4.xyz * r3.zzz + -r2.yzw; + r2.yzw = r5.xxx * r3.xyw + r2.yzw; + // ========================================================================== + // REFLECTION PROBE 1 (cb2[0].x enables this) + // ========================================================================== + r3.xy = cmp(float2(0.75,0.75) < cb2[0].xy); + if (r3.x != 0) { + r3.x = rsqrt(r0.w); + r5.yzw = r3.xxx * r0.yxz; + r3.x = dot(r5.zyw, cb2[15].xyz); + r3.w = cb2[19].x * cb2[19].x + -1; + r3.w = r3.x * r3.x + r3.w; + r4.w = max(0, r3.w); + r4.w = sqrt(r4.w); + r3.x = -r4.w + r3.x; + r6.xyz = r5.zyw * r3.xxx + -cb2[15].xyz; + r6.xyz = r6.xyz / cb2[19].xxx; + r3.x = dot(r6.xyz, cb2[21].xyz); + r7.xyz = -cb2[21].xyz * r3.xxx + r6.xyz; + r4.w = dot(r7.xyz, r7.xyz); + r4.w = rsqrt(r4.w); + r7.xyz = r7.xyz * r4.www; + r4.w = dot(r7.xyz, cb2[25].xyz); + r6.w = cmp(0 < r4.w); + r4.w = cmp(r4.w < 0); + r4.w = (int)-r6.w + (int)r4.w; + r4.w = (int)r4.w; + r6.w = saturate(-r4.w); + r7.x = dot(r7.xyz, cb2[23].xyz); + r7.y = 1 + -abs(r7.x); + r7.y = sqrt(r7.y); + r7.z = abs(r7.x) * -0.0187292993 + 0.0742610022; + r7.z = r7.z * abs(r7.x) + -0.212114394; + r7.z = r7.z * abs(r7.x) + 1.57072878; + r7.w = r7.z * r7.y; + r7.w = r7.w * -2 + 3.14159274; + r7.x = cmp(r7.x < -r7.x); + r7.x = r7.x ? r7.w : 0; + r7.x = r7.z * r7.y + r7.x; + r4.w = r7.x * r4.w; + r7.x = r4.w * 0.159154937 + r6.w; + r4.w = r3.x * r3.x; + r4.w = r4.w * -0.222222224 + -0.277777791; + r7.y = r4.w * -r3.x + 0.50000006; + r8.xyzw = t3.SampleBias(s2_s, r7.xy, cb1[26].x).xyzw; + r3.x = saturate(dot(cb2[17].xyz, r6.xyz)); + r3.x = saturate(r3.x * cb2[1].x + cb2[1].z); + r6.xyz = t5.SampleBias(s4_s, r7.xy, cb1[26].x).xyz; + r6.xyz = cb2[9].xyz * r6.xyz; + r8.xyz = r8.xyz * r3.xxx + r6.xyz; + r3.x = dot(cb2[15].xyz, cb2[15].xyz); + r3.x = rsqrt(r3.x); + r6.xyz = cb2[15].xyz * r3.xxx; + r3.x = saturate(dot(r5.zyw, r6.xyz)); + r3.x = r3.w * r3.x; + r3.x = max(0, r3.x); + r3.x = cmp(0 < r3.x); + r3.x = r3.x ? 1.000000 : 0; + r6.xyzw = r8.xyzw * r3.xxxx; + r6.xyz = r6.xyz * r8.www; + r6.xyzw = cb2[5].xyzw * r6.xyzw; + r5.y = saturate(r5.y); + r3.x = -1 + r5.y; + r3.x = cb2[29].w * r3.x + 1; + r7.xyzw = r6.xyzw * r3.xxxx; + r3.w = cmp(cb2[2].x >= 0.5); + r3.w = r3.w ? 1.000000 : 0; + r5.yz = cmp(float2(1.5,0.5) >= cb2[2].xx); + r5.yz = r5.yz ? float2(1,1) : 0; + r3.w = -r3.w * r5.y + 1; + r3.w = -r7.w * r3.w + 1; + r4.w = dot(r7.xyz, float3(0.212672904,0.715152204,0.0721750036)); + r6.xyz = r6.xyz * r3.xxx + -r4.www; + r6.xyz = cb1[104].www * r6.xyz + r4.www; + r6.xyz = cb1[104].xyz * r6.xyz; + r3.x = -r6.w * r3.x + 1; + r3.x = -r3.x * r5.z + 1; + r5.yzw = r6.xyz * r3.xxx; + r2.yzw = r2.yzw * r3.www + r5.yzw; + } + // ========================================================================== + // REFLECTION PROBE 2 (cb2[0].y enables this) + // ========================================================================== + if (r3.y != 0) { + r3.x = rsqrt(r0.w); + r3.xyw = r3.xxx * r0.yxz; + r0.x = dot(r3.yxw, cb2[16].xyz); + r0.z = cb2[20].x * cb2[20].x + -1; + r0.z = r0.x * r0.x + r0.z; + r4.w = max(0, r0.z); + r4.w = sqrt(r4.w); + r0.x = -r4.w + r0.x; + r5.yzw = r3.yxw * r0.xxx + -cb2[16].xyz; + r5.yzw = r5.yzw / cb2[20].xxx; + r0.x = dot(r5.yzw, cb2[22].xyz); + r6.xyz = -cb2[22].xyz * r0.xxx + r5.yzw; + r4.w = dot(r6.xyz, r6.xyz); + r4.w = rsqrt(r4.w); + r6.xyz = r6.xyz * r4.www; + r4.w = dot(r6.xyz, cb2[26].xyz); + r6.w = cmp(0 < r4.w); + r4.w = cmp(r4.w < 0); + r4.w = (int)-r6.w + (int)r4.w; + r4.w = (int)r4.w; + r6.w = saturate(-r4.w); + r6.x = dot(r6.xyz, cb2[24].xyz); + r6.y = 1 + -abs(r6.x); + r6.y = sqrt(r6.y); + r6.z = abs(r6.x) * -0.0187292993 + 0.0742610022; + r6.z = r6.z * abs(r6.x) + -0.212114394; + r6.z = r6.z * abs(r6.x) + 1.57072878; + r7.x = r6.z * r6.y; + r7.x = r7.x * -2 + 3.14159274; + r6.x = cmp(r6.x < -r6.x); + r6.x = r6.x ? r7.x : 0; + r6.x = r6.z * r6.y + r6.x; + r4.w = r6.x * r4.w; + r6.x = r4.w * 0.159154937 + r6.w; + r4.w = r0.x * r0.x; + r4.w = r4.w * -0.222222224 + -0.277777791; + r6.y = r4.w * -r0.x + 0.50000006; + r7.xyzw = t4.SampleBias(s3_s, r6.xy, cb1[26].x).xyzw; + r0.x = saturate(dot(cb2[18].xyz, r5.yzw)); + r0.x = saturate(r0.x * cb2[1].y + cb2[1].w); + r5.yzw = t6.SampleBias(s5_s, r6.xy, cb1[26].x).xyz; + r5.yzw = cb2[10].xyz * r5.yzw; + r7.xyz = r7.xyz * r0.xxx + r5.yzw; + r0.x = dot(cb2[16].xyz, cb2[16].xyz); + r0.x = rsqrt(r0.x); + r5.yzw = cb2[16].xyz * r0.xxx; + r0.x = saturate(dot(r3.yxw, r5.yzw)); + r0.x = r0.z * r0.x; + r0.x = max(0, r0.x); + r0.x = cmp(0 < r0.x); + r0.x = r0.x ? 1.000000 : 0; + r6.xyzw = r7.xyzw * r0.xxxx; + r6.xyz = r6.xyz * r7.www; + r6.xyzw = cb2[6].xyzw * r6.xyzw; + r3.x = saturate(r3.x); + r0.x = -1 + r3.x; + r0.x = cb2[32].w * r0.x + 1; + r7.xyzw = r6.xyzw * r0.xxxx; + r0.z = cmp(cb2[2].y >= 0.5); + r0.z = r0.z ? 1.000000 : 0; + r3.xy = cmp(float2(1.5,0.5) >= cb2[2].yy); + r3.xy = r3.xy ? float2(1,1) : 0; + r0.z = -r0.z * r3.x + 1; + r0.z = -r7.w * r0.z + 1; + r0.x = -r6.w * r0.x + 1; + r0.x = -r0.x * r3.y + 1; + r3.xyw = r7.xyz * r0.xxx; + r2.yzw = r2.yzw * r0.zzz + r3.xyw; + } + // Final skybox blend + r3.xyz = r4.xyz * r3.zzz + -r2.yzw; + r2.yzw = r5.xxx * r3.xyz + r2.yzw; + // ========================================================================== + // ATMOSPHERIC FOG / SCATTERING (Height-based exponential fog) + // ========================================================================== + r0.x = v1.y * cb1[74].w + cb1[75].w; + r0.z = r2.x * cb1[72].w + -cb1[71].w; + r0.xz = max(float2(0.00999999978,0), r0.xz); + r3.x = -1.44269502 * r0.x; + r3.x = exp2(r3.x); + r3.x = 1 + -r3.x; + r0.x = r3.x / r0.x; + r3.x = v1.y * cb1[74].w + cb1[76].w; + r3.x = 1.44269502 * r3.x; + r3.x = exp2(r3.x); + r0.x = r3.x * r0.x; + r0.x = -r0.z * r0.x; + r3.xyz = cb1[73].xyz * r0.xxx; + r3.xyz = float3(1.44269502,1.44269502,1.44269502) * r3.xyz; + r3.xyz = exp2(r3.xyz); + r0.x = dot(r1.yzw, cb1[72].xyz); + r0.z = cb1[73].w * cb1[73].w + 1; + r3.w = dot(r0.xx, cb1[73].ww); + r0.z = -r3.w + r0.z; + // ========================================================================== + // VOLUMETRIC FOG SAMPLING (t0: 3D fog volume) + // ========================================================================== + r3.w = cmp(0 < cb1[83].z); + if (r3.w != 0) { + r4.xy = (uint2)v0.xy; + r4.z = 7 & asint(cb1[26].w); + r5.xyz = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); + r3.w = mad((int)r5.y, (int)r5.z, (int)r5.x); + r4.z = mad((int)r5.z, (int)r3.w, (int)r5.y); + r4.w = mad((int)r3.w, (int)r4.z, (int)r5.z); + r5.x = mad((int)r4.z, (int)r4.w, (int)r3.w); + r6.x = -cb0[0].z; + r6.y = -cb0[1].z; + r6.z = -cb0[2].z; + r3.w = dot(r1.yzw, r6.xyz); + r5.z = cmp(5.96046448e-008 < r3.w); + r3.w = 1 / r3.w; + r3.w = r5.z ? r3.w : 0; + r3.w = cb1[83].w * r3.w; + r5.z = 1 / r2.x; + r5.w = r5.z * r3.w; + r6.x = r5.w * r0.y + cb0[44].y; + r5.w = -r5.w * r0.y + r0.y; + r3.w = -r3.w * r5.z + 1; + r5.z = r3.w * r2.x; + r6.y = cb1[77].z * r5.w; + r5.w = cb1[80].x * r5.w; + r5.w = max(-127, r5.w); + r6.z = -cb1[77].x + r6.x; + r6.z = cb1[77].z * r6.z; + r6.yz = max(float2(-127,-127), r6.yz); + r6.z = exp2(-r6.z); + r6.z = cb1[77].y * r6.z; + r6.w = cmp(5.96046448e-008 < abs(r6.y)); + r7.x = exp2(-r6.y); + r7.x = 1 + -r7.x; + r7.x = r7.x / r6.y; + r6.y = -r6.y * 0.240226507 + 0.693147182; + r6.y = r6.w ? r7.x : r6.y; + r6.x = -cb1[80].z + r6.x; + r6.x = cb1[80].x * r6.x; + r6.x = max(-127, r6.x); + r6.x = exp2(-r6.x); + r6.x = cb1[80].y * r6.x; + r6.w = cmp(5.96046448e-008 < abs(r5.w)); + r7.x = exp2(-r5.w); + r7.x = 1 + -r7.x; + r7.x = r7.x / r5.w; + r5.w = -r5.w * 0.240226507 + 0.693147182; + r5.w = r6.w ? r7.x : r5.w; + r5.w = r6.x * r5.w; + r5.w = r6.z * r6.y + r5.w; + r6.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r5.z = r5.w * r5.z; + r5.z = exp2(-r5.z); + r5.z = min(1, r5.z); + r5.z = max(cb1[79].w, r5.z); + r5.z = r5.z + r6.y; + r5.z = r5.z + r6.x; + r5.z = min(1, r5.z); + r5.y = mad((int)r4.w, (int)r5.x, (int)r4.z); + r4.zw = (uint2)r5.xy >> int2(16,16); + r4.xyzw = (uint4)r4.xyzw; + r4.zw = r4.zw * float2(3.05180438e-005,3.05180438e-005) + float2(-1,-1); + r4.xy = r4.zw * cb1[87].ww + r4.xy; + r4.xy = cb1[85].xy * r4.xy; + r4.w = v0.w * cb1[84].x + cb1[84].y; + r4.w = log2(r4.w); + r4.w = cb1[84].z * r4.w; + r4.z = r4.w / cb1[83].z; + r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; + r5.x = -cb1[86].z + v0.w; + r5.x = saturate(1000000 * r5.x); + r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; + r4.xyzw = r5.xxxx * r4.xyzw + float4(0,0,0,1); + r5.x = 1 + -r5.z; + r5.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r5.y = log2(r5.y); + r5.y = cb1[82].w * r5.y; + r5.y = exp2(r5.y); + r6.yzw = cb1[82].xyz * r5.yyy; + r3.w = r3.w * r2.x + -cb1[81].w; + r3.w = max(0, r3.w); + r3.w = r5.w * r3.w; + r3.w = exp2(-r3.w); + r3.w = min(1, r3.w); + r3.w = 1 + -r3.w; + r6.yzw = r6.yzw * r3.www; + r3.w = 1 + -r6.x; + r6.xyz = r6.yzw * r3.www; + r5.xyw = cb1[79].xyz * r5.xxx + r6.xyz; + r4.xyz = r5.xyw * r4.www + r4.xyz; + r3.w = r4.w * r5.z; + } else { + r4.w = cb1[77].z * r0.y; + r4.w = max(-127, r4.w); + r0.y = cb1[80].x * r0.y; + r0.y = max(-127, r0.y); + r5.x = -cb1[77].x + cb0[44].y; + r5.x = cb1[77].z * r5.x; + r5.x = max(-127, r5.x); + r5.x = exp2(-r5.x); + r5.x = cb1[77].y * r5.x; + r5.y = cmp(5.96046448e-008 < abs(r4.w)); + r5.z = exp2(-r4.w); + r5.z = 1 + -r5.z; + r5.z = r5.z / r4.w; + r4.w = -r4.w * 0.240226507 + 0.693147182; + r4.w = r5.y ? r5.z : r4.w; + r5.y = -cb1[80].z + cb0[44].y; + r5.y = cb1[80].x * r5.y; + r5.y = max(-127, r5.y); + r5.y = exp2(-r5.y); + r5.y = cb1[80].y * r5.y; + r5.z = cmp(5.96046448e-008 < abs(r0.y)); + r5.w = exp2(-r0.y); + r5.w = 1 + -r5.w; + r5.w = r5.w / r0.y; + r0.y = -r0.y * 0.240226507 + 0.693147182; + r0.y = r5.z ? r5.w : r0.y; + r0.y = r5.y * r0.y; + r0.y = r5.x * r4.w + r0.y; + r5.xy = saturate(r2.xx * cb1[78].wy + cb1[78].zx); + r2.x = r0.y * r2.x; + r2.x = exp2(-r2.x); + r2.x = min(1, r2.x); + r2.x = max(cb1[79].w, r2.x); + r2.x = r2.x + r5.y; + r2.x = r2.x + r5.x; + r3.w = min(1, r2.x); + r2.x = 1 + -r3.w; + r1.y = saturate(dot(-r1.yzw, cb1[81].xyz)); + r1.y = log2(r1.y); + r1.y = cb1[82].w * r1.y; + r1.y = exp2(r1.y); + r1.yzw = cb1[82].xyz * r1.yyy; + r0.w = r0.w * r1.x + -cb1[81].w; + r0.w = max(0, r0.w); + r0.y = r0.y * r0.w; + r0.y = exp2(-r0.y); + r0.y = min(1, r0.y); + r0.y = 1 + -r0.y; + r1.xyz = r1.yzw * r0.yyy; + r0.y = 1 + -r5.x; + r1.xyz = r1.xyz * r0.yyy; + r4.xyz = cb1[79].xyz * r2.xxx + r1.xyz; + } + // ========================================================================== + // FINAL COLOR GRADING + // ========================================================================== + // Desaturation based on luminance + r0.y = dot(r2.yzw, float3(0.212672904,0.715152204,0.0721750036)); // Luminance + r1.xyz = r2.yzw + -r0.yyy; + r1.xyz = cb1[104].www * r1.xyz + r0.yyy; // Saturation control + r1.xyz = cb1[104].xyz * r1.xyz; // Color tint/exposure + r2.xyz = r3.xyz * r3.www; + r0.x = r0.x * r0.x + 1; + r0.x = 0.0596831031 * r0.x; + r0.xyw = cb1[74].xyz * r0.xxx + cb1[76].xyz; + r1.w = -cb1[73].w * cb1[73].w + 1; + r2.w = 12.566371 * r0.z; + r0.z = sqrt(r0.z); + r0.z = r2.w * r0.z; + r0.z = max(0.00100000005, r0.z); + r0.z = r1.w / r0.z; + r0.xyz = saturate(cb1[75].xyz * r0.zzz + r0.xyw); + r0.xyz = float3(255,255,255) * r0.xyz; + r3.xyz = float3(1,1,1) + -r3.xyz; + r0.xyz = r3.xyz * r0.xyz; + r0.xyz = r0.xyz * r3.www + r4.xyz; + o0.xyz = r1.xyz * r2.xyz + r0.xyz; + + // ========================================================================== + // SKYBOX DESATURATION (50%) - Tech Test Look + // ========================================================================== + if (TECH_TEST_LOOK > 0.5f) { + float skyboxLuma = dot(o0.xyz, float3(0.2126f, 0.7152f, 0.0722f)); + o0.xyz = lerp(o0.xyz, float3(skyboxLuma, skyboxLuma, skyboxLuma), 0.5f); + } + + // ========================================================================== + // VELOCITY BUFFER OUTPUT (for motion blur / TAA) + // ========================================================================== + r0.x = max(9.99999994e-009, v3.z); + r0.xy = v3.xy / r0.xx; + r0.z = max(9.99999994e-009, v4.z); + r0.zw = v4.xy / r0.zz; + r0.xy = r0.xy + -r0.zw; + r1.xy = float2(0.5,-0.5) * r0.xy; + r1.xy = sqrt(abs(r1.xy)); + r1.xy = sqrt(r1.xy); + r0.z = -r0.y; + r0.yw = cmp(float2(0,0) < r0.xz); + r0.xz = cmp(r0.xz < float2(0,0)); + r0.xy = (int2)-r0.yw + (int2)r0.xz; + r0.xy = (int2)r0.xy; + r0.xy = r1.xy * r0.xy; + o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); + o0.w = 1; + o1.zw = float2(0,0); + return; +} diff --git a/src/games/endfield/others/skybox_0x9E0DE464.ps_5_0.hlsl b/src/games/endfield/others/skybox_0x9E0DE464.ps_5_0.hlsl deleted file mode 100644 index ddf5d9aec5..0000000000 --- a/src/games/endfield/others/skybox_0x9E0DE464.ps_5_0.hlsl +++ /dev/null @@ -1,592 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 13:20:49 2026 - -#include "../shared.h" - -// ============================================================================ -// SKYBOX / SKY RENDERING SHADER -// ============================================================================ -// Textures: -// t0: 3D LUT for volumetric fog/scattering -// t1: Environment/fallback sky cubemap lookup -// t2: Main skybox texture (4096x2048 equirectangular) -// t3: Reflection probe 1 texture -// t4: Reflection probe 2 texture -// t5: Reflection probe 1 detail/tint -// t6: Reflection probe 2 detail/tint -// ============================================================================ - -Texture2D t6 : register(t6); - -Texture2D t5 : register(t5); - -Texture2D t4 : register(t4); - -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture3D t0 : register(t0); - -SamplerState s5_s : register(s5); - -SamplerState s4_s : register(s4); - -SamplerState s3_s : register(s3); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[52]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[185]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float3 v5 : TEXCOORD4, - out float4 o0 : SV_Target0, - out float4 o1 : SV_Target1) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; - uint4 bitmask, uiDest; - float4 fDest; - - // ========================================================================== - // VIEW DIRECTION CALCULATION - // ========================================================================== - r0.xyz = -cb0[44].xyz + v1.xyz; - r0.w = dot(r0.xyz, r0.xyz); - r1.x = max(9.99999994e-09, r0.w); - r1.x = rsqrt(r1.x); - r1.yzw = r1.xxx * r0.xyz; - r1.x = r1.x * r0.w; - - // ========================================================================== - // OCTAHEDRAL / CUBEMAP UV MAPPING FOR t1 (fallback environment) - // ========================================================================== - r2.x = dot(abs(r1.yzw), float3(1,1,1)); - r2.x = 1 / r2.x; - r2.yz = r2.xx * r1.yw; - r2.y = r2.y + r2.z; - r2.x = r1.y * r2.x + -r2.z; - r3.xy = float2(1,1) + r2.yx; - r2.xy = float2(0.5,0.5) * r3.xy; - r2.xyz = t1.SampleLevel(s0_s, r2.xy, 0).xyz; - r2.w = saturate(r1.z * 10 + 1); - // ========================================================================== - // PROCEDURAL SUN DISK CALCULATION - // ========================================================================== - // cb1[11].xyz = sun direction - // cb1[10].x = sun size/falloff exponent - // cb1[9].xyz = sun color, cb1[9].w = sun intensity - r3.x = saturate(dot(-cb1[11].xyz, -r1.yzw)); // Sun-view alignment (1 = looking at sun) - r3.x = log2(r3.x); - - // Sun size adjustment: multiply exponent to shrink disk (5.0 = ~80% smaller) - float sunSizeMultiplier = (SUN_INTENSITY > 0.5f) ? 5.0f : 1.0f; - r3.x = cb1[10].x * sunSizeMultiplier * r3.x; // Apply sun size exponent - - r3.x = exp2(r3.x); - r3.y = r3.x * r3.x + 1; // Soft falloff numerator - r3.x = -r3.x * 1.98000002 + 1.98010004; // Soft falloff denominator - r3.z = log2(cb1[9].w); // Sun intensity - r3.yz = float2(0.0100164423,0.649999976) * r3.yz; - r3.z = exp2(r3.z); - r3.z = 8 * r3.z; - r3.x = log2(r3.x); - r3.x = r3.z * r3.x; - r3.x = exp2(r3.x); - r3.x = max(9.99999975e-05, r3.x); - r3.x = r3.y / r3.x; // Final sun disk intensity - - // ========================================================================== - // EQUIRECTANGULAR SKYBOX UV CALCULATION (for t2: 4096x2048) - // ========================================================================== - r3.y = r1.y / r1.w; - r3.z = cmp(abs(r3.y) < 1); - r3.w = 1 / abs(r3.y); - r3.w = r3.z ? abs(r3.y) : r3.w; - r4.x = r3.w * r3.w; - r4.y = r4.x * 0.0872929022 + -0.301894993; - r4.x = r4.y * r4.x + 1; - r4.y = r4.x * r3.w; - r3.w = -r4.x * r3.w + 1.57079637; - r3.z = r3.z ? r4.y : r3.w; - r3.w = abs(r1.z) * 0.0468878001 + -0.203471005; - r3.w = r3.w * abs(r1.z) + 1.57079601; - r4.x = 1 + -abs(r1.z); - r4.x = sqrt(r4.x); - r4.y = r4.x * r3.w; - r3.y = cmp(r3.y < 0); - r3.y = r3.y ? -r3.z : r3.z; - r4.zw = cmp(r1.yz >= float2(0,0)); - r3.z = r4.z ? 3.1415925 : -3.1415925; - r4.z = cmp(r1.w < 0); - r4.z = r4.z ? 1.000000 : 0; - r5.x = r3.z * r4.z + r3.y; - r3.y = -r3.w * r4.x + 3.14159274; - r3.y = r4.w ? r4.y : r3.y; - r5.y = 1.57079637 + -r3.y; - r3.yz = r5.xy * float2(0.159099996,0.318300009) + float2(0.5,0.5); - r3.y = -cb1[8].w * 0.00277777785 + r3.y; - r4.x = 1 + r3.y; - r4.y = r3.z * 2 + -1; - - // ========================================================================== - // SKYBOX TEXTURE SAMPLE (t2: 4096x2048 equirectangular) - // ========================================================================== - r5.xyzw = t2.SampleBias(s1_s, r4.xy, cb0[108].x).xyzw; - r3.yzw = float3(-0.5,-0.5,-0.5) + r5.xyz; - r5.xyz = r3.yzw * cb1[7].yyy + float3(0.5,0.5,0.5); - r6.xyzw = cb1[5].xyzw * r5.xyzw; - r3.y = max(r6.x, r6.y); - r5.xyzw = -r5.xyzw * cb1[5].xyzw + r3.yyyy; - r5.xyzw = cb1[7].xxxx * r5.xyzw + r6.xyzw; - r5.xyzw = cb1[6].xyzw * r5.xyzw; - r3.y = r4.w ? 1.000000 : 0; - r4.x = r5.w * r3.y; - r4.x = saturate(r4.x); - - // ========================================================================== - // SUN DISK BLENDING - // ========================================================================== - // Smoothstep for sun edge falloff - r3.z = -0.5 + r3.x; - r3.z = saturate(r3.z + r3.z); - r3.w = r3.z * -2 + 3; - r3.z = r3.z * r3.z; - r3.z = r3.w * r3.z; - r3.w = r3.z * r3.x; - r3.x = -r3.z * r3.x + r3.x; - r3.x = cb1[10].y * r3.x + r3.w; // Sun brightness - r3.xzw = cb1[9].xyz * r3.xxx; // Apply sun color - r3.xzw = cb1[10].www * r3.xzw; // Sun intensity multiplier - r3.xzw = cb1[11].www * r3.xzw; // Sun shadow/occlusion - r3.xzw = max(float3(0,0,0), r3.xzw); - - // HDR Sun toggle - if (SUN_INTENSITY > 0.5f) { - // Calculate sun-view alignment (1 = looking directly at sun center) - float sunDot = saturate(dot(-cb1[11].xyz, -r1.yzw)); - - // === HORIZON REDDENING === - // Sun direction Y component indicates height (-1 = below, 0 = horizon, 1 = zenith) - float sunHeight = saturate(cb1[11].y + 0.1f); // Shift so effect starts slightly above horizon - - // Warm shift when sun is low (more red/orange near horizon) - float3 horizonTint = lerp(float3(1.0f, 0.6f, 0.3f), // Low sun: warm orange - float3(1.0f, 0.95f, 0.9f), // High sun: nearly white - sunHeight); - - // === LIMB DARKENING === - // Real stars appear darker at edges due to optical depth through atmosphere - // Use a soft power curve - center is brightest, edges darken - float limbDarkening = pow(sunDot, 0.4f); // Subtle darkening toward edges - - // === CHROMATIC SUN EDGE === - // Core is white-hot, edges transition to yellow/orange - float3 sunCoreColor = float3(1.0f, 1.0f, 1.0f); // White-hot center - float3 sunEdgeColor = float3(1.0f, 0.85f, 0.6f); // Warm yellow edge - - // Blend from edge color to core color based on how centered we are - float coreFactor = pow(sunDot, 3.0f); // Sharp transition to white core - float3 chromaticColor = lerp(sunEdgeColor, sunCoreColor, coreFactor); - - // === COMBINE SUN DISK === - // Apply limb darkening and chromatic color to base sun - r3.xzw = r3.xzw * limbDarkening * chromaticColor * horizonTint; - - // Boost the sun intensity for HDR - r3.xzw = r3.xzw * 5.0f; - - // === CORONA GLOW === - // Inner corona (tight glow) - float coronaInner = pow(sunDot, 64.0f); - // Outer corona (wide soft glow) - float coronaOuter = pow(sunDot, 8.0f); - - // Corona colors - also affected by horizon - float3 coronaColorInner = lerp(float3(1.0f, 0.5f, 0.2f), // Warm inner at horizon - float3(1.0f, 0.7f, 0.3f), // Normal inner - sunHeight); - float3 coronaColorOuter = lerp(float3(1.0f, 0.3f, 0.1f), // Deep orange at horizon - float3(1.0f, 0.5f, 0.2f), // Normal outer - sunHeight); - - float3 corona = coronaInner * coronaColorInner * 2.0f - + coronaOuter * coronaColorOuter * 0.5f; - - // Modulate corona by sun color/intensity from game - corona *= cb1[9].xyz * cb1[9].w; - corona *= cb1[11].w; // Sun shadow/occlusion - - // Add corona to sun - r3.xzw += corona; - - // === DESATURATE SUN (50%) === - float sunLuma = dot(r3.xzw, float3(0.2126f, 0.7152f, 0.0722f)); - r3.xzw = lerp(r3.xzw, float3(sunLuma, sunLuma, sunLuma), 0.5f); - - // === BLOOM BOOST === - r3.xzw *= 10.0f; - - } else { - // Vanilla clamp - r3.xzw = min(float3(3,3,3), r3.xzw); - } - - // Blend environment + sun + skybox - r2.xyz = r2.xyz * r2.www + r3.xzw; - r3.xzw = r5.xyz * r3.yyy + -r2.xyz; - r2.xyz = r4.xxx * r3.xzw + r2.xyz; - - // ========================================================================== - // REFLECTION PROBE 1 (cb1[20].x enables this) - // ========================================================================== - r3.xz = cmp(float2(0.5,0.5) < cb1[20].xy); - if (r3.x != 0) { - r2.w = rsqrt(r0.w); - r4.yzw = r2.www * r0.yxz; - r2.w = dot(r4.zyw, cb1[23].xyz); - r3.x = cb1[27].x * cb1[27].x + -1; - r3.x = r2.w * r2.w + r3.x; - r3.w = max(0, r3.x); - r3.w = sqrt(r3.w); - r2.w = -r3.w + r2.w; - r6.xyz = r4.zyw * r2.www + -cb1[23].xyz; - r6.xyz = r6.xyz / cb1[27].xxx; - r2.w = dot(r6.xyz, cb1[29].xyz); - r7.xyz = -cb1[29].xyz * r2.www + r6.xyz; - r3.w = dot(r7.xyz, r7.xyz); - r3.w = rsqrt(r3.w); - r7.xyz = r7.xyz * r3.www; - r3.w = dot(r7.xyz, cb1[33].xyz); - r5.w = cmp(0 < r3.w); - r3.w = cmp(r3.w < 0); - r3.w = (int)-r5.w + (int)r3.w; - r3.w = (int)r3.w; - r5.w = saturate(-r3.w); - r6.w = dot(r7.xyz, cb1[31].xyz); - r7.x = 1 + -abs(r6.w); - r7.x = sqrt(r7.x); - r7.y = abs(r6.w) * -0.0187292993 + 0.0742610022; - r7.y = r7.y * abs(r6.w) + -0.212114394; - r7.y = r7.y * abs(r6.w) + 1.57072878; - r7.z = r7.y * r7.x; - r7.z = r7.z * -2 + 3.14159274; - r6.w = cmp(r6.w < -r6.w); - r6.w = r6.w ? r7.z : 0; - r6.w = r7.y * r7.x + r6.w; - r3.w = r6.w * r3.w; - r7.x = r3.w * 0.159154937 + r5.w; - r3.w = r2.w * r2.w; - r3.w = r3.w * -0.222222224 + -0.277777791; - r7.y = r3.w * -r2.w + 0.50000006; - r8.xyzw = t3.SampleBias(s2_s, r7.xy, cb0[108].x).xyzw; - r2.w = saturate(dot(cb1[25].xyz, r6.xyz)); - r2.w = saturate(r2.w * cb1[45].x + cb1[45].z); - r6.xyz = t5.SampleBias(s4_s, r7.xy, cb0[108].x).xyz; - r6.xyz = cb1[41].xyz * r6.xyz; - r6.xyz = r8.xyz * r2.www + r6.xyz; - r2.w = dot(cb1[23].xyz, cb1[23].xyz); - r2.w = rsqrt(r2.w); - r7.xyz = cb1[23].xyz * r2.www; - r2.w = saturate(dot(r4.zyw, r7.xyz)); - r2.w = r3.x * r2.w; - r2.w = max(0, r2.w); - r2.w = cmp(0 < r2.w); - r2.w = r2.w ? 1.000000 : 0; - r6.xyz = r6.xyz * r2.www; - r6.xyz = r6.xyz * r8.www; - r6.xyz = cb1[37].xyz * r6.xyz; - r4.y = saturate(r4.y); - r2.w = -1 + r4.y; - r2.w = cb1[48].w * r2.w + 1; - r4.yzw = r6.xyz * r2.www; - r3.x = dot(r4.yzw, float3(0.212672904,0.715152204,0.0721750036)); - r4.yzw = r6.xyz * r2.www + -r3.xxx; - r4.yzw = cb0[184].www * r4.yzw + r3.xxx; - r2.xyz = r4.yzw * cb0[184].xyz + r2.xyz; - } - - // ========================================================================== - // REFLECTION PROBE 2 (cb1[20].y enables this) - // ========================================================================== - if (r3.z != 0) { - r0.w = rsqrt(r0.w); - r0.xzw = r0.yxz * r0.www; - r2.w = dot(r0.zxw, cb1[24].xyz); - r3.x = cb1[28].x * cb1[28].x + -1; - r3.x = r2.w * r2.w + r3.x; - r3.z = max(0, r3.x); - r3.z = sqrt(r3.z); - r2.w = -r3.z + r2.w; - r4.yzw = r0.zxw * r2.www + -cb1[24].xyz; - r4.yzw = r4.yzw / cb1[28].xxx; - r2.w = dot(r4.yzw, cb1[30].xyz); - r6.xyz = -cb1[30].xyz * r2.www + r4.yzw; - r3.z = dot(r6.xyz, r6.xyz); - r3.z = rsqrt(r3.z); - r6.xyz = r6.xyz * r3.zzz; - r3.z = dot(r6.xyz, cb1[34].xyz); - r3.w = cmp(0 < r3.z); - r3.z = cmp(r3.z < 0); - r3.z = (int)-r3.w + (int)r3.z; - r3.z = (int)r3.z; - r3.w = saturate(-r3.z); - r5.w = dot(r6.xyz, cb1[32].xyz); - r6.x = 1 + -abs(r5.w); - r6.x = sqrt(r6.x); - r6.y = abs(r5.w) * -0.0187292993 + 0.0742610022; - r6.y = r6.y * abs(r5.w) + -0.212114394; - r6.y = r6.y * abs(r5.w) + 1.57072878; - r6.z = r6.y * r6.x; - r6.z = r6.z * -2 + 3.14159274; - r5.w = cmp(r5.w < -r5.w); - r5.w = r5.w ? r6.z : 0; - r5.w = r6.y * r6.x + r5.w; - r3.z = r5.w * r3.z; - r6.x = r3.z * 0.159154937 + r3.w; - r3.z = r2.w * r2.w; - r3.z = r3.z * -0.222222224 + -0.277777791; - r6.y = r3.z * -r2.w + 0.50000006; - r7.xyzw = t4.SampleBias(s3_s, r6.xy, cb0[108].x).xyzw; - r2.w = saturate(dot(cb1[26].xyz, r4.yzw)); - r2.w = saturate(r2.w * cb1[45].y + cb1[45].w); - r4.yzw = t6.SampleBias(s5_s, r6.xy, cb0[108].x).xyz; - r4.yzw = cb1[42].xyz * r4.yzw; - r4.yzw = r7.xyz * r2.www + r4.yzw; - r2.w = dot(cb1[24].xyz, cb1[24].xyz); - r2.w = rsqrt(r2.w); - r6.xyz = cb1[24].xyz * r2.www; - r0.z = saturate(dot(r0.zxw, r6.xyz)); - r0.z = r3.x * r0.z; - r0.z = max(0, r0.z); - r0.z = cmp(0 < r0.z); - r0.z = r0.z ? 1.000000 : 0; - r3.xzw = r4.yzw * r0.zzz; - r3.xzw = r3.xzw * r7.www; - r3.xzw = cb1[38].xyz * r3.xzw; - r0.x = saturate(r0.x); - r0.x = -1 + r0.x; - r0.x = cb1[51].w * r0.x + 1; - r2.xyz = r3.xzw * r0.xxx + r2.xyz; - } - - // Final skybox blend - r0.xzw = r5.xyz * r3.yyy + -r2.xyz; - r0.xzw = r4.xxx * r0.xzw + r2.xyz; - - // ========================================================================== - // ATMOSPHERIC FOG / SCATTERING (Height-based exponential fog) - // ========================================================================== - r2.x = v1.y * cb0[156].w + cb0[157].w; - r2.y = r1.x * cb0[154].w + -cb0[153].w; - r2.xy = max(float2(0.00999999978,0), r2.xy); - r2.z = -1.44269502 * r2.x; - r2.z = exp2(r2.z); - r2.z = 1 + -r2.z; - r2.x = r2.z / r2.x; - r2.z = v1.y * cb0[156].w + cb0[158].w; - r2.z = 1.44269502 * r2.z; - r2.z = exp2(r2.z); - r2.x = r2.x * r2.z; - r2.x = -r2.y * r2.x; - r2.xyz = cb0[155].xyz * r2.xxx; - r2.xyz = float3(1.44269502,1.44269502,1.44269502) * r2.xyz; - r2.xyz = exp2(r2.xyz); - - r2.w = dot(r1.yzw, cb0[154].xyz); - r3.x = cb0[155].w * cb0[155].w + 1; - r3.y = dot(r2.ww, cb0[155].ww); - r3.x = r3.x + -r3.y; - - // ========================================================================== - // VOLUMETRIC FOG SAMPLING (t0: 3D fog volume) - // ========================================================================== - r3.y = cmp(0 < cb0[163].z); - if (r3.y != 0) { - r4.xy = (uint2)v0.xy; - r4.z = 7 & asint(cb0[108].w); - r3.yzw = mad((int3)r4.xyz, int3(0x19660d,0x19660d,0x19660d), int3(0x3c6ef35f,0x3c6ef35f,0x3c6ef35f)); - r3.y = mad((int)r3.z, (int)r3.w, (int)r3.y); - r3.z = mad((int)r3.w, (int)r3.y, (int)r3.z); - r3.w = mad((int)r3.y, (int)r3.z, (int)r3.w); - r5.x = mad((int)r3.z, (int)r3.w, (int)r3.y); - r6.x = -cb0[0].z; - r6.y = -cb0[1].z; - r6.z = -cb0[2].z; - r1.y = dot(r1.yzw, r6.xyz); - r1.z = cmp(5.96046448e-08 < r1.y); - r1.y = 1 / r1.y; - r1.y = r1.z ? r1.y : 0; - r1.y = cb0[163].w * r1.y; - r1.z = 1 / r1.x; - r1.w = r1.y * r1.z; - r3.y = r1.w * r0.y + cb0[44].y; - r1.w = -r1.w * r0.y + r0.y; - r4.z = cb0[159].z * r1.w; - r1.w = cb0[162].x * r1.w; - r1.w = max(-127, r1.w); - r4.w = -cb0[159].x + r3.y; - r4.w = cb0[159].z * r4.w; - r4.zw = max(float2(-127,-127), r4.zw); - r4.w = exp2(-r4.w); - r4.w = cb0[159].y * r4.w; - r5.z = cmp(5.96046448e-08 < abs(r4.z)); - r5.w = exp2(-r4.z); - r5.w = 1 + -r5.w; - r5.w = r5.w / r4.z; - r4.z = -r4.z * 0.240226507 + 0.693147182; - r4.z = r5.z ? r5.w : r4.z; - r3.y = -cb0[162].z + r3.y; - r3.y = cb0[162].x * r3.y; - r3.y = max(-127, r3.y); - r3.y = exp2(-r3.y); - r3.y = cb0[162].y * r3.y; - r5.z = cmp(5.96046448e-08 < abs(r1.w)); - r5.w = exp2(-r1.w); - r5.w = 1 + -r5.w; - r5.w = r5.w / r1.w; - r1.w = -r1.w * 0.240226507 + 0.693147182; - r1.w = r5.z ? r5.w : r1.w; - r1.w = r3.y * r1.w; - r1.w = r4.w * r4.z + r1.w; - r1.y = -r1.y * r1.z + 1; - r1.y = r1.y * r1.x; - r1.y = r1.w * r1.y; - r1.y = exp2(-r1.y); - r1.y = min(1, r1.y); - r1.y = max(cb0[161].w, r1.y); - r1.zw = saturate(r1.xx * cb0[160].yw + cb0[160].xz); - r1.y = r1.y + r1.z; - r1.y = r1.y + r1.w; - r1.y = min(1, r1.y); - r1.zw = (uint2)r4.xy; - r5.y = mad((int)r3.w, (int)r5.x, (int)r3.z); - r3.yz = (uint2)r5.xy >> int2(16,16); - r3.yz = (uint2)r3.yz; - r3.yz = r3.yz * float2(3.05180438e-05,3.05180438e-05) + float2(-1,-1); - r1.zw = r3.yz * cb0[167].ww + r1.zw; - r4.xy = cb0[165].xy * r1.zw; - r1.z = v0.w * cb0[164].x + cb0[164].y; - r1.z = log2(r1.z); - r1.z = cb0[164].z * r1.z; - r4.z = r1.z / cb0[163].z; - r4.xyzw = t0.SampleLevel(s0_s, r4.xyz, 0).xyzw; - r1.z = -cb0[166].z + v0.w; - r1.z = saturate(1000000 * r1.z); - r4.xyzw = float4(-0,-0,-0,-1) + r4.xyzw; - r4.xyzw = r1.zzzz * r4.xyzw + float4(0,0,0,1); - r1.z = 1 + -r1.y; - r3.yzw = cb0[161].xyz * r1.zzz; - r3.yzw = r3.yzw * r4.www + r4.xyz; - r1.y = r4.w * r1.y; - } else { - r1.z = cb0[159].z * r0.y; - r0.y = cb0[162].x * r0.y; - r0.y = max(-127, r0.y); - r1.w = -cb0[159].x + cb0[44].y; - r1.w = cb0[159].z * r1.w; - r1.zw = max(float2(-127,-127), r1.zw); - r1.w = exp2(-r1.w); - r1.w = cb0[159].y * r1.w; - r4.x = cmp(5.96046448e-08 < abs(r1.z)); - r4.y = exp2(-r1.z); - r4.y = 1 + -r4.y; - r4.y = r4.y / r1.z; - r1.z = -r1.z * 0.240226507 + 0.693147182; - r1.z = r4.x ? r4.y : r1.z; - r4.x = -cb0[162].z + cb0[44].y; - r4.x = cb0[162].x * r4.x; - r4.x = max(-127, r4.x); - r4.x = exp2(-r4.x); - r4.x = cb0[162].y * r4.x; - r4.y = cmp(5.96046448e-08 < abs(r0.y)); - r4.z = exp2(-r0.y); - r4.z = 1 + -r4.z; - r4.z = r4.z / r0.y; - r0.y = -r0.y * 0.240226507 + 0.693147182; - r0.y = r4.y ? r4.z : r0.y; - r0.y = r4.x * r0.y; - r0.y = r1.w * r1.z + r0.y; - r0.y = r0.y * r1.x; - r0.y = exp2(-r0.y); - r0.y = min(1, r0.y); - r0.y = max(cb0[161].w, r0.y); - r1.xz = saturate(r1.xx * cb0[160].yw + cb0[160].xz); - r0.y = r1.x + r0.y; - r0.y = r0.y + r1.z; - r1.y = min(1, r0.y); - r0.y = 1 + -r1.y; - r3.yzw = cb0[161].xyz * r0.yyy; - } - - // ========================================================================== - // FINAL COLOR GRADING - // ========================================================================== - // Desaturation based on luminance - r0.y = dot(r0.xzw, float3(0.212672904,0.715152204,0.0721750036)); // Luminance - r0.xzw = r0.xzw + -r0.yyy; - r0.xyz = cb0[184].www * r0.xzw + r0.yyy; // Saturation control - r0.xyz = cb0[184].xyz * r0.xyz; // Color tint/exposure - r1.xzw = r2.xyz * r1.yyy; - r0.w = r2.w * r2.w + 1; - r0.w = 0.0596831031 * r0.w; - r4.xyz = cb0[156].xyz * r0.www + cb0[158].xyz; - r0.w = -cb0[155].w * cb0[155].w + 1; - r2.w = 12.566371 * r3.x; - r3.x = sqrt(r3.x); - r2.w = r3.x * r2.w; - r2.w = max(0.00100000005, r2.w); - r0.w = r0.w / r2.w; - r4.xyz = saturate(cb0[157].xyz * r0.www + r4.xyz); - r4.xyz = float3(255,255,255) * r4.xyz; - r2.xyz = float3(1,1,1) + -r2.xyz; - r2.xyz = r4.xyz * r2.xyz; - r2.xyz = r2.xyz * r1.yyy + r3.yzw; - o0.xyz = r0.xyz * r1.xzw + r2.xyz; - - // ========================================================================== - // VELOCITY BUFFER OUTPUT (for motion blur / TAA) - // ========================================================================== - r0.x = max(9.99999994e-09, v3.z); - r0.xy = v3.xy / r0.xx; - r0.z = max(9.99999994e-09, v4.z); - r0.zw = v4.xy / r0.zz; - r0.xy = r0.xy + -r0.zw; - r1.xy = float2(0.5,-0.5) * r0.xy; - r1.xy = sqrt(abs(r1.xy)); - r1.xy = sqrt(r1.xy); - r0.z = -r0.y; - r0.yw = cmp(float2(0,0) < r0.xz); - r0.xz = cmp(r0.xz < float2(0,0)); - r0.xy = (int2)-r0.yw + (int2)r0.xz; - r0.xy = (int2)r0.xy; - r0.xy = r1.xy * r0.xy; - o1.xy = r0.xy * float2(0.5,0.5) + float2(0.5,0.5); - o0.w = 1; - o1.zw = float2(0,0); - return; -} \ No newline at end of file diff --git a/src/games/endfield/others/sun-lens-dirt_0xC3217979.ps_5_0.hlsl b/src/games/endfield/others/sun-lens-dirt_0xA71BB1FA.ps_5_0.hlsl similarity index 81% rename from src/games/endfield/others/sun-lens-dirt_0xC3217979.ps_5_0.hlsl rename to src/games/endfield/others/sun-lens-dirt_0xA71BB1FA.ps_5_0.hlsl index b1dfa9ad53..1f844b96c8 100644 --- a/src/games/endfield/others/sun-lens-dirt_0xC3217979.ps_5_0.hlsl +++ b/src/games/endfield/others/sun-lens-dirt_0xA71BB1FA.ps_5_0.hlsl @@ -10,7 +10,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[109]; + float4 cb0[27]; } @@ -30,8 +30,8 @@ void main( uint4 bitmask, uiDest; float4 fDest; - r0.xyzw = t0.SampleBias(s0_s, v1.xy, cb0[108].x).xyzw; + r0.xyzw = t0.SampleBias(s0_s, v1.xy, cb0[26].x).xyzw; r0.xyzw = cb1[6].xyzw * r0.xyzw; - o0.xyzw = w1 * r0.xyzw; + o0.xyzw = w1 * r0.xyzw * 0.25f; return; -} \ No newline at end of file +} diff --git a/src/games/endfield/others/taa_0xD6EB7D42.ps_5_0.hlsl b/src/games/endfield/others/taa_0xD6EB7D42.ps_5_0.hlsl deleted file mode 100644 index 655228f288..0000000000 --- a/src/games/endfield/others/taa_0xD6EB7D42.ps_5_0.hlsl +++ /dev/null @@ -1,448 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Thu Nov 27 22:02:47 2025 - -// TAA shader - nothing done - -Texture2D t4 : register(t4); - -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[12]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[93]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - const float4 icb[] = { { 27, 0, 0, 0}, - { 54, 0, 0, 0}, - { 216, 0, 0, 0}, - { 432, 0, 0, 0} }; - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = cb1[7].zw * v0.xy; - r0.zw = cb1[8].xy * v0.xy; - r0.zw = floor(r0.zw); - r0.zw = (int2)r0.zw; - r1.xy = v0.xy * cb1[8].xy + -cb0[85].xy; - r1.zw = cb1[6].xy + float2(-0.5,-0.5); - r1.xy = max(float2(0.5,0.5), r1.xy); - r1.xy = min(r1.xy, r1.zw); - r1.xy = floor(r1.xy); - r2.xy = (int2)r1.xy; - r1.xy = float2(0.5,0.5) + r1.xy; - r1.xy = cb1[6].zw * r1.xy; - r1.x = t1.SampleBias(s0_s, r1.xy, cb0[92].x).x; - r2.zw = float2(0,0); - r3.xyzw = t2.Load(r2.xyz).xyzw; - r1.yz = abs(r3.xy) * float2(2,2) + float2(-1,-1); - r1.yz = r1.yz * r1.yz; - r1.yz = r1.yz * r1.yz; - r4.xyzw = float4(-0.5,-0.5,-0.600000024,-0.300000012) + r3.xyww; - r2.zw = cmp(float2(0,0) < r4.xy); - r3.xy = cmp(r4.xy < float2(0,0)); - r2.zw = (int2)-r2.zw + (int2)r3.xy; - r2.zw = (int2)r2.zw; - r1.yz = r2.zw * r1.yz; - r2.zw = v0.xy * cb1[7].zw + -r1.yz; - r1.w = cmp(0.899999976 < r3.w); - r3.x = r1.w ? 1.000000 : 0; - r3.yw = cmp(abs(r4.zw) < float2(0.100000001,0.100000001)); - r4.xy = r3.yy ? r0.zw : r2.xy; - r5.xy = (int2)r4.xy + int2(-1,-1); - r5.zw = float2(0,0); - r5.xyz = t0.Load(r5.xyz).xyz; - r5.xyz = min(float3(0,0,0), -r5.xyz); - r6.w = dot(-r5.xzy, float3(1,1,2)); - r7.y = dot(-r5.xz, float2(2,-2)); - r7.z = dot(-r5.xzy, float3(-1,-1,2)); - r8.xy = (int2)r4.xy + int2(0,-1); - r8.zw = float2(0,0); - r8.xyz = t0.Load(r8.xyz).xyz; - r8.xyz = min(float3(0,0,0), -r8.xyz); - r9.x = dot(-r8.xzy, float3(1,1,2)); - r9.y = dot(-r8.xz, float2(2,-2)); - r9.z = dot(-r8.xzy, float3(-1,-1,2)); - r10.xy = (int2)r4.xy + int2(1,-1); - r10.zw = float2(0,0); - r10.xyz = t0.Load(r10.xyz).xyz; - r10.xyz = min(float3(0,0,0), -r10.xyz); - r11.x = dot(-r10.xzy, float3(1,1,2)); - r11.y = dot(-r10.xz, float2(2,-2)); - r11.z = dot(-r10.xzy, float3(-1,-1,2)); - r12.xy = (int2)r4.xy + int2(-1,0); - r12.zw = float2(0,0); - r12.xyz = t0.Load(r12.xyz).xyz; - r12.xyz = min(float3(0,0,0), -r12.xyz); - r13.x = dot(-r12.xzy, float3(1,1,2)); - r13.y = dot(-r12.xz, float2(2,-2)); - r13.z = dot(-r12.xzy, float3(-1,-1,2)); - r4.zw = float2(0,0); - r14.xyz = t0.Load(r4.xyw).xyz; - r14.xyz = min(float3(0,0,0), -r14.xyz); - r15.x = dot(-r14.xzy, float3(1,1,2)); - r15.y = dot(-r14.xz, float2(2,-2)); - r15.z = dot(-r14.xzy, float3(-1,-1,2)); - r16.xyzw = (int4)r4.xyww + int4(1,0,0,0); - r16.xyz = t0.Load(r16.xyz).xyz; - r16.xyz = min(float3(0,0,0), -r16.xyz); - r17.x = dot(-r16.xzy, float3(1,1,2)); - r17.y = dot(-r16.xz, float2(2,-2)); - r17.z = dot(-r16.xzy, float3(-1,-1,2)); - r18.xyzw = (int4)r4.xyww + int4(-1,1,0,0); - r18.xyz = t0.Load(r18.xyz).xyz; - r18.xyz = min(float3(0,0,0), -r18.xyz); - r19.x = dot(-r18.xzy, float3(1,1,2)); - r19.y = dot(-r18.xz, float2(2,-2)); - r19.z = dot(-r18.xzy, float3(-1,-1,2)); - r20.xyzw = (int4)r4.xyww + int4(0,1,0,0); - r20.xyz = t0.Load(r20.xyz).xyz; - r20.xyz = min(float3(0,0,0), -r20.xyz); - r21.x = dot(-r20.xzy, float3(1,1,2)); - r21.y = dot(-r20.xz, float2(2,-2)); - r21.z = dot(-r20.xzy, float3(-1,-1,2)); - r4.xyzw = (int4)r4.xyzw + int4(1,1,0,0); - r4.xyz = t0.Load(r4.xyz).xyz; - r4.xyz = min(float3(0,0,0), -r4.xyz); - r22.x = dot(-r4.xzy, float3(1,1,2)); - r22.y = dot(-r4.xz, float2(2,-2)); - r22.z = dot(-r4.xzy, float3(-1,-1,2)); - r8.xyz = cb1[9].yyy * -r8.xyz; - r5.xyz = -r5.xyz * cb1[9].xxx + r8.xyz; - r5.xyz = -r10.xyz * cb1[9].zzz + r5.xyz; - r5.xyz = -r12.xyz * cb1[9].www + r5.xyz; - r5.xyz = -r14.xyz * cb1[10].xxx + r5.xyz; - r5.xyz = -r16.xyz * cb1[10].yyy + r5.xyz; - r5.xyz = -r18.xyz * cb1[10].zzz + r5.xyz; - r5.xyz = -r20.xyz * cb1[10].www + r5.xyz; - r4.xyz = -r4.xyz * cb1[11].xxx + r5.xyz; - r0.z = cb1[9].x + cb1[9].y; - r0.z = cb1[9].z + r0.z; - r0.z = cb1[9].w + r0.z; - r0.z = cb1[10].x + r0.z; - r0.z = cb1[10].y + r0.z; - r0.z = cb1[10].z + r0.z; - r0.z = cb1[10].w + r0.z; - r0.z = cb1[11].x + r0.z; - r0.z = 1 / r0.z; - r4.xyz = r4.xyz * r0.zzz; - r5.x = dot(r4.xzy, float3(1,1,2)); - r0.zw = r2.zw * cb1[7].xy + float2(-0.5,-0.5); - r0.zw = floor(r0.zw); - r8.xyzw = float4(0.5,0.5,-0.5,-0.5) + r0.zwzw; - r2.xy = r2.wz * cb1[7].yx + -r8.yx; - r10.xy = r2.yx * r2.yx; - r10.zw = r10.xy * r2.yx; - r12.xy = r10.yx * r2.xy + r2.xy; - r12.xy = -r12.xy * float2(0.5,0.5) + r10.yx; - r12.zw = float2(2.5,2.5) * r10.yx; - r10.zw = r10.wz * float2(1.5,1.5) + -r12.zw; - r10.zw = float2(1,1) + r10.zw; - r2.xy = r10.xy * r2.yx + -r10.xy; - r10.xy = float2(0.5,0.5) * r2.xy; - r12.zw = float2(1,1) + -r12.yx; - r12.zw = r12.zw + -r10.wz; - r2.xy = -r2.xy * float2(0.5,0.5) + r12.zw; - r10.zw = r10.zw + r2.yx; - r14.zw = cb1[7].zw * r8.zw; - r8.zw = float2(1,1) / r10.wz; - r2.xy = r2.xy * r8.zw + r8.xy; - r14.xy = cb1[7].zw * r2.xy; - r0.zw = float2(2.5,2.5) + r0.zw; - r8.xw = saturate(cb1[7].zw * r0.zw); - r0.zw = r10.wz * r12.xy; - r2.x = r10.w * r10.z; - r12.xy = r10.xy * r10.zw; - r16.xyzw = saturate(r14.xwzy); - r18.xyz = t4.SampleLevel(s1_s, r16.xy, 0).xyz; - r2.y = dot(r18.xyz, float3(0.212599993,0.715200007,0.0722000003)); - r2.y = 1 + r2.y; - r18.xyz = r18.xyz / r2.yyy; - r16.xyz = t4.SampleLevel(s1_s, r16.zw, 0).xyz; - r2.y = dot(r16.xyz, float3(0.212599993,0.715200007,0.0722000003)); - r2.y = 1 + r2.y; - r16.xyz = r16.xyz / r2.yyy; - r16.xyz = r16.xyz * r0.www; - r16.xyz = r18.xyz * r0.zzz + r16.xyz; - r12.zw = saturate(r14.xy); - r18.xyz = t4.SampleLevel(s1_s, r12.zw, 0).xyz; - r2.y = dot(r18.xyz, float3(0.212599993,0.715200007,0.0722000003)); - r2.y = 1 + r2.y; - r18.xyz = r18.xyz / r2.yyy; - r16.xyz = r18.xyz * r2.xxx + r16.xyz; - r8.yz = saturate(r14.yx); - r14.xyz = t4.SampleLevel(s1_s, r8.xy, 0).xyz; - r2.x = dot(r14.xyz, float3(0.212599993,0.715200007,0.0722000003)); - r2.x = 1 + r2.x; - r14.xyz = r14.xyz / r2.xxx; - r12.xzw = r14.xyz * r12.xxx + r16.xyz; - r8.xyz = t4.SampleLevel(s1_s, r8.zw, 0).xyz; - r2.x = dot(r8.xyz, float3(0.212599993,0.715200007,0.0722000003)); - r2.x = 1 + r2.x; - r8.xyz = r8.xyz / r2.xxx; - r8.xyz = r8.xyz * r12.yyy + r12.xzw; - r0.z = r0.z + r0.w; - r0.z = r10.w * r10.z + r0.z; - r0.z = r10.x * r10.z + r0.z; - r0.z = r10.y * r10.w + r0.z; - r0.z = 1 / r0.z; - r8.xyz = r8.xyz * r0.zzz; - r10.xyzw = t4.SampleLevel(s1_s, r2.zw, 0).xyzw; - r0.z = dot(r8.xyz, float3(0.212599993,0.715200007,0.0722000003)); - r0.z = 1 + -r0.z; - r8.xyz = r8.xyz / r0.zzz; - r12.xyzw = float4(0.200000003,0.200000003,0.200000003,0.899999976) * r10.xyzw; - r10.xyz = float3(1.79999995,1.79999995,1.79999995) * r10.xyz; - r8.xyz = max(r12.xyz, r8.xyz); - r8.xyz = min(r8.xyz, r10.xyz); - r10.x = dot(r8.xzy, float3(1,1,2)); - r10.y = dot(r8.xz, float2(2,-2)); - r10.z = dot(r8.xzy, float3(-1,-1,2)); - r0.z = r3.z * 1023 + 0.5; - r0.z = (uint)r0.z; - if (1 == 0) r0.z = 0; else if (1+1 < 32) { r0.z = (uint)r0.z << (32-(1 + 1)); r0.z = (uint)r0.z >> (32-1); } else r0.z = (uint)r0.z >> 1; - r0.z = (uint)r0.z; - r2.xy = -cb1[7].zw + float2(1,1); - r2.xy = cmp(r2.xy < r2.zw); - r0.w = (int)r2.y | (int)r2.x; - r2.xy = cmp(r2.zw < cb1[7].zw); - r2.x = (int)r2.y | (int)r2.x; - r0.w = (int)r0.w | (int)r2.x; - r2.x = (int)r0.w & 0x3f800000; - r2.y = max(r15.x, r6.w); - r2.z = min(r15.x, r6.w); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r6.z = min(100000, r6.w); - r6.y = 16; - r8.yzw = r2.yyy ? float3(2.38220739e-044,100000,0) : r6.yzw; - r2.z = max(r15.x, r9.x); - r2.w = min(r15.x, r9.x); - r2.z = r2.z / r2.w; - r2.w = cmp(0 < r2.z); - r2.z = cmp(r2.z < 1.89999998); - r2.z = r2.z ? r2.w : 0; - r8.x = r2.y ? 19 : 18; - r14.z = min(r8.z, r9.x); - r14.w = max(r8.w, r9.x); - r14.y = r8.y; - r8.yzw = r2.zzz ? r8.xzw : r14.yzw; - r2.y = max(r15.x, r11.x); - r2.z = min(r15.x, r11.x); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r8.x = (int)r8.y | 20; - r14.z = min(r8.z, r11.x); - r14.w = max(r8.w, r11.x); - r14.y = r8.y; - r8.yzw = r2.yyy ? r8.xzw : r14.yzw; - r2.y = max(r15.x, r13.x); - r2.z = min(r15.x, r13.x); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r8.x = (int)r8.y | 24; - r14.z = min(r8.z, r13.x); - r14.w = max(r8.w, r13.x); - r14.y = r8.y; - r8.yzw = r2.yyy ? r8.xzw : r14.yzw; - r2.y = max(r17.x, r15.x); - r2.z = min(r17.x, r15.x); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r8.x = (int)r8.y | 48; - r14.z = min(r8.z, r17.x); - r14.w = max(r8.w, r17.x); - r14.y = r8.y; - r8.yzw = r2.yyy ? r8.xzw : r14.yzw; - r2.y = max(r19.x, r15.x); - r2.z = min(r19.x, r15.x); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r8.x = (int)r8.y | 80; - r14.z = min(r8.z, r19.x); - r14.w = max(r8.w, r19.x); - r14.y = r8.y; - r8.yzw = r2.yyy ? r8.xzw : r14.yzw; - r2.y = max(r21.x, r15.x); - r2.z = min(r21.x, r15.x); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r8.x = (int)r8.y | 144; - r14.z = min(r8.z, r21.x); - r14.w = max(r8.w, r21.x); - r14.y = r8.y; - r8.yzw = r2.yyy ? r8.xzw : r14.yzw; - r2.y = max(r22.x, r15.x); - r2.z = min(r22.x, r15.x); - r2.y = r2.y / r2.z; - r2.z = cmp(0 < r2.y); - r2.y = cmp(r2.y < 1.89999998); - r2.y = r2.y ? r2.z : 0; - r8.x = (int)r8.y | 272; - r6.y = min(r8.z, r22.x); - r6.z = max(r8.w, r22.x); - r6.x = r8.y; - r2.yzw = r2.yyy ? r8.xzw : r6.xyz; - r2.w = cmp(r2.w < r15.x); - r2.z = cmp(r15.x < r2.z); - r2.z = (int)r2.z | (int)r2.w; - if (r2.z != 0) { - r2.zw = float2(0,0); - while (true) { - r3.z = cmp((int)r2.w < 4); - if (r3.z != 0) { - r3.z = (int)r2.y & (int)icb[r2.w+0].x; - r3.z = cmp((int)r3.z == (int)icb[r2.w+0].x); - if (r3.z != 0) { - r2.z = -1; - break; - } - r2.w = (int)r2.w + 1; - r2.z = 0; - continue; - } else { - r2.z = 0; - break; - } - r2.z = 0; - } - r2.y = r2.z ? 0 : 1; - } else { - r2.y = 0; - } - r2.y = max(r2.y, r12.w); - r0.x = t3.SampleLevel(s1_s, r0.xy, 0).x; - r0.x = cmp(0 < r0.x); - r0.x = r0.x ? 0 : 1; - r0.y = r1.w ? -1 : -0; - r0.x = r0.x + r0.y; - r0.y = r0.w ? -1 : -0; - r0.x = r0.x + r0.y; - r0.x = -cb1[1].w + r0.x; - r0.y = abs(r1.y) + abs(r1.z); - r0.y = cmp(0.300000012 < r0.y); - r0.y = r0.y ? -1 : -0; - r0.x = r0.x + r0.y; - r0.x = max(0, r0.x); - r0.x = r2.y * r0.x; - r0.y = cmp(r0.x >= 0.100000001); - r0.y = r0.y ? 1.000000 : 0; - r7.x = r6.w; - r2.yzw = r9.xyz * r9.xyz; - r2.yzw = r7.xyz * r7.xyz + r2.yzw; - r6.xyz = r9.xyz + r7.xyz; - r2.yzw = r11.xyz * r11.xyz + r2.yzw; - r6.xyz = r6.xyz + r11.xyz; - r2.yzw = r13.xyz * r13.xyz + r2.yzw; - r6.xyz = r6.xyz + r13.xyz; - r2.yzw = r15.xyz * r15.xyz + r2.yzw; - r6.xyz = r6.xyz + r15.xyz; - r2.yzw = r17.xyz * r17.xyz + r2.yzw; - r6.xyz = r6.xyz + r17.xyz; - r2.yzw = r19.xyz * r19.xyz + r2.yzw; - r6.xyz = r6.xyz + r19.xyz; - r2.yzw = r21.xyz * r21.xyz + r2.yzw; - r6.xyz = r6.xyz + r21.xyz; - r2.yzw = r22.xyz * r22.xyz + r2.yzw; - r6.xyz = r6.xyz + r22.xyz; - r7.xyz = float3(0.111111112,0.111111112,0.111111112) * r6.xyz; - r7.xyz = r7.xyz * r7.xyz; - r2.yzw = r2.yzw * float3(0.111111112,0.111111112,0.111111112) + -r7.xyz; - r2.yzw = sqrt(abs(r2.yzw)); - r7.xyz = float3(-20,-20,-20) + r2.yzw; - r7.xyz = saturate(float3(0.0500000007,0.0500000007,0.0500000007) * r7.xyz); - r8.xyz = r7.xyz * float3(-2,-2,-2) + float3(3,3,3); - r7.xyz = r7.xyz * r7.xyz; - r7.xyz = r8.xyz * r7.xyz; - r7.xyz = -r7.xyz * float3(0.699999988,0.699999988,0.699999988) + float3(1.25,1.25,1.25); - r2.yzw = r7.xyz * r2.yzw; - r7.xyz = r6.xyz * float3(0.111111112,0.111111112,0.111111112) + -r2.yzw; - r7.xyz = min(r7.xyz, r15.xyz); - r2.yzw = r6.xyz * float3(0.111111112,0.111111112,0.111111112) + r2.yzw; - r2.yzw = max(r2.yzw, r15.xyz); - r6.xyz = max(r10.xyz, r7.xyz); - r2.yzw = min(r6.xyz, r2.yzw); - r0.w = r0.w ? 0 : r0.y; - r6.xyz = r10.xyz + -r2.yzw; - r2.yzw = r0.www * r6.xyz + r2.yzw; - r5.y = dot(r4.xz, float2(2,-2)); - r5.z = dot(r4.xzy, float3(-1,-1,2)); - r4.xyz = r5.xyz + -r15.xyz; - r4.xyz = r0.zzz * r4.xyz + r15.xyz; - r0.w = 1 + r4.x; - r4.xyz = r4.xyz / r0.www; - r0.w = 1 + r2.y; - r2.yzw = r2.yzw / r0.www; - r0.w = abs(r1.z) * cb0[84].y + abs(r1.y); - r1.yz = r3.yw ? float2(1,1) : 0; - r1.x = r1.x * 256 + -1; - r1.x = r1.z * r1.x + 1; - r1.z = cb1[3].z + -cb1[3].y; - r0.w = r0.w * r1.x + -cb1[3].y; - r1.x = 1 / r1.z; - r0.w = saturate(r1.x * r0.w); - r1.x = r0.w * -2 + 3; - r0.w = r0.w * r0.w; - r0.w = r1.x * r0.w; - r1.x = cb1[0].w + -cb1[0].z; - r0.w = r0.w * r1.x + cb1[0].z; - r1.x = r2.x + r1.y; - r1.x = saturate(cb1[2].w + r1.x); - r1.y = cb1[4].x + -r0.w; - r0.w = r1.x * r1.y + r0.w; - r0.z = saturate(r3.x * cb1[5].x + r0.z); - r1.x = cb1[2].z + -r0.w; - r0.z = r0.z * r1.x + r0.w; - r0.w = 0.899999976 + -r0.z; - r0.y = r0.y * r0.w + r0.z; - r1.xyz = r2.yzw + -r4.xyz; - r0.yzw = r0.yyy * r1.xyz + r4.xyz; - r1.x = 1.00100005 + -r0.y; - r0.yzw = r0.yzw / r1.xxx; - r1.xyz = float3(0.25,0.25,0.25) * r0.yzw; - r2.yz = r1.xx + r1.yz; - r2.x = -r0.w * 0.25 + r2.y; - r0.y = r0.y * 0.25 + -r1.y; - r2.w = -r0.w * 0.25 + r0.y; - o0.xyz = max(float3(0,0,0), r2.xzw); - o0.w = r0.x; - return; -} \ No newline at end of file diff --git a/src/games/endfield/others/video_0x541BC9D1.ps_5_0.hlsl b/src/games/endfield/others/video_0x5477040A.ps_5_0.hlsl similarity index 96% rename from src/games/endfield/others/video_0x541BC9D1.ps_5_0.hlsl rename to src/games/endfield/others/video_0x5477040A.ps_5_0.hlsl index f1a86ff11e..b85eb5f596 100644 --- a/src/games/endfield/others/video_0x541BC9D1.ps_5_0.hlsl +++ b/src/games/endfield/others/video_0x5477040A.ps_5_0.hlsl @@ -15,7 +15,7 @@ SamplerState s0_s : register(s0); cbuffer cb0 : register(b0) { - float4 cb0[8]; + float4 cb0[6]; } @@ -50,6 +50,6 @@ void main( o0.x = rgb.x; o0.y = rgb.y; o0.z = rgb.z; - o0.w = -cb0[7].x + 1; + o0.w = -cb0[5].z + 1; return; -} \ No newline at end of file +} diff --git a/src/games/endfield/shadows/0x2F236158.cso b/src/games/endfield/shadows/0x2F236158.cso new file mode 100644 index 0000000000..7f171a1b7d Binary files /dev/null and b/src/games/endfield/shadows/0x2F236158.cso differ diff --git a/src/games/endfield/shadows/0x2F236158.ps_5_0.hlsl b/src/games/endfield/shadows/0x2F236158.ps_5_0.hlsl deleted file mode 100644 index dcc7ca962a..0000000000 --- a/src/games/endfield/shadows/0x2F236158.ps_5_0.hlsl +++ /dev/null @@ -1,72 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 04:33:32 2026 -Texture2D t0 : register(t0); - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4; - uint4 bitmask, uiDest; - float4 fDest; - - r0.zw = float2(0,0); - r1.xyzw = (int4)v0.xyxy; - r2.xyzw = (int4)r1.zwzw + int4(-3,0,-2,0); - r2.xyzw = (int4)r2.xyzw; - r2.xyzw = max(float4(0,0,0,0), r2.xyzw); - r3.xyzw = cb0[0].zwzw + float4(-1,-1,-1,-1); - r2.xyzw = min(r3.xyzw, r2.xyzw); - r2.xyzw = (uint4)r2.xyzw; - r0.xy = r2.zw; - r0.x = t0.Load(r0.xyz).x; - r0.x = 0.142857149 * r0.x; - r2.zw = float2(0,0); - r0.y = t0.Load(r2.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r2.xyzw = (int4)r1.zwzw + int4(-1,0,1,0); - r1.xyzw = (int4)r1.xyzw + int4(2,0,3,0); - r1.xyzw = (int4)r1.xyzw; - r1.xyzw = max(float4(0,0,0,0), r1.xyzw); - r1.xyzw = min(r1.xyzw, r3.xyzw); - r1.xyzw = (uint4)r1.zwxy; - r2.xyzw = (int4)r2.xyzw; - r2.xyzw = max(float4(0,0,0,0), r2.xyzw); - r2.xyzw = min(r2.xyzw, r3.xyzw); - r2.xyzw = (uint4)r2.zwxy; - r4.xy = r2.zw; - r4.zw = float2(0,0); - r0.y = t0.Load(r4.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r0.yz = trunc(v0.xy); - r0.yz = max(float2(0,0), r0.yz); - r0.yz = min(r0.yz, r3.xy); - r3.xy = (uint2)r0.yz; - r3.zw = float2(0,0); - r0.y = t0.Load(r3.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r2.zw = float2(0,0); - r0.y = t0.Load(r2.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r2.xy = r1.zw; - r2.zw = float2(0,0); - r0.y = t0.Load(r2.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r1.zw = float2(0,0); - r0.y = t0.Load(r1.xyz).x; - o0.xyz = r0.yyy * float3(0.142857149,0.142857149,0.142857149) + r0.xxx; - o0.w = 1; - return; -} \ No newline at end of file diff --git a/src/games/endfield/shadows/0x61FA72DD.ps_5_0.hlsl b/src/games/endfield/shadows/0x61FA72DD.ps_5_0.hlsl deleted file mode 100644 index d5b205bc52..0000000000 --- a/src/games/endfield/shadows/0x61FA72DD.ps_5_0.hlsl +++ /dev/null @@ -1,392 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 04:33:32 2026 -#include "../shared.h" - -Texture2D t5 : register(t5); - -Texture2D t4 : register(t4); - -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerComparisonState s3_s : register(s3); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb2 : register(b2) -{ - float4 cb2[715]; -} - -cbuffer cb1 : register(b1) -{ - float4 cb1[1]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[184]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float3 o0 : SV_Target0) -{ - const float4 icb[] = { { 1.000000, 0, 0, 0}, - { 0, 1.000000, 0, 0}, - { 0, 0, 1.000000, 0}, - { 0, 0, 0, 1.000000}, - { -0.399656, 0.916665, -0.942016, -0.399062}, - { 0.124512, -0.992218, 0.945586, -0.768907}, - { 0.852354, 0.522965, -0.094184, -0.929389}, - { -0.229312, 0.973353, 0.344959, 0.293878}, - { -0.772406, 0.635129, -0.915886, 0.457714}, - { 0.792753, -0.609544, -0.815442, -0.879125}, - { -0.578050, 0.816002, -0.382775, 0.276768}, - { -0.831130, -0.556079, 0.974844, 0.756484}, - { 0.807795, 0.589464, 0.443233, -0.975116}, - { 0.471415, 0.881911, 0.537430, -0.473734}, - { -0.313974, -0.949432, -0.264969, -0.418930}, - { -0.945007, -0.327051, 0.791975, 0.190902}, - { -0.185037, -0.982732, -0.241888, 0.997065}, - { -0.933756, 0.357911, -0.814100, 0.914376}, - { -0.997614, 0.069036, 0.199841, 0.786414}, - { 0.306128, 0.951990, 0.143832, -0.141008} }; - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = cmp(cb2[35].w < 0.99000001); - if (r0.x != 0) { - r0.xy = (uint2)v0.xy; - r0.zw = (uint2)r0.xy; - r1.xy = cb0[82].zw * r0.zw; - r1.zw = r1.xy * float2(2,2) + float2(-1,-1); - r2.xy = float2(0.5,0.5) + r0.zw; - r2.xy = cb0[82].zw * r2.xy; - r2.x = t0.SampleLevel(s0_s, r2.xy, 0).x; - r3.xyzw = cb0[25].xyzw * -r1.wwww; - r3.xyzw = cb0[24].xyzw * r1.zzzz + r3.xyzw; - r2.xyzw = cb0[26].xyzw * r2.xxxx + r3.xyzw; - r2.xyzw = cb0[27].xyzw + r2.xyzw; - r2.xyz = r2.xyz / r2.www; - r3.xyz = ddy_coarse(r2.zxy); - r4.xyz = ddx_coarse(r2.yzx); - r5.xyz = r4.xyz * r3.xyz; - r3.xyz = r3.zxy * r4.yzx + -r5.xyz; - r1.z = dot(r3.xyz, r3.xyz); - r1.z = max(1.17549435e-38, r1.z); - r1.z = rsqrt(r1.z); - r3.xyz = r3.xyz * r1.zzz; - r1.z = (int)cb2[35].x; - r1.w = cmp((int)r1.z == 2); - r4.xyz = r1.www ? cb2[20].xyz : cb0[44].xyz; - r4.xyz = -r4.xyz + r2.xyz; - r1.w = dot(r4.xyz, r4.xyz); - r1.w = cb2[34].w + -r1.w; - r1.w = saturate(cb2[34].z * r1.w); - r2.w = cmp(0 < r1.w); - if (r2.w != 0) { - r1.z = cmp(0 < (int)r1.z); - if (r1.z != 0) { - r1.xy = t5.SampleLevel(s1_s, r1.xy, 0).xy; - r4.xyz = -cb2[20].xyz + r2.xyz; - r5.xyz = -cb2[21].xyz + r2.xyz; - r6.xyz = -cb2[22].xyz + r2.xyz; - r7.xyz = -cb2[23].xyz + r2.xyz; - r4.x = dot(r4.xyz, r4.xyz); - r4.y = dot(r5.xyz, r5.xyz); - r4.z = dot(r6.xyz, r6.xyz); - r4.w = dot(r7.xyz, r7.xyz); - r5.x = cmp(r4.x < cb2[20].w); - r5.y = cmp(r4.y < cb2[21].w); - r5.z = cmp(r4.z < cb2[22].w); - r5.w = cmp(r4.w < cb2[23].w); - r6.xyzw = r5.xyzw ? float4(1,1,1,1) : 0; - r5.xyz = r5.xyz ? float3(-1,-1,-1) : float3(-0,-0,-0); - r5.xyz = r6.yzw + r5.xyz; - r6.yzw = max(float3(0,0,0), r5.xyz); - r1.z = dot(r6.xyzw, float4(4,3,2,1)); - r1.z = 4 + -r1.z; - r1.z = max(0, r1.z); - r1.z = min(3, r1.z); - r2.w = 1 + r1.z; - r2.w = min(3, r2.w); - r2.w = (uint)r2.w; - r3.w = dot(r4.yzw, icb[r2.w+0].yzw); - r2.w = r3.w / cb2[r2.w+20].w; - r3.w = cmp(r2.w >= 0); - r2.w = cmp(1 >= r2.w); - r2.w = r2.w ? r3.w : 0; - if (r2.w != 0) { - r2.w = (uint)r1.z; - r5.xy = float2(2.08299994,4.8670001) + r0.zw; - r3.w = dot(r5.xy, float2(0.0671105608,0.00583714992)); - r3.w = frac(r3.w); - r3.w = 52.9829178 * r3.w; - r3.w = frac(r3.w); - r4.x = dot(r4.xyzw, icb[r2.w+0].xyzw); - r2.w = r4.x / cb2[r2.w+20].w; - r2.w = sqrt(r2.w); - r2.w = -0.899999976 + r2.w; - r2.w = 12 * r2.w; - r2.w = cmp(r2.w >= r3.w); - r2.w = r2.w ? 1.000000 : 0; - r1.z = r2.w + r1.z; - } - r2.w = dot(r3.xyz, cb1[0].xyz); - r2.w = max(0, r2.w); - r2.w = min(0.899999976, r2.w); - r2.w = 1 + -r2.w; - r3.w = (uint)r1.z; - r4.x = (uint)r3.w << 2; - r4.yz = cb2[r3.w+24].xy * r2.ww; - r1.x = cmp(r1.x >= 0.999989986); - r1.x = r1.x ? 1.000000 : 0; - r1.x = r1.x * r1.y; - r1.x = 4 * r1.x; - r1.x = max(r4.y, r1.x); - r5.xyz = -cb1[0].xyz * r1.xxx + r2.xyz; - r4.yzw = r3.xyz * r4.zzz + r5.xyz; - r5.xyz = cb2[r4.x+1].xyz * r4.zzz; - r5.xyz = cb2[r4.x+0].xyz * r4.yyy + r5.xyz; - r4.yzw = cb2[r4.x+2].xyz * r4.www + r5.xyz; - r4.xyz = cb2[r4.x+3].xyz + r4.yzw; - r5.xyz = cmp(float3(0,0,0) >= r4.xyz); - r6.xyz = cmp(r4.xyz >= float3(1,1,1)); - r5.xyz = (int3)r5.xyz | (int3)r6.xyz; - r1.x = (int)r5.y | (int)r5.x; - r1.x = (int)r5.z | (int)r1.x; - r1.y = (int)r4.z & 0x7fffffff; - r1.y = cmp(0x7f800000 < (uint)r1.y); - r5.z = (int)r1.y | (int)r1.x; - r0.zw = float2(0.25,0.25) * r0.zw; - r6.xy = (int2)r0.zw; - r6.zw = float2(0,0); - r5.x = t3.Load(r6.xyz).x; - r0.z = cmp(r5.x < 0.00100000005); - r0.w = cmp(0.99000001 < r5.x); - r0.z = (int)r0.w | (int)r0.z; - if (r0.z == 0) { - r0.z = (int)r1.z; - r1.xy = r4.xy * cb2[r0.z+28].zw + cb2[r0.z+28].xy; - bitmask.x = ((~(-1 << 2)) << 2) & 0xffffffff; r0.x = (((uint)r0.x << 2) & bitmask.x) | ((uint)0 & ~bitmask.x); - bitmask.x = ((~(-1 << 2)) << 0) & 0xffffffff; r0.x = (((uint)r0.y << 0) & bitmask.x) | ((uint)r0.x & ~bitmask.x); - r0.y = dot(cb2[33].xyzw, icb[r0.z+0].xyzw); - r0.zw = icb[r0.x+4].xy * float2(1,-1); - r4.xy = float2(0,0); - r1.z = 0; - while (true) { - r2.w = cmp((uint)r1.z >= 16); - if (r2.w != 0) break; - r6.x = dot(icb[r1.z+4].zw, r0.zw); - r6.y = dot(icb[r1.z+4].wz, icb[r0.x+4].xy); - r6.xy = r6.xy * r0.yy + r1.xy; - r6.xyzw = t1.Gather(s1_s, r6.xy).xyzw; - r6.xyzw = r6.xyzw + -r4.zzzz; - r7.xyzw = cmp(r6.xyzw >= float4(0,0,0,0)); - r7.xyzw = r7.xyzw ? float4(1,1,1,1) : 0; - r2.w = dot(r6.xyzw, r7.xyzw); - r6.x = r4.x + r2.w; - r2.w = dot(r7.xyzw, float4(1,1,1,1)); - r6.y = r4.y + r2.w; - r2.w = (int)r1.z + 1; - r4.xy = r6.xy; - r1.z = r2.w; - continue; - } - r0.x = r4.y * 0.03125 + -1; - r0.y = cmp(0 < r0.x); - r0.z = cmp(r0.x < 0); - r0.y = (int)-r0.y + (int)r0.z; - r0.y = (int)r0.y; - r0.x = -r0.y * r0.x + 1; - r0.z = r0.x * r0.x; - r0.w = r0.z * r0.x; - r1.x = 1 / r4.y; - r1.x = r4.x * r1.x; - r1.y = 1 / r4.z; - r1.x = saturate(r1.x * r1.y); - r0.x = -r0.z * r0.x + r0.x; - r0.x = r1.x * r0.x + r0.w; - r0.x = 1 + -r0.x; - r0.x = r0.x * r0.y; - r0.x = -r0.x * 0.5 + 0.5; - r5.x = r5.z ? 1 : r0.x; - } - } else { - r5.xz = float2(1,0); - } - } else { - r5.xz = float2(1,0); - } - r0.x = cmp(r1.w < 1); - if (r0.x != 0) { - r0.x = dot(r3.xyz, cb1[0].xyz); - r0.x = max(0, r0.x); - r0.x = min(0.899999976, r0.x); - r0.x = 1 + -r0.x; - r0.xy = cb2[584].xy * r0.xx; - r0.xzw = -cb1[0].xyz * r0.xxx + r2.xyz; - r0.xyz = r3.xyz * r0.yyy + r0.xzw; - r1.xy = cb2[581].xy * r0.yy; - r1.xy = cb2[580].xy * r0.xx + r1.xy; - r1.xy = cb2[582].xy * r0.zz + r1.xy; - r1.xy = cb2[583].xy + r1.xy; - r3.xy = cmp(float2(0,0) < r1.xy); - r1.z = r3.y ? r3.x : 0; - r3.xy = cmp(r1.xy < float2(1,1)); - r2.w = r3.y ? r3.x : 0; - r1.z = (int)r1.z & (int)r2.w; - if (r1.z != 0) { - r1.y = cb2[585].z * r1.y; - r1.y = floor(r1.y); - r1.x = r1.y + r1.x; - r1.x = cb2[585].y * r1.x; - r1.x = (uint)r1.x; - r1.x = min(127, (uint)r1.x); - r1.y = 0x0000ffff & asint(cb2[r1.x+587].x); - r3.x = f16tof32(r1.y); - r1.y = cmp(r3.x >= 0); - if (r1.y != 0) { - r4.x = cb2[576].x; - r4.y = cb2[577].x; - r4.z = cb2[578].x; - r4.w = cb2[r1.x+587].y; - r0.w = 1; - r4.x = dot(r4.xyzw, r0.xyzw); - r6.x = cb2[576].y; - r6.y = cb2[577].y; - r6.z = cb2[578].y; - r6.w = cb2[r1.x+587].z; - r4.y = dot(r6.xyzw, r0.xyzw); - r6.x = cb2[576].z; - r6.y = cb2[577].z; - r6.z = cb2[578].z; - r6.w = cb2[r1.x+587].w; - r0.x = dot(r6.xyzw, r0.xyzw); - r0.yz = cmp(float2(0,0) < r4.xy); - r0.w = cmp(0 < r0.x); - r0.y = r0.z ? r0.y : 0; - r0.y = r0.w ? r0.y : 0; - r0.zw = cmp(r4.xy < float2(1,1)); - r1.y = cmp(r0.x < 1); - r0.z = r0.w ? r0.z : 0; - r0.z = r1.y ? r0.z : 0; - r0.y = r0.z ? r0.y : 0; - if (r0.y != 0) { - r0.y = asuint(cb2[r1.x+587].x) >> 16; - r3.y = f16tof32(r0.y); - r0.yz = r4.xy * cb2[584].zw + r3.xy; - r1.xy = r0.yz * cb2[586].zw + float2(0.5,0.5); - r1.xy = floor(r1.xy); - r0.yz = r0.yz * cb2[586].zw + -r1.xy; - r3.xyzw = float4(0.5,1,0.5,1) + r0.yyzz; - r4.xw = r3.xz * r3.xz; - r3.xz = min(float2(0,0), r0.yz); - r6.xy = max(float2(0,0), r0.yz); - r6.zw = r4.xw * float2(0.5,0.5) + -r0.yz; - r0.yz = float2(1,1) + -r0.yz; - r0.yz = -r3.xz * r3.xz + r0.yz; - r3.xy = -r6.xy * r6.xy + r3.yw; - r7.x = r6.z; - r7.y = r0.y; - r7.z = r3.x; - r7.w = r4.x; - r7.xyzw = float4(0.444440007,0.444440007,0.444440007,0.222220004) * r7.xyzw; - r4.x = r6.w; - r4.y = r0.z; - r4.z = r3.y; - r3.xyzw = float4(0.444440007,0.444440007,0.444440007,0.222220004) * r4.xyzw; - r4.xyzw = r7.xzxz + r7.ywyw; - r6.xyzw = r3.xxzz + r3.yyww; - r0.yz = r7.yw / r4.zw; - r0.yz = float2(-1.5,0.5) + r0.yz; - r7.xy = cb2[586].xx * r0.yz; - r0.yz = r3.yw / r6.yw; - r0.yz = float2(-1.5,0.5) + r0.yz; - r7.zw = cb2[586].yy * r0.yz; - r3.xyzw = r6.xyzw * r4.xyzw; - r4.xyzw = r1.xyxy * cb2[586].xyxy + r7.xzyz; - r0.y = t4.SampleCmpLevelZero(s3_s, r4.xy, r0.x).x; - r0.z = t4.SampleCmpLevelZero(s3_s, r4.zw, r0.x).x; - r0.z = r3.y * r0.z; - r0.y = r3.x * r0.y + r0.z; - r4.xyzw = r1.xyxy * cb2[586].xyxy + r7.xwyw; - r0.z = t4.SampleCmpLevelZero(s3_s, r4.xy, r0.x).x; - r0.y = r3.z * r0.z + r0.y; - r0.x = t4.SampleCmpLevelZero(s3_s, r4.zw, r0.x).x; - r5.y = r3.w * r0.x + r0.y; - } else { - r5.y = 1; - } - } else { - r5.y = 1; - } - } else { - r5.y = 1; - } - r5.x = r5.z ? r5.y : r5.x; - } else { - r5.y = 1; - } - r0.x = r5.x + -r5.y; - r0.x = r1.w * r0.x + r5.y; - r0.y = cmp(0.00100000005 < r0.x); - if (r0.y != 0) { - r0.yzw = -cb0[173].xyz + r2.xyz; - r1.xy = cb0[176].xz * r0.zz + r0.yw; - r1.zw = cb0[174].zz * r1.xy; - r2.xy = cb0[183].ww * cb0[175].xy; - r1.xy = r1.xy * cb0[174].zz + r2.xy; - r0.z = t2.SampleLevel(s2_s, r1.xy, 0).x; - r1.xy = r1.zw * cb0[175].ww + r2.xy; - r1.x = t2.SampleLevel(s2_s, r1.xy, 0).x; - r0.y = dot(r0.yw, r0.yw); - r0.y = sqrt(r0.y); - r0.w = cb0[174].y + -cb0[174].x; - r0.y = -cb0[174].x + r0.y; - r0.w = 1 / r0.w; - r0.y = saturate(r0.y * r0.w); - r0.w = r0.y * -2 + 3; - r0.y = r0.y * r0.y; - r0.y = r0.w * r0.y; - r0.w = r1.x + -r0.z; - r0.y = r0.y * r0.w + r0.z; - r0.y = -1 + r0.y; - r0.y = cb0[175].z * r0.y + 1; - - if (AO_INTENSITY >= 1.f) { - // Boost AO intensity (hardcoded 4x) - r0.y = 1.0 + (r0.y - 1.0) * 4.0; - } - - r0.x = r0.x * r0.y; - } - r0.y = cb2[35].z + -r0.x; - r0.x = cb2[35].w * r0.y + r0.x; - } else { - r0.x = cb2[35].z; - } - r0.x = min(1, r0.x); - r0.x = -1 + r0.x; - o0.x = cb2[34].x * r0.x + 1; - o0.yz = float2(1,0); - return; -} \ No newline at end of file diff --git a/src/games/endfield/shadows/0xA4516CE4.ps_5_0.hlsl b/src/games/endfield/shadows/0xA4516CE4.ps_5_0.hlsl deleted file mode 100644 index ec17592999..0000000000 --- a/src/games/endfield/shadows/0xA4516CE4.ps_5_0.hlsl +++ /dev/null @@ -1,321 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 04:33:32 2026 -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb2 : register(b2) -{ - float4 cb2[36]; -} - -cbuffer cb1 : register(b1) -{ - float4 cb1[1]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[85]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float o0 : SV_Target0) -{ - const float4 icb[] = { { 1.000000, 0, 0, 0}, - { 0, 1.000000, 0, 0}, - { 0, 0, 1.000000, 0}, - { 0, 0, 0, 1.000000}, - { -1, -1, -0.942016, -0.399062}, - { -1, 1, 0.945586, -0.768907}, - { 1, -1, -0.094184, -0.929389}, - { 1, 1, 0.344959, 0.293878}, - { 0, 0, -0.915886, 0.457714}, - { 0, 0, -0.815442, -0.879125}, - { 0, 0, -0.382775, 0.276768}, - { 0, 0, 0.974844, 0.756484}, - { 0, 0, 0.443233, -0.975116}, - { 0, 0, 0.537430, -0.473734}, - { 0, 0, -0.264969, -0.418930}, - { 0, 0, 0.791975, 0.190902}, - { 0, 0, -0.241888, 0.997065}, - { 0, 0, -0.814100, 0.914376}, - { 0, 0, 0.199841, 0.786414}, - { 0, 0, 0.143832, -0.141008} }; - float4 r0,r1,r2,r3,r4,r5,r6; - uint4 bitmask, uiDest; - float4 fDest; - - float4 x0[16]; - r0.xy = (uint2)v0.xy; - r0.zw = (uint2)r0.xy << int2(2,2); - r0.zw = (uint2)r0.zw; - r0.zw = cb0[82].zw * r0.zw; - r1.xyzw = t0.Gather(s0_s, r0.zw).xyzw; - r1.xyzw = cb0[84].zzzz * r1.wzxy + cb0[84].wwww; - r1.xyzw = float4(1,1,1,1) / r1.xyzw; - x0[0].x = r1.x; - x0[4].x = r1.y; - x0[1].x = r1.z; - x0[5].x = r1.w; - bitmask.x = ((~(-1 << 30)) << 2) & 0xffffffff; r1.x = (((uint)r0.x << 2) & bitmask.x) | ((uint)0 & ~bitmask.x); - bitmask.y = ((~(-1 << 30)) << 2) & 0xffffffff; r1.y = (((uint)r0.y << 2) & bitmask.y) | ((uint)2 & ~bitmask.y); - bitmask.z = ((~(-1 << 30)) << 2) & 0xffffffff; r1.z = (((uint)r0.x << 2) & bitmask.z) | ((uint)2 & ~bitmask.z); - bitmask.w = ((~(-1 << 30)) << 2) & 0xffffffff; r1.w = (((uint)r0.y << 2) & bitmask.w) | ((uint)0 & ~bitmask.w); - r1.xyzw = (uint4)r1.xyzw; - r1.xyzw = cb0[82].zwzw * r1.xyzw; - r2.xyzw = t0.Gather(s0_s, r1.xy).xyzw; - r2.xyzw = cb0[84].zzzz * r2.wzxy + cb0[84].wwww; - r2.xyzw = float4(1,1,1,1) / r2.xyzw; - x0[2].x = r2.x; - x0[6].x = r2.y; - x0[3].x = r2.z; - x0[7].x = r2.w; - r1.xyzw = t0.Gather(s0_s, r1.zw).xyzw; - r1.xyzw = cb0[84].zzzz * r1.wzxy + cb0[84].wwww; - r1.xyzw = float4(1,1,1,1) / r1.xyzw; - x0[8].x = r1.x; - x0[12].x = r1.y; - x0[9].x = r1.z; - x0[13].x = r1.w; - bitmask.x = ((~(-1 << 30)) << 2) & 0xffffffff; r0.x = (((uint)r0.x << 2) & bitmask.x) | ((uint)2 & ~bitmask.x); - bitmask.y = ((~(-1 << 30)) << 2) & 0xffffffff; r0.y = (((uint)r0.y << 2) & bitmask.y) | ((uint)2 & ~bitmask.y); - r0.xy = (uint2)r0.xy; - r0.zw = cb0[82].zw * r0.xy; - r1.xyzw = t0.Gather(s0_s, r0.zw).xyzw; - r1.xyzw = cb0[84].zzzz * r1.wzxy + cb0[84].wwww; - r1.xyzw = float4(1,1,1,1) / r1.xyzw; - x0[10].x = r1.x; - x0[14].x = r1.y; - x0[11].x = r1.z; - x0[15].x = r1.w; - r1.z = -1; - r2.xyzw = float4(0,0,0,0); - r1.xyw = float3(0,0,1.40129846e-45); - while (true) { - r3.x = cmp((int)r1.w < 3); - if (r3.x != 0) { - r3.x = (uint)r1.w << 2; - r3.yz = float2(0,0); - r4.xy = r1.yx; - r3.w = r2.x; - r4.z = r2.y; - r4.w = 1; - while (true) { - r5.x = cmp((int)r4.w < 3); - if (r5.x != 0) { - r5.x = (int)r3.x + (int)r4.w; - r5.x = x0[r5.x+0].x; - r6.xy = r3.yz; - r6.z = 0; - while (true) { - r5.y = cmp((int)r6.z < 4); - if (r5.y != 0) { - r5.y = (int)r4.w + (int)icb[r6.z+4].y; - r5.z = cmp((uint)r6.z < 2); - r5.z = r5.z ? -1 : 1; - r5.z = (int)r1.w + (int)r5.z; - r5.z = (uint)r5.z << 2; - r5.y = (int)r5.y + (int)r5.z; - r5.y = x0[r5.y+0].x; - r5.y = r5.x + -r5.y; - r5.y = cmp(5 < abs(r5.y)); - if (r5.y != 0) { - r6.xy = float2(-1,0.5); - break; - } - r6.z = (int)r6.z + 1; - continue; - } else { - r6.xy = r4.yx; - break; - } - } - r4.xy = r6.yx; - if (r4.y != 0) { - r3.w = -1; - r4.z = r4.x; - break; - } - r4.w = (int)r4.w + 1; - r3.yz = r4.yx; - continue; - } else { - r3.w = r4.y; - r4.z = r4.x; - break; - } - } - r1.x = r3.w; - r1.y = r4.z; - if (r1.x != 0) { - r2.zw = r1.yz; - break; - } - r1.w = (int)r1.w + 1; - r2.xy = r1.xy; - continue; - } else { - r2.zw = r1.yx; - break; - } - } - if (r2.w == 0) { - r1.x = (int)cb2[35].x; - r1.x = cmp(0 < (int)r1.x); - if (r1.x != 0) { - r1.xy = r0.zw * float2(2,2) + float2(-1,-1); - r1.zw = float2(0.5,0.5) + r0.xy; - r1.zw = cb0[82].zw * r1.zw; - r1.z = t0.SampleLevel(s0_s, r1.zw, 0).x; - r3.xyzw = cb0[25].xyzw * -r1.yyyy; - r3.xyzw = cb0[24].xyzw * r1.xxxx + r3.xyzw; - r1.xyzw = cb0[26].xyzw * r1.zzzz + r3.xyzw; - r1.xyzw = cb0[27].xyzw + r1.xyzw; - r1.xyz = r1.xyz / r1.www; - r0.zw = t2.SampleLevel(s1_s, r0.zw, 0).xy; - r2.xyw = ddy_coarse(r1.zxy); - r3.xyz = ddx_coarse(r1.yzx); - r4.xyz = r3.xyz * r2.xyw; - r2.xyw = r2.wxy * r3.yzx + -r4.xyz; - r1.w = dot(r2.xyw, r2.xyw); - r1.w = max(1.17549435e-38, r1.w); - r1.w = rsqrt(r1.w); - r2.xyw = r2.xyw * r1.www; - r3.xyz = -cb2[20].xyz + r1.xyz; - r4.xyz = -cb2[21].xyz + r1.xyz; - r5.xyz = -cb2[22].xyz + r1.xyz; - r6.xyz = -cb2[23].xyz + r1.xyz; - r3.x = dot(r3.xyz, r3.xyz); - r3.y = dot(r4.xyz, r4.xyz); - r3.z = dot(r5.xyz, r5.xyz); - r3.w = dot(r6.xyz, r6.xyz); - r4.x = cmp(r3.x < cb2[20].w); - r4.y = cmp(r3.y < cb2[21].w); - r4.z = cmp(r3.z < cb2[22].w); - r4.w = cmp(r3.w < cb2[23].w); - r5.xyzw = r4.xyzw ? float4(1,1,1,1) : 0; - r4.xyz = r4.xyz ? float3(-1,-1,-1) : float3(-0,-0,-0); - r4.xyz = r5.yzw + r4.xyz; - r5.yzw = max(float3(0,0,0), r4.xyz); - r1.w = dot(r5.xyzw, float4(4,3,2,1)); - r1.w = 4 + -r1.w; - r1.w = max(0, r1.w); - r1.w = min(3, r1.w); - r4.x = 1 + r1.w; - r4.x = min(3, r4.x); - r4.x = (uint)r4.x; - r4.y = dot(r3.yzw, icb[r4.x+0].yzw); - r4.x = r4.y / cb2[r4.x+20].w; - r4.y = cmp(r4.x >= 0); - r4.x = cmp(1 >= r4.x); - r4.x = r4.x ? r4.y : 0; - if (r4.x != 0) { - r4.x = (uint)r1.w; - r0.xy = float2(2.08299994,4.8670001) + r0.xy; - r0.x = dot(r0.xy, float2(0.0671105608,0.00583714992)); - r0.x = frac(r0.x); - r0.x = 52.9829178 * r0.x; - r0.x = frac(r0.x); - r0.y = dot(r3.xyzw, icb[r4.x+0].xyzw); - r0.y = r0.y / cb2[r4.x+20].w; - r0.y = sqrt(r0.y); - r0.y = -0.899999976 + r0.y; - r0.y = 12 * r0.y; - r0.x = cmp(r0.y >= r0.x); - r0.x = r0.x ? 1.000000 : 0; - r1.w = r1.w + r0.x; - } - r0.x = dot(r2.xyw, cb1[0].xyz); - r0.x = max(0, r0.x); - r0.x = min(0.899999976, r0.x); - r0.x = 1 + -r0.x; - r0.y = (uint)r1.w; - r3.x = (uint)r0.y << 2; - r0.xy = cb2[r0.y+24].xy * r0.xx; - r0.z = cmp(r0.z >= 0.999989986); - r0.z = r0.z ? 1.000000 : 0; - r0.z = r0.z * r0.w; - r0.z = 4 * r0.z; - r0.x = max(r0.x, r0.z); - r0.xzw = -cb1[0].xyz * r0.xxx + r1.xyz; - r0.xyz = r2.xyw * r0.yyy + r0.xzw; - r1.xyz = cb2[r3.x+1].xyz * r0.yyy; - r0.xyw = cb2[r3.x+0].xyz * r0.xxx + r1.xyz; - r0.xyz = cb2[r3.x+2].xyz * r0.zzz + r0.xyw; - r0.xyz = cb2[r3.x+3].xyz + r0.xyz; - r1.xyz = cmp(float3(0,0,0) >= r0.xyz); - r2.xyw = cmp(r0.xyz >= float3(1,1,1)); - r1.xyz = (int3)r1.xyz | (int3)r2.xyw; - r0.w = (int)r1.y | (int)r1.x; - r0.w = (int)r1.z | (int)r0.w; - r0.w = cmp((int)r0.w == 0); - r1.x = (int)r0.z & 0x7fffffff; - r1.x = cmp(0x7f800000 < (uint)r1.x); - r0.w = (int)r0.w | (int)r1.x; - if (r0.w != 0) { - r0.w = (int)r1.w; - r0.xy = r0.xy * cb2[r0.w+28].zw + cb2[r0.w+28].xy; - r0.w = dot(cb2[33].xyzw, icb[r0.w+0].xyzw); - r1.xyz = float3(0,0,0); - while (true) { - r1.w = cmp((uint)r1.z >= 16); - if (r1.w != 0) break; - r2.x = dot(icb[r1.z+4].zw, float2(-0.313973814,0.949431717)); - r2.y = dot(icb[r1.z+4].zw, float2(-0.949431717,-0.313973814)); - r2.xy = r2.xy * r0.ww + r0.xy; - r3.xyzw = t1.Gather(s1_s, r2.xy).xyzw; - r3.xyzw = r3.xyzw + -r0.zzzz; - r4.xyzw = cmp(r3.xyzw >= float4(0,0,0,0)); - r4.xyzw = r4.xyzw ? float4(1,1,1,1) : 0; - r1.w = dot(r4.xyzw, float4(1,1,1,1)); - r2.x = r1.x + r1.w; - r1.w = dot(r3.xyzw, r4.xyzw); - r2.y = r1.y + r1.w; - r1.w = (int)r1.z + 1; - r1.xy = r2.xy; - r1.xyz = r1.xyw; - continue; - } - r0.x = r1.x * 0.03125 + -1; - r0.y = cmp(0 < r0.x); - r0.w = cmp(r0.x < 0); - r0.y = (int)-r0.y + (int)r0.w; - r0.y = (int)r0.y; - r0.x = -r0.y * r0.x + 1; - r0.w = r0.x * r0.x; - r1.z = r0.w * r0.x; - r1.x = 1 / r1.x; - r1.x = r1.y * r1.x; - r0.z = 1 / r0.z; - r0.z = saturate(r1.x * r0.z); - r0.x = -r0.w * r0.x + r0.x; - r0.x = r0.z * r0.x + r1.z; - r0.x = 1 + -r0.x; - r0.x = r0.x * r0.y; - o0.x = -r0.x * 0.5 + 0.5; - } else { - o0.x = 1; - } - } else { - o0.x = cb2[35].z; - } - } else { - o0.x = r2.z; - } - return; -} \ No newline at end of file diff --git a/src/games/endfield/shadows/0xB295C5C4.cso b/src/games/endfield/shadows/0xB295C5C4.cso new file mode 100644 index 0000000000..8c8a820278 Binary files /dev/null and b/src/games/endfield/shadows/0xB295C5C4.cso differ diff --git a/src/games/endfield/shadows/0xB295C5C4.ps_5_0.hlsl b/src/games/endfield/shadows/0xB295C5C4.ps_5_0.hlsl deleted file mode 100644 index 5d8ccc190d..0000000000 --- a/src/games/endfield/shadows/0xB295C5C4.ps_5_0.hlsl +++ /dev/null @@ -1,72 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 04:33:32 2026 -Texture2D t0 : register(t0); - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4; - uint4 bitmask, uiDest; - float4 fDest; - - r0.zw = float2(0,0); - r1.xyzw = (int4)v0.xyxy; - r2.xyzw = (int4)r1.zwzw + int4(0,-3,0,-2); - r2.xyzw = (int4)r2.xyzw; - r2.xyzw = max(float4(0,0,0,0), r2.xyzw); - r3.xyzw = cb0[0].zwzw + float4(-1,-1,-1,-1); - r2.xyzw = min(r3.xyzw, r2.xyzw); - r2.xyzw = (uint4)r2.xyzw; - r0.xy = r2.zw; - r0.x = t0.Load(r0.xyz).x; - r0.x = 0.142857149 * r0.x; - r2.zw = float2(0,0); - r0.y = t0.Load(r2.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r2.xyzw = (int4)r1.zwzw + int4(0,-1,0,1); - r1.xyzw = (int4)r1.xyzw + int4(0,2,0,3); - r1.xyzw = (int4)r1.xyzw; - r1.xyzw = max(float4(0,0,0,0), r1.xyzw); - r1.xyzw = min(r1.xyzw, r3.xyzw); - r1.xyzw = (uint4)r1.zwxy; - r2.xyzw = (int4)r2.xyzw; - r2.xyzw = max(float4(0,0,0,0), r2.xyzw); - r2.xyzw = min(r2.xyzw, r3.xyzw); - r2.xyzw = (uint4)r2.zwxy; - r4.xy = r2.zw; - r4.zw = float2(0,0); - r0.y = t0.Load(r4.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r0.yz = trunc(v0.xy); - r0.yz = max(float2(0,0), r0.yz); - r0.yz = min(r0.yz, r3.xy); - r3.xy = (uint2)r0.yz; - r3.zw = float2(0,0); - r0.y = t0.Load(r3.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r2.zw = float2(0,0); - r0.y = t0.Load(r2.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r2.xy = r1.zw; - r2.zw = float2(0,0); - r0.y = t0.Load(r2.xyz).x; - r0.x = r0.y * 0.142857149 + r0.x; - r1.zw = float2(0,0); - r0.y = t0.Load(r1.xyz).x; - o0.xyz = r0.yyy * float3(0.142857149,0.142857149,0.142857149) + r0.xxx; - o0.w = 1; - return; -} \ No newline at end of file diff --git a/src/games/endfield/shadows/0xB4E7E6D9.cso b/src/games/endfield/shadows/0xB4E7E6D9.cso new file mode 100644 index 0000000000..2414d63e87 Binary files /dev/null and b/src/games/endfield/shadows/0xB4E7E6D9.cso differ diff --git a/src/games/endfield/shadows/0xD91A8DD3.ps_5_0.hlsl b/src/games/endfield/shadows/0xD91A8DD3.ps_5_0.hlsl deleted file mode 100644 index e5057a3c57..0000000000 --- a/src/games/endfield/shadows/0xD91A8DD3.ps_5_0.hlsl +++ /dev/null @@ -1,257 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 03:28:04 2026 -// ============================================================================ -// CAPSULE/TUBE LIGHT - SPHERICAL HARMONICS PROBE SHADER -// ============================================================================ -// This shader computes spherical harmonics (SH) lighting contributions from -// capsule/tube shaped light sources. It ray-marches along the capsule and -// accumulates SH coefficients for indirect lighting. -// -// Textures: -// t0: Depth buffer -// t1: Light attenuation/falloff lookup texture (256x1 or similar) -// t2: GBuffer normals (octahedral encoded) -// -// Constant Buffers: -// cb0[24-27]: Inverse projection matrix for depth reconstruction -// cb1[1]: SH coefficient scaling -// cb1[4]: Screen parameters (xy = dimensions, zw = 1/dimensions) -// cb2[n+1]: Capsule endpoint 1 (xyz) + radius (w) -// cb2[n+2]: Capsule endpoint 2 (xyz) + influence radius (w) -// cb2[n+3]: Capsule direction (xyz) + intensity (w) -// ============================================================================ - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb2 : register(b2) -{ - float4 cb2[385]; -} - -cbuffer cb1 : register(b1) -{ - float4 cb1[5]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[28]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - nointerpolation uint v3 : TEXCOORD2, // Light/probe instance index - out float4 o0 : SV_Target0) // Output: Spherical Harmonics coefficients (L0 + L1) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9; - uint4 bitmask, uiDest; - float4 fDest; - - // ========================================================================== - // SCREEN TO UV CONVERSION - // ========================================================================== - r0.xy = cb1[4].zw * v0.xy; // Convert screen position to UV (0-1) - r0.zw = r0.xy * float2(2,2) + float2(-1,-1); // Convert to NDC (-1 to 1) - - // ========================================================================== - // DEPTH BUFFER SAMPLING & WORLD POSITION RECONSTRUCTION - // ========================================================================== - r1.x = t0.SampleLevel(s0_s, r0.xy, 0).x; // Sample depth buffer - - // Reconstruct view/world position from depth using inverse projection - r2.xyzw = cb0[25].xyzw * -r0.wwww; // Inverse projection row 2 * -NDC.y - r2.xyzw = cb0[24].xyzw * r0.zzzz + r2.xyzw; // + Inverse projection row 1 * NDC.x - r1.xyzw = cb0[26].xyzw * r1.xxxx + r2.xyzw; // + Inverse projection row 3 * depth - r1.xyzw = cb0[27].xyzw + r1.xyzw; // + Inverse projection row 4 (translation) - r1.xyz = r1.xyz / r1.www; // Perspective divide -> world position - - // ========================================================================== - // CAPSULE LIGHT SETUP - // ========================================================================== - r0.z = cb1[4].y * 0.5; // Half screen height - r0.w = (int)v3.x * 3; // Light data offset (3 float4s per light) - r0.z = cb2[r0.w+2].w * r0.z; // Influence radius scaled by screen - - // Calculate capsule center (midpoint between endpoints) - r2.xyz = cb2[r0.w+2].xyz + cb2[r0.w+1].xyz; // endpoint1 + endpoint2 - r2.xyz = r2.xyz * float3(0.5,0.5,0.5) + -r1.xyz; // Center - worldPos - - // Distance from pixel to capsule center - r1.w = dot(r2.xyz, r2.xyz); - r1.w = sqrt(r1.w); - - // ========================================================================== - // EARLY OUT: CHECK IF PIXEL IS WITHIN INFLUENCE RADIUS - // ========================================================================== - r2.x = cmp(r0.z >= r1.w); // Is distance < influence radius? - if (r2.x != 0) { - // ======================================================================== - // GBUFFER NORMAL DECODING (Octahedral mapping) - // ======================================================================== - r0.xy = t2.SampleLevel(s1_s, r0.xy, 0).xy; // Sample encoded normal - r0.xy = r0.xy * float2(2,2) + float2(-1,-1); // Decode from 0-1 to -1 to 1 - - // Octahedral normal decoding - r2.x = dot(float2(1,1), abs(r0.xy)); // Sum of absolute values - r2.y = 1 + -r2.x; // Z component estimation - r2.w = cmp(r2.y < 0); // Check if on bottom hemisphere - r3.xy = cmp(r0.xy >= float2(0,0)); // Sign of XY - r3.zw = float2(1,1) + -abs(r0.yx); // Reflected coordinates - r3.xy = r3.xy ? float2(1,1) : float2(-1,-1); - r3.xy = r3.zw * r3.xy; // Apply sign - r2.xz = r2.ww ? r3.xy : r0.xy; // Choose based on hemisphere - - // Normalize the decoded normal - r0.x = dot(r2.xyz, r2.xyz); - r0.x = rsqrt(r0.x); - r2.xyz = r2.xyz * r0.xxx; // Final world normal - - // ======================================================================== - // RAY MARCH SETUP ALONG CAPSULE - // ======================================================================== - r0.x = cb1[4].x * 1.20000005; // Step size base - r0.y = cb2[r0.w+1].w * r0.x; // Capsule radius * step size - r2.w = cb2[r0.w+2].w / r0.y; // Number of steps - r2.w = ceil(r2.w); - r2.w = (uint)r2.w; - r2.w = (int)r2.w + -1; // Loop iteration count - - // Calculate step offset along capsule axis - r0.x = r0.x * cb2[r0.w+1].w + -cb2[r0.w+1].w; - r3.xyz = cb2[r0.w+3].xyz * r0.xxx + cb2[r0.w+1].xyz; // Start position - r0.x = cb2[r0.w+1].w + 9.99999975e-06; // Radius + epsilon - - // ======================================================================== - // RAY MARCH LOOP - ACCUMULATE SPHERICAL HARMONICS - // ======================================================================== - r4.y = 0.5; // V coordinate for attenuation LUT - r5.xyzw = float4(0,0,0,0); // Accumulated SH coefficients - r6.xyz = r3.xyz; // Current sample position - r3.w = 0; // Loop counter - - while (true) { - r4.z = cmp((uint)r3.w >= (uint)r2.w); - if (r4.z != 0) break; - - // -------------------------------------------------------------------- - // Calculate vector from world position to current sample point - // -------------------------------------------------------------------- - r7.xyz = r6.xyz + -r1.xyz; // Sample pos - world pos - r4.z = dot(r7.xyz, r7.xyz); - r4.z = sqrt(r4.z); // Distance to sample - r4.w = dot(r7.xyz, r2.xyz); // Project onto normal direction - - // Check capsule bounds - r6.w = cb2[r0.w+1].w + r4.w; // Distance + radius - r7.w = cmp(0 >= r4.w); // Behind surface? - r8.x = cmp(0 >= r6.w); // Outside capsule? - r8.y = cmp(r4.z < r0.x); // Within radius? - r8.y = r7.w ? r8.y : 0; - r8.x = (int)r8.y | (int)r8.x; - - if (r8.x == 0) { - // ------------------------------------------------------------------ - // CAPSULE INTERSECTION & ATTENUATION CALCULATION - // ------------------------------------------------------------------ - r8.x = cmp(cb2[r0.w+1].w >= abs(r4.w)); // Within capsule length? - if (r8.x != 0) { - // Calculate closest point on capsule surface - r8.xyz = -r2.xyz * r4.www + r6.xyz; // Clamp to capsule start - r9.xyz = r2.xyz * cb2[r0.w+1].www + r6.xyz; // Clamp to capsule end - r9.xyz = r9.xyz + r8.xyz; - r7.xyz = r9.xyz * float3(0.5,0.5,0.5) + -r1.xyz; // Midpoint - worldPos - - // Soft falloff calculation - if (r7.w != 0) { - r4.w = abs(r4.w) * abs(r4.w); - r4.w = cb2[r0.w+1].w * cb2[r0.w+1].w + -r4.w; - r4.w = sqrt(r4.w); // Perpendicular distance - r8.xyz = -r8.xyz + r1.xyz; - r7.w = dot(r8.xyz, r8.xyz); - r7.w = sqrt(r7.w); - r7.w = r7.w + -r4.w; - r4.w = r7.w / r4.w; - r4.w = min(1, r4.w); // Clamp attenuation - } else { - r4.w = 1; - } - r4.w = r4.w * r6.w; - r4.w = 0.5 * r4.w; // Half contribution - r6.w = dot(r7.xyz, r7.xyz); - r4.z = sqrt(r6.w); // Final distance - } else { - r4.w = cb2[r0.w+1].w; // Use full radius - } - - // ------------------------------------------------------------------ - // DIRECTION TO LIGHT SAMPLE (for SH projection) - // ------------------------------------------------------------------ - r6.w = dot(r7.xyz, r7.xyz); - r6.w = rsqrt(r6.w); - r7.xyz = r7.yzx * r6.www; // Normalized direction (YZX swizzle for SH) - - // Calculate attenuation based on distance - r4.w = r4.w * r4.w; - r4.w = r4.z * r4.z + -r4.w; - r4.w = sqrt(r4.w); - r4.z = r4.w / r4.z; - r4.z = r4.z * 255 + 0.5; // Scale to LUT range - r4.x = 0.00390625 * r4.z; // U coordinate (0-1) - - // ------------------------------------------------------------------ - // SAMPLE ATTENUATION LUT & COMPUTE SPHERICAL HARMONICS - // ------------------------------------------------------------------ - r4.xz = t1.SampleLevel(s1_s, r4.xy, 0).zw; // Sample attenuation LUT - r8.xy = r4.xz * cb1[1].xy + cb1[1].zw; // Scale and bias - r8.yzw = r8.yyy * r7.xyz; // Directional component * intensity - - // Spherical Harmonics basis coefficients: - // L0 (constant): Y_0^0 = 0.282094806 (1/(2*sqrt(pi))) - // L1 (linear): Y_1^-1, Y_1^0, Y_1^1 = ±0.488602489 (sqrt(3/(4*pi))) - r7.xyzw = float4(0.282094806,-0.488602489,0.488602489,-0.488602489) * r8.xyzw; - } else { - r7.xyzw = float4(0,0,0,0); // No contribution from this sample - } - - // Accumulate SH coefficients - r5.xyzw = r7.xyzw + r5.xyzw; - - // Move to next sample along capsule - r6.xyz = cb2[r0.w+3].xyz * r0.yyy + r6.xyz; - r3.w = (int)r3.w + 1; - } - - // ======================================================================== - // DISTANCE FALLOFF & FINAL OUTPUT - // ======================================================================== - r0.x = saturate(r1.w / r0.z); // Normalized distance (0-1) - r0.x = -0.300000012 + r0.x; // Shift falloff start - r0.x = 1.42857146 * r0.x; // Scale falloff curve - r0.x = max(0, r0.x); - r0.x = 1 + -r0.x; // Invert (1 at center, 0 at edge) - r0.x = cb2[r0.w+3].w * r0.x; // Apply light intensity - - // Output accumulated SH coefficients scaled by intensity - o0.xyzw = r5.xyzw * r0.xxxx; - } else { - // Outside influence radius - no contribution - o0.xyzw = float4(0,0,0,0); - } - return; -} \ No newline at end of file diff --git a/src/games/endfield/shadows/0xE9345161.cso b/src/games/endfield/shadows/0xE9345161.cso new file mode 100644 index 0000000000..27293b39aa Binary files /dev/null and b/src/games/endfield/shadows/0xE9345161.cso differ diff --git a/src/games/endfield/shadows/0xB8580FF6.ps_5_0.hlsl b/src/games/endfield/shadows/character-shadows_0xB1BC33D0.ps_5_0.hlsl similarity index 74% rename from src/games/endfield/shadows/0xB8580FF6.ps_5_0.hlsl rename to src/games/endfield/shadows/character-shadows_0xB1BC33D0.ps_5_0.hlsl index de6e5c8090..a068089204 100644 --- a/src/games/endfield/shadows/0xB8580FF6.ps_5_0.hlsl +++ b/src/games/endfield/shadows/character-shadows_0xB1BC33D0.ps_5_0.hlsl @@ -1,4 +1,3 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 04:33:32 2026 #include "../shared.h" Texture2D t6 : register(t6); @@ -23,24 +22,27 @@ SamplerState s1_s : register(s1); SamplerState s0_s : register(s0); +cbuffer cb3 : register(b3) +{ + float4 cb3[715]; +} + cbuffer cb2 : register(b2) { - float4 cb2[715]; + float4 cb2[1]; } cbuffer cb1 : register(b1) { - float4 cb1[1]; + float4 cb1[104]; } cbuffer cb0 : register(b0) { - float4 cb0[184]; + float4 cb0[45]; } - - // 3Dmigoto declarations #define cmp - @@ -74,10 +76,10 @@ void main( r0.zw = float2(0,0); r1.xyzw = t5.Load(r0.xyw).xyzw; r2.xy = (uint2)r0.xy; - r2.zw = cb0[82].zw * r2.xy; + r2.zw = cb1[0].zw * r2.xy; r2.zw = r2.zw * float2(2,2) + float2(-1,-1); r2.xy = float2(0.5,0.5) + r2.xy; - r2.xy = cb0[82].zw * r2.xy; + r2.xy = cb1[0].zw * r2.xy; r2.x = t0.SampleLevel(s0_s, r2.xy, 0).x; r3.xyzw = cb0[25].xyzw * -r2.wwww; r3.xyzw = cb0[24].xyzw * r2.zzzz + r3.xyzw; @@ -97,31 +99,32 @@ void main( r0.z = dot(r3.xyz, r3.xyz); r0.z = rsqrt(r0.z); r3.xyz = r3.xyz * r0.zzz; - r0.z = cmp(cb2[35].w < 0.99000001); + r0.z = cmp(cb3[35].w < 0.99000001); if (r0.z != 0) { - r0.z = (int)cb2[35].x; + r0.z = (int)cb3[35].x; r0.w = cmp((int)r0.z == 2); - r4.xyz = r0.www ? cb2[20].xyz : cb0[44].xyz; + r4.xyz = r0.www ? cb3[20].xyz : cb0[44].xyz; r4.xyz = -r4.xyz + r2.xyz; r0.w = dot(r4.xyz, r4.xyz); - r0.w = cb2[34].w + -r0.w; - r0.w = saturate(cb2[34].z * r0.w); + r0.w = cb3[34].w + -r0.w; + r0.w = saturate(cb3[34].z * r0.w); + r0.w = max(cb3[36].x, r0.w); r2.w = cmp(0 < r0.w); if (r2.w != 0) { r0.z = cmp(0 < (int)r0.z); if (r0.z != 0) { - r4.xyz = -cb2[20].xyz + r2.xyz; - r5.xyz = -cb2[21].xyz + r2.xyz; - r6.xyz = -cb2[22].xyz + r2.xyz; - r7.xyz = -cb2[23].xyz + r2.xyz; + r4.xyz = -cb3[20].xyz + r2.xyz; + r5.xyz = -cb3[21].xyz + r2.xyz; + r6.xyz = -cb3[22].xyz + r2.xyz; + r7.xyz = -cb3[23].xyz + r2.xyz; r0.z = dot(r4.xyz, r4.xyz); r2.w = dot(r5.xyz, r5.xyz); r3.w = dot(r6.xyz, r6.xyz); r4.x = dot(r7.xyz, r7.xyz); - r5.x = cmp(r0.z < cb2[20].w); - r5.y = cmp(r2.w < cb2[21].w); - r5.z = cmp(r3.w < cb2[22].w); - r5.w = cmp(r4.x < cb2[23].w); + r5.x = cmp(r0.z < cb3[20].w); + r5.y = cmp(r2.w < cb3[21].w); + r5.z = cmp(r3.w < cb3[22].w); + r5.w = cmp(r4.x < cb3[23].w); r4.xyzw = r5.xyzw ? float4(1,1,1,1) : 0; r5.xyz = r5.xyz ? float3(-1,-1,-1) : float3(-0,-0,-0); r5.xyz = r5.xyz + r4.yzw; @@ -130,20 +133,13 @@ void main( r0.z = 4 + -r0.z; r0.z = max(0, r0.z); r0.z = min(3, r0.z); - r0.z = max(cb2[34].y, r0.z); + r0.z = max(cb3[34].y, r0.z); r2.w = (uint)r0.z; - r3.w = (uint)r2.w << 2; - r4.x = dot(r3.xyz, cb1[0].xyz); - r4.x = max(0, r4.x); - r4.x = min(0.899999976, r4.x); - r4.x = 1 + -r4.x; - r2.w = cb2[r2.w+24].x * r4.x; - r2.w = max(0, r2.w); - r4.xyz = -cb1[0].xyz * r2.www + r2.xyz; - r5.xyz = cb2[r3.w+1].xyz * r4.yyy; - r4.xyw = cb2[r3.w+0].xyz * r4.xxx + r5.xyz; - r4.xyz = cb2[r3.w+2].xyz * r4.zzz + r4.xyw; - r4.xyz = cb2[r3.w+3].xyz + r4.xyz; + r2.w = (uint)r2.w << 2; + r4.xyz = cb3[r2.w+1].xyz * r2.yyy; + r4.xyz = cb3[r2.w+0].xyz * r2.xxx + r4.xyz; + r4.xyz = cb3[r2.w+2].xyz * r2.zzz + r4.xyz; + r4.xyz = cb3[r2.w+3].xyz + r4.xyz; r5.xyz = cmp(float3(0,0,0) >= r4.xyz); r6.xyz = cmp(r4.xyz >= float3(1,1,1)); r5.xyz = (int3)r5.xyz | (int3)r6.xyz; @@ -153,10 +149,10 @@ void main( r3.w = cmp(0x7f800000 < (uint)r3.w); r5.z = (int)r2.w | (int)r3.w; r0.z = (int)r0.z; - r4.xy = r4.xy * cb2[r0.z+28].zw + cb2[r0.z+28].xy; - r6.xy = r4.xy * cb2[32].zw + float2(0.5,0.5); + r4.xy = r4.xy * cb3[r0.z+28].zw + cb3[r0.z+28].xy; + r6.xy = r4.xy * cb3[32].zw + float2(0.5,0.5); r6.xy = floor(r6.xy); - r4.xy = r4.xy * cb2[32].zw + -r6.xy; + r4.xy = r4.xy * cb3[32].zw + -r6.xy; r7.xyzw = float4(0.5,1,0.5,1) + r4.xxyy; r8.xw = r7.xz * r7.xz; r6.zw = min(float2(0,0), r4.xy); @@ -178,17 +174,17 @@ void main( r10.xyzw = r8.xxzz + r8.yyww; r4.xy = r7.yw / r9.zw; r4.xy = float2(-1.5,0.5) + r4.xy; - r7.xy = cb2[32].xx * r4.xy; + r7.xy = cb3[32].xx * r4.xy; r4.xy = r8.yw / r10.yw; r4.xy = float2(-1.5,0.5) + r4.xy; - r7.zw = cb2[32].yy * r4.xy; + r7.zw = cb3[32].yy * r4.xy; r8.xyzw = r10.xyzw * r9.xyzw; - r9.xyzw = r6.xyxy * cb2[32].xyxy + r7.xzyz; + r9.xyzw = r6.xyxy * cb3[32].xyxy + r7.xzyz; r0.z = t1.SampleCmpLevelZero(s3_s, r9.xy, r4.z).x; r2.w = t1.SampleCmpLevelZero(s3_s, r9.zw, r4.z).x; r2.w = r8.y * r2.w; r0.z = r8.x * r0.z + r2.w; - r6.xyzw = r6.xyxy * cb2[32].xyxy + r7.xwyw; + r6.xyzw = r6.xyxy * cb3[32].xyxy + r7.xwyw; r2.w = t1.SampleCmpLevelZero(s3_s, r6.xy, r4.z).x; r0.z = r8.z * r2.w + r0.z; r2.w = t1.SampleCmpLevelZero(s3_s, r6.zw, r4.z).x; @@ -201,49 +197,51 @@ void main( r5.xz = float2(1,0); } r0.z = cmp(r0.w < 1); + r2.w = cmp(0.5 < cb3[36].x); + r0.z = (int)r0.z | (int)r2.w; if (r0.z != 0) { - r0.z = dot(r3.xyz, cb1[0].xyz); + r0.z = dot(r3.xyz, cb2[0].xyz); r0.z = max(0, r0.z); r0.z = min(0.899999976, r0.z); r0.z = 1 + -r0.z; - r4.xy = cb2[584].xy * r0.zz; - r4.xzw = -cb1[0].xyz * r4.xxx + r2.xyz; + r4.xy = cb3[584].xy * r0.zz; + r4.xzw = -cb2[0].xyz * r4.xxx + r2.xyz; r4.xyz = r3.xyz * r4.yyy + r4.xzw; - r6.xy = cb2[581].xy * r4.yy; - r6.xy = cb2[580].xy * r4.xx + r6.xy; - r6.xy = cb2[582].xy * r4.zz + r6.xy; - r6.xy = cb2[583].xy + r6.xy; + r6.xy = cb3[581].xy * r4.yy; + r6.xy = cb3[580].xy * r4.xx + r6.xy; + r6.xy = cb3[582].xy * r4.zz + r6.xy; + r6.xy = cb3[583].xy + r6.xy; r6.zw = cmp(float2(0,0) < r6.xy); r0.z = r6.w ? r6.z : 0; r6.zw = cmp(r6.xy < float2(1,1)); r2.w = r6.w ? r6.z : 0; - r0.z = (int)r0.z & (int)r2.w; + r0.z = r2.w ? r0.z : 0; if (r0.z != 0) { - r0.z = cb2[585].z * r6.y; + r0.z = cb3[585].z * r6.y; r0.z = floor(r0.z); r0.z = r0.z + r6.x; - r0.z = cb2[585].y * r0.z; + r0.z = cb3[585].y * r0.z; r0.z = (uint)r0.z; r0.z = min(127, (uint)r0.z); - r2.w = 0x0000ffff & asint(cb2[r0.z+587].x); + r2.w = 0x0000ffff & asint(cb3[r0.z+587].x); r6.x = f16tof32(r2.w); r2.w = cmp(r6.x >= 0); if (r2.w != 0) { - r7.x = cb2[576].x; - r7.y = cb2[577].x; - r7.z = cb2[578].x; - r7.w = cb2[r0.z+587].y; + r7.x = cb3[576].x; + r7.y = cb3[577].x; + r7.z = cb3[578].x; + r7.w = cb3[r0.z+587].y; r4.w = 1; r7.x = dot(r7.xyzw, r4.xyzw); - r8.x = cb2[576].y; - r8.y = cb2[577].y; - r8.z = cb2[578].y; - r8.w = cb2[r0.z+587].z; + r8.x = cb3[576].y; + r8.y = cb3[577].y; + r8.z = cb3[578].y; + r8.w = cb3[r0.z+587].z; r7.y = dot(r8.xyzw, r4.xyzw); - r8.x = cb2[576].z; - r8.y = cb2[577].z; - r8.z = cb2[578].z; - r8.w = cb2[r0.z+587].w; + r8.x = cb3[576].z; + r8.y = cb3[577].z; + r8.z = cb3[578].z; + r8.w = cb3[r0.z+587].w; r2.w = dot(r8.xyzw, r4.xyzw); r4.xy = cmp(float2(0,0) < r7.xy); r3.w = cmp(0 < r2.w); @@ -255,12 +253,12 @@ void main( r4.x = r4.z ? r4.x : 0; r3.w = r3.w ? r4.x : 0; if (r3.w != 0) { - r0.z = asuint(cb2[r0.z+587].x) >> 16; + r0.z = asuint(cb3[r0.z+587].x) >> 16; r6.y = f16tof32(r0.z); - r4.xy = r7.xy * cb2[584].zw + r6.xy; - r4.zw = r4.xy * cb2[586].zw + float2(0.5,0.5); + r4.xy = r7.xy * cb3[584].zw + r6.xy; + r4.zw = r4.xy * cb3[586].zw + float2(0.5,0.5); r4.zw = floor(r4.zw); - r4.xy = r4.xy * cb2[586].zw + -r4.zw; + r4.xy = r4.xy * cb3[586].zw + -r4.zw; r6.xyzw = float4(0.5,1,0.5,1) + r4.xxyy; r7.xw = r6.xz * r6.xz; r6.xz = min(float2(0,0), r4.xy); @@ -282,17 +280,17 @@ void main( r8.xyzw = r6.xxzz + r6.yyww; r4.xy = r9.yw / r7.zw; r4.xy = float2(-1.5,0.5) + r4.xy; - r9.xy = cb2[586].xx * r4.xy; + r9.xy = cb3[586].xx * r4.xy; r4.xy = r6.yw / r8.yw; r4.xy = float2(-1.5,0.5) + r4.xy; - r9.zw = cb2[586].yy * r4.xy; + r9.zw = cb3[586].yy * r4.xy; r6.xyzw = r8.xyzw * r7.xyzw; - r7.xyzw = r4.zwzw * cb2[586].xyxy + r9.xzyz; + r7.xyzw = r4.zwzw * cb3[586].xyxy + r9.xzyz; r0.z = t4.SampleCmpLevelZero(s3_s, r7.xy, r2.w).x; r3.w = t4.SampleCmpLevelZero(s3_s, r7.zw, r2.w).x; r3.w = r6.y * r3.w; r0.z = r6.x * r0.z + r3.w; - r4.xyzw = r4.zwzw * cb2[586].xyxy + r9.xwyw; + r4.xyzw = r4.zwzw * cb3[586].xyxy + r9.xwyw; r3.w = t4.SampleCmpLevelZero(s3_s, r4.xy, r2.w).x; r0.z = r6.z * r3.w + r0.z; r2.w = t4.SampleCmpLevelZero(s3_s, r4.zw, r2.w).x; @@ -312,20 +310,26 @@ void main( } r0.z = r5.x + -r5.y; r0.z = r0.w * r0.z + r5.y; - r0.w = cmp(0.00100000005 < r0.z); + r0.w = min(r5.y, r5.x); + r0.w = r0.w + -r0.z; + r0.z = cb3[36].x * r0.w + r0.z; + + // Cloud shadow (t3) — toggle via FAKE_CLOUD_SHADOWS + if (FAKE_CLOUD_SHADOWS >= 1.f) { + r0.w = cmp(0.00100000005 < r0.z); if (r0.w != 0) { - r4.xyz = -cb0[173].xyz + r2.xyz; - r4.yw = cb0[176].xz * r4.yy + r4.xz; - r5.xy = cb0[174].zz * r4.yw; - r5.zw = cb0[183].ww * cb0[175].xy; - r4.yw = r4.yw * cb0[174].zz + r5.zw; + r4.xyz = -cb1[93].xyz + r2.xyz; + r4.yw = cb1[96].xz * r4.yy + r4.xz; + r5.xy = cb1[94].zz * r4.yw; + r5.zw = cb1[103].ww * cb1[95].xy; + r4.yw = r4.yw * cb1[94].zz + r5.zw; r0.w = t3.SampleLevel(s2_s, r4.yw, 0).x; - r4.yw = r5.xy * cb0[175].ww + r5.zw; + r4.yw = r5.xy * cb1[95].ww + r5.zw; r2.w = t3.SampleLevel(s2_s, r4.yw, 0).x; r3.w = dot(r4.xz, r4.xz); r3.w = sqrt(r3.w); - r4.x = cb0[174].y + -cb0[174].x; - r3.w = -cb0[174].x + r3.w; + r4.x = cb1[94].y + -cb1[94].x; + r3.w = -cb1[94].x + r3.w; r4.x = 1 / r4.x; r3.w = saturate(r4.x * r3.w); r4.x = r3.w * -2 + 3; @@ -334,19 +338,14 @@ void main( r2.w = r2.w + -r0.w; r0.w = r3.w * r2.w + r0.w; r0.w = -1 + r0.w; - r0.w = cb0[175].z * r0.w + 1; - - if (AO_INTENSITY >= 1.f) { - // Boost AO intensity (hardcoded 4x) - r0.w = 1.0 + (r0.w - 1.0) * 4.0; - } - + r0.w = cb1[95].z * r0.w + 1; r0.z = r0.z * r0.w; + } } - r0.w = cb2[35].z + -r0.z; - r0.z = cb2[35].w * r0.w + r0.z; + r0.w = cb3[35].z + -r0.z; + r0.z = cb3[35].w * r0.w + r0.z; } else { - r0.z = cb2[35].z; + r0.z = cb3[35].z; } r1.xyzw = r1.wzyx * float4(3,1023,1023,1023) + float4(0.5,0.5,0.5,0.5); r1.xyzw = (uint4)r1.xyzw; @@ -358,22 +357,22 @@ void main( r0.w = log2(r0.w); r0.w = -8 + r0.w; r1.x = cmp(r0.w >= 0); - r1.y = cmp(r0.w < cb2[554].z); + r1.y = cmp(r0.w < cb3[554].z); r1.x = r1.y ? r1.x : 0; if (r1.x != 0) { r0.w = (int)r0.w; - r1.x = dot(r3.xyz, cb2[r0.w+523].xyz); + r1.x = dot(r3.xyz, cb3[r0.w+523].xyz); r1.x = max(0, r1.x); r1.x = min(0.899999976, r1.x); r1.x = 1 + -r1.x; r1.y = (uint)r0.w << 2; - r1.xz = cb2[r0.w+508].xy * r1.xx; - r2.xyz = -cb2[r0.w+523].xyz * r1.xxx + r2.xyz; + r1.xz = cb3[r0.w+508].xy * r1.xx; + r2.xyz = -cb3[r0.w+523].xyz * r1.xxx + r2.xyz; r1.xzw = r3.xyz * r1.zzz + r2.xyz; - r2.xyz = cb2[r1.y+449].xyz * r1.zzz; - r2.xyz = cb2[r1.y+448].xyz * r1.xxx + r2.xyz; - r1.xzw = cb2[r1.y+450].xyz * r1.www + r2.xyz; - r1.xyz = cb2[r1.y+451].xyz + r1.xzw; + r2.xyz = cb3[r1.y+449].xyz * r1.zzz; + r2.xyz = cb3[r1.y+448].xyz * r1.xxx + r2.xyz; + r1.xzw = cb3[r1.y+450].xyz * r1.www + r2.xyz; + r1.xyz = cb3[r1.y+451].xyz + r1.xzw; r1.z = max(0.00999999978, r1.z); r2.xy = cmp(float2(0,0) >= r1.xy); r2.zw = cmp(r1.xy >= float2(1,1)); @@ -382,8 +381,8 @@ void main( r2.x = (int)r2.y | (int)r2.x; r1.w = (int)r1.w | (int)r2.x; if (r1.w == 0) { - r2.x = cb2[553].x * 4; - r1.xy = r1.xy * cb2[r0.w+538].zw + cb2[r0.w+538].xy; + r2.x = cb3[553].x * 4; + r1.xy = r1.xy * cb3[r0.w+538].zw + cb3[r0.w+538].xy; bitmask.x = ((~(-1 << 2)) << 2) & 0xffffffff; r0.x = (((uint)r0.x << 2) & bitmask.x) | ((uint)0 & ~bitmask.x); bitmask.x = ((~(-1 << 2)) << 0) & 0xffffffff; r0.x = (((uint)r0.y << 0) & bitmask.x) | ((uint)r0.x & ~bitmask.x); r0.yw = icb[r0.x+0].xy * float2(1,-1); @@ -431,8 +430,14 @@ void main( } o0.y = r1.w ? r0.y : r0.x; r0.x = min(1, r0.z); + + // Shadow compositing contrast curve: S-curve deepens shadow cores + if (SHADOW_HARDENING >= 1.f) { + r0.x = r0.x * r0.x * (3.0 - 2.0 * r0.x); // smoothstep(0, 1, r0.x) + } + r0.x = -1 + r0.x; - o0.x = cb2[34].x * r0.x + 1; + o0.x = cb3[34].x * r0.x + 1; o0.z = 0; return; -} \ No newline at end of file +} diff --git a/src/games/endfield/shadows/0x0C02AB31.cs_5_0.hlsl b/src/games/endfield/shadows/screenspace-shadows_0x0C02AB31.cs_5_0.hlsl similarity index 95% rename from src/games/endfield/shadows/0x0C02AB31.cs_5_0.hlsl rename to src/games/endfield/shadows/screenspace-shadows_0x0C02AB31.cs_5_0.hlsl index 939eb641e7..a00afe8496 100644 --- a/src/games/endfield/shadows/0x0C02AB31.cs_5_0.hlsl +++ b/src/games/endfield/shadows/screenspace-shadows_0x0C02AB31.cs_5_0.hlsl @@ -1,5 +1,4 @@ -// ---- Created with 3Dmigoto v1.4.1 on Sat Jan 24 06:14:41 2026 -// Fixed for compilation + #include "../shared.h" groupshared struct { float val[1]; } g0[128]; @@ -26,14 +25,9 @@ cbuffer cb0 : register(b0) [numthreads(64, 1, 1)] void main(uint3 vThreadIDInGroup : SV_GroupThreadID, uint3 vThreadGroupID : SV_GroupID) { -// Needs manual fix for instruction: -// unknown dcl_: dcl_uav_typed_texture2d (unorm,unorm,unorm,unorm) u0 float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; uint4 bitmask, uiDest; float4 fDest; - -// Needs manual fix for instruction: -// unknown dcl_: dcl_thread_group 64, 1, 1 r0.x = cmp(0 < cb1[2].w); r0.x = r0.x ? 0 : 63; r0.x = (int)r0.x ^ (int)vThreadIDInGroup.x; @@ -380,17 +374,19 @@ void main(uint3 vThreadIDInGroup : SV_GroupThreadID, uint3 vThreadGroupID : SV_G r0.y = saturate(r1.w * cb1[0].z + r0.y); r0.y = min(r0.y, r2.y); r0.y = -1 + r0.y; - r5.yw = r1.xy * cb1[3].zw + float2(-0.5,-0.5); - r5.yw = abs(r5.yw) * float2(12,12) + float2(-4.80000019,-4.80000019); - r5.yw = max(float2(0,0), r5.yw); - r1.w = dot(r5.yw, r5.yw); - r1.w = 1 + -r1.w; - r1.w = max(0, r1.w); - r0.y = r1.w * r0.y; - if (AO_INTENSITY>= 1.f) { - r0.y = r0.y * 4.0; - } + // Removed screen edge fade for contact shadows (original) + // r5.yw = r1.xy * cb1[3].zw + float2(-0.5,-0.5); + // r5.yw = abs(r5.yw) * float2(12,12) + float2(-4.80000019,-4.80000019); + // r5.yw = max(float2(0,0), r5.yw); + // r1.w = dot(r5.yw, r5.yw); + // r1.w = 1 + -r1.w; + // r1.w = max(0, r1.w); + // r0.y = r1.w * r0.y; + + // Shadow hardening moved to deferred lighting shaders per-material: + // 0x1E8A471E (environment) = crude 4x + // 0xD3FA93FC (grass/foliage) = pow(x,4) power curve r6.xzw = cb1[0].www * r0.yyy + float3(1,1,1); r0.y = -cb1[2].w + r1.z; @@ -462,4 +458,4 @@ void main(uint3 vThreadIDInGroup : SV_GroupThreadID, uint3 vThreadGroupID : SV_G u0[r4.xy] = r6; return; -} \ No newline at end of file +} diff --git a/src/games/endfield/shadows/shadowcompositing-shadowmap_0xB370840A.ps_5_0.hlsl b/src/games/endfield/shadows/shadowcompositing-shadowmap_0xB370840A.ps_5_0.hlsl new file mode 100644 index 0000000000..bee5af38c1 --- /dev/null +++ b/src/games/endfield/shadows/shadowcompositing-shadowmap_0xB370840A.ps_5_0.hlsl @@ -0,0 +1,404 @@ +#include "../shared.h" + +Texture2D t5 : register(t5); + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerComparisonState s3_s : register(s3); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb3 : register(b3) +{ + float4 cb3[715]; +} + +cbuffer cb2 : register(b2) +{ + float4 cb2[1]; +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[104]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[45]; +} + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float3 o0 : SV_Target0) +{ + const float4 icb[] = { { 1.000000, 0, 0, 0}, + { 0, 1.000000, 0, 0}, + { 0, 0, 1.000000, 0}, + { 0, 0, 0, 1.000000}, + { -0.399656, 0.916665, -0.942016, -0.399062}, + { 0.124512, -0.992218, 0.945586, -0.768907}, + { 0.852354, 0.522965, -0.094184, -0.929389}, + { -0.229312, 0.973353, 0.344959, 0.293878}, + { -0.772406, 0.635129, -0.915886, 0.457714}, + { 0.792753, -0.609544, -0.815442, -0.879125}, + { -0.578050, 0.816002, -0.382775, 0.276768}, + { -0.831130, -0.556079, 0.974844, 0.756484}, + { 0.807795, 0.589464, 0.443233, -0.975116}, + { 0.471415, 0.881911, 0.537430, -0.473734}, + { -0.313974, -0.949432, -0.264969, -0.418930}, + { -0.945007, -0.327051, 0.791975, 0.190902}, + { -0.185037, -0.982732, -0.241888, 0.997065}, + { -0.933756, 0.357911, -0.814100, 0.914376}, + { -0.997614, 0.069036, 0.199841, 0.786414}, + { 0.306128, 0.951990, 0.143832, -0.141008} }; + float4 r0,r1,r2,r3,r4,r5,r6,r7; + uint4 bitmask, uiDest; + float4 fDest; + + r0.x = cmp(cb3[35].w < 0.99000001); + if (r0.x != 0) { + r0.xy = (uint2)v0.xy; + r0.zw = (uint2)r0.xy; + r1.xy = cb1[0].zw * r0.zw; + r1.zw = r1.xy * float2(2,2) + float2(-1,-1); + r2.xy = float2(0.5,0.5) + r0.zw; + r2.xy = cb1[0].zw * r2.xy; + r2.x = t0.SampleLevel(s0_s, r2.xy, 0).x; + r3.xyzw = cb0[25].xyzw * -r1.wwww; + r3.xyzw = cb0[24].xyzw * r1.zzzz + r3.xyzw; + r2.xyzw = cb0[26].xyzw * r2.xxxx + r3.xyzw; + r2.xyzw = cb0[27].xyzw + r2.xyzw; + r2.xyz = r2.xyz / r2.www; + r1.z = (int)cb3[35].x; + r1.w = cmp((int)r1.z == 2); + r3.xyz = r1.www ? cb3[20].xyz : cb0[44].xyz; + r3.xyz = -r3.xyz + r2.xyz; + r1.w = dot(r3.xyz, r3.xyz); + r1.w = cb3[34].w + -r1.w; + r1.w = saturate(cb3[34].z * r1.w); + r1.w = max(cb3[36].x, r1.w); + r2.w = cmp(0 < r1.w); + if (r2.w != 0) { + r1.z = cmp(0 < (int)r1.z); + if (r1.z != 0) { + r1.xy = t5.SampleLevel(s1_s, r1.xy, 0).xy; + r3.xyz = -cb3[20].xyz + r2.xyz; + r4.xyz = -cb3[21].xyz + r2.xyz; + r5.xyz = -cb3[22].xyz + r2.xyz; + r6.xyz = -cb3[23].xyz + r2.xyz; + r3.x = dot(r3.xyz, r3.xyz); + r3.y = dot(r4.xyz, r4.xyz); + r3.z = dot(r5.xyz, r5.xyz); + r3.w = dot(r6.xyz, r6.xyz); + r4.x = cmp(r3.x < cb3[20].w); + r4.y = cmp(r3.y < cb3[21].w); + r4.z = cmp(r3.z < cb3[22].w); + r4.w = cmp(r3.w < cb3[23].w); + r5.xyzw = r4.xyzw ? float4(1,1,1,1) : 0; + r4.xyz = r4.xyz ? float3(-1,-1,-1) : float3(-0,-0,-0); + r4.xyz = r5.yzw + r4.xyz; + r5.yzw = max(float3(0,0,0), r4.xyz); + r1.z = dot(r5.xyzw, float4(4,3,2,1)); + r1.z = 4 + -r1.z; + r1.z = max(0, r1.z); + r1.z = min(3, r1.z); + r2.w = 1 + r1.z; + r2.w = min(3, r2.w); + r4.x = (uint)r2.w; + r4.y = dot(r3.yzw, icb[r4.x+0].yzw); + r4.x = r4.y / cb3[r4.x+20].w; + r2.w = cmp(r1.z < r2.w); + r4.y = cmp(r4.x >= 0); + r2.w = r2.w ? r4.y : 0; + r4.x = cmp(1 >= r4.x); + r2.w = r2.w ? r4.x : 0; + if (r2.w != 0) { + r2.w = (uint)r1.z; + r4.xy = float2(2.08299994,4.8670001) + r0.zw; + r4.x = dot(r4.xy, float2(0.0671105608,0.00583714992)); + r4.x = frac(r4.x); + r4.x = 52.9829178 * r4.x; + r4.x = frac(r4.x); + r3.x = dot(r3.xyzw, icb[r2.w+0].xyzw); + r2.w = r3.x / cb3[r2.w+20].w; + r2.w = sqrt(r2.w); + r2.w = -0.899999976 + r2.w; + r2.w = 12 * r2.w; + r2.w = cmp(r2.w >= r4.x); + r2.w = r2.w ? 1.000000 : 0; + r1.z = r2.w + r1.z; + } + r2.w = (uint)r1.z; + r2.w = (uint)r2.w << 2; + r1.x = cmp(r1.x >= 0.999989986); + r1.x = r1.x ? 1.000000 : 0; + r1.x = r1.x * r1.y; + r1.x = 4 * r1.x; + r3.xyz = -cb2[0].xyz * r1.xxx + r2.xyz; + r4.xyz = cb3[r2.w+1].xyz * r3.yyy; + r3.xyw = cb3[r2.w+0].xyz * r3.xxx + r4.xyz; + r3.xyz = cb3[r2.w+2].xyz * r3.zzz + r3.xyw; + r3.xyz = cb3[r2.w+3].xyz + r3.xyz; + r4.xyz = cmp(float3(0,0,0) >= r3.xyz); + r5.xyz = cmp(r3.xyz >= float3(1,1,1)); + r4.xyz = (int3)r4.xyz | (int3)r5.xyz; + r1.x = (int)r4.y | (int)r4.x; + r1.x = (int)r4.z | (int)r1.x; + r1.y = (int)r3.z & 0x7fffffff; + r1.y = cmp(0x7f800000 < (uint)r1.y); + r4.z = (int)r1.y | (int)r1.x; + r0.zw = float2(0.25,0.25) * r0.zw; + r5.xy = (int2)r0.zw; + r5.zw = float2(0,0); + r4.x = t3.Load(r5.xyz).x; + r0.z = cmp(r4.x < 0.00100000005); + r0.w = cmp(0.99000001 < r4.x); + r0.z = (int)r0.w | (int)r0.z; + if (r0.z == 0) { + r0.z = (int)r1.z; + r1.xy = r3.xy * cb3[r0.z+28].zw + cb3[r0.z+28].xy; + bitmask.x = ((~(-1 << 2)) << 2) & 0xffffffff; r0.x = (((uint)r0.x << 2) & bitmask.x) | ((uint)0 & ~bitmask.x); + bitmask.x = ((~(-1 << 2)) << 0) & 0xffffffff; r0.x = (((uint)r0.y << 0) & bitmask.x) | ((uint)r0.x & ~bitmask.x); + r0.y = dot(cb3[33].xyzw, icb[r0.z+0].xyzw); + + // Per-cascade PCF kernel scaling: sharper near shadows, softer distant shadows + if (SHADOW_HARDENING >= 1.f) { + r0.y *= lerp(0.75, 1.5, saturate((float)r0.z / 3.0)); + } + r0.zw = icb[r0.x+4].xy * float2(1,-1); + r3.xy = float2(0,0); + r1.z = 0; + while (true) { + r2.w = cmp((uint)r1.z >= 16); + if (r2.w != 0) break; + r5.x = dot(icb[r1.z+4].zw, r0.zw); + r5.y = dot(icb[r1.z+4].wz, icb[r0.x+4].xy); + r5.xy = r5.xy * r0.yy + r1.xy; + r5.xyzw = t1.Gather(s1_s, r5.xy).xyzw; + r5.xyzw = r5.xyzw + -r3.zzzz; + r6.xyzw = cmp(r5.xyzw >= float4(0,0,0,0)); + r6.xyzw = r6.xyzw ? float4(1,1,1,1) : 0; + r2.w = dot(r5.xyzw, r6.xyzw); + r5.x = r3.x + r2.w; + r2.w = dot(r6.xyzw, float4(1,1,1,1)); + r5.y = r3.y + r2.w; + r2.w = (int)r1.z + 1; + r3.xy = r5.xy; + r1.z = r2.w; + continue; + } + r0.x = r3.y * 0.03125 + -1; + r0.y = cmp(0 < r0.x); + r0.z = cmp(r0.x < 0); + r0.y = (int)-r0.y + (int)r0.z; + r0.y = (int)r0.y; + r0.x = -r0.y * r0.x + 1; + r0.z = r0.x * r0.x; + r0.w = r0.z * r0.x; + r1.x = 1 / r3.y; + r1.x = r3.x * r1.x; + r1.y = 1 / r3.z; + r1.x = saturate(r1.x * r1.y); + r0.x = -r0.z * r0.x + r0.x; + r0.x = r1.x * r0.x + r0.w; + r0.x = 1 + -r0.x; + r0.x = r0.x * r0.y; + r0.x = -r0.x * 0.5 + 0.5; + r4.x = r4.z ? 1 : r0.x; + } + } else { + r4.xz = float2(1,0); + } + } else { + r4.xz = float2(1,0); + } + r0.x = cmp(r1.w < 1); + r0.y = cmp(0.5 < cb3[36].x); + r0.x = (int)r0.y | (int)r0.x; + if (r0.x != 0) { + r0.xyz = ddy_coarse(r2.zxy); + r1.xyz = ddx_coarse(r2.yzx); + r3.xyz = r1.xyz * r0.xyz; + r0.xyz = r0.zxy * r1.yzx + -r3.xyz; + r0.w = dot(r0.xyz, r0.xyz); + r0.w = max(1.17549435e-038, r0.w); + r0.w = rsqrt(r0.w); + r0.xyz = r0.xyz * r0.www; + r0.w = dot(r0.xyz, cb2[0].xyz); + r0.w = max(0, r0.w); + r0.w = min(0.899999976, r0.w); + r0.w = 1 + -r0.w; + r1.xy = cb3[584].xy * r0.ww; + r3.xyz = -cb2[0].xyz * r1.xxx + r2.xyz; + r0.xyz = r0.xyz * r1.yyy + r3.xyz; + r1.xy = cb3[581].xy * r0.yy; + r1.xy = cb3[580].xy * r0.xx + r1.xy; + r1.xy = cb3[582].xy * r0.zz + r1.xy; + r1.xy = cb3[583].xy + r1.xy; + r3.xy = cmp(float2(0,0) < r1.xy); + r1.z = r3.y ? r3.x : 0; + r3.xy = cmp(r1.xy < float2(1,1)); + r2.w = r3.y ? r3.x : 0; + r1.z = (int)r1.z & (int)r2.w; + if (r1.z != 0) { + r1.y = cb3[585].z * r1.y; + r1.y = floor(r1.y); + r1.x = r1.y + r1.x; + r1.x = cb3[585].y * r1.x; + r1.x = (uint)r1.x; + r1.x = min(127, (uint)r1.x); + r1.y = 0x0000ffff & asint(cb3[r1.x+587].x); + r3.x = f16tof32(r1.y); + r1.y = cmp(r3.x >= 0); + if (r1.y != 0) { + r5.x = cb3[576].x; + r5.y = cb3[577].x; + r5.z = cb3[578].x; + r5.w = cb3[r1.x+587].y; + r0.w = 1; + r5.x = dot(r5.xyzw, r0.xyzw); + r6.x = cb3[576].y; + r6.y = cb3[577].y; + r6.z = cb3[578].y; + r6.w = cb3[r1.x+587].z; + r5.y = dot(r6.xyzw, r0.xyzw); + r6.x = cb3[576].z; + r6.y = cb3[577].z; + r6.z = cb3[578].z; + r6.w = cb3[r1.x+587].w; + r0.x = dot(r6.xyzw, r0.xyzw); + r0.yz = cmp(float2(0,0) < r5.xy); + r0.w = cmp(0 < r0.x); + r0.y = r0.z ? r0.y : 0; + r0.y = r0.w ? r0.y : 0; + r0.zw = cmp(r5.xy < float2(1,1)); + r1.y = cmp(r0.x < 1); + r0.z = r0.w ? r0.z : 0; + r0.z = r1.y ? r0.z : 0; + r0.y = r0.z ? r0.y : 0; + if (r0.y != 0) { + r0.y = asuint(cb3[r1.x+587].x) >> 16; + r3.y = f16tof32(r0.y); + r0.yz = r5.xy * cb3[584].zw + r3.xy; + r1.xy = r0.yz * cb3[586].zw + float2(0.5,0.5); + r1.xy = floor(r1.xy); + r0.yz = r0.yz * cb3[586].zw + -r1.xy; + r3.xyzw = float4(0.5,1,0.5,1) + r0.yyzz; + r5.xw = r3.xz * r3.xz; + r3.xz = min(float2(0,0), r0.yz); + r6.xy = max(float2(0,0), r0.yz); + r6.zw = r5.xw * float2(0.5,0.5) + -r0.yz; + r0.yz = float2(1,1) + -r0.yz; + r0.yz = -r3.xz * r3.xz + r0.yz; + r3.xy = -r6.xy * r6.xy + r3.yw; + r7.x = r6.z; + r7.y = r0.y; + r7.z = r3.x; + r7.w = r5.x; + r7.xyzw = float4(0.444440007,0.444440007,0.444440007,0.222220004) * r7.xyzw; + r5.x = r6.w; + r5.y = r0.z; + r5.z = r3.y; + r3.xyzw = float4(0.444440007,0.444440007,0.444440007,0.222220004) * r5.xyzw; + r5.xyzw = r7.xzxz + r7.ywyw; + r6.xyzw = r3.xxzz + r3.yyww; + r0.yz = r7.yw / r5.zw; + r0.yz = float2(-1.5,0.5) + r0.yz; + r7.xy = cb3[586].xx * r0.yz; + r0.yz = r3.yw / r6.yw; + r0.yz = float2(-1.5,0.5) + r0.yz; + r7.zw = cb3[586].yy * r0.yz; + r3.xyzw = r6.xyzw * r5.xyzw; + r5.xyzw = r1.xyxy * cb3[586].xyxy + r7.xzyz; + r0.y = t4.SampleCmpLevelZero(s3_s, r5.xy, r0.x).x; + r0.z = t4.SampleCmpLevelZero(s3_s, r5.zw, r0.x).x; + r0.z = r3.y * r0.z; + r0.y = r3.x * r0.y + r0.z; + r5.xyzw = r1.xyxy * cb3[586].xyxy + r7.xwyw; + r0.z = t4.SampleCmpLevelZero(s3_s, r5.xy, r0.x).x; + r0.y = r3.z * r0.z + r0.y; + r0.x = t4.SampleCmpLevelZero(s3_s, r5.zw, r0.x).x; + r4.y = r3.w * r0.x + r0.y; + } else { + r4.y = 1; + } + } else { + r4.y = 1; + } + } else { + r4.y = 1; + } + r4.x = r4.z ? r4.y : r4.x; + } else { + r4.y = 1; + } + r0.x = r4.x + -r4.y; + r0.x = r1.w * r0.x + r4.y; + r0.y = min(r4.y, r4.x); + r0.y = r0.y + -r0.x; + r0.x = cb3[36].x * r0.y + r0.x; + + // Cloud shadow (t2) — toggle via FAKE_CLOUD_SHADOWS + if (FAKE_CLOUD_SHADOWS >= 1.f) { + r0.y = cmp(0.00100000005 < r0.x); + if (r0.y != 0) { + r0.yzw = -cb1[93].xyz + r2.xyz; + r1.xy = cb1[96].xz * r0.zz + r0.yw; + r1.zw = cb1[94].zz * r1.xy; + r2.xy = cb1[103].ww * cb1[95].xy; + r1.xy = r1.xy * cb1[94].zz + r2.xy; + r0.z = t2.SampleLevel(s2_s, r1.xy, 0).x; + r1.xy = r1.zw * cb1[95].ww + r2.xy; + r1.x = t2.SampleLevel(s2_s, r1.xy, 0).x; + r0.y = dot(r0.yw, r0.yw); + r0.y = sqrt(r0.y); + r0.w = cb1[94].y + -cb1[94].x; + r0.y = -cb1[94].x + r0.y; + r0.w = 1 / r0.w; + r0.y = saturate(r0.y * r0.w); + r0.w = r0.y * -2 + 3; + r0.y = r0.y * r0.y; + r0.y = r0.w * r0.y; + r0.w = r1.x + -r0.z; + r0.y = r0.y * r0.w + r0.z; + r0.y = -1 + r0.y; + r0.y = cb1[95].z * r0.y + 1; + r0.x = r0.x * r0.y; + } + } + r0.y = cb3[35].z + -r0.x; + r0.x = cb3[35].w * r0.y + r0.x; + } else { + r0.x = cb3[35].z; + } + r0.x = min(1, r0.x); + + // Shadow compositing contrast curve: S-curve deepens shadow cores + if (SHADOW_HARDENING >= 1.f) { + r0.x = r0.x * r0.x * (3.0 - 2.0 * r0.x); + } + + r0.x = -1 + r0.x; + o0.x = cb3[34].x * r0.x + 1; + o0.yz = float2(1,0); + return; +} diff --git a/src/games/endfield/shared.h b/src/games/endfield/shared.h index 9ede27511f..6d2441df91 100644 --- a/src/games/endfield/shared.h +++ b/src/games/endfield/shared.h @@ -16,6 +16,7 @@ // #define RENODX_TONE_MAP_FLARE 0 // #define RENODX_TONE_MAP_HUE_CORRECTION 1.f // #define RENODX_TONE_MAP_HUE_SHIFT 0 +// #define RENODX_TONE_MAP_HUE_METHOD 0 // #define RENODX_TONE_MAP_WORKING_COLOR_SPACE color::convert::COLOR_SPACE_BT709 // #define RENODX_TONE_MAP_CLAMP_COLOR_SPACE color::convert::COLOR_SPACE_NONE // #define RENODX_TONE_MAP_CLAMP_PEAK color::convert::COLOR_SPACE_BT709 @@ -79,6 +80,8 @@ struct ShaderInjectData { float reno_drt_tone_map_method; float status_text_opacity; float ping_text_opacity; + float latency_text_opacity; + float latency_bar_draw_opacity; float custom_random; float custom_grain_strength; float vignette_strength; @@ -87,7 +90,17 @@ struct ShaderInjectData { float bloom_strength; float godrays_intensity; float perchannelblowout; - float ao_intensity; + float fog_modification; + float shadow_hardening; + float chromatic_aberration_strength; + float disable_game_ao; + float cubemap_ambient_link; + float glass_transparency; + float improved_ssr; + float tech_test_look; + float ui_aspect_ratio; + float improved_gtao; + float fake_cloud_shadows; }; #ifndef __cplusplus @@ -126,8 +139,8 @@ cbuffer shader_injection : register(b13) { #define RENODX_SWAP_CHAIN_GAMMA_CORRECTION shader_injection.swap_chain_gamma_correction // #define RENODX_SWAP_CHAIN_DECODING_COLOR_SPACE shader_injection.swap_chain_decoding_color_space #define RENODX_SWAP_CHAIN_CUSTOM_COLOR_SPACE shader_injection.swap_chain_custom_color_space -// #define RENODX_SWAP_CHAIN_SCALING_NITS shader_injection.swap_chain_scaling_nits -// #define RENODX_SWAP_CHAIN_CLAMP_NITS shader_injection.swap_chain_clamp_nits +#define RENODX_SWAP_CHAIN_SCALING_NITS (shader_injection.swap_chain_encoding < 4.f ? 1.f : shader_injection.graphics_white_nits) +#define RENODX_SWAP_CHAIN_CLAMP_NITS (shader_injection.swap_chain_encoding < 4.f ? 1.f : shader_injection.peak_white_nits) #define RENODX_SWAP_CHAIN_CLAMP_COLOR_SPACE shader_injection.swap_chain_clamp_color_space #define RENODX_SWAP_CHAIN_ENCODING shader_injection.swap_chain_encoding #define RENODX_SWAP_CHAIN_ENCODING_COLOR_SPACE shader_injection.swap_chain_encoding_color_space @@ -135,6 +148,8 @@ cbuffer shader_injection : register(b13) { #define RENODX_VIDEO_NITS shader_injection.tone_map_video_nits #define RENODX_RENO_DRT_TONE_MAP_METHOD shader_injection.reno_drt_tone_map_method #define PING_TEXT_OPACITY shader_injection.ping_text_opacity +#define LATENCY_TEXT_OPACITY shader_injection.latency_text_opacity +#define LATENCY_BAR_DRAW_OPACITY shader_injection.latency_bar_draw_opacity #define STATUS_TEXT_OPACITY shader_injection.status_text_opacity #define CUSTOM_RANDOM shader_injection.custom_random #define CUSTOM_GRAIN_STRENGTH shader_injection.custom_grain_strength @@ -144,7 +159,28 @@ cbuffer shader_injection : register(b13) { #define BLOOM_STRENGTH shader_injection.bloom_strength #define GODRAYS_INTENSITY shader_injection.godrays_intensity #define PER_CHANNEL_BLOWOUT shader_injection.perchannelblowout -#define AO_INTENSITY shader_injection.ao_intensity +#define SHADOW_HARDENING shader_injection.shadow_hardening +#define CHROMATIC_ABERRATION_STRENGTH shader_injection.chromatic_aberration_strength +#define FOG_MODIFICATION shader_injection.fog_modification +#define GLASS_TRANSPARENCY shader_injection.glass_transparency +#define TECH_TEST_LOOK shader_injection.tech_test_look +#define UI_ASPECT_RATIO shader_injection.ui_aspect_ratio +#define AO_RADIUS 4.0 +#define AO_RADIUS_SCALE 1.0 +#define AO_FALLOFF_RANGE 1.0 +#define AO_DISTRIBUTION_POWER 2.0 +#define AO_THIN_OCCLUDER 2.0 +#define AO_GAMMA 2.2 +#define AO_TEMPORAL_FRAME 64.0 +#define AO_MIP_BIAS 4.0 +#define AO_DIRECTION_COUNT 6.0 +#define AO_STEP_COUNT 6.0 +#define AO_NORMAL_ATTENUATION 0.05 +#define AO_THICKNESS 0.5 +#define AO_DENOISER_BLUR_BETA 0.0 +#define AO_BITMASK 1.0 +#define IMPROVED_GTAO shader_injection.improved_gtao +#define FAKE_CLOUD_SHADOWS shader_injection.fake_cloud_shadows #include "../../shaders/renodx.hlsl" diff --git a/src/games/endfield/ssr/ssr-denoiser_0x4DF0E317.cs_5_0.hlsl b/src/games/endfield/ssr/ssr-denoiser_0x4DF0E317.cs_5_0.hlsl new file mode 100644 index 0000000000..7ebd245d77 --- /dev/null +++ b/src/games/endfield/ssr/ssr-denoiser_0x4DF0E317.cs_5_0.hlsl @@ -0,0 +1,203 @@ + +#include "../shared.h" + +Texture2D t3 : register(t3); +Texture2D t2 : register(t2); +Texture2D t1 : register(t1); +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb0 : register(b0) +{ + float4 cb0[1]; +} + +RWTexture2D u0 : register(u0); + +#define cmp - + +[numthreads(8, 8, 1)] +void main(uint3 vThreadID : SV_DispatchThreadID) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13; + uint4 bitmask, uiDest; + float4 fDest; + + // === ORIGINAL DENOISER === + r0.xyzw = (int4)vThreadID.xyxy + int4(0,1,1,1); + r0.xyzw = (int4)r0.xyzw; + r0.xyzw = float4(0.5,0.5,0.5,0.5) + r0.xyzw; + r0.xyzw = cb0[0].zwzw * r0.xyzw; + r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.xyz = t1.SampleLevel(s0_s, r0.xy, 0).xyz; + r0.w = dot(r1.xz, float2(0.5,-0.5)); + r2.y = 0.501960814 + r0.w; + r0.w = dot(r1.xzy, float3(-0.25,-0.25,0.5)); + r2.x = dot(r1.xzy, float3(0.25,0.25,0.5)); + r2.z = 0.501960814 + r0.w; + r0.w = dot(r0.xz, float2(0.5,-0.5)); + r1.y = 0.501960814 + r0.w; + r0.w = dot(r0.xzy, float3(-0.25,-0.25,0.5)); + r1.x = dot(r0.xzy, float3(0.25,0.25,0.5)); + r1.z = 0.501960814 + r0.w; + r0.xyzw = (int4)vThreadID.xyxy + int4(1,0,-1,1); + r0.xyzw = (int4)r0.xyzw; + r0.xyzw = float4(0.5,0.5,0.5,0.5) + r0.xyzw; + r0.xyzw = cb0[0].zwzw * r0.xyzw; + r3.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.xyz = t1.SampleLevel(s0_s, r0.xy, 0).xyz; + r0.w = dot(r3.xz, float2(0.5,-0.5)); + r4.y = 0.501960814 + r0.w; + r0.w = dot(r3.xzy, float3(-0.25,-0.25,0.5)); + r4.x = dot(r3.xzy, float3(0.25,0.25,0.5)); + r4.z = 0.501960814 + r0.w; + r0.w = dot(r0.xz, float2(0.5,-0.5)); + r3.y = 0.501960814 + r0.w; + r0.w = dot(r0.xzy, float3(-0.25,-0.25,0.5)); + r3.x = dot(r0.xzy, float3(0.25,0.25,0.5)); + r3.z = 0.501960814 + r0.w; + r0.xyzw = (int4)vThreadID.xyxy + int4(1,-1,-1,0); + r0.xyzw = (int4)r0.xyzw; + r0.xyzw = float4(0.5,0.5,0.5,0.5) + r0.xyzw; + r0.xyzw = cb0[0].zwzw * r0.xyzw; + r5.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.xyz = t1.SampleLevel(s0_s, r0.xy, 0).xyz; + r0.w = dot(r5.xz, float2(0.5,-0.5)); + r6.y = 0.501960814 + r0.w; + r0.w = dot(r5.xzy, float3(-0.25,-0.25,0.5)); + r6.x = dot(r5.xzy, float3(0.25,0.25,0.5)); + r6.z = 0.501960814 + r0.w; + r0.w = dot(r0.xz, float2(0.5,-0.5)); + r5.y = 0.501960814 + r0.w; + r0.w = dot(r0.xzy, float3(-0.25,-0.25,0.5)); + r5.x = dot(r0.xzy, float3(0.25,0.25,0.5)); + r5.z = 0.501960814 + r0.w; + r0.xyzw = (int4)vThreadID.xyxy + int4(-1,-1,0,-1); + r0.xyzw = (int4)r0.xyzw; + r0.xyzw = float4(0.5,0.5,0.5,0.5) + r0.xyzw; + r0.xyzw = cb0[0].zwzw * r0.xyzw; + r7.xyz = t1.SampleLevel(s0_s, r0.xy, 0).xyz; + r0.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.w = dot(r7.xz, float2(0.5,-0.5)); + r8.y = 0.501960814 + r0.w; + r0.w = dot(r7.xzy, float3(-0.25,-0.25,0.5)); + r8.x = dot(r7.xzy, float3(0.25,0.25,0.5)); + r8.z = 0.501960814 + r0.w; + r0.w = dot(r0.xz, float2(0.5,-0.5)); + r7.y = 0.501960814 + r0.w; + r0.w = dot(r0.xzy, float3(-0.25,-0.25,0.5)); + r7.x = dot(r0.xzy, float3(0.25,0.25,0.5)); + r7.z = 0.501960814 + r0.w; + r0.xyz = r7.xyz * r7.xyz; + r0.xyz = r8.xyz * r8.xyz + r0.xyz; + r0.xyz = r5.xyz * r5.xyz + r0.xyz; + r0.xyz = r6.xyz * r6.xyz + r0.xyz; + r9.xy = (int2)vThreadID.xy; + r9.xy = float2(0.5,0.5) + r9.xy; + r9.xy = cb0[0].zw * r9.xy; + r10.xyz = t1.SampleLevel(s0_s, r9.xy, 0).xyz; + r0.w = dot(r10.xz, float2(0.5,-0.5)); + r11.y = 0.501960814 + r0.w; + r0.w = dot(r10.xzy, float3(-0.25,-0.25,0.5)); + r11.z = 0.501960814 + r0.w; + r11.x = dot(r10.xzy, float3(0.25,0.25,0.5)); + r0.xyz = r11.xyz * r11.xyz + r0.xyz; + r0.xyz = r3.xyz * r3.xyz + r0.xyz; + r0.xyz = r4.xyz * r4.xyz + r0.xyz; + r0.xyz = r1.xyz * r1.xyz + r0.xyz; + r0.xyz = r2.xyz * r2.xyz + r0.xyz; + r12.xyz = r8.xyz + r7.xyz; + r12.xyz = r12.xyz + r5.xyz; + r12.xyz = r12.xyz + r6.xyz; + r12.xyz = r12.xyz + r11.xyz; + r12.xyz = r12.xyz + r3.xyz; + r12.xyz = r12.xyz + r4.xyz; + r12.xyz = r12.xyz + r1.xyz; + r12.xyz = r12.xyz + r2.xyz; + r13.xyz = float3(0.111111112,0.111111112,0.111111112) * r12.xyz; + r13.xyz = r13.xyz * r13.xyz; + r0.xyz = r0.xyz * float3(0.111111112,0.111111112,0.111111112) + -r13.xyz; + r0.xyz = sqrt(r0.xyz); + + // Variance multiplier: wider = more history survives the clamp = less shimmer + // Vanilla is 1.25. In Reduced mode, widen to 2.0 for stability. + + float variance_mult = (shader_injection.improved_ssr >= 0.5f) ? 2.0f : 1.25f; + r0.xyz = variance_mult * r0.xyz; + r13.xyz = r12.xyz * float3(0.111111112,0.111111112,0.111111112) + -r0.xyz; + r0.xyz = r12.xyz * float3(0.111111112,0.111111112,0.111111112) + r0.xyz; + r12.xyz = min(r8.xyz, r5.xyz); + r5.xyz = max(r8.xyz, r5.xyz); + r8.xyz = min(r4.xyz, r2.xyz); + r2.xyz = max(r4.xyz, r2.xyz); + r2.xyz = max(r5.xyz, r2.xyz); + r4.xyz = min(r12.xyz, r8.xyz); + r5.xyz = min(r3.xyz, r1.xyz); + r1.xyz = max(r3.xyz, r1.xyz); + r3.xyz = min(r11.xyz, r6.xyz); + r6.xyz = max(r11.xyz, r6.xyz); + r1.xyz = max(r6.xyz, r1.xyz); + r1.xyz = max(r7.xyz, r1.xyz); + r3.xyz = min(r3.xyz, r5.xyz); + r3.xyz = min(r7.xyz, r3.xyz); + r4.xyz = min(r3.xyz, r4.xyz); + r3.xyz = r4.xyz + r3.xyz; + r3.xyz = float3(0.5,0.5,0.5) * r3.xyz; + r3.xyz = min(r3.xyz, r13.xyz); + r2.xyz = max(r1.xyz, r2.xyz); + r1.xyz = r2.xyz + r1.xyz; + r1.xyz = float3(0.5,0.5,0.5) * r1.xyz; + r0.xyz = max(r1.xyz, r0.xyz); + r1.xyz = r0.xyz + -r3.xyz; + r0.xyz = r0.xyz + r3.xyz; + r1.xyz = float3(0.5,0.5,0.5) * r1.xyz; + r2.xy = t0.SampleLevel(s0_s, r9.xy, 0).xy; + r2.zw = float2(-0.5,-0.5) + r2.xy; + r2.xy = abs(r2.xy) * float2(2,2) + float2(-1,-1); + r2.xy = r2.xy * r2.xy; + r2.xy = r2.xy * r2.xy; + r3.xy = cmp(float2(0,0) < r2.zw); + r2.zw = cmp(r2.zw < float2(0,0)); + r2.zw = (int2)-r3.xy + (int2)r2.zw; + r2.zw = (int2)r2.zw; + r2.xy = -r2.xy * r2.zw + r9.xy; + r0.w = t2.SampleLevel(s0_s, r9.xy, 0).x; + r0.w = 0.899999976 * r0.w; + if (shader_injection.improved_ssr >= 0.5f) { + // Manual bilinear interpolation for history color + float2 texelPos = r2.xy * cb0[0].xy - 0.5; + float2 f = frac(texelPos); + float2 base = (floor(texelPos) + 0.5) * cb0[0].zw; + float3 h00 = t3.SampleLevel(s0_s, base, 0).xyz; + float3 h10 = t3.SampleLevel(s0_s, base + float2(cb0[0].z, 0), 0).xyz; + float3 h01 = t3.SampleLevel(s0_s, base + float2(0, cb0[0].w), 0).xyz; + float3 h11 = t3.SampleLevel(s0_s, base + cb0[0].zw, 0).xyz; + r2.xyz = lerp(lerp(h00, h10, f.x), lerp(h01, h11, f.x), f.y); + } else { + r2.xyz = t3.SampleLevel(s0_s, r2.xy, 0).xyz; + } + r1.w = dot(r2.xz, float2(0.5,-0.5)); + r3.y = 0.501960814 + r1.w; + r1.w = dot(r2.xzy, float3(-0.25,-0.25,0.5)); + r3.x = dot(r2.xzy, float3(0.25,0.25,0.5)); + r3.z = 0.501960814 + r1.w; + r2.xyz = -r0.xyz * float3(0.5,0.5,0.5) + r3.xyz; + r1.xyz = r2.xyz / r1.xyz; + r1.y = max(abs(r1.y), abs(r1.z)); + r1.x = max(abs(r1.x), r1.y); + r1.yzw = r2.xyz / r1.xxx; + r1.x = cmp(1 < r1.x); + r0.xyz = r0.xyz * float3(0.5,0.5,0.5) + r1.yzw; + r0.xyz = r1.xxx ? r0.xyz : r3.xyz; + r0.yz = float2(-0.501960814,-0.501960814) + r0.yz; + r1.xy = r0.xx + r0.yz; + r1.xw = r1.xx + -r0.zz; + r0.y = r0.x + -r0.y; + r1.z = r0.y + -r0.z; + r1.xyzw = r1.xyzw + -r10.xyzx; + r0.xyzw = r0.wwww * r1.xyzw + r10.xyzx; + r0.xyzw = max(float4(0.00100000005,0.00100000005,0.00100000005,0.00100000005), r0.xyzw); + u0[vThreadID.xy] = r0.xyzw; + return; +} diff --git a/src/games/endfield/ssr/ssr-temporal2_0x7D50F458.cs_5_0.hlsl b/src/games/endfield/ssr/ssr-temporal2_0x7D50F458.cs_5_0.hlsl new file mode 100644 index 0000000000..bceab45d41 --- /dev/null +++ b/src/games/endfield/ssr/ssr-temporal2_0x7D50F458.cs_5_0.hlsl @@ -0,0 +1,396 @@ +#include "../shared.h" + +#ifdef SSR_FULL_TRACE_VARIANT +Texture2D t5 : register(t5); +#endif + +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +StructuredBuffer t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb2 : register(b2) +{ +#ifdef SSR_FULL_TRACE_VARIANT + float4 cb2[6]; +#else + float4 cb2[7]; +#endif +} + +cbuffer cb1 : register(b1) +{ + float4 cb1[3]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[65]; +} + +RWTexture2D u0 : register(u0); +RWTexture2D u1 : register(u1); +RWTexture2D u2 : register(u2); + + +#define cmp - + + +[numthreads(8, 8, 1)] +void main(uint3 vThreadGroupID : SV_GroupID, uint3 vThreadIDInGroup : SV_GroupThreadID) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13; + uint4 bitmask, uiDest; + float4 fDest; + +#ifdef SSR_FULL_TRACE_VARIANT + uint dispatch_index = vThreadGroupID.x; +#else + uint dispatch_index = (uint)cb2[6].z + vThreadGroupID.x; +#endif + uint packed_dispatch = t0[dispatch_index]; + uint2 packed_group = uint2(packed_dispatch >> 16, packed_dispatch & 0x0000ffff); + r0.xy = mad((int2)packed_group, int2(8,8), (int2)vThreadIDInGroup.xy); + r1.xy = (uint2)cb2[0].xy; + r1.xy = cmp((uint2)r0.xy >= (uint2)r1.xy); + r1.x = (int)r1.y | (int)r1.x; + if (r1.x == 0) { + r1.x = u2[(uint2)r0.xy].x; + r1.yz = (int2)r0.xy; + r1.yz = float2(0.5,0.5) + r1.yz; + r2.xy = cb2[0].zw * r1.yz; + r1.w = cmp(0.00100000005 < r1.x); + if (r1.w != 0) { +#ifdef SSR_FULL_TRACE_VARIANT + r2.zw = (uint2)r0.xy; + r2.zw = float2(0.5,0.5) + r2.zw; + r2.zw = cb2[0].zw * r2.zw; + bool use_full_trace = t4.SampleLevel(s0_s, r2.zw, 0).x > 0.5; + float low_trace_count = max(ceil(cb2[3].x * 0.125), 4.0f); + r1.w = use_full_trace ? cb2[3].x : low_trace_count; + if (shader_injection.improved_ssr >= 0.5f) { + r1.w = max(r1.w, use_full_trace ? 256.0f : 32.0f); + } +#else + r1.w = cb2[3].x * 0.125; + r1.w = ceil(r1.w); + r1.w = max(r1.w, (shader_injection.improved_ssr >= 0.5f) ? 32.0f : 4.0f); +#endif + r3.z = t2.SampleLevel(s0_s, r2.xy, 0).x; + r3.xy = r2.xy * float2(2,2) + float2(-1,-1); + r4.xyzw = cb0[13].xyzw * r3.yyyy; + r4.xyzw = cb0[12].xyzw * r3.xxxx + r4.xyzw; + r4.xyzw = cb0[14].xyzw * r3.zzzz + r4.xyzw; + r4.xyzw = cb0[15].xyzw + r4.xyzw; + r4.xyz = r4.xyz / r4.www; + r0.zw = float2(0,0); +#ifdef SSR_FULL_TRACE_VARIANT + r5.xyz = t5.Load(r0.xyz).xyz; +#else + r5.xyz = t4.Load(r0.xyz).xyz; +#endif + r0.zw = r5.xy * float2(2,2) + float2(-1,-1); + r2.z = dot(float2(1,1), abs(r0.zw)); + r6.y = 1 + -r2.z; + r2.z = cmp(r6.y < 0); + r5.xy = cmp(r0.zw >= float2(0,0)); + r7.xy = float2(1,1) + -abs(r0.wz); + r5.xy = r5.xy ? float2(1,1) : float2(-1,-1); + r5.xy = r7.xy * r5.xy; + r6.xz = r2.zz ? r5.xy : r0.zw; + r0.z = dot(r6.xyz, r6.xyz); + r0.z = rsqrt(r0.z); + r5.xyw = r6.xyz * r0.zzz; + r0.z = r5.z * r5.z; + r0.z = r0.z * r0.z; + r4.w = -r4.y; + r0.w = dot(r4.xzw, r4.xzw); + r0.w = rsqrt(r0.w); + r4.xyz = r4.xwz * r0.www; + r6.xyz = cb0[1].xyz * r5.yyy; + r6.xyz = cb0[0].xyz * r5.xxx + r6.xyz; + r6.xyz = cb0[2].xyz * r5.www + r6.xyz; + r0.w = dot(r4.xyz, r6.xyz); + r0.w = r0.w + r0.w; + r4.xyz = r6.xyz * -r0.www + r4.xyz; + r6.xyzw = cb0[9].xyzw * r4.yyyy; + r6.xyzw = cb0[8].xyzw * r4.xxxx + r6.xyzw; + r4.xyzw = cb0[10].xyzw * r4.zzzz + r6.xyzw; + r3.w = 1; + r4.xyzw = r4.xyzw * float4(1,-1,1,1) + r3.xyzw; + r4.xyz = r4.xyz / r4.www; + r4.xyz = r4.xyz + -r3.xyz; + r0.w = dot(r4.xy, r4.xy); + r0.w = sqrt(r0.w); + r2.z = 0.5 * r0.w; + r6.xy = r3.xy * r2.zz + r4.xy; + r6.xy = -r0.ww * float2(0.5,0.5) + abs(r6.xy); + r6.xy = max(float2(0,0), r6.xy); + r6.xy = r6.xy / abs(r4.xy); + r6.xy = float2(1,1) + -r6.xy; + r0.w = min(r6.x, r6.y); + r0.w = r0.w / r2.z; + r4.xyz = r4.xyz * r0.www; + r0.w = abs(r4.z) / r1.w; + r0.w = max(9.99999975e-005, r0.w); + r2.z = 1 / r1.w; + r4.xyz = float3(0.5,0.5,1) * r4.xyz; + r4.xyz = r4.xyz * r2.zzz; + r2.zw = cb2[0].xy * r4.xy; + r2.z = max(abs(r2.z), abs(r2.w)); + r2.w = cmp(r2.z < 1); + r2.z = 0.00100000005 + r2.z; + r2.z = 1 / r2.z; + r3.w = trunc(cb2[1].x); + r1.yz = r3.ww * float2(2.08299994,4.8670001) + r1.yz; + r1.y = dot(r1.yz, float2(0.0671105608,0.00583714992)); + r1.y = frac(r1.y); + r1.y = 52.9829178 * r1.y; + r1.y = frac(r1.y); + r1.y = r2.w ? r2.z : r1.y; + r6.xyz = r3.xyz * float3(0.5,0.5,1) + float3(0.5,0.5,0); + r6.xyz = r4.xyz * r1.yyy + r6.xyz; + r1.y = t2.SampleLevel(s0_s, r6.xy, 0).x; + r1.y = r6.z + -r1.y; + r7.xyz = float3(0,0,0); + r8.xyz = float3(0,0,0); + r9.xyz = r6.xyz; + r1.z = 0; + r2.z = 0; + r2.w = r1.y; + while (true) { + r3.w = cmp(r2.z < r1.w); + if (r3.w != 0) { + r10.xyzw = r4.xyxy * float4(1,1,2,2) + r9.xyxy; + r11.xyzw = r4.xyxy * float4(3,3,4,4) + r9.xyxy; + r12.xyzw = r4.zzzz * float4(1,2,3,4) + r9.zzzz; + r13.x = t2.SampleLevel(s0_s, r10.xy, 0).x; + r13.y = t2.SampleLevel(s0_s, r10.zw, 0).x; + r13.z = t2.SampleLevel(s0_s, r11.xy, 0).x; + r13.w = t2.SampleLevel(s0_s, r11.zw, 0).x; + r10.xyzw = -r13.xyzw + r12.xyzw; + r11.xyzw = r10.xyzw + r0.wwww; + r11.xyzw = cmp(abs(r11.xyzw) < r0.wwww); + r12.xy = (int2)r11.zw | (int2)r11.xy; + r3.w = (int)r12.y | (int)r12.x; + if (r3.w != 0) { + r12.xy = r11.zz ? r10.zy : r10.wz; + r10.yz = r11.yy ? r10.yx : r12.xy; + r3.w = r11.x ? r10.x : r10.y; + r4.w = r11.x ? r2.w : r10.z; + r5.z = r11.z ? 2 : 3; + r5.z = r11.y ? 1 : r5.z; + r5.z = r11.x ? 0 : r5.z; + r3.w = r4.w + -r3.w; + r3.w = saturate(r4.w / r3.w); + r3.w = r5.z + r3.w; + r10.xyz = r4.xyz * r3.www + r9.xyz; + r1.z = -1; + r8.xyz = r10.xyz; + break; + } + r9.xyz = r4.xyz * float3(4,4,4) + r9.xyz; + r2.z = 4 + r2.z; + r7.xyz = r9.xyz; + r1.z = 0; + r2.w = r10.w; + continue; + } else { + r8.xyz = r7.xyz; + r1.z = 0; + break; + } + r1.z = 0; + } + if (r1.z != 0) { + r0.w = max(r8.x, r8.y); + r0.w = 1 + -r0.w; + r1.y = min(r8.x, r8.y); + r0.w = min(r1.y, r0.w); + r1.y = cmp(cb2[1].y < r0.w); + r0.w = saturate(r0.w / cb2[1].y); + r0.w = r1.y ? 1 : r0.w; + r0.w = r1.x * r0.w; + r1.yz = t3.SampleLevel(s0_s, r8.xy, 0).xy; + r2.zw = abs(r1.yz) * float2(2,2) + float2(-1,-1); + r2.zw = r2.zw * r2.zw; + r2.zw = r2.zw * r2.zw; + r1.yz = float2(-0.5,-0.5) + r1.yz; + r4.xy = cmp(float2(0,0) < r1.yz); + r1.yz = cmp(r1.yz < float2(0,0)); + r1.yz = (int2)-r4.xy + (int2)r1.yz; + r1.yz = (int2)r1.yz; + r1.yz = r2.zw * r1.yz; + r1.w = -cb2[2].z + 1; + r2.zw = r1.yz * r1.ww; + r2.xy = -r1.yz * r1.ww + r8.xy; + r1.y = t1.SampleLevel(s0_s, r2.xy, 0).x; + r1.z = cmp(0 < r1.y); + r1.w = cmp(cb2[2].z < 0.5); + r1.z = r1.w ? r1.z : 0; + r4.xy = r2.xy * float2(2,2) + float2(-1,-1); + r6.xyzw = cb0[62].xyzw * -r4.yyyy; + r4.xyzw = cb0[61].xyzw * r4.xxxx + r6.xyzw; + r4.xyzw = cb0[63].xyzw * r1.yyyy + r4.xyzw; + r4.xyzw = cb0[64].xyzw + r4.xyzw; + r1.yw = r8.xy * float2(2,2) + float2(-1,-1); + r6.xyzw = cb0[25].xyzw * -r1.wwww; + r6.xyzw = cb0[24].xyzw * r1.yyyy + r6.xyzw; + r6.xyzw = cb0[26].xyzw * r8.zzzz + r6.xyzw; + r6.xyzw = cb0[27].xyzw + r6.xyzw; + r1.y = cb1[2].z * r8.z + cb1[2].w; + r1.y = 1 / r1.y; + r4.xyz = r4.xyz / r4.www; + r6.xyz = r6.xyz / r6.www; + r4.xyz = -r6.xyz + r4.xyz; + r1.w = dot(r4.xyz, r4.xyz); + r1.w = sqrt(r1.w); + r1.y = r1.y * r1.y; + r1.y = 0.00999999978 * r1.y; + r1.y = cmp(r1.y < r1.w); + r1.y = r1.y ? 0 : r0.w; + r1.x = r1.z ? r1.y : r0.w; + } else { + r2.zw = float2(0,0); + r1.x = 0; + } + r1.yz = t3.SampleLevel(s0_s, r2.xy, 0).xy; + r4.xy = abs(r1.yz) * float2(2,2) + float2(-1,-1); + r4.xy = r4.xy * r4.xy; + r0.w = 2 / r0.z; + r0.w = -1 + r0.w; + r0.w = 1 / r0.w; + r0.w = -2.03504682 * r0.w; + r0.w = exp2(r0.w); + r1.w = 1 + -r0.w; + r1.w = sqrt(r1.w); + r3.w = r0.w * -0.0187292993 + 0.0742610022; + r3.w = r3.w * r0.w + -0.212114394; + r0.w = r3.w * r0.w + 1.57072878; + r0.w = r0.w * r1.w; + r6.xyzw = cb0[25].xyzw * r3.yyyy; + r6.xyzw = cb0[24].xyzw * r3.xxxx + r6.xyzw; + r6.xyzw = cb0[26].xyzw * r3.zzzz + r6.xyzw; + r6.xyzw = cb0[27].xyzw + r6.xyzw; + r6.xyzw = r6.xyzw / r6.wwww; + r3.xy = r8.xy * float2(2,2) + float2(-1,-1); + r7.xyzw = cb0[25].xyzw * r3.yyyy; + r7.xyzw = cb0[24].xyzw * r3.xxxx + r7.xyzw; + r7.xyzw = cb0[26].xyzw * r8.zzzz + r7.xyzw; + r7.xyzw = cb0[27].xyzw + r7.xyzw; + r3.xyw = cb0[44].xyz + -r6.xyz; + r1.w = dot(r3.xyw, r3.xyw); + r4.z = rsqrt(r1.w); + r8.xyz = r4.zzz * r3.xyw; + r1.w = sqrt(r1.w); + r4.w = cmp(abs(r5.w) < 0.999000013); + r9.z = r4.w ? 0 : 1; + r9.y = r4.w ? 1.000000 : 0; + r9.x = 0; + r10.xyz = r9.xyz * r5.xyw; + r9.xyz = r9.zxy * r5.ywx + -r10.xyz; + r4.w = dot(r9.xyz, r9.xyz); + r4.w = rsqrt(r4.w); + r9.xyz = r9.xyz * r4.www; + r7.xyzw = r7.xyzw / r7.wwww; + r6.xyzw = r7.xyzw + -r6.xyzw; + r4.w = dot(r6.xyzw, r6.xyzw); + r4.w = sqrt(r4.w); + r6.xyz = r9.zxy * r8.xyz; + r6.xyz = r9.yzx * r8.yzx + -r6.xyz; + sincos(r0.w, r7.x, r10.x); + r7.yzw = -r8.xyz * r1.www + cb0[44].xyz; + r10.yzw = r9.xyz * r5.xyw; + r5.xyz = r5.wxy * r9.yzx + -r10.yzw; + r9.xyz = r5.xyz * r8.xyz; + r5.xyz = r5.zxy * r8.yzx + -r9.xyz; + r0.w = r4.w + r1.w; + r9.xyz = r8.xyz * r0.www; + r10.yzw = cb0[21].xyw * -r9.yyy; + r9.xyw = cb0[20].xyw * -r9.xxx + r10.yzw; + r9.xyz = cb0[22].xyw * -r9.zzz + r9.xyw; + r9.xyz = cb0[23].xyw + r9.xyz; + r9.xy = r9.xy / r9.zz; + r9.xy = r9.xy * float2(0.5,0.5) + float2(0.5,0.5); + r9.xy = cb2[0].xy * r9.xy; + r0.w = dot(r6.yzx, -r8.xyz); + r10.yzw = r6.yzx * r0.www; + r11.xyz = -r3.xyw * r4.zzz + -r10.yzw; + r10.yzw = r10.xxx * r11.xyz + r10.yzw; + r11.xyz = r6.xyz * -r8.yzx; + r6.xyz = r6.zxy * -r8.zxy + -r11.xyz; + r6.xyz = r6.xyz * r7.xxx + r10.yzw; + r6.xyz = r6.xyz * r4.www + r7.yzw; + r6.xyz = -cb0[44].xyz + r6.xyz; + r10.yzw = cb0[21].xyw * r6.yyy; + r6.xyw = cb0[20].xyw * r6.xxx + r10.yzw; + r6.xyz = cb0[22].xyw * r6.zzz + r6.xyw; + r6.xyz = cb0[23].xyw + r6.xyz; + r0.w = dot(r5.yzx, -r8.xyz); + r10.yzw = r5.yzx * r0.www; + r3.xyw = -r3.xyw * r4.zzz + -r10.yzw; + r3.xyw = r10.xxx * r3.xyw + r10.yzw; + r10.xyz = r5.xyz * -r8.yzx; + r5.xyz = r5.zxy * -r8.zxy + -r10.xyz; + r3.xyw = r5.xyz * r7.xxx + r3.xyw; + r3.xyw = r3.xyw * r4.www + r7.yzw; + r3.xyw = -cb0[44].xyz + r3.xyw; + r5.xyz = cb0[21].xyw * r3.yyy; + r5.xyz = cb0[20].xyw * r3.xxx + r5.xyz; + r3.xyw = cb0[22].xyw * r3.www + r5.xyz; + r3.xyw = cb0[23].xyw + r3.xyw; + r4.xy = r4.xy * r4.xy; + r1.yz = float2(-0.5,-0.5) + r1.yz; + r4.zw = cmp(float2(0,0) < r1.yz); + r1.yz = cmp(r1.yz < float2(0,0)); + r1.yz = (int2)-r4.zw + (int2)r1.yz; + r1.yz = (int2)r1.yz; + r1.yz = r4.xy * r1.yz + r2.zw; + r1.yz = cb1[0].xy * r1.yz; + r0.w = dot(r1.yz, r1.yz); + r0.w = sqrt(r0.w); + r1.y = cb1[2].z * r3.z + cb1[2].w; + r1.y = 0.0199999996 / r1.y; + r1.y = log2(r1.y); + r1.y = saturate(r1.y * 0.693147182 + 0.00999999978); + r0.w = r1.y * -r0.w; + r0.w = 1.44269502 * r0.w; + r4.x = exp2(r0.w); + r0.z = cmp(9.99999975e-005 >= r0.z); + r1.yz = r6.xy / r6.zz; + r1.yz = r1.yz * float2(0.5,0.5) + float2(0.5,0.5); + r1.yz = -r1.yz * cb2[0].xy + r9.xy; + r0.w = dot(r1.yz, r1.yz); + r1.yz = r3.xy / r3.ww; + r1.yz = r1.yz * float2(0.5,0.5) + float2(0.5,0.5); + r1.yz = -r1.yz * cb2[0].xy + r9.xy; + r1.y = dot(r1.yz, r1.yz); + r0.w = r1.y + r0.w; + r0.w = sqrt(r0.w); + r0.w = 0.5 * r0.w; + r0.w = log2(r0.w); + r0.w = max(0, r0.w); + r0.w = min(cb2[5].y, r0.w); + r0.w = r0.w / cb2[5].y; + r4.y = r0.z ? 0 : r0.w; + } else { + r4.xy = float2(0,0); + } + if (shader_injection.improved_ssr >= 0.5f) { + float mip_threshold = 0.25f; + r4.y = saturate((r4.y - mip_threshold) / (1.0f - mip_threshold)); + } + u0[(uint2)r0.xy] = r2.xyxx; + u1[(uint2)r0.xy] = r4.xyxx; + u2[(uint2)r0.xy] = r1.xxxx; + } + return; + // Approximately 0 instruction slots used +} diff --git a/src/games/endfield/ssr/ssr-temporal_0x3594373F.cs_5_0.hlsl b/src/games/endfield/ssr/ssr-temporal_0x3594373F.cs_5_0.hlsl new file mode 100644 index 0000000000..cad5af90f9 --- /dev/null +++ b/src/games/endfield/ssr/ssr-temporal_0x3594373F.cs_5_0.hlsl @@ -0,0 +1,2 @@ +#define SSR_FULL_TRACE_VARIANT +#include "ssr-temporal2_0x7D50F458.cs_5_0.hlsl" diff --git a/src/games/endfield/ssr/ssr-upsample_0x4ED659BE.cs_5_0.hlsl b/src/games/endfield/ssr/ssr-upsample_0x4ED659BE.cs_5_0.hlsl new file mode 100644 index 0000000000..2163c608dd --- /dev/null +++ b/src/games/endfield/ssr/ssr-upsample_0x4ED659BE.cs_5_0.hlsl @@ -0,0 +1,76 @@ + +#include "../shared.h" + +Texture2D t2 : register(t2); +Texture2D t1 : register(t1); +Texture2D t0 : register(t0); + +SamplerState s1_s : register(s1); +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[6]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[1]; +} + +RWTexture2D u0 : register(u0); + +#define cmp - + +[numthreads(8, 8, 1)] +void main(uint3 vThreadID : SV_DispatchThreadID) +{ + float4 r0, r1; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = (uint2)vThreadID.xy; + r0.xy = float2(0.5, 0.5) + r0.xy; + r0.xy = cb0[0].zw * r0.xy; + + // Sample sharp temporal color and apply inverse Reinhard + r1.xyz = t1.SampleLevel(s1_s, r0.xy, 0).xyz; + r0.z = max(r1.x, r1.y); + r0.z = max(r0.z, r1.z); + r0.z = 1 + -r0.z; + r0.z = 1 / r0.z; + r1.xyzw = r1.xyzx * r0.zzzz; + + // Read mip from filter weight texture + r0.z = t0.SampleLevel(s0_s, r0.xy, 0).y; + r0.z = cb1[5].y * r0.z; + + if (shader_injection.improved_ssr >= 0.5f) { + // Improved mode: fractional mip blending (ported from Miru's Vulkan mod) + if (r0.z < 0.25) { + // Low mip — use sharp temporal color directly + r0.xyzw = r1.xyzw; + } else { + // Blend between sharp and blurred based on fractional mip + float mip0 = floor(r0.z); + float fraction = saturate(r0.z - mip0); + float4 color_blurred = t2.SampleLevel(s1_s, r0.xy, 0).xyzx; + + if (mip0 == 0.0) { + // Fractional blend between sharp and blurred + r0.xyzw = lerp(r1.xyzw, color_blurred, fraction); + } else { + // High mip — use blurred resolve entirely + r0.xyzw = color_blurred; + } + } + } else { + // Vanilla mode: hard cutoff at mip 0.25 + r0.xyw = t2.SampleLevel(s1_s, r0.xy, 0).xyz; + r0.z = cmp(r0.z < 0.25); + r0.xyzw = r0.zzzz ? r1.xyzw : r0.xywx; + } + + u0[vThreadID.xy] = r0.xyzw; + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0x039C28DA.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x039C28DA.ps_5_0.hlsl deleted file mode 100644 index 5017846631..0000000000 --- a/src/games/endfield/uberpost/uberpost_0x039C28DA.ps_5_0.hlsl +++ /dev/null @@ -1,258 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:03:58 2026 -#include "../common.hlsl" - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[26]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb1[0].xy + v1.xy; - r0.z = dot(r0.xy, r0.xy); - r0.w = sqrt(r0.z); - r0.w = max(0.00999999978, r0.w); - r0.w = 1 / r0.w; - r1.x = cb1[0].w * 0.5; - r0.z = log2(r0.z); - r0.z = r1.x * r0.z; - r0.z = exp2(r0.z); - r0.xy = r0.xy * r0.zz; - r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; - r1.xyz = float3(1,0,0) * r1.xyz; - r0.z = cmp(3 < cb1[25].x); - if (r0.z != 0) { - r2.xy = cmp(float2(0,0) != cb1[25].wz); - r0.z = (int)r2.y | (int)r2.x; - r2.xy = r0.xy * r0.ww; - r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); - r4.xy = -r2.xy * r0.zz + v1.xy; - r4.xyz = t0.SampleLevel(s1_s, r4.xy, 0).xyz; - r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; - r0.z = r0.z + r0.z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; - r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; - r5.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r2.zw = -r2.xy * r2.zz + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; - r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; - r2.xy = -r2.xy * r0.zz + v1.xy; - r2.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; - r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; - r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; - r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; - r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; - } else { - r0.z = cmp(0.000000 != cb1[25].w); - r3.xy = r0.xy * r0.ww; - r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; - r0.zw = -r0.xy * r0.zz + v1.xy; - r3.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; - r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; - r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; - r0.xy = -r0.xy * r0.zz + v1.xy; - r0.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; - r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; - } - r0.xw = float2(0,0); - r0.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r0.xyzw; - r1.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r0.xyzw = v1.xyxy + -r0.zwxy; - r4.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; - r0.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; - r0.w = r1.x * 0.5 + r1.y; - r0.w = r1.z * 0.5 + r0.w; - r2.w = r4.x * 0.5 + r4.y; - r2.w = r4.z * 0.5 + r2.w; - r3.w = r2.x * 0.5 + r2.y; - r3.w = r2.z * 0.5 + r3.w; - r4.w = r3.x * 0.5 + r3.y; - r4.w = r3.z * 0.5 + r4.w; - r5.x = r0.x * 0.5 + r0.y; - r5.x = r0.z * 0.5 + r5.x; - r5.yzw = min(r4.xyz, r3.xyz); - r5.yzw = min(r5.yzw, r1.xyz); - r5.yzw = min(r5.yzw, r0.xyz); - r6.xyz = max(r4.xyz, r3.xyz); - r6.xyz = max(r6.xyz, r1.xyz); - r6.xyz = max(r6.xyz, r0.xyz); - r7.xyz = float3(0.25,0.25,0.25) / r6.xyz; - r7.xyz = r7.xyz * r5.yzw; - r6.xyz = float3(1,1,1) + -r6.xyz; - r5.yzw = r5.yzw * float3(4,4,4) + float3(-4,-4,-4); - r5.yzw = float3(1,1,1) / r5.yzw; - r5.yzw = r6.xyz * r5.yzw; - r5.yzw = max(-r7.xyz, r5.yzw); - r5.z = max(r5.z, r5.w); - r5.y = max(r5.y, r5.z); - r5.y = min(0, r5.y); - r5.y = max(-0.1875, r5.y); - r5.y = cb1[24].x * r5.y; - r5.z = r2.w + r0.w; - r5.z = r5.z + r4.w; - r5.z = r5.z + r5.x; - r5.z = r5.z * 0.25 + -r3.w; - r5.w = max(r3.w, r2.w); - r5.w = max(r5.w, r0.w); - r6.x = max(r5.x, r4.w); - r5.w = max(r6.x, r5.w); - r2.w = min(r3.w, r2.w); - r0.w = min(r2.w, r0.w); - r2.w = min(r5.x, r4.w); - r0.w = min(r2.w, r0.w); - r0.w = r5.w + -r0.w; - r0.w = 1 / r0.w; - r0.w = saturate(abs(r5.z) * r0.w); - r0.w = r0.w * -0.5 + 1; - r0.w = r5.y * r0.w; - r2.w = r0.w * 4 + 1; - r2.w = 1 / r2.w; - r5.xyz = t2.SampleLevel(s0_s, v1.xy, 0).xyz; - r1.xyz = r4.zxy + r1.zxy; - r0.xyz = r1.xyz + r0.zxy; - r0.xyz = r0.xyz + r3.zxy; - r0.xyz = r0.www * r0.xyz + r2.zxy; - r0.xyz = r0.xyz * r2.www; - r0.xyz = cb0[109].xxx * r0.xyz; - r0.w = saturate(cb1[3].x * 3 + -2); - r1.x = min(r5.x, r5.y); - r1.x = min(r1.x, r5.z); - r1.x = -0.200000003 + r1.x; - r1.x = cmp(r1.x >= 0); - r1.x = r1.x ? 1.000000 : 0; - r0.w = -cb1[3].x + r0.w; - r0.w = r1.x * r0.w + cb1[3].x; - r1.xyz = float3(-1,-1,-1) + r5.zxy; - r1.xyz = r0.www * r1.xyz + float3(1,1,1); - r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - /* Original Code - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); - r0.xyz = max(float3(0,0,0), r0.xyz); - r0.xyz = log2(r0.xyz); - r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); - r0.yzw = cb1[7].zzz * r0.xyz; - r0.y = floor(r0.y); - r1.xy = cb1[7].xy * float2(0.5,0.5); - r1.yz = r0.zw * cb1[7].xy + r1.xy; - r1.x = r0.y * cb1[7].y + r1.y; - r2.xyz = t1.SampleLevel(s1_s, r1.xz, 0).xyz; - r3.x = cb1[7].y; - r3.y = 0; - r0.zw = r3.xy + r1.xz; - r1.xyz = t1.SampleLevel(s1_s, r0.zw, 0).xyz; - r0.x = r0.x * cb1[7].z + -r0.y; - r0.yzw = r1.xyz + -r2.xyz; - r0.xyz = r0.xxx * r0.yzw + r2.xyz; - r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; - r2.xyz = log2(abs(r0.xyz)); - r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; - r2.xyz = exp2(r2.xyz); - r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); - r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); - r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; - r0.w = dot(float2(171,231), r1.xy); - r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; - r1.xyz = frac(r1.xyz); - r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t1, lut_config, r0.xyz); - - o0.xyz = renodx::draw::RenderIntermediatePass(renodx::draw::ToneMapPass(r0.yzx, graded)); - } - */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - o0.w = min(1, r1.w); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x086097D2.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x086097D2.ps_5_0.hlsl deleted file mode 100644 index 542a13beca..0000000000 --- a/src/games/endfield/uberpost/uberpost_0x086097D2.ps_5_0.hlsl +++ /dev/null @@ -1,200 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:03:59 2026 -#include "../common.hlsl" -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[26]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - const float4 icb[] = { { 0.500000, 0, 0, 0}, - { 1.000000, 0, 0, 0}, - { 1.500000, 0, 0, 0}, - { 2.000000, 0, 0, 0}, - { 2.500000, 0, 0, 0} }; - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb1[0].xy + v1.xy; - r0.z = dot(r0.xy, r0.xy); - r0.z = sqrt(r0.z); - r0.w = log2(r0.z); - r0.w = cb1[0].w * r0.w; - r0.w = exp2(r0.w); - r0.xy = r0.xy * r0.ww; - r0.z = max(0.00999999978, r0.z); - r0.z = 1 / r0.z; - r0.z = -1 + r0.z; - r0.z = cb1[25].z * r0.z + 1; - r0.xy = r0.xy * r0.zz; - r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r2.xyz = r1.xyz; - r0.z = 0; - while (true) { - r0.w = cmp((int)r0.z >= 5); - if (r0.w != 0) break; - r0.w = icb[r0.z+0].x * cb1[0].z; - r3.xy = -r0.xy * r0.ww + v1.xy; - r3.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r3.xyz = r3.xyz + r2.xyz; - r0.w = (int)r0.z + 1; - r2.xyz = r3.xyz; - r0.z = r0.w; - continue; - } - r0.xyzw = r2.xyzz; - r2.xw = float2(0,0); - r2.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r2.xyzw; - r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r2.xyzw = v1.xyxy + -r2.zwxy; - r4.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r2.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; - r2.w = r1.x * 0.5 + r1.y; - r2.w = r1.z * 0.5 + r2.w; - r3.w = r4.x * 0.5 + r4.y; - r3.w = r4.z * 0.5 + r3.w; - r5.xyz = float3(0.166666672,0.166666672,0.166666672) * r0.xyz; - r0.x = r0.x * 0.0833333358 + r5.y; - r0.x = r0.w * 0.0833333358 + r0.x; - r0.y = r3.x * 0.5 + r3.y; - r0.y = r3.z * 0.5 + r0.y; - r0.z = r2.x * 0.5 + r2.y; - r0.z = r2.z * 0.5 + r0.z; - r6.xyz = min(r4.xyz, r3.xyz); - r6.xyz = min(r6.xyz, r1.xyz); - r6.xyz = min(r6.xyz, r2.xyz); - r7.xyz = max(r4.xyz, r3.xyz); - r7.xyz = max(r7.xyz, r1.xyz); - r7.xyz = max(r7.xyz, r2.xyz); - r8.xyz = float3(0.25,0.25,0.25) / r7.xyz; - r8.xyz = r8.xyz * r6.xyz; - r7.xyz = float3(1,1,1) + -r7.xyz; - r6.xyz = r6.xyz * float3(4,4,4) + float3(-4,-4,-4); - r6.xyz = float3(1,1,1) / r6.xyz; - r6.xyz = r7.xyz * r6.xyz; - r6.xyz = max(-r8.xyz, r6.xyz); - r0.w = max(r6.y, r6.z); - r0.w = max(r6.x, r0.w); - r0.w = min(0, r0.w); - r0.w = max(-0.1875, r0.w); - r0.w = cb1[24].x * r0.w; - r4.w = r3.w + r2.w; - r4.w = r4.w + r0.y; - r4.w = r4.w + r0.z; - r4.w = r4.w * 0.25 + -r0.x; - r5.w = max(r3.w, r0.x); - r5.w = max(r5.w, r2.w); - r6.x = max(r0.y, r0.z); - r5.w = max(r6.x, r5.w); - r0.x = min(r3.w, r0.x); - r0.x = min(r2.w, r0.x); - r0.y = min(r0.y, r0.z); - r0.x = min(r0.x, r0.y); - r0.x = r5.w + -r0.x; - r0.x = 1 / r0.x; - r0.x = saturate(abs(r4.w) * r0.x); - r0.x = r0.x * -0.5 + 1; - r0.x = r0.w * r0.x; - r0.y = r0.x * 4 + 1; - r0.y = 1 / r0.y; - r0.zw = -cb1[1].xy + v1.xy; - r2.w = -cb1[2].x + 1; - r2.w = cb1[1].w * r2.w + cb1[2].x; - r0.zw = r2.ww * abs(r0.zw); - r2.w = saturate(cb1[2].x * 1.04999995); - r2.w = r2.w * 1.5 + -1; - r2.w = cb1[1].w * r2.w + 1; - r0.z = r2.w * r0.z; - r2.w = cb1[2].x * 2 + -1; - r2.w = cb1[1].w * r2.w + 1; - r3.w = saturate(cb1[2].x + -2.79999995); - r3.w = 5 * r3.w; - r6.y = saturate(r0.w * r2.w + r3.w); - r0.w = cb0[82].x / cb0[82].y; - r2.w = -1 + r0.w; - r2.w = cb1[2].w * r2.w + 1; - r0.w = r0.w * 0.5625 + -r2.w; - r0.w = cb1[1].w * r0.w + r2.w; - r6.x = saturate(r0.z * r0.w); - r0.zw = log2(r6.xy); - r0.zw = cb1[2].zz * r0.zw; - r0.zw = exp2(r0.zw); - r1.xyz = r4.zxy + r1.zxy; - r1.xyz = r1.xyz + r2.zxy; - r1.xyz = r1.xyz + r3.zxy; - r1.xyz = r0.xxx * r1.xyz + r5.zxy; - r1.xyz = r1.xyz * r0.yyy; - r1.xyz = cb0[109].xxx * r1.xyz; - r0.x = dot(r0.zw, r0.zw); - r0.x = 1 + -r0.x; - r0.x = max(0, r0.x); - r0.x = log2(r0.x); - r0.x = cb1[2].y * r0.x; - r0.x = exp2(r0.x); - float vignette_value = lerp(1.0, r0.x, VIGNETTE_STRENGTH); - r0.x = 1.0; // Disable original vignette, apply after tonemapping - r0.yzw = -cb1[4].zxy + float3(1,1,1); - r0.xyz = r0.xxx * r0.yzw + cb1[4].zxy; - r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - // Apply vignette after tonemapping - o0.xyz *= vignette_value; - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - o0.w = min(1, r1.w); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x86420EBC.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x0BB60C37.ps_5_0.hlsl similarity index 75% rename from src/games/endfield/uberpost/uberpost_0x86420EBC.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x0BB60C37.ps_5_0.hlsl index c7c6f5055c..789e8d592f 100644 --- a/src/games/endfield/uberpost/uberpost_0x86420EBC.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x0BB60C37.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Fri Jan 23 01:44:52 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t2 : register(t2); @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -66,7 +66,7 @@ void main( r0.z = r0.w; continue; } - r0.xyz = cb0[109].xxx * r2.xyz; + r0.xyz = cb0[27].xxx * r2.xyz; r1.xyz = float3(0.166666672,0.166666672,0.166666672) * r0.xyz; r2.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; @@ -92,8 +92,8 @@ void main( r2.xyz = r2.xyz * cb1[11].zxy + r5.xyz; r0.xyz = -r0.xyz * float3(0.166666672,0.166666672,0.166666672) + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; - /* r0.xyz = cb1[7].www * r0.xyz; + /* Original Code r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); r0.xyz = max(float3(0,0,0), r0.xyz); r0.xyz = log2(r0.xyz); @@ -118,36 +118,21 @@ void main( r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -159,4 +144,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x0E520F06.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x0E520F06.ps_5_0.hlsl deleted file mode 100644 index b5ce43fece..0000000000 --- a/src/games/endfield/uberpost/uberpost_0x0E520F06.ps_5_0.hlsl +++ /dev/null @@ -1,213 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:00 2026 -#include "../common.hlsl" -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[26]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - const float4 icb[] = { { 0.500000, 0, 0, 0}, - { 1.000000, 0, 0, 0}, - { 1.500000, 0, 0, 0}, - { 2.000000, 0, 0, 0}, - { 2.500000, 0, 0, 0} }; - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb1[0].xy + v1.xy; - r0.z = dot(r0.xy, r0.xy); - r0.z = sqrt(r0.z); - r0.w = log2(r0.z); - r0.w = cb1[0].w * r0.w; - r0.w = exp2(r0.w); - r0.xy = r0.xy * r0.ww; - r0.z = max(0.00999999978, r0.z); - r0.z = 1 / r0.z; - r0.z = -1 + r0.z; - r0.z = cb1[25].z * r0.z + 1; - r0.xy = r0.xy * r0.zz; - r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r2.xyz = r1.xyz; - r0.z = 0; - while (true) { - r0.w = cmp((int)r0.z >= 5); - if (r0.w != 0) break; - r0.w = icb[r0.z+0].x * cb1[0].z; - r3.xy = -r0.xy * r0.ww + v1.xy; - r3.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r3.xyz = r3.xyz + r2.xyz; - r0.w = (int)r0.z + 1; - r2.xyz = r3.xyz; - r0.z = r0.w; - continue; - } - r0.xyzw = r2.xyzz; - r2.xw = float2(0,0); - r2.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r2.xyzw; - r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r2.xyzw = v1.xyxy + -r2.zwxy; - r4.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r2.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; - r2.w = r1.x * 0.5 + r1.y; - r2.w = r1.z * 0.5 + r2.w; - r3.w = r4.x * 0.5 + r4.y; - r3.w = r4.z * 0.5 + r3.w; - r5.xyz = float3(0.166666672,0.166666672,0.166666672) * r0.xyz; - r0.x = r0.x * 0.0833333358 + r5.y; - r0.x = r0.w * 0.0833333358 + r0.x; - r0.y = r3.x * 0.5 + r3.y; - r0.y = r3.z * 0.5 + r0.y; - r0.z = r2.x * 0.5 + r2.y; - r0.z = r2.z * 0.5 + r0.z; - r6.xyz = min(r4.xyz, r3.xyz); - r6.xyz = min(r6.xyz, r1.xyz); - r6.xyz = min(r6.xyz, r2.xyz); - r7.xyz = max(r4.xyz, r3.xyz); - r7.xyz = max(r7.xyz, r1.xyz); - r7.xyz = max(r7.xyz, r2.xyz); - r8.xyz = float3(0.25,0.25,0.25) / r7.xyz; - r8.xyz = r8.xyz * r6.xyz; - r7.xyz = float3(1,1,1) + -r7.xyz; - r6.xyz = r6.xyz * float3(4,4,4) + float3(-4,-4,-4); - r6.xyz = float3(1,1,1) / r6.xyz; - r6.xyz = r7.xyz * r6.xyz; - r6.xyz = max(-r8.xyz, r6.xyz); - r0.w = max(r6.y, r6.z); - r0.w = max(r6.x, r0.w); - r0.w = min(0, r0.w); - r0.w = max(-0.1875, r0.w); - r0.w = cb1[24].x * r0.w; - r4.w = r3.w + r2.w; - r4.w = r4.w + r0.y; - r4.w = r4.w + r0.z; - r4.w = r4.w * 0.25 + -r0.x; - r5.w = max(r3.w, r0.x); - r5.w = max(r5.w, r2.w); - r6.x = max(r0.y, r0.z); - r5.w = max(r6.x, r5.w); - r0.x = min(r3.w, r0.x); - r0.x = min(r2.w, r0.x); - r0.y = min(r0.y, r0.z); - r0.x = min(r0.x, r0.y); - r0.x = r5.w + -r0.x; - r0.x = 1 / r0.x; - r0.x = saturate(abs(r4.w) * r0.x); - r0.x = r0.x * -0.5 + 1; - r0.x = r0.w * r0.x; - r0.y = r0.x * 4 + 1; - r0.y = 1 / r0.y; - r1.xyz = r4.zxy + r1.zxy; - r1.xyz = r1.xyz + r2.zxy; - r1.xyz = r1.xyz + r3.zxy; - r0.xzw = r0.xxx * r1.xyz + r5.zxy; - r0.xyz = r0.xzw * r0.yyy; - r0.xyz = cb0[109].xxx * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - /* Original Code - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); - r0.xyz = max(float3(0,0,0), r0.xyz); - r0.xyz = log2(r0.xyz); - r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); - r0.yzw = cb1[7].zzz * r0.xyz; - r0.y = floor(r0.y); - r1.xy = cb1[7].xy * float2(0.5,0.5); - r1.yz = r0.zw * cb1[7].xy + r1.xy; - r1.x = r0.y * cb1[7].y + r1.y; - r2.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; - r3.x = cb1[7].y; - r3.y = 0; - r0.zw = r3.xy + r1.xz; - r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; - r0.x = r0.x * cb1[7].z + -r0.y; - r0.yzw = r1.xyz + -r2.xyz; - r0.xyz = r0.xxx * r0.yzw + r2.xyz; - r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; - r2.xyz = log2(abs(r0.xyz)); - r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; - r2.xyz = exp2(r2.xyz); - r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); - r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); - r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; - r0.w = dot(float2(171,231), r1.xy); - r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; - r1.xyz = frac(r1.xyz); - r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491, 0.0013725491, 0.0013725491) + r0.xyz; - - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - o0.xyz = renodx::draw::ToneMapPass(r0.yzx, graded); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - } - */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - o0.w = min(1, r1.w); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x1E0C02EC.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x1E0C02EC.ps_5_0.hlsl new file mode 100644 index 0000000000..8236f7905c --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0x1E0C02EC.ps_5_0.hlsl @@ -0,0 +1,205 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t4 : register(t4); + +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s2_s : register(s2); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[27]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + const float4 icb[] = { { 0.500000, 0, 0, 0}, + { 1.000000, 0, 0, 0}, + { 1.500000, 0, 0, 0}, + { 2.000000, 0, 0, 0}, + { 2.500000, 0, 0, 0} }; + float4 r0,r1,r2,r3,r4,r5; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyzw = t0.SampleLevel(s2_s, v1.xy, 0).xyzw; + r1.xy = -cb1[0].xy + v1.xy; + r1.z = dot(r1.xy, r1.xy); + r1.z = sqrt(r1.z); + r1.w = log2(r1.z); + r1.w = cb1[0].w * r1.w; + r1.w = exp2(r1.w); + r1.xy = r1.xy * r1.ww; + r1.z = max(0.00999999978, r1.z); + r1.z = 1 / r1.z; + r1.z = -1 + r1.z; + r1.z = cb1[25].z * r1.z + 1; + r1.xy = r1.xy * r1.zz; + r2.xyz = r0.zxy; + r1.z = 0; + while (true) { + r1.w = cmp((int)r1.z >= 5); + if (r1.w != 0) break; + r1.w = icb[r1.z+0].x * cb1[0].z; + r3.xy = -r1.xy * r1.ww + v1.xy; + r3.xyz = t0.SampleLevel(s2_s, r3.xy, 0).xyz; + r3.xyz = r3.xyz + r2.yzx; + r1.w = (int)r1.z + 1; + r2.xyz = r3.zxy; + r1.z = r1.w; + continue; + } + r0.xyz = float3(0.166666672,0.166666672,0.166666672) * r2.xyz; + r1.xyzw = t1.SampleLevel(s2_s, v1.xy, 0).xyzw; + r2.w = -cb1[9].z + 1; + r3.xyz = r2.www * r1.zxy; + r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); + r4.xyz = log2(r1.zxy); + r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); + r2.w = max(r0.y, r0.z); + r2.w = max(r2.w, r0.x); + r5.xy = -cb1[10].yx + r2.ww; + r3.w = max(0, r5.x); + r3.w = min(cb1[10].z, r3.w); + r3.w = r3.w * r3.w; + r3.w = cb1[10].w * r3.w; + r3.w = max(r3.w, r5.y); + r2.w = max(9.99999975e-005, r2.w); + r2.w = r3.w / r2.w; + r5.xyz = r2.www * r0.xyz; + r5.xyz = -r5.xyz * cb1[9].zzz + r0.xyz; + r1.xyz = r3.xyz ? r4.xyz : r1.zxy; + r1.xyz = r1.xyz * cb1[11].zxy + r5.xyz; + r1.xyz = -r2.xyz * float3(0.166666672,0.166666672,0.166666672) + r1.xyz; + r0.xyz = cb1[9].xxx * r1.xyz + r0.xyz; + o0.w = saturate(r1.w + r0.w); + r0.w = cb1[16].z + cb1[16].x; + r1.x = dot(cb1[16].xx, cb1[16].zz); + r0.w = -r1.x + r0.w; + r1.xy = -cb1[17].xy + v1.xy; + r1.zw = float2(-0.5,-0.5) + r1.xy; + r2.x = r1.z / r1.w; + r2.y = cmp(abs(r2.x) < 1); + r2.z = 1 / abs(r2.x); + r2.z = r2.y ? abs(r2.x) : r2.z; + r2.w = r2.z * r2.z; + r3.x = r2.w * 0.0872929022 + -0.301894993; + r2.w = r3.x * r2.w + 1; + r3.x = r2.w * r2.z; + r2.z = -r2.w * r2.z + 1.57079637; + r2.y = r2.y ? r3.x : r2.z; + r2.x = cmp(r2.x < 0); + r2.x = r2.x ? -r2.y : r2.y; + r2.y = cmp(r1.z >= 0); + r2.y = r2.y ? 3.1415925 : -3.1415925; + r2.z = cmp(r1.w < 0); + r2.z = r2.z ? 1.000000 : 0; + r2.x = r2.y * r2.z + r2.x; + r2.x = 3.14159274 + r2.x; + r2.x = 0.159154937 * r2.x; + r1.z = dot(r1.zw, r1.zw); + r1.z = sqrt(r1.z); + r2.y = r1.z + r1.z; + r1.zw = r2.xy * cb1[18].xy + cb1[18].zw; + r1.zw = cb1[17].zw * cb0[20].yy + r1.zw; + r1.z = t3.SampleBias(s0_s, r1.zw, cb0[26].x).x; + r1.z = r1.z * r0.y; + r1.w = cb1[20].y * r0.y; + r1.z = saturate(r1.z * cb1[20].x + r1.w); + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r3.xyz = cb1[7].zzz * r0.xyz; + r0.y = floor(r3.x); + r2.zw = cb1[7].xy * float2(0.5,0.5); + r3.yz = r3.yz * cb1[7].xy + r2.zw; + r3.x = r0.y * cb1[7].y + r3.y; + r4.xyz = t2.SampleLevel(s2_s, r3.xz, 0).xyz; + r5.x = cb1[7].y; + r5.y = 0; + r2.zw = r5.xy + r3.xz; + r3.xyz = t2.SampleLevel(s2_s, r2.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r3.xyz = r3.xyz + -r4.xyz; + r0.xyz = r0.xxx * r3.xyz + r4.xyz; + r3.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r4.xyz = log2(abs(r0.xyz)); + r4.xyz = float3(0.416666657,0.416666657,0.416666657) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + */ + LUTSampleResult lut_sample = LUTSAMPLE(s2_s, cb1[7].xyz, t2, r0.yzx); + float3 graded_linear; + [branch] + if (shader_injection.tone_map_type == 0.f) { + graded_linear = SDRGRADE(lut_sample); + } else { + graded_linear = HDRGRADE(lut_sample); + } + float3 graded_encoded = renodx::color::srgb::EncodeSafe(graded_linear); + r1.w = 1 + -r0.w; + r1.w = -cb1[16].y + r1.w; + r0.w = -cb1[16].y + r0.w; + r2.z = -r1.z * cb1[20].z + r1.z; + r2.w = -cb1[16].w + 1; + r1.xy = r2.ww * r1.xy; + r1.xy = r2.xy * cb1[16].ww + r1.xy; + r1.xy = r1.xy * cb1[19].xy + cb1[19].zw; + r1.x = t4.SampleBias(s1_s, r1.xy, cb0[26].x).x; + r1.x = r1.z * r1.x; + r1.x = r1.x * cb1[20].z + r2.z; + r0.w = r0.w + -r1.w; + r1.x = r1.x + -r1.w; + r0.w = 1 / r0.w; + r0.w = saturate(r1.x * r0.w); + r1.x = r0.w * -2 + 3; + r0.w = r0.w * r0.w; + r1.y = r1.x * r0.w; + r0.xyz = graded_encoded; + r0.w = -r1.x * r0.w + 1; + r1.xzw = cb1[22].xyz * r0.www; + r1.xyz = cb1[21].xyz * r1.yyy + r1.xzw; + r1.xyz = r1.xyz + -r0.xyz; + o0.xyz = cb1[20].www * r1.xyz + r0.xyz; + o0.xyz = renodx::color::srgb::DecodeSafe(o0.xyz); + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + return; +} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0xF8FA587F.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x22696E6B.ps_5_0.hlsl similarity index 67% rename from src/games/endfield/uberpost/uberpost_0xF8FA587F.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x22696E6B.ps_5_0.hlsl index b6c5791e20..f2499bab29 100644 --- a/src/games/endfield/uberpost/uberpost_0xF8FA587F.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x22696E6B.ps_5_0.hlsl @@ -13,7 +13,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -36,7 +36,7 @@ void main( r1.x = r0.x * 0.5 + r0.y; r1.x = r0.z * 0.5 + r1.x; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + -r2.zwxy; r2.xyzw = v1.xyxy + r2.xyzw; r1.yzw = t0.SampleLevel(s0_s, r3.xy, 0).xyz; @@ -93,31 +93,14 @@ void main( r1.x = r1.x * 4 + 1; r1.x = 1 / r1.x; r0.xyz = r1.xxx * r0.xyz; - r0.xyz = cb0[109].xxx * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - + r0.xyz = cb0[27].xxx * r0.xyz; + r0.xyz = cb1[7].www * r0.xyz; + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t1, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( o0.xyz, @@ -127,4 +110,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r0.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x9790A50C.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x231F3B6B.ps_5_0.hlsl similarity index 74% rename from src/games/endfield/uberpost/uberpost_0x9790A50C.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x231F3B6B.ps_5_0.hlsl index 2c9390cd29..67c0b6c6ac 100644 --- a/src/games/endfield/uberpost/uberpost_0x9790A50C.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x231F3B6B.ps_5_0.hlsl @@ -1,7 +1,5 @@ -// ---- Created with 3Dmigoto v1.3.16 on Fri Jan 23 01:44:52 2026 - +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" - Texture2D t3 : register(t3); Texture2D t2 : register(t2); @@ -21,7 +19,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -40,11 +38,10 @@ void main( uint4 bitmask, uiDest; float4 fDest; - r0.x = cb0[82].x / cb0[82].y; - r0.y = -1 + r0.x; - r0.y = cb1[2].w * r0.y + 1; - r0.x = r0.x * 0.5625 + -r0.y; - r0.x = cb1[1].w * r0.x + r0.y; + r0.x = cb0[27].z + -1; + r0.x = cb1[2].w * r0.x + 1; + r0.y = cb0[27].z * 0.5625 + -r0.x; + r0.x = cb1[1].w * r0.y + r0.x; r0.y = saturate(cb1[2].x * 1.04999995); r0.y = r0.y * 1.5 + -1; r0.y = cb1[1].w * r0.y + 1; @@ -82,7 +79,7 @@ void main( r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); r1.xyz = r3.xyz ? r2.xyz : r1.zxy; r2.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; - r3.xyz = cb0[109].xxx * r2.zxy; + r3.xyz = cb0[27].xxx * r2.zxy; r0.w = max(r3.y, r3.z); r0.w = max(r0.w, r3.x); r4.xy = -cb1[10].yx + r0.ww; @@ -96,7 +93,7 @@ void main( r4.xyz = r3.xyz * r0.www; r4.xyz = -r4.xyz * cb1[9].zzz + r3.xyz; r1.xyz = r1.xyz * cb1[11].zxy + r4.xyz; - r1.xyz = -r2.zxy * cb0[109].xxx + r1.xyz; + r1.xyz = -r2.zxy * cb0[27].xxx + r1.xyz; o0.w = min(1, r2.w); r1.xyz = cb1[9].xxx * r1.xyz + r3.xyz; r2.xyz = t3.SampleLevel(s0_s, v1.xy, 0).xyz; @@ -112,8 +109,8 @@ void main( r2.xyz = r0.www * r2.xyz + float3(1,1,1); r1.xyz = r2.xyz * r1.xyz; r0.xyz = r1.xyz * r0.xyz; - /* r0.xyz = cb1[7].www * r0.xyz; + /* Original Code r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); r0.xyz = max(float3(0,0,0), r0.xyz); r0.xyz = log2(r0.xyz); @@ -138,36 +135,20 @@ void main( r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r2.xyz : r1.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + return; */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -180,4 +161,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x2729B430.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x2729B430.ps_5_0.hlsl new file mode 100644 index 0000000000..690789fb89 --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0x2729B430.ps_5_0.hlsl @@ -0,0 +1,228 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[28]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1,r2,r3,r4,r5,r6,r7; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = -cb1[0].xy + v1.xy; + r0.z = dot(r0.xy, r0.xy); + r0.w = sqrt(r0.z); + r0.w = max(0.00999999978, r0.w); + r0.w = 1 / r0.w; + r1.x = cb1[0].w * 0.5; + r0.z = log2(r0.z); + r0.z = r1.x * r0.z; + r0.z = exp2(r0.z); + r0.xy = r0.xy * r0.zz; + r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; + r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; + r0.z = cmp(3 < cb1[25].x); + if (r0.z != 0) { + r2.xy = cmp(float2(0,0) != cb1[25].wz); + r0.z = (int)r2.y | (int)r2.x; + r2.xy = r0.xy * r0.ww; + r2.xy = r0.zz ? r2.xy : r0.xy; + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); + r4.xy = -r2.xy * r0.zz + v1.xy; + r4.xyz = t0.SampleLevel(s1_s, r4.xy, 0).xyz; + r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; + r0.z = r0.z + r0.z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; + r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; + r5.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r2.zw = -r2.xy * r2.zz + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; + r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; + r2.xy = -r2.xy * r0.zz + v1.xy; + r2.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; + r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; + r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; + r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; + r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; + } else { + r0.z = cmp(0.000000 != cb1[25].w); + r3.xy = r0.xy * r0.ww; + r0.xy = r0.zz ? r3.xy : r0.xy; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r0.zw = -r0.xy * r0.zz + v1.xy; + r3.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; + r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; + r0.z = cb1[0].z + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; + r0.xy = -r0.xy * r0.zz + v1.xy; + r0.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; + r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; + } + r0.xyz = cb0[27].xxx * r2.zxy; + r1.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; + r0.w = -cb1[9].z + 1; + r3.xyz = r1.zxy * r0.www; + r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); + r4.xyz = log2(r1.zxy); + r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); + r0.w = max(r0.y, r0.z); + r0.w = max(r0.w, r0.x); + r5.xy = -cb1[10].yx + r0.ww; + r2.w = max(0, r5.x); + r2.w = min(cb1[10].z, r2.w); + r5.xzw = t3.SampleLevel(s0_s, v1.xy, 0).xyz; + r6.xy = -cb1[1].xy + v1.xy; + r3.w = -cb1[2].x + 1; + r3.w = cb1[1].w * r3.w + cb1[2].x; + r6.xy = abs(r6.xy) * r3.ww; + r3.w = saturate(cb1[2].x * 1.04999995); + r3.w = r3.w * 1.5 + -1; + r3.w = cb1[1].w * r3.w + 1; + r3.w = r6.x * r3.w; + r4.w = cb1[2].x * 2 + -1; + r4.w = cb1[1].w * r4.w + 1; + r6.x = saturate(cb1[2].x + -2.79999995); + r6.x = 5 * r6.x; + r6.y = saturate(r6.y * r4.w + r6.x); + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r6.z = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r6.z + r4.w; + r6.x = saturate(r4.w * r3.w); + r6.xy = log2(r6.xy); + r6.xy = cb1[2].zz * r6.xy; + r6.xy = exp2(r6.xy); + r2.w = r2.w * r2.w; + r2.w = cb1[10].w * r2.w; + r2.w = max(r2.w, r5.y); + r0.w = max(9.99999975e-005, r0.w); + r0.w = r2.w / r0.w; + r7.xyz = r0.xyz * r0.www; + r7.xyz = -r7.xyz * cb1[9].zzz + r0.xyz; + r1.xyz = r3.xyz ? r4.xyz : r1.zxy; + r1.xyz = r1.xyz * cb1[11].zxy + r7.xyz; + r1.xyz = -r2.zxy * cb0[27].xxx + r1.xyz; + r0.xyz = cb1[9].xxx * r1.xyz + r0.xyz; + r0.w = saturate(cb1[3].x * 3 + -2); + r1.x = min(r5.x, r5.z); + r1.x = min(r1.x, r5.w); + r1.x = -0.200000003 + r1.x; + r1.x = cmp(r1.x >= 0); + r1.x = r1.x ? 1.000000 : 0; + r0.w = -cb1[3].x + r0.w; + r0.w = r1.x * r0.w + cb1[3].x; + r1.xyz = float3(-1,-1,-1) + r5.wxz; + r1.xyz = r0.www * r1.xyz + float3(1,1,1); + r0.xyz = r1.xyz * r0.xyz; + r0.w = dot(r6.xy, r6.xy); + r0.w = 1 + -r0.w; + r0.w = max(0, r0.w); + r0.w = log2(r0.w); + r0.w = cb1[2].y * r0.w; + r0.w = exp2(r0.w); + float vignette_value = lerp(1.0, r0.w, VIGNETTE_STRENGTH); + r0.w = 1.0; // Disable original vignette, apply after tonemapping + r1.xyz = -cb1[4].zxy + float3(1,1,1); + r1.xyz = r0.www * r1.xyz + cb1[4].zxy; + r0.xyz = r1.xyz * r0.xyz; + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t2.SampleLevel(s1_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t2.SampleLevel(s1_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); + [branch] + if (shader_injection.tone_map_type == 0.f) { + o0.xyz = SDRGRADE(lut_sample); + } else { + o0.xyz = HDRGRADE(lut_sample); + } + // Apply vignette after tonemapping + o0.xyz *= vignette_value; + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.w = min(1, r1.w); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0xA6501734.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x2970B6A6.ps_5_0.hlsl similarity index 61% rename from src/games/endfield/uberpost/uberpost_0xA6501734.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x2970B6A6.ps_5_0.hlsl index 923bda04c1..8d3dea670b 100644 --- a/src/games/endfield/uberpost/uberpost_0xA6501734.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x2970B6A6.ps_5_0.hlsl @@ -14,7 +14,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } #define cmp - @@ -28,11 +28,10 @@ void main( uint4 bitmask, uiDest; float4 fDest; - r0.x = cb0[82].x / cb0[82].y; - r0.y = -1 + r0.x; - r0.y = cb1[2].w * r0.y + 1; - r0.x = r0.x * 0.5625 + -r0.y; - r0.x = cb1[1].w * r0.x + r0.y; + r0.x = cb0[27].z + -1; + r0.x = cb1[2].w * r0.x + 1; + r0.y = cb0[27].z * 0.5625 + -r0.x; + r0.x = cb1[1].w * r0.y + r0.x; r0.y = saturate(cb1[2].x * 1.04999995); r0.y = r0.y * 1.5 + -1; r0.y = cb1[1].w * r0.y + 1; @@ -72,35 +71,18 @@ void main( r0.w = r0.w * r1.w + cb1[3].x; r1.xyz = r0.www * r1.xyz + float3(1,1,1); r2.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; - r2.xyz = cb0[109].xxx * r2.zxy; + r2.xyz = cb0[27].xxx * r2.zxy; o0.w = min(1, r2.w); r1.xyz = r2.xyz * r1.xyz; r0.xyz = r1.xyz * r0.xyz; r0.xyz = cb1[7].www * r0.xyz; - - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - + + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t1, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -113,4 +95,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x21241B7A.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x29EA566F.ps_5_0.hlsl similarity index 69% rename from src/games/endfield/uberpost/uberpost_0x21241B7A.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x29EA566F.ps_5_0.hlsl index 1493b24d61..5112cc5279 100644 --- a/src/games/endfield/uberpost/uberpost_0x21241B7A.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x29EA566F.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Wed Jan 21 21:30:43 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t2 : register(t2); @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -66,7 +66,7 @@ void main( r0.z = r0.w; continue; } - r0.xyz = cb0[109].xxx * r2.xyz; + r0.xyz = cb0[27].xxx * r2.xyz; r1.xyz = float3(0.166666672,0.166666672,0.166666672) * r0.xyz; r2.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; @@ -94,11 +94,10 @@ void main( r5.x = saturate(cb1[2].x + -2.79999995); r5.x = 5 * r5.x; r6.y = saturate(r5.z * r4.w + r5.x); - r4.w = cb0[82].x / cb0[82].y; - r5.x = -1 + r4.w; - r5.x = cb1[2].w * r5.x + 1; - r4.w = r4.w * 0.5625 + -r5.x; - r4.w = cb1[1].w * r4.w + r5.x; + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r5.x = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r5.x + r4.w; r6.x = saturate(r4.w * r3.w); r5.xz = log2(r6.xy); r5.xz = cb1[2].zz * r5.xz; @@ -127,9 +126,7 @@ void main( r0.xyz = r1.xyz * r0.xyz; r0.xyz = cb1[7].www * r0.xyz; /* Original Code - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); r0.xyz = max(float3(0,0,0), r0.xyz); r0.xyz = log2(r0.xyz); r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); @@ -153,49 +150,21 @@ void main( r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491, 0.0013725491, 0.0013725491) + r0.xyz; - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - o0.xyz = renodx::draw::ToneMapPass(r0.yzx, graded); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - } + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -209,4 +178,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xA6E6ABE6.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x2AD9D42E.ps_5_0.hlsl similarity index 72% rename from src/games/endfield/uberpost/uberpost_0xA6E6ABE6.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x2AD9D42E.ps_5_0.hlsl index b1abcfa6b8..5524d6285c 100644 --- a/src/games/endfield/uberpost/uberpost_0xA6E6ABE6.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x2AD9D42E.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:24 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t3 : register(t3); @@ -19,7 +19,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -50,15 +50,16 @@ void main( r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; r0.z = cmp(3 < cb1[25].x); if (r0.z != 0) { r2.xy = cmp(float2(0,0) != cb1[25].wz); r0.z = (int)r2.y | (int)r2.x; r2.xy = r0.xy * r0.ww; r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); r4.xy = -r2.xy * r0.zz + v1.xy; r4.xyz = t0.SampleLevel(s1_s, r4.xy, 0).xyz; r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; @@ -66,10 +67,10 @@ void main( r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; @@ -80,7 +81,7 @@ void main( r2.zw = -r2.xy * r2.zz + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; r2.xy = -r2.xy * r0.zz + v1.xy; r2.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; @@ -91,18 +92,18 @@ void main( r0.z = cmp(0.000000 != cb1[25].w); r3.xy = r0.xy * r0.ww; r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r0.zw = -r0.xy * r0.zz + v1.xy; r3.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; r0.xy = -r0.xy * r0.zz + v1.xy; r0.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; } r0.xw = float2(0,0); - r0.yz = cb0[82].wz; + r0.yz = cb0[0].wz; r3.xyzw = v1.xyxy + r0.xyzw; r1.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; r0.xyzw = v1.xyxy + -r0.zwxy; @@ -161,7 +162,7 @@ void main( r0.xyz = r0.xyz + r3.zxy; r0.xyz = r0.www * r0.xyz + r2.zxy; r0.xyz = r0.xyz * r2.www; - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r2.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -185,7 +186,7 @@ void main( r6.xyz = -r6.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r6.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.w = saturate(cb1[3].x * 3 + -2); r1.x = min(r5.x, r5.z); @@ -198,30 +199,47 @@ void main( r1.xyz = float3(-1,-1,-1) + r5.wxz; r1.xyz = r0.www * r1.xyz + float3(1,1,1); r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t2.SampleLevel(s1_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t2.SampleLevel(s1_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -233,4 +251,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x32A5505C.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x32A5505C.ps_5_0.hlsl new file mode 100644 index 0000000000..e0063d7eb0 --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0x32A5505C.ps_5_0.hlsl @@ -0,0 +1,120 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[28]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + const float4 icb[] = { { 0.500000, 0, 0, 0}, + { 1.000000, 0, 0, 0}, + { 1.500000, 0, 0, 0}, + { 2.000000, 0, 0, 0}, + { 2.500000, 0, 0, 0} }; + float4 r0,r1,r2,r3; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = -cb1[0].xy + v1.xy; + r0.z = dot(r0.xy, r0.xy); + r0.z = sqrt(r0.z); + r0.w = log2(r0.z); + r0.w = cb1[0].w * r0.w; + r0.w = exp2(r0.w); + r0.xy = r0.xy * r0.ww; + r0.z = max(0.00999999978, r0.z); + r0.z = 1 / r0.z; + r0.z = -1 + r0.z; + r0.z = cb1[25].z * r0.z + 1; + r0.xy = r0.xy * r0.zz; + r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; + r2.xyz = r1.zxy; + r0.z = 0; + while (true) { + r0.w = cmp((int)r0.z >= 5); + if (r0.w != 0) break; + r0.w = icb[r0.z+0].x * cb1[0].z; + r3.xy = -r0.xy * r0.ww + v1.xy; + r3.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; + r3.xyz = r3.xyz + r2.yzx; + r0.w = (int)r0.z + 1; + r2.xyz = r3.zxy; + r0.z = r0.w; + continue; + } + r0.xyz = cb0[27].xxx * r2.xyz; + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(0.92592597,0.92592597,0.92592597) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t1, r0.yzx * (1.f / 6.f)); + [branch] + if (shader_injection.tone_map_type == 0.f) { + o0.xyz = SDRGRADE(lut_sample); + } else { + o0.xyz = HDRGRADE(lut_sample); + } + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.w = min(1, r1.w); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0x00C16AFB.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x332E0835.ps_5_0.hlsl similarity index 80% rename from src/games/endfield/uberpost/uberpost_0x00C16AFB.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x332E0835.ps_5_0.hlsl index 84dc9d6af2..6eaa46f4ac 100644 --- a/src/games/endfield/uberpost/uberpost_0x00C16AFB.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x332E0835.ps_5_0.hlsl @@ -18,7 +18,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -41,7 +41,7 @@ void main( r1.x = r0.x * 0.5 + r0.y; r1.x = r0.z * 0.5 + r1.x; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + -r2.zwxy; r2.xyzw = v1.xyxy + r2.xyzw; r1.yzw = t0.SampleLevel(s1_s, r3.xy, 0).xyz; @@ -98,7 +98,7 @@ void main( r1.x = r1.x * 4 + 1; r1.x = 1 / r1.x; r0.xyz = r1.xxx * r0.xyz; - r0.xyz = cb0[109].xxx * r0.xyz; + r0.xyz = cb0[27].xxx * r0.xyz; o0.w = min(1, r0.w); r1.xyz = t2.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = min(r1.x, r1.y); @@ -112,11 +112,10 @@ void main( r0.w = r0.w * r1.w + cb1[3].x; r1.xyz = r0.www * r1.xyz + float3(1,1,1); r0.xyz = r1.xyz * r0.xyz; - r0.w = cb0[82].x / cb0[82].y; - r1.x = -1 + r0.w; - r1.x = cb1[2].w * r1.x + 1; - r0.w = r0.w * 0.5625 + -r1.x; - r0.w = cb1[1].w * r0.w + r1.x; + r0.w = cb0[27].z + -1; + r0.w = cb1[2].w * r0.w + 1; + r1.x = cb0[27].z * 0.5625 + -r0.w; + r0.w = cb1[1].w * r1.x + r0.w; r1.x = saturate(cb1[2].x * 1.04999995); r1.x = r1.x * 1.5 + -1; r1.x = cb1[1].w * r1.x + 1; @@ -173,13 +172,13 @@ void main( r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r2.xyz : r1.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; - + } else { renodx::lut::Config lut_config = renodx::lut::config::Create( s1_s, @@ -194,29 +193,12 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); } */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t1, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -229,4 +211,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x52A77DB9.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x52A77DB9.ps_5_0.hlsl new file mode 100644 index 0000000000..b8375266f4 --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0x52A77DB9.ps_5_0.hlsl @@ -0,0 +1,153 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb0 : register(b0) +{ + float4 cb0[26]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + const float4 icb[] = { { 0.500000, 0, 0, 0}, + { 1.000000, 0, 0, 0}, + { 1.500000, 0, 0, 0}, + { 2.000000, 0, 0, 0}, + { 2.500000, 0, 0, 0} }; + float4 r0,r1,r2,r3,r4,r5; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; + r1.xy = -cb0[0].xy + v1.xy; + r1.z = dot(r1.xy, r1.xy); + r1.z = sqrt(r1.z); + r1.w = log2(r1.z); + r1.w = cb0[0].w * r1.w; + r1.w = exp2(r1.w); + r1.xy = r1.xy * r1.ww; + r1.z = max(0.00999999978, r1.z); + r1.z = 1 / r1.z; + r1.z = -1 + r1.z; + r1.z = cb0[25].z * r1.z + 1; + r1.xy = r1.xy * r1.zz; + r2.xyz = r0.zxy; + r1.z = 0; + while (true) { + r1.w = cmp((int)r1.z >= 5); + if (r1.w != 0) break; + r1.w = icb[r1.z+0].x * cb0[0].z; + r3.xy = -r1.xy * r1.ww + v1.xy; + r3.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; + r3.xyz = r3.xyz + r2.yzx; + r1.w = (int)r1.z + 1; + r2.xyz = r3.zxy; + r1.z = r1.w; + continue; + } + r0.xyz = float3(0.166666672,0.166666672,0.166666672) * r2.xyz; + r1.xyzw = t1.SampleLevel(s0_s, v1.xy, 0).xyzw; + r2.w = -cb0[9].z + 1; + r3.xyz = r2.www * r1.zxy; + r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); + r4.xyz = log2(r1.zxy); + r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); + r2.w = max(r0.y, r0.z); + r2.w = max(r2.w, r0.x); + r5.xy = -cb0[10].yx + r2.ww; + r3.w = max(0, r5.x); + r3.w = min(cb0[10].z, r3.w); + r3.w = r3.w * r3.w; + r3.w = cb0[10].w * r3.w; + r3.w = max(r3.w, r5.y); + r2.w = max(9.99999975e-005, r2.w); + r2.w = r3.w / r2.w; + r5.xyz = r2.www * r0.xyz; + r5.xyz = -r5.xyz * cb0[9].zzz + r0.xyz; + r1.xyz = r3.xyz ? r4.xyz : r1.zxy; + r1.xyz = r1.xyz * cb0[11].zxy + r5.xyz; + r1.xyz = -r2.xyz * float3(0.166666672,0.166666672,0.166666672) + r1.xyz; + r0.xyz = cb0[9].xxx * r1.xyz + r0.xyz; + o0.w = saturate(r1.w + r0.w); + r0.w = cb0[16].z + cb0[16].x; + r1.x = dot(cb0[16].xx, cb0[16].zz); + r0.w = -r1.x + r0.w; + r1.xyz = cb0[7].www * r0.xyz; + /* Original Code + r1.xyz = r1.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r1.xyz = max(float3(0,0,0), r1.xyz); + r1.xyz = log2(r1.xyz); + r1.xyz = saturate(r1.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r1.yzw = cb0[7].zzz * r1.xyz; + r0.x = floor(r1.y); + r2.xy = cb0[7].xy * float2(0.5,0.5); + r2.yz = r1.zw * cb0[7].xy + r2.xy; + r2.x = r0.x * cb0[7].y + r2.y; + r1.yzw = t2.SampleLevel(s0_s, r2.xz, 0).xyz; + r3.x = cb0[7].y; + r3.y = 0; + r2.xy = r3.xy + r2.xz; + r2.xyz = t2.SampleLevel(s0_s, r2.xy, 0).xyz; + r0.x = r1.x * cb0[7].z + -r0.x; + r2.xyz = r2.xyz + -r1.yzw; + r1.xyz = r0.xxx * r2.xyz + r1.yzw; + r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r1.xyz; + r3.xyz = log2(abs(r1.xyz)); + r3.xyz = float3(0.416666657,0.416666657,0.416666657) * r3.xyz; + r3.xyz = exp2(r3.xyz); + r3.xyz = r3.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r1.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r1.xyz); + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb0[7].xyz, t2, r1.yzx); + float3 graded_linear; + [branch] + if (shader_injection.tone_map_type == 0.f) { + graded_linear = SDRGRADE(lut_sample); + } else { + graded_linear = HDRGRADE(lut_sample); + } + float3 graded_encoded = renodx::color::srgb::EncodeSafe(graded_linear); + r0.x = 1 + -r0.w; + r0.xz = -cb0[16].yy + r0.xw; + r0.z = r0.z + -r0.x; + r0.x = r0.y + -r0.x; + r0.y = 1 / r0.z; + r0.x = saturate(r0.x * r0.y); + r0.y = r0.x * -2 + 3; + r0.x = r0.x * r0.x; + r0.z = r0.y * r0.x; + r1.xyz = graded_encoded; + r0.x = -r0.y * r0.x + 1; + r0.xyw = cb0[22].xyz * r0.xxx; + r0.xyz = cb0[21].xyz * r0.zzz + r0.xyw; + r0.xyz = r0.xyz + -r1.xyz; + o0.xyz = cb0[20].www * r0.xyz + r1.xyz; + o0.xyz = renodx::color::srgb::DecodeSafe(o0.xyz); + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0x6A76C719.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x52AC7E00.ps_5_0.hlsl similarity index 73% rename from src/games/endfield/uberpost/uberpost_0x6A76C719.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x52AC7E00.ps_5_0.hlsl index 2bc6e6ea61..a012ab1fb9 100644 --- a/src/games/endfield/uberpost/uberpost_0x6A76C719.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x52AC7E00.ps_5_0.hlsl @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -38,7 +38,7 @@ void main( r1.x = r0.x * 0.5 + r0.y; r1.x = r0.z * 0.5 + r1.x; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + -r2.zwxy; r2.xyzw = v1.xyxy + r2.xyzw; r1.yzw = t0.SampleLevel(s0_s, r3.xy, 0).xyz; @@ -96,7 +96,7 @@ void main( r1.x = 1 / r1.x; r0.xyz = r1.xxx * r0.xyz; o0.w = min(1, r0.w); - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r0.w = max(r1.y, r1.z); r0.w = max(r0.w, r1.x); r2.xy = -cb1[10].yx + r0.ww; @@ -119,33 +119,16 @@ void main( r5.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r5.xyz); r3.xyz = r5.xyz ? r4.xyz : r3.zxy; r2.xyz = r3.xyz * cb1[11].zxy + r2.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.xyz = cb1[7].www * r0.xyz; - - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -156,4 +139,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x53875523.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x53875523.ps_5_0.hlsl deleted file mode 100644 index 5425472b9a..0000000000 --- a/src/games/endfield/uberpost/uberpost_0x53875523.ps_5_0.hlsl +++ /dev/null @@ -1,216 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:10 2026 -#include "../common.hlsl" - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[25]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r1.x = r0.x * 0.5 + r0.y; - r1.x = r0.z * 0.5 + r1.x; - r2.xw = float2(0,0); - r2.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + -r2.zwxy; - r2.xyzw = v1.xyxy + r2.xyzw; - r1.yzw = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r3.w = r1.y * 0.5 + r1.z; - r3.w = r1.w * 0.5 + r3.w; - r4.x = max(r3.w, r1.x); - r4.yzw = t0.SampleLevel(s0_s, r2.xy, 0).xyz; - r2.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; - r2.w = r4.y * 0.5 + r4.z; - r2.w = r4.w * 0.5 + r2.w; - r4.x = max(r2.w, r4.x); - r5.x = r2.x * 0.5 + r2.y; - r5.x = r2.z * 0.5 + r5.x; - r5.y = r3.x * 0.5 + r3.y; - r5.y = r3.z * 0.5 + r5.y; - r5.z = max(r5.x, r5.y); - r4.x = max(r5.z, r4.x); - r5.z = min(r3.w, r1.x); - r3.w = r2.w + r3.w; - r2.w = min(r5.z, r2.w); - r3.w = r3.w + r5.x; - r5.x = min(r5.x, r5.y); - r3.w = r3.w + r5.y; - r1.x = r3.w * 0.25 + -r1.x; - r2.w = min(r5.x, r2.w); - r2.w = r4.x + -r2.w; - r2.w = 1 / r2.w; - r1.x = saturate(r2.w * abs(r1.x)); - r1.x = r1.x * -0.5 + 1; - r5.xyz = max(r2.xyz, r1.yzw); - r5.xyz = max(r5.xyz, r4.yzw); - r5.xyz = max(r5.xyz, r3.xyz); - r6.xyz = float3(0.25,0.25,0.25) / r5.xyz; - r5.xyz = float3(1,1,1) + -r5.xyz; - r7.xyz = min(r2.xyz, r1.yzw); - r1.yzw = r4.wyz + r1.wyz; - r4.xyz = min(r7.xyz, r4.yzw); - r4.xyz = min(r4.xyz, r3.xyz); - r1.yzw = r1.yzw + r3.zxy; - r1.yzw = r1.yzw + r2.zxy; - r2.xyz = r4.xyz * r6.xyz; - r3.xyz = r4.xyz * float3(4,4,4) + float3(-4,-4,-4); - r3.xyz = float3(1,1,1) / r3.xyz; - r3.xyz = r5.xyz * r3.xyz; - r2.xyz = max(r3.xyz, -r2.xyz); - r2.y = max(r2.y, r2.z); - r2.x = max(r2.x, r2.y); - r2.x = min(0, r2.x); - r2.x = max(-0.1875, r2.x); - r2.x = cb1[24].x * r2.x; - r1.x = r2.x * r1.x; - r0.xyz = r1.xxx * r1.yzw + r0.zxy; - r1.x = r1.x * 4 + 1; - r1.x = 1 / r1.x; - r0.xyz = r1.xxx * r0.xyz; - r0.xyz = cb0[109].xxx * r0.xyz; - o0.w = min(1, r0.w); - r0.w = cb0[82].x / cb0[82].y; - r1.x = -1 + r0.w; - r1.x = cb1[2].w * r1.x + 1; - r0.w = r0.w * 0.5625 + -r1.x; - r0.w = cb1[1].w * r0.w + r1.x; - r1.x = saturate(cb1[2].x * 1.04999995); - r1.x = r1.x * 1.5 + -1; - r1.x = cb1[1].w * r1.x + 1; - r1.y = -cb1[2].x + 1; - r1.y = cb1[1].w * r1.y + cb1[2].x; - r1.zw = -cb1[1].xy + v1.xy; - r1.yz = abs(r1.zw) * r1.yy; - r1.x = r1.y * r1.x; - r1.x = saturate(r1.x * r0.w); - r0.w = cb1[2].x * 2 + -1; - r0.w = cb1[1].w * r0.w + 1; - r1.w = saturate(cb1[2].x + -2.79999995); - r1.w = 5 * r1.w; - r1.y = saturate(r1.z * r0.w + r1.w); - r1.xy = log2(r1.xy); - r1.xy = cb1[2].zz * r1.xy; - r1.xy = exp2(r1.xy); - r0.w = dot(r1.xy, r1.xy); - r0.w = 1 + -r0.w; - r0.w = max(0, r0.w); - r0.w = log2(r0.w); - r0.w = cb1[2].y * r0.w; - r0.w = exp2(r0.w); - float vignette_value = lerp(1.0, r0.w, VIGNETTE_STRENGTH); - r0.w = 1.0; // Disable original vignette, apply after tonemapping - r1.xyz = -cb1[4].zxy + float3(1,1,1); - r1.xyz = r0.www * r1.xyz + cb1[4].zxy; - r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - - /* Original Code - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); - r0.xyz = max(float3(0,0,0), r0.xyz); - r0.xyz = log2(r0.xyz); - r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); - r0.yzw = cb1[7].zzz * r0.xyz; - r0.y = floor(r0.y); - r0.x = r0.x * cb1[7].z + -r0.y; - r1.xy = cb1[7].xy * float2(0.5,0.5); - r1.yz = r0.zw * cb1[7].xy + r1.xy; - r1.x = r0.y * cb1[7].y + r1.y; - r2.x = cb1[7].y; - r2.y = 0; - r0.yz = r2.xy + r1.xz; - r1.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; - r0.yzw = t1.SampleLevel(s0_s, r0.yz, 0).xyz; - r0.yzw = r0.yzw + -r1.xyz; - r0.xyz = r0.xxx * r0.yzw + r1.xyz; - r1.xyz = log2(abs(r0.xyz)); - r1.xyz = float3(0.416666657,0.416666657,0.416666657) * r1.xyz; - r1.xyz = exp2(r1.xyz); - r1.xyz = r1.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); - r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; - r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); - r0.xyz = r0.xyz ? r2.xyz : r1.xyz; - r1.xy = cb0[82].xy * v1.xy; - r0.w = dot(float2(171,231), r1.xy); - r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; - r1.xyz = frac(r1.xyz); - r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - o0.xyz = renodx::draw::ToneMapPass(r0.yzx, graded); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - } - */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - // Apply vignette after tonemapping - o0.xyz *= vignette_value; - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x53D50BD5.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x53D50BD5.ps_5_0.hlsl deleted file mode 100644 index 55da2c3fdd..0000000000 --- a/src/games/endfield/uberpost/uberpost_0x53D50BD5.ps_5_0.hlsl +++ /dev/null @@ -1,325 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:10 2026 -#include "../common.hlsl" -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[26]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb1[0].xy + v1.xy; - r0.z = dot(r0.xy, r0.xy); - r0.w = sqrt(r0.z); - r0.w = max(0.00999999978, r0.w); - r0.w = 1 / r0.w; - r1.x = cb1[0].w * 0.5; - r0.z = log2(r0.z); - r0.z = r1.x * r0.z; - r0.z = exp2(r0.z); - r0.xy = r0.xy * r0.zz; - r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; - r1.xyz = float3(1,0,0) * r1.xyz; - r0.z = cmp(3 < cb1[25].x); - if (r0.z != 0) { - r2.xy = cmp(float2(0,0) != cb1[25].wz); - r0.z = (int)r2.y | (int)r2.x; - r2.xy = r0.xy * r0.ww; - r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); - r4.xy = -r2.xy * r0.zz + v1.xy; - r4.xyz = t0.SampleLevel(s1_s, r4.xy, 0).xyz; - r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; - r0.z = r0.z + r0.z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; - r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; - r5.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r2.zw = -r2.xy * r2.zz + v1.xy; - r5.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; - r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; - r2.xy = -r2.xy * r0.zz + v1.xy; - r2.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; - r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; - r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; - r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; - r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; - } else { - r0.z = cmp(0.000000 != cb1[25].w); - r3.xy = r0.xy * r0.ww; - r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; - r0.zw = -r0.xy * r0.zz + v1.xy; - r3.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; - r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; - r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; - r0.xy = -r0.xy * r0.zz + v1.xy; - r0.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; - r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; - } - r0.xw = float2(0,0); - r0.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r0.xyzw; - r1.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r0.xyzw = v1.xyxy + -r0.zwxy; - r4.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; - r0.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; - r0.w = r1.x * 0.5 + r1.y; - r0.w = r1.z * 0.5 + r0.w; - r2.w = r4.x * 0.5 + r4.y; - r2.w = r4.z * 0.5 + r2.w; - r3.w = r2.x * 0.5 + r2.y; - r3.w = r2.z * 0.5 + r3.w; - r4.w = r3.x * 0.5 + r3.y; - r4.w = r3.z * 0.5 + r4.w; - r5.x = r0.x * 0.5 + r0.y; - r5.x = r0.z * 0.5 + r5.x; - r5.yzw = min(r4.xyz, r3.xyz); - r5.yzw = min(r5.yzw, r1.xyz); - r5.yzw = min(r5.yzw, r0.xyz); - r6.xyz = max(r4.xyz, r3.xyz); - r6.xyz = max(r6.xyz, r1.xyz); - r6.xyz = max(r6.xyz, r0.xyz); - r7.xyz = float3(0.25,0.25,0.25) / r6.xyz; - r7.xyz = r7.xyz * r5.yzw; - r6.xyz = float3(1,1,1) + -r6.xyz; - r5.yzw = r5.yzw * float3(4,4,4) + float3(-4,-4,-4); - r5.yzw = float3(1,1,1) / r5.yzw; - r5.yzw = r6.xyz * r5.yzw; - r5.yzw = max(-r7.xyz, r5.yzw); - r5.z = max(r5.z, r5.w); - r5.y = max(r5.y, r5.z); - r5.y = min(0, r5.y); - r5.y = max(-0.1875, r5.y); - r5.y = cb1[24].x * r5.y; - r5.z = r2.w + r0.w; - r5.z = r5.z + r4.w; - r5.z = r5.z + r5.x; - r5.z = r5.z * 0.25 + -r3.w; - r5.w = max(r3.w, r2.w); - r5.w = max(r5.w, r0.w); - r6.x = max(r5.x, r4.w); - r5.w = max(r6.x, r5.w); - r2.w = min(r3.w, r2.w); - r0.w = min(r2.w, r0.w); - r2.w = min(r5.x, r4.w); - r0.w = min(r2.w, r0.w); - r0.w = r5.w + -r0.w; - r0.w = 1 / r0.w; - r0.w = saturate(abs(r5.z) * r0.w); - r0.w = r0.w * -0.5 + 1; - r0.w = r5.y * r0.w; - r2.w = r0.w * 4 + 1; - r2.w = 1 / r2.w; - r1.xyz = r4.zxy + r1.zxy; - r0.xyz = r1.xyz + r0.zxy; - r0.xyz = r0.xyz + r3.zxy; - r0.xyz = r0.www * r0.xyz + r2.zxy; - r0.xyz = r0.xyz * r2.www; - r1.xyz = cb0[109].xxx * r0.xyz; - r2.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; - r0.w = -cb1[9].z + 1; - r3.xyz = r2.zxy * r0.www; - r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); - r4.xyz = log2(r2.zxy); - r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; - r4.xyz = exp2(r4.xyz); - r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); - r0.w = max(r1.y, r1.z); - r0.w = max(r0.w, r1.x); - r5.xy = -cb1[10].yx + r0.ww; - r2.w = max(0, r5.x); - r2.w = min(cb1[10].z, r2.w); - r5.xz = -cb1[1].xy + v1.xy; - r3.w = -cb1[2].x + 1; - r3.w = cb1[1].w * r3.w + cb1[2].x; - r5.xz = abs(r5.xz) * r3.ww; - r3.w = saturate(cb1[2].x * 1.04999995); - r3.w = r3.w * 1.5 + -1; - r3.w = cb1[1].w * r3.w + 1; - r3.w = r5.x * r3.w; - r4.w = cb1[2].x * 2 + -1; - r4.w = cb1[1].w * r4.w + 1; - r5.x = saturate(cb1[2].x + -2.79999995); - r5.x = 5 * r5.x; - r6.y = saturate(r5.z * r4.w + r5.x); - r4.w = cb0[82].x / cb0[82].y; - r5.x = -1 + r4.w; - r5.x = cb1[2].w * r5.x + 1; - r4.w = r4.w * 0.5625 + -r5.x; - r4.w = cb1[1].w * r4.w + r5.x; - r6.x = saturate(r4.w * r3.w); - r5.xz = log2(r6.xy); - r5.xz = cb1[2].zz * r5.xz; - r5.xz = exp2(r5.xz); - r2.w = r2.w * r2.w; - r2.w = cb1[10].w * r2.w; - r2.w = max(r2.w, r5.y); - r0.w = max(9.99999975e-005, r0.w); - r0.w = r2.w / r0.w; - r6.xyz = r1.xyz * r0.www; - r6.xyz = -r6.xyz * cb1[9].zzz + r1.xyz; - r2.xyz = r3.xyz ? r4.xyz : r2.zxy; - r2.xyz = r2.xyz * cb1[11].zxy + r6.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; - r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; - r0.w = dot(r5.xz, r5.xz); - r0.w = 1 + -r0.w; - r0.w = max(0, r0.w); - r0.w = log2(r0.w); - r0.w = cb1[2].y * r0.w; - r0.w = exp2(r0.w); - float vignette_value = lerp(1.0, r0.w, VIGNETTE_STRENGTH); - r0.w = 1.0; // Disable original vignette, apply after tonemapping - r1.xyz = -cb1[4].zxy + float3(1,1,1); - r1.xyz = r0.www * r1.xyz + cb1[4].zxy; - r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - /* Original Code - o0.w = min(1, r1.w); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582, 5.55555582, 5.55555582) + float3(0.0479959995, 0.0479959995, 0.0479959995); - r0.xyz = max(float3(0, 0, 0), r0.xyz); - r0.xyz = log2(r0.xyz); - r0.xyz = saturate(r0.xyz * float3(0.0734997839, 0.0734997839, 0.0734997839) + float3(0.386036009, 0.386036009, 0.386036009)); - r0.yzw = cb1[7].zzz * r0.xyz; - r0.y = floor(r0.y); - r1.xy = cb1[7].xy * float2(0.5, 0.5); - r1.yz = r0.zw * cb1[7].xy + r1.xy; - r1.x = r0.y * cb1[7].y + r1.y; - r2.xyz = t2.SampleLevel(s1_s, r1.xz, 0).xyz; - r3.x = cb1[7].y; - r3.yw = float2(0, 0); - r0.zw = r3.xy + r1.xz; - r1.xyz = t2.SampleLevel(s1_s, r0.zw, 0).xyz; - r0.x = r0.x * cb1[7].z + -r0.y; - r0.yzw = r1.xyz + -r2.xyz; - r0.xyz = r0.xxx * r0.yzw + r2.xyz; - - r1.xyz = float3(12.9200001, 12.9200001, 12.9200001) * r0.xyz; - r2.xyz = log2(abs(r0.xyz)); - r2.xyz = float3(0.416666657, 0.416666657, 0.416666657) * r2.xyz; - r2.xyz = exp2(r2.xyz); - r2.xyz = r2.xyz * float3(1.05499995, 1.05499995, 1.05499995) + float3(-0.0549999997, -0.0549999997, -0.0549999997); - r0.xyz = cmp(float3(0.00313080009, 0.00313080009, 0.00313080009) >= r0.xyz); - r0.xyz = saturate(r0.xyz ? r1.xyz : r2.xyz); - - r1.xyz = cb1[8].zzz * r0.zxy; - r0.w = floor(r1.x); - r2.xy = cb1[8].xy * float2(0.5, 0.5); - r1.yz = r1.yz * cb1[8].xy + r2.xy; - r1.x = r0.w * cb1[8].y + r1.y; - r2.xyz = t3.SampleLevel(s0_s, r1.xz, 0).xyz; - r3.z = cb1[8].y; - r1.xy = r1.xz + r3.zw; - r1.xyz = t3.SampleLevel(s0_s, r1.xy, 0).xyz; - r0.w = r0.z * cb1[8].z + -r0.w; - r1.xyz = r1.xyz + -r2.xyz; - r1.xyz = r0.www * r1.xyz + r2.xyz; - r1.xyz = r1.xyz + -r0.xyz; - r0.xyz = cb1[8].www * r1.xyz + r0.xyz; - - r1.xy = cb0[82].xy * v1.xy; - r0.w = dot(float2(171, 231), r1.xy); - r1.xyz = float3(0.00970873795, 0.0140845068, 0.010309278) * r0.www; - r1.xyz = frac(r1.xyz); - r1.xyz = float3(-0.5, -0.5, -0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491, 0.0013725491, 0.0013725491) + r0.xyz; - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - o0.xyz = renodx::draw::ToneMapPass(r0.yzx, graded); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - } - */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - // Apply vignette after tonemapping - o0.xyz *= vignette_value; - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - o0.w = min(1, r1.w); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x6166487A.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x6166487A.ps_5_0.hlsl deleted file mode 100644 index fdbba0cbb0..0000000000 --- a/src/games/endfield/uberpost/uberpost_0x6166487A.ps_5_0.hlsl +++ /dev/null @@ -1,278 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:12 2026 -#include "../common.hlsl" -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[26]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb1[0].xy + v1.xy; - r0.z = dot(r0.xy, r0.xy); - r0.w = sqrt(r0.z); - r0.w = max(0.00999999978, r0.w); - r0.w = 1 / r0.w; - r1.x = cb1[0].w * 0.5; - r0.z = log2(r0.z); - r0.z = r1.x * r0.z; - r0.z = exp2(r0.z); - r0.xy = r0.xy * r0.zz; - r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r1.xyz = float3(1,0,0) * r1.xyz; - r0.z = cmp(3 < cb1[25].x); - if (r0.z != 0) { - r2.xy = cmp(float2(0,0) != cb1[25].wz); - r0.z = (int)r2.y | (int)r2.x; - r2.xy = r0.xy * r0.ww; - r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); - r4.xy = -r2.xy * r0.zz + v1.xy; - r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; - r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; - r0.z = r0.z + r0.z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; - r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; - r5.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r2.zw = -r2.xy * r2.zz + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; - r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; - r2.xy = -r2.xy * r0.zz + v1.xy; - r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; - r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; - r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; - } else { - r0.z = cmp(0.000000 != cb1[25].w); - r3.xy = r0.xy * r0.ww; - r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; - r0.zw = -r0.xy * r0.zz + v1.xy; - r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; - r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; - r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; - r0.xy = -r0.xy * r0.zz + v1.xy; - r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; - r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; - } - r0.xw = float2(0,0); - r0.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r0.xyzw; - r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r0.xyzw = v1.xyxy + -r0.zwxy; - r4.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r0.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; - r0.w = r1.x * 0.5 + r1.y; - r0.w = r1.z * 0.5 + r0.w; - r2.w = r4.x * 0.5 + r4.y; - r2.w = r4.z * 0.5 + r2.w; - r3.w = r2.x * 0.5 + r2.y; - r3.w = r2.z * 0.5 + r3.w; - r4.w = r3.x * 0.5 + r3.y; - r4.w = r3.z * 0.5 + r4.w; - r5.x = r0.x * 0.5 + r0.y; - r5.x = r0.z * 0.5 + r5.x; - r5.yzw = min(r4.xyz, r3.xyz); - r5.yzw = min(r5.yzw, r1.xyz); - r5.yzw = min(r5.yzw, r0.xyz); - r6.xyz = max(r4.xyz, r3.xyz); - r6.xyz = max(r6.xyz, r1.xyz); - r6.xyz = max(r6.xyz, r0.xyz); - r7.xyz = float3(0.25,0.25,0.25) / r6.xyz; - r7.xyz = r7.xyz * r5.yzw; - r6.xyz = float3(1,1,1) + -r6.xyz; - r5.yzw = r5.yzw * float3(4,4,4) + float3(-4,-4,-4); - r5.yzw = float3(1,1,1) / r5.yzw; - r5.yzw = r6.xyz * r5.yzw; - r5.yzw = max(-r7.xyz, r5.yzw); - r5.z = max(r5.z, r5.w); - r5.y = max(r5.y, r5.z); - r5.y = min(0, r5.y); - r5.y = max(-0.1875, r5.y); - r5.y = cb1[24].x * r5.y; - r5.z = r2.w + r0.w; - r5.z = r5.z + r4.w; - r5.z = r5.z + r5.x; - r5.z = r5.z * 0.25 + -r3.w; - r5.w = max(r3.w, r2.w); - r5.w = max(r5.w, r0.w); - r6.x = max(r5.x, r4.w); - r5.w = max(r6.x, r5.w); - r2.w = min(r3.w, r2.w); - r0.w = min(r2.w, r0.w); - r2.w = min(r5.x, r4.w); - r0.w = min(r2.w, r0.w); - r0.w = r5.w + -r0.w; - r0.w = 1 / r0.w; - r0.w = saturate(abs(r5.z) * r0.w); - r0.w = r0.w * -0.5 + 1; - r0.w = r5.y * r0.w; - r2.w = r0.w * 4 + 1; - r2.w = 1 / r2.w; - r5.xy = -cb1[1].xy + v1.xy; - r3.w = -cb1[2].x + 1; - r3.w = cb1[1].w * r3.w + cb1[2].x; - r5.xy = abs(r5.xy) * r3.ww; - r3.w = saturate(cb1[2].x * 1.04999995); - r3.w = r3.w * 1.5 + -1; - r3.w = cb1[1].w * r3.w + 1; - r3.w = r5.x * r3.w; - r4.w = cb1[2].x * 2 + -1; - r4.w = cb1[1].w * r4.w + 1; - r5.x = saturate(cb1[2].x + -2.79999995); - r5.x = 5 * r5.x; - r5.y = saturate(r5.y * r4.w + r5.x); - r4.w = cb0[82].x / cb0[82].y; - r5.z = -1 + r4.w; - r5.z = cb1[2].w * r5.z + 1; - r4.w = r4.w * 0.5625 + -r5.z; - r4.w = cb1[1].w * r4.w + r5.z; - r5.x = saturate(r4.w * r3.w); - r5.xy = log2(r5.xy); - r5.xy = cb1[2].zz * r5.xy; - r5.xy = exp2(r5.xy); - r1.xyz = r4.zxy + r1.zxy; - r0.xyz = r1.xyz + r0.zxy; - r0.xyz = r0.xyz + r3.zxy; - r0.xyz = r0.www * r0.xyz + r2.zxy; - r0.xyz = r0.xyz * r2.www; - r0.xyz = cb0[109].xxx * r0.xyz; - r0.w = dot(r5.xy, r5.xy); - r0.w = 1 + -r0.w; - r0.w = max(0, r0.w); - r0.w = log2(r0.w); - r0.w = cb1[2].y * r0.w; - r0.w = exp2(r0.w); - float vignette_value = lerp(1.0, r0.w, VIGNETTE_STRENGTH); - r0.w = 1.0; // Disable original vignette, apply after tonemapping - r1.xyz = -cb1[4].zxy + float3(1,1,1); - r1.xyz = r0.www * r1.xyz + cb1[4].zxy; - r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - /* Original Code - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); - r0.xyz = max(float3(0,0,0), r0.xyz); - r0.xyz = log2(r0.xyz); - r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); - r0.yzw = cb1[7].zzz * r0.xyz; - r0.y = floor(r0.y); - r1.xy = cb1[7].xy * float2(0.5,0.5); - r1.yz = r0.zw * cb1[7].xy + r1.xy; - r1.x = r0.y * cb1[7].y + r1.y; - r2.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; - r3.x = cb1[7].y; - r3.y = 0; - r0.zw = r3.xy + r1.xz; - r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; - r0.x = r0.x * cb1[7].z + -r0.y; - r0.yzw = r1.xyz + -r2.xyz; - r0.xyz = r0.xxx * r0.yzw + r2.xyz; - r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; - r2.xyz = log2(abs(r0.xyz)); - r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; - r2.xyz = exp2(r2.xyz); - r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); - r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); - r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; - r0.w = dot(float2(171,231), r1.xy); - r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; - r1.xyz = frac(r1.xyz); - r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; - - - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - o0.xyz = renodx::draw::ToneMapPass(r0.yzx, graded); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - } - */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - // Apply vignette after tonemapping - o0.xyz *= vignette_value; - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - o0.w = min(1, r1.w); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x5FC0BD3C.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x63AB936D.ps_5_0.hlsl similarity index 73% rename from src/games/endfield/uberpost/uberpost_0x5FC0BD3C.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x63AB936D.ps_5_0.hlsl index 2151594baa..a8becb094e 100644 --- a/src/games/endfield/uberpost/uberpost_0x5FC0BD3C.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x63AB936D.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:12 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t3 : register(t3); @@ -19,7 +19,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -42,7 +42,7 @@ void main( r1.x = r0.x * 0.5 + r0.y; r1.x = r0.z * 0.5 + r1.x; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + -r2.zwxy; r2.xyzw = v1.xyxy + r2.xyzw; r1.yzw = t0.SampleLevel(s1_s, r3.xy, 0).xyz; @@ -100,7 +100,7 @@ void main( r1.x = 1 / r1.x; r0.xyz = r1.xxx * r0.xyz; o0.w = min(1, r0.w); - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r0.w = max(r1.y, r1.z); r0.w = max(r0.w, r1.x); r2.xy = -cb1[10].yx + r0.ww; @@ -123,7 +123,7 @@ void main( r5.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r5.xyz); r3.xyz = r5.xyz ? r4.xyz : r3.zxy; r2.xyz = r3.xyz * cb1[11].zxy + r2.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r1.xyz = t3.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = min(r1.x, r1.y); @@ -137,11 +137,10 @@ void main( r0.w = r0.w * r1.w + cb1[3].x; r1.xyz = r0.www * r1.xyz + float3(1,1,1); r0.xyz = r1.xyz * r0.xyz; - r0.w = cb0[82].x / cb0[82].y; - r1.x = -1 + r0.w; - r1.x = cb1[2].w * r1.x + 1; - r0.w = r0.w * 0.5625 + -r1.x; - r0.w = cb1[1].w * r0.w + r1.x; + r0.w = cb0[27].z + -1; + r0.w = cb1[2].w * r0.w + 1; + r1.x = cb0[27].z * 0.5625 + -r0.w; + r0.w = cb1[1].w * r1.x + r0.w; r1.x = saturate(cb1[2].x * 1.04999995); r1.x = r1.x * 1.5 + -1; r1.x = cb1[1].w * r1.x + 1; @@ -170,11 +169,9 @@ void main( r1.xyz = -cb1[4].zxy + float3(1,1,1); r1.xyz = r0.www * r1.xyz + cb1[4].zxy; r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; + r0.xyz = cb1[7].www * r0.xyz; /* Original Code - [branch] - if (shader_injection.tone_map_type == 0.f) { - r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); r0.xyz = max(float3(0,0,0), r0.xyz); r0.xyz = log2(r0.xyz); r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); @@ -198,50 +195,20 @@ void main( r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r2.xyz : r1.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; - - } else { - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR - ); - - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - o0.xyz = renodx::draw::ToneMapPass(r0.yzx, graded); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - } + return; */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -254,4 +221,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x64CEB255.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x7B0B4041.ps_5_0.hlsl similarity index 79% rename from src/games/endfield/uberpost/uberpost_0x64CEB255.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x7B0B4041.ps_5_0.hlsl index cf8b817f90..cab6769571 100644 --- a/src/games/endfield/uberpost/uberpost_0x64CEB255.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x7B0B4041.ps_5_0.hlsl @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -68,7 +68,7 @@ void main( } r0.xyzw = r2.xyzz; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + r2.xyzw; r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; r2.xyzw = v1.xyxy + -r2.zwxy; @@ -128,7 +128,7 @@ void main( r1.xyz = r1.xyz + r3.zxy; r0.xzw = r0.xxx * r1.xyz + r5.zxy; r0.xyz = r0.xzw * r0.yyy; - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r2.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -155,11 +155,10 @@ void main( r5.x = saturate(cb1[2].x + -2.79999995); r5.x = 5 * r5.x; r6.y = saturate(r5.z * r4.w + r5.x); - r4.w = cb0[82].x / cb0[82].y; - r5.x = -1 + r4.w; - r5.x = cb1[2].w * r5.x + 1; - r4.w = r4.w * 0.5625 + -r5.x; - r4.w = cb1[1].w * r4.w + r5.x; + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r5.x = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r5.x + r4.w; r6.x = saturate(r4.w * r3.w); r5.xz = log2(r6.xy); r5.xz = cb1[2].zz * r5.xz; @@ -173,7 +172,7 @@ void main( r6.xyz = -r6.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r6.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.w = dot(r5.xz, r5.xz); r0.w = 1 + -r0.w; @@ -187,30 +186,13 @@ void main( r1.xyz = r0.www * r1.xyz + cb1[4].zxy; r0.xyz = r1.xyz * r0.xyz; r0.xyz = cb1[7].www * r0.xyz; - - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -224,4 +206,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x10076711.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x81073AFC.ps_5_0.hlsl similarity index 82% rename from src/games/endfield/uberpost/uberpost_0x10076711.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x81073AFC.ps_5_0.hlsl index cdf3c23425..65307a4174 100644 --- a/src/games/endfield/uberpost/uberpost_0x10076711.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x81073AFC.ps_5_0.hlsl @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -46,15 +46,16 @@ void main( r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; r0.z = cmp(3 < cb1[25].x); if (r0.z != 0) { r2.xy = cmp(float2(0,0) != cb1[25].wz); r0.z = (int)r2.y | (int)r2.x; r2.xy = r0.xy * r0.ww; r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); r4.xy = -r2.xy * r0.zz + v1.xy; r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; @@ -62,10 +63,10 @@ void main( r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; @@ -76,7 +77,7 @@ void main( r2.zw = -r2.xy * r2.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; r2.xy = -r2.xy * r0.zz + v1.xy; r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; @@ -87,18 +88,18 @@ void main( r0.z = cmp(0.000000 != cb1[25].w); r3.xy = r0.xy * r0.ww; r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r0.zw = -r0.xy * r0.zz + v1.xy; r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; r0.xy = -r0.xy * r0.zz + v1.xy; r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; } r0.xw = float2(0,0); - r0.yz = cb0[82].wz; + r0.yz = cb0[0].wz; r3.xyzw = v1.xyxy + r0.xyzw; r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; r0.xyzw = v1.xyxy + -r0.zwxy; @@ -157,7 +158,7 @@ void main( r0.xyz = r0.xyz + r3.zxy; r0.xyz = r0.www * r0.xyz + r2.zxy; r0.xyz = r0.xyz * r2.www; - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r2.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -184,11 +185,10 @@ void main( r5.x = saturate(cb1[2].x + -2.79999995); r5.x = 5 * r5.x; r6.y = saturate(r5.z * r4.w + r5.x); - r4.w = cb0[82].x / cb0[82].y; - r5.x = -1 + r4.w; - r5.x = cb1[2].w * r5.x + 1; - r4.w = r4.w * 0.5625 + -r5.x; - r4.w = cb1[1].w * r4.w + r5.x; + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r5.x = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r5.x + r4.w; r6.x = saturate(r4.w * r3.w); r5.xz = log2(r6.xy); r5.xz = cb1[2].zz * r5.xz; @@ -202,7 +202,7 @@ void main( r6.xyz = -r6.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r6.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.w = dot(r5.xz, r5.xz); r0.w = 1 + -r0.w; @@ -243,14 +243,14 @@ void main( r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; - + } else { renodx::lut::Config lut_config = renodx::lut::config::Create( s0_s, @@ -265,30 +265,12 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); } */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -302,4 +284,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x86D9DED1.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x86D9DED1.ps_5_0.hlsl new file mode 100644 index 0000000000..fe1e7b02cc --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0x86D9DED1.ps_5_0.hlsl @@ -0,0 +1,192 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[27]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + const float4 icb[] = { { 0.500000, 0, 0, 0}, + { 1.000000, 0, 0, 0}, + { 1.500000, 0, 0, 0}, + { 2.000000, 0, 0, 0}, + { 2.500000, 0, 0, 0} }; + float4 r0,r1,r2,r3,r4,r5; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; + r1.xy = -cb1[0].xy + v1.xy; + r1.z = dot(r1.xy, r1.xy); + r1.z = sqrt(r1.z); + r1.w = log2(r1.z); + r1.w = cb1[0].w * r1.w; + r1.w = exp2(r1.w); + r1.xy = r1.xy * r1.ww; + r1.z = max(0.00999999978, r1.z); + r1.z = 1 / r1.z; + r1.z = -1 + r1.z; + r1.z = cb1[25].z * r1.z + 1; + r1.xy = r1.xy * r1.zz; + r2.xyz = r0.zxy; + r1.z = 0; + while (true) { + r1.w = cmp((int)r1.z >= 5); + if (r1.w != 0) break; + r1.w = icb[r1.z+0].x * cb1[0].z; + r3.xy = -r1.xy * r1.ww + v1.xy; + r3.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; + r3.xyz = r3.xyz + r2.yzx; + r1.w = (int)r1.z + 1; + r2.xyz = r3.zxy; + r1.z = r1.w; + continue; + } + r0.xyz = float3(0.166666672,0.166666672,0.166666672) * r2.xyz; + r1.xyzw = t1.SampleLevel(s1_s, v1.xy, 0).xyzw; + r2.w = -cb1[9].z + 1; + r3.xyz = r2.www * r1.zxy; + r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); + r4.xyz = log2(r1.zxy); + r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); + r2.w = max(r0.y, r0.z); + r2.w = max(r2.w, r0.x); + r5.xy = -cb1[10].yx + r2.ww; + r3.w = max(0, r5.x); + r3.w = min(cb1[10].z, r3.w); + r3.w = r3.w * r3.w; + r3.w = cb1[10].w * r3.w; + r3.w = max(r3.w, r5.y); + r2.w = max(9.99999975e-005, r2.w); + r2.w = r3.w / r2.w; + r5.xyz = r2.www * r0.xyz; + r5.xyz = -r5.xyz * cb1[9].zzz + r0.xyz; + r1.xyz = r3.xyz ? r4.xyz : r1.zxy; + r1.xyz = r1.xyz * cb1[11].zxy + r5.xyz; + r1.xyz = -r2.xyz * float3(0.166666672,0.166666672,0.166666672) + r1.xyz; + r0.xyz = cb1[9].xxx * r1.xyz + r0.xyz; + o0.w = saturate(r1.w + r0.w); + r0.w = cb1[16].z + cb1[16].x; + r1.x = dot(cb1[16].xx, cb1[16].zz); + r0.w = -r1.x + r0.w; + r1.xy = -cb1[17].xy + v1.xy; + r1.xy = float2(-0.5,-0.5) + r1.xy; + r1.z = r1.x / r1.y; + r1.w = cmp(abs(r1.z) < 1); + r2.x = 1 / abs(r1.z); + r2.x = r1.w ? abs(r1.z) : r2.x; + r2.y = r2.x * r2.x; + r2.z = r2.y * 0.0872929022 + -0.301894993; + r2.y = r2.z * r2.y + 1; + r2.z = r2.y * r2.x; + r2.x = -r2.y * r2.x + 1.57079637; + r1.w = r1.w ? r2.z : r2.x; + r2.xyz = cb1[7].www * r0.xyz; + /* Original Code + r2.xyz = r2.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r2.xyz = max(float3(0,0,0), r2.xyz); + r2.xyz = log2(r2.xyz); + r2.xyz = saturate(r2.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r2.yzw = cb1[7].zzz * r2.xyz; + r0.x = floor(r2.y); + r3.xy = cb1[7].xy * float2(0.5,0.5); + r3.yz = r2.zw * cb1[7].xy + r3.xy; + r3.x = r0.x * cb1[7].y + r3.y; + r2.yzw = t2.SampleLevel(s1_s, r3.xz, 0).xyz; + r4.x = cb1[7].y; + r4.y = 0; + r3.xy = r4.xy + r3.xz; + r3.xyz = t2.SampleLevel(s1_s, r3.xy, 0).xyz; + r0.x = r2.x * cb1[7].z + -r0.x; + r3.xyz = r3.xyz + -r2.yzw; + r2.xyz = r0.xxx * r3.xyz + r2.yzw; + r3.xyz = float3(12.9200001,12.9200001,12.9200001) * r2.xyz; + r4.xyz = log2(abs(r2.xyz)); + r4.xyz = float3(0.416666657,0.416666657,0.416666657) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r2.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r2.xyz); + */ + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r2.yzx); + float3 graded_linear; + [branch] + if (shader_injection.tone_map_type == 0.f) { + graded_linear = SDRGRADE(lut_sample); + } else { + graded_linear = HDRGRADE(lut_sample); + } + float3 graded_encoded = renodx::color::srgb::EncodeSafe(graded_linear); + r0.x = 1 + -r0.w; + r0.xz = -cb1[16].yy + r0.xw; + r0.w = cmp(r1.z < 0); + r0.w = r0.w ? -r1.w : r1.w; + r1.z = cmp(r1.x >= 0); + r1.z = r1.z ? 3.1415925 : -3.1415925; + r1.w = cmp(r1.y < 0); + r1.w = r1.w ? 1.000000 : 0; + r0.w = r1.z * r1.w + r0.w; + r0.w = 3.14159274 + r0.w; + r5.x = cb1[18].x * r0.w; + r0.w = dot(r1.xy, r1.xy); + r0.w = sqrt(r0.w); + r5.y = cb1[18].y * r0.w; + r1.xy = r5.xy * float2(0.159154937,2) + cb1[18].zw; + r1.xy = cb1[17].zw * cb0[20].yy + r1.xy; + r0.w = t3.SampleBias(s0_s, r1.xy, cb0[26].x).x; + r0.w = r0.y * r0.w; + r0.y = cb1[20].y * r0.y; + r0.y = saturate(r0.w * cb1[20].x + r0.y); + r0.z = r0.z + -r0.x; + r0.x = r0.y + -r0.x; + r0.y = 1 / r0.z; + r0.x = saturate(r0.x * r0.y); + r0.y = r0.x * -2 + 3; + r0.x = r0.x * r0.x; + r0.z = r0.y * r0.x; + r1.xyz = graded_encoded; + r0.x = -r0.y * r0.x + 1; + r0.xyw = cb1[22].xyz * r0.xxx; + r0.xyz = cb1[21].xyz * r0.zzz + r0.xyw; + r0.xyz = r0.xyz + -r1.xyz; + o0.xyz = cb1[20].www * r0.xyz + r1.xyz; + o0.xyz = renodx::color::srgb::DecodeSafe(o0.xyz); + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + return; +} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x57737D9F.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x89929873.ps_5_0.hlsl similarity index 71% rename from src/games/endfield/uberpost/uberpost_0x57737D9F.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x89929873.ps_5_0.hlsl index c669fb0402..2069310875 100644 --- a/src/games/endfield/uberpost/uberpost_0x57737D9F.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x89929873.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Wed Jan 21 21:30:43 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t2 : register(t2); @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -46,15 +46,16 @@ void main( r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; r0.z = cmp(3 < cb1[25].x); if (r0.z != 0) { r2.xy = cmp(float2(0,0) != cb1[25].wz); r0.z = (int)r2.y | (int)r2.x; r2.xy = r0.xy * r0.ww; r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); r4.xy = -r2.xy * r0.zz + v1.xy; r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; @@ -62,10 +63,10 @@ void main( r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; @@ -76,7 +77,7 @@ void main( r2.zw = -r2.xy * r2.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; r2.xy = -r2.xy * r0.zz + v1.xy; r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; @@ -87,17 +88,17 @@ void main( r0.z = cmp(0.000000 != cb1[25].w); r3.xy = r0.xy * r0.ww; r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r0.zw = -r0.xy * r0.zz + v1.xy; r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; r0.xy = -r0.xy * r0.zz + v1.xy; r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; } - r0.xyz = cb0[109].xxx * r2.zxy; + r0.xyz = cb0[27].xxx * r2.zxy; r1.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r1.zxy * r0.www; @@ -120,12 +121,10 @@ void main( r5.xyz = -r5.xyz * cb1[9].zzz + r0.xyz; r1.xyz = r3.xyz ? r4.xyz : r1.zxy; r1.xyz = r1.xyz * cb1[11].zxy + r5.xyz; - r1.xyz = -r2.zxy * cb0[109].xxx + r1.xyz; + r1.xyz = -r2.zxy * cb0[27].xxx + r1.xyz; r0.xyz = cb1[9].xxx * r1.xyz + r0.xyz; r0.xyz = cb1[7].www * r0.xyz; /* Original Code - // Define untonemapped - float3 untonemapped = r0.yzx; r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); r0.xyz = max(float3(0,0,0), r0.xyz); r0.xyz = log2(r0.xyz); @@ -150,42 +149,21 @@ void main( r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; - o0.xyz = r1.xyz * float3(0.0013725491, 0.0013725491, 0.0013725491) + r0.xyz; - // sRGB Decode and output - o0.xyz = renodx::color::srgb::Decode(o0.xyz); - o0.xyz = renodx::draw::ToneMapPass(untonemapped, o0.xyz); - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; o0.w = min(1, r1.w); return; */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -197,4 +175,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xBCD91195.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x8F2C3A6B.ps_5_0.hlsl similarity index 50% rename from src/games/endfield/uberpost/uberpost_0xBCD91195.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x8F2C3A6B.ps_5_0.hlsl index 0c93caafda..a7a2c1a501 100644 --- a/src/games/endfield/uberpost/uberpost_0xBCD91195.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x8F2C3A6B.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Wed Jan 21 21:30:43 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t2 : register(t2); @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -44,7 +44,7 @@ void main( r2.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r2.xyz); r0.xyz = r2.xyz ? r1.xyz : r0.zxy; r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r2.xyz = cb0[109].xxx * r1.zxy; + r2.xyz = cb0[27].xxx * r1.zxy; r0.w = max(r2.y, r2.z); r0.w = max(r0.w, r2.x); r3.xy = -cb1[10].yx + r0.ww; @@ -58,33 +58,49 @@ void main( r3.xyz = r2.xyz * r0.www; r3.xyz = -r3.xyz * cb1[9].zzz + r2.xyz; r0.xyz = r0.xyz * cb1[11].zxy + r3.xyz; - r0.xyz = -r1.zxy * cb0[109].xxx + r0.xyz; + r0.xyz = -r1.zxy * cb0[27].xxx + r0.xyz; o0.w = min(1, r1.w); r0.xyz = cb1[9].xxx * r0.xyz + r2.xyz; r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r0.x = r0.x * cb1[7].z + -r0.y; + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.x = cb1[7].y; + r2.y = 0; + r0.yz = r2.xy + r1.xz; + r1.xyz = t2.SampleLevel(s0_s, r1.xz, 0).xyz; + r0.yzw = t2.SampleLevel(s0_s, r0.yz, 0).xyz; + r0.yzw = r0.yzw + -r1.xyz; + r0.xyz = r0.xxx * r0.yzw + r1.xyz; + r1.xyz = log2(abs(r0.xyz)); + r1.xyz = float3(0.416666657,0.416666657,0.416666657) * r1.xyz; + r1.xyz = exp2(r1.xyz); + r1.xyz = r1.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r2.xyz : r1.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -95,4 +111,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x61908D50.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0x93EC2A6B.ps_5_0.hlsl similarity index 66% rename from src/games/endfield/uberpost/uberpost_0x61908D50.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0x93EC2A6B.ps_5_0.hlsl index cb85e0019f..81c0918918 100644 --- a/src/games/endfield/uberpost/uberpost_0x61908D50.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0x93EC2A6B.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Wed Jan 21 18:05:04 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t2 : register(t2); @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -46,15 +46,16 @@ void main( r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; r0.z = cmp(3 < cb1[25].x); if (r0.z != 0) { r2.xy = cmp(float2(0,0) != cb1[25].wz); r0.z = (int)r2.y | (int)r2.x; r2.xy = r0.xy * r0.ww; r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); r4.xy = -r2.xy * r0.zz + v1.xy; r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; @@ -62,10 +63,10 @@ void main( r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; @@ -76,7 +77,7 @@ void main( r2.zw = -r2.xy * r2.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; r2.xy = -r2.xy * r0.zz + v1.xy; r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; @@ -87,17 +88,17 @@ void main( r0.z = cmp(0.000000 != cb1[25].w); r3.xy = r0.xy * r0.ww; r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r0.zw = -r0.xy * r0.zz + v1.xy; r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; r0.xy = -r0.xy * r0.zz + v1.xy; r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; } - r0.xyz = cb0[109].xxx * r2.zxy; + r0.xyz = cb0[27].xxx * r2.zxy; r1.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r1.zxy * r0.www; @@ -124,11 +125,10 @@ void main( r5.x = saturate(cb1[2].x + -2.79999995); r5.x = 5 * r5.x; r6.y = saturate(r5.z * r4.w + r5.x); - r4.w = cb0[82].x / cb0[82].y; - r5.x = -1 + r4.w; - r5.x = cb1[2].w * r5.x + 1; - r4.w = r4.w * 0.5625 + -r5.x; - r4.w = cb1[1].w * r4.w + r5.x; + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r5.x = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r5.x + r4.w; r6.x = saturate(r4.w * r3.w); r5.xz = log2(r6.xy); r5.xz = cb1[2].zz * r5.xz; @@ -142,7 +142,7 @@ void main( r6.xyz = -r6.xyz * cb1[9].zzz + r0.xyz; r1.xyz = r3.xyz ? r4.xyz : r1.zxy; r1.xyz = r1.xyz * cb1[11].zxy + r6.xyz; - r1.xyz = -r2.zxy * cb0[109].xxx + r1.xyz; + r1.xyz = -r2.zxy * cb0[27].xxx + r1.xyz; r0.xyz = cb1[9].xxx * r1.xyz + r0.xyz; r0.w = dot(r5.xz, r5.xz); r0.w = 1 + -r0.w; @@ -155,29 +155,47 @@ void main( r1.xyz = -cb1[4].zxy + float3(1,1,1); r1.xyz = r0.www * r1.xyz + cb1[4].zxy; r0.xyz = r1.xyz * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t2.SampleLevel(s0_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t2.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -191,4 +209,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xA8213A68.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xA8213A68.ps_5_0.hlsl deleted file mode 100644 index 7d762160cb..0000000000 --- a/src/games/endfield/uberpost/uberpost_0xA8213A68.ps_5_0.hlsl +++ /dev/null @@ -1,174 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:24 2026 -#include "../common.hlsl" -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[25]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; - r1.x = r0.x * 0.5 + r0.y; - r1.x = r0.z * 0.5 + r1.x; - r2.xw = float2(0,0); - r2.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + -r2.zwxy; - r2.xyzw = v1.xyxy + r2.xyzw; - r1.yzw = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; - r3.w = r1.y * 0.5 + r1.z; - r3.w = r1.w * 0.5 + r3.w; - r4.x = max(r3.w, r1.x); - r4.yzw = t0.SampleLevel(s1_s, r2.xy, 0).xyz; - r2.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; - r2.w = r4.y * 0.5 + r4.z; - r2.w = r4.w * 0.5 + r2.w; - r4.x = max(r2.w, r4.x); - r5.x = r2.x * 0.5 + r2.y; - r5.x = r2.z * 0.5 + r5.x; - r5.y = r3.x * 0.5 + r3.y; - r5.y = r3.z * 0.5 + r5.y; - r5.z = max(r5.x, r5.y); - r4.x = max(r5.z, r4.x); - r5.z = min(r3.w, r1.x); - r3.w = r2.w + r3.w; - r2.w = min(r5.z, r2.w); - r3.w = r3.w + r5.x; - r5.x = min(r5.x, r5.y); - r3.w = r3.w + r5.y; - r1.x = r3.w * 0.25 + -r1.x; - r2.w = min(r5.x, r2.w); - r2.w = r4.x + -r2.w; - r2.w = 1 / r2.w; - r1.x = saturate(r2.w * abs(r1.x)); - r1.x = r1.x * -0.5 + 1; - r5.xyz = max(r2.xyz, r1.yzw); - r5.xyz = max(r5.xyz, r4.yzw); - r5.xyz = max(r5.xyz, r3.xyz); - r6.xyz = float3(0.25,0.25,0.25) / r5.xyz; - r5.xyz = float3(1,1,1) + -r5.xyz; - r7.xyz = min(r2.xyz, r1.yzw); - r1.yzw = r4.wyz + r1.wyz; - r4.xyz = min(r7.xyz, r4.yzw); - r4.xyz = min(r4.xyz, r3.xyz); - r1.yzw = r1.yzw + r3.zxy; - r1.yzw = r1.yzw + r2.zxy; - r2.xyz = r4.xyz * r6.xyz; - r3.xyz = r4.xyz * float3(4,4,4) + float3(-4,-4,-4); - r3.xyz = float3(1,1,1) / r3.xyz; - r3.xyz = r5.xyz * r3.xyz; - r2.xyz = max(r3.xyz, -r2.xyz); - r2.y = max(r2.y, r2.z); - r2.x = max(r2.x, r2.y); - r2.x = min(0, r2.x); - r2.x = max(-0.1875, r2.x); - r2.x = cb1[24].x * r2.x; - r1.x = r2.x * r1.x; - r0.xyz = r1.xxx * r1.yzw + r0.zxy; - r1.x = r1.x * 4 + 1; - r1.x = 1 / r1.x; - r0.xyz = r1.xxx * r0.xyz; - o0.w = min(1, r0.w); - r1.xyz = cb0[109].xxx * r0.xyz; - r0.w = max(r1.y, r1.z); - r0.w = max(r0.w, r1.x); - r2.xy = -cb1[10].yx + r0.ww; - r0.w = max(9.99999975e-005, r0.w); - r1.w = max(0, r2.x); - r1.w = min(cb1[10].z, r1.w); - r1.w = r1.w * r1.w; - r1.w = cb1[10].w * r1.w; - r1.w = max(r1.w, r2.y); - r0.w = r1.w / r0.w; - r2.xyz = r1.xyz * r0.www; - r2.xyz = -r2.xyz * cb1[9].zzz + r1.xyz; - r3.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; - r4.xyz = log2(r3.zxy); - r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; - r4.xyz = exp2(r4.xyz); - r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); - r0.w = -cb1[9].z + 1; - r5.xyz = r3.zxy * r0.www; - r5.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r5.xyz); - r3.xyz = r5.xyz ? r4.xyz : r3.zxy; - r2.xyz = r3.xyz * cb1[11].zxy + r2.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; - r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; - r1.xyz = t3.SampleLevel(s0_s, v1.xy, 0).xyz; - r0.w = min(r1.x, r1.y); - r0.w = min(r0.w, r1.z); - r1.xyz = float3(-1,-1,-1) + r1.zxy; - r0.w = -0.200000003 + r0.w; - r0.w = cmp(r0.w >= 0); - r0.w = r0.w ? 1.000000 : 0; - r1.w = saturate(cb1[3].x * 3 + -2); - r1.w = -cb1[3].x + r1.w; - r0.w = r0.w * r1.w + cb1[3].x; - r1.xyz = r0.www * r1.xyz + float3(1,1,1); - r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0xACB34505.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xACB34505.ps_5_0.hlsl new file mode 100644 index 0000000000..8f077a6e10 --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0xACB34505.ps_5_0.hlsl @@ -0,0 +1,194 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t3 : register(t3); + +Texture2D t2 : register(t2); + +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s1_s : register(s1); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[28]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1,r2,r3,r4,r5,r6; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = -cb1[0].xy + v1.xy; + r0.z = dot(r0.xy, r0.xy); + r0.w = sqrt(r0.z); + r0.w = max(0.00999999978, r0.w); + r0.w = 1 / r0.w; + r1.x = cb1[0].w * 0.5; + r0.z = log2(r0.z); + r0.z = r1.x * r0.z; + r0.z = exp2(r0.z); + r0.xy = r0.xy * r0.zz; + r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; + r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; + r0.z = cmp(3 < cb1[25].x); + if (r0.z != 0) { + r2.xy = cmp(float2(0,0) != cb1[25].wz); + r0.z = (int)r2.y | (int)r2.x; + r2.xy = r0.xy * r0.ww; + r2.xy = r0.zz ? r2.xy : r0.xy; + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); + r4.xy = -r2.xy * r0.zz + v1.xy; + r4.xyz = t0.SampleLevel(s1_s, r4.xy, 0).xyz; + r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; + r0.z = r0.z + r0.z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; + r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; + r5.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r2.zw = -r2.xy * r2.zz + v1.xy; + r5.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; + r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; + r2.xy = -r2.xy * r0.zz + v1.xy; + r2.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; + r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; + r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; + r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; + r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; + } else { + r0.z = cmp(0.000000 != cb1[25].w); + r3.xy = r0.xy * r0.ww; + r0.xy = r0.zz ? r3.xy : r0.xy; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r0.zw = -r0.xy * r0.zz + v1.xy; + r3.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; + r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; + r0.z = cb1[0].z + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; + r0.xy = -r0.xy * r0.zz + v1.xy; + r0.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; + r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; + } + r0.xyz = cb0[27].xxx * r2.zxy; + r1.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; + r0.w = -cb1[9].z + 1; + r3.xyz = r1.zxy * r0.www; + r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); + r4.xyz = log2(r1.zxy); + r4.xyz = float3(0.330000013,0.330000013,0.330000013) * r4.xyz; + r4.xyz = exp2(r4.xyz); + r4.xyz = r4.xyz * float3(1.49380004,1.49380004,1.49380004) + float3(-0.699999988,-0.699999988,-0.699999988); + r0.w = max(r0.y, r0.z); + r0.w = max(r0.w, r0.x); + r5.xy = -cb1[10].yx + r0.ww; + r2.w = max(0, r5.x); + r2.w = min(cb1[10].z, r2.w); + r5.xzw = t3.SampleLevel(s0_s, v1.xy, 0).xyz; + r2.w = r2.w * r2.w; + r2.w = cb1[10].w * r2.w; + r2.w = max(r2.w, r5.y); + r0.w = max(9.99999975e-005, r0.w); + r0.w = r2.w / r0.w; + r6.xyz = r0.xyz * r0.www; + r6.xyz = -r6.xyz * cb1[9].zzz + r0.xyz; + r1.xyz = r3.xyz ? r4.xyz : r1.zxy; + r1.xyz = r1.xyz * cb1[11].zxy + r6.xyz; + r1.xyz = -r2.zxy * cb0[27].xxx + r1.xyz; + r0.xyz = cb1[9].xxx * r1.xyz + r0.xyz; + r0.w = saturate(cb1[3].x * 3 + -2); + r1.x = min(r5.x, r5.z); + r1.x = min(r1.x, r5.w); + r1.x = -0.200000003 + r1.x; + r1.x = cmp(r1.x >= 0); + r1.x = r1.x ? 1.000000 : 0; + r0.w = -cb1[3].x + r0.w; + r0.w = r1.x * r0.w + cb1[3].x; + r1.xyz = float3(-1,-1,-1) + r5.wxz; + r1.xyz = r0.www * r1.xyz + float3(1,1,1); + r0.xyz = r1.xyz * r0.xyz; + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t2.SampleLevel(s1_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t2.SampleLevel(s1_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); + [branch] + if (shader_injection.tone_map_type == 0.f) { + o0.xyz = SDRGRADE(lut_sample); + } else { + o0.xyz = HDRGRADE(lut_sample); + } + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.w = min(1, r1.w); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0x9AA3FC1F.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xACCCB347.ps_5_0.hlsl similarity index 80% rename from src/games/endfield/uberpost/uberpost_0x9AA3FC1F.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0xACCCB347.ps_5_0.hlsl index b87937fee2..d00b34b4b1 100644 --- a/src/games/endfield/uberpost/uberpost_0x9AA3FC1F.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0xACCCB347.ps_5_0.hlsl @@ -19,7 +19,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -50,15 +50,16 @@ void main( r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; r0.z = cmp(3 < cb1[25].x); if (r0.z != 0) { r2.xy = cmp(float2(0,0) != cb1[25].wz); r0.z = (int)r2.y | (int)r2.x; r2.xy = r0.xy * r0.ww; r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); r4.xy = -r2.xy * r0.zz + v1.xy; r4.xyz = t0.SampleLevel(s1_s, r4.xy, 0).xyz; r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; @@ -66,10 +67,10 @@ void main( r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; @@ -80,7 +81,7 @@ void main( r2.zw = -r2.xy * r2.zz + v1.xy; r5.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; r2.xy = -r2.xy * r0.zz + v1.xy; r2.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; @@ -91,18 +92,18 @@ void main( r0.z = cmp(0.000000 != cb1[25].w); r3.xy = r0.xy * r0.ww; r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r0.zw = -r0.xy * r0.zz + v1.xy; r3.xyz = t0.SampleLevel(s1_s, r0.zw, 0).xyz; r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; r0.xy = -r0.xy * r0.zz + v1.xy; r0.xyz = t0.SampleLevel(s1_s, r0.xy, 0).xyz; r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; } r0.xw = float2(0,0); - r0.yz = cb0[82].wz; + r0.yz = cb0[0].wz; r3.xyzw = v1.xyxy + r0.xyzw; r1.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; r0.xyzw = v1.xyxy + -r0.zwxy; @@ -161,7 +162,7 @@ void main( r0.xyz = r0.xyz + r3.zxy; r0.xyz = r0.www * r0.xyz + r2.zxy; r0.xyz = r0.xyz * r2.www; - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r2.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -189,11 +190,10 @@ void main( r6.x = saturate(cb1[2].x + -2.79999995); r6.x = 5 * r6.x; r6.y = saturate(r6.y * r4.w + r6.x); - r4.w = cb0[82].x / cb0[82].y; - r6.z = -1 + r4.w; - r6.z = cb1[2].w * r6.z + 1; - r4.w = r4.w * 0.5625 + -r6.z; - r4.w = cb1[1].w * r4.w + r6.z; + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r6.z = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r6.z + r4.w; r6.x = saturate(r4.w * r3.w); r6.xy = log2(r6.xy); r6.xy = cb1[2].zz * r6.xy; @@ -207,7 +207,7 @@ void main( r7.xyz = -r7.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r7.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.w = saturate(cb1[3].x * 3 + -2); r1.x = min(r5.x, r5.z); @@ -232,29 +232,12 @@ void main( r1.xyz = r0.www * r1.xyz + cb1[4].zxy; r0.xyz = r1.xyz * r0.xyz; r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -268,4 +251,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xB06827CB.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xB06827CB.ps_5_0.hlsl new file mode 100644 index 0000000000..36b761c4b1 --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0xB06827CB.ps_5_0.hlsl @@ -0,0 +1,186 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[28]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1,r2,r3,r4,r5; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = -cb1[0].xy + v1.xy; + r0.z = dot(r0.xy, r0.xy); + r0.w = sqrt(r0.z); + r0.w = max(0.00999999978, r0.w); + r0.w = 1 / r0.w; + r1.x = cb1[0].w * 0.5; + r0.z = log2(r0.z); + r0.z = r1.x * r0.z; + r0.z = exp2(r0.z); + r0.xy = r0.xy * r0.zz; + r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; + r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; + r0.z = cmp(3 < cb1[25].x); + if (r0.z != 0) { + r2.xy = cmp(float2(0,0) != cb1[25].wz); + r0.z = (int)r2.y | (int)r2.x; + r2.xy = r0.xy * r0.ww; + r2.xy = r0.zz ? r2.xy : r0.xy; + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); + r4.xy = -r2.xy * r0.zz + v1.xy; + r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; + r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; + r0.z = r0.z + r0.z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; + r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; + r5.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r2.zw = -r2.xy * r2.zz + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; + r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; + r2.xy = -r2.xy * r0.zz + v1.xy; + r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; + r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; + r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; + r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; + r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; + } else { + r0.z = cmp(0.000000 != cb1[25].w); + r3.xy = r0.xy * r0.ww; + r0.xy = r0.zz ? r3.xy : r0.xy; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r0.zw = -r0.xy * r0.zz + v1.xy; + r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; + r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; + r0.z = cb1[0].z + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; + r0.xy = -r0.xy * r0.zz + v1.xy; + r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; + r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; + } + r0.xy = -cb1[1].xy + v1.xy; + r0.z = -cb1[2].x + 1; + r0.z = cb1[1].w * r0.z + cb1[2].x; + r0.xy = abs(r0.xy) * r0.zz; + r0.z = saturate(cb1[2].x * 1.04999995); + r0.z = r0.z * 1.5 + -1; + r0.z = cb1[1].w * r0.z + 1; + r0.x = r0.x * r0.z; + r0.z = cb1[2].x * 2 + -1; + r0.z = cb1[1].w * r0.z + 1; + r0.w = saturate(cb1[2].x + -2.79999995); + r0.w = 5 * r0.w; + r1.y = saturate(r0.y * r0.z + r0.w); + r0.y = cb0[27].z + -1; + r0.y = cb1[2].w * r0.y + 1; + r0.z = cb0[27].z * 0.5625 + -r0.y; + r0.y = cb1[1].w * r0.z + r0.y; + r1.x = saturate(r0.x * r0.y); + r0.xy = log2(r1.xy); + r0.xy = cb1[2].zz * r0.xy; + r0.xy = exp2(r0.xy); + r1.xyz = cb0[27].xxx * r2.zxy; + r0.x = dot(r0.xy, r0.xy); + r0.x = 1 + -r0.x; + r0.x = max(0, r0.x); + r0.x = log2(r0.x); + r0.x = cb1[2].y * r0.x; + r0.x = exp2(r0.x); + float vignette_value = lerp(1.0, r0.x, VIGNETTE_STRENGTH); + r0.x = 1.0; // Disable original vignette, apply after tonemapping + r0.yzw = -cb1[4].zxy + float3(1,1,1); + r0.xyz = r0.xxx * r0.yzw + cb1[4].zxy; + r0.xyz = r1.xyz * r0.xyz; + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t1, r0.yzx); + [branch] + if (shader_injection.tone_map_type == 0.f) { + o0.xyz = SDRGRADE(lut_sample); + } else { + o0.xyz = HDRGRADE(lut_sample); + } + // Apply vignette after tonemapping + o0.xyz *= vignette_value; + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.w = min(1, r1.w); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0xBC012E29.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xBC012E29.ps_5_0.hlsl new file mode 100644 index 0000000000..6d8def4e25 --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0xBC012E29.ps_5_0.hlsl @@ -0,0 +1,152 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[28]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + float4 r0,r1,r2,r3,r4,r5; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = -cb1[0].xy + v1.xy; + r0.z = dot(r0.xy, r0.xy); + r0.w = sqrt(r0.z); + r0.w = max(0.00999999978, r0.w); + r0.w = 1 / r0.w; + r1.x = cb1[0].w * 0.5; + r0.z = log2(r0.z); + r0.z = r1.x * r0.z; + r0.z = exp2(r0.z); + r0.xy = r0.xy * r0.zz; + r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; + r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; + r0.z = cmp(3 < cb1[25].x); + if (r0.z != 0) { + r2.xy = cmp(float2(0,0) != cb1[25].wz); + r0.z = (int)r2.y | (int)r2.x; + r2.xy = r0.xy * r0.ww; + r2.xy = r0.zz ? r2.xy : r0.xy; + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); + r4.xy = -r2.xy * r0.zz + v1.xy; + r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; + r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; + r0.z = r0.z + r0.z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r5.xy = -r2.xy * r0.zz + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; + r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; + r5.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; + r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; + r2.zw = -r2.xy * r2.zz + v1.xy; + r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; + r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; + r2.xy = -r2.xy * r0.zz + v1.xy; + r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; + r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; + r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; + r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; + r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; + } else { + r0.z = cmp(0.000000 != cb1[25].w); + r3.xy = r0.xy * r0.ww; + r0.xy = r0.zz ? r3.xy : r0.xy; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; + r0.zw = -r0.xy * r0.zz + v1.xy; + r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; + r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; + r0.z = cb1[0].z + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; + r0.xy = -r0.xy * r0.zz + v1.xy; + r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; + r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; + } + r0.xyz = cb0[27].xxx * r2.zxy; + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t1, r0.yzx); + [branch] + if (shader_injection.tone_map_type == 0.f) { + o0.xyz = SDRGRADE(lut_sample); + } else { + o0.xyz = HDRGRADE(lut_sample); + } + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.w = min(1, r1.w); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0xC32F6D7B.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xC32F6D7B.ps_5_0.hlsl new file mode 100644 index 0000000000..bf86eb241b --- /dev/null +++ b/src/games/endfield/uberpost/uberpost_0xC32F6D7B.ps_5_0.hlsl @@ -0,0 +1,155 @@ +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 +#include "../common.hlsl" +Texture2D t1 : register(t1); + +Texture2D t0 : register(t0); + +SamplerState s0_s : register(s0); + +cbuffer cb1 : register(b1) +{ + float4 cb1[26]; +} + +cbuffer cb0 : register(b0) +{ + float4 cb0[28]; +} + + + + +// 3Dmigoto declarations +#define cmp - + + +void main( + float4 v0 : SV_Position0, + float2 v1 : TEXCOORD0, + out float4 o0 : SV_Target0) +{ + const float4 icb[] = { { 0.500000, 0, 0, 0}, + { 1.000000, 0, 0, 0}, + { 1.500000, 0, 0, 0}, + { 2.000000, 0, 0, 0}, + { 2.500000, 0, 0, 0} }; + float4 r0,r1,r2,r3; + uint4 bitmask, uiDest; + float4 fDest; + + r0.xy = -cb1[0].xy + v1.xy; + r0.z = dot(r0.xy, r0.xy); + r0.z = sqrt(r0.z); + r0.w = log2(r0.z); + r0.w = cb1[0].w * r0.w; + r0.w = exp2(r0.w); + r0.xy = r0.xy * r0.ww; + r0.z = max(0.00999999978, r0.z); + r0.z = 1 / r0.z; + r0.z = -1 + r0.z; + r0.z = cb1[25].z * r0.z + 1; + r0.xy = r0.xy * r0.zz; + r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; + r2.xyz = r1.zxy; + r0.z = 0; + while (true) { + r0.w = cmp((int)r0.z >= 5); + if (r0.w != 0) break; + r0.w = icb[r0.z+0].x * cb1[0].z; + r3.xy = -r0.xy * r0.ww + v1.xy; + r3.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; + r3.xyz = r3.xyz + r2.yzx; + r0.w = (int)r0.z + 1; + r2.xyz = r3.zxy; + r0.z = r0.w; + continue; + } + r0.xy = -cb1[1].xy + v1.xy; + r0.z = -cb1[2].x + 1; + r0.z = cb1[1].w * r0.z + cb1[2].x; + r0.xy = abs(r0.xy) * r0.zz; + r0.z = saturate(cb1[2].x * 1.04999995); + r0.z = r0.z * 1.5 + -1; + r0.z = cb1[1].w * r0.z + 1; + r0.x = r0.x * r0.z; + r0.z = cb1[2].x * 2 + -1; + r0.z = cb1[1].w * r0.z + 1; + r0.w = saturate(cb1[2].x + -2.79999995); + r0.w = 5 * r0.w; + r1.y = saturate(r0.y * r0.z + r0.w); + r0.y = cb0[27].z + -1; + r0.y = cb1[2].w * r0.y + 1; + r0.z = cb0[27].z * 0.5625 + -r0.y; + r0.y = cb1[1].w * r0.z + r0.y; + r1.x = saturate(r0.x * r0.y); + r0.xy = log2(r1.xy); + r0.xy = cb1[2].zz * r0.xy; + r0.xy = exp2(r0.xy); + r1.xyz = cb0[27].xxx * r2.xyz; + r1.xyz = float3(0.166666672,0.166666672,0.166666672) * r1.xyz; + r0.x = dot(r0.xy, r0.xy); + r0.x = 1 + -r0.x; + r0.x = max(0, r0.x); + r0.x = log2(r0.x); + r0.x = cb1[2].y * r0.x; + r0.x = exp2(r0.x); + float vignette_value = lerp(1.0, r0.x, VIGNETTE_STRENGTH); + r0.x = 1.0; // Disable original vignette, apply after tonemapping + r0.yzw = -cb1[4].zxy + float3(1,1,1); + r0.xyz = r0.xxx * r0.yzw + cb1[4].zxy; + r0.xyz = r1.xyz * r0.xyz; + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t1.SampleLevel(s0_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t1.SampleLevel(s0_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t1, r0.yzx); + [branch] + if (shader_injection.tone_map_type == 0.f) { + o0.xyz = SDRGRADE(lut_sample); + } else { + o0.xyz = HDRGRADE(lut_sample); + } + // Apply vignette after tonemapping + o0.xyz *= vignette_value; + if (CUSTOM_GRAIN_STRENGTH > 0) { + o0.xyz = renodx::effects::ApplyFilmGrain( + o0.xyz, + v1.xy, + CUSTOM_RANDOM, + CUSTOM_GRAIN_STRENGTH * 0.03f); + } + o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); + o0.w = min(1, r1.w); + return; +} diff --git a/src/games/endfield/uberpost/uberpost_0xAFDCA263.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xD589DFEB.ps_5_0.hlsl similarity index 76% rename from src/games/endfield/uberpost/uberpost_0xAFDCA263.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0xD589DFEB.ps_5_0.hlsl index 1b345ce829..9628149834 100644 --- a/src/games/endfield/uberpost/uberpost_0xAFDCA263.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0xD589DFEB.ps_5_0.hlsl @@ -1,4 +1,3 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:26 2026 #include "../common.hlsl" Texture2D t2 : register(t2); @@ -15,7 +14,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -68,7 +67,7 @@ void main( } r0.xyzw = r2.xyzz; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + r2.xyzw; r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; r2.xyzw = v1.xyxy + -r2.zwxy; @@ -128,7 +127,7 @@ void main( r1.xyz = r1.xyz + r3.zxy; r0.xzw = r0.xxx * r1.xyz + r5.zxy; r0.xyz = r0.xzw * r0.yyy; - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r2.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -151,32 +150,15 @@ void main( r5.xyz = -r5.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r5.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -188,4 +170,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xD5BC74AC.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xD5BC74AC.ps_5_0.hlsl deleted file mode 100644 index 07af03a625..0000000000 --- a/src/games/endfield/uberpost/uberpost_0xD5BC74AC.ps_5_0.hlsl +++ /dev/null @@ -1,194 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:33 2026 -#include "../common.hlsl" -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[26]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[110]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float2 v1 : TEXCOORD0, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5,r6,r7; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb1[0].xy + v1.xy; - r0.z = dot(r0.xy, r0.xy); - r0.w = sqrt(r0.z); - r0.w = max(0.00999999978, r0.w); - r0.w = 1 / r0.w; - r1.x = cb1[0].w * 0.5; - r0.z = log2(r0.z); - r0.z = r1.x * r0.z; - r0.z = exp2(r0.z); - r0.xy = r0.xy * r0.zz; - r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r1.xyz = float3(1,0,0) * r1.xyz; - r0.z = cmp(3 < cb1[25].x); - if (r0.z != 0) { - r2.xy = cmp(float2(0,0) != cb1[25].wz); - r0.z = (int)r2.y | (int)r2.x; - r2.xy = r0.xy * r0.ww; - r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); - r4.xy = -r2.xy * r0.zz + v1.xy; - r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; - r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; - r0.z = r0.z + r0.z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; - r5.xy = -r2.xy * r0.zz + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r3.xyzw = cb1[0].zzzz * float4(2,2,2,2) + r3.xyzw; - r3.xyzw = -r2.xyxy * r3.xyzw + v1.xyxy; - r5.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r2.zw = -r2.xy * r2.zz + v1.xy; - r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; - r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; - r2.xy = -r2.xy * r0.zz + v1.xy; - r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; - r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r2.xyz = r3.xyz * float3(0,0,1) + r2.xyz; - r2.xyz = float3(0.333333403,0.333333403,0.333333403) * r2.xyz; - } else { - r0.z = cmp(0.000000 != cb1[25].w); - r3.xy = r0.xy * r0.ww; - r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; - r0.zw = -r0.xy * r0.zz + v1.xy; - r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; - r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; - r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; - r0.xy = -r0.xy * r0.zz + v1.xy; - r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; - r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; - } - r0.xw = float2(0,0); - r0.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r0.xyzw; - r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; - r0.xyzw = v1.xyxy + -r0.zwxy; - r4.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s0_s, r3.zw, 0).xyz; - r0.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; - r0.w = r1.x * 0.5 + r1.y; - r0.w = r1.z * 0.5 + r0.w; - r2.w = r4.x * 0.5 + r4.y; - r2.w = r4.z * 0.5 + r2.w; - r3.w = r2.x * 0.5 + r2.y; - r3.w = r2.z * 0.5 + r3.w; - r4.w = r3.x * 0.5 + r3.y; - r4.w = r3.z * 0.5 + r4.w; - r5.x = r0.x * 0.5 + r0.y; - r5.x = r0.z * 0.5 + r5.x; - r5.yzw = min(r4.xyz, r3.xyz); - r5.yzw = min(r5.yzw, r1.xyz); - r5.yzw = min(r5.yzw, r0.xyz); - r6.xyz = max(r4.xyz, r3.xyz); - r6.xyz = max(r6.xyz, r1.xyz); - r6.xyz = max(r6.xyz, r0.xyz); - r7.xyz = float3(0.25,0.25,0.25) / r6.xyz; - r7.xyz = r7.xyz * r5.yzw; - r6.xyz = float3(1,1,1) + -r6.xyz; - r5.yzw = r5.yzw * float3(4,4,4) + float3(-4,-4,-4); - r5.yzw = float3(1,1,1) / r5.yzw; - r5.yzw = r6.xyz * r5.yzw; - r5.yzw = max(-r7.xyz, r5.yzw); - r5.z = max(r5.z, r5.w); - r5.y = max(r5.y, r5.z); - r5.y = min(0, r5.y); - r5.y = max(-0.1875, r5.y); - r5.y = cb1[24].x * r5.y; - r5.z = r2.w + r0.w; - r5.z = r5.z + r4.w; - r5.z = r5.z + r5.x; - r5.z = r5.z * 0.25 + -r3.w; - r5.w = max(r3.w, r2.w); - r5.w = max(r5.w, r0.w); - r6.x = max(r5.x, r4.w); - r5.w = max(r6.x, r5.w); - r2.w = min(r3.w, r2.w); - r0.w = min(r2.w, r0.w); - r2.w = min(r5.x, r4.w); - r0.w = min(r2.w, r0.w); - r0.w = r5.w + -r0.w; - r0.w = 1 / r0.w; - r0.w = saturate(abs(r5.z) * r0.w); - r0.w = r0.w * -0.5 + 1; - r0.w = r5.y * r0.w; - r2.w = r0.w * 4 + 1; - r2.w = 1 / r2.w; - r1.xyz = r4.zxy + r1.zxy; - r0.xyz = r1.xyz + r0.zxy; - r0.xyz = r0.xyz + r3.zxy; - r0.xyz = r0.www * r0.xyz + r2.zxy; - r0.xyz = r0.xyz * r2.www; - r0.xyz = cb0[109].xxx * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t1, lut_config, r0.yzx); - - [branch] - if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); - } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); - } - if (CUSTOM_GRAIN_STRENGTH > 0) { - o0.xyz = renodx::effects::ApplyFilmGrain( - o0.xyz, - v1.xy, - CUSTOM_RANDOM, - CUSTOM_GRAIN_STRENGTH * 0.03f); - } - o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); - o0.w = min(1, r1.w); - return; -} \ No newline at end of file diff --git a/src/games/endfield/uberpost/uberpost_0x09270FDA.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xD8401285.ps_5_0.hlsl similarity index 82% rename from src/games/endfield/uberpost/uberpost_0x09270FDA.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0xD8401285.ps_5_0.hlsl index 176d153139..c9e093c644 100644 --- a/src/games/endfield/uberpost/uberpost_0x09270FDA.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0xD8401285.ps_5_0.hlsl @@ -16,7 +16,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -47,15 +47,16 @@ void main( r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; r1.xyz = float3(1,0,0) * r1.xyz; + float ca_strength = CHROMATIC_ABERRATION_STRENGTH; r0.z = cmp(3 < cb1[25].x); if (r0.z != 0) { r2.xy = cmp(float2(0,0) != cb1[25].wz); r0.z = (int)r2.y | (int)r2.x; r2.xy = r0.xy * r0.ww; r2.xy = r0.zz ? r2.xy : r0.xy; - r0.z = cb1[25].y + cb1[0].z; - r2.z = cb1[25].y + cb1[25].y; - r3.xyzw = cb1[25].yyyy * float4(3,3,4,4); + r0.z = cb1[25].y * ca_strength + cb1[0].z; + r2.z = cb1[25].y * ca_strength + cb1[25].y * ca_strength; + r3.xyzw = cb1[25].yyyy * ca_strength * float4(3,3,4,4); r4.xy = -r2.xy * r0.zz + v1.xy; r4.xyz = t0.SampleLevel(s0_s, r4.xy, 0).xyz; r4.xyz = r4.xyz * float3(1,0,0) + r1.xyz; @@ -63,10 +64,10 @@ void main( r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(1,0,0) + r4.xyz; - r5.xy = -r2.xy * cb1[25].yy + v1.xy; + r5.xy = -r2.xy * cb1[25].yy * ca_strength + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r5.xy = -r2.xy * r0.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r5.xy, 0).xyz; r4.xyz = r5.xyz * float3(0,1,0) + r4.xyz; @@ -77,7 +78,7 @@ void main( r2.zw = -r2.xy * r2.zz + v1.xy; r5.xyz = t0.SampleLevel(s0_s, r2.zw, 0).xyz; r4.xyz = r5.xyz * float3(0,0,1) + r4.xyz; - r0.z = cb1[25].y * 3 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 3 + cb1[0].z; r2.xy = -r2.xy * r0.zz + v1.xy; r2.xyz = t0.SampleLevel(s0_s, r2.xy, 0).xyz; r2.xyz = r2.xyz * float3(0,0,1) + r4.xyz; @@ -88,18 +89,18 @@ void main( r0.z = cmp(0.000000 != cb1[25].w); r3.xy = r0.xy * r0.ww; r0.xy = r0.zz ? r3.xy : r0.xy; - r0.z = cb1[25].y * 2 + cb1[0].z; + r0.z = cb1[25].y * ca_strength * 2 + cb1[0].z; r0.zw = -r0.xy * r0.zz + v1.xy; r3.xyz = t0.SampleLevel(s0_s, r0.zw, 0).xyz; r1.xyz = r3.xyz * float3(0,1,0) + r1.xyz; r0.z = cb1[0].z + cb1[0].z; - r0.z = cb1[25].y * 3 + r0.z; + r0.z = cb1[25].y * ca_strength * 3 + r0.z; r0.xy = -r0.xy * r0.zz + v1.xy; r0.xyz = t0.SampleLevel(s0_s, r0.xy, 0).xyz; r2.xyz = r0.xyz * float3(0,0,1) + r1.xyz; } r0.xw = float2(0,0); - r0.yz = cb0[82].wz; + r0.yz = cb0[0].wz; r3.xyzw = v1.xyxy + r0.xyzw; r1.xyz = t0.SampleLevel(s0_s, r3.xy, 0).xyz; r0.xyzw = v1.xyxy + -r0.zwxy; @@ -158,7 +159,7 @@ void main( r0.xyz = r0.xyz + r3.zxy; r0.xyz = r0.www * r0.xyz + r2.zxy; r0.xyz = r0.xyz * r2.www; - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r2.xyz = t1.SampleLevel(s0_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -181,7 +182,7 @@ void main( r5.xyz = -r5.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r5.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.xyz = cb1[7].www * r0.xyz; /* Original Code @@ -211,7 +212,7 @@ void main( r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r1.xyz : r2.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); @@ -231,29 +232,12 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); } */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } if (CUSTOM_GRAIN_STRENGTH > 0) { o0.xyz = renodx::effects::ApplyFilmGrain( @@ -265,4 +249,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xE0058043.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xDBC83F91.ps_5_0.hlsl similarity index 65% rename from src/games/endfield/uberpost/uberpost_0xE0058043.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0xDBC83F91.ps_5_0.hlsl index fcdb84ba49..9b68021176 100644 --- a/src/games/endfield/uberpost/uberpost_0xE0058043.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0xDBC83F91.ps_5_0.hlsl @@ -16,7 +16,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -35,11 +35,10 @@ void main( uint4 bitmask, uiDest; float4 fDest; - r0.x = cb0[82].x / cb0[82].y; - r0.y = -1 + r0.x; - r0.y = cb1[2].w * r0.y + 1; - r0.x = r0.x * 0.5625 + -r0.y; - r0.x = cb1[1].w * r0.x + r0.y; + r0.x = cb0[27].z + -1; + r0.x = cb1[2].w * r0.x + 1; + r0.y = cb0[27].z * 0.5625 + -r0.x; + r0.x = cb1[1].w * r0.y + r0.x; r0.y = saturate(cb1[2].x * 1.04999995); r0.y = r0.y * 1.5 + -1; r0.y = cb1[1].w * r0.y + 1; @@ -77,7 +76,7 @@ void main( r3.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r3.xyz); r1.xyz = r3.xyz ? r2.xyz : r1.zxy; r2.xyzw = t0.SampleLevel(s0_s, v1.xy, 0).xyzw; - r3.xyz = cb0[109].xxx * r2.zxy; + r3.xyz = cb0[27].xxx * r2.zxy; r0.w = max(r3.y, r3.z); r0.w = max(r0.w, r3.x); r4.xy = -cb1[10].yx + r0.ww; @@ -91,35 +90,18 @@ void main( r4.xyz = r3.xyz * r0.www; r4.xyz = -r4.xyz * cb1[9].zzz + r3.xyz; r1.xyz = r1.xyz * cb1[11].zxy + r4.xyz; - r1.xyz = -r2.zxy * cb0[109].xxx + r1.xyz; + r1.xyz = -r2.zxy * cb0[27].xxx + r1.xyz; o0.w = min(1, r2.w); r1.xyz = cb1[9].xxx * r1.xyz + r3.xyz; r0.xyz = r1.xyz * r0.xyz; r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -132,4 +114,4 @@ void main( } o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0xAFECA8F4.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xFBD38A69.ps_5_0.hlsl similarity index 52% rename from src/games/endfield/uberpost/uberpost_0xAFECA8F4.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0xFBD38A69.ps_5_0.hlsl index 68dd99ccb0..f3cc1ee4d6 100644 --- a/src/games/endfield/uberpost/uberpost_0xAFECA8F4.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0xFBD38A69.ps_5_0.hlsl @@ -1,4 +1,4 @@ -// ---- Created with 3Dmigoto v1.3.16 on Tue Jan 20 19:04:26 2026 +// ---- Created with 3Dmigoto v1.3.16 on Thu Jul 16 20:38:41 2026 #include "../common.hlsl" Texture2D t3 : register(t3); @@ -19,7 +19,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -39,7 +39,7 @@ void main( { 1.500000, 0, 0, 0}, { 2.000000, 0, 0, 0}, { 2.500000, 0, 0, 0} }; - float4 r0,r1,r2,r3,r4,r5,r6,r7,r8; + float4 r0,r1,r2,r3,r4,r5,r6,r7; uint4 bitmask, uiDest; float4 fDest; @@ -56,7 +56,7 @@ void main( r0.z = cb1[25].z * r0.z + 1; r0.xy = r0.xy * r0.zz; r1.xyzw = t0.SampleLevel(s1_s, v1.xy, 0).xyzw; - r2.xyz = r1.xyz; + r2.xyz = r1.zxy; r0.z = 0; while (true) { r0.w = cmp((int)r0.z >= 5); @@ -64,75 +64,14 @@ void main( r0.w = icb[r0.z+0].x * cb1[0].z; r3.xy = -r0.xy * r0.ww + v1.xy; r3.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r3.xyz = r3.xyz + r2.xyz; + r3.xyz = r3.xyz + r2.yzx; r0.w = (int)r0.z + 1; - r2.xyz = r3.xyz; + r2.xyz = r3.zxy; r0.z = r0.w; continue; } - r0.xyzw = r2.xyzz; - r2.xw = float2(0,0); - r2.yz = cb0[82].wz; - r3.xyzw = v1.xyxy + r2.xyzw; - r1.xyz = t0.SampleLevel(s1_s, r3.xy, 0).xyz; - r2.xyzw = v1.xyxy + -r2.zwxy; - r4.xyz = t0.SampleLevel(s1_s, r2.xy, 0).xyz; - r3.xyz = t0.SampleLevel(s1_s, r3.zw, 0).xyz; - r2.xyz = t0.SampleLevel(s1_s, r2.zw, 0).xyz; - r2.w = r1.x * 0.5 + r1.y; - r2.w = r1.z * 0.5 + r2.w; - r3.w = r4.x * 0.5 + r4.y; - r3.w = r4.z * 0.5 + r3.w; - r5.xyz = float3(0.166666672,0.166666672,0.166666672) * r0.xyz; - r0.x = r0.x * 0.0833333358 + r5.y; - r0.x = r0.w * 0.0833333358 + r0.x; - r0.y = r3.x * 0.5 + r3.y; - r0.y = r3.z * 0.5 + r0.y; - r0.z = r2.x * 0.5 + r2.y; - r0.z = r2.z * 0.5 + r0.z; - r6.xyz = min(r4.xyz, r3.xyz); - r6.xyz = min(r6.xyz, r1.xyz); - r6.xyz = min(r6.xyz, r2.xyz); - r7.xyz = max(r4.xyz, r3.xyz); - r7.xyz = max(r7.xyz, r1.xyz); - r7.xyz = max(r7.xyz, r2.xyz); - r8.xyz = float3(0.25,0.25,0.25) / r7.xyz; - r8.xyz = r8.xyz * r6.xyz; - r7.xyz = float3(1,1,1) + -r7.xyz; - r6.xyz = r6.xyz * float3(4,4,4) + float3(-4,-4,-4); - r6.xyz = float3(1,1,1) / r6.xyz; - r6.xyz = r7.xyz * r6.xyz; - r6.xyz = max(-r8.xyz, r6.xyz); - r0.w = max(r6.y, r6.z); - r0.w = max(r6.x, r0.w); - r0.w = min(0, r0.w); - r0.w = max(-0.1875, r0.w); - r0.w = cb1[24].x * r0.w; - r4.w = r3.w + r2.w; - r4.w = r4.w + r0.y; - r4.w = r4.w + r0.z; - r4.w = r4.w * 0.25 + -r0.x; - r5.w = max(r3.w, r0.x); - r5.w = max(r5.w, r2.w); - r6.x = max(r0.y, r0.z); - r5.w = max(r6.x, r5.w); - r0.x = min(r3.w, r0.x); - r0.x = min(r2.w, r0.x); - r0.y = min(r0.y, r0.z); - r0.x = min(r0.x, r0.y); - r0.x = r5.w + -r0.x; - r0.x = 1 / r0.x; - r0.x = saturate(abs(r4.w) * r0.x); - r0.x = r0.x * -0.5 + 1; - r0.x = r0.w * r0.x; - r0.y = r0.x * 4 + 1; - r0.y = 1 / r0.y; - r1.xyz = r4.zxy + r1.zxy; - r1.xyz = r1.xyz + r2.zxy; - r1.xyz = r1.xyz + r3.zxy; - r0.xzw = r0.xxx * r1.xyz + r5.zxy; - r0.xyz = r0.xzw * r0.yyy; - r1.xyz = cb0[109].xxx * r0.xyz; + r0.xyz = cb0[27].xxx * r2.xyz; + r1.xyz = float3(0.166666672,0.166666672,0.166666672) * r0.xyz; r2.xyz = t1.SampleLevel(s1_s, v1.xy, 0).xyz; r0.w = -cb1[9].z + 1; r3.xyz = r2.zxy * r0.www; @@ -160,11 +99,10 @@ void main( r6.x = saturate(cb1[2].x + -2.79999995); r6.x = 5 * r6.x; r6.y = saturate(r6.y * r4.w + r6.x); - r4.w = cb0[82].x / cb0[82].y; - r6.z = -1 + r4.w; - r6.z = cb1[2].w * r6.z + 1; - r4.w = r4.w * 0.5625 + -r6.z; - r4.w = cb1[1].w * r4.w + r6.z; + r4.w = cb0[27].z + -1; + r4.w = cb1[2].w * r4.w + 1; + r6.z = cb0[27].z * 0.5625 + -r4.w; + r4.w = cb1[1].w * r6.z + r4.w; r6.x = saturate(r4.w * r3.w); r6.xy = log2(r6.xy); r6.xy = cb1[2].zz * r6.xy; @@ -178,7 +116,7 @@ void main( r7.xyz = -r7.xyz * cb1[9].zzz + r1.xyz; r2.xyz = r3.xyz ? r4.xyz : r2.zxy; r2.xyz = r2.xyz * cb1[11].zxy + r7.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * float3(0.166666672,0.166666672,0.166666672) + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; r0.w = saturate(cb1[3].x * 3 + -2); r1.x = min(r5.x, r5.z); @@ -202,30 +140,47 @@ void main( r1.xyz = -cb1[4].zxy + float3(1,1,1); r1.xyz = r0.www * r1.xyz + cb1[4].zxy; r0.xyz = r1.xyz * r0.xyz; - r0.xyz = cb1[7].www * r0.xyz; - renodx::lut::Config lut_config = renodx::lut::config::Create( - s1_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + r0.xyz = cb1[7].www * r0.xyz; + /* Original Code + r0.xyz = r0.xyz * float3(5.55555582,5.55555582,5.55555582) + float3(0.0479959995,0.0479959995,0.0479959995); + r0.xyz = max(float3(0,0,0), r0.xyz); + r0.xyz = log2(r0.xyz); + r0.xyz = saturate(r0.xyz * float3(0.0734997839,0.0734997839,0.0734997839) + float3(0.386036009,0.386036009,0.386036009)); + r0.yzw = cb1[7].zzz * r0.xyz; + r0.y = floor(r0.y); + r1.xy = cb1[7].xy * float2(0.5,0.5); + r1.yz = r0.zw * cb1[7].xy + r1.xy; + r1.x = r0.y * cb1[7].y + r1.y; + r2.xyz = t2.SampleLevel(s1_s, r1.xz, 0).xyz; + r3.x = cb1[7].y; + r3.y = 0; + r0.zw = r3.xy + r1.xz; + r1.xyz = t2.SampleLevel(s1_s, r0.zw, 0).xyz; + r0.x = r0.x * cb1[7].z + -r0.y; + r0.yzw = r1.xyz + -r2.xyz; + r0.xyz = r0.xxx * r0.yzw + r2.xyz; + r1.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; + r2.xyz = log2(abs(r0.xyz)); + r2.xyz = float3(0.416666657,0.416666657,0.416666657) * r2.xyz; + r2.xyz = exp2(r2.xyz); + r2.xyz = r2.xyz * float3(1.05499995,1.05499995,1.05499995) + float3(-0.0549999997,-0.0549999997,-0.0549999997); + r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); + r0.xyz = r0.xyz ? r1.xyz : r2.xyz; + r1.xy = cb0[0].xy * v1.xy; + r0.w = dot(float2(171,231), r1.xy); + r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; + r1.xyz = frac(r1.xyz); + r1.xyz = float3(-0.5,-0.5,-0.5) + r1.xyz; + o0.xyz = r1.xyz * float3(0.0013725491,0.0013725491,0.0013725491) + r0.xyz; + o0.w = min(1, r1.w); + return; + */ + LUTSampleResult lut_sample = LUTSAMPLE(s1_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -239,4 +194,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r1.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/uberpost/uberpost_0x51359B4D.ps_5_0.hlsl b/src/games/endfield/uberpost/uberpost_0xFFFBB3BD.ps_5_0.hlsl similarity index 81% rename from src/games/endfield/uberpost/uberpost_0x51359B4D.ps_5_0.hlsl rename to src/games/endfield/uberpost/uberpost_0xFFFBB3BD.ps_5_0.hlsl index 65ef2875a4..fccb61c0b2 100644 --- a/src/games/endfield/uberpost/uberpost_0x51359B4D.ps_5_0.hlsl +++ b/src/games/endfield/uberpost/uberpost_0xFFFBB3BD.ps_5_0.hlsl @@ -15,7 +15,7 @@ cbuffer cb1 : register(b1) cbuffer cb0 : register(b0) { - float4 cb0[110]; + float4 cb0[28]; } @@ -38,7 +38,7 @@ void main( r1.x = r0.x * 0.5 + r0.y; r1.x = r0.z * 0.5 + r1.x; r2.xw = float2(0,0); - r2.yz = cb0[82].wz; + r2.yz = cb0[0].wz; r3.xyzw = v1.xyxy + -r2.zwxy; r2.xyzw = v1.xyxy + r2.xyzw; r1.yzw = t0.SampleLevel(s0_s, r3.xy, 0).xyz; @@ -96,7 +96,7 @@ void main( r1.x = 1 / r1.x; r0.xyz = r1.xxx * r0.xyz; o0.w = min(1, r0.w); - r1.xyz = cb0[109].xxx * r0.xyz; + r1.xyz = cb0[27].xxx * r0.xyz; r0.w = max(r1.y, r1.z); r0.w = max(r0.w, r1.x); r2.xy = -cb1[10].yx + r0.ww; @@ -119,13 +119,12 @@ void main( r5.xyz = cmp(float3(0.300000012,0.300000012,0.300000012) < r5.xyz); r3.xyz = r5.xyz ? r4.xyz : r3.zxy; r2.xyz = r3.xyz * cb1[11].zxy + r2.xyz; - r0.xyz = -r0.xyz * cb0[109].xxx + r2.xyz; + r0.xyz = -r0.xyz * cb0[27].xxx + r2.xyz; r0.xyz = cb1[9].xxx * r0.xyz + r1.xyz; - r0.w = cb0[82].x / cb0[82].y; - r1.x = -1 + r0.w; - r1.x = cb1[2].w * r1.x + 1; - r0.w = r0.w * 0.5625 + -r1.x; - r0.w = cb1[1].w * r0.w + r1.x; + r0.w = cb0[27].z + -1; + r0.w = cb1[2].w * r0.w + 1; + r1.x = cb0[27].z * 0.5625 + -r0.w; + r0.w = cb1[1].w * r1.x + r0.w; r1.x = saturate(cb1[2].x * 1.04999995); r1.x = r1.x * 1.5 + -1; r1.x = cb1[1].w * r1.x + 1; @@ -183,7 +182,7 @@ void main( r2.xyz = float3(12.9200001,12.9200001,12.9200001) * r0.xyz; r0.xyz = cmp(float3(0.00313080009,0.00313080009,0.00313080009) >= r0.xyz); r0.xyz = r0.xyz ? r2.xyz : r1.xyz; - r1.xy = cb0[82].xy * v1.xy; + r1.xy = cb0[0].xy * v1.xy; r0.w = dot(float2(171,231), r1.xy); r1.xyz = float3(0.00970873795,0.0140845068,0.010309278) * r0.www; r1.xyz = frac(r1.xyz); @@ -203,29 +202,12 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); } */ - renodx::lut::Config lut_config = renodx::lut::config::Create( - s0_s, - shader_injection.color_grade_strength, - 0.f, - renodx::lut::config::type::ARRI_C1000_NO_CUT, - renodx::lut::config::type::LINEAR, - cb1[7].xyz - ); - float3 graded = renodx::lut::Sample(t2, lut_config, r0.yzx); - + LUTSampleResult lut_sample = LUTSAMPLE(s0_s, cb1[7].xyz, t2, r0.yzx); [branch] if (shader_injection.tone_map_type == 0.f) { - o0.xyz = renodx::tonemap::ExponentialRollOff(max(0, graded), 0.18f, 1.f); + o0.xyz = SDRGRADE(lut_sample); } else { - UserGradingConfig cg_config = CreateColorGradeConfig(); - float y = renodx::color::y::from::BT709(graded); - float3 graded_ap1 = renodx::color::ap1::from::BT709(graded); - float3 hue_chrominance_reference_color = renodx::color::bt709::from::AP1(renodx::tonemap::ReinhardPiecewise(graded_ap1, 2.f, 0.18f)); - float3 graded_bt709 = ApplyExposureContrastFlareHighlightsShadowsByLuminance(graded, y, cg_config); - o0.xyz = ApplySaturationBlowoutHueCorrectionHighlightSaturation(graded_bt709, hue_chrominance_reference_color, y, cg_config); - o0.xyz = renodx::color::bt2020::from::BT709(o0.xyz); - o0.xyz = ApplyHermiteSplineByMaxChannel(o0.xyz, shader_injection.peak_white_nits / shader_injection.diffuse_white_nits); - o0.xyz = renodx::color::bt709::from::BT2020(o0.xyz); + o0.xyz = HDRGRADE(lut_sample); } // Apply vignette after tonemapping o0.xyz *= vignette_value; @@ -239,4 +221,4 @@ void main( o0.xyz = renodx::draw::RenderIntermediatePass(o0.xyz); o0.w = min(1, r0.w); return; -} \ No newline at end of file +} diff --git a/src/games/endfield/ui/latencybar_0xF4EF16E9.vs_5_0.hlsl b/src/games/endfield/ui/latencybar_0xF4EF16E9.vs_5_0.hlsl new file mode 100644 index 0000000000..f20ce5764b --- /dev/null +++ b/src/games/endfield/ui/latencybar_0xF4EF16E9.vs_5_0.hlsl @@ -0,0 +1,96 @@ +#include "../shared.h" + +cbuffer cb4 : register(b4) { + float4 cb4[12]; +} + +cbuffer cb3 : register(b3) { + float4 cb3[9]; +} + +cbuffer cb2 : register(b2) { + float4 cb2[48]; +} + +cbuffer cb1 : register(b1) { + float4 cb1[1]; +} + +cbuffer cb0 : register(b0) { + float4 cb0[21]; +} + +void main( + float4 v0 : POSITION0, + float4 v1 : COLOR0, + float2 v2 : TEXCOORD0, + out float4 o0 : SV_Position0, + out float4 o1 : TEXCOORD0, + out float2 o2 : TEXCOORD1, + out float4 o3 : TEXCOORD2, + out float4 o4 : TEXCOORD3, + out float4 o5 : TEXCOORD4) { + float4 r0, r1, r2, r3; + + r0.xy = -cb1[0].yz * float2(2, 2) + float2(1, 1); + r1.xyz = cb3[1].xyz * v0.yyy; + r1.xyz = cb3[0].xyz * v0.xxx + r1.xyz; + r1.xyz = cb3[2].xyz * v0.zzz + r1.xyz; + r1.xyz = cb3[3].xyz + r1.xyz; + r1.xyz = -cb2[44].xyz * cb1[0].xxx + r1.xyz; + r1.w = 1; + r0.z = 0 < cb1[0].x ? 1.0 : 0.0; + r2.x = r0.z != 0 ? cb2[32].x : cb0[17].x; + r2.y = r0.z != 0 ? cb2[33].x : cb0[18].x; + r2.z = r0.z != 0 ? cb2[34].x : cb0[19].x; + r2.w = r0.z != 0 ? cb2[35].x : cb0[20].x; + r2.x = dot(r2.xyzw, r1.xyzw); + r3.x = r0.z != 0 ? cb2[32].y : cb0[17].y; + r3.y = r0.z != 0 ? cb2[33].y : cb0[18].y; + r3.z = r0.z != 0 ? cb2[34].y : cb0[19].y; + r3.w = r0.z != 0 ? cb2[35].y : cb0[20].y; + r2.y = dot(r3.xyzw, r1.xyzw); + r0.xy = r2.xy * r0.xy; + r2.xy = r0.zz != 0 ? r0.xy : r2.xy; + r3.x = r0.z != 0 ? cb2[32].z : cb0[17].z; + r3.y = r0.z != 0 ? cb2[33].z : cb0[18].z; + r3.z = r0.z != 0 ? cb2[34].z : cb0[19].z; + r3.w = r0.z != 0 ? cb2[35].z : cb0[20].z; + r2.z = dot(r3.xyzw, r1.xyzw); + r3.x = r0.z != 0 ? cb2[32].w : cb0[17].w; + r3.y = r0.z != 0 ? cb2[33].w : cb0[18].w; + r3.z = r0.z != 0 ? cb2[34].w : cb0[19].w; + r3.w = r0.z != 0 ? cb2[35].w : cb0[20].w; + r2.w = dot(r3.xyzw, r1.xyzw); + o0.xyzw = r2.xyzw; + o5.zw = r2.zw; + r0.x = cb4[11].y != 0.000000 ? 1.0 : 0.0; + r1.xyzw = r0.xxxx != 0 ? cb4[11].zzzw : float4(1, 1, 1, 1); + r3.xyzw = cb4[8].xyzw * v1.xyzw; + o1.xyzw = r3.xyzw * r1.xyzw; + o2.xy = v2.xy * cb4[9].xy + cb4[9].zw; + o3.xyzw = v0.xyzw; + r1.xz = r0.zz != 0 ? cb2[8].yx : cb0[5].yx; + r1.yw = r0.zz != 0 ? cb2[9].yx : cb0[6].yx; + r0.z = dot(r1.zw, cb2[47].xy); + r0.w = dot(r1.xy, cb2[47].xy); + r0.xy = r2.ww / abs(r0.zw); + r1.xz = float2(0.5, 0.5) * r2.xw; + r0.z = cb2[46].x * r2.y; + r1.w = 0.5 * r0.z; + o5.xy = r1.xw + r1.zz; + r0.xy = cb3[8].yz * float2(0.25, 0.25) + abs(r0.xy); + o4.zw = float2(0.25, 0.25) / r0.xy; + r0.xyzw = max(cb3[6].xyzw, float4(-2e+10, -2e+10, -2e+10, -2e+10)); + r0.xyzw = min(float4(2e+10, 2e+10, 2e+10, 2e+10), r0.xyzw); + r0.xy = v0.xy * float2(2, 2) + -r0.xy; + o4.xy = r0.xy + -r0.zw; + + if (LATENCY_BAR_DRAW_OPACITY < 0.5f) { + float2 ndc = o0.xy / max(abs(o0.w), 0.00001f); + if ((ndc.x >= -0.99f && ndc.x <= -0.93f) + && (ndc.y >= -0.99f && ndc.y <= -0.90f)) { + o0 = float4(2.0f, 2.0f, 0.0f, 1.0f); + } + } +} diff --git a/src/games/endfield/ui/ui10_0x65EB732F.ps_5_0.hlsl b/src/games/endfield/ui/ui10_0x65EB732F.ps_5_0.hlsl deleted file mode 100644 index 2891c3d216..0000000000 --- a/src/games/endfield/ui/ui10_0x65EB732F.ps_5_0.hlsl +++ /dev/null @@ -1,109 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 15:07:05 2026 - -#include "../shared.h" - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[33]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - float4 v6 : TEXCOORD5, - float4 v7 : TEXCOORD6, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3,r4,r5; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = t2.Sample(s2_s, v2.xy).w; - r0.y = -v3.x + r0.x; - r0.y = cmp(r0.y < 0); - if (r0.y != 0) discard; - r0.x = v3.z + -r0.x; - r0.y = cb1[22].w * cb1[6].x; - r0.z = cb1[22].w * cb1[4].y; - r0.yw = v3.yy * r0.yz; - r1.xyz = cb1[3].xyz * v1.xyz; - r2.xy = cb1[2].xy * cb0[0].yy + v6.xy; - r2.xyzw = t0.Sample(s0_s, r2.xy).xyzw; - r1.xyz = r2.xyz * r1.xyz; - r2.w = cb1[3].w * r2.w; - r3.xy = cb1[4].zw * cb0[0].yy + v6.zw; - r3.xyzw = t1.Sample(s1_s, r3.xy).xyzw; - r3.xyzw = cb1[5].xyzw * r3.xyzw; - r1.w = 0.5 * r0.y; - r2.xyz = r2.www * r1.xyz; - r3.xyz = r3.xyz * r3.www; - r1.xy = cb1[26].zw + -cb1[26].xy; - r1.xy = -abs(v4.xy) + r1.xy; - r1.xy = saturate(v4.zw * r1.xy); - r4.xyzw = max(cb1[26].xyzw, float4(-2e+10,-2e+10,-2e+10,-2e+10)); - r4.xyzw = min(float4(2e+10,2e+10,2e+10,2e+10), r4.xyzw); - r5.xy = v4.xy + r4.xy; - r5.xy = r5.xy + r4.zw; - r1.z = saturate(r0.x * v3.y + r1.w); - r0.y = min(1, r0.y); - r0.y = sqrt(r0.y); - r0.y = r1.z * r0.y; - r3.xyzw = r3.xyzw + -r2.xyzw; - r2.xyzw = r0.yyyy * r3.xyzw + r2.xyzw; - r0.x = r0.x * v3.y + -r1.w; - r0.x = r0.w * 0.5 + r0.x; - r0.y = r0.z * v3.y + 1; - r0.x = saturate(r0.x / r0.y); - r0.x = 1 + -r0.x; - r0.xyzw = r2.xyzw * r0.xxxx; - r1.x = r1.x * r1.y; - r0.xyzw = r1.xxxx * r0.xyzw; - r1.xy = r5.xy * float2(0.5,0.5) + -r4.xy; - r2.xyzw = float4(1,1,1,1) / cb1[32].xzyw; - r1.xy = saturate(r2.xz * r1.xy); - r1.zw = r1.xy * float2(-2,-2) + float2(3,3); - r1.xy = r1.xy * r1.xy; - r1.xy = r1.zw * r1.xy; - r1.zw = -r5.xy * float2(0.5,0.5) + r4.zw; - r1.zw = saturate(r1.zw * r2.yw); - r2.xy = r1.zw * float2(-2,-2) + float2(3,3); - r1.zw = r1.zw * r1.zw; - r1.zw = r2.xy * r1.zw; - r1.x = r1.x * r1.z; - r1.x = r1.x * r1.y; - r1.x = r1.x * r1.w; - r0.xyzw = r1.xxxx * r0.xyzw; - o0.xyzw = v1.wwww * r0.xyzw; - - if (UI_VISIBILITY < 0.5f) o0 = 0; - - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui11_0x85497B0F.ps_5_0.hlsl b/src/games/endfield/ui/ui11_0x85497B0F.ps_5_0.hlsl deleted file mode 100644 index c16f811b0a..0000000000 --- a/src/games/endfield/ui/ui11_0x85497B0F.ps_5_0.hlsl +++ /dev/null @@ -1,139 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 15:07:05 2026 - -#include "../shared.h" - -Texture2D t3 : register(t3); - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s3_s : register(s3); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[27]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = cb0[0].y * 0.0009765625; - r0.y = cmp(r0.x >= -r0.x); - r0.x = frac(abs(r0.x)); - r0.x = r0.y ? r0.x : -r0.x; - r0.x = 1024 * r0.x; - r1.xyzw = cb1[21].xxyy * r0.xxxx + v2.xxyy; - r1.xyzw = float4(-0.5,-0.5,-0.5,-0.5) + r1.xyzw; - r1.xyzw = cb1[18].xyzw * r1.xyzw; - r0.yz = r1.xy + r1.zw; - r0.yz = float2(0.5,0.5) + r0.yz; - r0.yz = r0.yz * cb1[19].xy + cb1[19].zw; - r0.yzw = t1.Sample(s1_s, r0.yz).xyw; - r0.zw = r0.wz * float2(2,2) + float2(-1,-1); - r0.zw = cb1[16].yy * r0.zw; - r1.x = cb1[15].w + 1; - r0.y = r0.y * r1.x + -cb1[15].w; - r1.yz = cb1[16].yz * r0.yy; - r0.y = cmp(0.000000 != cb1[16].x); - r0.yz = r0.yy ? r0.zw : r1.yz; - r1.yz = cb1[22].xy * r0.xx + v2.xy; - r1.yz = r1.yz * cb1[20].xy + cb1[20].zw; - r1.yzw = t2.Sample(s2_s, r1.yz).xyw; - r0.w = r1.y * r1.x + -cb1[15].w; - r1.xy = r1.wz * float2(2,2) + float2(-1,-1); - r1.xy = cb1[17].yy * r1.xy; - r1.zw = cb1[17].yz * r0.ww; - r0.w = cmp(0.000000 != cb1[17].x); - r1.xy = r0.ww ? r1.xy : r1.zw; - r0.yz = r1.xy + r0.yz; - r1.xyzw = cb1[12].xxyy * r0.xxxx + v2.xxyy; - r2.xyzw = cb1[25].xxyy * r0.xxxx + v2.xxyy; - r2.xyzw = float4(-0.5,-0.5,-0.5,-0.5) + r2.xyzw; - r2.xyzw = cb1[26].xyzw * r2.xyzw; - r0.xw = r2.xy + r2.zw; - r0.xw = float2(0.5,0.5) + r0.xw; - r0.xw = r0.xw * cb1[24].xy + cb1[24].zw; - r0.xw = r0.yz * cb1[23].xx + r0.xw; - r2.xyzw = t3.Sample(s3_s, r0.xw).xyzw; - r1.xyzw = float4(-0.5,-0.5,-0.5,-0.5) + r1.xyzw; - r1.xyzw = cb1[13].xyzw * r1.xyzw; - r0.xw = r1.xy + r1.zw; - r0.xw = float2(0.5,0.5) + r0.xw; - r0.xw = r0.xw * cb1[14].xy + cb1[14].zw; - r0.xy = r0.yz * cb1[10].ww + r0.xw; - r0.xyzw = t0.Sample(s0_s, r0.xy).xyzw; - r1.w = r0.x; - r1.x = 1; - r1.xyzw = r1.xxxw + -r0.xyzw; - r0.xyzw = cb1[11].xxxx * r1.xyzw + r0.xyzw; - r1.x = 255 * v1.w; - r1.x = round(r1.x); - r1.w = 0.00392156886 * r1.x; - r1.xyz = v1.xyz; - r0.xyzw = r1.xyzw * r0.xyzw; - r1.w = r2.x; - r1.x = 1; - r1.xyzw = r1.xxxw + -r2.xyzw; - r1.xyzw = cb1[23].yyyy * r1.xyzw + r2.xyzw; - r0.xyzw = r1.xyzw * r0.xyzw; - r1.xy = cb1[4].zw + -cb1[4].xy; - r1.xy = -abs(v4.xy) + r1.xy; - r1.xy = saturate(v4.zw * r1.xy); - r1.x = r1.x * r1.y; - r0.w = r1.x * r0.w; - r1.xyzw = max(cb1[4].xyzw, float4(-2e+10,-2e+10,-2e+10,-2e+10)); - r1.xyzw = min(float4(2e+10,2e+10,2e+10,2e+10), r1.xyzw); - r2.xy = v4.xy + r1.xy; - r2.xy = r2.xy + r1.zw; - r1.xy = r2.xy * float2(0.5,0.5) + -r1.xy; - r1.zw = -r2.xy * float2(0.5,0.5) + r1.zw; - r2.xyzw = float4(1,1,1,1) / cb1[8].xzyw; - r1.xyzw = saturate(r2.xzyw * r1.xyzw); - r2.xy = r1.xy * float2(-2,-2) + float2(3,3); - r1.xy = r1.xy * r1.xy; - r1.xy = r2.xy * r1.xy; - r2.xy = r1.zw * float2(-2,-2) + float2(3,3); - r1.zw = r1.zw * r1.zw; - r1.zw = r2.xy * r1.zw; - r1.x = r1.x * r1.z; - r1.x = r1.x * r1.y; - r1.x = r1.x * r1.w; - r0.w = r1.x * r0.w; - o0.xyz = r0.xyz * r0.www; - o0.w = cb1[9].z * -r0.w + r0.w; - - if (UI_VISIBILITY < 0.5f) o0 = 0; - - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui2_0x3DBCEA15.ps_5_0.hlsl b/src/games/endfield/ui/ui2_0x3DBCEA15.ps_5_0.hlsl deleted file mode 100644 index 01ea2c7012..0000000000 --- a/src/games/endfield/ui/ui2_0x3DBCEA15.ps_5_0.hlsl +++ /dev/null @@ -1,84 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 11:53:21 2026 -#include "../shared.h" - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb0 : register(b0) -{ - float4 cb0[19]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb0[8].yw + float2(1,1); - r1.xyzw = -cb0[7].xyzw + v2.zzww; - r0.xy = r1.yw * r0.xy; - r0.zw = -cb0[7].yw + float2(1,1); - r0.xy = r0.xy / r0.zw; - r0.xy = cb0[8].yw + r0.xy; - r0.zw = cmp(float2(1,1) >= v2.zw); - r0.xy = r0.zw ? r0.xy : v2.zw; - r0.zw = cb0[8].yw + -cb0[8].xz; - r0.zw = r1.xz * r0.zw; - r1.xy = cb0[7].yw + -cb0[7].xz; - r0.zw = r0.zw / r1.xy; - r0.zw = cb0[8].xz + r0.zw; - r1.xyzw = cmp(cb0[7].xyzw >= v2.zzww); - r0.xy = r1.yw ? r0.zw : r0.xy; - r0.zw = cb0[8].xz * v2.zw; - r0.zw = r0.zw / cb0[7].xz; - r1.yw = cmp(v2.zw >= float2(0,0)); - r1.xy = r1.xz ? r1.yw : 0; - r0.xy = r1.xy ? r0.zw : r0.xy; - r0.zw = cmp(v2.zw < float2(0,0)); - r0.xy = r0.zw ? v2.zw : r0.xy; - r0.z = cmp(0.000000 != cb0[9].x); - r0.xy = r0.zz ? r0.xy : v2.zw; - r0.zw = cmp(float2(1,1) >= r0.xy); - r0.zw = r0.zw ? float2(1,1) : 0; - r1.xy = cmp(float2(0,0) >= -r0.xy); - r0.xy = r0.xy * cb0[2].xy + cb0[2].zw; - r0.x = t1.Sample(s1_s, r0.xy).w; - r1.xy = r1.xy ? float2(1,1) : 0; - r0.yz = r1.xy * r0.zw; - r0.x = r0.x * r0.y; - r0.x = r0.x * r0.z; - r0.y = cmp(0.000000 != cb0[18].z); - r1.xyzw = t0.Sample(s0_s, v2.xy).xyzw; - r1.w = r0.y ? 1 : r1.w; - r1.xyzw = cb0[11].xyzw + r1.xyzw; - r0.y = 255 * v1.w; - r0.y = round(r0.y); - r2.w = 0.00392156886 * r0.y; - r2.xyz = v1.xyz; - r1.xyzw = r2.xyzw * r1.xyzw; - r0.x = r1.w * r0.x; - o0.xyz = r1.xyz * r0.xxx; - o0.w = cb0[17].z * -r0.x + r0.x; - if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui3_0xF0C4C307.ps_5_0.hlsl b/src/games/endfield/ui/ui3_0xF0C4C307.ps_5_0.hlsl deleted file mode 100644 index 9735cf4268..0000000000 --- a/src/games/endfield/ui/ui3_0xF0C4C307.ps_5_0.hlsl +++ /dev/null @@ -1,109 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 11:53:21 2026 -#include "../shared.h" - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[24]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = cb0[0].y * 0.0009765625; - r0.y = cmp(r0.x >= -r0.x); - r0.x = frac(abs(r0.x)); - r0.x = r0.y ? r0.x : -r0.x; - r0.x = 1024 * r0.x; - r0.xyzw = cb1[23].xxyy * r0.xxxx + v2.xxyy; - r0.xyzw = float4(-0.5,-0.5,-0.5,-0.5) + r0.xyzw; - r0.xyzw = cb1[20].xyzw * r0.xyzw; - r0.xy = r0.xy + r0.zw; - r0.xy = float2(0.5,0.5) + r0.xy; - r0.xy = r0.xy * cb1[21].xy + cb1[21].zw; - r0.xyzw = t2.Sample(s2_s, r0.xy).xyzw; - r1.x = cmp(0.000000 != cb1[18].z); - r2.xyzw = t0.Sample(s0_s, v2.xy).xyzw; - r2.w = r1.x ? 1 : r2.w; - r1.xyzw = cb1[11].xyzw + r2.xyzw; - r2.x = 255 * v1.w; - r2.x = round(r2.x); - r2.w = 0.00392156886 * r2.x; - r0.w = r2.w * r1.w + r0.w; - r0.w = saturate(cb1[22].w * r0.w); - r2.xyz = v1.xyz; - r1.xyzw = r2.xyzw * r1.xyzw; - r0.xyz = r0.xyz * cb1[22].xyz + -r1.xyz; - r0.xyz = r0.www * r0.xyz + r1.xyz; - r1.xy = -cb1[8].yw + float2(1,1); - r2.xyzw = -cb1[7].xyzw + v2.zzww; - r1.xy = r2.yw * r1.xy; - r2.yw = -cb1[7].yw + float2(1,1); - r1.xy = r1.xy / r2.yw; - r1.xy = cb1[8].yw + r1.xy; - r2.yw = cmp(float2(1,1) >= v2.zw); - r1.xy = r2.yw ? r1.xy : v2.zw; - r2.yw = cb1[8].yw + -cb1[8].xz; - r2.xy = r2.xz * r2.yw; - r2.zw = cb1[7].yw + -cb1[7].xz; - r2.xy = r2.xy / r2.zw; - r2.xy = cb1[8].xz + r2.xy; - r3.xyzw = cmp(cb1[7].xyzw >= v2.zzww); - r1.xy = r3.yw ? r2.xy : r1.xy; - r2.xy = cb1[8].xz * v2.zw; - r2.xy = r2.xy / cb1[7].xz; - r2.zw = cmp(v2.zw >= float2(0,0)); - r2.zw = r3.xz ? r2.zw : 0; - r1.xy = r2.zw ? r2.xy : r1.xy; - r2.xy = cmp(v2.zw < float2(0,0)); - r1.xy = r2.xy ? v2.zw : r1.xy; - r0.w = cmp(0.000000 != cb1[9].x); - r1.xy = r0.ww ? r1.xy : v2.zw; - r2.xy = cmp(float2(1,1) >= r1.xy); - r2.xy = r2.xy ? float2(1,1) : 0; - r2.zw = cmp(float2(0,0) >= -r1.xy); - r1.xy = r1.xy * cb1[2].xy + cb1[2].zw; - r0.w = t1.Sample(s1_s, r1.xy).w; - r1.xy = r2.zw ? float2(1,1) : 0; - r1.xy = r2.xy * r1.xy; - r0.w = r1.x * r0.w; - r0.w = r0.w * r1.y; - r0.w = r1.w * r0.w; - o0.xyz = r0.xyz * r0.www; - o0.w = cb1[17].z * -r0.w + r0.w; - if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui4_0xB75B5932.ps_5_0.hlsl b/src/games/endfield/ui/ui4_0xB75B5932.ps_5_0.hlsl deleted file mode 100644 index 21d21482b3..0000000000 --- a/src/games/endfield/ui/ui4_0xB75B5932.ps_5_0.hlsl +++ /dev/null @@ -1,110 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 11:53:21 2026 -#include "../shared.h" - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[33]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - float4 v6 : TEXCOORD5, - float4 v7 : TEXCOORD6, - float4 v8 : TEXCOORD7, - float4 v9 : TEXCOORD8, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = cb1[4].zw * cb0[0].yy + v8.zw; - r0.xyzw = t1.Sample(s1_s, r0.xy).xyzw; - r0.xyzw = cb1[5].xyzw * r0.xyzw; - r0.xyz = r0.xyz * r0.www; - r1.xyz = cb1[3].xyz * v1.xyz; - r2.xy = cb1[2].xy * cb0[0].yy + v8.xy; - r2.xyzw = t0.Sample(s0_s, r2.xy).xyzw; - r1.xyz = r2.xyz * r1.xyz; - r2.w = cb1[3].w * r2.w; - r2.xyz = r2.www * r1.xyz; - r0.xyzw = -r2.xyzw + r0.xyzw; - r1.x = cb1[22].w * cb1[6].x; - r1.x = v3.y * r1.x; - r1.y = min(1, r1.x); - r1.x = 0.5 * r1.x; - r1.y = sqrt(r1.y); - r1.z = t2.Sample(s2_s, v2.xy).w; - r1.z = v3.z + -r1.z; - r1.w = saturate(r1.z * v3.y + r1.x); - r1.x = r1.z * v3.y + -r1.x; - r1.y = r1.w * r1.y; - r0.xyzw = r1.yyyy * r0.xyzw + r2.xyzw; - r1.y = cb1[22].w * cb1[4].y; - r1.z = v3.y * r1.y; - r1.y = r1.y * v3.y + 1; - r1.x = r1.z * 0.5 + r1.x; - r1.x = saturate(r1.x / r1.y); - r1.x = 1 + -r1.x; - r2.xyzw = r1.xxxx * r0.xyzw; - r0.x = -r0.w * r1.x + 1; - r0.y = t2.Sample(s2_s, v6.xy).w; - r0.y = saturate(r0.y * v6.z + -v6.w); - r1.xyzw = v7.xyzw * r0.yyyy; - r0.xyzw = r1.xyzw * r0.xxxx + r2.xyzw; - r1.xy = cb1[26].zw + -cb1[26].xy; - r1.xy = -abs(v4.xy) + r1.xy; - r1.xy = saturate(v4.zw * r1.xy); - r1.x = r1.x * r1.y; - r0.xyzw = r1.xxxx * r0.xyzw; - r1.xyzw = max(cb1[26].xyzw, float4(-2e+10,-2e+10,-2e+10,-2e+10)); - r1.xyzw = min(float4(2e+10,2e+10,2e+10,2e+10), r1.xyzw); - r2.xy = v4.xy + r1.xy; - r2.xy = r2.xy + r1.zw; - r1.xy = r2.xy * float2(0.5,0.5) + -r1.xy; - r1.zw = -r2.xy * float2(0.5,0.5) + r1.zw; - r2.xyzw = float4(1,1,1,1) / cb1[32].xzyw; - r1.xyzw = saturate(r2.xzyw * r1.xyzw); - r2.xy = r1.xy * float2(-2,-2) + float2(3,3); - r1.xy = r1.xy * r1.xy; - r1.xy = r2.xy * r1.xy; - r2.xy = r1.zw * float2(-2,-2) + float2(3,3); - r1.zw = r1.zw * r1.zw; - r1.zw = r2.xy * r1.zw; - r1.x = r1.x * r1.z; - r1.x = r1.x * r1.y; - r1.x = r1.x * r1.w; - r0.xyzw = r1.xxxx * r0.xyzw; - o0.xyzw = v1.wwww * r0.xyzw; - if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui5_0x73F08C2F.ps_5_0.hlsl b/src/games/endfield/ui/ui5_0x73F08C2F.ps_5_0.hlsl deleted file mode 100644 index e172501c9b..0000000000 --- a/src/games/endfield/ui/ui5_0x73F08C2F.ps_5_0.hlsl +++ /dev/null @@ -1,69 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 11:53:21 2026 -#include "../shared.h" - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb0 : register(b0) -{ - float4 cb0[11]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xyzw = max(cb0[4].xyzw, float4(-2e+10,-2e+10,-2e+10,-2e+10)); - r0.xyzw = min(float4(2e+10,2e+10,2e+10,2e+10), r0.xyzw); - r1.xy = v4.xy + r0.xy; - r1.xy = r1.xy + r0.zw; - r0.xy = r1.xy * float2(0.5,0.5) + -r0.xy; - r0.zw = -r1.xy * float2(0.5,0.5) + r0.zw; - r1.xyzw = float4(1,1,1,1) / cb0[8].xzyw; - r0.xyzw = saturate(r1.xzyw * r0.xyzw); - r1.xy = r0.xy * float2(-2,-2) + float2(3,3); - r0.xy = r0.xy * r0.xy; - r0.xy = r1.xy * r0.xy; - r1.xy = r0.zw * float2(-2,-2) + float2(3,3); - r0.zw = r0.zw * r0.zw; - r0.zw = r1.xy * r0.zw; - r0.x = r0.x * r0.z; - r0.x = r0.x * r0.y; - r0.x = r0.x * r0.w; - r0.y = cmp(0.000000 != cb0[10].z); - r1.xyzw = t0.Sample(s0_s, v2.xy).xyzw; - r1.w = r0.y ? 1 : r1.w; - r1.xyzw = cb0[3].xyzw + r1.xyzw; - r0.y = 255 * v1.w; - r0.y = round(r0.y); - r2.w = 0.00392156886 * r0.y; - r2.xyz = v1.xyz; - r1.xyzw = r2.xyzw * r1.xyzw; - r0.yz = cb0[4].zw + -cb0[4].xy; - r0.yz = -abs(v4.xy) + r0.yz; - r0.yz = saturate(v4.zw * r0.yz); - r0.y = r0.y * r0.z; - r0.y = r1.w * r0.y; - r0.x = r0.y * r0.x; - o0.xyz = r1.xyz * r0.xxx; - o0.w = cb0[9].z * -r0.x + r0.x; - if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui6_0x9325952C.ps_5_0.hlsl b/src/games/endfield/ui/ui6_0x9325952C.ps_5_0.hlsl deleted file mode 100644 index 8b5231aeb5..0000000000 --- a/src/games/endfield/ui/ui6_0x9325952C.ps_5_0.hlsl +++ /dev/null @@ -1,44 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 11:53:21 2026 -#include "../shared.h" - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb0 : register(b0) -{ - float4 cb0[7]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - out float4 o0 : SV_Target0) -{ - float4 r0; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xyz = t0.SampleLevel(s0_s, v4.xy, 0).xyz; - r0.xyz = v1.xyz * r0.xyz; - o0.xyz = cb0[6].xxx * r0.xyz; - r0.x = t1.Sample(s1_s, v2.xy).w; - r0.x = cb0[3].w + r0.x; - o0.w = v1.w * r0.x; - if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui7_0xEC4B4DDC.ps_5_0.hlsl b/src/games/endfield/ui/ui7_0xEC4B4DDC.ps_5_0.hlsl deleted file mode 100644 index 11079d45e4..0000000000 --- a/src/games/endfield/ui/ui7_0xEC4B4DDC.ps_5_0.hlsl +++ /dev/null @@ -1,87 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 11:53:21 2026 -#include "../shared.h" - -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[23]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - float4 v6 : TEXCOORD5, - float4 v7 : TEXCOORD6, - float4 v8 : TEXCOORD7, - float4 v9 : TEXCOORD8, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = cb1[4].zw * cb0[0].yy + v8.zw; - r0.xyzw = t1.Sample(s1_s, r0.xy).xyzw; - r0.xyzw = cb1[5].xyzw * r0.xyzw; - r0.xyz = r0.xyz * r0.www; - r1.xyz = cb1[3].xyz * v1.xyz; - r2.xy = cb1[2].xy * cb0[0].yy + v8.xy; - r2.xyzw = t0.Sample(s0_s, r2.xy).xyzw; - r1.xyz = r2.xyz * r1.xyz; - r2.w = cb1[3].w * r2.w; - r2.xyz = r2.www * r1.xyz; - r0.xyzw = -r2.xyzw + r0.xyzw; - r1.x = cb1[22].w * cb1[6].x; - r1.x = v3.y * r1.x; - r1.y = min(1, r1.x); - r1.x = 0.5 * r1.x; - r1.y = sqrt(r1.y); - r1.z = t2.Sample(s2_s, v2.xy).w; - r1.z = v3.z + -r1.z; - r1.w = saturate(r1.z * v3.y + r1.x); - r1.x = r1.z * v3.y + -r1.x; - r1.y = r1.w * r1.y; - r0.xyzw = r1.yyyy * r0.xyzw + r2.xyzw; - r1.y = cb1[22].w * cb1[4].y; - r1.z = v3.y * r1.y; - r1.y = r1.y * v3.y + 1; - r1.x = r1.z * 0.5 + r1.x; - r1.x = saturate(r1.x / r1.y); - r1.x = 1 + -r1.x; - r2.xyzw = r1.xxxx * r0.xyzw; - r0.x = -r0.w * r1.x + 1; - r0.y = t2.Sample(s2_s, v6.xy).w; - r0.y = saturate(r0.y * v6.z + -v6.w); - r1.xyzw = v7.xyzw * r0.yyyy; - r0.xyzw = r1.xyzw * r0.xxxx + r2.xyzw; - o0.xyzw = v1.wwww * r0.xyzw; - if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui8_0xF6A41919.ps_5_0.hlsl b/src/games/endfield/ui/ui8_0xF6A41919.ps_5_0.hlsl deleted file mode 100644 index db03d69320..0000000000 --- a/src/games/endfield/ui/ui8_0xF6A41919.ps_5_0.hlsl +++ /dev/null @@ -1,111 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 14:33:10 2026 - -#include "../shared.h" - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb0 : register(b0) -{ - float4 cb0[19]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3; - uint4 bitmask, uiDest; - float4 fDest; - - r0.xy = -cb0[8].yw + float2(1,1); - r1.xyzw = -cb0[7].xyzw + v2.zzww; - r0.xy = r1.yw * r0.xy; - r0.zw = -cb0[7].yw + float2(1,1); - r0.xy = r0.xy / r0.zw; - r0.xy = cb0[8].yw + r0.xy; - r0.zw = cmp(float2(1,1) >= v2.zw); - r0.xy = r0.zw ? r0.xy : v2.zw; - r0.zw = cb0[8].yw + -cb0[8].xz; - r0.zw = r1.xz * r0.zw; - r1.xy = cb0[7].yw + -cb0[7].xz; - r0.zw = r0.zw / r1.xy; - r0.zw = cb0[8].xz + r0.zw; - r1.xyzw = cmp(cb0[7].xyzw >= v2.zzww); - r0.xy = r1.yw ? r0.zw : r0.xy; - r0.zw = cb0[8].xz * v2.zw; - r0.zw = r0.zw / cb0[7].xz; - r1.yw = cmp(v2.zw >= float2(0,0)); - r1.xy = r1.xz ? r1.yw : 0; - r0.xy = r1.xy ? r0.zw : r0.xy; - r0.zw = cmp(v2.zw < float2(0,0)); - r0.xy = r0.zw ? v2.zw : r0.xy; - r0.z = cmp(0.000000 != cb0[9].x); - r0.xy = r0.zz ? r0.xy : v2.zw; - r0.zw = cmp(float2(1,1) >= r0.xy); - r0.zw = r0.zw ? float2(1,1) : 0; - r1.xy = cmp(float2(0,0) >= -r0.xy); - r0.xy = r0.xy * cb0[2].xy + cb0[2].zw; - r0.x = t1.Sample(s1_s, r0.xy).w; - r1.xy = r1.xy ? float2(1,1) : 0; - r0.yz = r1.xy * r0.zw; - r0.x = r0.x * r0.y; - r0.x = r0.x * r0.z; - r0.y = cmp(0.000000 != cb0[18].z); - r1.xyzw = t0.Sample(s0_s, v2.xy).xyzw; - r1.w = r0.y ? 1 : r1.w; - r1.xyzw = cb0[11].xyzw + r1.xyzw; - r0.y = 255 * v1.w; - r0.y = round(r0.y); - r2.w = 0.00392156886 * r0.y; - r2.xyz = v1.xyz; - r1.xyzw = r2.xyzw * r1.xyzw; - r0.x = r1.w * r0.x; - r0.yz = cb0[12].zw + -cb0[12].xy; - r0.yz = -abs(v4.xy) + r0.yz; - r0.yz = saturate(v4.zw * r0.yz); - r0.y = r0.y * r0.z; - r0.x = r0.x * r0.y; - r2.xyzw = max(cb0[12].xyzw, float4(-2e+10,-2e+10,-2e+10,-2e+10)); - r2.xyzw = min(float4(2e+10,2e+10,2e+10,2e+10), r2.xyzw); - r0.yz = v4.xy + r2.xy; - r0.yz = r0.yz + r2.zw; - r2.xy = r0.yz * float2(0.5,0.5) + -r2.xy; - r0.yz = -r0.yz * float2(0.5,0.5) + r2.zw; - r3.xyzw = float4(1,1,1,1) / cb0[16].xzyw; - r2.xy = saturate(r3.xz * r2.xy); - r0.yz = saturate(r3.yw * r0.yz); - r2.zw = r2.xy * float2(-2,-2) + float2(3,3); - r2.xy = r2.xy * r2.xy; - r2.xy = r2.zw * r2.xy; - r2.zw = r0.yz * float2(-2,-2) + float2(3,3); - r0.yz = r0.yz * r0.yz; - r0.yz = r2.zw * r0.yz; - r0.y = r2.x * r0.y; - r0.y = r0.y * r2.y; - r0.y = r0.y * r0.z; - r0.x = r0.x * r0.y; - o0.xyz = r1.xyz * r0.xxx; - o0.w = cb0[17].z * -r0.x + r0.x; - - if (UI_VISIBILITY < 0.5f) o0 = 0; - - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui9_0x54B21797.ps_5_0.hlsl b/src/games/endfield/ui/ui9_0x54B21797.ps_5_0.hlsl deleted file mode 100644 index 1a654752c7..0000000000 --- a/src/games/endfield/ui/ui9_0x54B21797.ps_5_0.hlsl +++ /dev/null @@ -1,66 +0,0 @@ -// ---- Created with 3Dmigoto v1.4.1 on Thu Jan 22 14:35:33 2026 - -#include "../shared.h" - -Texture2D t0 : register(t0); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[15]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = cb0[0].y * 0.0009765625; - r0.y = cmp(r0.x >= -r0.x); - r0.x = frac(abs(r0.x)); - r0.x = r0.y ? r0.x : -r0.x; - r0.x = 1024 * r0.x; - r0.xyzw = cb1[12].xxyy * r0.xxxx + v2.xxyy; - r0.xyzw = float4(-0.5,-0.5,-0.5,-0.5) + r0.xyzw; - r0.xyzw = cb1[13].xyzw * r0.xyzw; - r0.xy = r0.xy + r0.zw; - r0.xy = float2(0.5,0.5) + r0.xy; - r0.xy = r0.xy * cb1[14].xy + cb1[14].zw; - r0.xyzw = t0.Sample(s0_s, r0.xy).xyzw; - r1.w = r0.x; - r1.x = 1; - r1.xyzw = r1.xxxw + -r0.xyzw; - r0.xyzw = cb1[11].xxxx * r1.xyzw + r0.xyzw; - r1.x = 255 * v1.w; - r1.x = round(r1.x); - r1.w = 0.00392156886 * r1.x; - r1.xyz = v1.xyz; - r0.xyzw = r1.xyzw * r0.xyzw; - o0.xyz = r0.xyz * r0.www; - o0.w = cb1[9].z * -r0.w + r0.w; - - if (UI_VISIBILITY < 0.5f) o0 = 0; - - return; -} \ No newline at end of file diff --git a/src/games/endfield/ui/ui_0xEF07F89A.ps_5_0.hlsl b/src/games/endfield/ui/ui_0xF1B0E28A.ps_5_0.hlsl similarity index 51% rename from src/games/endfield/ui/ui_0xEF07F89A.ps_5_0.hlsl rename to src/games/endfield/ui/ui_0xF1B0E28A.ps_5_0.hlsl index 117ac3cf91..255d84f0b9 100644 --- a/src/games/endfield/ui/ui_0xEF07F89A.ps_5_0.hlsl +++ b/src/games/endfield/ui/ui_0xF1B0E28A.ps_5_0.hlsl @@ -2,45 +2,38 @@ #include "../shared.h" Texture2D t0 : register(t0); - SamplerState s0_s : register(s0); -cbuffer cb0 : register(b0) -{ - float4 cb0[11]; +cbuffer cb1 : register(b1) { + float4 cb1[13]; } - - +cbuffer cb0 : register(b0) { + float4 cb0[6]; +} // 3Dmigoto declarations -#define cmp - - - void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - out float4 o0 : SV_Target0) -{ - float4 r0,r1; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = cmp(0.000000 != cb0[10].z); + float4 v0 : SV_Position0, + float4 v1 : TEXCOORD0, + float2 v2 : TEXCOORD1, + float4 v3 : TEXCOORD2, + float4 v4 : TEXCOORD3, + float4 v5 : TEXCOORD4, + out float4 o0 : SV_Target0) { + float4 r0, r1; + + r0.x = 0.000000 != cb1[12].x; r1.xyzw = t0.Sample(s0_s, v2.xy).xyzw; r1.w = r0.x ? 1 : r1.w; - r0.xyzw = cb0[3].xyzw + r1.xyzw; + r0.xyzw = cb0[5].xyzw + r1.xyzw; r1.x = 255 * v1.w; r1.x = round(r1.x); r1.w = 0.00392156886 * r1.x; r1.xyz = v1.xyz; r0.xyzw = r1.xyzw * r0.xyzw; o0.xyz = r0.xyz * r0.www; - o0.w = cb0[9].z * -r0.w + r0.w; + o0.w = cb1[11].x * -r0.w + r0.w; + if (UI_VISIBILITY < 0.5f) o0 = 0; - return; -} \ No newline at end of file +} diff --git a/src/games/endfield/ui/uid_0x6B8E9049.ps_5_0.hlsl b/src/games/endfield/ui/uid_0x6B8E9049.ps_5_0.hlsl deleted file mode 100644 index 7ba4ea34b4..0000000000 --- a/src/games/endfield/ui/uid_0x6B8E9049.ps_5_0.hlsl +++ /dev/null @@ -1,102 +0,0 @@ -// ---- Created with 3Dmigoto v1.3.16 on Wed Jan 21 22:51:32 2026 -#include "../shared.h" -Texture2D t2 : register(t2); - -Texture2D t1 : register(t1); - -Texture2D t0 : register(t0); - - - -SamplerState s2_s : register(s2); - -SamplerState s1_s : register(s1); - -SamplerState s0_s : register(s0); - -cbuffer cb1 : register(b1) -{ - float4 cb1[23]; -} - -cbuffer cb0 : register(b0) -{ - float4 cb0[1]; -} - - - - -// 3Dmigoto declarations -#define cmp - - - -void main( - float4 v0 : SV_Position0, - float4 v1 : TEXCOORD0, - float4 v2 : TEXCOORD1, - float4 v3 : TEXCOORD2, - float4 v4 : TEXCOORD3, - float4 v5 : TEXCOORD4, - float4 v6 : TEXCOORD5, - float4 v7 : TEXCOORD6, - out float4 o0 : SV_Target0) -{ - float4 r0,r1,r2,r3; - uint4 bitmask, uiDest; - float4 fDest; - - r0.x = t2.Sample(s2_s, v2.xy).w; - r0.y = -v3.x + r0.x; - r0.y = cmp(r0.y < 0); - if (r0.y != 0) discard; - r0.x = v3.z + -r0.x; - r0.y = cb1[22].w * cb1[6].x; - r0.z = cb1[22].w * cb1[4].y; - r0.yw = v3.yy * r0.yz; - r1.xyz = cb1[3].xyz * v1.xyz; - r2.xy = cb1[2].xy * cb0[0].yy + v6.xy; - r2.xyzw = t0.Sample(s0_s, r2.xy).xyzw; - r1.xyz = r2.xyz * r1.xyz; - r2.w = cb1[3].w * r2.w; - r3.xy = cb1[4].zw * cb0[0].yy + v6.zw; - r3.xyzw = t1.Sample(s1_s, r3.xy).xyzw; - r3.xyzw = cb1[5].xyzw * r3.xyzw; - r1.w = 0.5 * r0.y; - r2.xyz = r2.www * r1.xyz; - r3.xyz = r3.xyz * r3.www; - r1.x = saturate(r0.x * v3.y + r1.w); - r0.y = min(1, r0.y); - r0.y = sqrt(r0.y); - r0.y = r1.x * r0.y; - r3.xyzw = r3.xyzw + -r2.xyzw; - r2.xyzw = r0.yyyy * r3.xyzw + r2.xyzw; - r0.x = r0.x * v3.y + -r1.w; - r0.x = r0.w * 0.5 + r0.x; - r0.y = r0.z * v3.y + 1; - r0.x = saturate(r0.x / r0.y); - r0.x = 1 + -r0.x; - r0.xyzw = r2.xyzw * r0.xxxx; - o0.xyzw = v1.wwww * r0.xyzw; - - if (UI_VISIBILITY < 0.5f) { - o0 = 0; - return; - } - float2 invViewportSize = float2(3840.0f, 2160.0f); - float2 uv = v0.xy / invViewportSize; - - if (STATUS_TEXT_OPACITY < 0.5f) { - bool isUuid = (uv.x >= 0.05f && uv.x <= 0.13f) && (uv.y >= 0.97f); - if (isUuid) { - o0.xyzw = 0.0f; - } - } - if (PING_TEXT_OPACITY < 0.5f) { - bool isPing = (uv.x >= 0.02f && uv.x <= 0.05f) && (uv.y >= 0.97f); - if (isPing) { - o0.xyzw = 0.0f; - } - } - return; -} \ No newline at end of file diff --git a/src/games/endfield/vfx/orb-body_0x97BF4335.cso b/src/games/endfield/vfx/orb-body_0x97BF4335.cso new file mode 100644 index 0000000000..ef2880b8bc Binary files /dev/null and b/src/games/endfield/vfx/orb-body_0x97BF4335.cso differ diff --git a/src/games/endfield/vfx/orb-glow_0x1BF3323D.cso b/src/games/endfield/vfx/orb-glow_0x1BF3323D.cso new file mode 100644 index 0000000000..f7d264f95b Binary files /dev/null and b/src/games/endfield/vfx/orb-glow_0x1BF3323D.cso differ diff --git a/src/games/endfield/vfx/orb-rainbow_0x4D4DDEBE.cso b/src/games/endfield/vfx/orb-rainbow_0x4D4DDEBE.cso new file mode 100644 index 0000000000..d79124a739 Binary files /dev/null and b/src/games/endfield/vfx/orb-rainbow_0x4D4DDEBE.cso differ diff --git a/src/games/endfield/vfx/orb-sparkles_0x50898C70.cso b/src/games/endfield/vfx/orb-sparkles_0x50898C70.cso new file mode 100644 index 0000000000..fb5bf94127 Binary files /dev/null and b/src/games/endfield/vfx/orb-sparkles_0x50898C70.cso differ diff --git a/src/games/endfield/waterfalls/0x4DEFF5F5.cso b/src/games/endfield/waterfalls/0x4DEFF5F5.cso new file mode 100644 index 0000000000..d5d8fcf228 Binary files /dev/null and b/src/games/endfield/waterfalls/0x4DEFF5F5.cso differ