Rendering system, rendering task execution method, storage medium and program product

Abstract

The invention discloses a rendering system, a rendering task execution method, a storage medium and a program product. According to the method, the data packet can be intercepted through the simulated touch screen created by the SDK, so that the data packet cannot be transmitted to the system layer of the server cluster to be processed, the simulated touch screen analyzes the data packet after intercepting the data packet, and the data packet can be transmitted to the server cluster through the analyzed attribute information of the plurality of touch points. According to the embodiment of the invention, the touch event aiming at the plurality of touch operations of the user is generated, and the plurality of touch operations executed by the user aiming at one frame of picture can be regarded as one touch event by generating the touch event, so that the plurality of touch operations of the user can be simultaneously and concurrently responded in the subsequent image rendering process, and the picture required by the user is rendered. And the service execution efficiency of the user based on the cloud rendering service is also remarkably improved while the experience of using the cloud rendering service by the user is improved.

Description

Technical Field

[0001] One or more embodiments of this specification relate to the field of computer technology, and in particular, to a rendering system, a rendering task execution method, a storage medium, and a program product. Background Art

[0002] As users continue to pursue higher quality for digital content such as animation, film, television, and games, cloud rendering services have emerged. Leveraging the immense computing power of cloud computing, cloud rendering services offload the arduous rendering workload that previously required local devices to remote server clusters. This significantly improves rendering efficiency and quality while also reducing the hardware requirements for user devices. This not only relieves pressure on local devices but also allows users to access the rendering services they need anytime, anywhere, significantly enhancing work efficiency and flexibility.

[0003] However, current cloud rendering services do not support multi-touch processing capabilities. The so-called multi-touch refers to the user applying multiple touches simultaneously to a frame of rendered image displayed on the terminal device. The remote server cluster that executes the cloud rendering service cannot handle the user's multiple touch commands for a frame of rendered image at the same time. As a result, when the user uses multiple fingers to perform touch operations such as zooming and rotating in a frame of rendered image, they cannot get the correct response, which not only reduces the user experience, but also reduces the user's business execution efficiency based on the cloud rendering service. Summary of the Invention

[0004] In view of this, one or more embodiments of this specification provide the following technical solutions:

[0005] According to a first aspect of one or more embodiments of this specification, a rendering system is provided, the rendering system comprising: a terminal device used by a user and a rendering server in a server cluster that performs rendering tasks;

[0006] The terminal device generates, in response to multiple touch operations performed by the user on a frame of image displayed on the terminal device, multiple touch instructions corresponding to the multiple touch operations, and encapsulates the multiple touch instructions into data packets and sends them to the server cluster, wherein the multiple touch instructions record attribute information of multiple touch points touched by the user on the frame of image;

[0007] The rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates and generates touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen based on the touch events, and returns the target screen to the terminal device.

[0008] Optionally, the rendering server receives an application package including the SDK, and replaces an original application package in the server with the application package to mount the SDK.

[0009] Optionally, the rendering server creates a rendering container group for the user according to the SDK, wherein the rendering container group is used to create a running environment for executing the rendering task required by the user and manage computing resources for executing the rendering task required by the user;

[0010] The rendering server renders the screen to be displayed after the user performs the multiple touch operations according to the rendering container group and the touch event.

[0011] Optionally, the rendering server obtains the user information of the user through the SDK, determines the user screen element corresponding to the user based on the user information, and renders the screen to be displayed after the user performs the multiple touch operations based on the touch event and the user screen element.

[0012] Optionally, the rendering server determines the coordinates corresponding to the multiple touch points based on the attribute information of the multiple touch points, converts the coordinates based on the conversion relationship between the picture size of the frame image and the screen size corresponding to the simulated touch screen, and obtains the converted coordinates corresponding to the multiple touch points. Based on the converted coordinates, the simulated touch screen simulates and generates touch events for the multiple touch operations.

[0013] Optionally, the terminal device displays the image returned by the rendering server through a preset front-end H5 component.

[0014] Optionally, the rendering system further includes: a platform server;

[0015] The platform server receives a rendering request sent by the terminal device, determines, based on the rendering request, a server in the server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and returns connection information corresponding to the rendering server to the terminal device, wherein the connection information includes a server IP address and a port number of the rendering server;

[0016] The terminal device establishes a communication connection with the rendering server according to the connection information.

[0017] Optionally, the platform server parses the rendering request to determine the device information of the terminal device contained in the rendering request, and judges whether the terminal device is qualified for rendering based on the device information and a preset device list. If it is determined that the device list contains the device information of the terminal device, it is determined that the terminal device is qualified for rendering, so as to determine the server from the server cluster for executing the rendering task corresponding to the rendering request.

[0018] Optionally, the platform server receives an application package containing the SDK, verifies the application package, and when it is determined that the application package passes the verification, sends the application package to each server included in the server cluster, so that each server replaces the local original application package with the application package to mount the SDK.

[0019] Optionally, the system of the server cluster is a Linux system, and the SDK includes: Unity SDK.

[0020] According to a second aspect of one or more embodiments of this specification, a rendering task execution method is provided. The method is applied to a rendering server executing a rendering task in a server cluster, comprising:

[0021] Create a simulated touch screen through the pre-installed software development kit SDK;

[0022] intercepting, by means of the simulated touch screen, a data packet sent by the terminal device, and parsing the data packet to parse attribute information of a plurality of touch points, wherein the data packet is obtained by the terminal device encapsulating a plurality of touch instructions, the plurality of touch instructions being generated in response to a plurality of touch operations performed by a user in a frame of image displayed by the terminal device, the plurality of touch instructions recording attribute information of the plurality of touch points touched by the user in the frame of image;

[0023] By means of the simulated touch screen, touch events for the multiple touch operations are simulated and generated according to the attribute information of the multiple touch points;

[0024] According to the touch event, a screen to be displayed after the user performs the multiple touch operations is rendered as a target screen, and the target screen is returned to the terminal device.

[0025] Optionally, install the SDK, including:

[0026] Receive an application package containing the SDK;

[0027] The original application package in the server is replaced by the application package to mount the SDK.

[0028] Optionally, before rendering, according to the touch event, a screen to be displayed after the user performs the multiple touch operations, the method further includes:

[0029] Creating a rendering container group for the user according to the SDK, wherein the rendering container group is used to create a running environment for executing the rendering task required by the user and manage computing resources for executing the rendering task required by the user;

[0030] Rendering, according to the touch event, a screen to be displayed after the user performs the multiple touch operations, specifically includes:

[0031] The screen to be displayed after the user performs the multiple touch operations is rendered according to the rendering container group and the touch event.

[0032] Optionally, rendering, according to the touch event, a screen to be displayed after the user performs the multiple touch operations specifically includes:

[0033] Obtaining user information of the user through the SDK;

[0034] Determining a user screen element corresponding to the user according to the user information;

[0035] Rendering a screen to be displayed after the user performs the multiple touch operations according to the touch event and the user screen element.

[0036] Optionally, simulating and generating touch events for the multiple touch operations according to the attribute information of the multiple touch points through the simulated touch screen specifically includes:

[0037] determining coordinates corresponding to the plurality of touch points according to the attribute information of the plurality of touch points;

[0038] Converting the coordinates according to a conversion relationship between the screen size of the frame and the screen size corresponding to the simulated touch screen to obtain converted coordinates corresponding to the multiple touch points;

[0039] According to the converted coordinates, touch events for the multiple touch operations are simulated and generated through the simulated touch screen.

[0040] Optionally, the terminal device displays the image returned by the rendering server through a preset front-end H5 component.

[0041] Optionally, the system of the server cluster is a Linux system, and the SDK includes: Unity SDK.

[0042] According to a third aspect of one or more embodiments of this specification, a rendering task execution method is proposed. The method is applied to a platform server and includes:

[0043] Receive rendering requests sent by terminal devices;

[0044] According to the rendering request, determining a server from a server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and returning connection information corresponding to the rendering server to the terminal device, so that the terminal device establishes a communication connection with the rendering server according to the connection information, and sends a data packet to the rendering server based on the communication connection, and the rendering server executes the rendering task based on the data packet;

[0045] The connection information includes the server IP and port number of the rendering server, the data packet is obtained by the terminal device encapsulating multiple touch instructions, the multiple touch instructions are generated based on multiple touch operations performed by the user in a frame of image displayed by the terminal device, and the multiple touch instructions record attribute information of multiple touch points touched by the user in the frame of image;

[0046] During the execution of the rendering task, the rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates the generation of touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen according to the touch events, and returns the target screen to the terminal device.

[0047] Optionally, before determining, from a server cluster, a server for executing a rendering task corresponding to the rendering request, the method further includes:

[0048] Parsing the rendering request to determine device information of the terminal device included in the rendering request;

[0049] Determining whether the terminal device is qualified for rendering based on the device information and a preset device list;

[0050] Determining, according to the rendering request, a server from a server cluster for executing a rendering task corresponding to the rendering request, specifically comprising:

[0051] If it is determined that the device list contains the device information of the terminal device, it is determined that the terminal device has rendering qualifications, so as to determine a server from the server cluster for executing the rendering task corresponding to the rendering request.

[0052] Optionally, before receiving the rendering request sent by the terminal device, the method further includes:

[0053] Receive an application package containing the SDK;

[0054] Verifying the application package;

[0055] When it is determined that the application package passes the verification, the application package is sent to each server included in the server cluster, so that each server replaces the local original application package with the application package to mount the SDK.

[0056] Optionally, the system of the server cluster is a Linux system, and the SDK includes: Unity SDK.

[0057] According to a fourth aspect of one or more embodiments of this specification, a rendering task execution device is provided, including:

[0058] Create a module for creating a simulated touch screen through the pre-installed software development kit SDK;

[0059] a parsing module, configured to intercept, via the simulated touch screen, a data packet sent by the terminal device and parse the data packet to obtain attribute information of a plurality of touch points, wherein the data packet is obtained by the terminal device encapsulating a plurality of touch instructions, the plurality of touch instructions being generated in response to a plurality of touch operations performed by a user in a frame of image displayed by the terminal device, the plurality of touch instructions recording attribute information of the plurality of touch points touched by the user in the frame of image;

[0060] a simulation module, configured to simulate and generate touch events for the multiple touch operations according to the attribute information of the multiple touch points through the simulated touch screen;

[0061] A rendering module is used to render, according to the touch event, a screen to be displayed after the user performs the multiple touch operations as a target screen, and return the target screen to the terminal device.

[0062] According to a fifth aspect of one or more embodiments of this specification, a rendering task execution device is provided, including:

[0063] A receiving module, used to receive a rendering request sent by a terminal device;

[0064] a determination module configured to determine, based on the rendering request, a server from a server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and return connection information corresponding to the rendering server to the terminal device, so that the terminal device establishes a communication connection with the rendering server based on the connection information, and sends a data packet to the rendering server based on the communication connection, so that the rendering server executes the rendering task based on the data packet;

[0065] The connection information includes the server IP and port number of the rendering server, the data packet is obtained by the terminal device encapsulating multiple touch instructions, the multiple touch instructions are generated based on multiple touch operations performed by the user in a frame of image displayed by the terminal device, and the multiple touch instructions record attribute information of multiple touch points touched by the user in the frame of image;

[0066] During the execution of the rendering task, the rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates the generation of touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen according to the touch events, and returns the target screen to the terminal device.

[0067] According to a sixth aspect of one or more embodiments of this specification, a computer-readable storage medium is provided, on which computer instructions are stored. When the instructions are executed by a processor, the steps of the above-mentioned rendering task execution method are implemented.

[0068] According to a seventh aspect of one or more embodiments of this specification, a computer program product is proposed, including a computer program / instruction, which implements the steps of the above-mentioned rendering task execution method when executed by a processor.

[0069] It can be seen from the above embodiment that since the SDK for performing image rendering is pre-mounted in the server cluster that performs image rendering, when the terminal device sends a data packet generated based on the user performing multiple touch operations on a frame of the picture to the server cluster, the simulated touch screen created by the SDK will intercept the data packet, so that the data packet will not be transmitted to the system layer of the server cluster for processing. After intercepting the data packet, the simulated touch screen will parse it and generate touch events for the user's multiple touch operations based on the attribute information of the parsed multiple touch points. By generating the touch event, the multiple touch operations performed by the user on a frame of the picture can be regarded as one touch event. Therefore, in the subsequent image rendering process, the user's multiple touch operations can be responded to simultaneously and concurrently, thereby rendering the picture required by the user. While improving the user's experience of using the cloud rendering service, it also significantly improves the user's business execution efficiency based on the cloud rendering service. BRIEF DESCRIPTION OF THE DRAWINGS

[0070] Figure 1 A schematic diagram of a rendering system for performing rendering tasks provided in this specification;

[0071] Figure 2 A flowchart of a rendering task execution method provided in this specification;

[0072] Figure 3 Schematic diagram of the process of pre-installing the SDK on the server cluster provided in this manual;

[0073] Figure 4 This is a schematic diagram of a user performing multiple touch operations on a single frame displayed on a terminal device, as provided in this manual;

[0074] Figure 5 A schematic diagram of the process of the terminal device provided in this manual interacting with the server cluster to perform rendering tasks;

[0075] Figure 6 A schematic diagram of the process of the platform server performing rendering tasks provided in this manual;

[0076] Figure 7 A schematic diagram of the process of the platform server performing rendering tasks provided in this manual;

[0077] Figure 8 It is a schematic structural diagram of a device provided in this manual;

[0078] Figure 9 A block diagram of a rendering task execution device provided in this specification;

[0079] Figure 10 This is a block diagram of a rendering task execution device provided in this specification. DETAILED DESCRIPTION

[0080] The user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this manual are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of relevant data must comply with the relevant laws, regulations and standards of relevant countries and regions, and corresponding operation entrances are provided for users to choose to authorize or refuse.

[0081] In the current cloud rendering service environment, when a user on a terminal device issues multiple touch commands for a single frame, these touch commands must be transmitted over the network to a remote server cluster. During this process, the system layer within the server cluster (such as Linux) is responsible for capturing and processing these touch commands. However, due to limitations in the current design architecture, the system layer can only process these touch commands sequentially, not concurrently.

[0082] Specifically, when a user sends multiple touch commands for a single frame from a terminal device to a remote server cluster, they are first saved as temporary files on the Linux instance. These touch commands are then executed one by one in the order they were received. Because the system lacks an effective mechanism to handle multiple touch events simultaneously, all subsequent touch commands must wait until the previous one is processed. This serial processing significantly increases overall response time, especially under high load conditions, which can lead to severe latency issues.

[0083] In addition, in 3D rendering applications such as Unity or UnrealEngine, although there are optimization strategies to reduce the latency of the entire "streaming" link, such as connecting the streaming application layer and the rendering program through inter-process communication to avoid operating system interaction. However, when faced with multiple touch events involved in a frame, the problem that Input.touch (a class in the Unity system used to handle user touch operations on the touch screen, which provides the function of detecting touch events on the user's terminal device) can only retain one event per frame still exists. This means that even under ideal conditions, some touch information may be lost or not processed in time, further affecting the user experience.

[0084] Therefore, under this architecture, the inability to truly concurrently process multiple touch commands ultimately prevents the required rendered images from being quickly returned to the user's terminal device. This not only affects the user's real-time interactive experience, but also limits the performance of cloud rendering services in highly interactive applications such as virtual reality (VR), augmented reality (AR), and complex 3D gaming environments.

[0085] To this end, the present specification provides a rendering system and a corresponding rendering task execution method. Through a software development kit (SDK) pre-mounted in a remote server cluster, a simulated touch screen can be created in a server that executes a rendering task in the server cluster. Through the simulated touch screen, a data packet generated by a terminal device based on multiple touch operations performed by a user on a frame of a picture can be intercepted, so that the data packet does not enter the system layer of the server cluster for processing. Moreover, through the simulated touch screen, the data packet can be parsed to parse the attribute information of multiple touch points corresponding to the multiple touch operations performed by the user, and based on this attribute information, a touch event for the multiple touch operations is generated, that is, the multiple touch operations performed by the user are treated as a touch event for processing. In this way, the rendering task is subsequently executed through the touch event, so that the server cluster can respond to the multiple touch operations performed by the user concurrently, thereby rendering a picture that meets the requirements of the user after performing multiple touch operations and returning it to the user's terminal device. While improving the user's experience of using the cloud rendering service, it also significantly improves the user's business execution efficiency based on the cloud rendering service.

[0086] In order to further clearly explain the technical solutions provided in this specification, some important concepts involved in this specification are explained one by one below:

[0087] SDK: A set of tools, libraries, and documentation for developing specific types of applications. It is usually provided by the manufacturer of a hardware platform, operating system, or programming language to help developers more easily build applications for that specific platform.

[0088] A typical SDK includes but is not limited to the following:

[0089] API library: provides a set of predefined function call interfaces, allowing developers to access underlying system resources or services;

[0090] Debugger: used to find and fix errors in the code;

[0091] Compilers and interpreters: convert source code into executable files;

[0092] Analysis tools: help evaluate application performance;

[0093] Sample code: shows how to use the components in the SDK to build actual applications;

[0094] Documentation: Detailed description of API usage and best practices.

[0095] Therefore, in the context of the above-mentioned cloud rendering service, the SDK can be understood as a tool for creating a simulated touch screen, generating touch events, and executing rendering tasks. Its main function is to intercept data packets sent by terminal devices so that they do not enter the system layer of the server cluster, and to generate touch events for multiple touch operations performed by the user on a frame of the screen, so that the server cluster will treat multiple touch operations as one event when executing rendering tasks.

[0096] System layer of the remote server cluster: In a server cluster, the system layer refers to the operating system and its related management tools and middleware that run directly on physical hardware or in a virtualized environment. The main responsibility of this layer is to provide a unified interface and abstraction for upper-layer applications, shield the underlying hardware differences, and support the various functional features required by the cluster.

[0097] As the foundation of the system layer, the operating system provides the most basic computing resource management capabilities, such as process scheduling, memory allocation, text system operations, etc. In the server cluster of this manual, the operating system running thereon may be a Linux system.

[0098] An event is the fundamental unit by which an operating system or application responds to user input or other external stimuli. For the purposes of this specification, touch events refer to captured user actions on the device screen using a finger or other touch tool. Typically, each time a touch operation occurs, the system generates a corresponding event object and passes it to the appropriate listener for processing.

[0099] Containers are implemented using operating system-level virtualization technology. Unlike traditional virtual machines, they don't emulate the entire hardware layer. Instead, they share the host operating system's kernel while providing an isolated workspace for each container. This means containers start faster and consume fewer system resources. In the cloud rendering service scenario covered in this manual, containers are used to manage the computing resources and operating environment required to execute rendering tasks.

[0100] Based on this, different container groups can be created for different rendering tasks, allowing them to execute the corresponding rendering tasks using the computing resources and runtime environment managed by the container group. A container group can include at least one container. If a container group contains multiple containers, some containers can manage the runtime environment required to execute the rendering task, while others can manage the different computing resources required to execute the rendering task.

[0101] Unity: An engine used for game development and real-time 3D rendering. It provides efficient real-time rendering and compatibility with a variety of devices (such as PCs, mobile devices, the Web, VR / AR, etc.) in cloud rendering services. Unity also offers flexible expansion capabilities, allowing developers to customize features through scripts, such as physical simulation and animation control.

[0102] The technical solutions provided by the embodiments of this specification are described in detail below with reference to the accompanying drawings.

[0103] Figure 1 This is a schematic diagram of a rendering system for performing rendering tasks provided in this specification.

[0104] exist Figure 1 The rendering system shown here includes a user terminal device and a remote server cluster. The terminal device can be a device such as a laptop or desktop computer, or a mobile device such as a smartphone or tablet. The terminal device displays various images to the user through a running client and monitors the user's touch operations on these images. Once a touch operation is detected, the terminal device generates a corresponding touch command and sends it to the remote server cluster.

[0105] Remote server clusters provide cloud rendering services to users. This means leveraging the server cluster's powerful rendering capabilities to help users' devices render images. The server cluster then returns the rendered images to the devices, which then display them to the user.

[0106] The server cluster described above consists of multiple servers. If the rendering task requires a large amount of computation, these servers can collaborate to complete the rendering task. Of course, in actual applications, the rendering tasks required by users can usually be completed by a single server in the server cluster. Furthermore, individual servers in the server cluster can be divided into different partitions, each for performing different rendering tasks. These partitions can achieve resource isolation, improve server system security and stability, and enable business-level expansion, thereby providing cloud rendering services to more users within a fixed server cluster size.

[0107] Developers can pre-install the SDK in the server cluster, which contains the code logic for subsequent cloud rendering service execution. With the pre-installed SDK, the server cluster will not forward multiple touch commands from the user's terminal device for a single frame to the server cluster's system layer for processing during rendering tasks. Instead, it will intercept the data packets containing multiple touch commands sent by the terminal device based on the simulated touch screen created by the SDK and generate touch events that treat the user's multiple touch operations as a single event. This ensures that the server cluster can render the actual image desired by the user after performing multiple touch operations.

[0108] The rendering system also includes a platform server, which can be owned by the same operator as the server cluster. The platform server is primarily responsible for allocating servers from the server cluster to users for cloud rendering services and completing various pre-verification processes. This pre-verification primarily involves verifying user eligibility for cloud rendering services and verifying the SDK application packages uploaded by developers to the server cluster. This will be explained in detail later.

[0109] Therefore, the above rendering system can be summarized as the terminal device sending a rendering request to the platform server. Based on the rendering request, the platform server allocates the rendering server required to perform the rendering task to the terminal device, and the rendering server in the server cluster executes the rendering task required by the user through the touch instructions sent by the terminal device.

[0110] The following describes the rendering tasks provided in this manual from the perspective of the rendering server in the server cluster and the perspective of the platform server.

[0111] Figure 2 This is a flowchart of a rendering task execution method provided in this specification. The method is applied to a rendering server that executes rendering tasks in a server cluster, and specifically includes the following steps:

[0112] S200: Create a simulated touch screen through the pre-installed software development kit SDK.

[0113] In this manual, the rendering servers in the server cluster are pre-installed with a developer-developed SDK, which provides the logic code required to perform rendering tasks. Based on this, the rendering servers can use this SDK to create simulated touch screens. The rendering servers here can be servers assigned to users from the server cluster. The specific allocation process will be explained later.

[0114] Among them, the so-called simulated touch screen is not an actual touch screen, but an abstraction layer defined and managed by software. It can simulate the behavior of real input devices, which means that it can generate input event streams that are exactly the same as those of a real touch screen, even if these events are actually triggered by data packets transmitted from the network.

[0115] The simulated touch screen will intercept the touch instructions sent by subsequent terminal devices and generate a touch event for multiple touch instructions, which allows these multiple touch instructions to be processed simultaneously to correctly return to the user the screen that should be displayed after the user performs multiple touch operations on a frame of screen.

[0116] In this specification, the simulated touchscreen can be created by the server cluster when a user uses a terminal device to perform tasks involving cloud rendering services, or it can be directly generated by the server cluster after the SDK is installed. This specification does not limit the mechanism for creating the simulated touchscreen; it only requires that the terminal device completes the creation before sending a data packet containing multiple touch commands to the server cluster.

[0117] In addition, before creating the above simulated touch screen, you need to mount the SDK developed by the developer to the server cluster. The following will take the server cluster mounting Unity SDK as an example to illustrate the entire SDK mounting process. Figure 3 shown.

[0118] Figure 3 This is a diagram of the process of pre-installing the SDK on the server cluster provided in this manual.

[0119] First, developers can create Unity projects or update existing Unity projects based on the needs of the cloud rendering service. Creating or updating Unity here refers to creating or updating the Unity system in the server cluster based on actual needs, so that the created or updated Unity system can provide the rendering engine and operating environment during the execution of subsequent rendering tasks.

[0120] On this basis, developers can customize the Unity SDK based on the requirements of the cloud rendering service they want to implement. After that, the terminal device used by the developer will package the Unity SDK in response to the deployment operation performed by the developer to obtain an application package and send the application package to the platform server. The platform server can process the received application package, such as verifying the application package information and generating the corresponding version number for the application package. After completing the processing of the application package, the platform server can upload the application package to the remote server cluster to mount the application file corresponding to the SDK on the server cluster.

[0121] Before mounting the SDK, other application packages may have been deployed in the server cluster. Therefore, the deployed other application packages can be used as the original application packages, and then the received new application packages can be replaced with the original application packages to achieve the mounting of the SDK.

[0122] Once the mounting is complete, the server cluster will persistently mount the application files corresponding to the SDK, and in the subsequent process, the SDK can be used to provide cloud rendering services to users. During this process, the server cluster will apply for a Pod for the user during the cloud rendering service. The so-called Pod is the container group mentioned above. The Pod provides the necessary computing resources and operating environment for the subsequent cloud rendering service. Therefore, during the execution of the cloud rendering service, after applying for the Pod, the server cluster will pull the application package and provide cloud rendering services to users through the pre-mounted SDK.

[0123] Furthermore, in order to implement multi-touch rendering while executing rendering tasks so that the received touch commands do not need to be processed by the system layer in the server cluster, in this manual, the server cluster needs to create a simulated touch screen through a pre-installed SDK.

[0124] S202: intercepting data packets sent by the terminal device through the simulated touch screen, and parsing the data packets to parse out attribute information of multiple touch points.

[0125] When a user browses a picture displayed on a terminal device screen, he or she may need to perform touch operations such as clicking, zooming, stretching, etc. on the picture to further obtain the desired picture content. In this process, the user may use multiple fingers to perform multiple touch operations on a frame of the picture. These touch operations will correspond to different touch points on the terminal device screen, such as Figure 4 shown.

[0126] Figure 4 This manual provides a schematic diagram of a user performing multiple touch operations on a single frame displayed on a terminal device.

[0127] Figure 4 The terminal device shown displays a frame to the user. This frame can be displayed to the user after the terminal device runs the client. Based on this, the server cluster that subsequently executes the cloud rendering service and the platform server involved in the SDK mounting described above can be the server and server cluster of the operator corresponding to the client. In addition to providing the user with the services corresponding to the client, the operator also provides cloud rendering services to the user.

[0128] When the user views a frame displayed by the client, Figure 4 The two touch operations shown are Figure 4 It can be seen that the user's two fingers touch different positions of the screen to achieve zooming or stretching of the screen.

[0129] As can be seen from the above example, what kind of rendered screen the server cluster needs to return to the user subsequently depends on the multiple touch operations performed by the user on the terminal device. Therefore, the attribute information of multiple touch points corresponding to the multiple touch operations performed by the user is crucial for the screen rendering of the server cluster.

[0130] The attribute information mentioned here can refer to the location of the touch point in a frame displayed by the terminal device, the identification information of the touch point (such as an identifier used to distinguish different touch points), the touch duration, and other information. The attribute information of the touch point will also determine which part of the frame the server cluster needs to scale or stretch during the subsequent image rendering process, or which screen element in the frame needs to be displayed to the user.

[0131] The screen elements here refer to the objects contained in the screen, such as buildings, commodities, etc. Users can touch these screen elements through touch operations to view the detailed content of these screen elements. For example, when the screen element is a building, after the user touches the screen element, the terminal device will show the user the interior picture of the building, and the interior picture is the detailed content of the screen element.

[0132] Therefore, after creating the above-mentioned simulated touch screen, the server cluster can monitor the user's operations on the terminal device through the listener corresponding to the SDK. When the user performs multiple touch operations in a frame displayed on the terminal device, the terminal device can generate corresponding touch instructions for each touch operation based on the attribute information of the touch point corresponding to each touch operation, and then encapsulate the generated multiple touch instructions into a data packet and send it to the server cluster.

[0133] After the server cluster receives the data packet, the above-mentioned listener will monitor the operations performed by the user on the terminal device, and then intercept the data packet through the created simulated touch screen, so that the data packet will not be processed by the system layer of the server cluster. Then, the data packet can be parsed through the simulated touch screen to parse out the attribute information of multiple touch points corresponding to the multiple touch operations performed by the user in a frame displayed on the terminal device.

[0134] S204: Using the simulated touch screen, simulate and generate touch events for the multiple touch operations according to the attribute information of the multiple touch points.

[0135] After parsing these attribute information, the simulated touch screen can reconstruct these attribute information to create a data structure equivalent to the local touch event. That is, through the simulated touch screen, based on the attribute information of multiple touch points parsed, touch events for multiple touch operations performed by the user can be simulated and generated.

[0136] This touch event actually treats the user's multiple touch operations on a frame of screen as one event to trigger, rather than treating multiple touch operations as multiple event triggers separately. This allows the subsequent rendering server to synchronously and concurrently process the user's multiple touch instructions on a frame of screen.

[0137] S206: Rendering, according to the touch event, a screen to be displayed after the user performs the multiple touch operations as a target screen, and returning the target screen to the terminal device.

[0138] The rendering server can perform rendering tasks based on the generated touch events. As mentioned above, the rendering server can process multiple touch operations performed by the user on a frame of the screen in the terminal device as one touch event, instead of the existing conventional method of processing the user's multiple touch operations on a frame of the screen one by one in sequence. This ensures that the server cluster can eventually return the actual required rendering screen to the user.

[0139] In the process of executing the rendering task based on the touch event, since the rendering server needs to simulate the multiple touch operations performed by the user in the terminal device into touch operations performed locally through the above-mentioned simulated touch screen, the rendering server needs to perform coordinate conversion during this simulation process, that is, convert the coordinates of the multiple touch points involved in the multiple touch operations performed by the user on the terminal device into the coordinates of the touch points generated when the multiple touch operations occur on the simulated touch screen.

[0140] Therefore, the rendering server needs to determine the coordinates corresponding to the multiple touch points based on their attribute information (i.e., the coordinates of the touch points in a frame displayed on the terminal device). Then, based on the conversion relationship between the frame size and the corresponding screen size of the simulated touch screen, the rendering server performs coordinate conversion to obtain the converted coordinates corresponding to the multiple touch points. The so-called converted coordinates correspond to the positions of these touch points on the simulated touch screen. Based on the converted coordinates of the multiple touch points, the rendering server can generate touch events for these multiple touch operations through the simulated touch screen.

[0141] In addition, in actual applications, the screen elements contained in the screen displayed by the terminal device may be related to the user. That is, if some screen elements are related to the user's business assets, then different users may correspond to different screen elements. For example, in the scenario of non-fungible tokens (NFTs), the screen displayed by the terminal device may include the NFTs held by the user, where the displayed NFTs are the user screen elements related to the user in the screen.

[0142] On this basis, if the rendering server is to subsequently return the correct rendered image to the user, in addition to correctly responding to the user's multiple touch operations on a single frame on the terminal device, it also needs to obtain the user's user information and, based on the user's user information, determine the user's corresponding user screen element. Subsequently, through the aforementioned touch events and user screen elements, the image to be displayed after the user performs multiple touch operations is rendered. Therefore, the user screen element here primarily determines the screen elements presented in the image to be rendered by the server cluster.

[0143] In order to further illustrate the process of the rendering server executing the rendering task, the following will start from the establishment of a communication connection between the terminal device and the rendering server, and explain the entire process in series, as shown below. Figure 5 shown.

[0144] Figure 5 This document provides a schematic diagram of the process of terminal devices interacting with server clusters to perform rendering tasks.

[0145] First, the terminal device establishes a communication connection with a rendering server in the server cluster, where the rendering server here refers to a server selected from the server cluster for providing cloud rendering services to users. The rendering server can provide users with exclusive cloud rendering services.

[0146] After establishing a communication connection, the terminal device can transmit user information to the user, and the rendering server uses the user information, runs Unity, and establishes a rendering process for the user. Among them, the user information here is mainly used to distinguish users, so as to determine the user screen elements belonging to the user in the subsequent rendering task process. The user information contains information that can serve as an identification, such as the user account and the user's mobile phone number. It should be emphasized that this information will only be sent to the server cluster under the premise that the user authorizes the server cluster to obtain this information. Therefore, before executing the cloud rendering service, the user can first display the authorization page to the user. Only after the user authorization is confirmed through the authorization page can the information be obtained.

[0147] When the rendering server is performing a rendering task, whether it is a single touch operation or multiple touch operations performed by the user, it needs to parse the data packet sent by the terminal device to obtain the attribute information of the touch point corresponding to the touch operation performed by the user on the terminal device, and then perform the above-mentioned coordinate conversion based on the parsed attribute information to determine the coordinates corresponding to the touch point in the simulated touch screen, that is, the converted coordinates mentioned above.

[0148] The rendering server then generates corresponding touch events based on the converted coordinates, and then performs real-time rendering tasks. During this process, if a user performs multiple touch operations on a single frame on a terminal device, the simulated touch screen can process these multiple touch operations as a single touch event, eliminating the need to sequentially transmit the touch commands for these multiple touch operations to the system layer of the server cluster for processing. This allows for concurrent processing of the multiple touch commands corresponding to these multiple touch operations, returning to the user the image that would be displayed after responding to these multiple touch operations simultaneously.

[0149] In addition, in this manual, the terminal device can display various images through the preset front-end H5 component. Therefore, whether the terminal device is an Android system or an IOS system, it supports the use of H5 components to display images to users. Therefore, both systems can execute cloud rendering services, and there is no need to maintain two sets of code implementations for different operating systems of terminal devices. This not only ensures the user service experience, but also greatly reduces the maintenance cost of cloud rendering services.

[0150] In this specification, the system of the server cluster may be a Linux system, and on this basis, the SDK mounted in the server cluster may be a Unity SDK.

[0151] It can be seen from the above method that since the SDK for performing image rendering is pre-mounted in the server cluster that performs image rendering, when the terminal device sends a data packet generated based on the user performing multiple touch operations on a frame of the picture to the server cluster, the simulated touch screen created by the SDK will intercept the data packet, so that the data packet will not be transmitted to the system layer of the server cluster for processing. After intercepting the data packet, the simulated touch screen will parse it and generate touch events for the user's multiple touch operations based on the attribute information of the parsed multiple touch points. By generating the touch event, the multiple touch operations performed by the user on a frame of the picture can be regarded as one touch event. Therefore, in the subsequent image rendering process, the user's multiple touch operations can be responded to concurrently, thereby rendering the picture required by the user. While improving the user's experience of using the cloud rendering service, it also significantly improves the user's business execution efficiency based on the cloud rendering service.

[0152] In addition, it should be noted that although this manual will bypass the system layer processing of the server cluster for multiple touch instructions generated by the user's multi-touch operations, it does not mean that the entire rendering task no longer requires the participation of the server cluster system. The resource calls, data caching, etc. involved in the execution of the rendering task require the server cluster system to provide support for the rendering process that executes the rendering task. However, the rendering task method provided in this manual can effectively avoid the situation where the multiple touch operations performed by the user on a frame of the picture are processed one by one in sequence through the system layer, thereby ensuring that the actual required rendering picture is returned to the user.

[0153] The above content describes the rendering task execution method provided in this manual from the perspective of a remote server cluster. The following will continue to introduce it from the perspective of a platform server. In the following content, some unique steps of the platform server in the process of executing rendering tasks will be described in detail. As for the content that has been introduced above, it will not be repeated in detail.

[0154] Figure 6 This is a schematic diagram of the process of the platform server performing rendering tasks provided in this manual.

[0155] S600: Receive a rendering request sent by a terminal device.

[0156] S602: Based on the rendering request, determine a server from a server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and return connection information corresponding to the rendering server to the terminal device, so that the terminal device establishes a communication connection with the rendering server based on the connection information, and sends a data packet to the rendering server based on the communication connection, and the rendering server executes the rendering task based on the data packet.

[0157] In this specification, the operator of a server cluster can provide cloud rendering services to users. Before executing the cloud rendering service, it is necessary to first review whether the user is qualified for the cloud rendering service. This review process can be completed by the operator's platform server.

[0158] Therefore, in the cloud rendering service scenario, operators actually deploy two types of servers. One type of server is mainly used to perform rendering tasks, that is, the server in the server cluster; the other type is responsible for early docking with users, user qualification review, and providing a basis for communication between users' terminal devices and the server cluster.

[0159] Therefore, when a user needs to use the cloud rendering service, they can send a rendering request to the platform server through their terminal device. This rendering request is mainly for the preliminary preparation of the subsequent rendering task. During this process, the platform server needs to allocate a server to perform the rendering task to the user's terminal device based on the rendering request. However, it should be noted that since the number of servers in the server cluster is ultimately limited, the platform server needs to screen the terminal devices that send rendering requests and allocate a server to the terminal devices that actually need the cloud rendering service.

[0160] Based on this, the platform server can parse the rendering request to determine the device information of the user's terminal device contained in the rendering request. Then, based on this device information and a preset device list, the platform server can determine whether the user's terminal device is eligible for rendering, that is, whether the user is eligible to use the cloud rendering service.

[0161] If it is determined that the device list contains the device information of the terminal device, it can be determined that the terminal device is qualified for rendering, and then a server for executing the rendering task corresponding to the rendering request is determined from the server cluster. This server is the rendering server mentioned above.

[0162] The device list mentioned above may include device information of terminal devices with relatively low performance. Since the hardware performance of the terminal devices in the device list is poor, they may not be able to render high-quality images independently. Therefore, the platform server can provide cloud rendering services for these terminal devices, so that these low-performance terminal devices can also display high-quality images to users.

[0163] Of course, it does not mean that terminal devices with better performance cannot use the cloud rendering service. The reason for setting up a list of qualified devices is mainly to ensure that high-quality rendering images are returned to low-performance terminal devices when service needs are relatively tight. When the resources of the server cluster (that is, idle servers) are relatively sufficient, for rendering requests sent by high-performance terminal devices, the platform server can also allocate servers to terminal devices based on the rendering requests to perform rendering tasks. Therefore, this device list can be turned on and off based on the occupancy of servers in the server cluster, that is, when the number of idle servers in the server cluster is less than the set number, the device list is turned on to screen qualified terminal devices through the device list, and when the number of idle servers in the server cluster is not less than the set number, the device list can be closed, that is, for rendering requests sent by any terminal device, the platform server can allocate a server for it.

[0164] Once the terminal device is determined to be eligible, the platform server returns the connection information of the assigned rendering server to the terminal device. This connection information may include the rendering server's server IP and port number. Based on this connection information, the terminal device can establish a communication connection with the rendering server and then execute the rendering task based on the SDK pre-installed on the rendering server.

[0165] In order to further illustrate the role of the platform server in the entire rendering task execution process, the following will start from the terminal device sending the rendering request and explain the various operations performed by the platform server, such as Figure 7 shown.

[0166] Figure 7 This is a schematic diagram of the process of the platform server performing rendering tasks provided in this manual.

[0167] The terminal device can send a rendering request to the platform server so that the platform server can pre-verify the terminal device. This pre-verification process mainly involves two verifications: one is to determine whether the terminal device is qualified, and the other is to determine whether there are any idle servers in the current server cluster.

[0168] Therefore, the platform server can determine whether the terminal device used by the user is a low-end device through the preset device list. If it is determined to be a low-end device, it can send a query instruction to the server cluster so that the server cluster can query the currently idle server list based on the query instruction and return the query result to the platform server.

[0169] If the platform server determines that there are idle servers in the server cluster based on the query results, it can return a pre-verification result to the terminal device, indicating that the pre-verification has passed. This pre-verification result not only contains information indicating that the terminal device has passed pre-verification but also includes the aforementioned connection information. The terminal device can then establish a connection with the assigned rendering server based on the connection information contained in the pre-verification result, thereby executing the user's rendering task through this rendering server.

[0170] In addition, as mentioned above, the platform server also needs to verify the SDK application package sent by the developer to determine whether the application package information is complete and correct. Once the application package is confirmed to pass the verification, it can be sent to each server in the server cluster. Each server will replace the local original application package with the application package to mount the SDK sent by the developer.

[0171] Therefore, from the above content, it can be seen that the platform server, whether it is for developers or users of cloud rendering services, is mainly responsible for the preliminary work of rendering tasks, that is, mounting the SDK developed by developers to the server cluster, verifying the user's qualifications, and establishing the basis for the communication connection between the terminal device used by the user and the rendering server allocated in the server cluster.

[0172] Figure 8 This is a schematic diagram of the structure of a device provided in this manual. Please refer to Figure 8 At the hardware level, the device includes a processor 802, an internal bus 804, a network interface 806, a memory 808, and a non-volatile memory 810. Of course, it may also include hardware required for other functions. One or more embodiments of this specification can be implemented based on software, such as the processor 802 reading the corresponding computer program from the non-volatile memory 810 into the memory 808 and then running it. Of course, in addition to software implementation, one or more embodiments of this specification do not exclude other implementation methods, such as logic devices or a combination of software and hardware, etc., that is, the execution subject of the following processing flow is not limited to each logic unit, but can also be hardware or logic devices.

[0173] Please refer to Figure 9 The rendering task execution device provided in this specification can be applied to Figure 8The device shown in the figure is used to implement the technical solution of this specification. The rendering task execution device may include:

[0174] A creation module 900 is used to create a simulated touch screen using a pre-installed software development kit SDK;

[0175] a parsing module 902 configured to intercept, via the simulated touch screen, a data packet sent by the terminal device and parse the data packet to obtain attribute information of multiple touch points. The data packet is obtained by the terminal device encapsulating multiple touch instructions, the multiple touch instructions being generated in response to multiple touch operations performed by a user on a frame of image displayed by the terminal device, the multiple touch instructions recording attribute information of multiple touch points touched by the user on the frame of image;

[0176] A simulation module 904 is configured to simulate and generate touch events for the multiple touch operations according to the attribute information of the multiple touch points through the simulated touch screen;

[0177] The rendering module 906 is configured to render, according to the touch event, the screen to be displayed after the user performs the multiple touch operations as a target screen, and return the target screen to the terminal device.

[0178] Optionally, the device further comprises:

[0179] The mounting module 908 is configured to receive an application package including the SDK and replace the original application package in the server with the application package to mount the SDK.

[0180] Optionally, before rendering the screen to be displayed after the user performs the multiple touch operations according to the touch event, the rendering module 906 is further configured to create a rendering container group for the user according to the SDK, wherein the rendering container group is configured to create a running environment for executing the rendering task required by the user and manage computing resources for executing the rendering task required by the user;

[0181] The rendering module 906 is specifically used to create a rendering container group for the user according to the SDK. The rendering container group is used to create a running environment for executing the rendering task required by the user and manage computing resources for executing the rendering task required by the user.

[0182] Optionally, the rendering module 906 is specifically used to obtain the user information of the user through the SDK; determine the user screen element corresponding to the user based on the user information; and render the screen to be displayed after the user performs the multiple touch operations based on the touch event and the user screen element.

[0183] Optionally, the simulation module 904 is specifically used to determine the coordinates corresponding to the multiple touch points based on the attribute information of the multiple touch points; convert the coordinates according to the conversion relationship between the picture size of the frame image and the screen size corresponding to the simulated touch screen to obtain the converted coordinates corresponding to the multiple touch points; and generate touch events for the multiple touch operations through the simulated touch screen simulation based on the converted coordinates.

[0184] Optionally, the terminal device displays the image returned by the rendering server through a preset front-end H5 component.

[0185] Optionally, the system of the server cluster is a Linux system, and the SDK includes: Unity SDK.

[0186] Please refer to Figure 10 The rendering task execution device provided in this specification can be applied to Figure 8 The device shown in the figure is used to implement the technical solution of this specification. The rendering task execution device may include:

[0187] Receiving module 1000, used to receive a rendering request sent by a terminal device;

[0188] Determining module 1002 is configured to determine, based on the rendering request, a server from a server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and return connection information corresponding to the rendering server to the terminal device, so that the terminal device establishes a communication connection with the rendering server based on the connection information, and sends a data packet to the rendering server based on the communication connection, so that the rendering server executes the rendering task based on the data packet;

[0189] The connection information includes the server IP and port number of the rendering server, the data packet is obtained by the terminal device encapsulating multiple touch instructions, the multiple touch instructions are generated based on multiple touch operations performed by the user in a frame of image displayed by the terminal device, and the multiple touch instructions record attribute information of multiple touch points touched by the user in the frame of image;

[0190] During the execution of the rendering task, the rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates the generation of touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen according to the touch events, and returns the target screen to the terminal device.

[0191] Optionally, before determining, based on the rendering request, from a server cluster, a server for executing a rendering task corresponding to the rendering request, the determining module 1002 parses the rendering request to determine device information of the terminal device included in the rendering request; and determines whether the terminal device is eligible for rendering based on the device information and a preset device list.

[0192] The determining module 1002 is specifically configured to, if it is determined that the device list contains the device information of the terminal device, determine that the terminal device has rendering qualifications, so as to determine a server from the server cluster for executing the rendering task corresponding to the rendering request.

[0193] Optionally, the device further comprises:

[0194] The verification module 1004 is used to receive the application package containing the SDK; verify the application package; when it is determined that the application package passes the verification, send the application package to each server included in the server cluster, so that each server replaces the local original application package with the application package to mount the SDK.

[0195] Optionally, the system of the server cluster is a Linux system, and the SDK includes: Unity SDK.

[0196] Based on the same concept as the above method, this specification also provides an electronic device, including: a processor; a memory for storing processor-executable instructions; wherein the processor implements the steps of the method described in any of the above embodiments by running the executable instructions.

[0197] Based on the same concept as the above method, this specification also provides a computer-readable storage medium on which computer instructions are stored. When the instructions are executed by a processor, the steps of the method described in any of the above embodiments are implemented.

[0198] Based on the same concept as the above method, this specification also provides a computer program product, including a computer program / instruction, which implements the steps of the method described in any of the above embodiments when executed by a processor.

[0199] This specification may be described in the general context of computer-executable instructions, such as program modules, executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, and the like that perform specific tasks or implement specific abstract data types. This specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media, including storage devices.

[0200] The various embodiments in this specification are described in a progressive manner. Similar parts between the various embodiments can be referred to in conjunction with each other. Each embodiment focuses on the differences between the other embodiments. In particular, the system embodiments are generally similar to the method embodiments, so the description is relatively simple. For relevant parts, refer to the description of the method embodiments.

[0201] The above are merely examples of the present invention and are not intended to limit the present invention. Various modifications and variations are possible for those skilled in the art. Any modifications, equivalent substitutions, or improvements made within the spirit and principles of the present invention are intended to be included within the scope of the claims of the present invention.

Claims

1. A rendering system, comprising: The terminal devices used by users and the rendering servers in the server cluster that perform rendering tasks; The terminal device generates, in response to multiple touch operations performed by the user on a frame of image displayed on the terminal device, multiple touch instructions corresponding to the multiple touch operations, and encapsulates the multiple touch instructions into data packets and sends them to the server cluster, wherein the multiple touch instructions record attribute information of multiple touch points touched by the user on the frame of image; The rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates and generates touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen based on the touch events, and returns the target screen to the terminal device.

2. The rendering system according to claim 1, wherein the rendering server receives an application package including the SDK, and replaces an original application package in the server with the application package to mount the SDK.

3. The rendering system according to claim 1, wherein the rendering server creates a rendering container group for the user according to the SDK, wherein the rendering container group is used to create a running environment for executing the rendering task required by the user and manage computing resources for executing the rendering task required by the user; The rendering server renders the screen to be displayed after the user performs the multiple touch operations according to the rendering container group and the touch event.

4. The rendering system as described in claim 1, wherein the rendering server obtains the user information of the user through the SDK, determines the user screen element corresponding to the user based on the user information, and renders the screen to be displayed after the user performs the multiple touch operations based on the touch event and the user screen element.

5. The rendering system as described in claim 1, wherein the rendering server determines the coordinates corresponding to the multiple touch points based on the attribute information of the multiple touch points, converts the coordinates according to the conversion relationship between the picture size of the frame image and the screen size corresponding to the simulated touch screen to obtain the converted coordinates corresponding to the multiple touch points, and generates touch events for the multiple touch operations through the simulated touch screen simulation based on the converted coordinates.

6. The rendering system according to claim 1, wherein the terminal device displays the image returned by the rendering server through a preset front-end H5 component.

7. The rendering system according to claim 1, further comprising: Platform server; The platform server receives a rendering request sent by the terminal device, determines, based on the rendering request, a server in the server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and returns connection information corresponding to the rendering server to the terminal device, wherein the connection information includes a server IP address and a port number of the rendering server; The terminal device establishes a communication connection with the rendering server according to the connection information.

8. The rendering system according to claim 7, wherein the platform server parses the rendering request to determine the device information of the terminal device contained in the rendering request, and determines whether the terminal device is qualified for rendering based on the device information and a preset device list; if it is determined that the device list contains the device information of the terminal device, then it is determined that the terminal device is qualified for rendering, so as to determine a server from the server cluster for executing the rendering task corresponding to the rendering request.

9. The rendering system as described in claim 7, wherein the platform server receives an application package containing the SDK, verifies the application package, and when it is determined that the application package passes the verification, sends the application package to each server included in the server cluster, so that each server replaces the local original application package with the application package to mount the SDK.

10. The rendering system according to any one of claims 1 to 9, wherein the server cluster system is a Linux system, and the SDK comprises: Unity SDK.

11. A method for executing a rendering task, the method being applied to a rendering server executing a rendering task in a server cluster, comprising: Create a simulated touch screen through the pre-installed software development kit SDK; intercepting, by means of the simulated touch screen, a data packet sent by the terminal device, and parsing the data packet to parse attribute information of a plurality of touch points, wherein the data packet is obtained by the terminal device encapsulating a plurality of touch instructions, the plurality of touch instructions being generated in response to a plurality of touch operations performed by a user in a frame of image displayed by the terminal device, the plurality of touch instructions recording attribute information of the plurality of touch points touched by the user in the frame of image; By means of the simulated touch screen, touch events for the multiple touch operations are simulated and generated according to the attribute information of the multiple touch points; According to the touch event, a screen to be displayed after the user performs the multiple touch operations is rendered as a target screen, and the target screen is returned to the terminal device.

12. The method according to claim 11, wherein mounting the SDK comprises: Receive an application package containing the SDK; The original application package in the server is replaced by the application package to mount the SDK.

13. The method according to claim 11, before rendering the screen to be displayed after the user performs the multiple touch operations according to the touch event, the method further comprises: Creating a rendering container group for the user according to the SDK, wherein the rendering container group is used to create a running environment for executing the rendering task required by the user and manage computing resources for executing the rendering task required by the user; Rendering, according to the touch event, a screen to be displayed after the user performs the multiple touch operations, specifically includes: The screen to be displayed after the user performs the multiple touch operations is rendered according to the rendering container group and the touch event.

14. The method according to claim 11, wherein, based on the touch event, rendering the screen to be displayed after the user performs the plurality of touch operations comprises: Obtaining user information of the user through the SDK; Determining a user screen element corresponding to the user according to the user information; Rendering a screen to be displayed after the user performs the multiple touch operations according to the touch event and the user screen element.

15. The method according to claim 11, wherein, by using the simulated touch screen, according to the attribute information of the plurality of touch points, simulating and generating touch events for the plurality of touch operations, specifically comprises: determining coordinates corresponding to the plurality of touch points according to the attribute information of the plurality of touch points; Converting the coordinates according to a conversion relationship between the screen size of the frame and the screen size corresponding to the simulated touch screen to obtain converted coordinates corresponding to the multiple touch points; According to the converted coordinates, touch events for the multiple touch operations are simulated and generated through the simulated touch screen.

16. The method according to claim 11, wherein the terminal device displays the image returned by the rendering server through a preset front-end H5 component.

17. The method according to any one of claims 11 to 16, wherein the server cluster system is a Linux system, and the SDK comprises: Unity SDK.

18. A rendering task execution method, the method being applied to a platform server, comprising: Receive rendering requests sent by terminal devices; According to the rendering request, determining a server from a server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and returning connection information corresponding to the rendering server to the terminal device, so that the terminal device establishes a communication connection with the rendering server according to the connection information, and sends a data packet to the rendering server based on the communication connection, and the rendering server executes the rendering task based on the data packet; The connection information includes the server IP and port number of the rendering server, the data packet is obtained by the terminal device encapsulating multiple touch instructions, the multiple touch instructions are generated based on multiple touch operations performed by the user in a frame of image displayed by the terminal device, and the multiple touch instructions record attribute information of multiple touch points touched by the user in the frame of image; During the execution of the rendering task, the rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates the generation of touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen according to the touch events, and returns the target screen to the terminal device.

19. The method of claim 18, before determining, based on the rendering request, from a server cluster a server for executing a rendering task corresponding to the rendering request, the method further comprising: Parsing the rendering request to determine device information of the terminal device included in the rendering request; Determining whether the terminal device is qualified for rendering based on the device information and a preset device list; Determining, according to the rendering request, a server from a server cluster for executing a rendering task corresponding to the rendering request, specifically comprising: If it is determined that the device list contains the device information of the terminal device, it is determined that the terminal device has rendering qualifications, so as to determine a server from the server cluster for executing the rendering task corresponding to the rendering request.

20. The method according to claim 18, before receiving the rendering request sent by the terminal device, the method further comprises: Receive an application package containing the SDK; Verifying the application package; When it is determined that the application package passes the verification, the application package is sent to each server included in the server cluster, so that each server replaces the local original application package with the application package to mount the SDK.

21. The method according to any one of claims 18 to 20, wherein the server cluster system is a Linux system, and the SDK comprises: Unity SDK.

22. A rendering task execution device, comprising: Create a module for creating a simulated touch screen through the pre-installed software development kit SDK; a parsing module, configured to intercept, via the simulated touch screen, a data packet sent by the terminal device and parse the data packet to obtain attribute information of a plurality of touch points, wherein the data packet is obtained by the terminal device encapsulating a plurality of touch instructions, the plurality of touch instructions being generated in response to a plurality of touch operations performed by a user in a frame of image displayed by the terminal device, the plurality of touch instructions recording attribute information of the plurality of touch points touched by the user in the frame of image; a simulation module, configured to simulate and generate touch events for the multiple touch operations according to the attribute information of the multiple touch points through the simulated touch screen; A rendering module is used to render, according to the touch event, a picture to be displayed after the user performs the multiple touch operations as a target picture, and return the target picture to the terminal device.

23. A rendering task execution device, comprising: A receiving module, used to receive a rendering request sent by a terminal device; a determination module configured to determine, based on the rendering request, a server from a server cluster for executing a rendering task corresponding to the rendering request as the rendering server, and return connection information corresponding to the rendering server to the terminal device, so that the terminal device establishes a communication connection with the rendering server based on the connection information, and sends a data packet to the rendering server based on the communication connection, so that the rendering server executes the rendering task based on the data packet; The connection information includes the server IP and port number of the rendering server, the data packet is obtained by the terminal device encapsulating multiple touch instructions, the multiple touch instructions are generated based on multiple touch operations performed by the user in a frame of image displayed by the terminal device, and the multiple touch instructions record attribute information of multiple touch points touched by the user in the frame of image; During the execution of the rendering task, the rendering server creates a simulated touch screen through a pre-mounted software development kit SDK, intercepts and parses the data packet through the simulated touch screen to parse out the attribute information of the multiple touch points, and simulates the generation of touch events for the multiple touch operations based on the attribute information of the multiple touch points through the simulated touch screen, so as to render the screen to be displayed by the user after performing the multiple touch operations as the target screen according to the touch events, and returns the target screen to the terminal device.

24. A computer-readable storage medium having computer instructions stored thereon, which, when executed by a processor, implement the steps of the method according to any one of claims 11 to 17 or 18 to 21.

25. A computer program product comprising a computer program / instructions, which, when executed by a processor, implement the steps of the method according to any one of claims 11 to 17 or 18 to 21.

Images