Graph rendering method and device
By intercepting and sending the graphical rendering interface call information on the cloud server to the physical terminal for processing, the problems of high resource cost and large network bandwidth of the cloud server are solved, and efficient graphical rendering and data transmission are achieved.
Patent Information
- Application Number
- CN202410990635.4
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-07-22
- Publication Date
- 2024-11-19
AI Technical Summary
In the prior art, cloud servers require a large number of graphics processor resources for cloud rendering, which leads to high costs and limits the popularity of virtual terminals. The network transmits video data with high bandwidth, which increases the traffic costs of users and providers.
By intercepting the graphic rendering interface call information of the target application on the cloud server and sending it to the physical terminal for processing, the physical terminal uses the graphics processor to execute rendering instructions, simplifying the cloud rendering process, and compressing and asynchronous data if necessary to reduce transmission bandwidth.
It realizes graphics rendering without the graphics processor in the cloud server, reduces cloud server resource costs, and improves network transmission efficiency through data compression and asynchronous processing and reduces bandwidth requirements.
Smart Images

Figure CN118982452A_ABST
Abstract
Description
Technical Field
[0001] The embodiments of this specification relate to the field of computer technology, and in particular, to a graphics rendering method and device. Background Art
[0002] With the advent of the 5G era, low-latency and high-bandwidth networks have made it possible to put virtual terminals (such as virtual phones) running on cloud servers into practical use. Currently, virtual terminals can run operating systems and applications involving graphics rendering, and users can use physical terminals to access the applications, which can transmit cloud-rendered images to the physical terminals using high-speed, low-latency networks.
[0003] There is an urgent need for a reasonable and reliable solution that can simplify the cloud rendering process and reduce the resource costs of cloud servers. Summary of the invention
[0004] The embodiments of this specification provide a graphics rendering solution that can simplify the cloud rendering process and reduce the resource cost of the cloud server.
[0005] In a first aspect, an embodiment of the present specification provides a graphics rendering method, which is executed by a cloud server running a virtual terminal, in which a target application is installed. The method comprises: when a user uses a physical terminal including a graphics processor to access the target application, intercepting first call information of the target application calling a graphics rendering interface, which includes a first rendering instruction and related first data; sending the first call information to the physical terminal so that the physical terminal uses the graphics processor to execute the first rendering instruction according to the first data.
[0006] In some embodiments, sending the first call information to the entity terminal includes: compressing the first data to obtain a compression result; and sending the first rendering instruction and the compression result to the entity terminal.
[0007] In some embodiments, the cloud server and the physical terminal cache historical vertex data corresponding to the same handle, and the first data includes updated vertex data corresponding to the same handle; the compressing the first data to obtain a compression result includes: performing an XOR operation on the historical vertex data and the updated vertex data to obtain an operation result; compressing the operation result to obtain a first compression result.
[0008] In some embodiments, the compression processing of the operation result includes: for a byte stream formed by multiple consecutive identical bytes in the operation result, using a target marker to replace all bytes in the byte stream except the starting byte; wherein the target marker includes the position of the starting byte in the operation result and the length of the byte stream.
[0009] In some embodiments, the first data includes texture data; and compressing the first data to obtain a compression result includes: compressing the texture data using a lossless image compression algorithm to obtain a second compression result.
[0010] In some embodiments, the first data includes texture data; the method further includes: performing a hash calculation on the texture data to obtain a hash value; determining whether the hash value is cached locally; sending the first call information to the entity terminal includes: in response to determining that the hash value is not cached locally, caching the hash value locally, and sending the first call information and the hash value to the entity terminal, so that the entity terminal associates the hash value and the texture data with each other.
[0011] In some embodiments, the method further includes: in response to determining that the hash value is cached locally, sending the first rendering instruction and the hash value to the physical terminal, wherein the hash value is used by the physical terminal to obtain the texture data cached therein.
[0012] In some embodiments, the method also includes: using a preset instruction identification strategy to determine whether the first rendering instruction is a rendering instruction that can be executed asynchronously; wherein the instruction identification strategy includes description information for the rendering instructions that can be executed asynchronously; and sending the first call information to the entity terminal includes: in response to determining that the first rendering instruction is not a rendering instruction that can be executed asynchronously, sending the first call information to the entity terminal.
[0013] In some embodiments, before intercepting the first call information of the target application calling the graphics rendering interface, it also includes: intercepting the second call information of the target application calling the graphics rendering interface, which includes a second rendering instruction and related second data; using the instruction identification strategy to determine whether the second rendering instruction is a rendering instruction that can be executed asynchronously; in response to determining that the second rendering instruction is a rendering instruction that can be executed asynchronously, generating a virtual handle for the second data, returning the virtual handle to the target application, and caching the second call information and the virtual handle; sending the first call information to the physical terminal includes: sending the first call information and the second call information to the physical terminal.
[0014] In some embodiments, after sending the first call information and the second call information to the entity terminal, it also includes: receiving a real handle generated for the second data from the entity terminal; and associating the real handle with the virtual handle for caching.
[0015] In some embodiments, after the real handle is associated with the virtual handle for caching, it also includes: intercepting third call information of the target application calling the graphics rendering interface, which includes a third rendering instruction and related third data; using the instruction identification strategy to determine whether the third rendering instruction is a rendering instruction that can be executed asynchronously; in response to determining that the third rendering instruction is not a rendering instruction that can be executed asynchronously, if the virtual handle exists in the third data, replacing the virtual handle in the third data with the real handle, and sending the updated third call information to the physical terminal.
[0016] In some embodiments, sending the first call information and the second call information to the entity terminal includes: compressing the first data and the second data respectively, and replacing the first data in the first call information and the second data in the second call information with corresponding compression results; encapsulating the updated first call information and the second call information to obtain an encapsulation result; wherein the encapsulation result includes the aggregation result of the updated first call information and the second call information according to the order of instruction calls, and header information added to the aggregation result, and the header information includes the respective lengths of the updated first call information and the second call information; and sending the encapsulation result to the entity terminal.
[0017] In some embodiments, the header information further includes at least one of the following: a compression algorithm used in the compression process, the original length of each of the first call information and the second call information, and the number of call information.
[0018] In some embodiments, several first rendering threads are created in the cloud server, and several second rendering threads corresponding to the several first rendering threads are created in the physical terminal; sending the first call information to the physical terminal includes: determining a target thread among the several first rendering threads, and sending the first call information by the target thread to the second rendering thread corresponding to the target thread in the physical terminal.
[0019] In some embodiments, a first control thread is also created in the cloud server, and a second control thread is also created in the physical terminal. The several first rendering threads are created by the cloud server using the first control thread, and the several second rendering threads are created by the second control thread after receiving relevant control information sent by the cloud server through the first control thread.
[0020] In some embodiments, the virtual terminal includes a virtual mobile phone, and the physical terminal includes a physical mobile phone; or, the virtual terminal includes a virtual tablet computer, and the physical terminal includes a physical tablet computer; or, the virtual terminal includes a virtual game console, and the physical terminal includes a physical game console.
[0021] In some embodiments, the target application comprises a gaming application.
[0022] In some embodiments, the cloud server does not have a graphics processor.
[0023] In a second aspect, an embodiment of the present specification provides a graphics rendering method, involving a physical terminal including a graphics processor and a cloud server running a virtual terminal, wherein a target application is installed in the virtual terminal, and the method comprises: during a process in which a user uses the physical terminal to access the target application, the cloud server intercepts first call information of the target application calling a graphics rendering interface, which includes a first rendering instruction and related first data; the cloud server sends the first call information to the physical terminal; and the physical terminal uses the graphics processor to execute the first rendering instruction according to the first data.
[0024] In a third aspect, an embodiment of the present specification provides a graphics rendering device, which is applied to a cloud server running a virtual terminal, in which a target application is installed. The device includes: an interception unit, configured to intercept first call information of the target application calling a graphics rendering interface during a process in which a user uses a physical terminal including a graphics processor to access the target application, wherein the first call information includes a first rendering instruction and related first data; a sending unit, configured to send the first call information to the physical terminal, so that the physical terminal uses the graphics processor to execute the first rendering instruction according to the first data.
[0025] In a fourth aspect, an embodiment of the present specification provides a computer-readable storage medium having a computer program stored thereon, wherein when the computer program is executed in a computer, the computer is caused to execute the method described in any implementation manner in the first aspect.
[0026] In a fifth aspect, an embodiment of the present specification provides a computing device, including a memory and a processor, wherein the memory stores executable code, and when the processor executes the executable code, the method described in any implementation manner in the first aspect is implemented.
[0027] In a sixth aspect, an embodiment of the present specification provides a computer program product, including a computer program / instruction, which, when executed by a processor, implements the method described in any implementation manner in the first aspect.
[0028] The solution provided by the above-mentioned embodiments of this specification relates to a physical terminal including a graphics processing unit (GPU) and a cloud server running a virtual terminal, in which a target application is installed. In this solution, when a user uses a physical terminal to access a target application, the cloud server intercepts the call information of the target application calling a graphics rendering interface, and sends the call information to the physical terminal, so that the physical terminal uses the graphics processor to execute the rendering instructions in the call information, and the rendering operations that need to rely on the graphics processor can be put on the physical terminal side for execution, which can simplify the cloud rendering process and make the cloud server do not need to have any graphics processor resources. In addition, compared with transmitting the image rendered in the cloud, transmitting the call information of calling the graphics rendering interface to the physical terminal can effectively reduce the transmission bandwidth. In summary, this solution can simplify the cloud rendering process and reduce the resource cost of the cloud server. BRIEF DESCRIPTION OF THE DRAWINGS
[0029] In order to more clearly illustrate the technical solutions of the multiple embodiments disclosed in this specification, the drawings required for the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only the multiple embodiments disclosed in this specification. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.
[0030] Figure 1 It is a schematic diagram of an application scenario in which the embodiments of this specification can be applied;
[0031] Figure 2 is a timing diagram of the graphics rendering method in the embodiment of this specification;
[0032] Figure 3 is a schematic diagram of a communication method between a cloud server and a physical terminal in an embodiment of this specification;
[0033] Figure 4 is a schematic diagram of a compression processing process for updating vertex data in an embodiment of this specification;
[0034] Figure 5is another timing diagram of the graphics rendering method in the embodiment of this specification;
[0035] Figure 6 is another timing diagram of the graphics rendering method in the embodiment of this specification;
[0036] Figure 7 is a schematic diagram of the encapsulation syntax procedure in the embodiments of this specification;
[0037] Figure 8 It is a structural diagram of a graphics rendering device in an embodiment of this specification. DETAILED DESCRIPTION
[0038] The present invention is further described in detail below in conjunction with the accompanying drawings and embodiments. It is to be understood that the specific embodiments described herein are only used to explain the relevant invention, rather than to limit the invention. The described embodiments are only part of the embodiments of the present invention, rather than all of the embodiments. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in the field without creative work are within the scope of protection of this application.
[0039] It should be noted that, for the convenience of description, only the parts related to the invention are shown in the drawings. In the absence of conflict, the embodiments and features in the embodiments in this specification can be combined with each other.
[0040] As mentioned earlier, currently, the virtual terminal on the cloud server can run the operating system and applications involving graphics rendering. Users can access the application using a physical terminal, and the application can transmit the cloud-rendered images to the physical terminal using a high-speed, low-latency network.
[0041] Virtual terminals have inherent limitations. Cloud rendering requires a dedicated graphics processor so that the graphics data can be encoded into video data and transmitted to the physical terminal through the network to achieve the presentation of the picture. This requires the providers of virtual terminals to have huge graphics processor resources invested in cloud servers. The expensive graphics processors invested in cloud servers have greatly increased the cost, which will force the provider to raise the threshold and price of virtual terminals and limit the scope of consumers. The existence of these unfavorable factors in turn hinders the development of the entire virtual terminal industry. On the other hand, transmitting video data through the network requires a large network bandwidth, which forces users and providers to bear the high traffic costs alone.
[0042] Based on the above considerations, the embodiments of this specification provide a graphics rendering solution that can simplify the cloud rendering process and reduce the resource cost of the cloud server.
[0043] Figure 11 is a schematic diagram of an application scenario in which the embodiments of the present specification can be applied. The application scenario involves a cloud server 101, a virtual terminal 102 running on the cloud server 101, a physical terminal 103, and a graphics processor 104 included in the physical terminal 103.
[0044] In actual applications, the virtual terminal 102 may be a virtual mobile terminal, and the physical terminal 103 may be a physical mobile terminal. As an example, the virtual terminal 102 is a virtual mobile phone, and the physical terminal 103 is a physical mobile phone; or, the virtual terminal 102 is a virtual tablet computer, and the physical terminal 103 is a physical tablet computer; or, the virtual terminal 102 is a virtual game console, and the physical terminal 103 is a physical game console, etc. It should be noted that the virtual terminal in the embodiments of this specification may be referred to as a cloud terminal; taking a virtual mobile phone as an example, the virtual mobile phone may be referred to as a cloud phone.
[0045] The virtual terminal 102 is implemented based on cloud computing technology and provides cloud services through the cloud server 101. The virtual terminal 102 runs an operating system and has a target application installed. When the virtual terminal 102 is a virtual mobile terminal, the operating system may be referred to as a mobile operating system. The mobile operating system may be any known operating system, for example, including but not limited to the Android operating system, which is not specifically limited here.
[0046] The target application can be any category of application involving graphics rendering. For example, the target application may include video applications or game applications, etc. The game application may be called a cloud game. In addition, the target application can call a graphics rendering interface, such as specifically calling a rendering instruction included in the graphics rendering interface. The rendering instruction may be called a rendering function. In one example, the graphics rendering interface may be an OpenGL (Open Graphics Library) interface. Among them, OpenGL is a cross-language, cross-platform application programming interface for rendering 2D and 3D vector graphics. It should be noted that the cloud server 101 may not have a graphics processor, and the target application can call the graphics rendering interface without the support of a graphics processor, and then perform graphics drawing at the remote end (ie, the physical terminal 103).
[0047] The physical terminal 103 is installed with a client application capable of accessing the virtual terminal 102 . The user of the physical terminal 103 can access the virtual terminal 102 through the client application and operate the target application in the virtual terminal 102 .
[0048] When the user uses the physical terminal 103 to access the target application in the virtual terminal 102, the target application can call the graphics rendering interface based on the graphics rendering trigger operation performed by the user. The cloud server 101 can intercept the call information of the target application calling the graphics rendering interface, and the call information includes the rendering instruction and related data. The related data serves as the input parameter of the rendering instruction. The related data may include resource data or non-resource data. The resource data may include vertex data and / or texture data. The non-resource data may include data for initializing or updating the context, etc. Afterwards, the cloud server 101 can Figure 1 As shown in , the calling information is sent to the physical terminal 103, so that the physical terminal 103 uses the graphics processor 104 to execute the rendering instruction, such as executing the rendering instruction according to the related data.
[0049] The following is a detailed description of the graphics rendering solution provided by the embodiments of this specification in conjunction with some drawings. It should be noted that in order to distinguish different call information, different rendering instructions, and different data, the words "first", "second", "third", etc. will be used to distinguish them. It should be understood that the words only serve to distinguish information and do not have any limiting effect.
[0050] See also Figure 2 , which is a timing diagram of the graphics rendering method in the embodiment of this specification. The method includes steps S201-S205 as shown below.
[0051] like Figure 2 As shown, in step S201, when a user uses a physical terminal 103 including a graphics processor 104 to access a target application installed in a virtual terminal 102, a cloud server 101 running the virtual terminal 102 intercepts first call information of the target application calling a graphics rendering interface, which includes a first rendering instruction and related first data.
[0052] The first rendering instruction may be any rendering instruction in the graphics rendering interface. The first data serves as an input parameter of the first rendering instruction. The first data may include resource data or non-resource data as described above.
[0053] Next, in step S203 , the cloud server 101 sends first calling information to the physical terminal 103 .
[0054] It should be noted that the cloud server 101 can create Figure 3 The first rendering threads shown in FIG. 1 and FIG. 2 may be created in the entity terminal 103 as follows: Figure 3 The plurality of second rendering threads shown in corresponds to the plurality of first rendering threads. Figure 3It is a schematic diagram of the communication method between the cloud server and the physical terminal in the embodiment of this specification. The first rendering thread can communicate with the corresponding second rendering thread through a network, such as performing socket communication. Socket is the cornerstone of communication and is the basic operating unit of network communication that supports the TCP / IP (Transmission Control Protocol / Internet Protocol) protocol.
[0055] When the cloud server 101 sends the first call information to the entity terminal 103, the target thread can be determined from the above-mentioned several first rendering threads, and the target thread sends the first call information to the second rendering thread corresponding to the target thread in the entity terminal 103. Among them, the cloud server 101 can determine the target thread in various implementation methods. For example, the above-mentioned several first rendering threads can be used for rendering all parts (such as characters, backgrounds, etc.), and the cloud server 101 can randomly select a first rendering thread from the above-mentioned several first rendering threads as the target thread. For another example, the above-mentioned several first rendering threads can be used for rendering different parts, and the cloud server 101 can determine the target thread from the above-mentioned several first rendering threads based on the first call information.
[0056] In one embodiment, the cloud server 101 may also create Figure 3 The first control thread shown in FIG. 104 may also be created in the entity terminal 103 as shown in FIG. Figure 3 The second control thread shown in . Network communication, such as socket communication, can be performed between the first control thread and the second control thread. The above-mentioned several first rendering threads can be created by the cloud server 101 using the first control thread. The first control thread can also be responsible for sending relevant control information to the second control thread, and can also receive control information from the second control thread, and perform corresponding actions. Among them, the control information may, for example, include but is not limited to information related to the initialization of the underlying interface of the graphics rendering interface. As an example, when the graphics rendering interface is an OpenGL interface, the underlying interface may, for example, be EGL (Embedded Graphics Library). EGL is generally an interface between an OpenGL interface and a native window system. The above-mentioned several second rendering threads can be created by the second control thread after receiving the relevant control information sent by the cloud server 101 through the first control thread.
[0057] It should be noted that by creating a first control thread and several first rendering threads in the cloud server 101, and creating a second control thread and several second rendering threads in the physical terminal 103, all graphics drawing data can be directly transmitted between the corresponding rendering threads of the cloud server 101 and the physical terminal 103, without passing through the first control thread and the second control thread. In this way, the separation of the control channel and the data channel can be achieved, and the blockage generated during actual drawing will not affect the data transmission of the control channel.
[0058] Next, in step S205 , the physical terminal 103 uses the graphics processor 104 to execute the first rendering instruction according to the first data.
[0059] In one implementation, in order to optimize network transmission efficiency, in step S203, the cloud server 101 may compress the first data to obtain a compression result, and send the first rendering instruction and the compression result to the physical terminal 103; for example, the cloud server 101 may use the compression result to replace the first data in the first call information, and send the updated first call information to the physical terminal 103. Then, the physical terminal 103 may decompress the compression result to obtain the first data, and then execute step S205.
[0060] Furthermore, since resource data usually has a large amount of data, the cloud server 101 can compress the resource data when the first data includes the resource data.
[0061] In practice, vertex data has a special property when the application is running: the actual data of the same vertex buffer object is usually updated multiple times when the application is executed. In most cases, the data of the two vertex buffer updates are often redundant. By using this property, the vertex data can be incrementally updated to reduce a considerable amount of data transmission.
[0062] Specifically, as an implementation method, when the cloud server 101 and the physical terminal 103 cache historical vertex data corresponding to the same handle, and the first data includes updated vertex data corresponding to the same handle, the cloud server 101 can perform an exclusive OR (XOR) operation on the historical vertex data and the updated vertex data, such as a byte-by-byte exclusive OR operation, to obtain an operation result, and then compress the operation result to obtain a first compressed result. Wherein, when compressing the operation result, for example, for a byte stream formed by a plurality of consecutive identical bytes in the operation result, a target tag can be used to replace all bytes in the byte stream except the starting byte. The target tag includes the position of the starting byte in the operation result and the length of the byte stream. Using this compression method, compression can be performed at an extremely low compression rate. In an example, this compression method can be implemented by a gzip compression algorithm. In addition, after the first compression result is transmitted to the physical terminal 103, the physical terminal 103 may first decompress the first compression result to restore the operation result, and then perform an XOR operation on the operation result and the historical vertex data to obtain the updated vertex data.
[0063] Next, combine Figure 4 , an example is given to illustrate the compression process of updating vertex data. Figure 4 FIG. 1 is a schematic diagram of the compression processing process of updating vertex data in the embodiment of this specification. Assume that the above historical vertex data is as follows Figure 4 The vertex data indicated by the middle mark ① is "...0AC4638...", and the updated vertex data of the above historical vertex data is as follows Figure 4 The vertex data “…0AC463A…” indicated by label ② can obtain the operation result “…0000002…” by performing XOR operation on the vertex data indicated by labels ① and ② respectively. Afterwards, by performing gzip compression processing on the operation result, the byte stream “000000” formed by multiple consecutive 0s in the operation result can be compressed into “0(1, 6)”, thereby obtaining the compressed result of the operation result “…0(1, 6)2…”. It should be pointed out that the “0” in “0(1, 6)” is the starting byte of the byte stream, and “(1, 6)” can be called the target mark, the “1” in the target mark is the position of the starting byte in the operation result, and the “6” in the target mark is the length of the byte stream.
[0064] According to the description in the foregoing, the first data may include texture data. As an implementation method, when the first data includes texture data, the cloud server 101 can use a lossless image compression algorithm to compress the texture data to obtain a second compression result. The lossless image compression algorithm includes but is not limited to the QOI (The Quite OK Image Format) lossless compression algorithm. After the second compression result is transmitted to the entity terminal 103, the entity terminal 103 can use the decompression algorithm corresponding to the lossless image compression algorithm to decompress the second compression result to obtain the texture data.
[0065] Figure 2 The solution provided by the corresponding embodiment involves a physical terminal including a graphics processor and a cloud server running a virtual terminal, in which a target application is installed. In this solution, when a user uses a physical terminal to access a target application, the cloud server intercepts the call information of the target application calling a graphics rendering interface, and sends the call information to the physical terminal, so that the physical terminal uses the graphics processor to execute the rendering instructions in the call information, and can put the rendering operations that need to rely on the graphics processor to be executed on the physical terminal side, which can simplify the cloud rendering process and make the cloud server do not need to have any graphics processor resources. In addition, compared with transmitting the cloud-rendered image, transmitting the call information of calling the graphics rendering interface to the physical terminal can effectively reduce the transmission bandwidth. In summary, this solution can simplify the cloud rendering process and reduce the resource cost of the cloud server.
[0066] In one embodiment, in order to further improve network transmission efficiency, the physical terminal 103 can cache the received texture data and the hash value of the texture data. When the rendering instruction subsequently called by the target application takes the texture data as an input parameter, the cloud server 101 can transmit the hash value of the texture data to the physical terminal 103, so that the physical terminal 103 obtains the cached texture data based on the hash value.
[0067] Next, taking the first data as texture data Td as an example, Figure 5 , introduces the graphics rendering process. Among them, Figure 5 is another timing diagram of the graphics rendering method in the embodiment of this specification. The method includes steps S501-S517 as shown below.
[0068] like Figure 5 As shown, in step S501, when a user uses a physical terminal 103 including a graphics processor 104 to access a target application installed in a virtual terminal 102, a cloud server 101 running the virtual terminal 102 intercepts first call information of the target application calling a graphics rendering interface, which includes a first rendering instruction and related texture data Td.
[0069] For the explanation of step S501, please refer to the relevant description in the previous text, which will not be repeated here.
[0070] Next, in step S503 , the cloud server 101 performs hash calculation on the texture data Td to obtain a hash value hash1 .
[0071] It should be noted that the cloud server 101 can use any known hash algorithm to perform hash calculation on the texture data Td, and the hash algorithm used is not specifically limited here.
[0072] Next, in step S505 , the cloud server 101 determines whether hash1 is cached locally.
[0073] In practice, for the texture data that the cloud server 101 has sent to the physical terminal 103, the cloud server 101 has cached the hash value of the texture data, and the physical terminal 103 has cached the hash value and the texture data corresponding to the hash value. Based on this, after calculating hash1, the cloud server 101 can search for hash1 in the locally cached hash values. If found, it can be determined that hash1 is cached locally, so that it is known that the physical terminal 103 has cached the texture data Td corresponding to hash1, and then step S507 is executed. If not found, it can be determined that hash1 is not cached locally, so that it is known that the physical terminal 103 does not cache the texture data Td corresponding to hash1, and then steps S511 and S513 are executed.
[0074] In step S507 , in response to the determination result of step S505 being yes, the cloud server 101 sends the first rendering instruction and hash1 to the entity terminal 103 .
[0075] After executing step S507, the entity terminal 103 may execute steps S509 and S517.
[0076] In step S509 , the physical terminal 103 obtains the texture data Td associated with the hash1 cache from the local.
[0077] In step S511 , in response to the determination result of step S505 being negative, the cloud server 101 caches hash1 locally.
[0078] In step S513 , the cloud server 101 sends the first call information and hash1 to the entity terminal 103 .
[0079] It should be noted that when executing step S507 or step S513, the first rendering thread and the second rendering thread as described above can be used to transmit information. For the specific transmission process, please refer to the relevant description in the above text, which will not be repeated here.
[0080] After executing step S513, the entity terminal 103 may execute steps S515 and S517.
[0081] In step S515, the entity terminal 103 associates and caches hash1 and texture data Td.
[0082] In one implementation, in order to further improve network transmission efficiency, in step S513, a lossless image compression algorithm may be used to compress the texture data Td to obtain a compression result, and the first rendering instruction, the compression result, and hash1 are sent to the entity terminal 103. The entity terminal 103 may first use a decompression algorithm corresponding to the above-mentioned lossless image compression algorithm to decompress the compression result to obtain the texture data Td, and then perform associated caching of hash1 and the texture data Td by executing step S515.
[0083] In step S517 , the physical terminal 103 uses the graphics processor 104 to execute the first rendering instruction according to the texture data Td.
[0084] Figure 5 The solution provided by the corresponding embodiment can simplify the cloud rendering process and reduce the resource cost of the cloud server by intercepting the call information of the target application calling the graphics rendering interface and making the rendering instructions in the call information executed on the physical terminal side. In addition, the solution can enable the physical terminal to cache the received texture data and the hash value of the texture data, so that when the rendering instruction subsequently called by the target application takes the texture data as an input parameter, the cloud server replaces the texture data with the corresponding hash value and transmits it to the physical terminal, which can greatly improve the network transmission efficiency.
[0085] In the graphics rendering solution provided in the embodiments of this specification, data is transmitted between the cloud server and the physical terminal through the network. If the cloud server and the physical terminal always wait for each other to execute and return for each graphics rendering call, the entire rendering process will be extremely slowed down. In order to improve the drawing efficiency, in this solution, it is possible to consider distinguishing between synchronous execution and asynchronous execution for each rendering instruction in the graphics rendering interface. Through fine synchronous and asynchronous regulation, the rendering instructions can be replayed in the physical terminal and the picture can be rendered smoothly.
[0086] Among them, for rendering instructions that need to be executed synchronously, after intercepting the call information containing the rendering instruction, the call information should be sent to the physical terminal immediately. For rendering instructions that can be executed asynchronously, after intercepting the call information c1 containing the rendering instruction, the cloud server can generate a virtual execution result for the rendering instruction (such as a virtual handle generated for the relevant data of the rendering instruction), and return the virtual execution result to the target application, and cache the virtual execution result and the call information c1. After caching the call information c1, if new call information c2 is intercepted and the call information c2 includes a rendering instruction that needs to be executed synchronously, the cloud server can send the call information c2 together with the cached and not actually executed call information c1 to the physical terminal.
[0087] In order to enable the cloud server to identify whether the rendering instruction in the intercepted call information is a rendering instruction that can be executed asynchronously, an instruction identification strategy can be pre-configured in the cloud server, and the instruction identification strategy can include description information for the rendering instruction that can be executed asynchronously.
[0088] In one example, the description information may include various rendering instructions that can be executed asynchronously.
[0089] In another example, when the number of rendering instructions that can be executed asynchronously is much larger than the number of rendering instructions that need to be executed synchronously, the instruction identification strategy may include an instruction set formed by the rendering instructions that need to be executed synchronously, and the description information may be used to indicate that the rendering instructions that can be executed asynchronously are not included in the instruction set.
[0090] In another example, when the graphics rendering interface is an OpenGL interface as described above, the rendering instructions in the OpenGL interface can be divided into four categories, including calls that need to get return values immediately (such as glReadGraphicBuffer and glGetShaderSource, etc.), calls that end a frame and perform actual drawing (mainly eglSwapBuffers), calls when there is no OpenGL context (such as eglCreateWindowSurface, glGetStaticValues), and other ordinary calls. Among them, the first three types of rendering instructions need to be executed synchronously, because this is the only way to ensure the correctness of the drawing results. As for the fourth type of rendering instructions, this type of rendering instructions accounts for the vast majority of ordinary calls and can be executed asynchronously. When the rendering instructions are divided into these four categories, the above-mentioned instruction identification strategy can indicate the category to which each rendering instruction belongs in these four categories, and the above-mentioned description information can indicate that the rendering instructions belonging to other ordinary calls are instructions that can be executed asynchronously.
[0091] for Figure 2 In the solution provided by the corresponding embodiment, when the cloud server 101 is preset with the instruction recognition strategy as described above, after intercepting the first call information of the target application calling the graphics rendering interface, the cloud server 101 can use the instruction recognition strategy to determine whether the first rendering instruction is a rendering instruction that can be executed asynchronously. Afterwards, the cloud server 101 can send the first call information to the entity terminal 103 in response to determining that the first rendering instruction is not a rendering instruction that can be executed asynchronously. It should be pointed out that a rendering instruction that cannot be executed asynchronously can be understood as a rendering instruction that needs to be executed synchronously.
[0092] Furthermore, if before intercepting the first call information, a second call information of the target application calling the graphics rendering interface is also intercepted, and the second rendering instruction in the second call information is a rendering instruction that can be executed asynchronously, then the following can be executed: Figure 6 The rendering process shown in Figure 1. Figure 6 It is another timing diagram of the graphics rendering method in the embodiment of this specification. The method includes steps S601-S621 as shown below.
[0093] like Figure 6 As shown, in step S601, when a user uses a physical terminal 103 including a graphics processor 104 to access a target application installed in a virtual terminal 102, a cloud server 101 running the virtual terminal 102 intercepts second call information of the target application calling a graphics rendering interface, which includes a second rendering instruction and related second data.
[0094] Next, in step S603 , the cloud server 101 uses a preset instruction identification strategy to determine whether the second rendering instruction is a rendering instruction that can be executed asynchronously.
[0095] The instruction recognition strategy includes description information for rendering instructions that can be executed asynchronously. For a detailed explanation of the instruction recognition strategy, please refer to the relevant description in the previous text, which will not be repeated here.
[0096] Next, in step S605, in response to the determination result of step S603 being yes, the cloud server 101 generates a virtual handle Vh for the second data.
[0097] The virtual handle Vh may be generated for the second data itself, or may be generated for specific data in the second data, which is not specifically limited here.
[0098] It should be noted that the rendering instructions that can be executed asynchronously are mainly used for context update and graphics resource management. When the second rendering instruction is used for context update, for example, the second rendering instruction is a well-known instruction such as glBindBuffer or glBindTexture, the virtual handle Vh generated for the second data can be called a virtual context handle. When the second rendering instruction is used for graphics resource management, for example, the second rendering instruction is a well-known instruction such as glBufferData or glTexImage2D, the virtual handle Vh generated for the second data can be called a virtual resource handle.
[0099] Next, in step S607, the cloud server 101 returns the virtual handle Vh to the target application.
[0100] Next, in step S609, the cloud server 101 caches the second call information and the virtual handle Vh.
[0101] Next, in step S611, the cloud server 101 intercepts first call information of the target application calling the graphics rendering interface, which includes a first rendering instruction and related first data.
[0102] Next, in step S613 , the cloud server 101 uses a preset instruction identification strategy to determine whether the first rendering instruction is a rendering instruction that can be executed asynchronously.
[0103] Next, in step S615 , in response to the determination result of step S613 being no, the cloud server 101 sends the first calling information and the second calling information to the entity terminal 103 .
[0104] It should be noted that in step S615, the first rendering thread and the second rendering thread as described above can be used to transmit the first call information and the second call information. For the specific transmission process, please refer to the relevant description in the above text, which will not be repeated here.
[0105] Next, in step S617 , the physical terminal 103 utilizes the graphics processor 104 to execute the second rendering instruction according to the second data, and execute the first rendering instruction according to the first data.
[0106] When the physical terminal 103 uses the graphics processor 104 to execute the second rendering instruction according to the second data, it can generate a real handle Rh for the second data and execute step S619.
[0107] In step S619 , the entity terminal 103 returns the real handle Rh generated for the second data to the cloud server 101 .
[0108] Next, in step S621, the cloud server 101 associates the real handle Rh with the virtual handle Vh for caching.
[0109] Among them, the cloud server 101 can use a hash table to maintain the association relationship between the real handle Rh and the virtual handle Vh.
[0110] In one embodiment, in order to improve network transmission efficiency, when sending the first call information and the second call information to the entity terminal 103, the cloud server 101 can compress the first data and the second data respectively, and replace the first data in the first call information and the second data in the second call information with the corresponding compression results. For the specific compression processing process, please refer to the relevant description in the previous text, which will not be repeated here. Afterwards, the cloud server 101 can encapsulate the updated first call information and the second call information, for example, according to Figure 7 The encapsulation syntax procedure shown is used to perform encapsulation processing to obtain an encapsulation result, and the encapsulation result is sent to the entity terminal 103.
[0111] in, Figure 7 Schematic diagram of the packaging syntax process in the embodiment of this specification. Figure 7 As shown, the encapsulation syntax procedure shows the aggregation result of each compressed (updated) call information transmitted in the order of instruction calls, and the header information (Header) added to the aggregation result. Figure 7 The "Call1+compressed call data" and "Call2+compressed call data" shown in the figure both represent compressed call information, "Call1" and "Call2" both represent rendering instructions, and "compressed call data" represents the compression result of the relevant data of the rendering instructions. The header includes the length of each compressed call information. Furthermore, the header can also include the following: Figure 7 At least one of the following items shown in: compression algorithm, length of each (original) call information before compression, and number of call information.
[0112] According to Figure 7 The encapsulation result obtained by encapsulating the updated first call information and the second call information in the encapsulation syntax procedure shown may include an aggregation result of the updated first call information and the second call information according to the instruction call sequence, and header information added to the aggregation result, the header information including the length of the updated first call information and the second call information. Further, the header information may also include at least one of the following: the compression algorithm used in the above compression processing, the length of the original first call information and the second call information, and the number of call information.
[0113] After receiving the encapsulation result as described above, the entity terminal 103 may first parse the header information of the encapsulation result, and then parse the aggregation result in the encapsulation result according to the parsing result, so as to restore the original first call information and the second call information.
[0114] In one implementation, in order to further improve network transmission efficiency, when the first data and / or the second data include texture data, Figure 5 In the corresponding embodiment, the processing process based on the hash value of the texture data is adaptively adjusted and applied to Figure 6 In the corresponding embodiment.
[0115] In one embodiment, after associating the real handle Rh with the virtual handle Vh for caching, the cloud server 101 may also intercept the third call information of the target application calling the graphics rendering interface, which includes the third rendering instruction and the related third data. Afterwards, the cloud server 101 may use the instruction identification strategy as described above to determine whether the third rendering instruction is a rendering instruction that can be executed asynchronously. Then, in response to determining that the third rendering instruction is not a rendering instruction that can be executed asynchronously, the cloud server 101 may replace the virtual handle Vh in the third data with the real handle Rh in the case where the virtual handle Vh exists in the third data, and send the updated third call information to the physical terminal 103. Thus, based on the association relationship between the real handle Rh and the virtual handle Vh, the cloud server 101 and the target application can communicate using the virtual handle Vh, and the cloud server 101 and the physical terminal 103 can communicate using the real handle Rh.
[0116] Figure 6 The solution provided by the corresponding embodiment can simplify the cloud rendering process and reduce the resource cost of the cloud server by intercepting the call information of the target application calling the graphics rendering interface and making the rendering instructions in the call information executed on the physical terminal side. In addition, by asynchronously executing certain rendering instructions, the solution can make it possible for the target application to not need to directly interact with the physical terminal synchronously, solve the problem of drawing blocking caused by long delays in some graphics synchronous calls, and greatly improve drawing efficiency.
[0117] Figure 8It is a structural diagram of the graphics rendering device in the embodiment of this specification. The device can be applied to a cloud server running a virtual terminal, in which a target application is installed. Further, the device can be applied to the virtual terminal. The device includes: an interception unit 801, which is configured to intercept the first call information of the target application calling the graphics rendering interface during the process of the user using the physical terminal including the graphics processor to access the target application, which includes the first rendering instruction and the related first data; a sending unit 802, which is configured to send the first call information to the physical terminal, so that the physical terminal uses the graphics processor to execute the first rendering instruction according to the first data.
[0118] In one implementation, the sending unit 802 may be further configured to: perform compression processing on the first data to obtain a compression result; and send the first rendering instruction and the compression result to the entity terminal.
[0119] In one embodiment, the cloud server and the physical terminal cache historical vertex data corresponding to the same handle, and the first data includes updated vertex data corresponding to the same handle; the sending unit 802 can be further configured to: perform an XOR operation on the historical vertex data and the updated vertex data to obtain an operation result; and compress the operation result to obtain a first compression result.
[0120] In one embodiment, the sending unit 802 can be further configured to: for a byte stream formed by multiple consecutive identical bytes in the above operation result, use a target marker to replace all bytes other than the starting byte in the byte stream; wherein the target marker includes the position of the starting byte in the above operation result and the length of the byte stream.
[0121] In one implementation, the first data includes texture data; the sending unit 802 may be further configured to: compress the texture data using a lossless image compression algorithm to obtain a second compression result.
[0122] In one embodiment, the first data includes texture data; the above-mentioned device may also include: a computing unit (not shown in the figure), configured to perform hash calculation on the texture data to obtain a hash value; a first determination unit (not shown in the figure), configured to determine whether the hash value is cached locally; the sending unit 802 may be further configured to: in response to determining that the hash value is not cached locally, cache the hash value locally, and send the first call information and the hash value to the entity terminal, so that the entity terminal associates the hash value and the texture data with cache.
[0123] In one implementation, the sending unit 802 may also be configured to: in response to determining that the hash value is cached locally, send a first rendering instruction and the hash value to the physical terminal, where the hash value is used by the physical terminal to obtain the texture data cached therein.
[0124] In one embodiment, the above-mentioned device may also include: a second determination unit (not shown in the figure), configured to use a preset instruction identification strategy to determine whether the first rendering instruction is a rendering instruction that can be executed asynchronously; wherein the instruction identification strategy includes description information for the rendering instructions that can be executed asynchronously; the sending unit 802 can be further configured to: in response to determining that the first rendering instruction is not a rendering instruction that can be executed asynchronously, send a first call information to the entity terminal.
[0125] In one embodiment, the interception unit 801 can also be configured to: before intercepting the first call information of the target application calling the graphics rendering interface, intercept the second call information of the target application calling the graphics rendering interface, which includes the second rendering instruction and the related second data; the above-mentioned second determination unit can also be configured to: use the above-mentioned instruction identification strategy to determine whether the second rendering instruction is a rendering instruction that can be executed asynchronously; the generation unit (not shown in the figure) is configured to generate a virtual handle for the second data in response to determining that the second rendering instruction is a rendering instruction that can be executed asynchronously, return the virtual handle to the target application, and cache the second call information and the virtual handle; the sending unit 802 can be further configured to: send the first call information and the second call information to the entity terminal.
[0126] In one embodiment, the above-mentioned device may also include: a receiving unit (not shown in the figure), configured to receive a real handle generated for the second data from a physical terminal; and a cache unit (not shown in the figure), configured to associate the real handle with the above-mentioned virtual handle for caching.
[0127] In one embodiment, the interception unit 801 can also be configured to: after the above-mentioned cache unit associates the above-mentioned real handle with the above-mentioned virtual handle for caching, intercept the third call information of the target application calling the graphics rendering interface, which includes the third rendering instruction and related third data; the above-mentioned second determination unit can also be configured to: use the above-mentioned instruction identification strategy to determine whether the third rendering instruction is a rendering instruction that can be executed asynchronously; the sending unit 802 can also be configured to: in response to determining that the third rendering instruction is not a rendering instruction that can be executed asynchronously, if the above-mentioned virtual handle exists in the third data, replace the above-mentioned virtual handle in the third data with the above-mentioned real handle, and send the updated third call information to the physical terminal.
[0128] In one embodiment, the sending unit 802 can be further configured to: compress the first data and the second data respectively, and replace the first data in the first call information and the second data in the second call information with corresponding compression results; encapsulate the updated first call information and the second call information to obtain an encapsulation result; wherein the encapsulation result includes the aggregation result of the updated first call information and the second call information according to the order of instruction calls, and the header information added to the aggregation result, and the header information includes the respective lengths of the updated first call information and the second call information; and send the encapsulation result to the entity terminal.
[0129] Furthermore, the header information also includes at least one of the following: a compression algorithm used in the above compression process, the length of the original first call information and the second call information, and the number of call information.
[0130] In one embodiment, a plurality of first rendering threads are created in the cloud server, and a plurality of second rendering threads corresponding to the plurality of first rendering threads are created in the physical terminal; the sending unit 802 may be further configured to: determine a target thread from the plurality of first rendering threads, and have the target thread send the first call information to the second rendering thread corresponding to the target thread in the physical terminal.
[0131] In one embodiment, a first control thread is also created in the cloud server, and a second control thread is also created in the physical terminal. The above-mentioned several first rendering threads are created by the cloud server using the first control thread, and the above-mentioned several second rendering threads are created by the second control thread after receiving relevant control information sent by the cloud server through the first control thread.
[0132] In one embodiment, the virtual terminal includes a virtual mobile phone, and the physical terminal includes a physical mobile phone; or, the virtual terminal includes a virtual tablet computer, and the physical terminal includes a physical tablet computer; or, the virtual terminal includes a virtual game console, and the physical terminal includes a physical game console.
[0133] In one embodiment, the target application includes a gaming application.
[0134] In one embodiment, the cloud server does not have a graphics processor.
[0135] The present specification also provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed in a computer, the computer is caused to execute the following Figure 2 , Figure 5 , Figure 6 Describe the method.
[0136] The embodiment of the present specification also provides a computing device, including a memory and a processor, wherein the memory stores an executable code, and when the processor executes the executable code, the following is implemented: Figure 2 , Figure 5 , Figure 6 Describe the method.
[0137] The embodiments of the present specification also provide a computer program product, including a computer program / instruction, which is executed by a processor to implement the following Figure 2 , Figure 5 , Figure 6 Describe the method.
[0138] Those skilled in the art should be aware that in one or more of the above examples, the functions described in the multiple embodiments disclosed in this specification can be implemented by hardware, software, firmware, or any combination thereof. When implemented by software, these functions can be stored in a computer-readable medium or transmitted as one or more instructions or codes on a computer-readable medium.
[0139] In some cases, the actions or steps described in the claims may be performed in a different order than in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or sequential order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
[0140] The specific implementation methods described above further illustrate in detail the purposes, technical solutions and beneficial effects of the multiple embodiments disclosed in this specification. It should be understood that the above description is only the specific implementation methods of the multiple embodiments disclosed in this specification, and is not used to limit the protection scope of the multiple embodiments disclosed in this specification. Any modifications, equivalent substitutions, improvements, etc. made on the basis of the technical solutions of the multiple embodiments disclosed in this specification should be included in the protection scope of the multiple embodiments disclosed in this specification.
Claims
1. A graphics rendering method, executed by a cloud server running a virtual terminal, wherein a target application is installed in the virtual terminal, the method comprising: When a user uses a physical terminal including a graphics processor to access the target application, first call information of the target application calling a graphics rendering interface is intercepted, including a first rendering instruction and related first data; The first calling information is sent to the entity terminal, so that the entity terminal uses the graphics processor to execute the first rendering instruction according to the first data.
2. The method according to claim 1, wherein: The sending the first calling information to the entity terminal includes: compressing the first data to obtain a compression result; Sending the first rendering instruction and the compression result to the entity terminal.
3. The method according to claim 2, wherein: The cloud server and the physical terminal cache historical vertex data corresponding to the same handle, and the first data includes updated vertex data corresponding to the same handle; The compressing the first data to obtain a compression result includes: Performing an XOR operation on the historical vertex data and the updated vertex data to obtain an operation result; The operation result is compressed to obtain a first compression result.
4. The method according to claim 3, wherein: The compressing the operation result includes: For a byte stream formed by a plurality of consecutive identical bytes in the operation result, a target tag is used to replace all bytes in the byte stream except a start byte; wherein the target tag includes the position of the start byte in the operation result and the length of the byte stream.
5. The method according to claim 2, wherein: The first data includes texture data; The compressing the first data to obtain a compression result includes: The texture data is compressed using a lossless image compression algorithm to obtain a second compression result.
6. The method according to claim 1, wherein: The first data includes texture data; The method further comprises: Performing hash calculation on the texture data to obtain a hash value; Determine whether the hash value is cached locally; The sending the first calling information to the entity terminal includes: In response to determining that the hash value is not cached locally, the hash value is cached locally, and the first call information and the hash value are sent to the entity terminal, so that the entity terminal associates the hash value with the texture data for cache.
7. The method according to claim 6, further comprising: In response to determining that the hash value is cached locally, the first rendering instruction and the hash value are sent to the entity terminal, and the hash value is used by the entity terminal to obtain the texture data cached therein.
8. The method according to claim 1, further comprising: Using a preset instruction identification strategy, determining whether the first rendering instruction is a rendering instruction that can be executed asynchronously; wherein the instruction identification strategy includes description information for the rendering instruction that can be executed asynchronously; The sending the first calling information to the entity terminal includes: In response to determining that the first rendering instruction is not a rendering instruction that can be executed asynchronously, the first calling information is sent to the entity terminal.
9. The method according to claim 8, wherein: Before intercepting the first call information of the target application calling the graphics rendering interface, the method further includes: intercepting second call information of the target application calling a graphics rendering interface, which includes a second rendering instruction and related second data; Using the instruction identification strategy, determining whether the second rendering instruction is a rendering instruction that can be executed asynchronously; In response to determining that the second rendering instruction is a rendering instruction that can be executed asynchronously, generating a virtual handle for the second data, returning the virtual handle to the target application, and caching the second call information and the virtual handle; The sending the first calling information to the entity terminal includes: The first calling information and the second calling information are sent to the entity terminal.
10. The method according to claim 9, wherein: After sending the first calling information and the second calling information to the entity terminal, the method further includes: receiving, from the entity terminal, a real handle generated for the second data; The real handle is associated with the virtual handle for caching.
11. The method according to claim 10, wherein: After associating the real handle with the virtual handle for caching, the method further includes: intercepting third call information of the target application calling a graphics rendering interface, including a third rendering instruction and related third data; Using the instruction identification strategy, determining whether the third rendering instruction is a rendering instruction that can be executed asynchronously; In response to determining that the third rendering instruction is not a rendering instruction that can be executed asynchronously, if the virtual handle exists in the third data, the virtual handle in the third data is replaced with the real handle, and the updated third call information is sent to the physical terminal.
12. The method according to claim 9, wherein: The sending the first calling information and the second calling information to the entity terminal includes: compressing the first data and the second data respectively, and replacing the first data in the first call information and the second data in the second call information with corresponding compression results; Encapsulating the updated first call information and the second call information to obtain an encapsulation result; wherein the encapsulation result includes an aggregation result of the updated first call information and the second call information according to the instruction calling sequence, and header information added to the aggregation result, wherein the header information includes the length of each of the updated first call information and the second call information; The encapsulation result is sent to the entity terminal.
13. The method according to claim 12, wherein: The header information also includes at least one of the following: a compression algorithm used in the compression process, the original length of each of the first call information and the second call information, and the number of call information.
14. The method according to claim 1, wherein: A plurality of first rendering threads are created in the cloud server, and a plurality of second rendering threads corresponding to the plurality of first rendering threads are created in the physical terminal; The sending the first calling information to the entity terminal includes: A target thread is determined from the plurality of first rendering threads, and the target thread sends the first call information to a second rendering thread corresponding to the target thread in the entity terminal.
15. The method according to claim 14, wherein: A first control thread is also created in the cloud server, and a second control thread is also created in the physical terminal. The plurality of first rendering threads are created by the cloud server using the first control thread, and the plurality of second rendering threads are created by the second control thread after receiving relevant control information sent by the cloud server through the first control thread.
16. The method according to claim 1, wherein: The virtual terminal includes a virtual mobile phone, and the physical terminal includes a physical mobile phone; or The virtual terminal includes a virtual tablet computer, and the physical terminal includes a physical tablet computer; or, The virtual terminal includes a virtual game console, and the physical terminal includes a physical game console.
17. The method according to claim 1, wherein: The target application includes a game application.
18. The method according to claim 1, wherein: The cloud server does not have a graphics processor.
19. A graphics rendering method, comprising: a physical terminal including a graphics processor and a cloud server running a virtual terminal, wherein a target application is installed in the virtual terminal, the method comprising: When the user uses the physical terminal to access the target application, the cloud server intercepts first call information of the target application calling a graphics rendering interface, which includes a first rendering instruction and related first data; The cloud server sends the first calling information to the physical terminal; The physical terminal uses the graphics processor to execute the first rendering instruction according to the first data.
20. A graphics rendering device, applied to a cloud server running a virtual terminal, wherein a target application is installed in the virtual terminal, the device comprising: An interception unit is configured to intercept first call information of the target application calling a graphics rendering interface, including a first rendering instruction and related first data, when a user uses a physical terminal including a graphics processor to access the target application; The sending unit is configured to send the first calling information to the entity terminal, so that the entity terminal uses the graphics processor to execute the first rendering instruction according to the first data.
21. A computer-readable storage medium having a computer program stored thereon, wherein: When the computer program is executed in a computer, the computer is caused to execute the method according to any one of claims 1 to 18.
22. A computing device comprising a memory and a processor, wherein: The memory stores executable codes, and when the processor executes the executable codes, the method according to any one of claims 1 to 18 is implemented.
Citation Information
Cited By
OpenGL resource optimization method and device, terminal and medium
CN121387425A
