WO2023197762A1

WO2023197762A1 - Image rendering method and apparatus, electronic device, computer-readable storage medium, and computer program product

Info

Publication number: WO2023197762A1
Application number: PCT/CN2023/078405
Authority: WO
Inventors: 连冠荣; 昔文博
Original assignee: 腾讯科技（深圳）有限公司
Priority date: 2022-04-13
Filing date: 2023-02-27
Publication date: 2023-10-19
Also published as: CN114494024B; CN114494024A

Abstract

Embodiments of the present application provide an image rendering method and apparatus, an electronic device, a computer-readable storage medium, and a computer program product, at least applied to the field of image rendering and the technical field of games. The method comprises: obtaining data to be rendered and an index data set, the data to be rendered corresponding to a vertex set; performing, on the basis of the data to be rendered and index data in the index data set, vertex elimination processing on some of vertices in the vertex set to obtain a vertex set to be rendered; and sequentially performing vertex rendering on vertices to be rendered in the vertex set to be rendered to obtain a rendered image.

Description

Image rendering methods, devices, electronic equipment, computer-readable storage media and computer program products

Cross-references to related applications

This application is filed based on a Chinese patent application with application number 202210384063.6 and a filing date of April 13, 2022, and claims the priority of the Chinese patent application. The entire content of the Chinese patent application is hereby incorporated by reference into this application.

Technical field

Embodiments of the present application relate to the field of Internet technology, and relate to but are not limited to an image rendering method, device, electronic equipment, computer-readable storage media, and computer program products.

Background technique

A mesh refers to a structure containing vertices and faces. The mesh is a common method for displaying three-dimensional (3D, 3-dimension) game objects. In 3D game object rendering and display technology, the smallest unit (triangle) in the mesh is usually used. ) performs vertex rendering for the rendering unit. The vertex buffer (VB, Vertex Buffer) is a continuous array of vertex data. In some image rendering scenarios, intermittent vertex rendering of the mesh needs to be performed from the vertex buffer.

In related technologies, when implementing intermittent vertex rendering, it is usually necessary to call multiple draw calls (Drawcall) separately; or, a high-end graphics processor (GPU, Graphics Processing Unit) is required (that is, the rendering performance is higher than that of a conventional GPU). Rendering performance); or, the data to be rendered needs to be filled in VB in real time according to whether the components of the object to be rendered are enabled for rendering. This filling step involves a data copy process.

Obviously, the methods in the related art need to call multiple draw calls when implementing intermittent vertex rendering, which will greatly increase the rendering time and reduce the rendering efficiency; while the graphics drawing interface that requires a high-end GPU has insufficient adaptability. , a problem that is not applicable to all models; at the same time, there will be a certain delay in the data copy process, which will greatly affect the image rendering efficiency. It can be seen that the intermittent vertex rendering methods in related technologies all have the problem of low image rendering efficiency.

Contents of the invention

Embodiments of the present application provide an image rendering method, device, electronic device, computer-readable storage medium and computer program product, which are at least used in the field of image rendering and game technology and can perform vertex processing on some vertices in a vertex set based on index data. Eliminate processing so that intermittent vertex rendering of data to be rendered can be achieved by calling a single draw call, thereby improving image rendering efficiency.

The technical solution of the embodiment of this application is implemented as follows:

An embodiment of the present application provides an image rendering method, which includes:

Obtain data to be rendered and an index data set used to reflect rendering requirement information; the data to be rendered corresponds to a vertex set; based on the data to be rendered and the index data in the index data set, calculate the vertex set in the vertex set Perform vertex elimination processing on some vertices to obtain a set of vertices to be rendered; perform vertex rendering on the vertices to be rendered in the set of vertices to be rendered in order to obtain a rendered image.

An embodiment of the present application provides an image rendering device. The device includes: an acquisition module configured to acquire the to-be- Rendering data and an index data set used to reflect rendering requirement information; the data to be rendered corresponds to a vertex set; an elimination module is configured to eliminate the vertices based on the data to be rendered and the index data in the index data set. Part of the vertices in the set are subjected to vertex elimination processing to obtain a set of vertices to be rendered; a vertex rendering module is configured to sequentially perform vertex rendering on the vertices to be rendered in the set of vertices to be rendered to obtain a rendered image.

An embodiment of the present application provides an electronic device, including: a memory for storing executable instructions; and a processor for implementing the above image rendering method when executing the executable instructions stored in the memory.

Embodiments of the present application provide a computer program product or computer program. The computer program product or computer program includes executable instructions, and the executable instructions are stored in a computer-readable storage medium; wherein, the processor of the electronic device obtains the information from the computer-readable storage medium. When the executable instructions are read and executed, the above image rendering method is implemented.

Embodiments of the present application provide a computer-readable storage medium that stores executable instructions for causing a processor to execute the executable instructions to implement the above image rendering method.

The embodiments of the present application have the following beneficial effects: based on the acquired data to be rendered and the index data in the index data set, vertex elimination processing is performed on some vertices in the vertex set corresponding to the data to be rendered, and a set of vertices to be rendered is obtained. In this way, after The rendering vertex set includes the remaining vertices after vertex elimination processing of the vertex set. For these remaining vertices, vertex rendering can be achieved by calling a draw call, that is, by calling a draw call. Intermittent vertex rendering of vertices in a vertex collection can be implemented. In this way, not only the image rendering efficiency can be improved, but also the intermittent vertex rendering method is suitable for devices with different configurations, thereby improving device adaptability.

Description of the drawings

Figure 1A is a schematic structural diagram of a grid provided by an embodiment of the present application;

Figure 1B is a schematic diagram of the relationship between vertices-face-edges provided by the embodiment of the present application;

Figure 2 is a schematic diagram of intermittent vertex rendering;

Figure 3 is a schematic diagram of calling multiple draw calls for intermittent vertex rendering in related technologies;

Figure 4 is a schematic diagram of intermittent vertex rendering using the graphics rendering interface of a high-end GPU in related technologies;

Figure 5 is a schematic diagram of intermittent vertex rendering through data copying in the related art;

Figure 6 is a schematic diagram of intermittent vertex rendering through multiple renderings in the related art;

Figure 7 is an optional architectural schematic diagram of the image rendering system provided by the embodiment of the present application;

Figure 8 is a schematic structural diagram of an electronic device provided by an embodiment of the present application;

Figure 9 is an optional flow diagram of the image rendering method provided by the embodiment of the present application;

Figure 10 is another optional flow diagram of the image rendering method provided by the embodiment of the present application;

Figure 11 is another optional flow diagram of the image rendering method provided by the embodiment of the present application;

Figure 12A is an original image before rendering of enabling/disabling certain parts of the body according to an embodiment of the present application;

Figure 12B is an image of disabling the rendering of the hair part of the body according to the embodiment of the present application;

Figure 13 is a flow chart of an image rendering method provided by an embodiment of the present application;

Figure 14 is another flow chart of the image rendering method provided by the embodiment of the present application;

Figure 15 is a schematic diagram of the effect of the method according to the embodiment of the present application applied to a low-end machine;

Figure 16 is a schematic diagram of the effect of the method according to the embodiment of the present application applied to a mid-range machine;

Figure 17 is a schematic diagram of the effect of applying the method according to the embodiment of the present application to a high-end machine.

Detailed ways

In order to make the purpose, technical solutions and advantages of the present application clearer, the present application will be described in further detail below in conjunction with the accompanying drawings. The described embodiments should not be regarded as limiting the present application. Those of ordinary skill in the art will not make any All other embodiments obtained under the premise of creative work belong to the scope of protection of this application.

In the following description, reference is made to "some embodiments" which describe a subset of all possible embodiments, but it is understood that "some embodiments" may be the same subset or a different subset of all possible embodiments, and Can be combined with each other without conflict. Unless otherwise defined, all technical and scientific terms used in the embodiments of the present application have the same meanings as commonly understood by those skilled in the technical field belonging to the embodiments of the present application. The terms used in the embodiments of the present application are only for the purpose of describing the embodiments of the present application and are not intended to limit the present application.

Before describing the solutions of the embodiments of the present application, first, the terms involved in the embodiments of the present application are explained:

(1) Mesh: refers to the structure containing vertices and faces. Grids are a common method of displaying 3D game objects. A mesh is a data structure that contains arrays of vertices and arrays of faces. As shown in FIG. 1A , it is a schematic structural diagram of a grid. During the image rendering process, rendering is performed in units of grid units in the grid, where the grid includes multiple grid units 101 .

(2) Vertex: It is a data structure that contains a three-dimensional space vector. Each vertex corresponds to the position of the vertex [x, y, z]. As shown in Figure 1B, it is a schematic diagram of the relationship between vertices-faces-edges. The vertices (i.e. vertices = [x, y, z]) in Figure 1B include vertex 0, vertex 1 and vertex 2 respectively.

(3) Face: It is a data structure containing three index integers. The index data can indicate the vertices used by this face. As shown in Figure 1B, face 1 is expressed as: face 1 = [0, 1, 2].

(4) Sides: Each face has three sides. An edge is a data structure containing two indexed integers. As shown in Figure 1B, the three edges (edge 0, edge 1, and edge 2) are respectively represented as: edge 0=[0,1], edge 1=[1,2], and edge 2=[2,0].

(5) Rendering instantiation: Rendering instantiation is also called GPU instantiation. Using GPU instantiation, you can use a small number of draw calls (Drawcall) to draw (or render) multiple copies of the same mesh at once. Useful for drawing objects such as buildings, trees, grass, or other objects that recur in a scene. GPU instancing simply renders the same mesh on each draw call, but each instance can have different parameters (for example, color or scale) to increase variation and reduce repetition in appearance. GPU instancing can reduce the number of draw calls used per scene. GPU instancing can significantly improve your project's rendering performance.

(6) Draw call: It is the call command of the central processing unit (CPU, Central Processing Unit) to the underlying graphics drawing interface to instruct the GPU to perform rendering operations. The rendering process is implemented using a pipeline. The CPU and GPU work in parallel, and there is a gap between the CPU and the GPU. Through the command buffer connection, the CPU sends rendering commands to the command buffer, and the GPU receives and executes the corresponding rendering commands. Here, the main reason why draw calls affect drawing is because every time you draw, the CPU needs to call a draw call, and each draw call requires a lot of preparation work. For example, preparation work includes but is not limited to: detecting rendering status, submitting rendering Data and submission rendering state, etc. The GPU itself has very powerful computing power and can handle rendering tasks quickly. When there are too many draw calls, the CPU needs to provide a lot of extra overhead for preparation work. The CPU itself is under high load, and the GPU may be idle at this time. Since too many draw calls will cause a CPU performance bottleneck, a lot of time is spent on the preparation of draw calls. For situations where draw calls affect drawing, one optimization direction is to try to merge small draw calls into one large draw call.

(7) Graphics drawing interface of high-end GPU (such as GPU glMulti): refers to the open graphics interface (OpenGLES, Open Graphics Library). These interfaces require high-end GPU (supporting OpenGLES 3.1 or above) hardware to use graphics drawing. interface. Among them, high-end GPU refers to a GPU whose rendering performance is higher than that of a conventional GPU.

(8) Vertex buffer: It is a buffer stored in the GPU such as OpenGL/Directx (an image application programming interface, these image application programming interfaces are used to render two-dimensional or three-dimensional images), and is used to store the number of vertices. Data array, vertex buffer provides a method to upload vertex data (position, normal vector, color, etc.) to the GPU for non-immediate mode rendering. Vertex buffers provide significant performance improvements over immediate mode rendering, primarily because the data resides in GPU memory rather than system memory, so the data can be fetched by the GPU and rendered directly.

(9) Intermittent vertex rendering of a single draw call: The vertex buffer is a continuous array of vertex data. Some scenes require intermittent rendering of vertices from a single draw call of the vertex buffer, that is, it is not from vertex 1 to vertex within a single draw call. n are all rendered sequentially, but vertices 1-10, vertices 31-100, vertices 221-300..., and vertices 1000-n are rendered intermittently within a single draw call, and some vertices in the middle are skipped. As shown in Figure 2, it is a schematic diagram of intermittent vertex rendering. Before intermittent vertex rendering, only a small amount of processing needs to be done to determine whether the intermediate vertices are displayed. For example, the first row in Figure 2 represents all 20 vertices in the vertex data array: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20. In the actual rendering process, intermittent vertex rendering is required, that is, only vertices 1, 2, 3, 4, 5, 6, 7 and vertices 13, 14, 15, 16, 17, 18, 19, 20 need to be rendered. Therefore, The middle vertices 8, 9, 10, 11, and 12 will be skipped and not rendered.

Before explaining the image rendering method in the embodiment of the present application, the method in the related art will first be described.

During the intermittent vertex rendering process, one implementation method in related technologies is to separate multiple draw calls to implement intermittent vertex rendering. That is to say, intermittent vertex rendering needs to be implemented by calling multiple draw calls. As shown in Figure 3, it is a schematic diagram of calling multiple draw calls for intermittent vertex rendering in related technologies. For all 20 vertices in the vertex data array: 1, 2, 3, 4, 5, 6, 7, 8, 9 , 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, among which, during the rendering process of the first row of image data, vertices 4, 5, 6, and 7 are vertices that do not need to be rendered. , during the rendering process of the second row of image data, vertices 8, 9, 10, 11, 12 and 13, 14, 15, 16, 17, 18, 19, 20 are vertices that do not need to be rendered, therefore, the overall rendering process , 5 draw calls need to be called for rendering. The 5 draw calls are: glDrawArray(1, 2, 3), used to render vertices 1, 2, 3; glDrawArray(8, 9, 10, 11, 12 ), used to render vertices 8, 9, 10, 11, 12; glDrawArray(13, 14, 15, 16, 17, 18, 19, 20), used to render vertices 13, 14, 15, 16, 17, 18 , 19, 20; glDrawArray (1, 2, 3), used to render vertices 1, 2, 3; glDrawArray (4, 5, 6, 7), used to render vertices 4, 5, 6, 7.

Another implementation method in the related art requires a graphics drawing interface of a high-end GPU. As shown in Figure 4, it is a schematic diagram of using the graphics drawing interface of a high-end GPU to perform intermittent vertex rendering in the related art. For the vertex data array All 20 vertices: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, among which, in the first During the rendering process of the row image data, vertices 4, 5, 6, and 7 are vertices that do not need to be rendered. During the rendering process of the second row of image data, vertices 8, 9, 10, 11, 12 and 13, 14, 15 , 16, 17, 18, 19, and 20 are vertices that do not need to be rendered. Therefore, during the overall rendering process, the graphics rendering interface of the high-end GPU is used to call one draw call for rendering. This draw call is:
glDrawArray(
1, 2, 3,
8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20,
1, 2, 3,
4, 5, 6, 7
).

However, the adaptability of this method is not wide enough, and not all models can be applied.

Another implementation method in the related art is to fill the data that needs to be rendered into VB in real time according to whether the components of the object enable rendering. As shown in Figure 5, it is a schematic diagram of intermittent vertex rendering through data copying in the related art. For All 20 vertices in the vertex data array: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, among which, in the rendering process of the first row of image data, vertices 4, 5, 6, and 7 are vertices that do not need to be rendered, and in the second row of image data During the rendering process, vertices 8, 9, 10, 11, 12 and 13, 14, 15, 16, 17, 18, 19, 20 are vertices that do not need to be rendered. Therefore, during the overall rendering process, the data to be rendered can be Copy it to the vertex buffer and render. However, this method involves a data copy process, so there is a bottleneck limit on performance.

Another implementation method in the related technology is that if there is no graphics drawing interface of a high-end GPU, because the components of similar objects have different enabled states, they cannot be instantiated and need to be rendered multiple times. As shown in Figure 6, it is a schematic diagram of intermittent vertex rendering through multiple renderings in related technologies. For object one, object two and object three, component 1, component 2, component 3 and component 4 are the same components and need to be rendered. The data and content are exactly the same, but the components that do not need to be rendered in object one, object two and object three are different. Therefore, for the same component, multiple renderings may be required in different objects. This will obviously reduce image rendering efficiency.

Based on at least one of the above problems existing in related technologies, embodiments of the present application provide an image rendering method. The image rendering method is a GPU rendering call optimization method with wider adaptability. This method solves the problem in certain scenarios. , the need to implement intermittent vertex rendering from a single draw call in the vertex buffer, that is, not all vertices 1 to vertex n are rendered sequentially within a single draw call, but vertices 1-10, vertices 31-100 are intermittently rendered within a single draw call , vertices 221-300..., vertices 1000-n are rendered, and some vertices in the middle will be skipped and not rendered.

In the image rendering method provided by the embodiment of the present application, first, the data to be rendered and the index data set are obtained; the data to be rendered corresponds to a vertex set; then, based on the data to be rendered and the index data in the index data set, the vertex set in the vertex set is Vertex elimination is performed on some vertices to obtain a set of vertices to be rendered; finally, vertex rendering is performed on the vertices to be rendered in the set of vertices to be rendered to obtain a rendered image. In this way, since the vertex elimination process is performed on some vertices in the vertex set based on the index data, intermittent vertex rendering can be implemented with a single draw call, which not only improves image rendering efficiency, but is also suitable for different devices and has high adaptability. .

The following describes an exemplary application of the image rendering device according to the embodiment of the present application. The image rendering device is an electronic device used to implement the image rendering method according to the embodiment of the present application. The image rendering device (ie, electronic device) provided by the embodiment of the present application can be implemented as a terminal or as a server. In one implementation, the image rendering device provided by the embodiment of the present application can be implemented as a notebook computer, a tablet computer, a desktop computer, a mobile device (for example, a mobile phone, a portable music player, a personal digital assistant, a dedicated messaging device, a portable Game equipment), smart robots, smart home appliances, smart vehicle-mounted equipment, and other terminals with image processing functions, video display functions, and image rendering functions; in another implementation, the image rendering device provided by the embodiment of the present application can also Implemented as a server, where the server can be an independent physical server, or a server cluster or distributed system composed of multiple physical servers, or it can provide cloud services, cloud databases, cloud computing, cloud functions, cloud storage, and networks. Services, cloud communications, middleware services, domain name services, security services, content delivery network (CDN, Content Delivery Network), and cloud servers for basic cloud computing services such as big data and artificial intelligence platforms. The terminal and the server can be connected directly or indirectly through wired or wireless communication methods, which are not limited in the embodiments of this application. Next, an exemplary application when the image rendering device is implemented as a server will be described.

Referring to Figure 7, Figure 7 is an optional architectural schematic diagram of an image rendering system provided by an embodiment of the present application. In order to support any video application or image display application, the image rendering system 10 at least includes a terminal 100, a network 200 and a server. 300, where the server 300 is a server for a video application or an image display application, and the server 300 may constitute the image rendering device in the embodiment of the present application. The terminal 100 connects to the server 300 through the network 200. The network 200 may be a wide area network or a local area network, or a combination of the two. During the image rendering process, the terminal 100 sends the image rendering request to the server 300 through the network 200. After obtaining the data to be rendered and the index data set used to reflect the rendering requirement information, the server 300 performs the processing based on the data to be rendered and the index data set. Index data, perform vertex elimination processing on some vertices in the vertex set corresponding to the to-be-rendered data, and obtain the to-be-rendered vertex set; then perform vertex rendering on the to-be-rendered vertices in the to-be-rendered vertex set in sequence to obtain the rendered image. in getting After rendering the image, the rendered image is sent to the terminal 100 through the network 200, and the rendered image is displayed on the terminal 100.

The image rendering method provided by the embodiment of the present application can also be based on a cloud platform and implemented through cloud technology. For example, the above-mentioned server 300 can be a cloud server, and the cloud server can perform vertex mapping based on the data to be rendered and the index data in the index data set. Vertex elimination is performed on some vertices in the set to obtain a set of vertices to be rendered, and the vertices to be rendered in the set of vertices to be rendered are sequentially rendered through the cloud server to obtain a rendered image.

In some embodiments, there may also be cloud storage. The rendered image may be stored in the cloud storage, or the index data set may be stored in the cloud storage, or the data to be rendered and the rendered image may be mapped and stored in the cloud. in memory. In this way, when the image rendering data needs to be rendered again later, the rendered image can be read directly from the cloud storage.

What needs to be explained here is that cloud technology refers to a hosting technology that unifies a series of resources such as hardware, software, and networks within a wide area network or local area network to realize data calculation, storage, processing, and sharing. Cloud technology is a general term for network technology, information technology, integration technology, management platform technology, application technology, etc. based on the cloud computing business model. It can form a resource pool and use it on demand, which is flexible and convenient. Cloud computing technology will become an important support. The background services of technical network systems require a large amount of computing and storage resources, such as video websites, picture websites and more portal websites. With the rapid development and application of the Internet industry, in the future each item may have its own identification mark, which needs to be transmitted to the backend system for logical processing. Data at different levels will be processed separately, and all types of industry data need to be powerful. System backing support can only be achieved through cloud computing.

Figure 8 is a schematic structural diagram of an electronic device provided by an embodiment of the present application. The electronic device shown in Figure 8 includes: at least one processor 310, a memory 350, at least one network interface 320 and a user interface 330. The various components in the electronic device are coupled together through bus system 340 . It can be understood that the bus system 340 is used to implement connection communication between these components. In addition to the data bus, the bus system 340 also includes a power bus, a control bus and a status signal bus. However, for the sake of clarity, the various buses are labeled bus system 340 in FIG. 8 .

The processor 310 may be an integrated circuit chip with signal processing capabilities, such as a general-purpose processor, a digital signal processor (DSP, Digital Signal Processor), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware Components, etc., wherein the general processor can be a microprocessor or any conventional processor, etc. User interface 330 includes one or more output devices 331 that enable the presentation of media content, and one or more input devices 332. Memory 350 may be removable, non-removable, or a combination thereof. Exemplary hardware devices include solid state memory, hard disk drives, optical disk drives, etc. Memory 350 optionally includes one or more storage devices physically located remotely from processor 310 . Memory 350 includes volatile memory or non-volatile memory, and may include both volatile and non-volatile memory. Non-volatile memory can be read-only memory (ROM, Read Only Memory), and volatile memory can be random access memory (RAM, Random Access Memory). The memory 350 described in the embodiments of this application is intended to include any suitable type of memory. In some embodiments, the memory 350 is capable of storing data to support various operations, examples of which include programs, modules, and data structures, or subsets or supersets thereof, as exemplarily described below. Operating system 351, including system programs used to process various basic system services and perform hardware-related tasks, such as framework layer, core library layer, driver layer, etc., used to implement various basic services and process hardware-based tasks; network communication Module 352 for reaching other computing devices via one or more (wired or wireless) network interfaces 320, example network interfaces 320 include: Bluetooth, Wireless Compliance (WiFi), and Universal Serial Bus (USB, Universal Serial Bus), etc.; input processing module 353 for detecting one or more user inputs or interactions from one or more input devices 332 and translating the detected inputs or interactions.

In some embodiments, the device provided by the embodiment of the present application can be implemented in software. Figure 8 shows an image rendering device 354 stored in the memory 350. The image rendering device 354 can be an image rendering device in an electronic device. Like the rendering device, it can be software in the form of programs and plug-ins, including the following software modules: acquisition module 3541, vertex elimination module 3542 and vertex rendering module 3543. These modules are logical, so any implementation can be performed according to the functions implemented. combination or further split. The functions of each module are explained below.

In other embodiments, the device provided by the embodiment of the present application can be implemented in hardware. As an example, the device provided by the embodiment of the present application can be a processor in the form of a hardware decoding processor, which is programmed to execute the present application. The image rendering method provided by the embodiment, for example, the processor in the form of a hardware decoding processor can use one or more Application Specific Integrated Circuits (ASIC, Application Specific Integrated Circuit), DSP, Programmable Logic Device (PLD, Programmable Logic Device) ), Complex Programmable Logic Device (CPLD, Complex Programmable Logic Device), Field Programmable Gate Array (FPGA, Field-Programmable Gate Array) or other electronic components.

The image rendering method provided by each embodiment of the present application can be executed by an image rendering device, where the image rendering device can be any terminal with image processing functions, video display functions and image rendering functions, or it can also be a server, That is, the image rendering method in each embodiment of the present application can be executed through a terminal, a server, or the terminal interacts with a server.

Figure 9 is an optional flow diagram of the image rendering method provided by the embodiment of the present application. The following will be described in conjunction with the steps shown in Figure 9. It should be noted that the image rendering method in Figure 9 uses the server as the execution subject. To illustrate with an example. Referring to Figure 9, the image rendering method includes the following steps S101 to S103:

Step S101: Obtain the data to be rendered and the index data set; the data to be rendered corresponds to a vertex set.

Here, the data to be rendered is the original data used to render the rendered image. The data to be rendered includes the data corresponding to each pixel on the rendered image. By performing image rendering on the data to be rendered, the original image can be obtained. The original image is the unused image. Images that undergo any processing and do not reflect any rendering requirement information are images that do not reflect any rendering requirements of the user.

In this embodiment of the present application, the original data in the data to be rendered may include the pixel value of each pixel of the rendered image, and all vertices in the vertex set are evenly arranged in the rendered image. Among them, each pixel point can correspond to a vertex, and the position of the pixel point is the position of the vertex; or, multiple pixel points can correspond to one vertex, and the center position of the multiple pixel points is the position of the corresponding vertex.

The index data set is a data set based on the user's rendering requirement information. That is to say, the index data in the index data set is data that can reflect the user's rendering requirement. The index data in the index data set is used to perform scaling processing on the vertex position information of each vertex in the vertex set, thereby determining whether each vertex is to be rendered.

In this embodiment of the present application, the vertex set includes at least three vertices, where every three vertices can form a triangle. In the process of image rendering, triangle is the smallest unit of image rendering. Of course, four vertices can also be connected to form a quadrilateral, five vertices can be connected to form a pentagon, etc. These triangles, quadrilaterals, pentagons and other graphics are superimposed to form a grid corresponding to the image in the embodiment of the present application. In the actual rendering process, for the graphics in the grid, the image is divided into triangles, and the triangles are used as rendering units for rendering.

In some embodiments, the index data in the index data set may be preset, or may be calculated based on the user's rendering instructions. The setting process of the index data and the calculation process based on the rendering instructions will be described in detail below. .

Step S102: Based on the data to be rendered and the index data in the index data set, perform vertex elimination processing on some of the vertices in the vertex set to obtain a vertex set to be rendered.

Here, the vertex elimination operation can be performed on each vertex in the vertex set corresponding to the to-be-rendered data to obtain the operation result of each vertex, and then it is determined whether each vertex needs to be eliminated based on the operation result. Alternatively, you can also determine whether the vertex is to be eliminated by determining the data type of the index data corresponding to each vertex. That is to say, the index data corresponding to each vertex can have a label data, and the label data can identify The elimination status of the vertex can be used to determine whether the vertex is to be eliminated.

In the embodiment of this application, since the index data is preset or calculated based on the user's rendering instructions, the index data can represent the user's rendering needs. Then, the operation result obtained by performing the vertex elimination operation based on the index data can be Accurately reflects whether each vertex is a vertex to be eliminated. Alternatively, the vertices can be distinguished through label data, and it can be quickly and accurately determined whether each vertex is a vertex to be eliminated.

Vertex elimination processing refers to deleting some vertices in the vertex set from the vertex set, so that some vertices in the vertex set can not be rendered during the rendering process. The set of vertices to be rendered includes at least one vertex to be rendered, and the vertex to be rendered is a vertex that actually needs to be rendered. The number of vertices to be rendered in the vertex set to be rendered is less than the number of vertices in the vertex set.

In the embodiment of the present application, some vertices are not rendered, that is, intermittent vertex rendering is performed. That is to say, instead of continuously rendering all the vertices in the vertex set in sequence, a part of the vertices is intermittently skipped, and the part of the vertices is not rendered. To render.

Step S103: Perform vertex rendering on the vertices to be rendered in the vertex set to be rendered in sequence to obtain a rendered image.

In the embodiment of the present application, after obtaining a set of vertices to be rendered with some vertices eliminated, vertex rendering is performed on all the vertices to be rendered in the set of vertices to be rendered, to obtain a rendered image (i.e., a rendered image). During the rendering process, the vertices to be rendered in the vertex set to be rendered can be triangulated to obtain multiple triangles, and then the triangular image is rendered in units of each triangle to obtain a rendered image.

The image rendering method provided by the embodiment of the present application performs vertex elimination processing on some vertices in the vertex set corresponding to the data to be rendered based on the acquired data to be rendered and the index data in the index data set, to obtain the set of vertices to be rendered; and The vertices to be rendered in the rendering vertex set are rendered in sequence to obtain the rendered image. In this way, since the vertex elimination process is performed on some vertices in the vertex set based on the index data, intermittent vertex rendering can be implemented by calling a draw call, which not only improves the image rendering efficiency, but also the image rendering method is suitable for different devices and has high performance. device compatibility.

In some embodiments, the image rendering system for implementing the image rendering method includes at least a terminal and a server. A video application or an image display application is running on the terminal. Here, an image display application is running on the terminal, and the image display application is a game application.

During the rendering process of each frame of the game, you can pre-define which parts of the frame (i.e. which pixels) need to be rendered and which parts do not need to be rendered. In this way, based on the same to-be-rendered data and the user's preset Define information to render different game screens. For example, when performing a game operation on the same operating object, the difference between the two frames of the game screen may be very small, and only the local display information is different. Therefore, it is possible to predefine which of the two frames of the game screen before rendering the image. Information in local areas needs to be rendered, and information in local areas does not need to be rendered. During the rendering process, based on the predefined information, the image rendering method provided by the embodiment of the present application can be used to perform image rendering to obtain the final displayed game screen.

Figure 10 is another optional flow diagram of the image rendering method provided by the embodiment of the present application. As shown in Figure 10, the method includes the following steps S201 to S213:

Step S201: The terminal obtains input data to be rendered and preset rendering requirement information. The data to be rendered corresponds to a vertex set.

Here, the rendering requirement information can be input by the user through the terminal. For example, when inputting the data to be rendered, the areas, pixels or vertices that do not need to be rendered can be marked corresponding to the data to be rendered. Then all the data marked at this time constitute Information about the rendering requirements.

In some embodiments, when performing image rendering, prompt information can be displayed on the current interface of the game application. The prompt information is used to prompt the user to input rendering requirement information. The user can enter commands through the command line input box to form the rendering requirement information. , you can also select and mark areas, pixels or vertices through the mouse or keyboard, from And generate rendering requirement information.

Step S202: The terminal generates an image rendering request based on the data to be rendered and preset rendering requirement information.

Here, the data to be rendered and the preset rendering requirement information are encapsulated into the image rendering request.

Step S203: The terminal sends an image rendering request to the server.

Step S204: The server parses the rendering requirement information to obtain index data corresponding to each vertex in the vertex set.

In some embodiments, the rendering requirement information includes processing instructions for each vertex. Correspondingly, step S204 can be implemented in the following manner: first, initialize and set the index data of each vertex to obtain initialization index data; then, The rendering requirement information is parsed to obtain the processing instruction of each vertex; finally, when the processing instruction is a rendering instruction, the initial index data of the vertex is updated to the second type index data; and, when the processing instruction is a non-rendering instruction, Update the initial index data of the vertex to the first type index data.

Here, the initialization setting may be to set the index data of each vertex to the same initial value, and the initial value constitutes the initialization index data. For example, set the index data of each vertex to 0. At this time, the initial index data is 0.

In this embodiment of the present application, it can be determined whether rendering is required for each vertex by parsing the rendering requirement information. When a certain vertex needs to be rendered, the processing corresponding to the vertex is designated as a rendering instruction; when a certain vertex does not need to be rendered, the processing instruction corresponding to the vertex is designated as a non-rendering instruction.

In some embodiments, it can also be determined whether elimination processing is to be performed on each vertex by parsing the rendering requirement information. When a certain vertex needs to be eliminated, the processing corresponding to the vertex is designated as a non-rendering instruction; when a certain vertex does not need to be eliminated, the processing instruction corresponding to the vertex is designated as a rendering instruction.

The first type of index data and the second type of index data are index data used to represent two relative vertex processing states. The first type of index data is index data used to represent vertices that are not to be rendered. When the index data of any vertex is the first type of index data, it can be determined that the vertex needs to be eliminated and does not need to be rendered. The second type of index data is index data used to represent the vertices to be rendered. When the index data of any vertex is the second type of index data, it can be determined that the vertex does not need to be eliminated and is a vertex that needs to be rendered.

In the embodiment of the present application, in response to the processing instruction being a rendering instruction, the initialization index data of the vertex is updated, and a rendering tag is added to the corresponding vertex through the second type of index data. In this way, in the subsequent rendering process, the rendering processing method of the corresponding vertex can be determined based on the second type of index data.

In the embodiment of the present application, in response to the processing instruction being a non-rendering instruction, the initialization index data of the vertex is updated, and a rendering tag is added to the corresponding vertex through the first type of index data. In this way, in the subsequent rendering process, the rendering processing method of the corresponding vertex can be determined based on the first type of index data.

Step S205: The server integrates the index data corresponding to all vertices in the vertex set to obtain an index data set.

In this embodiment of the present application, there is a mapping relationship between each index data in the index data set and a vertex. Here, the index data corresponding to all vertices in the vertex set is integrated, which may include counting the index data of all vertices to form an index data set. The index data set includes the index data of each vertex, and the mapping relationship between the vertex identifier of the vertex and the index data. Through the vertex identifier and the mapping relationship, the index data corresponding to the vertex can be determined.

In some embodiments, the terminal can also obtain the input data to be rendered and the index data corresponding to each vertex, integrate the index data corresponding to all vertices to obtain an index data set, and then generate an image based on the data to be rendered and the index data set. Rendering request. At this time, the image rendering request includes the data to be rendered and the index data collection. That is to say, the server can obtain the rendering requirement information sent by the terminal, then parse the rendering requirement information, obtain the index data of each vertex, and further integrate the index data to obtain the index data set; or, it can also be The terminal parses the user's rendering requirement information to obtain the index data of each vertex, and further integrates the index data to obtain an index data set.

Step S206: The server obtains the vertex position information of each vertex in the vertex set.

Here, the vertex position information refers to the position information of each vertex in the image. The vertex position information may be a coordinate data, that is, the vertex position information is presented in the form of coordinate data.

Step S207: The server obtains index data corresponding to each vertex from the index data set.

Here, the index data corresponding to each vertex can be determined from the index data set based on the vertex identifier of each vertex.

Step S208: The server performs scaling processing on the vertex position information of each vertex based on the index data to obtain a scaling result.

In some embodiments, step S208 can be implemented in the following manner: multiply the vertex position information of each vertex with the index data corresponding to the vertex to obtain a vertex position product; after obtaining the vertex position product of each vertex, determine the vertex position product is the scaling result of the corresponding vertex.

In the embodiment of the present application, scaling processing refers to reducing or amplifying the coordinate data of the vertex position information. In one implementation, the index data can take on any positive number. When the index data of any vertex is a positive number less than 1, the coordinate data of the vertex can be reduced through the index data; when the index data of any vertex is a number greater than 1, the coordinate data of the vertex can be reduced through the index data. The coordinate data of the vertex is enlarged; when the index data of any vertex is equal to 1, the coordinate data of the vertex does not change based on the index data.

In another implementation, the index data can take the value 0 or 1. When the index data is equal to 0, the coordinate data of the vertex can be reduced through the index data; when the index data is equal to 1, the coordinate data of the vertex does not change based on the index data.

Step S209: The server determines the vertex to be eliminated from the vertex set based on the scaling result of each vertex.

In one implementation, after obtaining the vertex position information of each vertex in the vertex set, the vertices in the vertex set can also be triangulated based on the vertex position information to obtain at least one initial triangle; wherein, each The initial triangle includes three vertices. Correspondingly, based on the scaling result of each vertex, determine the vertex to be eliminated from the vertex set. This can be when the product of the vertex positions corresponding to the three vertices of any initial triangle is the same, determine the three vertices of the initial triangle as Vertices to be eliminated.

Here, when the vertex position products corresponding to the three vertices of any initial triangle are all the same, it may be when the vertex position products corresponding to the three vertices of any initial triangle are all 0. At this time, the three vertices of this initial triangle can be determined as the vertices to be eliminated. In this way, since the products of the vertex positions corresponding to the three vertices are all 0, that is, the coordinate data of the three vertices are all 0, and the three vertices are at the same position, the three vertices can be shrunk to the same position, thereby hiding the three vertices. two of them. During the implementation process, these three vertices are all vertices to be eliminated and do not need to be rendered.

In another implementation, based on the scaling result of each vertex, determining the vertex to be eliminated from the vertex set may be: when the vertex position product is the first type of position data, determine the vertex corresponding to the vertex position product as Vertices to be eliminated; when the vertex position product is the second type of position data, the vertex corresponding to the vertex position product is determined as the vertex to be rendered.

Here, the first type of position data and the second type of position data are two opposite types of position data. That is to say, the vertex position product is either the first type of position data or the second type of position data, and the first type of position data and The second type of position data is state data used to represent two completely opposite elimination states of a vertex. The elimination state includes a state to be eliminated and a non-elimination state. When a vertex is determined to be in a state to be eliminated based on the first type of location data, the vertex is a vertex to be eliminated; when a vertex is determined to be in a non-elimination state based on the second type of location data. state, the vertex is the vertex to be rendered.

For example, the first type of position data may be 0. Then when the product of the vertex position of any vertex is 0, the vertex will be The point is determined as a vertex to be eliminated; the second type of position data can be 1, then when the vertex position product of any vertex is 1, the vertex is determined to be a vertex to be rendered, that is, a non-eliminated vertex.

Step S210: The server deletes the vertices to be eliminated in the vertex set to obtain a set of vertices to be rendered.

Step S211: The server sequentially performs vertex rendering on the vertices to be rendered in the vertex set to be rendered, and obtains a rendered image.

In step S212, the server sends the rendered image to the terminal.

Step S213: The terminal displays the rendered image on the current interface.

The image rendering method provided by the embodiment of the present application performs scaling processing on the vertex position information of each vertex based on the index data of each vertex to obtain a scaling result, and based on the scaling result of each vertex, determines the desired vertex set from the vertex set. Eliminate vertices. In this way, judgment is made based on the calculated vertex position product to determine which of the first type of position data and the second type of position data the vertex position product belongs to, so that the elimination state of the vertex can be accurately determined, and the vertex set can be accurately analyzed. The vertices to be eliminated are obtained to obtain an accurate set of vertices to be rendered, so as to accurately respond to the user's rendering needs.

In some embodiments, when performing image rendering, a draw call (Drawcall) may be called to implement the image rendering method in the embodiment of the present application. Figure 11 is another optional flow diagram of the image rendering method provided by the embodiment of the present application. As shown in Figure 11, the method includes the following steps S301 to step S312:

Step S301: The terminal obtains input data to be rendered and preset rendering requirement information. The data to be rendered corresponds to a vertex set.

Step S302: The terminal generates an image rendering request based on the data to be rendered and preset rendering requirement information.

Step S303: The terminal sends the image rendering request to the server.

Step S304: The server parses the rendering requirement information to obtain index data corresponding to each vertex in the vertex set.

Step S305: The server integrates the index data corresponding to all vertices in the vertex set to obtain an index data set.

Here, there is a mapping relationship between each index data in the index data set and a vertex.

Step S306: The server obtains index data corresponding to each vertex from the index data set.

Step S307: The server determines the vertex processing status corresponding to each vertex based on the index data.

In one implementation, the server can also obtain the vertex position information of each vertex; and based on the vertex position information, triangulate the vertices in the vertex set to obtain at least one initial triangle; wherein each initial triangle includes three vertex. Correspondingly, determining the vertex processing status corresponding to each vertex based on the index data may be that when the index data corresponding to the three vertices of any initial triangle are all preset type index data, the vertex processing of the three vertices of the initial triangle The state is determined to be the elimination state, that is, the three vertices of the initial triangle are determined as the vertices to be eliminated. In another implementation, determining the vertex processing status corresponding to each vertex based on the index data may be: when the index data is the first type of index data, determining the vertex processing status of the vertex that has a mapping relationship with the index data as Elimination state; when the index data is the second type of index data, the vertex processing state of the vertex that has a mapping relationship with the index data is determined to be a non-elimination state, where the first type of index data and the second type of index data are used to represent Index data for the two relative vertex processing states. That is to say, when the index data is the first type of index data, the vertices that have a mapping relationship with the index data are determined as the vertices to be eliminated; when the index data is the second type of index data, the vertices that have a mapping relationship with the index data are determined Identified as the vertex to be rendered.

Step S308: When the vertex processing status of any vertex is the elimination state, the server determines the vertex as the vertex to be eliminated.

Step S309: The server deletes the vertices to be eliminated in the vertex set to obtain a set of vertices to be rendered.

Step S310: The server sequentially performs vertex rendering on the vertices to be rendered in the vertex set to be rendered, and obtains a rendered image.

In some embodiments, step S310 can be implemented in the following manner: first, obtain the vertex position information of each vertex to be rendered; then, based on the vertex position information, triangulate the vertices to be rendered in the vertex set to be rendered to obtain at least one The triangle to be rendered; finally, vertex rendering is performed with each triangle to be rendered as the rendering unit, and the rendered image is obtained.

Step S311, the server sends the rendered image to the terminal.

Step S312: The terminal displays the rendered image on the current interface.

In the image rendering method provided by the embodiment of the present application, the server determines the vertex processing status corresponding to each vertex based on the index data. When the vertex processing status of any vertex is the elimination status, the server determines the vertex as the vertex to be eliminated, thereby performing Vertex elimination is performed on some vertices in the vertex set to obtain a vertex set to be rendered; and vertex rendering is performed on the vertices to be rendered in the vertex set to be rendered sequentially to obtain a rendered image. In this way, since the vertex elimination process is performed on some vertices in the vertex set based on the index data, intermittent vertex rendering can be implemented with a single draw call, which not only improves the image rendering efficiency, but also is suitable for different devices and has high device adaptability. sex. In addition, since the vertices to be eliminated can be accurately determined and an accurate set of vertices to be rendered is obtained, accurate response to the user's rendering needs is achieved.

Next, taking the game screen rendering of any game application P1 as an example, the image rendering method according to the embodiment of the present application will be described.

When a user runs the game application P1 on the terminal and starts playing the game as a player, a specific game screen is displayed corresponding to each operation of the user. When the server of the game application P1 renders each game screen, due to the screen in the game application The continuity of the game screen in several consecutive frames may not be much different, with only local differences. Therefore, at the moment of implementation, batch rendering can be performed on the continuous game screen, and the local differences can be extracted to obtain each game Vertex rendering is performed on the vertices of the screen to be rendered. In this case, the rendering data of the previous game screen can constitute the data to be rendered for the next game screen. At the same time, based on the user's operation, the parts of the latter game screen that do not need to be rendered are determined, thereby obtaining the data of the latter game screen. The vertices to be rendered. In other words, the problem that the method of the embodiment of the present application can solve is the rapid and accurate rendering of consecutive similar video frames. In order to achieve fast and accurate rendering of consecutive similar video frames, in the embodiment of the present application, the data to be rendered of the game screen and the index data set corresponding to the user's operation are first obtained. Here, the index data set corresponds to the user's operation, that is, it can be based on the user's operation. The operation determines the index data set; the data to be rendered corresponds to a vertex set; then based on the data to be rendered and the index data in the index data set, vertex elimination is performed on some vertices in the vertex set to obtain the vertex set to be rendered; finally Vertex rendering is performed sequentially on the vertices to be rendered in the vertex set to be rendered, and the game screen is obtained.

Referring to Figures 12A and 12B, Figure 12A presents the original face image (i.e., the original image) before the user performs any operation, and Figure 12B presents the game screen that needs to be displayed after the user performs any operation (i.e., rendering). The resulting image), corresponding to the user's operation, the game screen that needs to be displayed is compared with the original face image, and part of the hair 121 is not rendered. Therefore, it is necessary to obtain data to be rendered that does not include part of the hair 121 . During the implementation process, the user's operation instruction K1 under the original face image can be obtained, and the rendering requirement information corresponding to the operation instruction K1 is determined based on K1, and then the rendering requirement information is analyzed to obtain the same as in Figure 12A The index data of each vertex in the vertex set corresponding to the data to be rendered of the original face image; wherein, based on the index data, the vertex processing state corresponding to each vertex can be determined, and the vertex processing state includes the elimination state and the non-elimination state. After obtaining the index data of each vertex, based on the data to be rendered of the original face image and the index data in the index data set, vertex elimination processing is performed on the vertices of the partial hair 121 area in the original face image to obtain the game screen. A set of vertices to be rendered, and then the vertices to be rendered in the set of vertices to be rendered are sequentially rendered to obtain a game screen of the unrendered hair 121 area.

In the embodiment of the present application, when rendering the game screen, the corresponding index data set is determined based on the user's operation instructions. The index data set can represent the user's rendering needs, that is, based on the index data in the index data set, the corresponding index data set can be determined. Which vertices in the game screen need to be rendered and which vertices do not need to be rendered, so as to realize the control Fast and accurate rendering of consecutive similar video frames.

Below, an exemplary application of the embodiment of the present application in an actual application scenario will be described. Embodiments of the present application provide an image rendering method, which is a GPU rendering call optimization method with wider adaptability. This method solves the need to implement intermittent vertex rendering from a single draw call of the vertex buffer in some scenarios, that is, not all rendering from vertex 1 to vertex n is performed in sequence within a single draw call, but intermittently within a single draw call. Render vertices 1-10, vertices 31-100, vertices 221-300..., and vertices 1000-n. During the rendering process, some vertices in the middle will be skipped.

In the embodiment of this application, only some processing is needed to determine whether the intermediate vertices are displayed, and the algorithms corresponding to these processes do not require the support of high-end GPU hardware, and there is no need to use glMultiDraw (a) that can be supported by the OpenGL3.1 or above image application programming interface. Graphics drawing interface), you only need to use the intermittent rendering function (for example, it can be the glDrawElements function) to achieve intermittent rendering of vertices for the vertex buffer through one draw call. In the embodiment of the present application, an index value (i.e., the above-mentioned index data) is added to the vertex data to index the scale factor array (i.e., scaleFactors[], the scale factor array includes multiple scale factors), thereby controlling the vertex shrinkage to [ 0, 0, 0] to hide some vertices or triangular faces and achieve the purpose of intermittently rendering vertices.

In the embodiment of this application, by shrinking the vertices to the same position (for example, [0, 0, 0]) and utilizing the GPU rendering characteristics (when the three vertices of the triangle are all at the same position, no pixels will be rendered), To achieve the purpose of whether to render vertices (and triangles). By shrinking the vertices to the same position (such as [0, 0, 0]), you can control whether to render vertices and triangles to intermittently render the vertices (and triangles) of the vertex buffer.

The method of the embodiment of the present application can be applied to at least the following scenarios: in a clothing system, in a single drawing call, it is necessary to enable/disable the rendering of certain parts of the body. As shown in Figures 12A and 12B, Figure 12A is the original image, and Figure 12B is an image in which the rendering of the hair part of the body is disabled. For the hair of the person in the image, the rendering of part of the hair 121 in Figure 12B can be prohibited.

The method of the embodiment of the present application can use any hardware environment of a device with a GPU and at least supporting the OpenGL-ES 2.0 standard. The vertex elimination algorithm used in implementing vertex elimination processing in the embodiments of this application mainly involves the following principles: adding a vertex index data (scaleFactorIdx) to each vertex, and the vertex index data is used to index the scale factor array (scaleFactors). During rendering, each vertex position (vertices[i].xyz) (corresponding to the above vertex position information) is scaled using this scale factor array. For example, scaling can be calculated through scaleFactors[vertices[i].scaleFactorIdx], then The scaling result is expressed as the following formula (1):
p=vertices[i].xyz*scaleFactors[vertices[i].scaleFactorIdx] (1).

Here, * means multiplication. After the above scaling process, the scaled result (that is, the scaled result of vertex P) can be rendered. Therefore, if scaleFactors[vertices[i].scaleFactorIdx]=1, the position of vertex p does not change (equal to vertices[i].xyz), otherwise scaleFactors[vertices[i].scaleFactorIdx]=0, the position of vertex p becomes Origin [0, 0, 0].

In the embodiment of this application, because the GPU has the following characteristics: when the three vertices of the triangle are all at the same position, no pixels will be rendered. Exploiting this property in conjunction with the vertex elimination algorithm above can produce very useful results.

When the scaleFactors[vertices[i].scaleFactorIdx] of the three vertices of a triangle is 1, the vertex positions do not change, so the shape of the triangle is rendered normally.

However, if the scaleFactors[vertices[i].scaleFactorIdx] of the three vertices of the triangle are all 0, all vertices of the triangle shrink to [0, 0, 0], and the triangle shrinks to a single point [0, 0, 0]. Triangles are hidden and not rendered.

Through the scaling of the vertices, you can control whether the triangle is rendered. Therefore, the triangles in the middle of the entire triangle array can be hidden at will, so that the effect of intermittent vertex (triangle) rendering can be achieved.

Figure 13 is a flow chart of an image rendering method provided by an embodiment of the present application. As shown in Figure 13, the method includes the following steps S401 to S407:

Step S401, load the value of the scale factor array (i.e. scaleFactors[], corresponding to the index in the above embodiment data collection).

Step S402, define i=0.

Step S403: Calculate scaleFactor=scaleFactors[vertices[i].scaleFactorIdx] based on the vertex index data (scaleFactorIdx).

Here, scaleFactor represents the scale factor corresponding to the product of the i-th vertex (vertices[i]) and the scale factor index (scaleFactorIdx) (corresponding to the index data in the above embodiment).

Step S404, during vertex rendering, the position of each vertex (i.e. vertices[i].xyz) is scaled using scaleFactors[vertices[i].scaleFactorIdx] (i.e. scaleFactor). Then, it can be calculated by the following formula (2) The scaled result of vertex p p.xyz:
p.xyz=vertices[verticesIdx].xyz*scaleFactor (2).

Among them, verticesIdx represents the vertex index, which is used to index specific vertices; vertices[verticesIdx].xyz represents the position of the vertex corresponding to the vertex index.

Step S405: Render vertex p.

Step S406, define i=i+1.

Step S407, determine whether i is less than the total number of vertices.

If the judgment result is yes, then return to step S403 to continue; if the judgment result is no, the process ends, vertex rendering is completed, and the rendering result is cached.

Figure 14 is another flow chart of the image rendering method provided by the embodiment of the present application. As shown in Figure 14, the method includes the following steps S501 to S508:

Step S501, initialize the value of the scale factor array to be equal to 1 (that is, scaleFactors[]=1).

Step S502, define i=0.

Step S503: Determine whether to enable rendering of vertex i (i.e., the i-th vertex).

If the judgment result is yes, step S504 is executed; if the judgment result is no, step S505 is executed.

Step S504: Define the value of the i-th scale factor array to be equal to 0 (that is, scaleFactors[i]=0).

Step S505, determine whether to turn on the rendering of vertex i.

If the judgment result is yes, step S506 is executed; if the judgment result is no, step S507 is executed.

Step S506: Define the value of the i-th scale factor array to be equal to 1 (that is, scaleFactors[i]=1).

Step S507, define i=i+1.

Step S508, determine whether i is less than the total number of values in the scale factor array.

If the judgment result is yes, return to continue executing step S503; if the judgment result is no, the process ends and the process of changing whether the vertex is rendered is completed.

Figures 15 to 17 are schematic diagrams of the effects of applying the method of the embodiment of the present application to three devices with different device performance (such as low-end machines, mid-range machines and high-end machines). As shown in Figure 15, on the low-end machine , the average number of frames transmitted per second (FPS, Frames Per Second) is 58.9, and during operation, the FPS change curve 151 is relatively stable. It should be noted that the FPS after 00:06 in Figure 15 is relatively stable, but there is a large valley value at 00:06. The main reason is: the influence of other interference factors, such as the game has just started, needs to be dealt with There are many other things that are not related to the image rendering process of the embodiment of the present application, so the low value can be ignored.

As shown in Figure 16, on mid-range machines, the average FPS is 59.6, and during operation, the FPS change curve 161 is also relatively stable (ignoring the trough at 00:06).

As shown in Figure 17, on high-end machines, the average FPS is 59.6, and during operation, the FPS change curve 171 is also relatively stable (ignoring the low value at 00:06).

Based on the image rendering method provided by the above embodiments of the present application, in realizing the problem of intermittent vertex rendering, since there is no need to copy vertex data or a high-end GPU, the method of the embodiments of the present application has wider adaptability and higher rendering efficiency. Nothing is lost by enabling or disabling the rendering of certain parts of the image to be rendered.

It can be understood that in the embodiment of the present application, the content related to user information, such as data to be rendered, index data sets, rendered images and other information, if it involves data related to user information or enterprise information, when this application When application embodiments are applied to specific products or technologies, user permission or consent needs to be obtained, and the collection, use and processing of relevant data need to comply with relevant laws, regulations and standards of relevant countries and regions.

The following continues to describe an exemplary structure in which the image rendering device 354 provided by the embodiment of the present application is implemented as a software module. In some embodiments, as shown in Figure 8 , the image rendering device 354 includes: an acquisition module 3541 configured to acquire data to be rendered. and an index data set used to reflect rendering requirement information; the data to be rendered corresponds to a vertex set; the vertex elimination module 3542 is configured to eliminate the vertex set in the vertex set based on the data to be rendered and the index data in the index data set. Perform vertex elimination processing on some of the vertices to obtain a set of vertices to be rendered; the vertex rendering module 3543 is configured to sequentially perform vertex rendering on the vertices to be rendered in the set of vertices to be rendered to obtain a rendered image.

In some embodiments, there is a mapping relationship between each index data in the index data set and a vertex in the vertex set; the vertex elimination module is further configured to: obtain the index of each vertex in the vertex set. Vertex position information; obtain index data corresponding to each vertex from the index data set; perform scaling processing on the vertex position information of each vertex based on the index data, and obtain the scaling result of each vertex correspondingly; based on each vertex The scaling result of a vertex determines the vertex to be eliminated from the vertex set; deletes the vertex to be eliminated in the vertex set to obtain the vertex set to be rendered.

In some embodiments, the vertex elimination module is further configured to: multiply the vertex position information of each vertex with the index data corresponding to the corresponding vertex to obtain the vertex position product of each vertex; multiply the vertex position product of each vertex , determined as the scaling result of the corresponding vertex.

In some embodiments, the device further includes: a first triangulation module configured to triangulate the vertices in the vertex set based on the vertex position information to obtain at least one initial triangle; wherein each The initial triangle includes three vertices; the vertex elimination module is also configured to: when the products of the vertex positions of the three vertices of any initial triangle are the same, determine the three vertices of the initial triangle as the vertices to be eliminated. .

In some embodiments, the vertex elimination module is further configured to: when the vertex position product is the first type of position data, determine the vertex corresponding to the vertex position product as the vertex to be eliminated; when the vertex position product When it is the second type of position data, the vertex corresponding to the vertex position product is determined as the vertex to be rendered; the first type of position data and the second type of position data are used to represent two relative elimination states. status data.

In some embodiments, there is a mapping relationship between each index data in the index data set and a vertex in the vertex set; the vertex elimination module is further configured to: obtain the data associated with each vertex from the index data set. Index data corresponding to the vertex; based on the index data, determine the vertex processing state corresponding to each vertex; when the vertex processing state of any vertex is the elimination state, determine the vertex as the vertex to be eliminated; from the vertex set Delete the vertices to be eliminated to obtain the set of vertices to be rendered.

In some embodiments, the device further includes: a position information acquisition module configured to obtain vertex position information of each vertex; a second triangulation module configured to, based on the vertex position information, obtain the vertex position information in the vertex set. The vertices are triangulated to obtain at least one initial triangle; wherein each initial triangle includes three vertices; the vertex elimination module is also configured to: when the index data corresponding to the three vertices of any initial triangle is preset When type indexing data, the vertex processing status of the three vertices of the initial triangle is determined to be the elimination status.

In some embodiments, the vertex elimination module is further configured to: when the index data is the first type of index data, determine the vertex processing status of the vertex having the mapping relationship with the index data as the elimination status; When the index data is second type index data, the vertex processing state of the vertex having the mapping relationship with the index data is determined to be a non-elimination state; the first type index data and the second type index Data is index data used to characterize two relative vertex processing states.

In some embodiments, the vertex rendering module is further configured to: obtain the vertex position information of each vertex to be rendered. information; based on the vertex position information, triangulate the vertices to be rendered in the vertex set to be rendered to obtain at least one triangle to be rendered; taking each triangle to be rendered as a rendering unit, triangulate the vertices to be rendered Vertex rendering is performed on the vertices to be rendered in the set to obtain the rendered image.

In some embodiments, the device further includes: a request acquisition module configured to obtain an image rendering request, the image rendering request including the data to be rendered and preset rendering requirement information; a parsing module configured to perform rendering The demand information is parsed to obtain index data corresponding to each vertex in the vertex set; an integration module is configured to integrate index data corresponding to all vertices in the vertex set to obtain the index data set.

In some embodiments, the rendering requirement information includes processing instructions for each vertex; the parsing module is also configured to: initialize and set the index data of each vertex to obtain initialization index data; and set the rendering requirement The information is parsed to obtain the processing instruction of each vertex; when the processing instruction is a rendering instruction, the initialization index data of the vertex is updated to the second type index data; when the processing instruction is a non-rendering instruction, the The initialization index data of the vertex is updated to the first type of index data.

It should be noted that the description of the device in the embodiment of the present application is similar to the description of the above-mentioned method embodiment, and has similar beneficial effects as the method embodiment, and therefore will not be described again. For technical details not disclosed in the device embodiment, please refer to the description of the method embodiment of this application for understanding.

Embodiments of the present application provide a computer program product or computer program. The computer program product or computer program includes executable instructions. The executable instructions are computer instructions; the executable instructions are stored in a computer-readable storage medium. When the processor of the electronic device reads the executable instruction from the computer-readable storage medium and the processor executes the executable instruction, the image rendering device is caused to perform the method described above in the embodiment of the present application.

Embodiments of the present application provide a storage medium in which executable instructions are stored. When the executable instructions are executed by a processor, they will cause the processor to execute the method provided by embodiments of the present application. For example, as shown in Figure 9 shows the method.

In some embodiments, the storage medium may be a computer-readable storage medium, such as ferroelectric memory (FRAM, Ferromagnetic Random Access Memory), read-only memory (ROM, Read Only Memory), programmable read-only memory (PROM, Programmable Read Only Memory), Erasable Programmable Read Only Memory (EPROM, Erasable Programmable Read Only Memory), Electrically Erasable Programmable Read Only Memory (EEPROM, Electrically Erasable Programmable Read Only Memory), flash memory, magnetic surface memory, optical disk, Or memory such as CD-ROM (Compact Disk-Read Only Memory); it can also be various devices including one of the above memories or any combination thereof.

In some embodiments, executable instructions may take the form of a program, software, software module, script, or code, written in any form of programming language, including compiled or interpreted languages, or declarative or procedural languages, and their May be deployed in any form, including deployed as a stand-alone program or deployed as a module, component, subroutine, or other unit suitable for use in a computing environment.

As an example, executable instructions may, but do not necessarily correspond to, files in a file system and may be stored as part of a file holding other programs or data, for example, in a Hyper Text Markup Language (HTML) document. in one or more scripts, in a single file that is specific to the program in question, or in multiple collaborative files (e.g., files that store one or more modules, subroutines, or portions of code). As examples, executable instructions may be deployed for execution on one computing device (which may be a job runtime determination device), or on multiple computing devices located at one location, or distributed across multiple locations and via Execute on multiple computing devices interconnected by a communication network.

The above descriptions are only examples of the present application and are not used to limit the protection scope of the present application. Any modifications, equivalent substitutions and improvements made within the spirit and scope of this application are included in the protection scope of this application.

Claims

An image rendering method, the method is executed by an electronic device, the method includes:

Obtain data to be rendered and an index data set used to reflect rendering requirement information; the data to be rendered corresponds to a vertex set;

Based on the data to be rendered and the index data in the index data set, perform vertex elimination processing on some of the vertices in the vertex set to obtain a set of vertices to be rendered;

Vertex rendering is performed on the to-be-rendered vertices in the to-be-rendered vertex set sequentially to obtain a rendered image.
The method according to claim 1, wherein there is a mapping relationship between each index data in the index data set and a vertex in the vertex set;

The step of performing vertex elimination processing on some of the vertices in the vertex set based on the data to be rendered and the index data in the index data set to obtain a set of vertices to be rendered includes:

Obtain the vertex position information of each vertex in the vertex set;

Obtain index data corresponding to each vertex from the index data set;

Based on the index data, perform scaling processing on the vertex position information of each vertex, and correspondingly obtain the scaling result of each vertex;

Based on the scaling result of each vertex, determine the vertex to be eliminated from the vertex set;

The vertex to be eliminated is deleted from the vertex set to obtain the vertex set to be rendered.
The method according to claim 2, wherein the scaling process is performed on the vertex position information of each vertex based on the index data, and the corresponding scaling result of each vertex is obtained, including:

Multiply the vertex position information of each vertex with the index data corresponding to the corresponding vertex to obtain the vertex position product of each vertex;

The product of the vertex position of each vertex is determined as the scaling result of the corresponding vertex.
The method of claim 3, further comprising:

Based on the vertex position information, triangulate the vertices in the vertex set to obtain at least one initial triangle; wherein each of the initial triangles includes three vertices;

Determining the vertex to be eliminated from the vertex set based on the scaling result of each vertex includes:

When the vertex position products of the three vertices of any initial triangle are the same, the three vertices of the initial triangle are determined as the vertices to be eliminated.
The method of claim 3, wherein determining the vertices to be eliminated from the vertex set based on the scaling result of each vertex includes:

When the vertex position product is the first type of position data, determine the vertex corresponding to the vertex position product as the vertex to be eliminated;

When the vertex position product is the second type of position data, the vertex corresponding to the vertex position product is determined as the vertex to be rendered; the first type of position data and the second type of position data are used to represent Status data of the two relative elimination states.
The method according to claim 1, wherein there is a mapping relationship between each index data in the index data set and a vertex in the vertex set;

The step of performing vertex elimination processing on some of the vertices in the vertex set based on the data to be rendered and the index data in the index data set to obtain a set of vertices to be rendered includes:

Obtain index data corresponding to each vertex from the index data set;

Based on the index data, determine the vertex processing status corresponding to each vertex;

When the vertex processing status of any vertex is the elimination state, the vertex is determined as the vertex to be eliminated;

The vertex to be eliminated is deleted from the vertex set to obtain the vertex set to be rendered.
The method of claim 6, further comprising:

Get the vertex position information of each vertex;

Based on the vertex position information, triangulate the vertices in the vertex set to obtain at least one initial triangle; wherein each of the initial triangles includes three vertices;

Determining the vertex processing status corresponding to each vertex based on the index data includes:

When the index data corresponding to the three vertices of any initial triangle is preset type index data, the vertex processing state of the three vertices of the initial triangle is determined to be the elimination state.
The method of claim 6, wherein determining the vertex processing status corresponding to each vertex based on the index data includes:

When the index data is the first type of index data, determine the vertex processing state corresponding to the vertex having the mapping relationship with the index data as the elimination state;

When the index data is the second type of index data, the vertex processing state corresponding to the vertex having the mapping relationship with the index data is determined to be a non-elimination state; the first type of index data is different from the second type of index data. Index data is index data used to characterize two relative vertex processing states.
The method according to any one of claims 1 to 8, wherein said sequentially performing vertex rendering on the to-be-rendered vertices in the to-be-rendered vertex set to obtain a rendered image includes:

Obtain the vertex position information of each vertex to be rendered;

Based on the vertex position information, triangulate the vertices to be rendered in the set of vertices to be rendered to obtain at least one triangle to be rendered;

Using each triangle to be rendered as a rendering unit, perform vertex rendering on the vertices to be rendered in the vertex set to be rendered, to obtain the rendered image.
The method according to any one of claims 1 to 8, wherein the method further includes:

Obtain an image rendering request, which includes the data to be rendered and preset rendering requirement information;

Parse the rendering requirement information to obtain index data corresponding to each vertex in the vertex set;

The index data corresponding to all vertices in the vertex set is integrated to obtain the index data set.
The method according to claim 10, wherein the rendering requirement information includes processing instructions for each vertex; the rendering requirement information is parsed to obtain the rendering requirement information corresponding to each vertex in the vertex set. Index data, including:

Initialize the index data of each vertex to obtain the initialized index data;

Analyze the rendering requirement information to obtain processing instructions for each vertex;

When the processing instruction is a rendering instruction, update the initialization index data of the vertex to the second type of index data;

When the processing instruction is a non-rendering instruction, the initialization index data of the vertex is updated to the first type of index data.
An image rendering device, the device includes:

An acquisition module configured to acquire data to be rendered and an index data set used to reflect rendering requirement information; the data to be rendered corresponds to a vertex set;

A vertex elimination module configured to perform vertex elimination processing on some of the vertices in the vertex set based on the to-be-rendered data and the index data in the index data set to obtain a to-be-rendered vertex set;

The vertex rendering module is configured to sequentially perform vertex rendering on the vertices to be rendered in the set of vertices to be rendered to obtain a rendered image.
An electronic device including:

a memory configured to store executable instructions; a processor configured to execute the executable instructions stored in the memory When instructed, the image rendering method described in any one of claims 1 to 11 is implemented.
A computer-readable storage medium stores executable instructions and is configured to cause a processor to implement the image rendering method according to any one of claims 1 to 11 when the processor executes the executable instructions.
A computer program product or computer program that includes executable instructions stored in a computer-readable storage medium;

When the processor of the electronic device reads the executable instructions from the computer-readable storage medium and executes the executable instructions, the image rendering method according to any one of claims 1 to 11 is implemented.