CN115861505A - Method, device, equipment and medium for batch processing of rendered objects - Google Patents
Method, device, equipment and medium for batch processing of rendered objects Download PDFInfo
- Publication number
- CN115861505A CN115861505A CN202211328266.XA CN202211328266A CN115861505A CN 115861505 A CN115861505 A CN 115861505A CN 202211328266 A CN202211328266 A CN 202211328266A CN 115861505 A CN115861505 A CN 115861505A
- Authority
- CN
- China
- Prior art keywords
- data
- rendering
- batch
- buffer area
- data buffer
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Landscapes
- Image Generation (AREA)
Abstract
The invention provides a method, a device, equipment and a medium for rendering objects in batch, which relate to the technical field of three-dimensional rendering and comprise the following steps: acquiring data of a data buffer area; acquiring batch render data, and sequentially filling the batch render data into a data buffer area from the initial position of the data buffer area to obtain data of objects to be rendered; rendering the batch renderings according to the data of the to-be-rendered objects; and performing batch rendering on the batch rendering objects according to the rendering flow drawing. The embodiment of the invention formulates a method for rendering objects in batch processing, and can continuously use a high-performance batch rendering mode while reducing the use threshold. When the batch rendering processing mechanism is started, dynamic maintenance is carried out on rendering formations such as buffer areas, materials, textures and the like used in batch rendering.
Description
Technical Field
The invention belongs to the technical field of three-dimensional rendering, and particularly relates to a method and a device for processing rendered objects in batch, electronic equipment and a storage medium.
Background
Instantiated rendering (instanceddradwing) is a batch rendering process done by a Graphics Processor (GPU). Compared with the common rendering mode, the GPU needs to be informed of the times of rendering the objects (drawing N) when the rendering commands are called, and the GPU can continuously draw the N rendering objects, so that the efficiency is much higher than that of continuously calling the rendering objects for multiple times.
By storing the information in a vertex buffer (VertexBuffer), an index buffer (IndexBuffer), and the like, the GPU can process N rendering objects (sequentially obtain vertex data, matrix data, color data, and the like of the rendering objects) according to a specified step size when performing instantiation rendering, and draw through a single rendering command (DrawCall).
However, although the instantiation rendering has higher execution efficiency than the ordinary rendering method, the shader and the data buffer used for rendering the object are required to be the same.
Disclosure of Invention
The embodiment of the invention provides a method and a device for batch processing of renderings, electronic equipment and a storage medium, which can solve the problem of batch rendering of the renderings.
In a first aspect, an embodiment of the present invention provides a method for batch processing a rendered object, including:
acquiring data of a data buffer area, wherein the data of the data buffer area comprises: the starting position of the data buffer area and the length of the data buffer area;
obtaining batch rendering object data, and sequentially filling the batch rendering object data into the data buffer area from the initial position of the data buffer area to obtain object data to be rendered;
rendering the batch renderings according to the data of the to-be-rendered objects;
and performing batch rendering on the batch rendering objects according to the rendering flow drawing.
Optionally, the obtaining batch render data includes:
obtaining vertex data of a rendered object, and generating a first key value pair according to a first rule;
acquiring rendered object shader data, and generating a second key value pair according to a second rule;
combining the first and second key-value pairs by an MD5 algorithm to generate a third key-value pair.
Optionally, the above and before sequentially filling the data buffer from the starting position of the data buffer to the data buffer, further includes:
and searching the data buffer area corresponding to the batch renderings in an idle buffer area according to the third key value pair.
Optionally, the searching for the data buffer area corresponding to the batch render object in an idle buffer area according to the third key value pair specifically includes:
comparing the total byte length in the third key value pair with the total byte length in the idle buffer area;
when the total byte length in the third key value pair is not less than the total byte length of the idle buffer area, determining that the data buffer area corresponding to the batch renderings exists in the idle buffer area;
and when the total byte length in the third key value pair is smaller than the total byte length of the idle buffer area, the data buffer area is created.
Optionally, before performing batch rendering on the rendered object according to the rendering flow, the method further includes:
and when the data of the object to be rendered is changed or/and the animation is played, deleting the current rendered object.
Further, after deleting the current render, the method further includes:
and acquiring vertex data and shader data of the current render object, and rendering according to the vertex data and the shader data.
Further, after the batch rendering of the rendered objects according to the rendering process drawing, the method further includes:
and after the batch renderings are finished, marking the position as an idle state according to the position information of the matrix buffer area.
In a second aspect, an embodiment of the present invention provides a batch processing rendering device, including:
a first obtaining module, configured to obtain data in a data buffer, where the data in the data buffer includes: the starting position of the data buffer area and the length of the data buffer area;
the second acquisition module is used for acquiring batch rendering object data and sequentially filling the batch rendering object data into the data buffer area from the initial position of the data buffer area to obtain object data to be rendered;
the rendering flow drawing module is used for rendering flow drawing of the batch renderings according to the data of the objects to be rendered;
and the rendering module is used for rendering the batch rendering objects in batch according to the rendering flow drawing.
A third aspect of the embodiments of the present invention provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, where the processor implements the steps of the method when executing the computer program.
A fourth aspect of embodiments of the present invention provides a computer-readable storage medium having stored thereon a computer program which, when executed by a processor, performs the steps of the method as described above.
It is understood that the beneficial effects of the second to fourth aspects can be seen from the description of the first aspect, and are not described herein again.
The method comprises the steps of obtaining data of a data buffer area, obtaining batch rendering object data, and sequentially filling the data buffer area from the initial position of the data buffer area to obtain object data to be rendered; rendering the batch renderings according to the data of the to-be-rendered objects; and performing batch rendering on the renderings according to the rendering flow. The method for rendering objects in batch processing can reduce the use threshold and can continuously use a high-performance batch rendering mode. Developers do not need to manage the rendering objects such as buffers, materials and textures, and when a batch rendering processing mechanism is started, the technology can dynamically maintain the rendering formations such as buffers, materials and textures used in batch rendering.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed for the embodiments or the prior art descriptions will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings without creative efforts.
FIG. 1 is a flowchart illustrating a method for batch processing a rendered object according to an embodiment of the present invention;
FIG. 2 is a flowchart illustrating a method for obtaining batch rendering data according to an embodiment of the present invention;
FIG. 3 is a schematic structural diagram of a batch processing rendering device according to an embodiment of the present invention;
fig. 4 is a schematic structural diagram of an electronic device according to an embodiment of the invention.
Detailed Description
In the following description, for purposes of explanation and not limitation, specific details are set forth, such as particular system structures, techniques, etc. in order to provide a thorough understanding of the embodiments of the invention. It will be apparent, however, to one skilled in the art that the present invention may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known systems, devices, and methods are omitted so as not to obscure the description of the present invention with unnecessary detail.
It should be understood that the terms "comprises" and/or "comprising," when used in this specification and the appended claims, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
It should also be understood that the term "and/or" as used in this specification and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.
The existing rendering technology cannot independently modify the rendering characteristics of a certain render, and if the rendering characteristics need to be independently modified, the shader code needs to be changed to process the corresponding logic. If the animation is contained in the rendered object, the animation needs to be specially processed to achieve instantiation rendering, so that the writing difficulty of the shader is greatly increased, and the usability of the instantiation rendering is also reduced. To solve the above problem, an embodiment of the present invention provides a method for batch processing of a rendered object.
The invention is described in detail below with reference to the accompanying drawings:
referring to fig. 1, fig. 1 is a flowchart illustrating steps of a method for rendering objects in batch processing according to an embodiment of the present invention, including:
step S100: obtaining data in a data buffer, the data in the data buffer comprising: the starting position of the data buffer area and the length of the data buffer area.
Specifically, data in a data buffer is obtained, where the data in the data buffer includes: the initial position of the data buffer area is used for reusing the data buffer area after the subsequent renderings are deleted, and the idle data buffer area is reused as much as possible. The data buffer is established according to the standard of the array, so the initial position can be the subscript of the array, and the subscript can increase automatically and continuously along with the change of the length of the array. When the rendered object is released, the subscript needs to be recovered, so that a free subscript list needs to be established for subsequent reuse of the released data space. The length of the data buffer may be expressed in total number of bytes.
Step S101: and acquiring batch render data, and sequentially filling the batch render data into a data buffer area to obtain the data of the object to be rendered.
Wherein the sequential filling into the data buffer means filling from the start position of the data buffer.
Specifically, referring to fig. 2, fig. 2 is a schematic flowchart of a method for acquiring batch render data according to an embodiment of the present invention, where acquiring batch render data includes:
step S1011: vertex data of the rendered object is obtained, and a first key-value pair is generated according to a first rule.
Specifically, vertex data of the rendered object is acquired, and the vertex data includes: after the vertex data is obtained, according to a first rule: the [ buffer type/data type/number of data combinations/length of buffer data ] generates a unique key-value pair of the character string, i.e. a first key-value pair, such as: "[ VertexBuffer/float/3/100]" string indicates: the buffer type is: vertexBuffer, the data type is: 32-bit float, number of data combinations: xyz combination, buffer data length: 100.
further, the buffer types include: vertex buffer (VertexBuffer), index buffer (IndexBuffer), normal buffer (NormalBuffer), texture coordinate buffer (UVBuffer); the data type (DataType) includes: floating point (float)/32-bit shaping/16-bit shaping; the number of data combinations (dataslide) includes: shaping numbers (generally, numbers below 4, for example, 3 is an xyz combination); buffer data length (DataLength): indicating the length of the data. Then, the total number of bytes is: the number of data combinations, the data type and the buffer length are determined together, such as: data type: float (4 bytes), number of combinations: 3. data length: 100, the total number of bytes is: 4x3x100=1200.
Optionally, the vertex buffer data format is generally declared by a fixed data type, such as a combination of three floating point values (xyz); the index buffer data format is typically declared with a data type of 16 bits length; the normal buffer data format is generally stated by a fixed data type, such as three floating point value combinations (xyz); texture coordinate buffers typically exist in multiples (e.g., UV0, UV1, UV2 \ 8230; etc.) in the format of typically 2 floating point value combinations (xy).
Step S1012: and acquiring rendered object shader data, and generating a second key value pair according to a second rule.
Specifically, shader data of the render is obtained, and the shader data includes: the shader code key value pair, the shader attribute data and the shader Uniform variable key value pair are subjected to shader data acquisition, and then according to a second rule: the [ shader code key-value pair ] [ shader attribute type/shader attribute name ] shader Uniform variable key-value pair generates a string unique key-value pair, i.e., a second key-value pair.
Further, the shader code key value pairs are generated through an MD5 algorithm according to shader codes; shader attribute data is data about attribute declarations (attributes) in shader code, which are combined as follows: attribute type (AttributeType), attribute name (AttributeName); the shader Uniform variable key-value pair is generated according to data about a Uniform variable in shader code, the Uniform variable key-value pair can be used for subsequent comparison processing of Uniform data, and the data of the Uniform variable is combined in the following way: property name (UniformName), property value (UniformValue), where the Uniform variable may be a numeric value or a texture object, and if a texture object, the texture object needs to be converted into a unique serializable key-value pair.
Further, the render shader data also includes attribute information of a binding matrix buffer (matrix buffer) for storing the matrix data of each render, and during the subsequent rendering of the renders, the attributes of the matrix buffer will receive data from the matrix buffer regarding the position, rendering, and scaling information of the renders.
Step S1013: and combining the first key-value pair and the second key-value pair through an MD5 algorithm to generate a third key-value pair.
Specifically, the first key-value pair and the second key-value pair may be combined by using an MD5 algorithm to generate a third key-value pair, for example, in a combination manner: "[ VertexBuffer/float/3]" + "[ MD5] [ vec3/position ] [ vec3/nor mal ] [ vec2/uv ] [ uniform/modelView ] [ uniform/project ]" after the character string is combined, the MD5 code, namely the third key value pair, is generated.
After acquiring batch rendering object data and generating a third key value pair, firstly judging whether a data buffer area corresponding to the batch rendering object exists or not, and searching whether the data buffer area exists or not by using the third key value pair, wherein the specific searching process comprises the following steps: the data of the buffer area, the shader codes and the variables required by each render are similar, so a third key value pair can be used for comparison, the total byte length contained in the third key value is obtained, the data of the buffer area subscript which is released is obtained from the subscript of the idle buffer area, the total byte length of the idle buffer area is calculated, the total byte length in the third key value pair and the total byte length of the idle buffer area are compared to ensure that the data buffer area can sufficiently store batch render data, the data buffer area which can be used is found out, and if the corresponding data buffer area does not exist or the corresponding data of the buffer area is full, the data buffer area is created. The data buffer is created according to the vertex data of the rendered objects, and a data buffer for storing 2048 rendered objects can be generated. At the same time of creating the data buffer, a matrix buffer (matrix buffer) is created for processing the position, rotation and scaling information of each rendered object, and the name of the matrix buffer may be: model matrix, data type: mat4, number of data combinations: 16, may consist of 4x4 floating point numbers.
Furthermore, the batch rendering object data is sequentially filled into the data buffer area from the initial position of the data buffer area, the initial position of the data buffer area is recorded so as to be convenient for reuse after the rendering object is deleted after the processing, and the idle data buffer area is utilized, so that the resources are saved, and the load is reduced. Meanwhile, the matrix buffer area carries out data filling from the initial position of the data buffer area in sequence so as to ensure the correctness of the position of the render object.
Further, after the data filling is completed, the length of the data buffer area is updated. And after the batch rendering object data is filled into the data buffer area, updating the usage amount of the first buffer area so as to ensure that the data in the buffer area cannot be added with a newly added rendering object.
Step S102: and rendering the batch renderings according to the data of the to-be-rendered objects.
In the embodiment of the invention, the rendering process drawing refers to completing the position synchronization of the rendered object according to the obtained data of the object to be rendered so as to facilitate the completion of the rendering work.
Specifically, rendering the batch renderings according to the data of the to-be-rendered objects comprises: after the batch of rendering data is filled into the data buffer area, the rendering is subjected to Position synchronization processing in the data buffer area, wherein the relative displacement (Position), scaling (Scale) and Rotation (Rotation Matrix) of the rendering are combined according to 4x4 Matrix processing, and the combination formula is as follows:
in the above formula: tX, tY, tZ denote relative displacement Position, sX, sY, sZ denote zoom, and rotate (rotamindatarix) the localmatrix calculated by the above steps.
And synchronizing matrix data of the rendering object in the world coordinate system into a matrix buffer (matrix buffer) according to the initial position of the data buffer to complete position synchronization of the rendering object, so that rendering flow drawing of batch rendering objects is completed.
Further, if the rendered object is in a hidden state, the scaling value in the matrix data process of the synchronous rendered object is adjusted to a minimum value (such as 0.0000000001) to make it in a tiny invisible state in the rendering process, and the original shader code of the rendered object is executed to perform the rendering process, so as to recover the original rendering flow of the rendered object; and if the render object is in a state to be rendered, shielding the original rendering process of the render object, and not executing the original shader code of the render object for rendering, so that the situation of repeated rendering is avoided.
Step S103: and performing batch rendering on the batch rendering objects according to rendering flow drawing.
And performing batch rendering on batch rendering objects according to rendering flow drawing, and specifically performing batch rendering on batch rendering objects completing position synchronization.
And after the rendering of the render is finished, marking the position as an idle state according to the position information of the matrix buffer area so as to be used by the newly added render.
Step S104: and deleting the batch rendering flow for the renderings.
Furthermore, the invention also comprises a batch rendering flow for deleting the rendering object, and in the batch rendering process, when the rendering data transmitted by the data buffer area of the rendering object is modified or the animation is played, the batch rendering flow is deleted for the rendering object. Specifically, the data is modified or the animation operation is played while a batch rendering process is notified to perform corresponding data processing, a scaling value in the matrix data process of the synchronous rendering object is adjusted to a minimum value (for example, 0.0000000001), so that the matrix data is in a tiny invisible state in the rendering process, and the original shader code of the rendering object is executed to perform the rendering process, so as to recover the original rendering process of the rendering object and avoid erroneous rendering.
Based on the same inventive concept, the embodiment of the present invention further provides a device for processing a render object in batch, where the device for processing a render object in batch may be, for example, a server, and the device for processing a render object in batch may be a hardware structure, a software module, or a hardware structure plus a software module. Based on the above embodiments, referring to fig. 3, a schematic structural diagram of a batch processing rendering device in an embodiment of the present invention specifically includes:
the first obtaining module 300: for obtaining data buffer data, the data buffer data comprising: the starting position of the data buffer area and the length of the data buffer area;
the second obtaining module 301: the data buffer area is filled with the batch rendering object data from the initial position of the data buffer area in sequence to obtain object data to be rendered;
rendering process drawing module 302: the system is used for rendering the batch renderings according to the data of the to-be-rendered objects;
the rendering module 303: the rendering device is used for rendering the rendered objects in batch according to the rendering flow drawing.
Optionally, the second obtaining module 301 is further configured to: obtaining vertex data of a rendered object, and generating a first key value pair according to a first rule; acquiring rendered object shader data, and generating a second key value pair according to a second rule; and combining the first key-value pair and the second key-value pair through an MD5 algorithm to generate a third key-value pair.
Optionally, the second obtaining module 301 is further configured to: and searching the data buffer area corresponding to the batch renderings in an idle buffer area according to the third key value pair. Comparing the total byte length in the third key value pair with the total byte length in the idle buffer area; when the total byte length in the third key value pair is not less than the total byte length of the idle buffer area, determining that the data buffer area corresponding to the batch renderings exists in the idle buffer area; and when the total byte length in the third key value pair is smaller than the total byte length of the idle buffer area, creating the data buffer area.
Optionally, the embodiment of the present invention further includes a marking module, configured to mark the position as an idle state according to the position information of the matrix buffer after the batch renderings are completed.
Based on the above embodiments, please refer to fig. 4, fig. 4 is a schematic structural diagram of an electronic device according to an embodiment of the present invention.
An embodiment of the present invention provides an electronic device, which may include a processor 410 (CPU), a memory 420, an input device 430, an output device 440, and the like, wherein the input device 430 may include a keyboard, a mouse, a touch screen, and the like, and the output device 440 may include a display device, such as a Liquid Crystal Display (LCD), a Cathode Ray Tube (CRT), and the like.
The processor 410 is configured to execute any one of the batch processing rendering methods according to the embodiments of the present invention according to the obtained program instructions by calling the program instructions stored in the memory 420.
Based on the above embodiments, in an embodiment of the present invention, a computer-readable storage medium is provided, on which a computer program is stored, and the computer program, when executed by a processor, implements a method for batch processing of a rendered object in any of the above method embodiments.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to the invention. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents.
Claims (10)
1. A method of batch processing a rendered object, comprising:
acquiring data of a data buffer area, wherein the data of the data buffer area comprises: the starting position of the data buffer area and the length of the data buffer area;
acquiring batch render data, and sequentially filling the batch render data into the data buffer area from the initial position of the data buffer area to obtain data of an object to be rendered;
rendering the batch renderings according to the data of the to-be-rendered objects;
and performing batch rendering on the batch rendering objects according to the rendering flow drawing.
2. The method of claim 1, wherein the obtaining batch render data comprises:
obtaining vertex data of a rendered object, and generating a first key value pair according to a first rule;
acquiring rendered object shader data, and generating a second key value pair according to a second rule;
combining the first and second key-value pairs by an MD5 algorithm to generate a third key-value pair.
3. The method of claim 2, further comprising, prior to the sequentially filling the batch render data from the data buffer starting location to the data buffer:
and searching a data buffer area corresponding to the batch renderings in an idle buffer area according to the third key value pair.
4. The method according to claim 3, wherein the searching for the data buffer corresponding to the batch renderings in an idle buffer according to the third key value pair specifically comprises:
comparing the total byte length in the third key value pair with the total byte length in the idle buffer area;
when the total byte length in the third key value pair is not less than the total byte length of the idle buffer area, determining that a data buffer area corresponding to the batch renderings exists in the idle buffer area;
and when the total byte length in the third key value pair is smaller than the total byte length of the idle buffer area, creating a data buffer area.
5. The method of claim 1, further comprising, before the batch rendering the render according to the rendering flow rendering,:
and when the data of the object to be rendered is changed or/and the animation is played, deleting the current rendered object.
6. The method of claim 5, further comprising, after the deleting the current render:
and acquiring the vertex data and the shader data of the current render object, and rendering according to the vertex data and the shader data.
7. The method of claim 1, after the batch rendering the render object according to the rendering flow rendering, further comprising:
and after the batch rendering objects are rendered, marking the positions of the batch rendering objects in an idle state according to the position information of the matrix buffer area.
8. An apparatus for rendering a thing in batch, comprising:
a first obtaining module, configured to obtain data in a data buffer, where the data in the data buffer includes: the starting position of the data buffer area and the length of the data buffer area;
the second acquisition module is used for acquiring batch render data and sequentially filling the batch render data into the data buffer area from the initial position of the data buffer area to obtain the data of the object to be rendered;
the rendering flow drawing module is used for rendering flow drawing of the batch renderings according to the data of the objects to be rendered;
and the rendering module is used for rendering the batch rendering objects in batch according to the rendering flow drawing.
9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method of any of claims 1 to 7 when executing the computer program.
10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211328266.XA CN115861505A (en) | 2022-10-27 | 2022-10-27 | Method, device, equipment and medium for batch processing of rendered objects |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211328266.XA CN115861505A (en) | 2022-10-27 | 2022-10-27 | Method, device, equipment and medium for batch processing of rendered objects |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115861505A true CN115861505A (en) | 2023-03-28 |
Family
ID=85661975
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211328266.XA Pending CN115861505A (en) | 2022-10-27 | 2022-10-27 | Method, device, equipment and medium for batch processing of rendered objects |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115861505A (en) |
-
2022
- 2022-10-27 CN CN202211328266.XA patent/CN115861505A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109840931B (en) | Batch rendering method, device and system for skeletal animation and storage medium | |
| US10255650B2 (en) | Graphics processing using dynamic resources | |
| US9715750B2 (en) | System and method for layering using tile-based renderers | |
| US8345059B2 (en) | Methods, systems, and data structures for generating a rasterizer | |
| CN109260708A (en) | Map rendering method, device and computer equipment | |
| KR100928192B1 (en) | Offline optimization pipeline for 3D content on embedded devices | |
| CN105183764B (en) | A kind of data paging method and device | |
| CN107251004A (en) | The backward compatibility realized by using deception clock and fine-grained frequency control | |
| US11397608B2 (en) | Multi-dimensional spreadsheet system enabling stack based programming using a virtual machine | |
| CN111145329A (en) | Model rendering method and system and electronic device | |
| EP2550617A2 (en) | Sequential layout builder | |
| CN109634611B (en) | Mobile terminal three-dimensional model ply file analysis and display method based on OpenGL | |
| US9324299B2 (en) | Atlasing and virtual surfaces | |
| CN111414150B (en) | Game engine rendering method and device, electronic equipment and computer storage medium | |
| EP2550618B1 (en) | Sequential layout builder architecture | |
| CN109598672B (en) | Map road rendering method and device | |
| CN115861505A (en) | Method, device, equipment and medium for batch processing of rendered objects | |
| US20130063482A1 (en) | Application programming interface for a bitmap composition engine | |
| CN116109767A (en) | Rendering method of three-dimensional scene, image processor, electronic device and storage medium | |
| CN111243069B (en) | Scene switching method and system of Unity3D engine | |
| CN115040869A (en) | Method and system for displaying 3D game object brief information | |
| US20070206021A1 (en) | Adapting and rendering graphic effects | |
| WO2024045701A9 (en) | Data processing method and apparatus, and device and storage medium | |
| CN114996491A (en) | Method and system for optimizing display performance of all-liquid-crystal instrument | |
| CN117333599A (en) | Method for creating rendering state based on multithreading, rendering device and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |