WebGPU-based end-cloud hybrid rendering method and device and computer storage medium

Abstract

The embodiment of the invention provides a WebGPU-based end-cloud hybrid rendering method and device and a computer storage medium. The method comprises the steps that multi-dimensional data associated with a target rendering task are obtained, the multi-dimensional data comprise static parameters and dynamic parameters, the static parameters comprise client hardware capability parameters and task feature parameters, and the dynamic parameters comprise real-time operation state parameters and dynamic historical feature parameters; based on the acquired multi-dimensional data, dynamically selecting an optimal rendering strategy from a rendering strategy set comprising a plurality of rendering strategies, the plurality of rendering strategies comprising: a full-client rendering strategy, a full-cloud rendering strategy and a hybrid rendering strategy; and executing the target rendering task on the client and / or the cloud based on the optimal rendering strategy. According to the end-cloud hybrid rendering scheme based on the WebGPU, rendering tasks are dynamically arranged and scheduled at the client and the cloud according to the real-time environment, and the general computing potential of the client side of the WebGPU is fully released.

Description

Technical Field

[0001] This invention belongs to the fields of computer graphics and cloud computing technology, and particularly relates to a WebGPU-based edge-cloud hybrid rendering method, device and computer storage medium. Background Technology

[0002] Before the advent of WebGPU, WebGL was the mainstream standard for real-time 3D rendering on the web. However, its design was primarily geared towards graphics rendering and did not provide native support for general-purpose computing. Although developers could indirectly implement some computational functions through techniques such as texture mapping, this approach still had significant limitations: on the one hand, WebGL lacked dedicated computational shaders, and general-purpose computing tasks had to be adapted to the graphics rendering pipeline, which not only increased development complexity but also limited the expressive power and execution efficiency of algorithms; on the other hand, data needed to be packaged in texture format and read back after computation, introducing additional performance overhead and making it difficult to apply to large-scale data processing scenarios.

[0003] Existing cloud rendering engines largely rely on preset static rules for resource selection, lacking the ability to respond in real-time to dynamic changes in the runtime environment. This rigid strategy often proves unstable when faced with complex situations such as network fluctuations and sudden changes in task load, leading to decreased rendering quality and impacting user experience. Furthermore, the difficulty in accurately predicting the actual resource requirements of rendering tasks can easily result in unreasonable resource allocation. In addition, such methods typically treat the client as a passive content receiver, failing to effectively utilize the increasing computing power of terminal devices and lacking a holistic design perspective for end-to-end cloud collaboration.

[0004] Furthermore, in recent years, modern web frameworks such as Next.js, Nuxt, and Astro have widely adopted hybrid rendering techniques, combining server-side rendering, client-side rendering, and static site generation to optimize application performance. For example, server-side rendering of the initial screen improves loading speed, while client-side "hydration" mechanisms activate interactive functions. However, the rendering strategies of these frameworks are mostly based on routes or predefined components during the development phase, lacking runtime adaptability. Such static decision-making mechanisms struggle to flexibly handle diverse user scenarios and also limit the full realization of the computing potential of new technologies such as WebGPU on the client side.

[0005] In summary, existing technologies, whether relying on local computing like WebGL, cloud rendering relying on cloud computing power, or hybrid rendering frameworks that initially combine both, all have significant shortcomings in terms of edge-cloud collaboration and dynamic decision-making. There is a need to dynamically and intelligently orchestrate and schedule rendering tasks between the client and the cloud based on the real-time environment, fully unleashing the general computing potential of WebGPU on the client side. Summary of the Invention

[0006] This invention provides a WebGPU-based edge-cloud hybrid rendering method, apparatus, device, and computer storage medium, which can solve the technical problem of how to dynamically orchestrate and schedule rendering tasks on the client and cloud according to the real-time environment and fully unleash the general computing potential of WebGPU on the client side.

[0007] In a first aspect, embodiments of the present invention provide an edge-cloud hybrid rendering method based on WebGPU, the method comprising: Acquire multidimensional data associated with the target rendering task. The multidimensional data includes static parameters and dynamic parameters. The static parameters include client hardware capability parameters and task characteristic parameters, while the dynamic parameters include real-time running status parameters and dynamic historical characteristic parameters. Based on the acquired multidimensional data, the optimal rendering strategy is dynamically selected from a set of rendering strategies, including: a full-client rendering strategy, a full-cloud rendering strategy, and a hybrid rendering strategy; and The target rendering task is executed on the client and / or in the cloud based on the selected optimal rendering strategy.

[0008] In one feasible implementation, dynamic historical feature parameters are extracted based on client hardware capability parameters, task feature parameters, and real-time running status parameters.

[0009] In one feasible implementation, the method further includes: A scene feature library is built based on historical rendering task data. The scene feature library is used to store multiple task clusters and the cluster feature set of each task cluster. Each task cluster includes a set of multiple similar historical rendering tasks. Based on client hardware capability parameters, task characteristic parameters, and real-time runtime status parameters, the target rendering task is matched to one task cluster from multiple task clusters; and Select the cluster feature set of the matching task cluster from the scene feature library as the dynamic historical feature parameter.

[0010] In one feasible implementation, the cluster feature set includes the following parameters: mean of intra-cluster feature vectors, average intra-cluster performance metric, and distribution of optimal intra-cluster rendering strategy.

[0011] In one feasible implementation, the method further includes: After starting the target rendering task using the optimal rendering strategy, adaptive feedback learning is performed based on the performance metric parameters obtained for executing the target rendering task under the optimal rendering strategy to optimize the dynamic selection of the optimal rendering strategy. The performance metric parameters include: actual performance metric parameters and predicted performance metric parameters.

[0012] In one feasible implementation, the performance metrics include the following parameters: average first frame time, average image quality score, and average cost.

[0013] In one feasible implementation, the method further includes: After starting the target rendering task using the optimal rendering strategy, the actual performance metrics of the target rendering task using the optimal rendering strategy are collected in real time. The collected actual performance metrics are compared with the predicted performance metrics for the target rendering task; and Based on the performance parameter comparison results, a dual-track learning strategy is adopted to dynamically update the parameters of the artificial intelligence model used to select the optimal rendering strategy. The dual-track learning strategy includes rapid online fine-tuning and periodic offline retraining.

[0014] In one feasible implementation, the hybrid rendering strategy includes a preprocessing hybrid rendering mode and a workload-segmented hybrid rendering mode, wherein: In preprocessing rendering mode, the client performs data preprocessing on the target rendering task and transmits the preprocessed data to the cloud for rendering; and In workload splitting hybrid mode, different parts of the target rendering task are executed in parallel on the client and in the cloud.

[0015] In one feasible implementation, the dynamic historical feature parameters include: the mean feature vector of the historical rendering scene that matches the target rendering task, the average first frame time, the average quality score, the average cost, and the distribution of the historical best rendering strategy.

[0016] In one feasible implementation, the client hardware capability parameters include at least one of the following: the available storage buffer binding size of the client, the available texture size, the number of available binding groups supported per shader stage, and the number of available dynamic uniform buffers per shader stage.

[0017] In one feasible implementation, the task characteristic parameters include at least one of the following: rendering task type, target resolution, frame rate requirement, material precision and level of detail, and task priority.

[0018] In one feasible implementation, the real-time runtime status parameters include at least one of the following: user network link status, cloud engine real-time load status, geometric complexity, video memory (VRAM) utilization, and GPU core utilization.

[0019] Secondly, embodiments of the present invention provide an edge-cloud hybrid rendering device based on WebGPU, the device comprising: The acquisition module is used to acquire multidimensional data associated with the target rendering task. The multidimensional data includes static parameters and dynamic parameters. The static parameters include client hardware capability parameters and task characteristic parameters, while the dynamic parameters include real-time running status parameters and dynamic historical characteristic parameters. The selection module dynamically selects the optimal rendering strategy from a set of multiple rendering strategies based on the acquired multidimensional data. These strategies include: a full-client rendering strategy, a full-cloud rendering strategy, and a hybrid rendering strategy. The execution module is used to perform target rendering tasks on the client and / or in the cloud based on the selected optimal rendering strategy.

[0020] Thirdly, embodiments of the present invention provide an edge-cloud hybrid rendering device based on WebGPU, the device comprising: a processor, and a memory storing computer program instructions; the processor reads and executes the computer program instructions to perform any of the edge-cloud hybrid rendering methods based on WebGPU in the above embodiments.

[0021] Fourthly, embodiments of the present invention provide a computer storage medium, characterized in that the computer storage medium stores computer program instructions, which, when executed by a processor, implement any of the WebGPU-based edge-cloud hybrid rendering methods described in the above embodiments.

[0022] Fifthly, embodiments of the present invention provide a computer program product, including a computer program, which, when executed, implements any of the WebGPU-based edge-cloud hybrid rendering methods described in the above embodiments.

[0023] The WebGPU-based edge-cloud hybrid rendering method, apparatus, device, and computer storage medium of this invention integrate the client and cloud into a collaborative computing whole. By sensing multi-dimensional data in real time, it can dynamically select from various rendering strategies using an artificial intelligence core, and dynamically divide and schedule rendering tasks between the client and cloud, fully releasing the general computing potential of the WebGPU client side. Furthermore, this invention constructs an adaptive feedback learning framework that dynamically updates the parameters of the artificial intelligence core after the rendering task begins execution, thereby enabling the entire scheduling system to possess closed-loop, adaptive learning and evolution capabilities. Attached Figure Description

[0024] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the embodiments of the present invention will be briefly introduced below. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0025] Figure 1 This is a flowchart illustrating a WebGPU-based edge-cloud hybrid rendering method provided in an embodiment of the present invention. Figure 2 A flowchart illustrating a method 200 for extracting dynamic historical feature parameters according to an embodiment of the present invention is shown. Figure 3 A flowchart illustrating an artificial intelligence decision-making process for an optimal rendering strategy, according to an embodiment of the present invention, is shown. Figure 4 A schematic diagram of a hybrid neural network architecture provided in one embodiment of the present invention is shown.

[0026] Figure 5 This diagram illustrates the entire process of a WebGPU-based edge-cloud hybrid rendering method according to an embodiment of the present invention.

[0027] Figure 6 This is a schematic diagram of the structure of a WebGPU-based edge-cloud hybrid rendering device provided in an embodiment of the present invention; Figure 7 This is a schematic diagram of the structure of a WebGPU-based edge-cloud hybrid rendering device provided in an embodiment of the present invention. Detailed Implementation

[0028] The features and exemplary embodiments of various aspects of the present invention will now be described in detail. To make the objectives, technical solutions, and advantages of the present invention clearer, the present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. It should be understood that the specific embodiments described herein are merely intended to explain the present invention and not to limit the present invention. For those skilled in the art, the present invention can be practiced without some of these specific details. The following description of the embodiments is merely to provide a better understanding of the present invention by illustrating examples of the invention.

[0029] It should be noted that, in this document, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising..." does not exclude the presence of additional identical elements in the process, method, article, or apparatus that includes said element.

[0030] Current graphics rendering technologies can be mainly categorized into three types: local rendering, cloud rendering, and hybrid rendering. Local rendering is entirely handled by the terminal's CPU / GPU, offering advantages such as low latency and offline / privacy capabilities, but it is limited by the device's computing power and energy consumption. Cloud rendering completes scene calculations and encoding in the cloud, with the terminal only decoding and displaying, facilitating cross-device consistency and elastic scaling, but it relies on bandwidth and latency and is affected by usage costs. Hybrid rendering involves task splitting and orchestration between the edge and the cloud. For example, the edge performs light-load tasks such as input sampling, geometric clipping, or post-processing, while the cloud handles heavy-load tasks such as shading, global illumination, or large-scene cluster rendering. However, task splitting and orchestration are usually based on static or preset rules.

[0031] To address the problems of existing technologies, embodiments of the present invention provide a WebGPU-based edge-cloud hybrid rendering method, apparatus, device, and computer storage medium.

[0032] This invention integrates the client and cloud into a collaborative computing system. By real-time sensing of multi-dimensional data such as client hardware capabilities, task characteristics, real-time running status, and historical execution experience, it utilizes an artificial intelligence model to dynamically weigh multiple performance objectives of rendering tasks, including time, cost, and quality. This allows for the optimal selection among various rendering strategies and the dynamic allocation and scheduling of rendering tasks between the client and cloud. Furthermore, based on multi-dimensional feature vectors, this invention can intelligently determine whether and how to enable the client's general computing capabilities to dynamically optimize data transmission and cloud load. This invention also constructs an adaptive feedback learning framework. After a rendering task begins execution, its actual performance indicators are collected in real time and compared with the predicted performance indicators of the artificial intelligence model. Through a dual-track learning strategy, the parameters of the artificial intelligence model are dynamically updated using the comparison results, thereby enabling the entire scheduling system to possess closed-loop, adaptive learning and evolution capabilities.

[0033] Figure 1 This diagram illustrates a flowchart of a WebGPU-based edge-cloud hybrid rendering method 100 according to an embodiment of the present invention. Figure 1 As shown, method 100 may include steps 110-130. In one embodiment, the method may be executed in the cloud. In another embodiment, method 100 may include more or fewer steps, and the present invention is not limited thereto.

[0034] In step 110, multidimensional data associated with the target rendering task is obtained. This multidimensional data may include static parameters and dynamic parameters. The static parameters may include client hardware capability parameters and task characteristic parameters, and the dynamic parameters may include real-time running status parameters and dynamic historical characteristic parameters.

[0035] In one embodiment, the specific data acquisition process of step 110 is as follows.

[0036] S1: Multidimensional Data Acquisition To systematically construct the aforementioned multidimensional data, a two-stage process can be implemented: Stage 1, S1.1: Establishing a static decision baseline. This stage is executed before the rendering task begins, and its core function is to assess the client's hardware capabilities and analyze task characteristics. Stage 2, S1.2: Proposing a dynamic decision baseline. This stage is executed during the rendering process, continuously monitoring the system's operating status and collecting a series of dynamic parameters. The combination of the static and dynamic decision baselines constitutes a multidimensional feature vector that comprehensively reflects the current system state, thereby ensuring the timeliness and accuracy of subsequent decisions.

[0037] S1.1 Static Decision Baseline Establishing a static decision baseline can include client hardware capability assessment and task characteristic parameter analysis.

[0038] S1.1.1 Client Hardware Capability Assessment In one embodiment, the WebGPU application programming interface (API) can be invoked to obtain a set of precise, quantified client hardware capability parameters to form client hardware capability parameters P01.

[0039] In one embodiment, the client hardware capability parameter P01 can be acquired by performing the following procedure on the client: 1. Request GPU adapter: Request the browser to access the GPUAdapter object; 2. Obtain hardware information: Read hardware vendor information from the returned GPUAdapter object and query the isFallbackAdapter property to determine whether it is a backup adapter in order to identify the client's actual GPU capabilities; 3. Query device limitation parameters: Request a GPUDevice object and query the hardware attribute parameters of the GPU device during the request process.

[0040] In one embodiment, the client hardware capability parameter P01 may include: the available storage buffer binding size of the client, the available texture size, the number of available binding groups supported per shader stage, and / or the number of available dynamic uniform buffers per shader stage, etc.

[0041] S1.1.2 Task Feature Parameter Analysis Once the target rendering task (e.g., on the client side) is specified, the client encapsulates all relevant task parameters collected into a structured data object and sends it to the designated API interface on the cloud. After receiving the rendering request from the client, the cloud server's API interface parses and extracts the data object and constructs the task feature parameters P02 that can be used standardly in subsequent processes.

[0042] In one embodiment, the task feature parameter P02 may include: rendering task type (e.g., video rendering, VR content creation, 3D modeling, etc.), target resolution (e.g., 1080p, 4K, 8K, etc.), frame rate requirement (e.g., 30fps, 60fps, 120fps, etc.), material precision and level of detail, and / or task priority (e.g., real-time priority or image quality priority), etc.

[0043] S1.2: Dynamic Decision Baseline The establishment of a dynamic decision-making baseline can include real-time operational status acquisition and dynamic historical feature extraction.

[0044] S1.2.1 Real-time operating status acquisition After the rendering task starts, various dynamic parameters on both the client and cloud sides can be continuously monitored and collected through, for example, the WebAssembly monitoring module embedded in the client and the network probe detection mechanism of the cloud server, and then integrated into a real-time running status parameter P03.

[0045] In one embodiment, the real-time running status parameter P03 may include: User network link status: for example, detected latency, bandwidth, packet loss rate, fluctuations, etc.; Real-time load status of the cloud engine: for example, the length of the cloud task queue, GPU utilization, available resources, etc. Geometric complexity: For example, the number of vertices or triangles in the current frame after frustum culling; VRAM usage: The current usage of the client's GPU memory; GPU core utilization: The real-time load of the computing units of the client's GPU.

[0046] In another embodiment, the real-time running status parameter P03 may also include various other dynamic parameters from the client and the cloud.

[0047] S1.2.2: Dynamic Historical Feature Extraction To enable AI decision-making to go beyond simply responding to the current instantaneous state and to draw upon the system's past execution experience, this invention introduces a dynamic historical feature construction mechanism. The core of this mechanism is to first analyze the historical task database offline using the K-Means clustering algorithm to identify several consistent task clusters and construct a feature set for each cluster. Then, during task rendering, the current task is matched in real-time to the most suitable task cluster, and the feature set of that cluster is extracted as the decision input. When historical task data is insufficient, the system employs a preset default strategy or randomly tries different rendering strategies to quickly accumulate initial data.

[0048] Figure 2 A flowchart illustrating a method 200 for extracting dynamic historical feature parameters according to an embodiment of the present invention is shown. Figure 2 As shown, method 200 may include steps 210-230. In one embodiment, method 200 may include more or fewer steps, and the present invention is not limited thereto.

[0049] In step 210, a scene feature library is constructed based on historical rendering task data. This scene feature library is used to store the cluster feature sets of multiple task clusters. Each task cluster includes a set of multiple similar historical rendering tasks. In step 220, the target rendering task is matched to one of the multiple task clusters based on client hardware capability parameters, task feature parameters, and real-time running status parameters. In step 230, the cluster feature set of the matched task cluster is selected from the scene feature library as dynamic historical feature parameters.

[0050] The process is executed as follows: (I) Offline K-Means Clustering and Construction of Scene Feature Library This phase is executed periodically in the background (e.g., daily scheduled execution) to dynamically update the scene model. The process includes three steps: feature extraction, cluster analysis, and extraction and storage of cluster feature sets.

[0051] 1. Feature Extraction Extract the corresponding feature vector from the historical task database for each completed rendering task. The vector is composed of client hardware capability parameters P01, task feature parameters P02, and real-time system status parameters P03 recorded at the end of the rendering task.

[0052] 2. Cluster analysis The K-Means clustering algorithm is used to analyze massive amounts of historical task feature vectors. Divided into N clusters The core idea of ​​this algorithm is to find a partitioning scheme that minimizes the sum of variances within clusters. In other words, the goal of this algorithm is to make the data points within each created cluster as close together as possible.

[0053] Therefore, it is first necessary to define each cluster. , which represents the arithmetic mean of all eigenvectors in the cluster, is calculated using the following formula:

[0054] in, It is a cluster The total number of historical tasks included.

[0055] Based on this definition, the objective function of the K-Means algorithm can be expressed as finding an optimal cluster partitioning scheme. To minimize the distance between all data points and their respective cluster centers The sum of squared Euclidean distances between them. Its objective function is defined as:

[0056] in, Represents the feature vector of historical tasks with the mean of its cluster feature vector The algorithm minimizes the squared Euclidean distance between tasks. By minimizing this function, the algorithm ensures that tasks within each cluster are highly similar in the feature space. For example, each cluster might represent a specific type of rendering scenario, such as "high-end devices processing high-frame-rate VR tasks" or "video rendering under unstable network conditions."

[0057] 3. Cluster feature set extraction and storage For each cluster Calculate and store its feature set This feature set is a quantitative summary of historical experience for this type of rendering scenario and serves as the core basis for subsequent online decision-making. It consists of a series of key statistical indicators, calculated as follows: Intra-cluster average performance: Calculate the cluster's average performance. The average of actual performance metrics for all historical tasks. These metrics are actual observations monitored and recorded in the historical performance database after the system completed previous tasks, specifically including the actual time from the start of the task to the rendering of the first frame. Actual picture quality score ( Actual total cost ( By averaging these historical actual values, the average performance baseline for this type of scenario can be obtained. The calculation formula is as follows:

[0058] Intra-cluster optimal rendering strategy distribution: This involves statistically analyzing the frequency with which each of the four rendering strategies (s=1, 2, 3, 4) is selected as the optimal strategy within the cluster, thus obtaining a probability distribution vector. .

[0059]

[0060] Where t represents cluster One of the historical tasks. This represents the recorded optimal rendering strategy corresponding to task t. The cardinality of a set represents... All strategies that satisfy their optimal policy are s The number of tasks. For example, clusters. The strategy distribution may be [0.1, 0.8, 0.1, 0.0], indicating that strategy 2 is most suitable for tasks belonging to this cluster in 80% of cases.

[0061] Finally, the cluster centers calculated in the cluster analysis step are... Integrating with the above performance indicators forms a complete cluster feature set. It is defined as a structured tuple containing vectors and scalar values, and stored in the scene feature library for use in the online matching stage.

[0062] (ii) Online matching and dynamic historical feature P04 generation When a new rendering task requires a decision, the system enters the online matching phase. The core objective of this phase is to intelligently match the real-time context of the current task with the scene feature library built in the offline phase, thereby extracting the most relevant historical experience. As a key input for AI decision-making.

[0063] The process is executed as follows: 1. Construct the query vector for the current task. The client hardware capability parameter P01, task feature parameter P02, and real-time running status parameter P03, which are currently collected in real time, are concatenated and standardized to obtain the real-time query vector of the current task. :

[0064] 2. Match the nearest scene cluster The query vector is calculated using weighted Euclidean distance. With N cluster center points in the scene feature library The distance between them. This distance represents the similarity between the current task and various typical rendering scenarios in history. The calculation formula is as follows:

[0065] in, The representative is the current task and the first j The weighted distance between cluster centers. It is the standardized i-th feature component in the current task query vector. It is the i-th feature component in the j-th cluster center point vector. Indicates the first Preset weights for each feature.

[0066] 3. Select the optimal matching cluster Based on the calculated distance value, the cluster with the smallest distance to the current task is selected, and this cluster is regarded as the set of historical scenes most similar to the current task.

[0067]

[0068] 4. Generate dynamic historical features After confirming the optimal matching cluster Next, the system will retrieve the feature set corresponding to the cluster calculated in the previous stage from the offline-built scene feature library. This feature set is recorded as a dynamic historical feature.

[0069]

[0070] Therefore, the generated dynamic historical feature P04 is a set of structured historical experience data, which may include: the center point of the matching scene ( ), average first frame time of matching scene ( ), average quality score of the matched scene ( ), average cost of matching scenarios ( ), matching the historical best rendering strategy distribution of the scene ( ).

[0071] Return to reference Figure 1 In step 120, based on the acquired multidimensional data, the optimal rendering strategy is dynamically selected from a set of rendering strategies, including: a full-client rendering strategy, a full-cloud rendering strategy, and a hybrid rendering strategy. In one embodiment, the hybrid rendering strategy may include a preprocessing hybrid rendering mode and a workload-split hybrid rendering mode.

[0072] The specific definitions of the above rendering strategy are as follows: Full-client rendering strategy: Under this strategy, the client uses the local rendering pipeline to complete the rendering, and the cloud only provides the raw data and does not participate in the calculation. This strategy is suitable for situations such as low scene complexity, strong client computing power, and good network conditions.

[0073] Full Cloud Rendering Strategy: Under this strategy, the system behavior degenerates into the traditional cloud rendering mode, and the results are transmitted to the client as video streams or pixel streams. This strategy is suitable for situations such as extremely complex scenes that far exceed the client's processing capabilities, or when the client does not support WebGPU.

[0074] Preprocessing Hybrid Rendering Mode: In this mode, the rendering workload is executed sequentially. Client-side work occurs before cloud-based work. The client first performs optimization tasks on the raw data (e.g., culling, compression, LOD generation), and then sends the streamlined data package to the cloud for final high-quality rendering. Its core principle is to reduce data transfer volume and the initial computational load on the cloud. It is suitable for scenarios where the client has some computing power but insufficient to complete the entire rendering process.

[0075] Workload Split Hybrid Mode: In this mode, rendering workloads are executed in parallel, meaning the client and cloud simultaneously perform computations on different parts of the same rendering task. For example, the client handles the highly interactive, real-time parts, while the cloud handles the computationally intensive parts, and the final result is composited on the client to balance real-time performance and image quality.

[0076] In one embodiment, the specific decision-making process of step 120 is as follows.

[0077] S2: Artificial Intelligence Decision Making To select the optimal rendering strategy for the target rendering task, the cloud server receives the client's hardware capability parameters P01, task characteristic parameters P02, real-time running status parameters P03, and dynamic historical characteristic parameters P04. It then uses a neural network algorithm to dynamically weight and evaluate the collected multi-dimensional data, predicting the performance of each feasible rendering strategy under the current state. The specific process is as follows: Figure 3 As shown, Figure 3 The diagram illustrates a flowchart of an artificial intelligence decision-making process for an optimal rendering strategy according to an embodiment of the present invention.

[0078] S2.1: Standardized Preprocessing First, the collected features are standardized and preprocessed to eliminate the dimensional differences between different data. The calculation formula is as follows:

[0079] in, It is the raw measurement value of a certain feature, such as the maximum storage buffer binding size in the client hardware capability parameter P01 or the rendering task type in the task feature parameter P02. These are the normalized eigenvalues, which range between [0, 1].

[0080] S2.2: Feature Vector Construction The preprocessed parameters are concatenated to form a multidimensional feature vector. Let the set of preprocessed client hardware capability parameters P01 be... (Containing n features), the set of task feature parameters P02 is as follows: (Containing m features), the set of real-time running status parameters P03 is as follows: (Contains p features), and the set of dynamic historical feature parameters P04 is as follows: (Contains q features).

[0081] The total dimension of this feature vector is eigenvectors It can be represented as:

[0082] S2.3: Multi-task regression prediction Figure 4 A schematic diagram illustrating a hybrid neural network architecture provided by an embodiment of the present invention is shown. (Using...) Figure 4 The hybrid neural network architecture shown is for the input 3D feature vector The data is then analyzed and predicted. Subsequently, the feature vectors are processed through a feedforward neural network (FFN) containing two fully connected layers.

[0083]

[0084] Next, a bidirectional long short-term memory (BSTTM) layer is used to capture the deep dependencies between historical features and current real-time features (such as network latency and task type), thereby better understanding the historical context of the current state.

[0085]

[0086] Subsequently, a multi-head attention layer is used to dynamically assign weights to different information within the concatenated multi-dimensional feature vector. The core of this mechanism is to learn the real-time features of the current task (from P01', P02', P03') and the baseline features of the historical scene (from the cluster centers in P04'). The differences and connections between them.

[0087] When a feature of the current task is detected to deviate significantly from the historical average, the attention mechanism automatically increases the weight of that feature, as well as historical performance results and historical policy distributions. This allows the model to focus on the most critical decision information based on a dynamic comparison between the current state and historical experience, thereby making more adaptive judgments.

[0088]

[0089] As previously stated, this invention may include four candidate strategies. In one embodiment, the following three key performance metrics are defined for each strategy: 1. Prediction time T (estimated time from the start of the task to the rendering of the first frame). 2. Quality Q (a quantitative score obtained through model learning, representing the fidelity and sharpness of the final image). 3. Cost K (represents the total overhead of cloud computing, bandwidth, and client power consumption required to implement this strategy); Will Mapped to the desired output dimensions. The total dimensions of the output are... (Four candidate strategies and three performance metrics).

[0090]

[0091] in, and These represent weight and bias, respectively. This represents mapping the output of the linear layer to... A matrix of size *3.

[0092] Finally, a different activation function is applied to each column of matrix Z to obtain the prediction matrix. .

[0093]

[0094] in, , These are the activation functions for non-negative constraint values ​​and constraint values ​​in the interval between 0 and 1, respectively.

[0095] S2.4: Dynamic Utility Assessment To make real-time trade-offs among multiple performance objectives (e.g., time T, cost K, quality Q), this invention introduces the dynamic utility function shown in Equation 19 to transform multi-dimensional performance predictions into a single comprehensive utility score U:

[0096] in, It is a normalization function. It is the predicted performance metric for this rendering strategy. , , These are dynamic weights that sum to 1, and their values ​​are determined by the current system state and historical experience.

[0097] The system iterates through all candidate strategies and calculates the overall utility score U(s) for each strategy using a utility function. Finally, the strategy with the highest score is selected as the optimal execution plan for this rendering task. .

[0098]

[0099] Return to reference Figure 1 In step 130, the target rendering task is performed on the client and / or in the cloud based on the selected optimal rendering strategy.

[0100] In one embodiment, the policy execution process in step 130 is as follows.

[0101] S3: Decision Execution The system dynamically selects the optimal rendering strategy. This serves as the target strategy to be implemented. In one embodiment, the context information and result records of the decision-making process are saved, including but not limited to hard disks and databases, for use in subsequent learning model updates.

[0102] like For strategy 1 (e.g., full client rendering strategy): the system sends all rendering instructions and raw data to the client, and the client's local rendering pipeline completes all the work independently.

[0103] like For strategy 2 (e.g., full cloud rendering strategy): the system completely assigns rendering tasks to the cloud rendering engine and transmits the rendering results to the client in the form of video streams or pixel streams.

[0104] like For Strategy 3 (e.g., preprocessing hybrid rendering mode): The system first instructs the client to perform data preprocessing tasks using its WebGPU capabilities, such as view frustum culling and data compression. After preprocessing is complete, the client sends the optimized data to the cloud, where the cloud engine performs the final high-quality rendering.

[0105] like For Strategy 4 (e.g., workload-split hybrid rendering mode): The system splits the rendering task into different parts. For example, interactive layers that require real-time responsiveness (such as UI) are assigned to client-side rendering, while computationally intensive visual enhancement layers (such as global illumination and complex backgrounds) are assigned to cloud-side rendering. After parallel processing on both ends, the images are finally composited into a single frame on the client side.

[0106] In one embodiment, method 100 may further include: after starting to execute the target rendering task using the optimal rendering strategy, performing adaptive feedback learning to optimize the dynamic selection of the optimal rendering strategy based on performance metric parameters obtained for executing the target rendering task under the optimal rendering strategy, wherein the performance metric parameters may include: actual performance metric parameters and predicted performance metric parameters. In one embodiment, the adaptive feedback learning process is as follows.

[0107] S4: Adaptive Feedback Learning After the rendering process begins, the system enters the adaptive feedback learning phase, building a complete closed-loop learning mechanism to continuously optimize the decision-making model. This step may include real-time performance monitoring (S4.1), weighted bias analysis (S4.2), and execution of the dual-track learning strategy (S4.3).

[0108] S4.1: Real-time performance monitoring After the target rendering task begins execution according to the selected optimal rendering strategy, the cloud server can record the actual key performance indicator vector of the target rendering task under that strategy. This vector This can include: the actual time from the start of the task to the rendering of the first frame ( Actual picture quality score ( Actual total cost ( ).Right now .

[0109] S4.2: Weighted Bias Analysis To evaluate and optimize the artificial intelligence model, the system needs to vectorize the actual performance. Compared with the model's initial selection of the strategy The prediction performance vectors are compared.

[0110] First, the prediction matrix generated from S2.3 Extracting from the already executed strategy Corresponding prediction row vector :

[0111] Then, the prediction error of the model is quantified by calculating the weighted bias (loss) L between these two vectors. The weighted bias analysis method is defined as follows:

[0112] in, As the weight of performance indicators, and Represent the first and second parts of the actual performance vector and the predicted performance vector, respectively. i Each component.

[0113] S4.3: Dual-track learning strategy The loss value was calculated using the weighted bias analysis method. Then, the model parameters can be updated using gradient descent to enable the model to make more accurate predictions in the future. The system employs a dual-track learning strategy for model updates: 1. Quick online fine-tuning Based on recent sliding window data, such as 100 tasks, perform small-batch, high-frequency online fine-tuning.

[0114]

[0115] in, Indicates model parameters, Represents the loss function It has a large learning rate, which is used for rapid fine-tuning updates.

[0116] 2. Periodic offline retraining After accumulating a large amount of data, for example, triggering offline model retraining every 1000 tasks or every 7 days.

[0117]

[0118] in, It is a small learning rate for granular offline updates.

[0119] In summary, this invention realizes a WebGPU-based edge-cloud hybrid rendering method through the complete process of S1 to S4 described above. Figure 5This diagram illustrates the entire process of a WebGPU-based edge-cloud hybrid rendering method according to an embodiment of the present invention. First, before rendering execution, client hardware capability parameters are collected and task feature parameters are analyzed. During rendering, real-time running status parameters are acquired. Based on the acquired client hardware capability parameters, task feature parameters, and real-time running status parameters, dynamic historical features are extracted to construct a multi-dimensional feature vector. Subsequently, a multi-task regression prediction model is used to analyze the multi-dimensional feature vector and predict the prediction performance indicators of four candidate rendering strategies. Based on the prediction results, the system dynamically selects the optimal rendering strategy and executes the target rendering task in the cloud and / or on the client side. During execution, an adaptive feedback learning mechanism continuously optimizes prediction accuracy and decision quality, ultimately forming a closed-loop control system of perception-decision-execution-optimization.

[0120] The method disclosed in this invention treats the client and the cloud as a collaborative computing entity, and combines neural network algorithms for dynamic task partitioning and scheduling, ultimately achieving the following technical and performance advantages: 1. Minimize end-to-end rendering latency: By allocating computing tasks to the most suitable resources (client GPU and / or cloud GPU) through neural network algorithms, unnecessary data transfer between the client and the cloud is reduced, thereby significantly reducing the total latency from user interaction to screen rendering and improving the application's responsiveness and interactivity.

[0121] 2. Reduce network bandwidth consumption: Through dynamic decision-making, the client-side WebGPU's general computing capabilities are intelligently enabled in appropriate scenarios, such as for data preprocessing (e.g., culling, compression), transmitting only the minimum effective data to the cloud. This not only significantly saves network bandwidth but also fundamentally reduces reliance on high-cost cloud computing power.

[0122] 3. Maximize end-to-end resource utilization: Dynamically integrate the GPUs of massive end users into a unified, schedulable resource pool. Through an intelligent offloading mechanism, fully utilize client computing power to relieve pressure on the cloud when client performance is sufficient; and smoothly migrate tasks back to the cloud when client load is too high, achieving on-demand allocation and maximizing efficiency of end-to-end computing resources.

[0123] 4. Enhance and ensure user experience quality: Real-time sensing of environmental changes such as network fluctuations and device load, and dynamic adjustment of rendering strategies to meet challenges, ensuring that users can enjoy a smooth, stable and high-quality rendering experience under various unstable network conditions and diverse terminal devices, achieving true environmental adaptability.

[0124] Figure 6 This is a schematic diagram of the structure of a WebGPU-based edge-cloud hybrid rendering device provided in an embodiment of the present invention. Figure 5 As shown, the device may include an acquisition module / unit 610, a selection module / unit 620, and a selection module / unit 630.

[0125] The acquisition module / unit 610 is used to acquire multidimensional data associated with the target rendering task. The multidimensional data may include static parameters and dynamic parameters. The static parameters may include client hardware capability parameters and task characteristic parameters, and the dynamic parameters may include real-time running status parameters and dynamic historical characteristic parameters.

[0126] Select module / unit 620 to dynamically select the optimal rendering strategy from a set of rendering strategies, which includes multiple rendering strategies, based on the acquired multidimensional data. These multiple rendering strategies may include: a full client rendering strategy, a full cloud rendering strategy, and a hybrid rendering strategy.

[0127] Execution module / unit 630 is used to perform target rendering tasks on the client and / or in the cloud based on the selected optimal rendering strategy.

[0128] Figure 7 This diagram illustrates the hardware structure of a WebGPU-based edge-cloud hybrid rendering device according to an embodiment of the present invention.

[0129] A WebGPU-based edge-cloud hybrid rendering device may include a processor 701 and a memory 702 storing computer program instructions.

[0130] Specifically, the processor 701 may include a central processing unit (CPU), an application specific integrated circuit (ASIC), or one or more integrated circuits that can be configured to implement the embodiments of the present invention.

[0131] Memory 702 may include mass storage for data or instructions. For example, and not limitingly, memory 702 may include a hard disk drive (HDD), floppy disk drive, flash memory, optical disk, magneto-optical disk, magnetic tape, or Universal Serial Bus (USB) drive, or a combination of two or more of these. In one instance, memory 702 may include removable or non-removable (or fixed) media, or memory 702 may be non-volatile solid-state memory. Memory 702 may be internal or external to the integrated gateway disaster recovery device.

[0132] In one instance, memory 702 may be read-only memory (ROM). In one instance, the ROM may be a mask-programmed ROM, a programmable ROM (PROM), an erasable PROM (EPROM), an electrically erasable PROM (EEPROM), an electrically rewritable ROM (EAROM), or flash memory, or a combination of two or more of these.

[0133] Memory 702 may include read-only memory (ROM), random access memory (RAM), disk storage media device, optical storage media device, flash memory device, electrical, optical, or other physical / tangible memory storage device. Therefore, generally, memory includes one or more tangible (non-transitory) computer-readable storage media (e.g., memory devices) encoded with software including computer-executable instructions, and when the software is executed (e.g., by one or more processors), it is operable to perform the operations described with reference to the method according to one aspect of this disclosure.

[0134] The processor 701 reads and executes computer program instructions stored in the memory 702 to achieve... Figure 1 The illustrated embodiment presents a WebGPU-based edge-cloud hybrid rendering method.

[0135] In one example, a WebGPU-based edge-cloud hybrid rendering device may also include a communication interface 703 and a bus 704. For example, Figure 7 As shown, the processor 701, memory 702, and communication interface 703 are connected through bus 704 and complete communication with each other.

[0136] The communication interface 703 is mainly used to realize communication between various modules, devices, units and / or equipment in the embodiments of the present invention.

[0137] Bus 704 includes hardware, software, or both, that couples components of an online data traffic metering device together. For example, and not limitingly, the bus may include an Accelerated Graphics Port (AGP) or other graphics bus, an Extended Industry Standard Architecture (EISA) bus, a Front Side Bus (FSB), a Hyper Transport (HT) interconnect, an Industry Standard Architecture (ISA) bus, an Infinite Bandwidth Interconnect, a Low Pin Count (LPC) bus, a memory bus, a Microchannel Architecture (MCA) bus, a Peripheral Component Interconnect (PCI) bus, a PCI-Express (PCI-X) bus, a Serial Advanced Technology Attachment (SATA) bus, a Video Electronics Standards Association Local (VLB) bus, or other suitable buses, or combinations of two or more of these. Where appropriate, bus 704 may include one or more buses. While specific buses are described and illustrated in embodiments of the invention, the invention contemplates any suitable bus or interconnect.

[0138] This WebGPU-based edge-cloud hybrid rendering device can execute the WebGPU-based edge-cloud hybrid rendering method in this embodiment of the invention based on collected client hardware capability parameters, task feature parameters, real-time running status parameters, and dynamic historical feature parameters.

[0139] Furthermore, in conjunction with the WebGPU-based edge-cloud hybrid rendering method in the above embodiments, this invention can be implemented using a computer storage medium. This computer storage medium stores computer program instructions; when these computer program instructions are executed by a processor, they implement any of the WebGPU-based edge-cloud hybrid rendering methods described in the above embodiments.

[0140] This application also provides a computer program product, including a computer program, which, when executed, implements any of the WebGPU-based edge-cloud hybrid rendering methods described in the above embodiments.

[0141] The WebGPU-based edge-cloud hybrid rendering method, apparatus, and computer storage medium provided in this invention have the following technical advantages compared with existing technologies: (I) Performance Improvement and Latency Optimization: Existing technologies for full cloud computing are subject to network latency, while full client computing is limited by device performance. This invention utilizes the powerful general-purpose computing capabilities of client-side WebGPUs for data preprocessing, significantly reducing the amount of data transmitted over the network and the initial computing load in the cloud. This results in improved cloud response speed, shorter end-to-end rendering time, and enhanced user interaction experience. The performance advantages are particularly prominent when dealing with large-scale, highly complex scenarios.

[0142] (ii) Bandwidth saving and cost optimization: Traditional cloud rendering mode faces dual pressures of performance and cost. This invention uses an AI intelligent decision-making mechanism to prioritize the use of client computing resources and only call cloud services when necessary, which significantly reduces the dependence on cloud resources. This not only saves service providers considerable operating costs, but also enables them to cover more users at a lower cost.

[0143] (III) Dynamic Adaptive Capability: This invention integrates the GPU resources of massive user terminal devices into an important component of the overall system computing power, forming a distributed computing network architecture. By offloading some workloads to the client, the pressure on the cloud server during peak access periods can be effectively alleviated. When the client device performance is insufficient or does not support WebGPU, AI intelligent decision-making can smoothly migrate the workload to the cloud. When cloud resources are scarce or network connectivity is poor, the system can enhance its reliance on client computing, ensuring the continuity and quality stability of services under complex conditions. Similarly, when the system detects that the client's local video memory usage is too high or the GPU load is continuously at its peak, AI intelligent decision-making can also proactively migrate more computing tasks to the cloud, preventing the client from crashing due to resource exhaustion, thereby achieving bidirectional dynamic adaptation.

[0144] (iv) Learning capability: Existing technologies cannot optimize strategies using historical data. This proposal constructs an adaptive feedback learning framework, collects actual data to evaluate the model, and updates the model through a dual-track learning process, adapting to technological and business developments and demonstrating a stronger ability to handle atypical tasks.

[0145] It should be clarified that the present invention is not limited to the specific configurations and processes described above and shown in the figures. For the sake of brevity, detailed descriptions of known methods are omitted here. In the above embodiments, several specific steps are described and shown as examples. However, the method process of the present invention is not limited to the specific steps described and shown. Those skilled in the art can make various changes, modifications, and additions, or change the order of steps, after understanding the spirit of the present invention.

[0146] The functional blocks shown in the above-described structural diagram can be implemented as hardware, software, firmware, or a combination thereof. When implemented in hardware, they can be, for example, electronic circuits, application-specific integrated circuits (ASICs), appropriate firmware, plug-ins, function cards, etc. When implemented in software, the elements of this invention are programs or code segments used to perform the required tasks. Programs or code segments can be stored on a machine-readable medium or transmitted over a transmission medium or communication link via data signals carried in a carrier wave. "Machine-readable medium" can include any medium capable of storing or transmitting information. Examples of machine-readable media include electronic circuits, semiconductor memory devices, read-only memory (ROM), flash memory, erasable read-only memory (EROM), floppy disks, compact disc read-only memory (CD-ROM), optical disks, hard disks, fiber optic media, radio frequency (RF) links, etc. Code segments can be downloaded via computer networks such as the Internet, intranets, etc.

[0147] It should also be noted that the exemplary embodiments mentioned in this invention describe methods or systems based on a series of steps or apparatus. However, this invention is not limited to the order of the steps described above; that is, the steps can be performed in the order mentioned in the embodiments, or in a different order, or several steps can be performed simultaneously.

[0148] The aspects of this disclosure have been described above with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this disclosure. It should be understood that each block in the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that these instructions, executable via the processor of the computer or other programmable data processing apparatus, enable the implementation of the functions / actions specified in one or more blocks of the flowchart illustrations and / or block diagrams. Such a processor can be, but is not limited to, a general-purpose processor, a special-purpose processor, a special application processor, or a field-programmable logic circuit. It is also understood that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can also be implemented by special-purpose hardware performing the specified functions or actions, or can be implemented by a combination of special-purpose hardware and computer instructions.

[0149] The above description is merely a specific embodiment of the present invention. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, modules, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here. It should be understood that the protection scope of the present invention is not limited thereto. Any person skilled in the art can easily conceive of various equivalent modifications or substitutions within the technical scope disclosed in the present invention, and these modifications or substitutions should all be covered within the protection scope of the present invention.

Claims

1. A WebGPU-based end-cloud hybrid rendering method, characterized in that, The method comprises: acquiring multi-dimensional data associated with a target rendering task, the multi-dimensional data comprising static parameters and dynamic parameters, wherein the static parameters comprise client hardware capability parameters and task characteristic parameters, and the dynamic parameters comprise real-time running state parameters and dynamic historical characteristic parameters; dynamically selecting an optimal rendering strategy from a rendering strategy set comprising a plurality of rendering strategies based on the acquired multi-dimensional data, the plurality of rendering strategies comprising a full-client rendering strategy, a full-cloud rendering strategy, and a hybrid rendering strategy; and executing the target rendering task on the client and / or in the cloud based on the selected optimal rendering strategy.

2. The method of claim 1, wherein, The dynamic historical characteristic parameters are extracted based on the client hardware capability parameters, the task characteristic parameters, and the real-time running state parameters.

3. The method according to claim 1 or 2, characterized in that, The method further comprises: constructing a scene feature library based on historical rendering task data, the scene feature library being configured to store a plurality of task clusters and a cluster characteristic set of each task cluster, wherein each task cluster in the plurality of task clusters comprises a collection of a plurality of similar historical rendering tasks; matching the target rendering task to one task cluster in the plurality of task clusters based on the client hardware capability parameters, the task characteristic parameters, and the real-time running state parameters; and selecting the cluster characteristic set of the matched task cluster from the scene feature library as the dynamic historical characteristic parameters.

4. The method of claim 3, wherein, The cluster characteristic set comprises the following parameters: in-cluster characteristic vector mean, in-cluster average performance index, and in-cluster optimal rendering strategy distribution.

5. The method according to claim 1 or 2, characterized in that, The method further comprises: after starting to execute the target rendering task using the optimal rendering strategy, performing adaptive feedback learning to optimize the dynamic selection of the optimal rendering strategy based on performance index parameters acquired for executing the target rendering task under the optimal rendering strategy, wherein the performance index parameters comprise actual performance index parameters and predicted performance index parameters.

6. The method of claim 5, wherein, The performance index parameters comprise the following parameters: average first-frame time, average picture quality score, and average cost.

7. The method according to claim 5 or 6, characterized in that, The method further comprises: after starting to execute the target rendering task using the optimal rendering strategy, collecting actual performance index parameters for executing the target rendering task using the optimal rendering strategy in real time; comparing the collected actual performance index parameters with predicted performance index parameters predicted for the target rendering task; and based on the performance parameter comparison result, dynamically updating an artificial intelligence model used to select the optimal rendering strategy using a double-track learning strategy, wherein the double-track learning strategy comprises rapid online fine-tuning and periodic offline retraining.

8. The method of claim 1, wherein, The hybrid rendering strategy comprises a preprocessing hybrid rendering mode and a workload segmentation hybrid rendering mode, wherein: in the preprocessing rendering mode, the client performs data preprocessing on the target rendering task, and transmits the preprocessed data to the cloud for rendering; and in the workload segmentation hybrid mode, the client and the cloud execute different parts of the target rendering task in parallel.

9. The method of claim 1, wherein, The dynamic historical feature parameter comprises: a feature vector mean value, an average first frame time, an average quality score, an average cost, and a historical optimal rendering strategy distribution of a historical rendering scene matched with the target rendering task.

10. The method of claim 1, wherein, The client hardware capability parameter comprises at least one of: an available storage buffer binding size, an available texture size, an available binding group number supported by each shader stage, and an available dynamic uniform buffer number of each shader stage of the client.

11. The method of claim 1, wherein, The task feature parameter comprises at least one of: a rendering task type, a target resolution, a frame rate requirement, a material precision and a detail level, and a task priority.

12. The method of claim 1, wherein, The real-time running state parameter comprises at least one of: a user network link state, a cloud engine real-time load state, a geometry complexity, a video random access memory (VRAM) occupancy, and a GPU core utilization.

13. A WebGPU-based end-to-cloud hybrid rendering apparatus, comprising: The apparatus comprises: an acquisition module configured to acquire multi-dimensional data associated with a target rendering task, the multi-dimensional data comprising static parameters and dynamic parameters, wherein the static parameters comprise client hardware capability parameters and task feature parameters, and the dynamic parameters comprise real-time running state parameters and dynamic historical feature parameters; a selection module configured to dynamically select an optimal rendering strategy from a rendering strategy set comprising a plurality of rendering strategies based on the acquired multi-dimensional data, the plurality of rendering strategies comprising: a full-client rendering strategy, a full-cloud rendering strategy, and a hybrid rendering strategy; and an execution module configured to execute the target rendering task on a client and / or a cloud based on the selected optimal rendering strategy.

14. A WebGPU-based end-to-cloud hybrid rendering device, comprising: The device comprises a processor and a memory storing computer program instructions; the processor reads and executes the computer program instructions to implement the WebGPU-based end-cloud hybrid rendering method according to any one of claims 1-12.

15. A computer-readable storage medium, characterized in that, The computer storage medium stores computer program instructions, and the computer program instructions are executed by a processor to implement the WebGPU-based end-cloud hybrid rendering method according to any one of claims 1-12.

16. A computer program product, characterised in that, The computer program is executed by a processor to implement the WebGPU-based end-cloud hybrid rendering method according to any one of claims 1-12.

Images