Rendering task rendering method and device, equipment and medium

Abstract

The embodiment of the invention discloses a rendering task rendering method and device, equipment and a medium. The rendering task rendering method comprises the steps that a specified rendering task is transferred to a Worker thread from a UI thread; dynamically configuring parameter information of a specified rendering task based on hardware characteristics of an environment where the Worker thread is located; setting a rendering mechanism of the specified rendering task based on the parameter information; and rendering the specified rendering task based on the rendering mechanism to obtain a rendering result of the specified rendering task. According to the method, the rendering task is stripped from the UI thread to the Worker thread, the blocking risk of the main thread is fundamentally eliminated, meanwhile, the rendering parameters are dynamically generated based on the real-time hardware characteristics of the Worker environment, the three major mechanisms of multi-stage buffering, tile rendering and layered rendering are coordinated and linked under unified configuration, a rendering strategy precisely matched with the hardware capability is formed, and the rendering efficiency is improved. Therefore, the cross-platform rendering robustness and the resource utilization efficiency of the high-end and low-end equipment are remarkably improved while smooth interaction experience is guaranteed.

Description

Technical Field

[0001] This specification relates to the field of computer technology, and in particular to a rendering method, apparatus, device and medium for a rendering task. Background Technology

[0002] In the current field of graphics rendering (especially in front-end visualization technologies such as WebGL and Canvas), rendering tasks are mainly executed synchronously through the UI thread.

[0003] In existing technologies, the UI thread needs to handle user interaction, logic calculation, and rendering tasks simultaneously. When performing complex rendering, thread blocking is easily caused, resulting in interface lag and response delays, which seriously affects the user experience. At the same time, most existing technologies adopt fixed configuration solutions, which cannot fully utilize computing power on high-performance devices, while easily causing rendering timeouts or crashes on low-end devices, and lacking cross-platform compatibility.

[0004] Therefore, there is an urgent need for a better rendering solution to completely solve the problems of thread blocking and poor rendering results. Summary of the Invention

[0005] This specification provides one or more embodiments of a rendering method, apparatus, device, and medium for a rendering task, which are used to solve the technical problems raised in the background art.

[0006] One or more embodiments of this specification employ the following technical solutions:

[0007] This specification provides a rendering method for a rendering task according to one or more embodiments, the method comprising:

[0008] Transfer the specified rendering task from the UI thread to the Worker thread;

[0009] Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured;

[0010] Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization.

[0011] The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0012] It should be noted that this application fundamentally eliminates the risk of main thread blocking by separating the rendering task from the UI thread to the Worker thread. At the same time, it dynamically generates rendering parameters based on the real-time hardware characteristics of the Worker environment, enabling the three mechanisms of multi-level buffering, tiled rendering, and layered rendering to work together under a unified configuration to form a rendering strategy that is precisely matched with the hardware capabilities. This significantly improves the cross-platform rendering robustness and resource utilization efficiency of high-end and low-end devices while ensuring a smooth interactive experience.

[0013] Furthermore, the step of dynamically configuring the parameter information of the specified rendering task based on the hardware characteristics of the environment in which the Worker thread resides includes:

[0014] Based on the available computing resources and device hardware characteristics of the Worker thread, the rendering resolution and shader precision parameters of the specified rendering task are adaptively configured.

[0015] It should be noted that this application analyzes computing resources and hardware characteristics (such as GPU computing power and memory bandwidth) in real time in the Worker thread environment, enabling the rendering resolution and shader precision parameters to dynamically adapt to the actual load capacity of the device. This avoids resource idleness caused by precision redundancy on high-end devices and eliminates rendering stuttering or crashes caused by ultra-precision calculations on low-end devices, thereby establishing an optimal balance between rendering quality and hardware performance while ensuring the continuity of visual effects.

[0016] Furthermore, the method also includes:

[0017] Obtain historical running data of pre-monitored Worker threads, including CPU / GPU utilization and memory fluctuations;

[0018] The resource prediction model is trained based on the historical operating data, and the peak computing resources within a specified time period are output.

[0019] Based on the peak computing resource prediction, the required runtime data for the specified rendering task is preloaded, and the block size of the buffer mechanism is adjusted based on the required runtime data.

[0020] It should be noted that this application trains a prediction model by continuously monitoring the hardware resource fluctuation patterns of the Worker thread, enabling the rendering buffer mechanism to preload key data in advance based on the upcoming computation peak and intelligently calibrate the block granularity, thereby proactively avoiding the risk of resource overload and data loading gaps, and ensuring the continuity and stability of the frame generation process in complex rendering scenarios.

[0021] Furthermore, the method also includes:

[0022] A rendering error monitoring module is constructed to capture shader compilation failures or memory overflow exceptions in real time and trigger a preset degraded rendering pipeline, which includes replacing simplified shaders and reducing the geometric detail level.

[0023] It should be noted that this application dynamically captures key anomalies such as shader compilation failure and memory overflow by embedding a real-time error monitoring module in the rendering pipeline, and instantly switches to a preset degradation strategy (including simplified shader and geometric detail degradation). This enables the system to maintain basic rendering capabilities without interrupting the rendering process, effectively preventing overall rendering failure due to local crashes, thereby significantly improving fault tolerance and user experience continuity in complex environments.

[0024] Furthermore, the step of rendering the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task includes:

[0025] The weight value of the specified rendering task is calculated in real time using a preset rendering task complexity evaluation model.

[0026] Based on the current load of the Worker thread and the weight value of the specified rendering task, the rendering order is dynamically adjusted using a non-preemptive priority queue to obtain the current rendering task order.

[0027] Rendering is performed based on the current rendering task and the rendering mechanism to obtain the rendering result of the specified rendering task.

[0028] It should be noted that this application enables the non-preemptive priority queue to intelligently reorganize the execution sequence of rendering tasks by quantifying the weight value of rendering tasks in real time and analyzing it in conjunction with the load status of Worker threads. This allows the system to focus on the efficient processing of critical tasks when system resources are limited, significantly enhancing the rendering pipeline's resilience to fluctuations and the continuity of task throughput.

[0029] Furthermore, the method also includes:

[0030] The specified rendering task is split into subtasks and distributed to Worker threads on multiple devices;

[0031] Synchronize intermediate rendering results across devices using a distributed rendering protocol;

[0032] The intermediate rendering results are merged based on a consistency check algorithm to obtain the rendering result of the specified rendering task.

[0033] It should be noted that this application intelligently decomposes complex rendering tasks into multiple sub-tasks and schedules them to be processed collaboratively by a heterogeneous device group. Under the unified coordination of the distributed rendering protocol, the intermediate results are synchronously transmitted. Furthermore, a consistency check algorithm is used to intelligently bridge the logical deviations of multi-source data. This achieves seamless integration of cross-device rendering resources and high reliability of result output while avoiding single-point performance bottlenecks.

[0034] Furthermore, the distributed rendering protocol includes:

[0035] A timestamp synchronization mechanism is used to ensure the execution order of subtasks;

[0036] Redundant checksums are used to repair packet loss during data transmission.

[0037] It should be noted that this application uses a timestamp synchronization mechanism to force the alignment of the subtask execution order of distributed nodes and embeds redundant check codes in the data transmission layer to autonomously repair network packet loss errors. This enables heterogeneous device groups to maintain strict consistency of rendering logic even in non-steady network environments, thereby effectively avoiding rendering gaps caused by timing disorder and data loss, and achieving high reliability and logical self-consistency in cross-device collaborative output.

[0038] This specification provides a rendering apparatus for a rendering task according to one or more embodiments, comprising:

[0039] The transfer unit transfers a specified rendering task from the UI thread to the Worker thread;

[0040] The configuration unit dynamically configures the parameter information of the specified rendering task based on the hardware characteristics of the environment in which the Worker thread is located.

[0041] The setting unit sets the rendering mechanism for the specified rendering task based on the parameter information. The rendering mechanism includes a multi-level buffering mechanism, tiled rendering management, and layered rendering optimization.

[0042] The rendering unit renders the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0043] This specification provides a rendering device for a rendering task according to one or more embodiments, including:

[0044] At least one processor; and,

[0045] A memory communicatively connected to the at least one processor; wherein,

[0046] The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enable the at least one processor to:

[0047] Transfer the specified rendering task from the UI thread to the Worker thread;

[0048] Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured;

[0049] Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization.

[0050] The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0051] This specification provides one or more embodiments of a non-volatile computer storage medium storing computer-executable instructions, which, when executed by a computer, can perform the following:

[0052] Transfer the specified rendering task from the UI thread to the Worker thread;

[0053] Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured;

[0054] Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization.

[0055] The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0056] The above-described at least one technical solution adopted in the embodiments of this specification can achieve the following beneficial effects:

[0057] This application fundamentally eliminates the risk of main thread blocking by separating the rendering task from the UI thread to the Worker thread. At the same time, it dynamically generates rendering parameters based on the real-time hardware characteristics of the Worker environment, enabling the three mechanisms of multi-level buffering, tiled rendering, and layered rendering to work together under a unified configuration to form a rendering strategy that is precisely matched with the hardware capabilities. This significantly improves the cross-platform rendering robustness and resource utilization efficiency of high-end and low-end devices while ensuring a smooth interactive experience. Attached Figure Description

[0058] To more clearly illustrate the technical solutions in the embodiments or prior art of this specification, the drawings used in the description of the embodiments or prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. In the drawings:

[0059] Figure 1 A flowchart illustrating a rendering method for a rendering task provided in one or more embodiments of this specification;

[0060] Figure 2 A schematic diagram of the structure of a rendering apparatus for a rendering task provided in one or more embodiments of this specification;

[0061] Figure 3 This is a schematic diagram of the structure of a rendering device for a rendering task provided in one or more embodiments of this specification. Detailed Implementation

[0062] This specification provides a rendering method, apparatus, device, and medium for a rendering task.

[0063] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this specification.

[0064] Figure 1 This diagram illustrates a rendering method for a rendering task provided in one or more embodiments of this specification. This process can be executed by a rendering system. Certain input parameters or intermediate results in the process can be manually adjusted to help improve accuracy.

[0065] The method flow steps of the embodiments in this specification are as follows:

[0066] S101, transfers the specified rendering task from the UI thread to the Worker thread.

[0067] In the embodiments described in this specification, the UI thread calls the `new Worker(scriptURL)` interface to create a dedicated Worker thread; the data to be rendered (including geometric data and texture resources) is serialized and transmitted using the `postMessage()` method. Within the Worker thread, an `onmessage` event listener is implemented to parse task instructions; binary rendering data is passed between the UI thread and the Worker thread using an `ArrayBuffer` to reduce serialization overhead.

[0068] S102, Based on the hardware characteristics of the environment where the Worker thread is located, dynamically configure the parameter information of the specified rendering task.

[0069] In the embodiments described in this specification, the Worker thread calls navigator.hardwareConcurrency to obtain the number of CPU cores; and reads GPU rendering capability parameters (such as MAX_TEXTURE_SIZE) through WebGLRenderingContext.getParameter(). It matches a preset device capability level table (divided into high / medium / low levels) according to the GPU model; and automatically sets the shader precision (highp / mediump / lowp) and rendering resolution scaling factor (1.0~0.5) according to the level.

[0070] S103, based on the parameter information, set the rendering mechanism for the specified rendering task, the rendering mechanism including a multi-level buffering mechanism, tiled rendering management and layered rendering optimization.

[0071] In the embodiments described in this specification, a front buffer pool can be created at 1.5 times the screen resolution, and a back buffer pool can be created at 0.5 times the screen resolution. The maximum number of instances for each level of buffer is dynamically allocated based on the GPU memory parameters configured in S102. A tile grid is divided based on the device pixel ratio, and the size of a single tile is adjusted in conjunction with the resolution scaling factor determined in S102. A spatial index identifier (such as tile_x10_y20_z3) is attached to each tile. A hierarchy of visibility (LOD) is established based on the camera's view frustum, and scene objects are grouped into different levels according to their bounding box size. High-level (close-up) objects are bound to high-precision shaders, and low-level (far-up) objects are bound to medium-precision shaders.

[0072] S104, Render the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0073] In the embodiments described in this specification, the WebGL API is called within the Worker thread to perform rendering according to the mechanism configured in S103; a multi-level buffering mechanism prioritizes filling the background buffer pool, and then swaps it to the front buffer when the frame refresh cycle is triggered. The rendered frame data is then passed from the Worker thread back to the UI thread; the UI thread draws the final rendering result using CanvasRenderingContext2D.drawImage().

[0074] It should be noted that this application fundamentally eliminates the risk of main thread blocking by separating the rendering task from the UI thread to the Worker thread. At the same time, it dynamically generates rendering parameters based on the real-time hardware characteristics of the Worker environment, enabling the three mechanisms of multi-level buffering, tiled rendering, and layered rendering to work together under a unified configuration to form a rendering strategy that is precisely matched with the hardware capabilities. This significantly improves the cross-platform rendering robustness and resource utilization efficiency of high-end and low-end devices while ensuring a smooth interactive experience.

[0075] Furthermore, when dynamically configuring the parameter information of the specified rendering task based on the hardware characteristics of the environment where the Worker thread is located, the rendering resolution and shader precision parameters of the specified rendering task can be adaptively configured according to the available computing resources and device hardware characteristics of the Worker thread.

[0076] It should be noted that the above content can be implemented through the following specific implementation plan:

[0077] Detecting computing resources and hardware characteristics: The Worker thread calls the browser environment interface to obtain the number of currently available logical processor cores and the memory capacity of the graphics processor; based on the graphics interface enumeration capability, it reads the maximum texture size threshold supported by the device and the shader compilation limit characteristics.

[0078] Build an adaptive decision engine: generate parallel computing load levels (high / medium / low) based on the number of processor cores; determine the device rendering capability index based on memory capacity and texture size characteristics (combined with memory bandwidth and fill rate for comprehensive evaluation).

[0079] Dynamic resolution adaptation: When the device rendering capability index reaches a high level, rendering is performed using the original target resolution; when the index drops to a medium level, a resolution scaling mechanism is activated (the output frame is reduced by a factor of 0.7); when the index falls to a low level, a minimalist rendering mode is enabled (0.5x resolution + image quality enhancement algorithm).

[0080] Intelligent matching of shader precision: High-end devices are bound to high-precision shaders (supporting 32-bit floating-point calculation and 8× multisampling); mid-range devices switch to medium-precision shaders (16-bit floating-point calculation and 4× sampling); low-end devices enable simplified shaders (8-bit integer calculation and no-sampling anti-aliasing).

[0081] It should be noted that this application analyzes computing resources and hardware characteristics (such as GPU computing power and memory bandwidth) in real time in the Worker thread environment, enabling the rendering resolution and shader precision parameters to dynamically adapt to the actual load capacity of the device. This avoids resource idleness caused by precision redundancy on high-end devices and eliminates rendering stuttering or crashes caused by ultra-precision calculations on low-end devices, thereby establishing an optimal balance between rendering quality and hardware performance while ensuring the continuity of visual effects.

[0082] Furthermore, the embodiments of this specification can obtain historical running data of pre-monitored Worker threads, including CPU / GPU utilization and memory fluctuations; train a resource prediction model based on the historical running data, and output the peak computing resources within a specified time period; predict and preload the required running data of the specified rendering task according to the peak computing resources, and adjust the block size of the buffer mechanism based on the required running data.

[0083] It should be noted that the above content can be implemented through the following specific implementation plan:

[0084] Historical operational data collection: Start the performance monitoring agent when the Worker thread is initialized; periodically record the CPU core utilization curve, GPU memory fluctuation peak and memory allocation frequency, and archive them to the local database by timestamp.

[0085] Resource prediction model training: Historical data is processed using time series analysis algorithms to extract the periodic patterns and sudden characteristics of resource fluctuations; a peak and valley prediction model for computing resources is established to output the expected extreme values ​​of CPU / GPU load within the next N milliseconds (N is dynamically set by the complexity of the rendering scene).

[0086] Preloading strategy execution: When the prediction model outputs a high load peak warning: preload high-frequency access texture data from the resource pool to the video memory buffer; pre-parse geometry vertex data into GPU-ready format; when the prediction model outputs a low load valley value, delay loading non-critical resources to save memory bandwidth.

[0087] Dynamic optimization of buffer blocks: Based on the total amount and type distribution of preloaded data, the block granularity of multi-level buffers is scaled proportionally: high-frequency data accounts for a high proportion → reduce the size of a single block to improve loading speed; low-frequency, large-volume data accounts for a large proportion → increase the block size to reduce scheduling times; linked with the tiled rendering management described in S103, the tile division and buffer block use a unified spatial indexing rule.

[0088] It should be noted that this application trains a prediction model by continuously monitoring the hardware resource fluctuation patterns of the Worker thread, enabling the rendering buffer mechanism to preload key data in advance based on the upcoming computation peak and intelligently calibrate the block granularity, thereby proactively avoiding the risk of resource overload and data loading gaps, and ensuring the continuity and stability of the frame generation process in complex rendering scenarios.

[0089] Furthermore, embodiments of this specification can construct a rendering error monitoring module to capture shader compilation failures or memory overflow exceptions in real time and trigger a preset degraded rendering pipeline, which includes replacing simplified shaders and reducing the geometric detail level.

[0090] It should be noted that the above content can be implemented through the following specific implementation plan:

[0091] Rendering error monitoring module construction: When an asynchronous error sniffer is implanted in the Worker thread rendering pipeline, the shader compiler output channel is associated to capture compilation failure signals; the memory allocator interface is hooked to monitor memory overflow exceptions; and a classification mapping table of error types and levels (such as fatal errors and degradable errors) is established.

[0092] Degradation strategy library pre-configuration: Pre-deploy simplified shader resource packages, including basic shader programs that remove complex lighting calculations; minimized shader units that retain core texture sampling functions; and pre-set LOD (Level of Detail) ladders (high / medium / low) for each model when building the geometric detail level gradient table.

[0093] Real-time error response and degradation triggering: When a degradable error is captured, the degraded rendering pipeline is invoked to replace the currently active shader with a simplified version; the scene model is switched to a lower level of geometric detail according to the gradient table; the error state is continuously monitored until it recovers to a stable threshold and then automatically resets.

[0094] Degraded rendering pipeline execution: When rendering with a simplified shader, subsurface scattering and ambient occlusion effects are turned off; when degrading geometric details, the tessellation stage and high-precision normal calculation are automatically skipped.

[0095] It should be noted that this application dynamically captures key anomalies such as shader compilation failure and memory overflow by embedding a real-time error monitoring module in the rendering pipeline, and instantly switches to a preset degradation strategy (including simplified shader and geometric detail degradation). This enables the system to maintain basic rendering capabilities without interrupting the rendering process, effectively preventing overall rendering failure due to local crashes, thereby significantly improving fault tolerance and user experience continuity in complex environments.

[0096] Furthermore, when rendering the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task, the weight value of the specified rendering task is calculated in real time using a preset rendering task complexity evaluation model; the rendering order is dynamically adjusted using a non-preemptive priority queue according to the current load of the Worker thread and the weight value of the specified rendering task to obtain the current rendering task order; and the rendering is performed based on the current rendering task and the rendering mechanism to obtain the rendering result of the specified rendering task.

[0097] It should be noted that the above content can be implemented through the following specific implementation plan:

[0098] Rendering task complexity weight calculation: Input the preloaded scene element feature library (including geometry density, texture size, and lighting complexity) into the evaluation model; the model outputs task weight coefficients (continuous values ​​from 0.1 to 1.0) in real time, with high values ​​corresponding to complex special effects or rendering of close-up objects.

[0099] Synchronous monitoring of load status: Worker threads periodically collect current CPU utilization and remaining video memory capacity; generate system load index (three levels of status indicators: light load / medium load / heavy load).

[0100] Non-preemptive queue dynamic sorting: Newly submitted tasks are inserted into the queue according to their weight coefficients. High-weight tasks are moved forward without interrupting currently executing tasks. In overloaded conditions, low-priority tasks with a weight < 0.3 (such as distant static objects) are automatically skipped.

[0101] Sequential execution of collaborative rendering: The queue scheduler calls the rendering mechanism established by S103 item by item according to the sorting result; each task is bound to the corresponding multi-level buffer configuration and layered rendering rules when it is executed.

[0102] It should be noted that this application enables the non-preemptive priority queue to intelligently reorganize the execution sequence of rendering tasks by quantifying the weight value of rendering tasks in real time and analyzing it in conjunction with the load status of Worker threads. This allows the system to focus on the efficient processing of critical tasks when system resources are limited, significantly enhancing the rendering pipeline's resilience to fluctuations and the continuity of task throughput.

[0103] Furthermore, in the embodiments of this specification, the specified rendering task can be split into subtasks and distributed to worker threads on multiple devices; intermediate rendering results of each device can be synchronized through a distributed rendering protocol; and the intermediate rendering results can be merged based on a consistency check algorithm to obtain the rendering result of the specified rendering task.

[0104] It should be noted that the above content can be implemented through the following specific implementation plan:

[0105] Cross-device subtask splitting and distribution: The master device splits the specified rendering task into N logical subtasks according to the spatial sharding rules (N = number of participating devices); it identifies available nodes through the device discovery protocol and distributes the subtask data packets to the local worker threads of each device.

[0106] Distributed intermediate result synchronization: After each device's worker thread completes its subtask, it generates an intermediate rendering result with a spatial location identifier; the intermediate result is then broadcast to the cluster by frame sequence number through a message queue middleware (such as the MQTT protocol).

[0107] Consistency verification and result merging: After receiving the intermediate results, the master control device executes a hash digest comparison algorithm to check the integrity of data transmission; for data blocks with verification deviations, a local re-rendering request is initiated instead of full retransmission; and the multi-source intermediate results are stitched together into a complete frame through a deep buffer fusion algorithm.

[0108] Final rendering result generation: The merged frame data is normalized in color space to eliminate color differences between devices; the final rendering result, which is equivalent to the single-device rendering logic, is output to the UI thread of the main control device.

[0109] It should be noted that this application intelligently decomposes complex rendering tasks into multiple sub-tasks and schedules them to be processed collaboratively by a heterogeneous device group. Under the unified coordination of the distributed rendering protocol, the intermediate results are synchronously transmitted. Furthermore, a consistency check algorithm is used to intelligently bridge the logical deviations of multi-source data. This achieves seamless integration of cross-device rendering resources and high reliability of result output while avoiding single-point performance bottlenecks.

[0110] Furthermore, the distributed rendering protocol includes: employing a timestamp synchronization mechanism to ensure the execution order of subtasks; and using redundant check codes to repair packet loss during data transmission.

[0111] It should be noted that the above content can be implemented through the following specific implementation plan:

[0112] Deployment of timestamp synchronization mechanism: When distributing subtasks, the master device attaches a timestamp tag generated by a globally unified clock; each slave device worker thread executes the subtasks in ascending order based on the timestamp; for subtasks with dependencies, the order constraint rules are explicitly declared in the timestamp tag.

[0113] Redundancy check code generation and application: Before transmitting intermediate results, the sending device generates a parity check block sequence based on the original data packet; the check block is encapsulated into the end of the transmitted message to form a data transmission unit with self-healing capability; when the receiving end detects packet loss, it uses the check block to perform the lost data block reconstruction operation.

[0114] Cross-device execution logic alignment: The timestamp mechanism forces all devices to process subtasks in the same logical sequence; the checksum mechanism ensures that even if some packets are lost, the reconstructed data still meets the subsequent merging conditions.

[0115] It should be noted that this application uses a timestamp synchronization mechanism to force the alignment of the subtask execution order of distributed nodes and embeds redundant check codes in the data transmission layer to autonomously repair network packet loss errors. This enables heterogeneous device groups to maintain strict consistency of rendering logic even in non-steady network environments, thereby effectively avoiding rendering gaps caused by timing disorder and data loss, and achieving high reliability and logical self-consistency in cross-device collaborative output.

[0116] Furthermore, this invention proposes an off-screen Canvas graphics rendering method based on multi-level buffering, aiming to solve the technical problems existing in the prior art. This method includes the following core technical features:

[0117] Control transfer mechanism:

[0118] The main thread transfers control of the Canvas to the Worker thread via the browser API, achieving complete separation of rendering tasks from the UI thread. The specific steps are as follows:

[0119] 1. The main thread creates a standard Canvas element and obtains its OffscreenCanvas object, providing a foundation for subsequent control transfer.

[0120] 2. By transferring control of OffscreenCanvas to the Worker thread through inter-thread communication, the rendering task can be performed in an independent Worker thread, avoiding blocking the UI thread.

[0121] 3. Establish a dedicated rendering thread management channel for communication and coordination between the main thread and worker threads, ensuring a stable and efficient transfer of control.

[0122] Multi-level buffer architecture:

[0123] The rendering pipeline is optimized using a double buffering mechanism, specifically including:

[0124] 1. Maintain two independent rendering contexts for the preceding and following frames. The background frame can perform asynchronous rendering operations, while the foreground frame is used to display the current rendering result, thus achieving parallel processing of rendering and display.

[0125] 2. Frame buffer switching is achieved through atomic swap operations, ensuring the atomicity and stability of frame buffer switching and avoiding problems such as screen tearing.

[0126] 3. Supports multi-level buffer expansion, allowing for flexible adjustment of buffer levels based on different performance requirements and device characteristics to achieve optimal rendering effects and performance.

[0127] Dynamic resolution adaptation:

[0128] The adaptive rendering strategy based on device pixel ratio is detailed below:

[0129] 1. Monitor the device's PixelRatio parameter in real time to obtain the device's pixel density information.

[0130] 2. Establish a tiered resolution degradation strategy table, and formulate different resolution degradation strategies based on the device's performance and display requirements.

[0131] 3. Dynamically adjust the rendering buffer size to improve rendering efficiency while ensuring a certain level of rendering quality.

[0132] 4. Supports anti-aliasing post-processing compensation, which improves the display quality of the image after resolution adjustment through anti-aliasing and other post-processing technologies.

[0133] Layered rendering optimization:

[0134] The following details the construction of a layered rendering system based on element type:

[0135] 1. Divide the rendering layers according to element characteristics, such as static / dynamic, and use different rendering strategies for elements at different layers.

[0136] 2. Allocate independent rendering buffers for each level to ensure that the rendering of elements at each level does not interfere with each other and improves the parallelism of rendering.

[0137] 3. Implement differentiated update strategies: reduce update frequency for static elements and update dynamic elements in real time to improve rendering efficiency.

[0138] 4. Establish a Z-index-based compositing mechanism to composite elements according to their hierarchical order, ensuring correct display of the image.

[0139] Tile-based rendering management:

[0140] Spatial partitioning technology is used to optimize the rendering of large-scale scenes, as follows:

[0141] 1. Based on the quadtree spatial index structure, large-scale scenes are spatially partitioned and managed, improving the efficiency of scene element query and rendering.

[0142] 2. Dynamic tile division and viewport clipping: Based on the position and size of the viewport, tiles are dynamically divided and clipped, rendering only the tiles within the viewport to reduce unnecessary rendering.

[0143] 3. Incremental tile update mechanism: When elements in the scene change, only the relevant tiles are updated, improving update efficiency.

[0144] 4. Local redraw optimization: Redraw only local areas to avoid re-rendering the entire scene and save rendering resources.

[0145] Big data processing optimization:

[0146] Specific optimizations for massive amounts of graphic data are as follows:

[0147] 1. Streaming data compression transmission: The transmitted graphic data is compressed to reduce the amount of data transmitted and improve data transmission efficiency.

[0148] 2. Time-sharing batch processing scheduling divides massive amounts of data into several batches and processes them at different times, avoiding performance bottlenecks caused by centralized processing.

[0149] 3. Viewport-based visibility culling: Based on the viewport's position and size, invisible graphic elements are culled, reducing the amount of data that needs to be processed.

[0150] 4. Multi-level level of detail (LOD) control: dynamically adjusts the level of detail of graphic elements based on their distance from the viewpoint, reducing rendering complexity while ensuring visual quality.

[0151] Technical advantages: Compared with existing technologies, the present invention has the following significant advantages:

[0152] 1. By using thread separation and buffering mechanisms, rendering tasks are transferred to Worker threads, and double buffering and multi-level buffering technologies are adopted to effectively improve the overall rendering throughput and maintain stable rendering performance under high frame rates and complex scenes.

[0153] 2. The dynamic resolution strategy can dynamically adjust the rendering resolution based on the device's pixel density and performance, achieving cross-device performance optimization and ensuring good performance on different devices.

[0154] 3. The layered architecture processes graphic elements according to their characteristics, which reduces rendering complexity, improves rendering efficiency, and facilitates differentiated management of elements at different levels.

[0155] 4. Tile management effectively reduces invalid rendering and improves rendering efficiency for large-scale scenes through techniques such as spatial partitioning and viewport clipping.

[0156] 5. Through the combination of various optimization technologies, the big data processing capability has been improved by an order of magnitude compared with the existing technology, enabling it to better handle massive amounts of graphic data.

[0157] The preferred embodiments of the present invention are described in detail below:

[0158] 1. Implementation of the transfer of control

[0159] Main thread execution control transfer process:

[0160] 1.1 Creating a standard HTMLCanvasElement object: In the main thread, through the HTML document... <canvas>The tag creates a standard Canvas element, which is the basic carrier for graphics rendering.

[0161] 1.2 Obtaining an OffscreenCanvas reference: Using the browser's API, obtain the OffscreenCanvas object from the created standard Canvas element. This object allows offscreen rendering in the Worker thread.

[0162] 1.3 Initialize the Worker communication thread: Create a Worker thread and establish a communication channel between the main thread and the Worker thread for transmitting data and instructions.

[0163] 1.4 Transfer the OffscreenCanvas control handle: Through the inter-thread communication mechanism, the control handle of the OffscreenCanvas object is transferred to the Worker thread, so that the Worker thread gains control of the OffscreenCanvas and can perform rendering operations in the Worker thread.

[0164] 2. Multi-level buffering implementation

[0165] The worker thread maintains the rendering context:

[0166] 2.1 Initialize the front and rear frame buffers: In the Worker thread, create two independent rendering buffers to store the graphics data of the previous frame and the next frame that is currently being rendered, respectively.

[0167] 2.2 Establish an asynchronous rendering task queue: Add rendering tasks to the task queue and implement parallel execution of rendering tasks through asynchronous processing to improve rendering efficiency.

[0168] 2.3 Implement the frame buffer switching protocol: Define the rules and mechanisms for frame buffer switching. After the next frame is rendered, the frame buffers are switched through atomic swap operations so that the foreground displays the content of the next frame and the background continues to render the next frame.

[0169] 2.4 Configure buffer synchronization strategy: Configure the buffer synchronization strategy according to the device performance and rendering requirements to ensure the synchronization of rendering and display and avoid problems such as screen stuttering or tearing.

[0170] 3. Dynamic resolution strategy

[0171] 3.1 Device Characteristic Detection Module: This module detects device characteristic information such as PixelRatio parameter, screen size, and hardware performance in real time, providing a basis for resolution decision-making.

[0172] 3.2 Resolution Decision Tree Construction: Based on the information obtained by the device characteristic detection module, a hierarchical resolution degradation strategy table is established to form a resolution decision tree, and an appropriate resolution is selected according to different device conditions and rendering requirements.

[0173] 3.3 Dynamic scaling of rendering targets: Based on the resolution decision, the size of the rendering buffer is dynamically adjusted to adapt the rendering target to the display requirements and performance of the current device.

[0174] 3.4 Post-processing quality compensation: After adjusting the resolution, post-processing techniques such as anti-aliasing and image sharpening are used to compensate for the image quality, ensuring that a good display effect can still be maintained at a lower resolution.

[0175] 4. Layered rendering implementation

[0176] 4.1 Hierarchical Classification Strategy Configuration: Based on the characteristics of graphic elements, such as static / dynamic, complexity, etc., configure a hierarchical classification strategy to divide graphic elements into different rendering layers, such as static background layer, dynamic object layer, UI layer, etc.

[0177] 4.2 Buffer Allocation Management: Allocate an independent rendering buffer for each rendering level. Based on the characteristics of elements at each level and the rendering requirements, allocate buffer resources reasonably to ensure that the rendering of each level does not interfere with each other.

[0178] 4.3 Differential Update Scheduler: Implements differentiated update scheduling strategies for elements at different levels. For static elements, updates are only required when the element changes after scene initialization; for dynamic elements, real-time updates are necessary to ensure the smoothness of their dynamic effects.

[0179] 4.4 Multi-layer Compositing Controller: Establish a multi-layer compositing mechanism based on Z-index, and composite the rendering results of each layer according to the Z-index order to generate the final rendered image, ensuring the correct occlusion relationship of elements.

[0180] 5. Tile-based management system

[0181] 5.1 Spatial Index Builder: A quadtree spatial index structure is used to spatially partition large-scale scenes into multiple tiles. Each tile corresponds to a region in the scene, facilitating the management and querying of scene elements.

[0182] 5.2 Viewport Detection Module: Real-time detection of the position and size of the viewport to determine the scene area covered by the current viewport.

[0183] 5.3 Incremental Update Tracker: Tracks changes in elements in the scene. When an element is moved or modified, it determines the corresponding tile and records the content that needs to be updated, thus achieving incremental tile updates.

[0184] 5.4 Local Redraw Optimizer: Based on the results of the viewport detection module and the incremental update tracker, only the tiles within the viewport and the tiles that have changed are locally redrawn, avoiding re-rendering the entire scene and improving rendering efficiency.

[0185] 6. Big Data Processing Solutions

[0186] 6.1 Data Compression Transmission Channel: When transmitting massive amounts of graphic data, streaming data compression technology is used to compress the data, reduce the amount of data transmitted, and improve the transmission efficiency between the main thread and the worker thread.

[0187] 6.2 Time-sharing Batch Processing Scheduler: Divides massive amounts of graphics data into several batches and processes them in time-sharing manner based on system load and time slice allocation. This avoids processing too much data at the same time, which could lead to a degraded system performance.

[0188] 6.3 Visibility Determination Engine: Based on the viewport's position and size, and utilizing spatial indexing and clipping techniques, it determines which graphic elements are visible within the viewport and which are not. Invisible elements are directly culled without rendering, reducing the amount of data that needs to be processed.

[0189] 6.4 LOD Management Subsystem: This subsystem establishes a multi-level level of detail (LOD) model for each graphic element and dynamically selects the appropriate LOD level for rendering based on the element's distance from the viewpoint. When an element is far from the viewpoint, a low LOD model is used to reduce rendering complexity; when an element is close to the viewpoint, a high LOD model is used to ensure visual quality.

[0190] (The instruction manual should include detailed interaction procedures and technical parameters for each module. For example, during the control transfer process, the specific protocols and data formats for inter-thread communication; in the multi-level buffer implementation, the buffer size and the specific implementation methods for atomic swap operations; in the dynamic resolution strategy, the specific contents of the hierarchical resolution degradation strategy table and the resolution adjustment algorithm, etc. These detailed interaction procedures and technical parameters can provide specific guidance for the implementation of this method.)

[0191] This invention is suitable for use in the following fields:

[0192] 1. WebGL Game Engine: Provides efficient graphics rendering support for WebGL games, improving the game's visual quality and performance, and supporting complex game scenes and high frame rate rendering requirements.

[0193] 2. Geographic Information System: In a geographic information system, it is necessary to process large-scale map data and geographic graphic elements. The tiled rendering management and big data processing optimization technology of this invention can effectively improve the rendering efficiency and display effect of maps.

[0194] 3. Data visualization platform: Data visualization platforms typically need to display a large number of data graphs, such as line charts, bar charts, scatter plots, etc. The layered rendering and dynamic resolution adaptation technology of this invention can provide the best visualization effect according to different data types and device characteristics.

[0195] 4. Remote Desktop Rendering: In remote desktop scenarios, desktop content needs to be rendered and transmitted to the client in real time. The control transfer and multi-level buffering mechanism of this invention can improve rendering efficiency, reduce latency, and enhance the user experience of remote desktop.

[0196] 5. Industrial Simulation System: Industrial simulation systems require simulation rendering of complex industrial scenes and equipment. The various optimization technologies of this invention can meet the needs of industrial simulation for high-performance graphics rendering and achieve realistic simulation effects.

[0197] Figure 2 This specification provides a schematic diagram of the structure of a rendering apparatus for a rendering task, which includes: a transfer unit 201, a configuration unit 202, a setting unit 203, and a rendering unit 204, according to one or more embodiments of this specification.

[0198] Transfer unit 201 transfers the specified rendering task from the UI thread to the Worker thread;

[0199] Configuration unit 202 dynamically configures the parameter information of the specified rendering task based on the hardware characteristics of the environment in which the Worker thread is located;

[0200] Setting unit 203 sets the rendering mechanism of the specified rendering task based on the parameter information. The rendering mechanism includes a multi-level buffering mechanism, tiled rendering management, and layered rendering optimization.

[0201] The rendering unit 204 renders the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0202] Figure 3 A schematic diagram of the structure of a rendering device for a rendering task provided in one or more embodiments of this specification includes:

[0203] At least one processor; and,

[0204] A memory communicatively connected to the at least one processor; wherein,

[0205] The memory stores instructions executable by the at least one processor, which, when executed by the at least one processor, enable the at least one processor to:

[0206] Transfer the specified rendering task from the UI thread to the Worker thread;

[0207] Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured;

[0208] Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization.

[0209] The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0210] This specification provides one or more embodiments of a non-volatile computer storage medium storing computer-executable instructions, which, when executed by a computer, can perform the following:

[0211] Transfer the specified rendering task from the UI thread to the Worker thread;

[0212] Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured;

[0213] Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization.

[0214] The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

[0215] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the embodiments of apparatus, devices, and non-volatile computer storage media are basically similar to the method embodiments, so the descriptions are relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0216] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the apparatus embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions of the method embodiments.

[0217] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0218] In the embodiments provided in this application, it should be understood that the disclosed apparatus / network devices and methods can be implemented in other ways. For example, the apparatus / network device embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0219] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0220] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The aforementioned units can be implemented in hardware or software.

[0221] If the integrated module / unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include: any entity or device capable of carrying the computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium can be appropriately added or removed according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electrical carrier signals and telecommunication signals.

[0222] The above-described embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.< / canvas>

Claims

1. A rendering method for a rendering task, characterized in that, The method includes: Transfer the specified rendering task from the UI thread to the Worker thread; Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured; Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization. The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

2. The method according to claim 1, characterized in that, The dynamic configuration of parameter information for the specified rendering task based on the hardware characteristics of the environment in which the Worker thread resides includes: Based on the available computing resources and device hardware characteristics of the Worker thread, the rendering resolution and shader precision parameters of the specified rendering task are adaptively configured.

3. The method according to claim 1, characterized in that, The method further includes: Obtain historical running data of pre-monitored Worker threads, including CPU / GPU utilization and memory fluctuations; The resource prediction model is trained based on the historical operating data, and the peak computing resources within a specified time period are output. Based on the peak computing resource prediction, the required runtime data for the specified rendering task is preloaded, and the block size of the buffer mechanism is adjusted based on the required runtime data.

4. The method according to claim 1, characterized in that, The method further includes: A rendering error monitoring module is constructed to capture shader compilation failures or memory overflow exceptions in real time and trigger a preset degraded rendering pipeline, which includes replacing simplified shaders and reducing the geometric detail level.

5. The method according to claim 1, characterized in that, The process of rendering the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task includes: The weight value of the specified rendering task is calculated in real time using a preset rendering task complexity evaluation model. Based on the current load of the Worker thread and the weight value of the specified rendering task, the rendering order is dynamically adjusted using a non-preemptive priority queue to obtain the current rendering task order. Rendering is performed based on the current rendering task and the rendering mechanism to obtain the rendering result of the specified rendering task.

6. The method according to claim 1, characterized in that, The method further includes: The specified rendering task is split into subtasks and distributed to Worker threads on multiple devices; Synchronize intermediate rendering results across devices using a distributed rendering protocol; The intermediate rendering results are merged based on a consistency check algorithm to obtain the rendering result of the specified rendering task.

7. The method according to claim 6, characterized in that, The distributed rendering protocol includes: A timestamp synchronization mechanism is used to ensure the execution order of subtasks; Redundant checksums are used to repair packet loss during data transmission.

8. A rendering apparatus for a rendering task, characterized in that, include: The transfer unit transfers a specified rendering task from the UI thread to the Worker thread; The configuration unit dynamically configures the parameter information of the specified rendering task based on the hardware characteristics of the environment in which the Worker thread is located. The setting unit sets the rendering mechanism for the specified rendering task based on the parameter information. The rendering mechanism includes a multi-level buffering mechanism, tiled rendering management, and layered rendering optimization. The rendering unit renders the specified rendering task based on the rendering mechanism to obtain the rendering result of the specified rendering task.

9. A rendering device for a rendering task, characterized in that, include: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to: Transfer the specified rendering task from the UI thread to the Worker thread; Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured; Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization. The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

10. A non-volatile computer storage medium, characterized in that, It stores computer-executable instructions, which, when executed by a computer, can achieve the following: Transfer the specified rendering task from the UI thread to the Worker thread; Based on the hardware characteristics of the environment in which the Worker thread resides, the parameter information of the specified rendering task is dynamically configured; Based on the parameter information, the rendering mechanism of the specified rendering task is set, and the rendering mechanism includes a multi-level buffering mechanism, tiled rendering management and layered rendering optimization. The specified rendering task is rendered based on the rendering mechanism to obtain the rendering result of the specified rendering task.

Images