"Merge Tagged PR 9042"

src/audio_core/sink/sink_stream.cpp

@@ -265,20 +265,8 @@ void SinkStream::ProcessAudioOutAndRender(std::span<s16> output_buffer, std::siz
     }
 }
 
-void SinkStream::Stall() {
-    if (stalled) {
-        return;
-    }
-    stalled = true;
-    system.StallProcesses();
-}
+void SinkStream::Stall() {}
 
-void SinkStream::Unstall() {
-    if (!stalled) {
-        return;
-    }
-    system.UnstallProcesses();
-    stalled = false;
-}
+void SinkStream::Unstall() {}
 
 } // namespace AudioCore::Sink

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -348,7 +348,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
             config.unsafe_optimizations = true;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
             config.fastmem_address_space_bits = 64;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
         }

src/core/hle/service/ldn/lan_discovery.cpp

@@ -487,7 +487,7 @@ void LANDiscovery::ReceivePacket(const Network::LDNPacket& packet) {
     std::scoped_lock lock{packet_mutex};
     switch (packet.type) {
     case Network::LDNPacketType::Scan: {
-        LOG_INFO(Frontend, "Scan packet received!");
+        LOG_DEBUG(Frontend, "Scan packet received!");
         if (state == State::AccessPointCreated) {
             // Reply to the sender
             SendPacket(Network::LDNPacketType::ScanResp, network_info, packet.local_ip);
@@ -495,7 +495,7 @@ void LANDiscovery::ReceivePacket(const Network::LDNPacket& packet) {
         break;
     }
     case Network::LDNPacketType::ScanResp: {
-        LOG_INFO(Frontend, "ScanResp packet received!");
+        LOG_DEBUG(Frontend, "ScanResp packet received!");
 
         NetworkInfo info{};
         std::memcpy(&info, packet.data.data(), sizeof(NetworkInfo));
@@ -611,13 +611,6 @@ MacAddress LANDiscovery::GetFakeMac() const {
 
 Result LANDiscovery::GetNodeInfo(NodeInfo& node, const UserConfig& userConfig,
                                  u16 localCommunicationVersion) {
-    const auto network_interface = Network::GetSelectedNetworkInterface();
-
-    if (!network_interface) {
-        LOG_ERROR(Service_LDN, "No network interface available");
-        return ResultNoIpAddress;
-    }
-
     node.mac_address = GetFakeMac();
     node.is_connected = 1;
     std::memcpy(node.user_name.data(), userConfig.user_name.data(), UserNameBytesMax + 1);

src/core/hle/service/ldn/ldn.cpp

@@ -150,7 +150,7 @@ public:
     }
 
     ~IUserLocalCommunicationService() {
-        if (is_initialized) {
+        if (is_network_available) {
             if (auto room_member = room_network.GetRoomMember().lock()) {
                 room_member->Unbind(ldn_packet_received);
             }
@@ -193,7 +193,7 @@ public:
         NetworkInfo network_info{};
         const auto rc = lan_discovery.GetNetworkInfo(network_info);
         if (rc.IsError()) {
-            LOG_ERROR(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
+            LOG_DEBUG(Service_LDN, "NetworkInfo is not valid {}", rc.raw);
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(rc);
             return;
@@ -205,6 +205,14 @@ public:
     }
 
     void GetIpv4Address(Kernel::HLERequestContext& ctx) {
+        if (!is_network_available) {
+            IPC::ResponseBuilder rb{ctx, 4};
+            rb.Push(ResultSuccess);
+            rb.PushRaw(Ipv4Address{127, 0, 0, 1});
+            rb.PushRaw(Ipv4Address{255, 255, 255, 0});
+            return;
+        }
+
         const auto network_interface = Network::GetSelectedNetworkInterface();
 
         if (!network_interface) {
@@ -342,6 +350,13 @@ public:
             return;
         }
 
+        if (!is_network_available) {
+            IPC::ResponseBuilder rb{ctx, 3};
+            rb.Push(ResultSuccess);
+            rb.Push(0);
+            return;
+        }
+
         u16 count = 0;
         std::vector<NetworkInfo> network_infos(network_info_size);
         Result rc = lan_discovery.Scan(network_infos, count, scan_filter);
@@ -488,18 +503,18 @@ public:
     }
 
     void Initialize(Kernel::HLERequestContext& ctx) {
-        const auto rc = InitializeImpl(ctx);
-        if (rc.IsError()) {
-            LOG_ERROR(Service_LDN, "Network isn't initialized, rc={}", rc.raw);
-        }
+        InitializeImpl(ctx);
 
+        // Initialize always returns success
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(rc);
+        rb.Push(ResultSuccess);
     }
 
     void Finalize(Kernel::HLERequestContext& ctx) {
-        if (auto room_member = room_network.GetRoomMember().lock()) {
-            room_member->Unbind(ldn_packet_received);
+        if (is_network_available) {
+            if (auto room_member = room_network.GetRoomMember().lock()) {
+                room_member->Unbind(ldn_packet_received);
+            }
         }
 
         is_initialized = false;
@@ -519,22 +534,25 @@ public:
     }
 
     Result InitializeImpl(Kernel::HLERequestContext& ctx) {
+        lan_discovery.Initialize([&]() { OnEventFired(); });
+        is_initialized = true;
+        is_network_available = false;
+
         const auto network_interface = Network::GetSelectedNetworkInterface();
         if (!network_interface) {
             LOG_ERROR(Service_LDN, "No network interface is set");
-            return ResultAirplaneModeEnabled;
+            return ResultSuccess;
         }
 
         if (auto room_member = room_network.GetRoomMember().lock()) {
             ldn_packet_received = room_member->BindOnLdnPacketReceived(
                 [this](const Network::LDNPacket& packet) { OnLDNPacketReceived(packet); });
+            is_network_available = true;
         } else {
             LOG_ERROR(Service_LDN, "Couldn't bind callback!");
-            return ResultAirplaneModeEnabled;
+            return ResultSuccess;
         }
 
-        lan_discovery.Initialize([&]() { OnEventFired(); });
-        is_initialized = true;
         return ResultSuccess;
     }
 
@@ -547,6 +565,7 @@ public:
     Network::RoomMember::CallbackHandle<Network::LDNPacket> ldn_packet_received;
 
     bool is_initialized{};
+    bool is_network_available{};
 };
 
 class LDNS final : public ServiceFramework<LDNS> {

src/core/internal_network/network_interface.cpp

@@ -199,7 +199,7 @@ std::optional<NetworkInterface> GetSelectedNetworkInterface() {
         });
 
     if (res == network_interfaces.end()) {
-        LOG_ERROR(Network, "Couldn't find selected interface \"{}\"", selected_network_interface);
+        LOG_DEBUG(Network, "Couldn't find selected interface \"{}\"", selected_network_interface);
         return std::nullopt;
     }
 

src/shader_recompiler/backend/glasm/emit_glasm.cpp

@@ -320,6 +320,7 @@ void SetupOptions(const IR::Program& program, const Profile& profile,
     }
     if (stage == Stage::Fragment) {
         header += "OPTION ARB_draw_buffers;";
+        header += "OPTION ARB_fragment_layer_viewport;";
     }
 }
 

src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp

@@ -104,6 +104,9 @@ void EmitGetAttribute(EmitContext& ctx, IR::Inst& inst, IR::Attribute attr, Scal
     case IR::Attribute::PrimitiveId:
         ctx.Add("MOV.F {}.x,primitive.id;", inst);
         break;
+    case IR::Attribute::Layer:
+        ctx.Add("MOV.F {}.x,fragment.layer;", inst);
+        break;
     case IR::Attribute::PositionX:
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:

src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp

@@ -205,6 +205,9 @@ void EmitGetAttribute(EmitContext& ctx, IR::Inst& inst, IR::Attribute attr,
     case IR::Attribute::PrimitiveId:
         ctx.AddF32("{}=itof(gl_PrimitiveID);", inst);
         break;
+    case IR::Attribute::Layer:
+        ctx.AddF32("{}=itof(gl_Layer);", inst);
+        break;
     case IR::Attribute::PositionX:
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -315,6 +315,8 @@ Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr, Id vertex) {
     switch (attr) {
     case IR::Attribute::PrimitiveId:
         return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.primitive_id));
+    case IR::Attribute::Layer:
+        return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.layer));
     case IR::Attribute::PositionX:
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -1359,6 +1359,10 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     if (loads[IR::Attribute::PrimitiveId]) {
         primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
     }
+    if (loads[IR::Attribute::Layer]) {
+        AddCapability(spv::Capability::Geometry);
+        layer = DefineInput(*this, U32[1], false, spv::BuiltIn::Layer);
+    }
     if (loads.AnyComponent(IR::Attribute::PositionX)) {
         const bool is_fragment{stage != Stage::Fragment};
         const spv::BuiltIn built_in{is_fragment ? spv::BuiltIn::Position : spv::BuiltIn::FragCoord};

src/video_core/engines/maxwell_3d.cpp

@@ -232,7 +232,7 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         use_topology_override = true;
         return;
     case MAXWELL3D_REG_INDEX(clear_surface):
-        return ProcessClearBuffers();
+        return ProcessClearBuffers(1);
     case MAXWELL3D_REG_INDEX(report_semaphore.query):
         return ProcessQueryGet();
     case MAXWELL3D_REG_INDEX(render_enable.mode):
@@ -596,8 +596,8 @@ u32 Maxwell3D::GetRegisterValue(u32 method) const {
     return regs.reg_array[method];
 }
 
-void Maxwell3D::ProcessClearBuffers() {
-    rasterizer->Clear();
+void Maxwell3D::ProcessClearBuffers(u32 layer_count) {
+    rasterizer->Clear(layer_count);
 }
 
 void Maxwell3D::ProcessDraw(u32 instance_count) {

src/video_core/engines/maxwell_3d.h

@@ -3086,6 +3086,9 @@ public:
 
     std::vector<u8> inline_index_draw_indexes;
 
+    /// Handles a write to the CLEAR_BUFFERS register.
+    void ProcessClearBuffers(u32 layer_count);
+
 private:
     void InitializeRegisterDefaults();
 
@@ -3120,9 +3123,6 @@ private:
     /// Handles firmware blob 4
     void ProcessFirmwareCall4();
 
-    /// Handles a write to the CLEAR_BUFFERS register.
-    void ProcessClearBuffers();
-
     /// Handles a write to the QUERY_GET register.
     void ProcessQueryGet();
 

src/video_core/macro/macro_hle.cpp

@@ -126,11 +126,25 @@ void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     }
 }
 
-constexpr std::array<std::pair<u64, HLEFunction>, 4> hle_funcs{{
+// Multi-layer Clear
+void HLE_EAD26C3E2109B06B(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
+    ASSERT(parameters.size() == 1);
+
+    const Engines::Maxwell3D::Regs::ClearSurface clear_params{parameters[0]};
+    const u32 rt_index = clear_params.RT;
+    const u32 num_layers = maxwell3d.regs.rt[rt_index].depth;
+    ASSERT(clear_params.layer == 0);
+
+    maxwell3d.regs.clear_surface.raw = clear_params.raw;
+    maxwell3d.ProcessClearBuffers(num_layers);
+}
+
+constexpr std::array<std::pair<u64, HLEFunction>, 5> hle_funcs{{
     {0x771BB18C62444DA0, &HLE_771BB18C62444DA0},
     {0x0D61FC9FAAC9FCAD, &HLE_0D61FC9FAAC9FCAD},
     {0x0217920100488FF7, &HLE_0217920100488FF7},
     {0x3F5E74B9C9A50164, &HLE_3F5E74B9C9A50164},
+    {0xEAD26C3E2109B06B, &HLE_EAD26C3E2109B06B},
 }};
 
 class HLEMacroImpl final : public CachedMacro {

src/video_core/rasterizer_interface.h

@@ -43,7 +43,7 @@ public:
     virtual void Draw(bool is_indexed, u32 instance_count) = 0;
 
     /// Clear the current framebuffer
-    virtual void Clear() = 0;
+    virtual void Clear(u32 layer_count) = 0;
 
     /// Dispatches a compute shader invocation
     virtual void DispatchCompute() = 0;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -136,7 +136,7 @@ void RasterizerOpenGL::LoadDiskResources(u64 title_id, std::stop_token stop_load
     shader_cache.LoadDiskResources(title_id, stop_loading, callback);
 }
 
-void RasterizerOpenGL::Clear() {
+void RasterizerOpenGL::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(OpenGL_Clears);
     if (!maxwell3d->ShouldExecute()) {
         return;

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -69,7 +69,7 @@ public:
     ~RasterizerOpenGL() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;
-    void Clear() override;
+    void Clear(u32 layer_count) override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
     void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -213,7 +213,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     EndTransformFeedback();
 }
 
-void RasterizerVulkan::Clear() {
+void RasterizerVulkan::Clear(u32 layer_count) {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 
     if (!maxwell3d->ShouldExecute()) {
@@ -256,7 +256,7 @@ void RasterizerVulkan::Clear() {
         .rect = regs.clear_control.use_scissor ? GetScissorState(regs, 0, up_scale, down_shift)
                                                : default_scissor,
         .baseArrayLayer = regs.clear_surface.layer,
-        .layerCount = 1,
+        .layerCount = layer_count,
     };
     if (clear_rect.rect.extent.width == 0 || clear_rect.rect.extent.height == 0) {
         return;

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -65,7 +65,7 @@ public:
     ~RasterizerVulkan() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;
-    void Clear() override;
+    void Clear(u32 layer_count) override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
     void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;

src/yuzu/main.cpp

@@ -917,7 +917,6 @@ void GMainWindow::InitializeWidgets() {
         statusBar()->addPermanentWidget(label);
     }
 
-    // TODO (flTobi): Add the widget when multiplayer is fully implemented
     statusBar()->addPermanentWidget(multiplayer_state->GetStatusText(), 0);
     statusBar()->addPermanentWidget(multiplayer_state->GetStatusIcon(), 0);