Rendering acceleration system and method and electronic equipment

Abstract

The invention provides a rendering acceleration system and method and electronic equipment, and relates to the technical field of cloud computing, efficient compression and encrypted transmission are performed on touch control and attitude data through quantum state compression coding, and the bandwidth demand and data security risk of cloud interaction are reduced; through block classification based on quantum gradient features, rendering tasks are accurately distributed to heterogeneous computing nodes, and the computing potential of a low-computing-power server is fully utilized; and through processing technologies such as multi-order feature tensor construction and compression, motion perception interpolation and the like, the dependence on a high-performance graphic processing unit is greatly reduced while the high-definition rendering effect and fluency are ensured. Therefore, the problems of high hardware cost and low resource utilization rate can be effectively solved, high-quality and high-efficiency rendering in a low-computing-power environment is realized, and a technical scheme with higher cost effectiveness and expandability is provided for scenes such as cloud mobile phones and cloud games.

Description

Technical Field

[0001] This disclosure relates to the field of cloud computing technology, and in particular to a system and method for rendering acceleration, and an electronic device. Background Technology

[0002] With the increasing popularity of cloud phones in mobile cloud gaming, augmented reality (AR) / virtual reality (VR) scenarios, users' demands for high-quality real-time rendering, ultra-low latency interaction, and data security have surged. Related technologies primarily rely on high-performance graphics processing unit (GPU) servers to centrally process rendering tasks, ensuring image quality and frame rate through hardware performance improvements.

[0003] However, the related technologies rely on stacking high-performance hardware, which results in high hardware costs. At the same time, low-computing-power servers are only used for edge data relay and cannot participate in core computing, leading to low resource utilization.

[0004] Therefore, how to achieve efficient rendering in low-computing-power environments through rendering acceleration methods with low hardware costs and high resource utilization is an urgent problem to be solved. Summary of the Invention

[0005] This disclosure provides a system, method, and electronic device for rendering acceleration. Its main purpose is to solve the problem of how to achieve efficient rendering in low-computing-power environments through rendering acceleration methods with low hardware costs and high resource utilization.

[0006] According to a first aspect of this disclosure, a rendering acceleration system is provided, comprising: a target terminal, a server, and at least one computing node. The target terminal is configured to generate a quantum state sequence by processing the collected touch trajectory data and gyroscope data through quantum state compression encoding, and then transmit the quantum state sequence to the server. The server is configured to divide the quantum state sequence into blocks to obtain multiple blocks of data, and classify the multiple blocks of data by calculating quantum gradient features to generate block label matrices corresponding to each of the multiple blocks of data. The server is also configured to distribute multiple data blocks to their respective computing nodes and / or target terminals based on the block tag matrix and resource pool status. The computing nodes and target terminals are also configured to perform rendering calculations on their respective block data to obtain pixel coloring results; The server is also configured to construct a multi-level feature tensor based on the pixel coloring results, and to compress the multi-level feature tensor to obtain the fused rendering result; The server is also configured to perform motion-aware interpolation on the fused rendering results to generate smooth transition frames, and encode the smooth transition frames and the fused rendering results to obtain the target image.

[0007] According to a second aspect of this disclosure, a method for accelerating rendering is provided, wherein the method is applied to a target terminal of the rendering acceleration system of the first aspect described above, comprising: The collected touch trajectory data and gyroscope data are processed through quantum state compression encoding to generate quantum state sequences; The quantum state sequence is transmitted to the server so that the server can execute the rendering process based on the quantum state sequence.

[0008] According to a third aspect of this disclosure, a method for accelerating rendering is provided, wherein the method is applied to the server side of the rendering acceleration system of the first aspect described above, comprising: The quantum state sequence from the target terminal is divided into blocks to obtain multiple blocks of data. The multiple blocks of data are then classified by calculating quantum gradient features, generating block label matrices corresponding to each block of data. Based on the block tag matrix and resource pool status, multiple blocks of data are allocated to their respective computing nodes and / or target terminals, so that the computing nodes and target terminals can perform rendering calculations on their respective blocks of data to obtain pixel coloring results. Receive pixel coloring results returned by computing nodes and / or target terminals, construct multi-order feature tensors based on pixel coloring results, and compress the multi-order feature tensors to obtain fused rendering results; Motion-aware interpolation is performed on the fused rendering result to generate a smooth transition frame. The smooth transition frame and the fused rendering result are then encoded to obtain the target image.

[0009] According to a fourth aspect of this disclosure, a method for accelerating rendering is provided, wherein the method is applied to a computing node of the rendering acceleration system of the first aspect described above, comprising: It receives block data of different data categories allocated by the server, and performs rendering calculations on the block data according to the rendering nodes corresponding to the data categories to obtain pixel coloring results. The calculation nodes include multiple rendering nodes. The pixel coloring results are sent to the server.

[0010] According to a fifth aspect of this disclosure, an electronic device is provided, comprising: At least one processor; and A memory that is communicatively connected to at least one processor; wherein, The memory stores instructions that can be executed by at least one processor, such that the at least one processor is able to perform the methods of the second aspect, the third aspect, or the fourth aspect described above.

[0011] According to a sixth aspect of this disclosure, a non-transitory computer-readable storage medium is provided storing computer instructions, wherein the computer instructions are used to cause a computer to perform the methods of the second aspect, the third aspect, or the fourth aspect described above.

[0012] According to a seventh aspect of this disclosure, a computer program product is provided, including a computer program that, when executed by a processor, implements the method of the second aspect, the third aspect, or the fourth aspect described above.

[0013] The rendering acceleration system, method, and electronic device disclosed herein utilize quantum state compression coding to efficiently compress and encrypt touch and gesture data, reducing bandwidth requirements and data security risks associated with cloud interactions. By employing quantum gradient feature-based block classification, rendering tasks are precisely allocated to heterogeneous computing nodes, fully utilizing the computational potential of low-power servers. Furthermore, through multi-order feature tensor construction and compression, motion-aware interpolation, and other processing techniques, high-quality rendering effects and smoothness are ensured while significantly reducing reliance on high-performance graphics processing units. Therefore, this effectively solves the problems of high hardware costs and low resource utilization, achieving high-quality, high-efficiency rendering in low-computing-power environments, and providing a more cost-effective and scalable technical solution for scenarios such as cloud phones and cloud gaming.

[0014] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this application, nor is it intended to limit the scope of this application. Other features of this application will become readily apparent from the following description. Attached Figure Description

[0015] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure. Wherein: Figure 1 This is a schematic diagram of the structure of a rendering acceleration system provided in an embodiment of the present disclosure; Figure 2 A flowchart illustrating a rendering acceleration method provided in an embodiment of this disclosure; Figure 3 A flowchart illustrating another method for accelerating rendering provided in an embodiment of this disclosure; Figure 4 A flowchart illustrating another method for accelerating rendering provided in an embodiment of this disclosure; Figure 5This is a schematic block diagram of an electronic device provided in an embodiment of the present disclosure. Detailed Implementation

[0016] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0017] The following description, with reference to the accompanying drawings, describes a system, method, and electronic device for rendering acceleration according to embodiments of the present disclosure.

[0018] Figure 1 This is a schematic diagram of the structure of a rendering acceleration system provided in an embodiment of the present disclosure.

[0019] like Figure 1 As shown, the system includes: a target terminal, a server, and at least one computing node. The target terminal is configured to generate a quantum state sequence by processing the collected touch trajectory data and gyroscope data through quantum state compression encoding, and then transmit the quantum state sequence to the server. The server is configured to divide the quantum state sequence into blocks to obtain multiple blocks of data, and classify the multiple blocks of data by calculating quantum gradient features to generate block label matrices corresponding to each of the multiple blocks of data. The server is also configured to distribute multiple data blocks to their respective computing nodes and / or target terminals based on the block tag matrix and resource pool status. The computing nodes and target terminals are also configured to perform rendering calculations on their respective block data to obtain pixel coloring results; The server is also configured to construct a multi-level feature tensor based on the pixel coloring results, and to compress the multi-level feature tensor to obtain the fused rendering result; The server is also configured to perform motion-aware interpolation on the fused rendering results to generate smooth transition frames, and encode the smooth transition frames and the fused rendering results to obtain the target image.

[0020] In the embodiments disclosed herein, the core components of the rendering acceleration system include a target terminal, a server, and a set of computing nodes. Through a collaborative computing architecture, this system significantly reduces the reliance of traditional cloud rendering on high-performance graphics processing units and effectively improves the resource utilization of existing low-computing-power servers.

[0021] The target terminal typically refers to a user-held mobile device, such as a smartphone or tablet, running a specific cloud-based mobile application. This target terminal is responsible for collecting touch trajectory data and gyroscope data generated during user interaction in real time. Touch trajectory data specifically refers to a series of continuous coordinate points generated when the user performs actions such as swiping and clicking on the touchscreen, reflecting the user's direct operational intent. Gyroscope data originates from the device's built-in inertial measurement unit (IMU), used to accurately sense the device's rotational attitude in three-dimensional space, i.e., its orientation and angular changes. The target terminal performs quantum state compression encoding on these two types of raw data. This process involves mapping and compressing classical, continuous sensor data into a quantum computing state space, forming a special quantum state sequence. This quantum state sequence is a sequence composed of a superposition of qubits, carrying the original touch and attitude information in a high-density, high-security manner. After encoding, the target terminal transmits this quantum state sequence to a remote server via a quantum-encrypted channel.

[0022] The server, the core processing unit located in the cloud, first receives the quantum state sequence from the target terminal. The server performs block processing on this sequence, an operation that logically divides the continuous quantum state data stream into multiple smaller, more regular data units. Specifically, it divides the entire sequence into multiple blocks, each containing a fixed number of quantum states to facilitate parallel and refined analysis. Subsequently, the server performs in-depth analysis on each block by calculating quantum gradient features. Quantum gradient features are high-dimensional vectors reflecting the sensitivity and characteristics of quantum state changes within each data block, effectively distinguishing the differences in the screen content represented by different data blocks. Based on the calculated quantum gradient features, the server uses a classification algorithm to assign a category label to each data block, ultimately generating a structured block label matrix. This block label matrix is ​​a two-dimensional data matrix where each element uniquely corresponds to the category label of a specific block on the screen, identifying the type of screen content represented by that block, such as dynamic entities or static backgrounds.

[0023] After classification, the server further performs intelligent resource scheduling based on the block tag matrix and the real-time monitored resource pool status. The resource pool status is a dynamically updated data structure that summarizes the real-time operating status of all available computing units in the system (including computing nodes managed by the server itself and target terminals on the user's local machine), such as their current computing load, available computing power, and network latency. Based on this information, the server uses an optimized scheduling model to intelligently allocate different data blocks to the most suitable computing units for processing, thereby achieving fine-grained distribution of computing tasks.

[0024] Computing nodes are entities distributed throughout a network that possess a certain level of computing power, such as high-performance processor clusters in data centers, edge computing units deployed at base stations, or other user terminals. Like the user's target terminal, after receiving chunked data allocated by the server, they perform specific rendering calculations. Rendering calculations involve decoding, geometric processing, and lighting simulation of the allocated quantized chunked data, ultimately yielding the pixel shading result corresponding to that chunk. The pixel shading result is the direct output of the rendering process, represented as an image data block containing visual information such as color and brightness.

[0025] After all computing units complete their rendering tasks, the server aggregates the pixel shading results from various computing nodes and the target terminal. The server performs coordinate alignment and integration on these image data from different sources, potentially located in different coordinate spaces, to construct a unified multi-level feature tensor. This multi-level feature tensor is a high-order data structure that contains not only the image's two-dimensional spatial information (height and width) but also multiple feature channels (such as color, normals, and material) and possible temporal series information, thus comprehensively describing the features of the rendered image. Next, the server performs data compression on this tensor. This process aims to remove redundant information while preserving key visual features to the maximum extent possible, resulting in a fused rendering result with significantly reduced data volume but high visual fidelity.

[0026] Finally, the server performs temporal enhancement processing on the fused rendering result. It analyzes motion information between consecutive frames and performs motion-aware interpolation. Motion-aware interpolation is an intelligent frame generation technique that predicts the trajectory of objects in the scene and automatically generates additional, smooth transition frames between existing frames. This effectively increases the frame rate of the final video output, making dynamic scenes smoother. Ultimately, the server sends these smooth transition frames along with the original fused rendering result sequence to the video encoder to obtain a target image stream that meets specific format and resolution requirements, and then transmits it back to the user's target terminal for display.

[0027] The rendering acceleration system disclosed herein efficiently compresses and encrypts touch and gesture data through quantum state compression coding, reducing bandwidth requirements and data security risks associated with cloud interactions. By using quantum gradient feature-based block classification, rendering tasks are precisely allocated to heterogeneous computing nodes, fully utilizing the computing potential of low-power servers. Furthermore, through multi-order feature tensor construction and compression, motion-aware interpolation, and other processing techniques, high-quality rendering effects and smoothness are ensured while significantly reducing reliance on high-performance graphics processing units. Therefore, it effectively solves the problems of high hardware costs and low resource utilization, achieving high-quality, high-efficiency rendering in low-computing-power environments, and providing a more cost-effective and scalable technical solution for scenarios such as cloud phones and cloud gaming.

[0028] In one possible implementation of this disclosure, the target terminal is specifically configured as follows: The touch trajectory data is normalized and transformed into a coordinate system. Then, the touch coordinates, the filtered coordinates from the previous moment, and the filtered coordinates from the two previous moments are combined with the touch coordinates in the touch trajectory data to perform smoothing filtering and obtain preprocessed touch data. The device attitude parameters, including the unit vector of the rotation axis and the rotation angle, are obtained by solving the gyroscope data based on the quaternion algorithm. The preprocessed touch data is encoded into a touch quantum superposition state, which is a superposition of the basic quantum state and the quantum state after touch coordinate phase adjustment; A first matrix is ​​constructed based on the device attitude parameters, and the first matrix is ​​mapped to an attitude quantum superposition state. The attitude quantum superposition state is a superposition of the basic quantum state and the quantum state after phase adjustment by the first matrix. Using the touch quantum superposition state and the attitude quantum superposition state as input quantum states, the gradient descent method is used to compress the input quantum states to obtain a quantum state sequence.

[0029] In the embodiments of this disclosure, the process of generating a quantum state sequence from the collected touch trajectory data and gyroscope data through quantum state compression encoding involves data preprocessing and quantization operations. First, the target terminal performs a coordinate system transformation on the collected raw touch trajectory data. Coordinate system transformation is a mathematical process designed to convert the original coordinates from a device-specific pixel coordinate system to a standardized coordinate system ranging from zero to one, thereby eliminating differences caused by different device screen resolutions and making subsequent processing device-independent. After the coordinate transformation, the system further performs smoothing filtering on the normalized touch coordinates. Smoothing filtering is a signal processing technique aimed at eliminating abrupt changes in coordinate data caused by user operation jitter or sensor noise, thereby generating more stable and continuous trajectory data. This processing combines the current touch coordinates, the filtered coordinates from the previous moment, and the filtered coordinates from two moments ago, using a weighted average algorithm to predict and correct the current coordinate values, ultimately outputting smooth preprocessed touch data. The preprocessed touch data is a sequence of touch coordinates that has been cleaned and standardized as described above, providing a clean and consistent input for subsequent quantum encoding.

[0030] Simultaneously, the target terminal analyzes the gyroscope data acquired from the inertial sensor, applying a quaternion algorithm to solve this data. The quaternion algorithm is a mathematical tool for representing and calculating rotation in three-dimensional space; it efficiently and gimbal-freely describes the rotational state using a quaternion. The solution process involves integrating the raw angular velocity data or deriving the device's current orientation through sensor fusion algorithms. The result of this solution is the device's attitude parameters, a set of key parameters including the rotation axis unit vector and the rotation angle. The rotation axis unit vector is a three-dimensional vector defining the direction of the axis around which the device rotates; the rotation angle is a scalar representing the magnitude of the angle of rotation around that axis. These parameters together accurately describe the device's instantaneous attitude in space.

[0031] After the data preprocessing stage is completed, the target terminal begins quantum encoding. First, it encodes the preprocessed touch data into a touch quantum superposition state. A touch quantum superposition state is a quantum state that utilizes the superposition principle in quantum mechanics. Specifically, this quantum state is a linear superposition of a fundamental quantum state and a quantum state adjusted for touch coordinate phase. The fundamental quantum state typically refers to the reference state in quantum computing, for example, the calculation ground state. The quantum state after touch coordinate phase adjustment refers to a phase factor modulated by the touch coordinate value (e.g., ...). For another ground state (e.g.: The state is formed by rotating the state. This encoding method allows a single qubit to simultaneously represent multiple possibilities of touch coordinates in the form of probability amplitude, thereby achieving data compression and efficient representation.

[0032] Similarly, for attitude information, the target terminal constructs a first matrix based on the device attitude parameters (i.e., the aforementioned quaternions). Constructing the first matrix is ​​a mapping process, where the first matrix is ​​typically a Hermitian matrix, constructed from the four components of a quaternion, faithfully reflecting the mathematical properties of three-dimensional rotation. Subsequently, the system maps this matrix to an attitude quantum superposition state. The attitude quantum superposition state is another type of quantum superposition state, also in the form of a superposition of a fundamental quantum state and a quantum state phase-adjusted by the first matrix. Here, the quantum state phase-adjusted by the first matrix refers to a state whose phase adjustment factor is determined by the exponential operation of the Hermitian matrix, thereby encoding complex rotational information into the phase of the quantum state.

[0033] Ultimately, the target terminal uses the aforementioned touch quantum superposition state and attitude quantum superposition state together as the input quantum state. The input quantum state represents the original set of quantum data to be compressed. Gradient descent is used to compress them. Gradient descent is an optimization technique that iteratively adjusts a compression matrix on a specific complex manifold (such as the Stiefel manifold) to minimize the difference between the quantum states before and after compression. This process aims to find an efficient representation that approximates the original data with fewer qubits. Through this optimization, the system compresses the input quantum state, significantly reducing the quantum resources required to represent these states while preserving as much critical information as possible. The final output of the compression is a quantum state sequence, a highly compressed ordered set of quantum states containing touch and attitude information, laying a solid foundation for subsequent transmission to the server and distributed rendering tasks. The entire process improves the efficiency and security of data processing through quantum mechanisms, providing core support for high-quality interactive rendering in low-computing-power environments.

[0034] Specifically, when the target terminal generates a quantum state sequence by processing the collected touch trajectory data and gyroscope data through quantum state compression encoding, it can also adopt, but is not limited to, the following methods: The collected touch trajectory, i.e., the set of touch points X, undergoes coordinate preprocessing and normalized coordinate system transformation: Taking a user-owned mobile terminal as an example, the user uses a cloud phone installed on the terminal to play games. Assuming the device used is a capacitive touchscreen with a physical resolution of 2686×1320 and a sampling rate of 120Hz, the user's touch trajectory data can be obtained by collecting the data. .

[0035]

[0036] in (Maximum number of pixels horizontally on the device) The minimum x-coordinate value in the touch trajectory data. (Maximum number of pixels vertically on the screen) , These are the coordinates of the touch trajectory data after normalization coordinate system transformation.

[0037] The transformed coordinate system is then subjected to trajectory smoothing filtering to eliminate jitter.

[0038] in, The first in the touch trajectory data Touch coordinates at any moment The previous time frame after filtering coordinates, The filtered coordinates from the first two time steps. Preprocess touch data.

[0039] Meanwhile, processing the gyroscope attitude data collected during use helps to perform accurate spatiotemporal correction: Calculate the device attitude parameters:

[0040] in, The unit vector of the rotation axis. The rotation angle is... Quaternions are used to represent rotations in three-dimensional space. Transform the device coordinate system to the world coordinate system:

[0041] in, For the pre-calibrated sensor bias matrix, This is the device coordinate system.

[0042] Next, set the coordinates Perform quantum state encoding calculations Preprocessing touch data is about to begin. As input, a Bell-type superposition state is generated through a parameterized quantum circuit:

[0043] for The x-coordinate in the range [0,1]). The quantum state that encodes the touch position information is in a superposition state, namely the touch quantum superposition state.

[0044] Device attitude parameters As input, the quaternion is encoded using Grassman manifold coding. Mapping to quantum state : Construct the Hermitian matrix, i.e., the first matrix:

[0045] in, The cosine component representing the rotation angle; , , The component representing the axis of rotation; i is the imaginary unit; Hermitian matrix of quaternion mapping.

[0046] Next, the quantum state is calculated. :

[0047] in, To make quaternions It is mapped to a Hermitian matrix.

[0048] Will , as input quantum state The quantum state sequence was obtained by optimizing the gradient descent method on the Stiefel manifold. :

[0049] in, The number of qubits, such as 16. The dimension after compression, such as: 3. Input the complex matrix corresponding to the quantum state. matrix The conjugate transpose of .

[0050] In one possible implementation of this disclosure, the target terminal is further configured as follows: The first calculation result is obtained by performing data calculations based on the complex matrix corresponding to the input quantum state, the conjugate transpose of the complex matrix, and the input quantum state. The first difference is calculated by comparing the first calculation result with the input quantum state to obtain the first difference. The input quantum state is then compressed with the goal of minimizing the first difference to obtain the quantum state sequence.

[0051] In the embodiments of this disclosure, the complex matrix is ​​a matrix with complex elements, the number of rows and columns of which is determined by the number of qubits before and after compression. In this optimization process, it serves as a trainable parameter matrix and acts as a projection transformation operator from high-dimensional quantum space to low-dimensional quantum space.

[0052] The specific computation process involves first multiplying the complex matrix by its conjugate transpose, and then multiplying the resulting product matrix by the input quantum state. This series of operations aims to approximate the original input quantum state using a low-dimensional subspace. Through this series of linear transformations, the system obtains a first computational result, which is essentially a projection approximation of the original input quantum state on a compressed subspace.

[0053] Difference calculation is a mathematical operation that measures the difference between two things, typically calculating their distance at a specific norm (such as the L2 norm). This operation yields a quantized first difference, which precisely reflects the degree of information loss between the compressed approximate quantum state and the original quantum state; the smaller the value, the higher the fidelity of the compression.

[0054] Minimizing the first difference means that the system's optimization algorithm, namely the aforementioned gradient descent method, will iteratively adjust the parameters of the complex matrix on the complex manifold, continuously optimizing its values ​​to minimize the calculated first difference. When the optimization process converges to a satisfactory minimum, the compression transformation represented by the optimized complex matrix, when applied to the original input quantum state, yields the final quantum state sequence that has been efficiently compressed and has a significantly reduced data volume.

[0055] In one possible implementation of this disclosure, the server is specifically configured as follows: The quantum state sequence is decomposed into a one-dimensional quantum state array, and the one-dimensional quantum state array is mapped into a two-dimensional quantum state matrix. The two-dimensional quantum state matrix is ​​then divided into blocks in the first dimension to obtain multiple initial block data. Multiple initial data blocks are processed by non-overlapping sub-blocking in the second dimension to obtain multiple data blocks. If the resolution of the two-dimensional quantum state matrix is ​​not an integer multiple of the second dimension, the missing positions of the data blocks are filled with zero quantum states.

[0056] In embodiments of this disclosure, decomposition into a one-dimensional quantum state array is an unfolding process that explicitly transforms a received linear or packed sequence into a logically continuous one-dimensional sequence composed of a large number of independent quantum states, where each element is a basic quantum state unit. Mapping to a two-dimensional quantum state matrix is ​​a data structure transformation operation that rearranges the one-dimensional quantum state array into a two-dimensional grid-like matrix with height and width, according to the logical spatial structure of the original image or data.

[0057] The first dimension of block processing refers to dividing the matrix along its rows and columns into several large, continuous rectangular regions, each called an initial block of data. The second dimension of non-overlapping sub-block processing involves further subdividing each larger initial block into smaller, non-overlapping sub-blocks. "Non-overlapping" means that these sub-blocks do not share any quantum states; each quantum state belongs to only one sub-block, ensuring the independence and lack of redundancy in computational tasks. The second dimension typically refers to a smaller partitioning scale than the first dimension.

[0058] If the resolution of the two-dimensional quantum state matrix is ​​not an integer multiple of the second dimension, it means that the total size of the matrix cannot be uniformly divided by the size of the sub-blocks, leading to incomplete sub-blocks at the edges. Therefore, the system uses zero quantum states to fill in the missing positions of the sub-block data. Using zero quantum states is a boundary processing technique, where the zero quantum state usually refers to the ground state in quantum computing. Used as filler values. Filling missing positions in block data refers to filling in preset zero quantum states in regions where complete sub-blocks cannot be formed due to insufficient size, thereby ensuring that each block of data has a uniform and regular size.

[0059] When dividing a quantum state sequence into blocks to obtain multiple data blocks, the following methods can be used, but are not limited to: Processing quantum state sequences Perform 64×64 (first dimension) block processing: Will Decomposed into a one-dimensional quantum state sequence:

[0060] will sequence Mapped to a two-dimensional matrix and divided into 8×8 (second dimension) blocks (non-overlapping blocks): , Each data block is

[0061] Total Each block contains [number] blocks. Quantum state. Where the target terminal resolution size is not a multiple of 8, zero-padding is used: Used to fill in missing positions.

[0062] In one possible implementation of this disclosure, the server is further configured as follows: A quantum gate with trainable parameters is applied to multiple data blocks to calculate the quantum observables corresponding to each data block. The partial derivatives of each quantum observable with respect to the trainable parameters are calculated based on the preset parameter shift algorithm, and the quantum gradient feature vectors corresponding to each of the multiple data blocks are obtained based on the partial derivatives. The quantum gradient feature vector is reduced in dimension by a pre-defined principal component analysis algorithm to obtain a dimension-reduced feature vector. After linear combination of the dimension-reduced feature vectors, the classification probability of each of the multiple data blocks is obtained by probability calculation. The classification probability is used to determine the probability that the multiple data blocks belong to the dynamic entity class, the high light reflection class, the precise structure class, and the static background class. The data category to which each of the multiple data blocks belongs is determined based on the classification probability, and the category label corresponding to the data category is mapped back to the corresponding data block position in the two-dimensional quantum state matrix to obtain the block label matrix.

[0063] In embodiments of this disclosure, a quantum gate with trainable parameters is a parameterized sequence of quantum logic gates whose operation is controlled by a set of adjustable numerical parameters that are optimized during training to better perform a specific task. Applying these quantum gates to multiple data blocks means sequentially applying them to the quantum state corresponding to each block, performing a series of unitary transformations on them.

[0064] In quantum mechanics, a quantum observable corresponds to a Hermitian operator whose expectation value represents the average measurement result of the system on that physical quantity. In this context, it is an operator specifically designed or chosen for feature extraction, used to extract numerical features from the transformed quantum state. Calculating the expectation value of the observable for each block provides the basic data for subsequent gradient calculations.

[0065] Preset parameter shifting is a common technique in quantum computing. It approximates the gradient (partial derivative) of an observation with respect to a parameter by shifting a parameter in the quantum circuit by a fixed amount (e.g., π / 2) in both positive and negative directions, and then calculating the difference between the expected values ​​of the observation after two runs. The quantum gradient eigenvector is a high-dimensional vector composed of all the calculated partial derivatives arranged in a specific order. It comprehensively reflects the sensitivity of the quantum state to changes in circuit parameters and contains the inherent characteristics of the partitioned data. Preset principal component analysis is a classic linear dimensionality reduction technique. It transforms the original correlated high-dimensional features to a new set of uncorrelated low-dimensional coordinate axes (i.e., principal components) through orthogonal transformation, while retaining the most important variation information in the data.

[0066] Linear combination refers to performing a dot product operation between the dimensionality-reduced feature vector and a set of pre-trained classification weight vectors, plus a bias term. Probability calculation typically involves inputting the result of the linear combination into a Softmax function, which converts these values ​​into a probability distribution. The final classification probability is a probability distribution vector, where each element determines the probability that multiple data blocks belong to the dynamic entity class, specular reflection class, intricate structure class, or static background class. Dynamic entities typically refer to objects in continuous motion and with significant deformation in a scene, such as characters in a game; specular reflection refers to surface areas with strong specular reflection characteristics; intricate structure refers to static or micro-organisms containing complex details and textures, such as vegetation or architectural sculptures; and static background refers to large, unchanging background elements in a scene.

[0067] The system determines the data category of each data block based on classification probabilities. This is typically done by selecting the category with the highest probability as the final classification result for that block. Then, the system maps the category labels corresponding to the data categories back to the corresponding data block locations in a two-dimensional quantum state matrix. This means that the classification result of each sub-block is recorded according to its original spatial position in the two-dimensional matrix. Through this step, a block label matrix is ​​finally obtained. This matrix is ​​a label map corresponding to the spatial structure of the original quantum state matrix, where the value at each position represents the rendering category determined for that image block after the aforementioned complex quantum calculations. When classifying multiple data blocks by calculating quantum gradient features and generating block label matrices corresponding to each data block, the following methods can be used, but are not limited to: For each block of data Calculate its quantum gradient characteristics Then, classification is performed based on features: Define a quantum gate Apply to each block :

[0068] in, Interaction terms involving neighboring qubits, such as: , Trainable parameters, The first of the trainable parameters One parameter. The total number of trainable parameters, i.e., the number of quantum gate layers or the dimension of the parameter vector.

[0069] Combining trace operation with quantum gates Generating quantum observable parameters That is, quantum observable measurement:

[0070] in, No. A quantum observable (e.g., quantum state projection measurement basis). Input the density matrix of the quantum block (block data), where Tr represents the trace operation of the matrix, used to calculate the expected value.

[0071] Processing quantum observable parameters Calculate the quantum gradient features of each data block. : Based on the parametric displacement rule, for each parameter Calculate partial derivatives:

[0072] Then each block gradient feature vector for:

[0073] Next, regarding Perform dimensionality reduction calculation:

[0074] in For example, a dimensionality reduction matrix can be created by compressing a 66-dimensional gradient into a 4-dimensional principal component.

[0075] For each data segment, classification and label matrix generation are performed, and the dimensionality-reduced gradient features, i.e., the dimensionality-reduced feature vectors, are generated. Softmax after linear combination:

[0076] in, For category The weight vector, For bias terms, Classify blocks with tags (e.g., dynamic entities, specular reflections, etc.).

[0077] Based on classification probability Value category determines the classification, for example: dynamic entity | |etc.

[0078] Generate a label matrix based on the label determination results.

[0079] Each block of data Generate a category label, and map it back to its original position to construct a 64×64 label matrix:

[0080] in, Quantum superposition state, i.e. , Tag matrix, 4-bit integers to store category IDs (1-4).

[0081] In one possible implementation of this disclosure, the server is further configured as follows: Collect the node type, total computing power, current load rate and quantum processing power of at least one computing node to form the resource pool status corresponding to at least one computing node. The at least one computing node includes processor clusters, peripheral terminals and edge computing nodes. Construct a label matrix, which records the category, resource requirements, and maximum allowable processing latency for each computing node; Based on preset constraints, resource pool status, and a label matrix, mixed integer programming scheduling is performed to obtain task allocation results. The preset constraints include at least an objective function for minimizing the weighted sum of total processing latency and load imbalance, and the resource capacity of computing nodes. Based on the task allocation results, the block data of dynamic entity class is allocated to the processor cluster, the block data of specular reflection class is allocated to the peripheral terminal, the block data of precision structure class is allocated to the edge computing node, and the block data of static background class is allocated to the target terminal.

[0082] In the embodiments of this disclosure, node type is a classification of computing units based on their physical location and hardware characteristics. For example, a processor cluster typically refers to a collection of high-performance graphics processors located in a data center, a peripheral terminal refers to other available user devices in the network, and an edge computing node refers to computing devices deployed at the network edge (e.g., 5G base stations). Total computing power is a quantitative description of the node's theoretical peak computing performance, typically measured in floating-point operations per second. Current load rate is an instantaneous indicator reflecting the proportion of computing resources currently used by the node relative to the total resources. Quantum processing power is a specific indicator used to describe the node's ability to process quantum information, such as the number of qubits it can virtually simulate or actually manipulate. By aggregating these multi-dimensional real-time information, the system forms the resource pool state corresponding to at least one computing node, which constitutes a dynamically updated, global resource information database.

[0083] Constructing a label matrix is ​​a data structure that establishes descriptive information for computational tasks to be assigned. Each entry in the label matrix records key attributes associated with a computational task (i.e., a chunk of data). These attributes mainly include the category determined by the task based on its classification results (e.g., dynamic entity class or static background class), resource requirements (i.e., the estimated amount of computation, memory, and other resources required to execute the rendering task), and maximum allowable processing latency (i.e., the maximum time constraint allowed for the task from start to finish to ensure the real-time performance of the rendering).

[0084] The pre-defined constraints are the rules and optimization objectives that the scheduling model must follow. The objective function, which minimizes the weighted sum of total processing latency and load imbalance, aims to simultaneously pursue a fast overall system response and even load distribution among computing nodes, avoiding overload on some nodes while others are idle. The resource capacity of computing nodes serves as a hard constraint, ensuring that the total number of tasks allocated does not exceed the actual processing capacity of any node. Mixed-integer programming scheduling is a mathematical optimization method whose decision variables include both continuous variables (e.g., task start time) and integer variables (e.g., the 0-1 decision variable for whether a task should be assigned to a particular node), making it well-suited for solving problems involving the trade-off between discrete allocation and continuous resources. By solving this programming model, the system obtains an optimized task allocation result, which clarifies which specific computing node instance should process each block of data.

[0085] When allocating multiple data blocks to their respective computing nodes and / or target terminals based on the block tag matrix and resource pool status, the following methods can also be used, but are not limited to: Based on the label matrix of each data block Compared with the current computing unit resource pool status Perform mixed-integer programming to allocate tasks to processor clusters, peripheral terminals, edge computing nodes, and target terminals: Constructing the tag matrix :

[0086] in, For the task (i.e., block data) The resource requirements (e.g., computing power, storage requirements) are predefined by the business logic. Maximum allowed processing delay (in milliseconds), task The deadline (which must be completed before this time) is predefined by the business. Total number of tasks.

[0087] Build resource pool status :

[0088] in, node The types are processor clusters, peripheral terminals, edge computing nodes, and target terminals. node Total computing power (TFLOPS) Current load rate (0-1) Use the number of qubits (if applicable).

[0089] Perform mixed-integer programming to allocate tasks to processor clusters, peripheral terminals, edge computing nodes, target terminals, etc. Define binary allocation variables:

[0090] in, From resource pool status Extract from; Instance numbers are assigned to each type of node. From the tag matrix Extract from.

[0091] Preset constraints: Construct an objective function that minimizes the weighted sum of total latency and load imbalance.

[0092] in, ( For type (Base delay factor), task In resources The Execution time per instance. The weight of the balance term is, for example, 0.6. Target load factor, for example: 0.7. node Current load Binary decision variables (0 or 1) represent the task. Is it assigned to a resource? The One example. :Task The size of the resource demand, :resource The Total capacity of each instance.

[0093] Determine resource capacity limits:

[0094] Based on the allocation results, the corresponding block data The tasks are assigned to the corresponding computing nodes to perform game screen rendering calculations: dynamic entity objects are assigned to the processor cluster, specular reflection objects are assigned to peripheral terminals, intricate structure objects are assigned to edge computing nodes, and static background objects are assigned to the target terminal.

[0095] In one possible implementation of this disclosure, the processor cluster is configured as follows: Quantum state decoding is performed on the block data of dynamic entity classes to obtain touch trajectory decoding vector, posture mapping parameters, bone driving parameters and material reflectivity parameters. The touch trajectory decoding vector, posture mapping parameters, bone driving parameters and material reflectivity parameters are then processed to obtain a geometric parameter set. The diffuse and specular reflection terms are calculated based on the geometric parameter set, and the rendering is performed by combining the diffuse and specular reflection terms with ambient light intensity and ambient light occlusion compensation to obtain the dynamic entity rendering result. The pixel shading result includes at least the dynamic entity rendering result. The block data of the dynamic entity class is the first type of game data. The edge computing node and the target terminal work together to calculate the initial velocity of the ballistic trajectory, local environmental force and impact coordinates based on the block data of the dynamic entity class, and supplement the dynamic entity rendering result.

[0096] In the embodiments of this disclosure, the segmented data of dynamic entity classes refers to the quantum state data blocks identified by the server as moving or interactive objects (such as characters, weapons, etc. in a game) in the scene. Quantum state decoding is a reverse transformation process that restores quantum information to classically computeable parameters. Through specific quantum measurements and classical post-processing algorithms, hidden semantic information is extracted from the quantum superposition state. Through this decoding process, key rendering parameters are obtained, including touch trajectory decoding vectors, pose mapping parameters, skeletal drive parameters, and material reflectivity parameters. The touch trajectory decoding vector is the spatial coordinate information related to the user's previous interaction operations, which is restored from the quantum state. It may affect the intensity or position of specular reflection, such as the indirect control of the light source direction when the user swipes the screen. The pose mapping parameters are the device spatial orientation data restored from the quantum state, usually represented in the form of quaternions or rotation matrices. It determines the relative relationship between the observer's viewpoint and the reflective surface and is a key input for calculating the specular reflection direction. Skeletal drive parameters are a set of data that controls the motion state of the skeletal hierarchy within a character or object, such as joint rotation angles, which determine the entity's posture deformation and animation effects. Material reflectivity parameters, on the other hand, are multi-dimensional vectors that define the reflective properties of an object's surface to light, including physical properties such as diffuse color and specular intensity.

[0097] The geometric parameter set is a comprehensive data structure that systematically bundles the aforementioned touch trajectory, pose, skeleton, and material information. Based on this geometric parameter set, the processor cluster performs standard lighting calculations to generate the final pixel colors. The diffuse component is a part of the lighting model that simulates the color and brightness produced when light undergoes ideal diffuse reflection on an object's surface. Its calculation depends on the surface normal, the direction of illumination, and the material's diffuse reflection coefficient. The specular component simulates the effect of light forming specular highlights on a smooth surface; its intensity is closely related to the viewing direction, the reflection direction, and the material's specular properties. After calculating these two core lighting components, the processor cluster performs rendering based on the diffuse and specular components, combined with ambient light intensity and ambient occlusion compensation. Ambient light intensity represents the overall intensity of indirect lighting from all directions in the scene, providing basic illumination for objects. Ambient occlusion compensation is a rendering technique used to simulate the weakening of ambient light caused by occlusion between objects or in recesses within an object, enhancing the depth and realism of the image by adding a compensation value. By combining these elements, the final result is a dynamic entity rendering, which is a complete dynamic entity image block with lighting details. It is worth noting that the pixel shading result, as a generalized output, includes at least the dynamic entity rendering result, meaning it is an important component of the series of rendering results that make up the final image.

[0098] Furthermore, the processor cluster possesses enhanced capabilities for handling specific complex game scenarios. It can respond to chunked data of dynamic entity classes as Type I game data. Type I game data specifically refers to data generated by game types with extremely high requirements for physics simulation accuracy, such as first-person shooter games, which involve precise ballistic calculations. When this type of data is identified, the processor cluster initiates a collaborative computing mode, coordinating with edge computing nodes and the target terminal. This means the processor cluster no longer works in isolation but establishes communication links with edge computing nodes in the network and the user's local target terminal to jointly complete an extended computing task. The goal of this collaboration is to calculate the initial velocity, local environmental forces, and impact coordinates of the projectile based on the chunked data of dynamic entity classes. This means the rendering result not only includes visual images but also incorporates precise physical interaction data, allowing the bullet impact effects and bullet hole positions to be presented on the final screen based on realistic physics simulation, greatly improving the realism and fairness of competitive games. The entire process embodies efficient collaboration from quantum information decoding to classical rendering and then to cross-node physics simulation.

[0099] When computing nodes perform rendering calculations on their respective block data to obtain pixel coloring results, if the computing nodes are a processor cluster, the following methods can be used, but are not limited to: Based on quantum block vector The touch trajectory decoding vector is calculated. Gyroscope attitude mapping refers to attitude mapping parameters. Skeletal drive parameters Material reflectivity To form a set of geometric parameters (Position / Rotation / Skeleton / Material):

[0100] in, Touch mode basis vectors (pre-trained adversarial generation). The user's touch trajectory (coordinate sequence) is encoded by a quantum circuit into an 8-qubit superposition state. Location decoding weights (3×64 dimensions). A neural network (64-dimensional input, 128-dimensional hidden layer, 3-dimensional output) maps weighted touch features to entity locations. , Mapping from quaternions to rotation matrices Quantum state gradient operator, Will This is mapped to a 2×2 Hermitian matrix, representing the quantum mechanical description of the device's attitude. Skeletal-driven weights Material weight.

[0101] The calculated geometric parameter set Geometric and rasterization processes are performed to ultimately produce the pixel coloring result. (Dynamic entity rendering result) is output as the screen rendering result:

[0102]

[0103]

[0104] in, For diffuse color, the first three components of the material's reflectance represent the RGB color. For surface normals and lighting direction, the geometric normal vector at the location of the rendering point and the unit vector pointing from the rendering point to the light source; The intensity of specular reflection is the fourth component of the material's reflectivity, which controls the brightness of highlights. Ambient light Hermite matrix; : View direction, a unit vector pointing from the rendering point to the camera, a half-angle vector; Highlight index: controls the sharpness of highlights; Quantum coupling coefficient, the gradient magnitude of the touch quantum state, dynamically adjusts the quantum enhancement strength; Ambient light intensity: The RGB intensity of the scene's global illumination; Ambient occlusion: A compensation item based on ambient occlusion map.

[0105] In the case of a first-person shooter (FPS) competitive game, the processor cluster needs to coordinate with edge computing nodes and target terminal nodes to calculate the impact coordinates in real time. The steps are as follows: Processor clusters based on quantum touch trajectory gradient amplitude Combined with weapon type coefficient (e.g., pistol 0.8 / rifle 1.2 / sniper rifle 1.6), calculate the initial velocity of the ballistic trajectory. ; Real-time computing environment parameters of edge computing nodes Local environmental forces are calculated using a lightweight model (3 layers, 128 hidden layers). ; The processor cluster receives computations from edge computing nodes. The target terminal provides real-time screen touch coordinates. It is used for bullet impact point prediction and compensation to obtain the impact coordinate values. .

[0106] In one possible implementation of this disclosure, the peripheral terminal is configured as follows: Quantum state decoding is performed on the block data of high light reflection to obtain the touch trajectory decoding vector and attitude mapping parameters; The reflection intensity coefficient and hue shift coefficient are calculated based on the touch trajectory decoding vector and posture mapping parameters. Then, specular reflection rendering is performed based on the reflection intensity coefficient and hue shift coefficient combined with the ambient light intensity to obtain the specular reflection rendering result. The pixel shading result includes at least the specular reflection rendering result. In response to the specular reflection data being classified as the second type of game data, the specular reflection rendering results are asynchronously transmitted to the processor cluster and the target terminal to enhance the rendering effects of other categories, which are data categories other than specular reflection.

[0107] In the embodiments of this disclosure, peripheral terminals refer to other terminal devices in the network that are not the target terminal but can be scheduled and used. These devices access the system through a cloud mobile application and contribute their idle computing power. Peripheral terminals are mainly responsible for processing block data classified as specular reflection. This type of data typically corresponds to surface areas in a scene with strong specular reflection characteristics, such as highlights on water surfaces, metal, or glass.

[0108] The reflection intensity coefficient is a scalar value used to quantify the brightness of specular reflections. Its calculation integrates attitude information decoded from quantum states and preset material properties, and is ultimately constrained to a reasonable range of zero to one by an activation function (such as the sigmoid function). The hue shift coefficient is a multi-dimensional vector (usually RGB three-channel) that represents the color shift of the specular region relative to the ambient light source. This shift may be caused by special material filters or ambient light interference effects, and its calculation often involves the extraction and analysis of the frequency domain characteristics of quantum states.

[0109] Specular rendering is a lightweight computer-aided graphics computation used to simulate the reflective properties of smooth surfaces. Based on an optical physics model, it calculates the color and brightness of specular highlights formed by a light source on a surface at a specific viewing angle. In this process, the calculated reflection intensity coefficient directly controls the intensity of the highlight, while the hue shift coefficient dynamically modulates the color of the highlight, allowing it to blend with ambient light and produce possible color variations. The final result is a specular rendering image, i.e., a block of image data with completed specular reflection shading. It's important to clarify that the final pixel shading result output by the system is a collective concept; it includes at least the specular reflection rendering result, meaning that this result is an essential component of the complete image.

[0110] Furthermore, the peripheral terminal possesses scene-adaptive collaborative capabilities. It can respond to specular reflection data as the second type of game data. This second type of game data specifically refers to data generated by game types that have high requirements for environmental atmosphere and lighting uniformity, such as large open-world games. When this type is identified, the peripheral terminal asynchronously transmits the specular reflection rendering results to the processor cluster and the target terminal. Asynchronous transmission means that this data transmission process does not need to wait for a strict synchronization clock; it can be sent immediately after calculation without affecting the speed of the main rendering pipeline. The purpose of this operation is to enhance the rendering effects of other categories. Other categories explicitly refer to data categories other than specular reflection, mainly including dynamic entity classes handled by the processor cluster and static background classes handled by the target terminal. Specifically, when rendering dynamic entities, the processor cluster can incorporate specular information provided by the peripheral terminal, making the specular highlights on the surface of characters or weapons coordinate with environmental reflections; while when rendering static backgrounds, the target terminal can also refer to this data, making background elements such as the sky and distant mountains react to strong light in the scene. This cross-node data sharing mechanism effectively improves the consistency and realism of the lighting in the entire rendered image, forming a synergistic distributed rendering closed loop.

[0111] When computing nodes perform rendering calculations on their respective block data to obtain pixel coloring results, if the computing node is a peripheral terminal, it can be implemented in the following ways, but not limited to: For block data involving specular reflections (such as global illumination effects or specular reflection effects), due to their small computational load, the base station calls upon the computing units of surrounding terminals to perform collaborative rendering calculations using third-party terminals. The calculation steps are as follows: Through quantum decoding, quantum block vectors Decode the touch trajectory to obtain the decoding vector. Gyroscope attitude mapping refers to attitude mapping parameters. And based on this, the reflection intensity estimation coefficient is calculated. and hue shift coefficient .

[0112]

[0113] in, Intensity decoding weights (2 qubits → scalar); FFT: Fast Fourier Transform, extracting frequency domain features of quantum states; A 2-layer network (3D input → 3D output) maps frequency domain features to RGB color shift.

[0114] Obtain the reflection intensity estimation coefficient and hue shift coefficient Then, lightweight specular reflection rendering is performed to obtain the specular pixel shading result for specular reflection objects. That is, the rendering result of specular reflection.

[0115]

[0116] in, High light attenuation coefficient (optimized value for mobile devices); High sharpness (balancing performance and effect); Channel-by-channel multiplication enables dynamic color shift.

[0117] If the game is an open-world game, the calculation results from peripheral terminals need to be asynchronously transmitted to the processor cluster and target terminal nodes to enhance the impact of environmental factors and strengthen the effect of ambient lighting factors on the pixel shading results of dynamic entities. The construction and calculation formula is as follows: Pixel coloring results for dynamic entities:

[0118] In one possible implementation of this disclosure, the edge computing node is configured as follows: Quantum state decoding is performed on the block data of the precise structure class, and the hash value of the block data of the precise structure class is calculated. The hash value is compared with the preset template hash value to determine the template matching result. Calculate the detail scaling factor of the block data of the precision structure class, calculate the texture displacement vector and dynamic normal perturbation vector based on the detail scaling factor and the template matching result, and perform basic texture adjustment based on the texture displacement vector and dynamic normal perturbation vector to obtain the precision structure rendering result. The pixel shading result includes at least the precision structure rendering result. In response to the fact that the segmented data of the precision structure class is the third type of game data, the entity acceleration parameters transmitted by the processor cluster are received, and the precision structure rendering results are subjected to momentum-aware texture blurring based on the entity acceleration parameters to obtain enhanced precision structure rendering results.

[0119] In the embodiments of this disclosure, edge computing nodes are computing devices deployed at the network edge (e.g., within a 5G base station). They are characterized by low-latency access and certain computing resources, making them very suitable for performing fast texture retrieval and streaming processing tasks.

[0120] A hash value is a fixed-length digital fingerprint generated by a hash function, which uniquely (or with high probability) represents the characteristics of input data. This disclosure uses a quantum-state hash function specifically designed to process quantum-state data, generating a compact and rapidly comparable digital digest. The preset template hash values ​​are a set of hash values ​​pre-computed and stored in the local database of the edge nodes, each corresponding to a known high-frequency detail texture template (e.g., various types of leaf or brick wall textures). By quickly comparing the hash value of the current block data with the hash values ​​in the template library, the system can determine the template matching result. The template matching result is an identifier that indicates which pre-stored texture in the template library is most similar to the current fine-structure block, thus achieving efficient structure reuse and avoiding redundant calculations.

[0121] The detail scaling factor is a scalar parameter that determines the degree to which texture details are magnified or reduced. Its calculation is typically based on the analysis of quantum state gradients and obtained through a lightweight neural network mapping. The texture displacement vector is a three-dimensional vector that represents the minute positional shift that texture vertices should undergo due to object movement or changes in viewpoint in the virtual world. The dynamic normal perturbation vector is also a three-dimensional vector used to simulate the effect of surface micro-irregularities on the direction of light reflection, thereby enhancing visual details without increasing geometric complexity.

[0122] Base texture adjustment is a graphics processing procedure that uses calculated displacement and normal perturbation vectors to perform coordinate transformations (UV offsets) and surface normal modifications on the base texture retrieved from the template library. Through this adjustment, the static template texture is endowed with dynamic, detail variations consistent with the current scene context. The final result is a fine-grained structure rendering, i.e., a texture image containing rich dynamic details. The system's pixel shading results, as a comprehensive output, include at least the fine-grained structure rendering result.

[0123] Furthermore, edge computing nodes possess enhanced processing capabilities for high-speed motion scenes. They can respond to segmented data of intricate structures as third-category game data. Third-category game data refers to data generated by game types involving high-speed motion that produce significant motion blur, such as racing games or high-speed flight simulators. When this type is identified, the edge computing node receives entity acceleration parameters transmitted from the processor cluster. Entity acceleration parameters are physical quantities calculated and sent by the processor cluster responsible for rendering dynamic entities; they describe the instantaneous magnitude and direction of the acceleration of relevant moving objects in the scene. Upon receiving these parameters, the edge computing node performs momentum-aware texture blurring on the intricate structure rendering results based on the entity acceleration parameters. Momentum-aware texture blurring is a post-processing effect that dynamically simulates and applies motion blur based on the object's momentum (directly related to acceleration). Specifically, a directional blur convolution is performed on the rendered intricate structure texture along the direction of motion, with the degree of blur proportional to the magnitude of the entity's acceleration. Through this processing, the system obtains a more visually realistic enhanced intricate structure rendering result, greatly improving the dynamic realism of the image.

[0124] When a computing node performs rendering calculations on its corresponding block data to obtain pixel coloring results, if the computing node is an edge computing node, it can be implemented in the following ways, but not limited to: For segmented data with intricate structures, such as vegetation or architectural details, the server can generate corresponding quantum segment vectors due to their high reusability. Send to the edge computing node, and the edge computing node processes it. Perform texture streaming processing to calculate the detail-enhanced texture. The calculation steps for the detailed structure rendering result are as follows: Based on quantum block vector Reusable structure retrieval is performed to obtain template matching results for precise structural textures. With detail scaling factor parameter :

[0125] in, : Pre-stored geometric template library in the base station (containing high-frequency detail models such as vegetation / buildings); Hash: Quantum state hash function; : 2-layer network (4-dimensional input, 1-dimensional output), with limited output range; Then based on the template matching results With detail scaling factor parameter This involves calculating the displacement of texture vertex directions to determine the displacement vector of vegetation or building textures caused by changes in the character's movement direction. and dynamic normal perturbation vector :

[0126] in, Displacement decoding matrix; The real component of the quantum state (2-dimensional, due to) ); : Normal perturbation weight matrix; : The 5th to 8th order components of the quantum state frequency domain characteristics (corresponding to high-frequency details).

[0127] Based on texture displacement change vector and the dynamic normal perturbation change vector Calculate detailed texture enhancement for objects with precise structural structures. :

[0128]

[0129] in, : 3-layer network (6-dimensional input, 2-dimensional output) to learn the relationship between vertex displacement and UV offset; Conv3×3: 3×3 convolution kernel to extract local patterns of normal perturbation.

[0130] In high-speed racing games, due to the involvement of high-speed motion blur, the textures of intricate structures need to be adjusted secondaryly based on the motion acceleration of dynamic entities. Therefore, the processor cluster is required to process the entity acceleration parameters. The data is fed back to the edge computing nodes for additional momentum-aware texture blurring, thereby calculating the enhanced precision structure rendering result. The calculation formula is as follows:

[0131] In one possible implementation of this disclosure, the target terminal is further configured as follows: Quantum state decoding is performed on the block data of static background, and the quantum frequency domain projection vector and touch brightness correction coefficient are calculated; The rendering is based on a combination of quantum frequency domain projection vector and touch brightness correction coefficient, screen coordinates and cloud gradient simulation algorithm, to obtain static background rendering results. The pixel coloring results include at least the static background rendering results.

[0132] In the embodiments of this disclosure, the block data of static background class refers to the quantum state data block that is identified as a large range of background elements in the scene that are fixed or slowly changing after being classified by the server-side quantum gradient features, such as: skybox, distant mountain terrain or static building group, etc.

[0133] Quantum frequency domain projection is a feature mapping technique that extracts color information from decoded quantum states. It first performs a Fast Fourier Transform on the quantum state to analyze its frequency domain characteristics, where low-frequency components typically correspond to large, smoothly varying color patches in an image, such as the dominant color of the sky. Then, through a pre-trained projection matrix (e.g., a combination of the Softmax function and a weight matrix), these frequency domain features are robustly mapped to a three-dimensional vector space, resulting in an RGB vector representing the dominant color of the sky or background—the quantum frequency domain projection vector. The touch brightness correction coefficient is a scalar parameter used to dynamically adjust the overall brightness of the background. Its calculation relies on the analysis of the gradient of the quantum state of the user's touch operation, which reflects the intensity of the user's interaction or the strength of their intent. By using activation functions such as the hyperbolic tangent function to normalize the gradient magnitude to a reasonable range, the user's recent touch behavior can subtly and smoothly affect the background brightness, thereby enhancing the real-time feedback of the interaction and the dynamic realism of the image.

[0134] Screen coordinates refer to the normalized position information of the currently processed pixel on the device's display screen, defining the spatial context of the rendering operation. The cloud gradient simulation algorithm is a procedural content generation technique that uses periodic functions (such as sine functions) or noise functions to simulate the irregular shapes, density variations, and soft lighting transitions of clouds in nature, based on screen coordinates, thereby generating a realistic sky background effect. The specific rendering process is as follows: First, the primary color vector obtained from the quantum frequency domain projection vector is modulated using a touch brightness correction coefficient to calculate the final background effect color vector, which includes dynamic brightness changes caused by user interaction. Then, combining the screen coordinates of each pixel, the effect color vector is fused with the pattern intensity generated by the cloud gradient simulation algorithm. For example, by multiplying the effect color vector by a periodic intensity factor simulating cloud distribution calculated based on screen coordinate UV values, the output color value of each pixel is finally determined.

[0135] The static background rendering result is a block of image data that has undergone color processing and represents the static background portion of the scene. It directly corresponds to the final visual representation of a specific area on the terminal screen. It is important to clarify that in the output of the entire system, the pixel coloring result is a broad set concept that summarizes the rendering output from all computing nodes and includes at least the static background rendering result.

[0136] When rendering and calculating the block data on the target terminal to obtain the pixel coloring result, the following methods can be used, but are not limited to: For segmented data with static backgrounds (such as sky backgrounds), due to their small computational load, the calculations are performed locally on the target terminal, and the target terminal node... Perform skybox hue decoding and terrain material blending to calculate the static background pixel coloring result. The static background rendering result is calculated using the following steps: According to the quantized sequence Perform skybox hue decoding to obtain the quantum frequency domain projection vector. and touch brightness correction factor Used to render the sky background:

[0137] in, Sky color decoding matrix (frequency domain to RGB); : Low-frequency components of quantum state frequency domain characteristics (corresponding to the main color tone of the sky). Then combine and , thus obtaining the final background color vector :

[0138] Based on the background effect color vector The static background pixel coloring result is obtained. :

[0139] in, : Screen UV coordinates (normalized to [0,1]); Sine term: simulates cloud gradient effect (period 10, amplitude 0.2); , : This refers to the device screen size parameter.

[0140] In one possible implementation of this disclosure, the server is further configured as follows: The pixel coloring results fed back by each computing node and / or target terminal are uniformly transformed to the world coordinate system through a preset affine transformation algorithm and a preset transformation method to obtain the transformed pixel coloring results. The preset transformation method includes at least minimizing the coordinate error of the coordinate points corresponding to multiple pixel coloring results. Based on the converted pixel coloring results, a multi-order feature tensor is constructed. The dimensions of the multi-order feature tensor include at least the image resolution dimension, the feature channel dimension, and the time frame sequence dimension. The feature channel dimension includes at least the channels for dynamic entities, the channels for specular reflection, the channels for fine structures, and the channels for static backgrounds. The multi-order feature tensor is decomposed into a kernel tensor and a multimodal factor matrix by a preset singular value decomposition algorithm. The kernel tensor and the multimodal factor matrix are then input into a preset conditional generative adversarial network for data fusion processing to obtain a fused rendering result. The preset conditional generative adversarial network is used at least to fill in the high-frequency details lost during compression by learning high-frequency texture and lighting features.

[0141] In the embodiments of this disclosure, the preset affine transformation algorithm is a set of mathematical tools that includes linear transformations such as rotation, scaling, translation, and shearing. It can systematically map points or image data in one coordinate system to another. The world coordinate system is a unified and absolute three-dimensional spatial reference system defined in the virtual scene. All objects and effects in the scene determine their positions and orientations according to this coordinate system. The transformation goal here is to uniformly transform pixel coloring results from different sources such as processor clusters, peripheral terminals, edge computing nodes, and target terminals from their respective possible local coordinate systems or screen coordinate systems to this world coordinate system, thereby ensuring that all screen elements can be correctly aligned and stitched in space. The preset transformation method specifically indicates how to determine the optimal parameters of this series of affine transformations. The method includes at least minimizing the coordinate error of the corresponding coordinate points of multiple pixel coloring results. This means that the system will find a set of transformation parameters that minimize the difference in the corresponding spatial positions of image data from different computing nodes depicting the same scene element in the world coordinate system after transformation, thereby mathematically ensuring the accuracy of fusion.

[0142] A multi-order feature tensor is a high-order data structure that can be viewed as a multi-dimensional array designed to efficiently encapsulate and organize rich information about a rendered image across multiple dimensions. The tensor's dimensions include at least image resolution, feature channels, and a temporal frame sequence. The image resolution dimension corresponds to the spatial dimensions of the rendered image, namely height and width, defining the spatial range of the image. The feature channel dimension contains multiple data channels depicting different physical or visual attributes of the scene, including at least channels for dynamic entities, specular reflections, detailed structures, and static backgrounds. This means that the tensor has dedicated channels for storing dynamic entity information from the processor cluster, specular reflection information from peripheral terminals, detailed structural details from edge computing nodes, and static background information from the target terminal, achieving structured storage of data for different rendering categories. The temporal frame sequence dimension accommodates multiple consecutive frames of data within a short time window, enabling the system to utilize temporal information for subsequent temporal processing, such as motion prediction and frame interpolation.

[0143] Preset singular value decomposition algorithms refer to decomposition methods applicable to higher-order tensors, such as higher-order singular value decomposition. It can decompose complex multidimensional data into a core kernel tensor and a set of multimodal factor matrices corresponding to each dimension. The kernel tensor captures the core features of the interactions between different dimensional modes, while the multimodal factor matrices represent the main variation patterns of the tensor in each independent dimension (such as spatial, channel, and temporal).

[0144] Preconditional Generative Adversarial Networks (GANs) are generative artificial intelligence models consisting of a generator and a discriminator that evolve through adversarial training. The core function of this network is to fill in high-frequency details lost during compression by learning high-frequency texture and lighting features. Specifically, the generator, given the compressed core tensor and factor matrix as conditional inputs, learns to reconstruct a visually complete and detailed image, focusing particularly on recovering high-frequency visual information such as fine textures, sharp edges, and complex lighting changes that may have been smoothed out or lost during tensor decomposition and compression. The discriminator is responsible for judging whether the generated image details are indistinguishable from a real, high-quality rendering result, thus driving the generator to continuously improve. Through this detail filling and enhancement based on adversarial learning, the server ultimately obtains a visually high-fidelity, detail-rich fused rendering result.

[0145] When constructing a multi-order feature tensor based on pixel shading results and compressing the multi-order feature tensor to obtain the fused rendering result, the following methods can also be used, but are not limited to: constructing a multi-order feature tensor based on the rendering calculation results of each computing node and the target terminal. ; First, the calculation results are subjected to a unified coordinate transformation to unify the result data of all calculation unit nodes into the world coordinate system, resulting in the transformed pixel coloring result. :

[0146] in, Pixel coloring results , The representation vectors on the rotation matrices about the Z-axis, the Y-axis, and the X-axis. is the translation vector, representing the position offset of the main camera's view in the world coordinate system. The number of transformation steps (e.g., multi-frame pose superposition).

[0147] Next, minimize Minimize the error at the corresponding point:

[0148] in, The first in the local coordinate system The coordinates of a point (e.g., camera coordinate system). The coordinates of the corresponding point in the global coordinate system (e.g., the world coordinate system).

[0149] Define multi-order tensors Data structures: 16 represents the image resolution (e.g., 1920×1080); 16 represents the number of feature channels (including RGB color, normals, depth, material, etc.). The length of the time frame sequence (5 frames are buffered for time-domain fusion).

[0150] Will The component space coordinates are filled into the multi-order tensor. middle:

[0151] in, In order to be in Spatial coordinates on. 'Channel' represents the physical quantity processed by different computing units. 't' represents the time dimension (dynamic data sequence).

[0152] For multi-order tensors Perform high-order singular value decomposition and compression to extract core image rendering information: decompose the tensor into kernel tensors. and modal factor matrices :

[0153] in, The core tensor (controls the interaction between different modalities). is a multimodal factor matrix, corresponding to the linear transformations of the spatial (x,y), channel (c), and time (t) modes, respectively. For modular multiplication of tensors and matrices.

[0154] right , The merged rendering result is obtained by performing a second decomposition:

[0155] in, For the first Modal factor vectors (low-dimensional basis vectors). Let be the rank (compressed dimension) of each mode. This is the outer product operation for vectors.

[0156] In one possible implementation of this disclosure, the server is further configured as follows: The fused rendering result is split into consecutive previous and next frame images according to the time series, and the forward and reverse optical flow fields between the previous and next frame images are calculated. By eliminating unreliable optical flow vectors whose vector magnitude exceeds a preset flow field threshold in both the forward and reverse optical flow fields, the optimized bidirectional optical flow field is obtained. The optimized bidirectional optical flow field and the depth maps of the previous and next frames are input into a preset spatiotemporal prediction network for feature extraction to obtain a motion change matrix. Based on the motion change matrix and preset interpolation weights, adaptive weighted interpolation is performed to generate a smooth transition frame. The smooth transition frames and the fused rendering results are integrated into an image sequence. The image sequence is compressed using a preset high-efficiency video coding standard to obtain the target image, and the target image is streamed to the target terminal.

[0157] In the embodiments of this disclosure, splitting by time sequence refers to dividing the continuous rendering output into two adjacent, temporally continuous image frames based on the timestamp or frame order of the data, namely the previous frame image (the image at time point t) and the next frame image (the image at time point t+1). The two frames form the basis for motion analysis and interpolation.

[0158] The forward optical flow field is a two-dimensional vector field that describes the displacement vector of each pixel from the previous frame to the next frame, i.e., predicting the positional change of each pixel in the next frame. The backward optical flow field describes the inverse pixel motion vector from the next frame to the previous frame. Computing the optical flow field typically employs dense optical flow estimation algorithms, which estimate pixel-level motion by analyzing the consistency of visual features such as brightness and gradient between two frames.

[0159] The vector magnitude refers to the Euclidean length of the optical flow vector, representing the amplitude of pixel motion. The preset flow field threshold is a pre-defined empirical value used to judge the rationality of the motion vector. For example, when the optical flow vector amplitude is abnormally large, it may originate from occlusion areas, fast-moving boundaries, or estimation errors; these are considered unreliable optical flow vectors. Removing these outliers helps avoid introducing obvious visual artifacts in subsequent interpolation. After this filtering step, the system obtains a cleaner and more consistent optimized bidirectional optical flow field, which retains only reliable vectors with continuous motion trajectories and high spatial consistency.

[0160] A depth map is a grayscale image corresponding to an image frame, recording the distance information between each pixel and the camera. It provides the three-dimensional geometric context of the scene, helping to distinguish foreground and background motion, thereby improving the accuracy of motion prediction. A pre-defined spatiotemporal prediction network is a deep learning model that typically combines 3D convolutional layers, self-attention mechanisms, and recurrent neural networks to learn motion patterns and dynamic features from spatiotemporal sequence data. This network performs multi-level feature extraction and spatiotemporal correlation analysis on the input bidirectional optical flow, image, and depth information, ultimately obtaining a motion change matrix representing pixel-level motion trajectory changes. This matrix quantifies the expected displacement of each pixel relative to the preceding and following frames at an intermediate frame.

[0161] Adaptive weighted interpolation is a frame generation technique that dynamically adjusts weights based on motion boundaries and image content. Its core principle is to utilize a motion change matrix and a preset interpolation weight (determined by the relative position of the target transition frame on the time axis). By inversely twisting the pixels of the previous and next frames according to the motion vectors and then linearly blending them based on the weights, a smooth transition frame is synthesized, resulting in an intermediate image that transitions smoothly both temporally and visually. This effectively maintains the edge sharpness of moving objects and avoids blurring.

[0162] Integrating into an image sequence refers to inserting newly generated, smoothly transitioning frames into the original blended rendering result frames in the correct temporal order, forming a continuous image stream with a higher frame rate and improved temporal resolution. This enhanced image sequence provides a smoother visual experience for the final video output.

[0163] The pre-defined high-efficiency video coding standard refers to a new generation of video compression specifications that utilizes advanced predictive, transform, and entropy coding technologies to significantly reduce video data volume while maintaining high visual quality. After efficient compression, the system obtains the target image, which is a bitrate-optimized image stream that meets transmission requirements. The server then streams the target image to the target terminal, allowing users to view high-frame-rate, low-latency rendered footage in real time. The entire process, through motion-aware frame interpolation and efficient coding, significantly improves the smoothness and visual quality of the final output video.

[0164] When generating smooth transition frames by motion-aware interpolation of the fused rendering results, and encoding the smooth transition frames and the fused rendering results to obtain the target image, the following methods can also be used, but are not limited to: Using time t as the unit, sort the fused rendering results into the previous frame image according to the time sequence.

[0165] The next frame image Then, spatiotemporal network motion prediction and interpolation are applied to generate smooth transition frames. This requires considering both the preceding and following frames. , Perform bidirectional optical flow field , Estimate, The dense optical flow field, i.e., the forward optical flow field, is estimated based on two consecutive frames. With reverse optical flow field :

[0166]

[0167] PWC is an optical flow estimation algorithm. , For image frames at times t and t+1.

[0168] Then, unreliable optical flow vectors (low confidence or large inverse error) need to be removed, such as frames with rendering errors, to avoid magnifying erroneous images and thus obtain a reliable set of optical flow vectors. , :

[0169] Among them, the consistency threshold , retaining effective optical flow vectors to construct sparse motion trajectories. These are the pixel position coordinates.

[0170] based on , When placed into a conventional spatiotemporal trajectory prediction network, smooth frame prediction is performed:

[0171] in, , It is a depth map or feature map of the previous frame and the next frame (used for multimodal optical flow estimation). The size of the 3D convolution kernel (spatial dimension). This represents the number of output channels. SAttn is the self-attention layer (capturing spatiotemporal dependencies). MaxPool is the resource pool. The matrix of predicted motion changes (two-dimensional motion vectors of N points). is the dimension of the LSTM hidden layer.

[0172] Wherein, the motion vector of the kth intermediate frame is predicted. The calculation formula is as follows:

[0173] in, For interpolation weights, This represents the number of intermediate frames. Features of historical frames.

[0174] Based on the calculation Adaptive weighted interpolation is performed to obtain the final transition frame. :

[0175] in, For motion vectors, For interpolation weights, The image frames used for interpolation are smooth transition frames, and edge-guided interpolation is used for motion boundaries:

[0176] in, Adjustment factors, such as 0.3, enhance the continuity of motion boundaries. This represents the image gradient magnitude.

[0177] Will Interpolation result frame and the initial calculation result frame , The merged image is then output to the user's terminal to display the target image after overall rendering acceleration.

[0178] In one possible implementation of this disclosure, the target terminal is further configured as follows: The peak signal-to-noise ratio, frame delay, and load rate of each computing node of the target image stream are collected in real time according to the sampling period of the quantum state sequence. If the peak signal-to-noise ratio, frame latency, or load rate does not meet the preset data judgment conditions, it is judged as data abnormality, and the abnormal data and abnormality type in the peak signal-to-noise ratio, frame latency, or load rate are transmitted to the server so that the server can re-execute the rendering process based on the abnormal data.

[0179] In the embodiments of this disclosure, the sampling period of the quantum state sequence refers to the time interval when the touch and gyroscope data are initially quantum encoded. This serves as the rhythm benchmark for monitoring, ensuring the temporal logical consistency from data acquisition to final image evaluation. The target image stream is compressed image data that has been fully processed by the system and finally transmitted to the user terminal. Peak signal-to-noise ratio (PSNR) is an objective indicator of image reconstruction quality and the degree of distortion of the original signal. A higher value indicates better image fidelity and is a key parameter for evaluating the clarity and noise level of the rendered image. Frame latency refers to the total time elapsed from the occurrence of a user operation to the display of the corresponding image on the screen. It directly determines the real-time interactive experience and is one of the core performance indicators of a cloud rendering system. Load rate refers to the percentage of computing resources currently occupied by each computing node in the system (including processor clusters, peripheral terminals, edge computing nodes, etc.), reflecting the real-time pressure distribution of the system.

[0180] The terminal has pre-set data judgment conditions, which are a set of thresholds or logical rules regarding system health and user experience quality. For example, the peak signal-to-noise ratio (PSNR) needs to be maintained above a certain lower limit to ensure image quality, frame latency needs to be below a certain upper limit to ensure smoothness, and the load rate of computing nodes needs to be controlled within a certain range to avoid overload. The system continuously compares the real-time collected indicators with these conditions. When the PNR, frame latency, or load rate does not meet the pre-set data judgment conditions, for example, a sudden drop in PNR indicating significant image distortion, a sudden increase in frame latency causing operational lag, or an abnormally high load rate of a computing node, the monitoring module determines that the data is abnormal.

[0181] Once an anomaly is confirmed, the target terminal immediately initiates a feedback mechanism, transmitting abnormal data and anomaly types in peak signal-to-noise ratio, frame latency, or load rate to the server. Abnormal data refers to specific values ​​exceeding the normal range, while the anomaly type is a classification identifier for the corresponding problem, such as frame latency exceeding limits or processor cluster overload. This information constitutes a concise yet crucial diagnostic report.

[0182] Upon receiving feedback, the server doesn't merely make minor adjustments; it can re-execute the rendering process based on the abnormal data. This means the server can dynamically adjust its internal strategies based on feedback information. For example, if frame latency is too high, the server might prioritize edge nodes with lower latency but slightly lower computing power in subsequent scheduling; if the peak signal-to-noise ratio decreases, it might adjust the compression ratio in tensor fusion or enable a more aggressive detail recovery mode in generative adversarial networks; if the load rate of a certain type of computing node remains too high, it will reallocate tasks using a mixed-integer programming model, migrating some of the computing load to other idle nodes. This process enables the entire system to dynamically adapt and continuously optimize, forming a complete closed loop from terminal monitoring to cloud decision-making and back to rendering execution. This ensures that high-quality rendering output and a smooth user experience are maintained even when facing uncertainties such as network fluctuations and changes in computing load.

[0183] Figure 2 This is a flowchart illustrating a method for accelerating rendering provided in an embodiment of the present disclosure.

[0184] like Figure 2 As shown, this method is applied to Figure 1 The target terminal of the rendering acceleration system includes the following steps: Step 201: The collected touch trajectory data and gyroscope data are processed by quantum state compression encoding to generate a quantum state sequence.

[0185] Step 202: Transmit the quantum state sequence to the server so that the server can execute the rendering process based on the quantum state sequence.

[0186] For details on the specific implementation process of the embodiments of this disclosure, please refer to the detailed description in the above-described rendering acceleration system, and therefore will not be repeated here.

[0187] Figure 3 This is a flowchart illustrating a method for accelerating rendering provided in an embodiment of the present disclosure.

[0188] like Figure 3 As shown, this method is applied to Figure 1 The server-side of the rendering acceleration system includes the following steps: Step 301: The quantum state sequence from the target terminal is divided into blocks to obtain multiple blocks of data. The multiple blocks of data are then classified by calculating quantum gradient features to generate block label matrices corresponding to each block of data.

[0189] Step 302: Based on the block tag matrix and resource pool status, allocate multiple block data to their respective computing nodes and / or target terminals so that the computing nodes and target terminals can perform rendering calculations on their respective block data to obtain pixel coloring results.

[0190] Step 303: Receive the pixel coloring results returned by the computing node and / or the target terminal, construct a multi-level feature tensor based on the pixel coloring results, and compress the multi-level feature tensor to obtain the fused rendering result.

[0191] Step 304: Perform motion-aware interpolation on the fused rendering result to generate a smooth transition frame, and encode the smooth transition frame and the fused rendering result to obtain the target image.

[0192] For details on the specific implementation process of the embodiments of this disclosure, please refer to the detailed description in the above-described rendering acceleration system, and therefore will not be repeated here.

[0193] Figure 4 This is a flowchart illustrating a method for accelerating rendering provided in an embodiment of the present disclosure.

[0194] like Figure 4 As shown, this method is applied to Figure 1 The computation nodes of the rendering acceleration system include the following steps: Step 401: Receive block data of different data categories allocated by the server, and perform rendering calculations on the block data according to the rendering nodes corresponding to the data categories to obtain pixel coloring results. The calculation nodes include multiple rendering nodes.

[0195] Step 402: Send the pixel coloring results to the server.

[0196] For details on the specific implementation process of the embodiments of this disclosure, please refer to the detailed description in the above-described rendering acceleration system, and therefore will not be repeated here.

[0197] According to embodiments of this disclosure, this disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0198] Figure 5A schematic block diagram of an example electronic device 500 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0199] like Figure 5 As shown, device 500 includes a computing unit 501, which can perform various appropriate actions and processes based on a computer program stored in ROM (Read-Only Memory) 502 or loaded from storage unit 508 into RAM (Random Access Memory) 503. RAM 503 may also store various programs and data required for the operation of device 500. The computing unit 501, ROM 502, and RAM 503 are interconnected via bus 504. I / O (Input / Output) interface 505 is also connected to bus 504.

[0200] Multiple components in device 500 are connected to I / O interface 505, including: input unit 506, such as keyboard, mouse, etc.; output unit 507, such as various types of monitors, speakers, etc.; storage unit 508, such as disk, optical disk, etc.; and communication unit 509, such as network card, modem, wireless transceiver, etc. Communication unit 509 allows device 500 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0201] The computing unit 501 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 501 include, but are not limited to, CPUs (Central Processing Units), GPUs (Graphics Processing Units), various special-purpose AI (Artificial Intelligence) computing chips, various computing units running machine learning model algorithms, DSPs (Digital Signal Processors), and any suitable processor, controller, microcontroller, etc. The computing unit 501 performs the various methods and processes described above, such as rendering acceleration methods. For example, in some embodiments, the rendering acceleration method may be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 508. In some embodiments, part or all of the computer program may be loaded and / or installed on device 500 via ROM 502 and / or communication unit 509. When the computer program is loaded into RAM 503 and executed by the computing unit 501, one or more steps of the methods described above may be performed. Alternatively, in other embodiments, computing unit 501 may be configured to perform the aforementioned rendering acceleration method by any other suitable means (e.g., by means of firmware).

[0202] Various implementations of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, FPGAs (Field Programmable Gate Arrays), ASICs (Application-Specific Integrated Circuits), ASSPs (Application-Specific Standard Products), SOCs (System-on-Chips), CPLDs (Complex Programmable Logic Devices), computer hardware, firmware, software, and / or combinations thereof. These various implementations may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0203] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0204] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, RAM, ROM, EPROM (Electrically Programmable Read-Only Memory) or flash memory, optical fiber, CD-ROM (Compact Disc Read-Only Memory), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0205] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (Cathode-Ray Tube) or LCD (Liquid Crystal Display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0206] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as data servers), or computing systems that include middleware components (e.g., application servers), or computing systems that include frontend components (e.g., user computers with graphical user interfaces or web browsers through which users can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., communication networks). Examples of communication networks include LANs (Local Area Networks), WANs (Wide Area Networks), the Internet, and blockchain networks.

[0207] Computer systems can include clients and servers. Clients and servers are generally geographically separated and typically interact via communication networks. The client-server relationship is created by computer programs running on the respective computers and having a client-server relationship with each other. A server can be a cloud server, also known as a cloud computing server or cloud host, a hosting product within the cloud computing service system that addresses the shortcomings of traditional physical hosts and VPS (Virtual Private Server) services, such as high management difficulty and weak business scalability. Servers can also be servers for distributed systems or servers incorporating blockchain technology.

[0208] It's important to note that artificial intelligence (AI) is the study of enabling computers to simulate certain human thought processes and intelligent behaviors (such as learning, reasoning, thinking, and planning). It encompasses both hardware and software technologies. AI hardware technologies generally include sensors, dedicated AI chips, cloud computing, distributed storage, and big data processing. AI software technologies primarily include computer vision, speech recognition, natural language processing, machine learning / deep learning, big data processing, and knowledge graph technologies.

[0209] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0210] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A rendering acceleration system, characterized in that, include: The target terminal, the server, and at least one computing node. The target terminal is configured to generate a quantum state sequence by processing the collected touch trajectory data and gyroscope data through quantum state compression encoding, and then transmit the quantum state sequence to the server. The server is configured to perform block processing on the quantum state sequence to obtain multiple block data, and classify the multiple block data by calculating quantum gradient features to generate a block label matrix corresponding to each of the multiple block data. The server is further configured to allocate the multiple block data to their respective computing nodes and / or target terminals based on the block tag matrix and resource pool status. The computing node and the target terminal are also configured to perform rendering calculations on their respective block data to obtain pixel coloring results. The server is also configured to construct a multi-level feature tensor based on the pixel coloring result, and to compress the multi-level feature tensor to obtain a fused rendering result; The server is also configured to perform motion-aware interpolation on the fused rendering result to generate a smooth transition frame, and encode the smooth transition frame and the fused rendering result to obtain the target image.

2. The rendering acceleration system according to claim 1, characterized in that, The target terminal is specifically configured as follows: The touch trajectory data is normalized to a coordinate system and then combined with the touch coordinates, the filtered coordinates from the previous moment, and the filtered coordinates from the previous two moments in the touch trajectory data to perform smoothing filtering to obtain preprocessed touch data. The device attitude parameters, including the unit vector of the rotation axis and the rotation angle, are obtained by solving the gyroscope data based on the quaternion algorithm. The preprocessed touch data is encoded into a touch quantum superposition state, which is a superposition of the basic quantum state and the quantum state after touch coordinate phase adjustment; A first matrix is ​​constructed based on the device attitude parameters, and the first matrix is ​​mapped to an attitude quantum superposition state, wherein the attitude quantum superposition state is a superposition of the basic quantum state and the quantum state after phase adjustment by the first matrix; Using the touch quantum superposition state and the attitude quantum superposition state as input quantum states, the gradient descent method is used to compress the input quantum states to obtain the quantum state sequence.

3. The rendering acceleration system according to claim 2, characterized in that, The target terminal is further configured as follows: Data calculations are performed based on the complex matrix corresponding to the input quantum state, the conjugate transpose of the complex matrix, and the input quantum state to obtain a first calculation result; The first calculation result is compared with the input quantum state to obtain a first difference. The input quantum state is then compressed with the goal of minimizing the first difference to obtain the quantum state sequence.

4. The rendering acceleration system according to claim 1, characterized in that, The server is specifically configured as follows: The quantum state sequence is decomposed into a one-dimensional quantum state array, and the one-dimensional quantum state array is mapped into a two-dimensional quantum state matrix. The two-dimensional quantum state matrix is ​​then divided into blocks in the first dimension to obtain multiple initial block data. The multiple initial data blocks are processed by non-overlapping sub-blocking in the second dimension to obtain the multiple data blocks. If the resolution of the two-dimensional quantum state matrix is ​​not an integer multiple of the second dimension, the missing positions of the data blocks are filled with zero quantum states.

5. The rendering acceleration system according to claim 4, characterized in that, The server is further configured as follows: A quantum gate with trainable parameters is applied to the multiple data blocks to calculate the quantum observables corresponding to each of the multiple data blocks. The partial derivatives of each quantum observable with respect to the trainable parameters are calculated based on the preset parameter shift algorithm, and the quantum gradient feature vectors corresponding to each of the multiple data blocks are obtained based on the partial derivatives. The quantum gradient feature vector is reduced in dimension by using a preset principal component analysis algorithm to obtain a dimension-reduced feature vector. After linearly combining the dimension-reduced feature vectors, the classification probability of each of the multiple data blocks is obtained by probability calculation. The classification probability is used to determine the probability that the multiple data blocks belong to the dynamic entity class, the high light reflection class, the precise structure class, and the static background class. The data category to which each of the multiple data blocks belongs is determined based on the classification probability, and the category label corresponding to the data category is mapped back to the corresponding data block position in the two-dimensional quantum state matrix to obtain the block label matrix.

6. The rendering acceleration system according to claim 5, characterized in that, The server is further configured as follows: Collect the node type, total computing power, current load rate and quantum processing power of each of the at least one computing node to form the resource pool status corresponding to each of the at least one computing node, wherein the at least one computing node includes processor clusters, peripheral terminals and edge computing nodes; Construct a label matrix, wherein the label matrix records the category, resource requirement, and maximum allowed processing latency of each computing node; Based on preset constraints, the resource pool status, and the tag matrix, mixed integer planning and scheduling are performed to obtain task allocation results. The preset constraints include at least an objective function for minimizing the weighted sum of total processing latency and load imbalance, and the resource capacity of the computing node. Based on the task allocation results, the block data of the dynamic entity class is allocated to the processor cluster, the block data of the specular reflection class is allocated to the peripheral terminal, the block data of the precision structure class is allocated to the edge computing node, and the block data of the static background class is allocated to the target terminal.

7. The rendering acceleration system according to claim 6, characterized in that, The processor cluster is configured as follows: Quantum state decoding is performed on the block data of the dynamic entity class to obtain the touch trajectory decoding vector, posture mapping parameters, bone driving parameters and material reflectivity parameters. The touch trajectory decoding vector, posture mapping parameters, bone driving parameters and material reflectivity parameters are then processed to obtain a geometric parameter set. The diffuse and specular reflection terms are calculated based on the geometric parameter set, and the rendering is performed by combining the diffuse and specular reflection terms with ambient light intensity and ambient light occlusion compensation to obtain a dynamic entity rendering result. The pixel shading result includes at least the dynamic entity rendering result. In response to the fact that the segmented data of the dynamic entity class is the first type of game data, the edge computing node and the target terminal work together to calculate the initial velocity of the ballistic trajectory, the local environmental force and the impact coordinates based on the segmented data of the dynamic entity class, and supplement the rendering result of the dynamic entity.

8. The rendering acceleration system according to claim 6, characterized in that, The peripheral terminal is configured as follows: Quantum state decoding is performed on the block data of the high-reflectivity class to obtain the touch trajectory decoding vector and attitude mapping parameters; The reflection intensity coefficient and hue shift coefficient are calculated based on the touch trajectory decoding vector and the posture mapping parameters. Specular reflection rendering is then performed based on the reflection intensity coefficient and the hue shift coefficient in conjunction with the ambient light intensity to obtain a specular reflection rendering result. The pixel shading result includes at least the specular reflection rendering result. In response to the fact that the block data of the specular reflection class is the second type of game data, the specular reflection rendering result is asynchronously transmitted to the processor cluster and the target terminal to enhance the rendering effect of other categories, wherein the other categories are data categories other than the specular reflection class.

9. The rendering acceleration system according to claim 6, characterized in that, The edge computing node is configured as follows: Quantum state decoding is performed on the block data of the precise structure class, and the hash value of the block data of the precise structure class is calculated. The hash value is compared with the preset template hash value to determine the template matching result. Calculate the detail scaling factor of the block data of the precision structure class, calculate the texture displacement vector and dynamic normal perturbation vector based on the detail scaling factor and the template matching result, and perform basic texture adjustment based on the texture displacement vector and the dynamic normal perturbation vector to obtain the precision structure rendering result, wherein the pixel shading result includes at least the precision structure rendering result. In response to the fact that the segmented data of the precision structure class is third-class game data, the entity acceleration parameters transmitted by the processor cluster are received, and the precision structure rendering result is subjected to momentum-aware texture blurring based on the entity acceleration parameters to obtain an enhanced precision structure rendering result.

10. The rendering acceleration system according to claim 6, characterized in that, The target terminal is also configured as follows: Quantum state decoding is performed on the block data of the static background class, and the quantum frequency domain projection vector and touch brightness correction coefficient are calculated; The static background rendering result is obtained by combining the quantum frequency domain projection vector and the touch brightness correction coefficient with the screen coordinates and cloud gradient simulation algorithm. The pixel coloring result includes at least the static background rendering result.

11. The rendering acceleration system according to claim 6, characterized in that, The server is further configured as follows: The pixel coloring results fed back by each computing node and / or the target terminal are uniformly transformed to the world coordinate system through a preset affine transformation algorithm and a preset transformation method to obtain the transformed pixel coloring results. The preset transformation method includes at least minimizing the coordinate error of multiple coordinate points corresponding to the pixel coloring results. Based on the converted pixel coloring results, the multi-order feature tensor is constructed. The dimensions of the multi-order feature tensor include at least the image resolution dimension, the feature channel dimension, and the time frame sequence dimension. The feature channel dimension includes at least the channel of the dynamic entity class, the channel of the specular reflection class, the channel of the precision structure class, and the channel of the static background class. The multi-order feature tensor is decomposed into a kernel tensor and a multimodal factor matrix using a preset singular value decomposition algorithm. The kernel tensor and the multimodal factor matrix are then input into a preset conditional generative adversarial network for data fusion processing to obtain the fused rendering result. The preset conditional generative adversarial network is used at least to fill in the high-frequency details lost during compression by learning high-frequency texture and lighting features.

12. The rendering acceleration system according to claim 6, characterized in that, The server is further configured as follows: The fused rendering result is split into consecutive previous and next frame images according to the time series, and the forward and reverse optical flow fields between the previous and next frame images are calculated. By removing unreliable optical flow vectors whose vector magnitude exceeds a preset flow field threshold from the forward and reverse optical flow fields, an optimized bidirectional optical flow field is obtained. The optimized bidirectional optical flow field and the depth maps of the previous frame image and the next frame image are input into a preset spatiotemporal prediction network for feature extraction to obtain a motion change matrix. Based on the motion change matrix and preset interpolation weights, adaptive weighted interpolation processing is performed to generate the smooth transition frame. The smooth transition frame and the fusion rendering result are integrated into an image sequence, and the image sequence is compressed using a preset high-efficiency video coding standard to obtain the target image, which is then streamed to the target terminal.

13. The rendering acceleration system according to claim 6, characterized in that, The target terminal is also configured as follows: According to the sampling period of the quantum state sequence, the peak signal-to-noise ratio, frame delay and load rate of each computing node of the target image stream are collected in real time. If the peak signal-to-noise ratio, frame latency, or load rate does not meet the preset data judgment conditions, it is determined that the data is abnormal, and the abnormal data and abnormal type in the peak signal-to-noise ratio, frame latency, or load rate are transmitted to the server so that the server can re-execute the rendering process based on the abnormal data.

14. A method for accelerating rendering, characterized in that, The method is applied to a target terminal of the rendering acceleration system as described in any one of claims 1-13, comprising: The collected touch trajectory data and gyroscope data are processed through quantum state compression encoding to generate quantum state sequences; The quantum state sequence is transmitted to the server so that the server can execute the rendering process based on the quantum state sequence.

15. The rendering acceleration method according to claim 14, characterized in that, The process of generating a quantum state sequence from the collected touch trajectory data and gyroscope data through quantum state compression encoding includes: The touch trajectory data is normalized to a coordinate system and then combined with the touch coordinates, the filtered coordinates from the previous moment, and the filtered coordinates from the previous two moments in the touch trajectory data to perform smoothing filtering to obtain preprocessed touch data. The device attitude parameters, including the unit vector of the rotation axis and the rotation angle, are obtained by solving the gyroscope data based on the quaternion algorithm. The preprocessed touch data is encoded into a touch quantum superposition state, which is a superposition of the basic quantum state and the quantum state after touch coordinate phase adjustment; A first matrix is ​​constructed based on the device attitude parameters, and the first matrix is ​​mapped to an attitude quantum superposition state, wherein the attitude quantum superposition state is a superposition of the basic quantum state and the quantum state after phase adjustment by the first matrix; Using the touch quantum superposition state and the attitude quantum superposition state as input quantum states, the gradient descent method is used to compress the input quantum states to obtain the quantum state sequence.

16. The rendering acceleration method according to claim 15, characterized in that, The step of using gradient descent to compress the input quantum state to obtain the quantum state sequence includes: Data calculations are performed based on the complex matrix corresponding to the input quantum state, the conjugate transpose of the complex matrix, and the input quantum state to obtain a first calculation result; The first calculation result is compared with the input quantum state to obtain a first difference. The input quantum state is then compressed with the goal of minimizing the first difference to obtain the quantum state sequence.

17. The rendering acceleration method according to claim 14, characterized in that, After transmitting the quantum state sequence to the server, the method further includes: Receive the block data of the static background class allocated by the server; Quantum state decoding is performed on the block data of the static background class, and the quantum frequency domain projection vector and touch brightness correction coefficient are calculated; The static background rendering result is obtained by combining the quantum frequency domain projection vector and the touch brightness correction coefficient with the screen coordinates and cloud gradient simulation algorithm, and then the static background rendering result is sent to the server.

18. A method for accelerating rendering, characterized in that, The method is applied to the server side of the rendering acceleration system as described in any one of claims 1-13, comprising: The quantum state sequence from the target terminal is divided into blocks to obtain multiple blocks of data. The multiple blocks of data are then classified by calculating quantum gradient features to generate a block label matrix corresponding to each of the multiple blocks of data. Based on the block tag matrix and resource pool status, the multiple block data are allocated to their respective computing nodes and / or the target terminal, so that the computing nodes and the target terminal can perform rendering calculations on their respective block data to obtain pixel coloring results. Receive the pixel coloring result returned by the computing node and / or the target terminal, construct a multi-order feature tensor based on the pixel coloring result, and compress the multi-order feature tensor to obtain the fused rendering result; Motion-aware interpolation is performed on the fused rendering result to generate a smooth transition frame. The smooth transition frame and the fused rendering result are then encoded to obtain the target image.

19. The rendering acceleration method according to claim 18, characterized in that, The process of dividing the quantum state sequence from the target terminal into blocks to obtain multiple data blocks includes: The quantum state sequence is decomposed into a one-dimensional quantum state array, and the one-dimensional quantum state array is mapped into a two-dimensional quantum state matrix. The two-dimensional quantum state matrix is ​​then divided into blocks in the first dimension to obtain multiple initial block data. The multiple initial data blocks are processed by non-overlapping sub-blocking in the second dimension to obtain the multiple data blocks. If the resolution of the two-dimensional quantum state matrix is ​​not an integer multiple of the second dimension, the missing positions of the data blocks are filled with zero quantum states.

20. The rendering acceleration method according to claim 19, characterized in that, The step of classifying the multiple data blocks by calculating quantum gradient features and generating a block label matrix corresponding to each of the multiple data blocks includes: A quantum gate with trainable parameters is applied to the multiple data blocks to calculate the quantum observables corresponding to each of the multiple data blocks. The partial derivatives of each quantum observable with respect to the trainable parameters are calculated based on the preset parameter shift algorithm, and the quantum gradient feature vectors corresponding to each of the multiple data blocks are obtained based on the partial derivatives. The quantum gradient feature vector is reduced in dimension by using a preset principal component analysis algorithm to obtain a dimension-reduced feature vector. After linearly combining the dimension-reduced feature vectors, the classification probability of each of the multiple data blocks is obtained by probability calculation. The classification probability is used to determine the probability that the multiple data blocks belong to the dynamic entity class, the high light reflection class, the precise structure class, and the static background class. The data category to which each of the multiple data blocks belongs is determined based on the classification probability, and the category label corresponding to the data category is mapped back to the corresponding data block position in the two-dimensional quantum state matrix to obtain the block label matrix.

21. The rendering acceleration method according to claim 20, characterized in that, The step of allocating the multiple data blocks to their respective computing nodes and / or the target terminal based on the block tag matrix and resource pool status includes: The node type, total computing power, current load rate and quantum processing power of each computing node are collected to form the resource pool status corresponding to each computing node. The computing nodes include processor clusters, peripheral terminals and edge computing nodes. Construct a label matrix, wherein the label matrix records the category, resource requirement, and maximum allowed processing latency of each computing node; Based on preset constraints, the resource pool status, and the tag matrix, mixed integer planning and scheduling are performed to obtain task allocation results. The preset constraints include at least an objective function for minimizing the weighted sum of total processing latency and load imbalance, and the resource capacity of the computing node. Based on the task allocation results, the block data of the dynamic entity class is allocated to the processor cluster, the block data of the specular reflection class is allocated to the peripheral terminal, the block data of the precision structure class is allocated to the edge computing node, and the block data of the static background class is allocated to the target terminal.

22. The rendering acceleration method according to claim 21, characterized in that, The step of constructing a multi-level feature tensor based on the pixel coloring result and compressing the multi-level feature tensor to obtain the fused rendering result includes: The pixel coloring results fed back by each computing node and / or the target terminal are uniformly transformed to the world coordinate system through a preset affine transformation algorithm and a preset transformation method to obtain the transformed pixel coloring results. The preset transformation method includes at least minimizing the coordinate error of multiple coordinate points corresponding to the pixel coloring results. Based on the converted pixel coloring results, the multi-order feature tensor is constructed. The dimensions of the multi-order feature tensor include at least the image resolution dimension, the feature channel dimension, and the time frame sequence dimension. The feature channel dimension includes at least the channel of the dynamic entity class, the channel of the specular reflection class, the channel of the precision structure class, and the channel of the static background class. The multi-order feature tensor is decomposed into a kernel tensor and a multimodal factor matrix using a preset singular value decomposition algorithm. The kernel tensor and the multimodal factor matrix are then input into a preset conditional generative adversarial network for data fusion processing to obtain the fused rendering result. The preset conditional generative adversarial network is used at least to fill in the high-frequency details lost during compression by learning high-frequency texture and lighting features.

23. The rendering acceleration method according to claim 18, characterized in that, The step of performing motion-aware interpolation on the fused rendering result to generate a smooth transition frame, and encoding the smooth transition frame and the fused rendering result to obtain the target image includes: The fused rendering result is split into consecutive previous and next frame images according to the time series, and the forward and reverse optical flow fields between the previous and next frame images are calculated. By removing unreliable optical flow vectors whose vector magnitude exceeds a preset flow field threshold from the forward and reverse optical flow fields, an optimized bidirectional optical flow field is obtained. The optimized bidirectional optical flow field and the depth maps of the previous frame image and the next frame image are input into a preset spatiotemporal prediction network for feature extraction to obtain a motion change matrix. Based on the motion change matrix and preset interpolation weights, adaptive weighted interpolation processing is performed to generate the smooth transition frame. The smooth transition frame and the fusion rendering result are integrated into an image sequence, and the image sequence is compressed using a preset high-efficiency video coding standard to obtain the target image, which is then streamed to the target terminal.

24. A method for accelerating rendering, characterized in that, The method is applied to a computing node of the rendering acceleration system as described in any one of claims 1-13, comprising: The system receives block data of different data categories allocated by the server, and performs rendering calculations on the block data according to the rendering nodes corresponding to the data categories to obtain pixel coloring results. The calculation nodes include multiple rendering nodes. The pixel coloring result is sent to the server.

25. The rendering acceleration method according to claim 24, characterized in that, The step of rendering the block data according to the rendering node corresponding to the data category to obtain the pixel coloring result includes: In response to the fact that the data category of the segmented data is a dynamic entity class, the segmented data of the dynamic entity class is rendered and calculated through the processor cluster; The rendering calculation of the segmented data of the dynamic entity class through the processor cluster includes: Quantum state decoding is performed on the block data of dynamic entity class to obtain touch trajectory decoding vector, posture mapping parameters, bone driving parameters and material reflectivity parameters. The touch trajectory decoding vector, posture mapping parameters, bone driving parameters and material reflectivity parameters are then processed to obtain a geometric parameter set. The diffuse and specular reflection terms are calculated based on the geometric parameter set, and the rendering is performed by combining the diffuse and specular reflection terms with ambient light intensity and ambient light occlusion compensation to obtain a dynamic entity rendering result. The pixel shading result includes at least the dynamic entity rendering result. In response to the fact that the segmented data of the dynamic entity class is the first type of game data, the edge computing node and the target terminal work together to calculate the initial velocity of the ballistic trajectory, the local environmental force and the impact coordinates based on the segmented data of the dynamic entity class, and supplement the rendering result of the dynamic entity.

26. The rendering acceleration method according to claim 25, characterized in that, The step of rendering the block data according to the rendering node corresponding to the data category to obtain the pixel coloring result includes: In response to the fact that the data category of the segmented data is specular reflection, the peripheral terminal performs rendering calculations on the segmented data of specular reflection. The rendering calculation of the segmented data of the specular reflection class through the peripheral terminal includes: Quantum state decoding is performed on the block data of the high-reflectivity class to obtain the touch trajectory decoding vector and attitude mapping parameters; The reflection intensity coefficient and hue shift coefficient are calculated based on the touch trajectory decoding vector and the posture mapping parameters. Specular reflection rendering is then performed based on the reflection intensity coefficient and the hue shift coefficient in conjunction with the ambient light intensity to obtain a specular reflection rendering result. The pixel shading result includes at least the specular reflection rendering result. In response to the fact that the block data of the specular reflection class is the second type of game data, the specular reflection rendering result is asynchronously transmitted to the processor cluster and the target terminal to enhance the rendering effect of other categories, wherein the other categories are data categories other than the specular reflection class.

27. The rendering acceleration method according to claim 25, characterized in that, The step of rendering the block data according to the rendering node corresponding to the data category to obtain the pixel coloring result includes: In response to the fact that the data category of the segmented data is a precision structure class, the edge computing node performs rendering calculations on the segmented data of the precision structure class. The rendering calculation of the segmented data of the precise structure class through the edge computing node includes: Quantum state decoding is performed on the block data of the precise structure class, and the hash value of the block data of the precise structure class is calculated. The hash value is compared with the preset template hash value to determine the template matching result. Calculate the detail scaling factor of the block data of the precision structure class, calculate the texture displacement vector and dynamic normal perturbation vector based on the detail scaling factor and the template matching result, and perform basic texture adjustment based on the texture displacement vector and the dynamic normal perturbation vector to obtain the precision structure rendering result, wherein the pixel shading result includes at least the precision structure rendering result. In response to the fact that the segmented data of the precision structure class is third-class game data, the entity acceleration parameters transmitted by the processor cluster are received, and the precision structure rendering result is subjected to momentum-aware texture blurring based on the entity acceleration parameters to obtain an enhanced precision structure rendering result.

28. An electronic device, 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 executable by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform the method of any one of claims 14-17, any one of claims 18-23, or any one of claims 24-27.

Images