Game Client UI Rendering via Browser Kernel Thread Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current game interaction interfaces face issues with resource redundancy and inconsistent user experiences due to frequent UI updates and the use of embedded browsers, which block native UIs and affect player interaction.
Innovation Solution
A user interface processing method and device that utilize two threads in a game client, where a first thread obtains rendering events and a second thread, pre-packaged in the browser kernel, renders objects and sends results back to the first thread for presentation, enabling efficient and consistent UI rendering.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If native UIs with local pictures and resources are used for game interaction interfaces, then UI customization and interaction control are improved, but resource redundancy increases and package size gradually grows due to frequent updates requiring multiple patches
Solution Approach 1:
The patent merges the UI rendering functionality into the browser kernel by pre-packaging the second thread in the browser kernel of the game client. This allows UI resources to be shared across different games and updates through the unified browser kernel, eliminating the need for separate local picture resources in each game client, thereby reducing resource redundancy while maintaining UI customization capabilities.
Solution Approach 2:
The browser kernel is designed to provide universal UI rendering services for multiple games and updates. By making the browser kernel multi-functional, it can handle various UI rendering tasks across different game clients without requiring duplicate resources, thus reducing package size while maintaining adaptability for UI customization.
2Ease of manufacture
If an embedded browser is used to display activity interfaces in the game, then development cost is reduced and page maintenance is easier, but the browser interface completely covers the native UI, blocking game prompts and affecting player interaction experience
Solution Approach 1:
The patent segments the UI rendering process into two independent threads: the first thread handles game logic and native UI display, while the second thread (pre-packaged in the browser kernel) handles web page rendering. This segmentation allows both the embedded browser and native UI to coexist without mutual interference, maintaining ease of development while preserving player interaction experience.
Solution Approach 2:
The patent introduces an intermediary mechanism through the two-thread architecture where the first thread acts as a mediator between the game client and the second thread in the browser kernel. This intermediary enables communication and coordination between the embedded browser and native UI, allowing them to work together without one blocking the other, thus maintaining both development efficiency and interaction quality.
3Adaptability or versatility
If an embedded browser is used for game interfaces, then Web technology flexibility is improved, but consistency between browser interface and native UI deteriorates, creating a feeling of inconsistency for players
Solution Approach 1:
The patent implements a dynamic UI rendering system where the first thread can dynamically control what the second thread renders and how it is displayed. This dynamic control allows the system to adapt Web technology flexibility while maintaining visual consistency with the native UI by dynamically adjusting the integration of browser-rendered content with native game interfaces.
Data Source
AI summary
Disclosed are a user interface processing method and device. The method is applied to a user terminal which is configured to execute a game client, the game client comprises a first thread and a second thread, and the second thread is pre-packaged in a browser kernel of the game client, and the method includes: obtaining, by the first thread, a user interface rendering event which is to be processed: obtaining by the second thread, a to-be-rendered object corresponding to the user interface rendering event; rendering, by the second thread, the to-be-rendered object, and sending a rendering result to the first thread through a first interface, wherein the first interface is an interface provided by the second thread for storing the rendering result; and presenting, by the first thread, the rendering result.