script to make <26 sdk icon

Signed-off-by: crueter <crueter@eden-emu.dev>

src/android/app/build.gradle.kts

@@ -58,8 +58,7 @@ android {
 
     defaultConfig {
         applicationId = "dev.eden.eden_emulator"
-
-        minSdk = 28
+        minSdk = 24
         targetSdk = 36
         versionName = getGitVersion()
 

src/common/settings.h

@@ -161,7 +161,7 @@ struct Values {
                                          Category::LibraryApplet};
     Setting<AppletMode> photo_viewer_applet_mode{
                                                  linkage, AppletMode::LLE, "photo_viewer_applet_mode", Category::LibraryApplet};
-    Setting<AppletMode> offline_web_applet_mode{linkage, AppletMode::LLE, "offline_web_applet_mode",
+    Setting<AppletMode> offline_web_applet_mode{linkage, AppletMode::HLE, "offline_web_applet_mode",
                                                 Category::LibraryApplet};
     Setting<AppletMode> login_share_applet_mode{linkage, AppletMode::HLE, "login_share_applet_mode",
                                                 Category::LibraryApplet};

src/core/hle/service/am/frontend/applet_web_browser.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -71,6 +68,42 @@ std::string ResolveURL(const std::string& url) {
     return url.substr(0, index) + "lp1" + url.substr(index + 1);
 }
 
+WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
+    std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
+
+    if (web_arg.size() == sizeof(WebArgHeader)) {
+        return {};
+    }
+
+    WebArgInputTLVMap input_tlv_map;
+
+    u64 current_offset = sizeof(WebArgHeader);
+
+    for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
+        if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
+            return input_tlv_map;
+        }
+
+        WebArgInputTLV input_tlv;
+        std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
+
+        current_offset += sizeof(WebArgInputTLV);
+
+        if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
+            return input_tlv_map;
+        }
+
+        std::vector<u8> data(input_tlv.arg_data_size);
+        std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
+
+        current_offset += input_tlv.arg_data_size;
+
+        input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
+    }
+
+    return input_tlv_map;
+}
+
 FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
                                      FileSys::ContentRecordType nca_type) {
     if (nca_type == FileSys::ContentRecordType::Data) {
@@ -111,43 +144,6 @@ FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
     }
 }
 
-#ifdef YUZU_USE_QT_WEB_ENGINE
-WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
-    std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
-
-    if (web_arg.size() == sizeof(WebArgHeader)) {
-        return {};
-    }
-
-    WebArgInputTLVMap input_tlv_map;
-
-    u64 current_offset = sizeof(WebArgHeader);
-
-    for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
-        if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
-            return input_tlv_map;
-        }
-
-        WebArgInputTLV input_tlv;
-        std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
-
-        current_offset += sizeof(WebArgInputTLV);
-
-        if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
-            return input_tlv_map;
-        }
-
-        std::vector<u8> data(input_tlv.arg_data_size);
-        std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
-
-        current_offset += input_tlv.arg_data_size;
-
-        input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
-    }
-
-    return input_tlv_map;
-}
-
 void ExtractSharedFonts(Core::System& system) {
     static constexpr std::array<const char*, 7> DECRYPTED_SHARED_FONTS{
         "FontStandard.ttf",
@@ -225,7 +221,6 @@ void ExtractSharedFonts(Core::System& system) {
         FileSys::VfsRawCopy(decrypted_font, out_file);
     }
 }
-#endif
 
 } // namespace
 
@@ -237,7 +232,6 @@ WebBrowser::WebBrowser(Core::System& system_, std::shared_ptr<Applet> applet_,
 WebBrowser::~WebBrowser() = default;
 
 void WebBrowser::Initialize() {
-#ifdef YUZU_USE_QT_WEB_ENGINE
     FrontendApplet::Initialize();
 
     LOG_INFO(Service_AM, "Initializing Web Browser Applet.");
@@ -290,7 +284,6 @@ void WebBrowser::Initialize() {
         ASSERT_MSG(false, "Invalid ShimKind={}", web_arg_header.shim_kind);
         break;
     }
-#endif
 }
 
 Result WebBrowser::GetStatus() const {
@@ -302,7 +295,6 @@ void WebBrowser::ExecuteInteractive() {
 }
 
 void WebBrowser::Execute() {
-#ifdef YUZU_USE_QT_WEB_ENGINE
     switch (web_arg_header.shim_kind) {
     case ShimKind::Shop:
         ExecuteShop();
@@ -330,10 +322,6 @@ void WebBrowser::Execute() {
         WebBrowserExit(WebExitReason::EndButtonPressed);
         break;
     }
-#else
-    LOG_INFO(Service_AM, "Web Browser Applet disabled, skipping.");
-    WebBrowserExit(WebExitReason::EndButtonPressed);
-#endif
 }
 
 void WebBrowser::ExtractOfflineRomFS() {

src/qt_common/CMakeLists.txt

@@ -45,10 +45,6 @@ if (NOT APPLE AND ENABLE_OPENGL)
     target_compile_definitions(qt_common PUBLIC HAS_OPENGL)
 endif()
 
-if (UNIX AND NOT APPLE)
-    if (TARGET Qt6::GuiPrivate)
-        target_link_libraries(qt_common PRIVATE Qt6::GuiPrivate)
-    else()
-        target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
-    endif()
+if (NOT WIN32)
+    target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
 endif()

src/video_core/buffer_cache/buffer_cache.h

@@ -386,9 +386,11 @@ void BufferCache<P>::BindHostComputeBuffers() {
 template <class P>
 void BufferCache<P>::SetUniformBuffersState(const std::array<u32, NUM_STAGES>& mask,
                                             const UniformBufferSizes* sizes) {
-    if (channel_state->enabled_uniform_buffer_masks != mask) {
-        channel_state->fast_bound_uniform_buffers.fill(0);
-        if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
+    if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
+        if (channel_state->enabled_uniform_buffer_masks != mask) {
+            if constexpr (IS_OPENGL) {
+                channel_state->fast_bound_uniform_buffers.fill(0);
+            }
             channel_state->dirty_uniform_buffers.fill(~u32{0});
             channel_state->uniform_buffer_binding_sizes.fill({});
         }
@@ -804,7 +806,7 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
                     channel_state->uniform_buffer_binding_sizes[stage][binding_index] != size;
                 if (should_fast_bind) {
                     // We only have to bind when the currently bound buffer is not the fast version
-                    channel_state->fast_bound_uniform_buffers[stage] |= 1u << binding_index;
+                    channel_state->fast_bound_uniform_buffers[stage] |= 1U << binding_index;
                     channel_state->uniform_buffer_binding_sizes[stage][binding_index] = size;
                     runtime.BindFastUniformBuffer(stage, binding_index, size);
                 }
@@ -813,8 +815,10 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
                 return;
             }
         }
-        channel_state->fast_bound_uniform_buffers[stage] |= 1u << binding_index;
-        channel_state->uniform_buffer_binding_sizes[stage][binding_index] = size;
+        if constexpr (IS_OPENGL) {
+            channel_state->fast_bound_uniform_buffers[stage] |= 1U << binding_index;
+            channel_state->uniform_buffer_binding_sizes[stage][binding_index] = size;
+        }
         // Stream buffer path to avoid stalling on non-Nvidia drivers or Vulkan
         const std::span<u8> span = runtime.BindMappedUniformBuffer(stage, binding_index, size);
         device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
@@ -835,6 +839,9 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     }
     const u32 offset = buffer.Offset(device_addr);
     if constexpr (IS_OPENGL) {
+        // Fast buffer will be unbound
+        channel_state->fast_bound_uniform_buffers[stage] &= ~(1U << binding_index);
+
         // Mark the index as dirty if offset doesn't match
         const bool is_copy_bind = offset != 0 && !runtime.SupportsNonZeroUniformOffset();
         channel_state->dirty_uniform_buffers[stage] |= (is_copy_bind ? 1U : 0U) << index;
@@ -848,7 +855,6 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     } else {
         runtime.BindUniformBuffer(buffer, offset, size);
     }
-    channel_state->fast_bound_uniform_buffers[stage] &= ~(1u << binding_index);
 }
 
 template <class P>
@@ -1783,7 +1789,12 @@ std::span<u8> BufferCache<P>::ImmediateBuffer(size_t wanted_capacity) {
 
 template <class P>
 bool BufferCache<P>::HasFastUniformBufferBound(size_t stage, u32 binding_index) const noexcept {
-    return ((channel_state->fast_bound_uniform_buffers[stage] >> binding_index) & 1u) != 0;
+    if constexpr (IS_OPENGL) {
+        return ((channel_state->fast_bound_uniform_buffers[stage] >> binding_index) & 1) != 0;
+    } else {
+        // Only OpenGL has fast uniform buffers
+        return false;
+    }
 }
 
 template <class P>

src/video_core/buffer_cache/buffer_cache_base.h

@@ -54,8 +54,6 @@ constexpr u32 NUM_STORAGE_BUFFERS = 16;
 constexpr u32 NUM_TEXTURE_BUFFERS = 32;
 constexpr u32 NUM_STAGES = 5;
 
-static_assert(NUM_GRAPHICS_UNIFORM_BUFFERS <= 32, "fast bitmask must fit u32");
-
 using UniformBufferSizes = std::array<std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES>;
 using ComputeUniformBufferSizes = std::array<u32, NUM_COMPUTE_UNIFORM_BUFFERS>;
 
@@ -139,8 +137,8 @@ public:
     u32 written_compute_texture_buffers = 0;
     u32 image_compute_texture_buffers = 0;
 
-    std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS> uniform_cache_hits{};
-    std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS> uniform_cache_shots{};
+    std::array<u32, 16> uniform_cache_hits{};
+    std::array<u32, 16> uniform_cache_shots{};
 
     u32 uniform_buffer_skip_cache_size = DEFAULT_SKIP_CACHE_SIZE;
 

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -337,11 +337,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
         uint8_pass = std::make_unique<Uint8Pass>(device, scheduler, descriptor_pool, staging_pool,
                                                  compute_pass_descriptor_queue);
     }
-    const u32 ubo_align = static_cast<u32>(
-            device.GetUniformBufferAlignment() //check if the device has it
-    );
-    // add the ability to change the size in settings in future
-    uniform_ring.Init(device, memory_allocator, 8 * 1024 * 1024 /* 8 MiB */, ubo_align ? ubo_align : 256);
     quad_array_index_buffer = std::make_shared<QuadArrayIndexBuffer>(device_, memory_allocator_,
                                                                      scheduler_, staging_pool_);
     quad_strip_index_buffer = std::make_shared<QuadStripIndexBuffer>(device_, memory_allocator_,
@@ -360,42 +355,6 @@ void BufferCacheRuntime::FreeDeferredStagingBuffer(StagingBufferRef& ref) {
     staging_pool.FreeDeferred(ref);
 }
 
-void BufferCacheRuntime::UniformRing::Init(const Device& device,
-                                           MemoryAllocator& alloc,
-                                           u64 bytes, u32 alignment) {
-    for (size_t i = 0; i < NUM_FRAMES; ++i) {
-        VkBufferCreateInfo ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .size  = bytes,
-            .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = 0,
-            .pQueueFamilyIndices = nullptr,
-        };
-        buffers[i] = alloc.CreateBuffer(ci, MemoryUsage::Upload);
-        mapped[i] = buffers[i].Mapped().data();
-    }
-    size   = bytes;
-    align  = alignment ? alignment : 256;
-    head   = 0;
-    current_frame = 0;
-}
-
-std::span<u8> BufferCacheRuntime::UniformRing::Alloc(u32 bytes, u32& out_offset) {
-    const u64 aligned = Common::AlignUp(head, static_cast<u64>(align));
-    u64 end = aligned + bytes;
-
-    if (end > size) {
-       return {}; // Fallback to staging pool
-    }
-
-    out_offset = static_cast<u32>(aligned);
-    head = end;
-    return {mapped[current_frame] + out_offset, bytes};
-}
-
 u64 BufferCacheRuntime::GetDeviceLocalMemory() const {
     return device.GetDeviceLocalMemory();
 }
@@ -416,7 +375,6 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         it->ResetUsageTracking();
     }
-    uniform_ring.BeginFrame();
 }
 
 void BufferCacheRuntime::Finish() {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -127,15 +124,8 @@ public:
 
     void BindTransformFeedbackBuffers(VideoCommon::HostBindings<Buffer>& bindings);
 
-    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t /*stage*/,
-                                          [[maybe_unused]] u32 /*binding_index*/,
-                                          u32 size) {
-        u32 offset = 0;
-        if (auto span = uniform_ring.Alloc(size, offset); !span.empty()) {
-            BindBuffer(*uniform_ring.buffers[uniform_ring.current_frame], offset, size);
-            return span;
-        }
-        // Fallback for giant requests
+    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t stage,
+                                          [[maybe_unused]] u32 binding_index, u32 size) {
         const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
         BindBuffer(ref.buffer, static_cast<u32>(ref.offset), size);
         return ref.mapped_span;
@@ -163,24 +153,6 @@ private:
     void ReserveNullBuffer();
     vk::Buffer CreateNullBuffer();
 
-    struct UniformRing {
-        static constexpr size_t NUM_FRAMES = 3;
-        std::array<vk::Buffer, NUM_FRAMES> buffers{};
-        std::array<u8*, NUM_FRAMES> mapped{};
-        u64 size = 0;
-        u64 head = 0;
-        u32 align = 256;
-        size_t current_frame = 0;
-
-        void Init(const Device& device, MemoryAllocator& alloc, u64 bytes, u32 alignment);
-        void BeginFrame() {
-            current_frame = (current_frame + 1) % NUM_FRAMES;
-            head = 0;
-        }
-        std::span<u8> Alloc(u32 bytes, u32& out_offset);
-    };
-    UniformRing uniform_ring;
-
     const Device& device;
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;

src/yuzu/CMakeLists.txt

@@ -393,8 +393,16 @@ target_link_libraries(yuzu PRIVATE common core input_common frontend_common netw
 target_link_libraries(yuzu PRIVATE Boost::headers glad Qt6::Widgets)
 target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
+if (NOT WIN32)
+    target_include_directories(yuzu PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
+endif()
+
 if (UNIX AND NOT APPLE)
     target_link_libraries(yuzu PRIVATE Qt6::DBus)
+
+    if (TARGET Qt6::GuiPrivate)
+        target_link_libraries(yuzu PRIVATE Qt6::GuiPrivate)
+    endif()
 endif()
 
 target_compile_definitions(yuzu PRIVATE

tools/VectorDrawable2Svg.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python2
+"""
+VectorDrawable2Svg
+This script convert your VectorDrawable to a Svg
+Author: Alessandro Lucchet
+
+Usage: drop one or more vector drawable onto this script to convert them to svg format
+"""
+
+from xml.dom.minidom import *
+import sys
+
+# extracts all paths inside vdContainer and add them into svgContainer
+def convertPaths(vdContainer,svgContainer,svgXml):
+	vdPaths = vdContainer.getElementsByTagName('path')
+	for vdPath in vdPaths:
+		# only iterate in the first level
+		if vdPath.parentNode == vdContainer:
+			svgPath = svgXml.createElement('path')
+			svgPath.attributes['d'] = vdPath.attributes['android:pathData'].value
+			if vdPath.hasAttribute('android:fillColor'):
+				svgPath.attributes['fill'] = vdPath.attributes['android:fillColor'].value
+			else:
+				svgPath.attributes['fill'] = 'none'
+			if vdPath.hasAttribute('android:strokeLineJoin'):
+				svgPath.attributes['stroke-linejoin'] = vdPath.attributes['android:strokeLineJoin'].value
+			if vdPath.hasAttribute('android:strokeLineCap'):
+				svgPath.attributes['stroke-linecap'] = vdPath.attributes['android:strokeLineCap'].value
+			if vdPath.hasAttribute('android:strokeMiterLimit'):
+				svgPath.attributes['stroke-miterlimit'] = vdPath.attributes['android:strokeMiterLimit'].value
+			if vdPath.hasAttribute('android:strokeWidth'):
+				svgPath.attributes['stroke-width'] = vdPath.attributes['android:strokeWidth'].value
+			if vdPath.hasAttribute('android:strokeColor'):
+				svgPath.attributes['stroke'] = vdPath.attributes['android:strokeColor'].value
+			svgContainer.appendChild(svgPath);
+		
+# define the function which converts a vector drawable to a svg
+def convertVd(vdFilePath):
+
+	# create svg xml
+	svgXml = Document()
+	svgNode = svgXml.createElement('svg')
+	svgXml.appendChild(svgNode);
+
+	# open vector drawable
+	vdXml = parse(vdFilePath)
+	vdNode = vdXml.getElementsByTagName('vector')[0]
+
+	# setup basic svg info
+	svgNode.attributes['xmlns'] = 'http://www.w3.org/2000/svg'
+	svgNode.attributes['width'] = vdNode.attributes['android:viewportWidth'].value
+	svgNode.attributes['height'] = vdNode.attributes['android:viewportHeight'].value
+	svgNode.attributes['viewBox'] = '0 0 {} {}'.format(vdNode.attributes['android:viewportWidth'].value, vdNode.attributes['android:viewportHeight'].value)
+
+	# iterate through all groups
+	vdGroups = vdXml.getElementsByTagName('group')
+	for vdGroup in vdGroups:
+	
+		# create the group
+		svgGroup = svgXml.createElement('g')
+		
+		# setup attributes of the group
+		if vdGroup.hasAttribute('android:translateX'):
+			svgGroup.attributes['transform'] = 'translate({},{})'.format(vdGroup.attributes['android:translateX'].value,vdGroup.attributes['android:translateY'].value)
+		
+		# iterate through all paths inside the group
+		convertPaths(vdGroup,svgGroup,svgXml)
+			
+		# append the group to the svg node
+		svgNode.appendChild(svgGroup);
+
+	# iterate through all svg-level paths
+	convertPaths(vdNode,svgNode,svgXml)
+
+	# write xml to file
+	svgXml.writexml(open(vdFilePath + '.svg', 'w'),indent="",addindent="  ",newl='\n')
+	
+# script begin
+if len(sys.argv)>1:
+	iterArgs = iter(sys.argv)
+	next(iterArgs) #skip the first entry (it's the name of the script)
+	for arg in iterArgs:
+		convertVd(arg)
+else:
+	print("You have to pass me something")
+	sys.exit()

tools/generate-legacy-icons.sh

@@ -0,0 +1,26 @@
+#!/bin/sh -e
+
+# Generate SDK <26 icons for android
+# requires imagemagick, inkscape
+
+ROOTDIR=$PWD
+
+cd src/android/app/src/main
+
+pushd res/drawable
+# convert vector to svg--needed to generate launcher png
+cp ic_yuzu_icon.xml tmp
+
+python3 $ROOTDIR/tools/VectorDrawable2Svg.py tmp
+
+inkscape -w 768 -h 768 tmp.svg -o ic_tmp.png
+magick ic_icon_bg_orig.png -resize 512x512 bg_tmp.png
+
+magick bg_tmp.png -strip -type TrueColor -depth 8 -colorspace sRGB -color-matrix "1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0" bg_tmp_rgb.png
+magick -verbose bg_tmp_rgb.png ic_tmp.png -gravity center -composite -colorspace sRGB ic_launcher.png
+echo
+
+rm *tmp*
+popd
+
+# Add legacy here when legacy gets merged