Real-time visual rendering method and system of API-driven pre-made UI

Abstract

The application belongs to the technical field of computers, and discloses a real-time visual rendering method and system of API-driven prefabricated UI, and aims to solve the technical problem of significant delay of visual feedback in the existing somatosensory interaction system. The method comprises the following steps: establishing a prefabricated UI resource library, storing a plurality of preset visual element samples and visual attribute information of the preset visual element samples which are pre-rendered and calculated according to target layout styles and aesthetic styles; obtaining user action data and generating a semantic request; sending the semantic request to a decision module to match a corresponding target visual identifier; calling the visual attribute information of the prefabricated UI resource, and directly mapping the visual attribute information into visual output through a local rendering engine. The system comprises a prefabricated UI resource library module, an action data acquisition module, a semantic request generation module, a decision matching module, a local rendering module and a visual output module. According to the application, the visual attribute information is pre-rendered and calculated and stored by adopting an API-driven prefabricated UI combination architecture scheme, and the visual attribute information is directly called and mapped into output, so that the style calculation and layout operation required in the mapping of natural language description into visual elements are avoided, the generation time of visual feedback is greatly shortened, the immersion and fluency of somatosensory interaction are effectively ensured, and technical support is provided for instant visual feedback in a psychological intervention scene.

Description

Technical Field

[0001] This invention belongs to the field of computer technology, specifically relating to a real-time visual rendering method and system for API-driven pre-built UI. Background Technology

[0002] Motion-sensing interaction technology, by capturing users' body movements and converting them into input for digital systems, has been widely applied in fields such as gaming, sports training, and psychological intervention. Among these, skeletal tracking-based interaction methods are widely used because they can accurately capture the positional information of human joints and generate corresponding visual or auditory feedback. In psychological intervention scenarios, motion-sensing interaction can bypass the cognitive processing path of language and achieve "bottom-up" emotion regulation through direct participation of body movements, providing a new technological means to alleviate anxiety and enhance self-efficacy.

[0003] Specifically, current motion-sensing interaction systems primarily employ two implementation paths for their visual feedback modules: one relies entirely on local computing power for real-time rendering, and the other uploads user action data to the cloud for processing by an AI model, which then returns corresponding visual commands. In the latter architecture, to achieve rich and diverse visual presentations, the system typically needs to utilize the semantic understanding capabilities of a cloud-based large language model. This model generates descriptive visual suggestions based on the user's action characteristics, which are then transformed into specific visual elements by the local rendering engine. However, this approach suffers from a critical bottleneck: when visual suggestions involve high-quality typography, complex visual compositions, or specific aesthetic styles (such as the strokes and ink density in Chinese calligraphy), the generation of visual feedback is often significantly delayed due to the time-consuming data transmission between the cloud and local systems, as well as the time-consuming parsing of complex visual commands by the local rendering engine. This results in the time interval between user actions and visual feedback exceeding the perceptual threshold of motion-sensing interaction.

[0004] The root cause of this latency issue lies in the fact that the output of the cloud-based large language model is natural language description. The mapping process from natural language description to specific visual elements requires a large amount of style calculation and layout computation, which is difficult to complete within milliseconds. The existence of latency not only disrupts the immersiveness and smoothness of haptic interaction, but more importantly, when this technology is applied to psychological intervention scenarios, the immediacy of visual feedback directly affects the effectiveness of the "defamiliarization" strategy. If visual feedback is delayed, the user's attention will be forced to switch between action and feedback, making it difficult to achieve a mind-body unity experience in a "suspended" state. Summary of the Invention

[0005] The purpose of this invention is to provide a real-time visual rendering method and system for API-driven pre-built UI, which can effectively solve the problems in the background art mentioned above.

[0006] To achieve the above objectives, the technical solution adopted by the present invention is as follows: a real-time visual rendering method for API-driven pre-built UI, comprising the following specific steps: S1: Establish a pre-made UI resource library, which stores multiple preset visual element samples. Each preset visual element sample contains a visual identifier and corresponding visual attribute information. The visual attribute information is pre-rendered, calculated, and stored according to the target layout style and target aesthetic style. S2: Acquire user action data and generate a corresponding semantic request based on the user action data; the user action data is collected through a motion-sensing interaction device; S3: The semantic request is sent to the decision module, which then matches the corresponding target visual identifier from the pre-made UI resource library based on the semantic request; S4: Call the visual attribute information of the prefabricated UI resource corresponding to the target visual identifier, and directly map the visual attribute information into visual output through the local rendering engine without performing style calculation and layout calculation; S5: Output the visualization implementation.

[0007] Compared with the prior art, the present invention has the following beneficial effects: This invention employs an API-driven pre-built UI architecture. It establishes a pre-built UI resource library containing samples of preset visual elements and pre-calculates and stores visual attribute information according to the target layout and aesthetic style. When a user's action triggers a semantic request, the system directly matches the corresponding target visual identifier from the pre-built UI resource library, calls the pre-stored visual attribute information, and maps the visual attribute information directly to the visual output through the local rendering engine. This approach avoids the extensive style calculations and layout operations required in existing technologies to map natural language descriptions to specific visual elements. It significantly reduces the generation time of visual feedback to within a preset time threshold, effectively solving the technical latency and poor rendering issues of cloud-based large language models in high-quality visual layout display. This ensures the immersiveness and smoothness of haptic interaction and provides immediate visual feedback for implementing "defamiliarization" strategies in psychological intervention scenarios.

[0008] Preferably, the multiple preset visual element samples in the pre-made UI resource library include at least one of calligraphy stroke elements, ink wash elements, imagery graphic elements, and ink wash blank space elements; the calligraphy stroke elements are rendered by pre-simulating the stroke trends of Chinese calligraphy; the ink wash elements are rendered by pre-simulating the diffusion effect of ink on rice paper.

[0009] Preferably, the acquisition of user motion data in step S2 includes collecting the user's human joint position information through a skeletal tracking device, and extracting multidimensional skeletal features based on the human joint position information; the multidimensional skeletal features include at least one of displacement progress, movement speed, movement intensity, and pause duration.

[0010] Preferably, the decision module in step S3 is a cloud-based large language model, and the semantic request includes a dimensionality-reduced semantic package generated based on the multidimensional skeletal features; the decision module matches the corresponding target visual identifier from the pre-made UI resource library based on the dimensionality-reduced semantic package, and returns the matched target visual identifier to the local system.

[0011] Preferably, the local rendering engine in step S4 is the UI rendering subsystem of the game engine. The UI rendering subsystem of the game engine directly reads the visual attribute information of the pre-made UI resources and performs visualization output without additional parsing processing.

[0012] Preferably, the visual attribute information in step S4 includes at least one of vertex coordinate data, texture coordinate data, shader parameter data, and hierarchy order data; the visual attribute information is stored in a structured data format and can be directly accessed by the local rendering engine.

[0013] Preferably, the method also includes an update step for the prefabricated UI resource library: periodically receiving new visual element style suggestions generated by a cloud-based large language model, converting the new visual element style suggestions into corresponding visual attribute information, and updating them to the prefabricated UI resource library.

[0014] Preferably, the pre-made UI resource library in step S1 uses a hash table as the index structure, visual identifiers as keys, and visual attribute information as mapping values, supporting fast lookup with constant-level time complexity.

[0015] A second aspect of the present invention also proposes a real-time visual rendering system for API-driven pre-built UI.

[0016] According to a second aspect of the present invention, an API-driven real-time visual rendering system for prefabricated UI includes: The pre-made UI resource library module is used to store multiple preset visual element samples. Each preset visual element sample contains a visual identifier and corresponding visual attribute information. The visual attribute information is pre-rendered, calculated, and stored according to the target layout style and target aesthetic style. The motion data acquisition module is used to acquire user motion data; the user motion data is acquired through a motion-sensing interaction device. The semantic request generation module is used to generate corresponding semantic requests based on the user action data. The decision matching module is used to send the semantic request to the decision module, which then matches the corresponding target visual identifier from the pre-made UI resource library based on the semantic request. The local rendering module is used to call the visual attribute information of the prefabricated UI resources corresponding to the target visual identifier, and directly map the visual attribute information into the visual output through the local rendering engine, without the need for style calculation and layout calculation; The visualization output module is used to output the visualization implementation.

[0017] Since the API-driven pre-built UI real-time visual rendering system of the second aspect of the present invention utilizes the API-driven pre-built UI real-time visual rendering method of the first aspect of the present invention, the API-driven pre-built UI real-time visual rendering system of the second aspect of the present invention has essentially the same technical effects as the API-driven pre-built UI real-time visual rendering method of the first aspect of the present invention, and will not be described again here. Attached Figure Description

[0018] Figure 1 This is a schematic diagram of the overall technical solution architecture of the API-driven real-time visual rendering method for prefabricated UI proposed in this invention. Figure 2 This is a schematic diagram illustrating the core principle framework of the pre-rendering storage and fast search mechanism of the pre-made UI resource library in this invention; Figure 3 This is a flowchart illustrating the main process framework of this invention, from user action data collection to semantic request generation and then to visualization output. Figure 4 This is a schematic diagram of the multi-level interaction relationship and data flow between the cloud decision-making module and the local rendering engine in this invention; Figure 5 This is a schematic diagram comparing the technical effects of the present invention and traditional style calculation and layout methods in terms of visual feedback generation time. Detailed Implementation

[0019] To further illustrate the technical means and effects of the present invention in achieving its intended purpose, the following detailed description of the specific implementation methods, structures, features, and effects of the present invention, in conjunction with the accompanying drawings and preferred embodiments, is provided below. Example 1

[0020] (System architecture construction) This embodiment addresses the application scenario of haptic interaction in psychological intervention, constructing an API-driven real-time visual rendering system with a pre-built UI. The core architecture of this system comprises six functional modules, which interact with each other through standardized interfaces, forming a complete signal processing chain and visual feedback loop.

[0021] The pre-built UI resource library module serves as the data hub of the entire system, responsible for storing and retrieving visual element samples. Its physical storage structure employs a hash table indexing mechanism, using visual identifiers as keys and pre-rendered, calculated visual attribute information as values. At the hardware implementation level, the pre-built UI resource library module can be deployed on the solid-state drive of a local computing device or configured in a low-latency memory cache area to ensure that subsequent query operations achieve constant-time complexity. The visual element samples stored within the pre-built UI resource library module fall into four main categories: calligraphy stroke elements, ink wash elements, imagery graphic elements, and ink wash white space elements. The visual attribute information of calligraphy stroke elements is pre-rendered and calculated based on the stroke trends of Chinese characters, including the coordinate data of the stroke's starting position, the curvature interpolation parameters of the stroke path, the shader parameters for varying stroke density, and the hierarchical order data of multiple layers. The visual attribute information of the ink wash effect is pre-simulated for rendering calculations based on the diffusion effect of ink on rice paper. This includes the vertex coordinates of the irregular polygons at the edge of the wash, the texture coordinate mapping parameters for the penetration depth, the RGBA channel parameters for the color gradient, and the blending mode parameters for transparency mixing. This visual attribute information is stored in a structured binary format, which can be directly read and parsed by the local rendering engine without additional unpacking or style conversion calculations.

[0022] The motion data acquisition module is responsible for acquiring the user's somatosensory motion data. This module achieves digital capture of user movements through a somatosensory interaction device. In this embodiment, the somatosensory interaction device adopts a skeletal tracking scheme based on a depth camera, which integrates three core hardware components: an infrared projector, a depth sensor, and an RGB camera. The infrared projector emits an encoded infrared pattern into the shooting area, and the depth sensor receives the reflected light and calculates the depth information of each pixel. The RGB camera simultaneously acquires visible light images to assist in recognizing the human body contour. The embedded processor built into the skeletal tracking device runs a skeletal tracking algorithm, which segments the body parts from the depth image to determine the human body's position in three-dimensional space and the coordinates of 23 major skeletal joints. The coordinate data of each joint includes components in three directions: x-axis, y-axis, and z-axis, with an update frequency of up to 30 frames per second.

[0023] The multidimensional skeletal feature extraction module processes the joint position information output by the skeletal tracking device to extract multidimensional feature vectors related to the user's motion state. This module is typically integrated into the core processor of the local computing device, employing a parallel computing architecture to meet real-time requirements. The feature dimensions calculated by the multidimensional skeletal feature extraction module include four categories: displacement progress features, motion speed features, action intensity features, and stagnation duration features. Displacement progress features are defined as the overall displacement amplitude of the user within a preset time period. They are calculated by weighted summation of the magnitudes of all joint displacement vectors, with weights allocated based on the contribution of each joint to upper limb movement. Motion speed features are defined as the rate of change of the user's movement, obtained through joint position difference calculations between consecutive frames. Based on the interval distribution of speed values, the user's motion state can be divided into four levels: stationary, low speed, medium speed, and high speed. Action intensity features are defined as the intensity of the user's movement, obtained by calculating the standard deviation of the acceleration of all joints. This feature can effectively distinguish between two different motion modes: slight swaying and large-amplitude swinging. The stagnation duration feature is defined as the duration during which a user remains in a relatively still state. When the displacement of all joints is lower than the preset motion threshold, the system determines that the user is in a stagnation state and begins to accumulate time.

[0024] The semantic request generation module reduces the dimensionality of the high-dimensional feature vector output by the multi-dimensional skeletal feature extraction module to generate a semantic request data packet that can be understood by the cloud-based decision-making module. This module internally incorporates a feature compression neural network that accepts multi-dimensional feature vectors as input and outputs a low-dimensional semantic packet vector. The dimension of the semantic packet vector is typically controlled between 8 and 16 dimensions, with each dimension representing an abstract behavioral semantic label, such as "slowly raise the right hand," "swing the left upper limb dramatically," "lean forward," or "remain still." In this embodiment, the semantic request generation module also appends timestamp information and scene context identifiers to the semantic packet vector to enable the cloud-based decision-making module to perform context-aware matching decisions.

[0025] The cloud-based decision-making module, serving as the central hub for semantic understanding and policy matching in the entire system, runs a finely tuned large language model. Upon receiving a semantic request data packet, the large language model first decodes the semantic packet vector, restoring it to a behavior description in natural language form. Then, based on this behavior description, the large language model searches a predefined behavior-visual mapping policy library and selects the most suitable visual feedback policy for the current user state. Finally, the large language model converts the selected visual policy into a corresponding target visual identifier and returns it to the local system via an API interface. The execution process of the cloud-based decision-making module typically consumes 200 to 500 milliseconds of computation time; this time delay is precisely the core technical problem that this invention aims to solve.

[0026] The local rendering module is the core innovation of this invention. This module achieves millisecond-level visual feedback output through rapid lookup of a pre-built UI resource library and direct mapping of visual attribute information. The local rendering module integrates the game engine's UI rendering subsystem, which has the ability to directly read structured visual attribute data without requiring style parsing or layout calculations. When the target visual identifier returns to the local system from the cloud, the local rendering module first uses this identifier as a key to perform a hash lookup in the pre-built UI resource library, with an average time complexity of O(1). After a successful lookup, the local rendering module obtains the visual attribute information data packet corresponding to the identifier and directly transmits this data packet to the rendering pipeline of the game engine's UI rendering subsystem. The rendering pipeline generates the final visual image according to the vertex coordinate data, texture coordinate data, shader parameters, and hierarchy order data contained in the visual attribute information, following a preset rendering process.

[0027] The visualization output module is responsible for presenting the rendered image to the user. This module can connect to indoor display screens, projectors, or VR headsets. The visualization output module has a built-in frame buffer manager and display controller. The frame buffer uses a double-buffered structure to avoid screen tearing, and the display controller is responsible for outputting the rendered image according to the interface protocol of the target display device.

[0028] (Workflow demonstration) The workflow of this embodiment unfolds sequentially in time and is divided into the following five stages.

[0029] The first phase is the system initialization phase. Upon startup, the system first loads the pre-built UI resource library, reading visual element sample data from the solid-state drive or memory cache into the cache area of ​​the pre-built UI resource library module. The pre-built UI resource library uses a hash table as its index structure, and the hash function is designed based on the CRC32 checksum of the visual identifier string, enabling fast lookups with constant-time complexity. The initialization phase also calibrates the motion-sensing interaction device, prompting the user to stand within the effective shooting range of the depth camera and perform several standard poses to establish a baseline for the user's body model. The entire initialization phase takes approximately 2 to 3 seconds and occurs only once during system startup.

[0030] The second stage is the user motion data acquisition stage. The skeletal tracking device continuously acquires the user's joint position information at a sampling frequency of 30 frames per second. Each frame contains the three-dimensional coordinates of 23 joints, with a total data volume of approximately 690 floating-point components per frame. The skeletal tracking device transmits the acquired data to the local computing device via USB interface or wireless LAN. The multidimensional skeletal feature extraction module synchronously receives this data and begins feature calculation. In this embodiment, the multidimensional skeletal feature extraction module adopts a sliding window mechanism with a window width set to 10 frames, meaning the minimum time unit for feature calculation is approximately 333 milliseconds. The multidimensional skeletal feature extraction module updates the feature statistics within the window each time a new frame of data arrives and outputs the multidimensional feature vector at the current moment.

[0031] The third stage is the semantic request generation stage. The feature vector output by the multi-dimensional skeletal feature extraction module is pushed to the semantic request generation module. The feature compression neural network inside the semantic request generation module performs dimensionality reduction processing on the feature vector, generating a 16-dimensional semantic packet vector. The semantic request generation module also attaches a scene context identifier to the semantic packet vector, indicating that the user is currently in a specific intervention stage within a psychological intervention scenario. The semantic request generation module sends the encapsulated semantic request data packet to the cloud decision-making module through an encrypted network channel. This network channel can be established using an HTTP RESTful API or WebSocket protocol. A typical request-response interaction takes approximately 300 to 600 milliseconds, including network transmission round-trip time and cloud model inference time.

[0032] The fourth stage is the target visual identifier matching stage. After receiving the semantic request data packet, the cloud decision module internally runs a large language model to perform semantic understanding and intent inference on the data packet. The large language model first decodes the semantic packet vector into a behavior description in natural language form, such as "the user is waving their right hand at a moderate speed, with a slight shift in their center of gravity." Subsequently, the large language model performs strategy matching in a predefined behavior-visual mapping strategy library based on this behavior description, selecting the visual feedback strategy that best matches the current user's movement state. In this embodiment, the behavior-visual mapping strategy library predefines the correspondence between more than 100 behavior types and visual elements, such as "waving the right hand vigorously" corresponding to "flying white calligraphy strokes," "slowly raising the hand" corresponding to "light ink wash elements," and "remaining still" corresponding to "ink wash white space elements." After selecting a visual strategy, the large language model encapsulates the corresponding target visual identifier into a JSON format response data packet and returns it to the local system through the same network channel.

[0033] The fifth stage is the local rendering output stage. Upon receiving the target visual identifier, the local rendering module immediately performs a hash lookup in the corresponding pre-made UI resource library entry. Since the pre-made UI resource library uses a hash table index structure, the time complexity of the lookup operation is O(1), with typical lookup times in microseconds or even lower. The retrieved visual attribute information includes pre-rendered vertex coordinate data, texture coordinate data, shader parameters, and hierarchy order data. The local rendering module directly pushes this data into the rendering pipeline of the game engine's UI rendering subsystem, bypassing any intermediate steps of parsing natural language descriptions or performing style calculations. The game engine's UI rendering subsystem immediately generates the corresponding visual image based on the parameters in the visual attribute information. The execution time of this rendering process is typically between 5 and 15 milliseconds. The entire process from receiving the target visual identifier to completing the visual image output can be controlled within 20 milliseconds, achieving an order-of-magnitude performance improvement compared to the total time consumed by cloud transmission latency plus style calculation latency in existing technologies.

[0034] Finally, the visualization output module presents the rendered visual image to the user through a display device. Users can see visual feedback corresponding to their actions within milliseconds. This near-zero latency visual response ensures the immersiveness and smoothness of the haptic interaction, providing immediate visual feedback to guarantee the implementation of estrangement strategies in psychological intervention scenarios. Example 2

[0035] (System architecture construction) This embodiment provides an API-driven real-time visual rendering system architecture for advanced applications in psychological intervention scenarios. Building upon the aforementioned Embodiment 1, this architecture introduces a dynamic update mechanism for a pre-built UI resource library to adapt to changes in user preferences and iterative visual style requirements over long-term use.

[0036] In addition to storing basic calligraphy stroke elements, ink wash elements, imagery graphic elements, and ink wash white space elements, the system's pre-made UI resource library module also includes a style extension interface module. This module is responsible for establishing periodic connections with a remote cloud server and receiving style suggestions for new visual elements generated by a cloud-based large language model. Each time the cloud-based large language model completes a round of user behavior pattern analysis, it may generate several creative suggestions for new visual elements. These suggestions, in the form of natural language descriptions, are sent to the local system via an API interface. The style extension interface module forwards these natural language description suggestions to the local style conversion engine. The style conversion engine integrates an image generation model based on a diffusion model, which can generate corresponding visual element images based on the natural language descriptions. Simultaneously, the style conversion engine also calls the pre-rendering calculation module to extract vertex coordinates, bake textures, and configure shader parameters for the newly generated visual element images, transforming them into structured visual attribute information data. Finally, the new visual attribute information data is appended to the pre-made UI resource library through a hash table insertion operation, completing the incremental update of the pre-made UI resource library.

[0037] In this embodiment, the pre-built UI resource library is designed to support the storage of more than 5,000 independent visual element samples, which can meet the needs of long-term use. The pre-built UI resource library module is also configured with an LRU cache eviction policy, which automatically removes the least recently accessed entries to free up storage space when the storage capacity approaches the preset upper limit.

[0038] (Workflow demonstration) Based on the aforementioned Embodiment 1, the workflow of this system adds a step of dynamic updating of the resource library, as detailed below.

[0039] During the system's daily operation, the style extension interface module proactively initiates a connection request to the cloud server every 24 hours, requesting the latest user behavior analysis report and visual element style suggestions. Upon receiving this request, the cloud server aggregates and analyzes all user behavior data collected over the past 24 hours to identify the behavioral pattern preferences of the current user group. Based on the analysis results, the cloud-based large language model generates several new visual element style suggestions, such as "suggest adding more dynamic ink-wash flying white elements" or "suggest adding soft gradient imagery graphic elements."

[0040] After receiving these suggestions, the style extension interface module places them in a processing queue. The style conversion engine retrieves each suggestion sequentially from the queue and initiates the image generation model to create visual elements. The image generation model first generates a basic visual image based on the natural language description of the suggestion, and then calls the top-part extraction algorithm to obtain the contour vertex coordinates of key elements in the image. The pre-rendering calculation module further performs texture baking on these images to generate multi-level precision mipmap texture sets and writes the shader parameters into a predefined parameter template. The visual attribute information after the above processing is organized into a unified structured data format and stored in the prefabricated UI resource library module through hash table insertion operations, while updating the index structure of the hash table.

[0041] The introduction of this dynamic update mechanism enables the system to continuously learn and adapt to changes in user preferences, providing increasingly accurate visual feedback. Simultaneously, through pre-built UI combinations, newly added visual elements also inherit the rapid rendering advantages of this invention, without sacrificing response latency performance due to the expansion of visual styles. Example 3

[0042] (System architecture construction) This embodiment provides a distributed architecture API-driven real-time visual rendering system for prefabricated UIs for large-scale deployment scenarios. It can support multiple users to perform haptic interactions simultaneously and share visual resources from the prefabricated UI resource library.

[0043] The distributed system's architecture comprises a centralized resource management server and multiple edge computing nodes. The resource management server is responsible for maintaining a global index of pre-built UI resource libraries and coordinating resource allocation among the edge computing nodes. Each edge computing node is deployed at the network edge, close to the user, and is configured with a local pre-built UI resource library cache and a local rendering module.

[0044] When a new user connects to the system, their nearest edge computing node first checks if the required visual element exists in its local cache. If the cache is hit, the visual attribute information from the local cache is used directly for rendering output; if the cache is not hit, a resource request is sent to the resource management server. The resource management server retrieves the corresponding visual element from the global resource library and distributes it to the requesting node via a high-speed network. The distributed architecture used in this embodiment effectively reduces the load on the central server, while the edge caching strategy ensures that the visual feedback latency for each user remains within milliseconds.

[0045] The above three embodiments clearly demonstrate the specific technical implementation of the API-driven pre-built UI real-time visual rendering method and system of the present invention in practical applications, as well as its significant technical improvements over the prior art.

Claims

1. A real-time visual rendering method for API-driven pre-built UI, characterized in that, Includes the following steps: S1: Establish a pre-made UI resource library. Each pre-made UI resource library stores multiple preset visual element samples. Each preset visual element sample includes a visual identifier and corresponding visual attribute information. The visual attribute information is pre-rendered, calculated, and stored according to the target layout style and target aesthetic style. S2: Acquire user action data and generate a corresponding semantic request based on the user action data; the user action data is collected through a motion-sensing interaction device; S3: The semantic request is sent to the decision module, which then matches the corresponding target visual identifier from the pre-made UI resource library based on the semantic request; S4: Call the visual attribute information of the preset visual element sample corresponding to the target visual identifier, and directly map the visual attribute information into the visual output through the local rendering engine without performing style calculation and layout calculation; S5: Output the visualization implementation.

2. The real-time visual rendering method for API-driven pre-built UI according to claim 1, characterized in that, A sample of the plurality of preset visual elements includes at least one of calligraphy stroke elements, ink wash elements, imagery graphic elements, and ink wash blank space elements.

3. The real-time visual rendering method for API-driven pre-built UI according to claim 2, characterized in that, One of the calligraphy stroke elements is rendered by pre-simulating the stroke trends of Chinese calligraphy; the other of the ink wash element is rendered by pre-simulating the diffusion effect of ink on rice paper.

4. The real-time visual rendering method for API-driven pre-built UI according to claim 1, characterized in that, One of the steps in step S2, namely, acquiring user motion data, includes: collecting the user's human joint position information through a skeletal tracking device, and extracting multidimensional skeletal features based on the human joint position information.

5. The real-time visual rendering method for API-driven pre-built UI according to claim 4, characterized in that, One of the multidimensional skeletal features includes at least one of displacement progress, movement speed, movement intensity, and stagnation duration.

6. The real-time visual rendering method for API-driven pre-built UI according to claim 1, characterized in that, The decision module mentioned in step S3 is a cloud-based large language model, and one of the semantic requests includes a dimensionality-reduced semantic package generated based on the multidimensional skeletal features.

7. The real-time visual rendering method for API-driven pre-built UI according to claim 1, characterized in that, The local rendering engine mentioned in step S4 is a UI rendering subsystem of a game engine.

8. A real-time visual rendering method for API-driven pre-built UI according to claim 1 or 7, characterized in that, A visual attribute information includes at least one of vertex coordinate data, texture coordinate data, shader parameter data, and hierarchy order data; the visual attribute information is stored in a structured data format.

9. The real-time visual rendering method for API-driven pre-built UI according to claim 1, characterized in that, It also includes the update steps of the prefabricated UI resource library: periodically receiving new visual element style suggestions generated by the cloud-based large language model, converting the new visual element style suggestions into corresponding visual attribute information, and updating them to the prefabricated UI resource library.

10. A real-time visual rendering method for API-driven pre-built UI according to claim 1, characterized in that, One of the prefabricated UI resource libraries uses a hash table as its index structure, visual identifiers as keys, and visual attribute information as mapping values.

Images