CN114581596A - Geometric body fast rendering method based on graphic processing unit GPU drive - Google Patents

Abstract

Embodiments of the present disclosure provide methods, electronic devices, and computer program products related to Graphics Processing Unit (GPU) -driven geometry-based fast rendering. The method includes determining, in a cache of the GPU, respective buffers according to respective types and respective rendering attributes of a plurality of geometric shapes in a target scene. The method also includes populating rendering parameters for each geometric form to a respective buffer according to the priority. The method also includes generating a view frustum based on the plurality of geometric shapes and the perspective parameters associated with the target scene, and removing, using the GPU, rendering parameters for geometric shapes outside of the view frustum range from the respective buffers. And the method further comprises generating a rendered target scene using the shader based on the rendering parameters remaining in the corresponding buffer. By the embodiment of the disclosure, the rendering frame rate can be improved, the load of a Central Processing Unit (CPU) can be reduced, and the data volume of communication between the GPU and the CPU can be reduced.

Description

A method for fast rendering of geometric shapes based on graphics processing unit GPU

technical field

Embodiments of the present disclosure relate to the field of computers, and more particularly, to methods, electronic devices, apparatuses, media, and computer program products for fast rendering of geometric shapes based on graphics processing units (GPUs).

Background technique

In the prior art, the rendering of geometry by modeling software products generally implements discrete geometry data on the CPU side (for example, discretizes the geometry data into triangular patches), and then converts the triangular patch data on the GPU side. Rendered by the corresponding GPU rendering pipeline. In this way, the amount of data communicated between the CPU and the GPU is large, and the CPU has a large amount of calculation when calculating the geometric data to be discrete, and the computing power of the GPU is wasted at this time, resulting in a higher final rendering frame rate. Low, the rendered visual effect is poor, which reduces the user experience. Therefore, a rendering method is urgently needed, by which the load of the central processing unit CPU can be reduced, the amount of data communicated between the GPU and the CPU can be reduced, and the rendering frame rate can be improved.

SUMMARY OF THE INVENTION

Embodiments of the present disclosure provide a method, electronic device, apparatus, medium, and computer program product for fast rendering of geometry based on GPU driving.

According to a first aspect of the present disclosure, a method for fast rendering of geometric shapes based on GPU is provided. The method includes determining a corresponding buffer in a cache of the GPU according to the corresponding types and corresponding rendering attributes of multiple geometric bodies in the target scene, and the corresponding buffer corresponds to the corresponding GPU rendering in the multiple GPU rendering pipelines in the GPU pipeline. The method also includes, according to the predetermined priority, filling the rendering parameter of each geometrical shape of the plurality of geometrical shapes into the corresponding buffer according to the priority. The method also includes generating a view frustum based on the plurality of geometries in the target scene and viewing angle parameters associated with the target scene, using the GPU to remove the rendering parameters of the geometry outside the view frustum from the corresponding buffers . And the method further includes using at least one shader in the GPU rendering pipeline to generate a rendered target scene based on the remaining rendering parameters in the corresponding buffer, wherein the remaining rendering parameters represent the geometry to be rendered.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate the first plurality of Triangular patch data. and rendering the target scene based on the first plurality of triangular patch data.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a geometry shader in the GPU rendering pipeline to generate the second plurality of triangular faces slice data. and rendering the target scene based on the second plurality of triangular patch data.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate a third plurality of Triangular patch data. Based on the third plurality of triangular patch data, the geometry shader in the GPU rendering pipeline is used to generate the fourth plurality of triangular patch data, wherein the number of the fourth plurality of triangular patch data is greater than that of the third plurality of triangular patch data number. and rendering the target scene based on the fourth plurality of triangular patch data.

In some embodiments, the frustum is determined by generating a bounding box for each of the plurality of geometries using a hull shader in the GPU rendering pipeline based on the rendering parameters remaining in the corresponding buffer . Through matrix transformation, the bounding box of each geometric body is transformed to the standard device space, and the transformation satisfies the display characteristics of normalized device coordinates. And the bounds of the transform are determined as the bounds of the view frustum.

In some embodiments, where a plurality of geometries are classified into respective types by a scene management tree, the scene management tree indicates the type of geometry and the relationship between the subtypes of each type.

In some embodiments, the type of geometry includes a solid, wherein the geometry belonging to the solid has a geometric shape that can be represented using parameters. A curvilinear surface, where the geometry that is a curvilinear surface has a surface that can be represented using equations. Triangular patches, in which geometry that is not a solid or curved surface is a triangular patch.

In some embodiments, the plurality of geometries are represented using Building Information Modeling BIM data.

According to a second aspect of the present disclosure, there is also provided an electronic device. The electronic device includes a processor, a graphics processing unit GPU, and a memory coupled together or separately with the processor and the GPU, the memory having instructions stored therein, a memory coupled to the processor and the GPU, the memory having instructions stored therein, When executed by the processor, the instruction causes the electronic device to perform the following actions: causing the processor to determine a corresponding buffer in the cache of the GPU according to the corresponding types and corresponding rendering attributes of the plurality of geometric shapes in the target scene, and the corresponding buffer corresponds to A corresponding GPU rendering pipeline among the multiple GPU rendering pipelines in the GPU. According to a predetermined priority, the rendering parameters of each of the plurality of geometric shapes are filled into the corresponding buffer according to the priority. The instructions, when executed by the GPU, cause the electronic device to perform the following actions: generate a view frustum based on a plurality of geometric shapes in the target scene and viewing angle parameters associated with the target scene, use the GPU to convert the geometry outside the view frustum The rendering parameters are removed from the corresponding buffer. A rendered target scene is generated using at least one shader in the GPU rendering pipeline based on the remaining rendering parameters in the corresponding buffer, wherein the remaining rendering parameters represent the geometry to be rendered.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate the first plurality of Triangular patch data. and rendering the target scene based on the first plurality of triangular patch data.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a geometry shader in the GPU rendering pipeline to generate the second plurality of triangular faces slice data. and rendering the target scene based on the second plurality of triangular patch data.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate a third plurality of Triangular patch data. Based on the third plurality of triangular patch data, the geometry shader in the GPU rendering pipeline is used to generate the fourth plurality of triangular patch data, wherein the number of the fourth plurality of triangular patch data is greater than that of the third plurality of triangular patch data number. and rendering the target scene based on the fourth plurality of triangular patch data.

In some embodiments, the frustum is determined by generating a bounding box for each of the plurality of geometries using a hull shader in the GPU rendering pipeline based on the rendering parameters remaining in the corresponding buffer . Through matrix transformation, the bounding box of each geometric body is transformed to the standard device space, and the transformation satisfies the display characteristics of normalized device coordinates. And the bounds of the transform are determined as the bounds of the view frustum.

In some embodiments, where a plurality of geometries are classified into respective types by a scene management tree, the scene management tree indicates the type of geometry and the relationship between the subtypes of each type.

In some embodiments, the type of geometry includes a solid, wherein the geometry belonging to the solid has a geometric shape that can be represented using parameters. A curvilinear surface, where the geometry that is a curvilinear surface has a surface that can be represented using equations. Triangular patches, in which geometry that is not a solid or curved surface is a triangular patch.

In some embodiments, the plurality of geometries are represented using Building Information Modeling BIM data.

According to a third aspect of the present disclosure, an apparatus for fast rendering of geometric shapes based on GPU is provided. The device includes a buffer determination module configured to determine corresponding buffers in a GPU cache according to corresponding types and corresponding rendering attributes of a plurality of geometric shapes in a target scene, and the corresponding buffers correspond to a plurality of The corresponding GPU rendering pipeline in the GPU rendering pipeline. The apparatus further includes a filling module configured to fill the rendering parameters of each geometric shape in the plurality of geometric shapes into the corresponding buffer according to the priority according to the predetermined priority. The apparatus further includes generating a view frustum based on the plurality of geometric shapes in the target scene and viewing angle parameters associated with the target scene, and using the GPU to remove the rendering parameters of the geometric shapes outside the range of the view frustum from the corresponding buffers . And the apparatus further includes generating a rendered target scene using at least one shader in the GPU rendering pipeline based on the remaining rendering parameters in the corresponding buffer, wherein the remaining rendering parameters represent the geometry to be rendered.

According to a fourth aspect of the present disclosure, there is provided a computer-readable storage medium comprising machine-executable instructions which, when executed by an apparatus, cause the apparatus to perform the method according to the first aspect of the present disclosure.

According to a fifth aspect of the present disclosure, there is provided a computer program product tangibly stored on a computer-readable medium and comprising machine-executable instructions that, when executed by an apparatus, cause the apparatus to perform the method on the one hand.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary section is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to limit the scope of the claimed subject matter.

Description of drawings

The above and other features, advantages and aspects of various embodiments of the present disclosure will become more apparent when taken in conjunction with the accompanying drawings and with reference to the following detailed description. In the drawings, the same or similar reference numbers refer to the same or similar elements, wherein:

1 shows a schematic diagram of an example environment in which embodiments of the present disclosure can be implemented;

FIG. 2 schematically shows a schematic diagram of a scene management tree according to an embodiment of the present disclosure;

3 schematically shows a schematic diagram of a GPU rendering pipeline according to an embodiment of the present disclosure;

FIG. 4 schematically shows a schematic diagram of a viewing frustum according to an embodiment of the present disclosure;

5A schematically shows a schematic diagram of a shader according to an exemplary implementation of the present disclosure;

5B schematically illustrates a schematic diagram of a tessellated shader in a tessellation shader according to an exemplary implementation of the present disclosure;

6 schematically shows a flowchart of a method for GPU-driven geometry rendering according to an exemplary implementation of the present disclosure;

FIG. 7 schematically illustrates a block diagram of an apparatus for GPU-driven geometry rendering according to an exemplary implementation of the present disclosure; and

8 schematically illustrates a block diagram of an apparatus for GPU-driven geometry rendering according to an exemplary implementation of the present disclosure.

Throughout the drawings, the same or similar reference numbers refer to the same or similar elements.

Detailed ways

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. While certain embodiments of the present disclosure are shown in the drawings, it should be understood that the present disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein, but rather are provided for the purpose of A more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are only for exemplary purposes, and are not intended to limit the protection scope of the present disclosure.

In the description of embodiments of the present disclosure, the term "including" and the like should be construed as inclusive, ie, "including but not limited to". The term "based on" should be understood as "based at least in part on". The terms "one embodiment" or "the embodiment" should be understood to mean "at least one embodiment". The terms "first", "second", etc. may refer to different or the same objects. Other explicit and implicit definitions may also be included below.

In addition, all specific numerical values herein are examples, are provided only to aid understanding, and are in no way intended to limit the range.

The inventors have noticed that the rendering of geometric shapes by existing modeling software products generally implements the discrete geometric shape data on the CPU side (for example, the geometric shape data is discretized into triangular patches), and then the triangular surfaces are separated on the GPU side. Slice data is rendered by the corresponding GPU rendering pipeline. In this way, communication between the CPU and GPU is required, and the amount of data is large. When the CPU calculates the geometry data to be discrete, the calculation amount is large, while the GPU is idle at this time, and the parallel computing power of the two is wasted. In this way, the final rendering frame rate may be lower, the rendered visual effect may be poor, and the user experience may be degraded. Therefore, there is an urgent need for a rendering method by which the load of the CPU can be reduced, the amount of data communicated between the GPU and the CPU can be reduced, and the rendering frame rate can be improved.

In view of this, the method of the present disclosure provides a method for GPU-driven geometry rendering. Using this method, part of the process in the original CPU can be transferred to the GPU, so that both the CPU and the GPU can perform parallel computing, which improves the computing efficiency while reducing the CPU compliance, and reduces the communication between the CPU and the GPU. The amount of data increases the rendering frame rate.

In the following description, certain embodiments will be discussed with reference to write access. However, it should be understood that this is only for a better understanding of the principles and ideas of the embodiments of the present disclosure, and is not intended to limit the scope of the present disclosure in any way.

1 shows a schematic diagram of an example environment 100 in which embodiments of the present disclosure can be implemented. As shown in FIG. 1, at a computing resource 101 (eg, a computer system, server, etc.), a computerized representation of a target scene is obtained (eg, received), eg, data of the target scene described using a building information model (BIM), which Examples of BIM data include, for example, model elements, temporary elements, model data with graphics, non-graphical parameter data, other forms of result data (text, pictures, XML, etc.). Based on these data, the characteristics of the corresponding geometric shapes in the target scene are reflected, and each geometric shape is a separate parametric geometric representation. Computing resources 101 include a central processing unit CPU 102 and a graphics processing unit GPU 103 . As should be possible, both CPU 102 and GPU 103 may have multiple cores (not shown).

It should be understood that the example environment 100 shown in FIG. 1 is illustrative only and is not intended to limit the scope of the present disclosure. Various additional devices, apparatus, and/or modules may also be included in the example environment 100 . Moreover, the modules shown in FIG. 1 are also only schematic and are not intended to limit the scope of the present disclosure. In some embodiments, certain modules may be integrated into one physical entity, or further split into more modules.

FIG. 2 schematically shows a schematic diagram of a scene management tree 200 according to an embodiment of the present disclosure.

As shown, the scene management tree indicates the types of geometry and the relationship between the subtypes of each type. Using the scene management tree, the target scene can be divided into different geometries. Combining with the scene management tree, it can be seen that the first layer of the scene management tree includes solids, curved surfaces and triangular patches. A solid can be understood as one in which the geometry belonging to the solid has a geometric shape that can be represented using parameters. For example, a sphere can be expressed as the size of the radius and the mathematical formula for the sphere. A curved surface can be understood as one in which the geometry belonging to a curved surface has a surface that can be represented using equations. For example, Bezier surfaces, B-spline surfaces. A triangular patch can be understood as a geometry that does not belong to a solid or curved surface as a triangular patch. A triangular patch is a type that cannot be expressed structured with parameters.

Subtypes of each type can be further divided. For example, subtypes of solid types include face, sphere, cylinder, torus, extruded body, revolved body, swept body, and so on. Subtypes of curve surface types include Bezier surfaces, B-spline surfaces, rational Bezier surfaces, and more. Since triangular patches cannot be represented structurally with parameters, there are no subtypes.

FIG. 3 schematically shows a schematic diagram of a GPU rendering pipeline 300 according to an embodiment of the present disclosure. As shown, the GPU rendering pipeline 300 may include a vertex stage 301 in which coordinate transformations are performed and data required for subsequent stages is output. A tessellation stage 302, in which improved geometric fidelity of the geometry is implemented. Geometry stage 303, in which geometry data is refined. Fragmentation stage 304, in which data information is generated describing how a triangular mesh covers each pixel.

FIG. 4 schematically shows a schematic diagram of a view frustum 400 according to an embodiment of the present disclosure.

As shown in the figure, the viewing frustum 400 can be obtained through cubic coordinate transformation according to the coordinate system of the target scene itself. First, transform the coordinate system of the target scene itself into the world coordinate system. Then, convert the world coordinate system to the view space coordinate system, project the obtained coordinates in the view space coordinate system to the clipping space, and obtain the view frustum 400 conforming to the normalized device coordinate display characteristics through perspective division. It can be understood that this process "compresses" the target scene in the three-dimensional space into a two-dimensional screen, and observes it from the perspective of the human eye, so the resulting cone is called a "view cone". Geometry outside the view frustum 400 does not need to be rendered. This process, also known as "culling", prevents invalid geometry from being rendered and affects rendering performance.

5A schematically shows a schematic diagram of a shader according to an exemplary implementation of the present disclosure.

As shown in the figure, the shader may include a vertex shader 501 , and the vertex data may be transformed by using the vertex shader 501 . The tessellation shader 502 is an optional stage of the GPU rendering pipeline. Using the tessellation shader 502 can enrich the mesh details and improve the fidelity of the geometry by increasing the number of triangles. The geometry shader 503 is an optional stage of the GPU rendering pipeline. Using the geometry shader 503, the input points or lines can be expanded into polygons to complete the geometry data. Fragment shader 504, using fragment shader 504, can determine the final color of pixels on the screen. In this stage, lighting calculation and shadow processing are performed, which is where the advanced effects of the GPU rendering pipeline are generated.

5B schematically shows a schematic diagram of a tessellated shader in a tessellation shader according to an exemplary implementation of the present disclosure.

As shown in the figure, some subdivision parameters, subdivision factors of internal parameters and other data are defined in the hull shader 505, and the bounding box of the triangular patch is generated for culling and other operations. The tessellator 506 is not programmable, and is processed by the hardware itself according to the parameters configured in the hull shader 505 to perform data segmentation operations. In the domain shader 507, the actual vertex coordinates are calculated patch by patch and based on the subdivision factor and the tessellated vertex UV data, and are converted into homogeneous clipping space to generate the display data required by the program for subsequent rendering .

FIG. 6 schematically shows a flowchart of a method 600 for fast rendering of geometry based on GPU driven according to an exemplary implementation of the present disclosure.

At block 602, according to the corresponding types and corresponding rendering attributes of the plurality of geometries in the target scene, corresponding buffers are determined in the cache of the GPU, the corresponding buffers correspond to corresponding ones of the plurality of GPU rendering pipelines in the GPU GPU rendering pipeline.

In some embodiments, according to the scene management tree, which geometric bodies are included in the target scene are extracted, and according to the types and rendering parameters of these geometric bodies, the geometric body types and corresponding rendering parameters are stored as entries. This entry can be updated. Rendering parameters can include colors, graphs, values, etc. For each geometry, in the GPU cache, a buffer is determined to store these entries. Each buffer corresponds to the corresponding GPU rendering pipeline and is rendered in its own rendering stage.

At block 604, according to the predetermined priority, the rendering parameters of each geometry of the plurality of geometries are filled into the corresponding buffer according to the priority.

In some embodiments, based on the principle of maximizing rendering performance, corresponding priorities are determined for different types of geometry. Fill the corresponding buffer with the corresponding geometry type and the corresponding rendering parameters. Then, for each buffer, the geometry belonging to the buffer is traversed, and the graphics application is called for graphics rendering.

In this way, in the subsequent steps, the process originally in the CPU can be transferred to the GPU, thereby reducing the data communication between the CPU and the GPU, and reducing the consumption of rendering bandwidth.

At block 606, a view frustum is generated based on the plurality of geometries in the target scene and the viewing angle parameters associated with the target scene, using the GPU to shift the rendering parameters of the geometry outside the view frustum from the corresponding buffers remove.

It can be understood that the removed geometry (represented by the corresponding rendering parameters) is content that cannot be observed from a human perspective, and therefore does not need to be rendered.

At block 608, a rendered target scene is generated using at least one shader in the GPU rendering pipeline based on the remaining rendering parameters in the respective buffers, wherein the remaining rendering parameters represent the geometry to be rendered.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate the first plurality of triangles patch data. and rendering the target scene based on the first plurality of triangular patch data.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using the geometry shader in the GPU rendering pipeline to generate the second plurality of triangular patches data. and rendering the target scene based on the second plurality of triangular patch data.

In some embodiments, wherein generating the rendered target scene using at least one shader in the GPU rendering pipeline includes discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate the third plurality of triangles patch data. Based on the third plurality of triangular patch data, the geometry shader in the GPU rendering pipeline is used to generate the fourth plurality of triangular patch data, wherein the number of the fourth plurality of triangular patch data is greater than that of the third plurality of triangular patch data number. and rendering the target scene based on the fourth plurality of triangular patch data.

For example, the generated third plurality of triangular patch data includes 10 pieces of data, and then 4 pieces of data are generated again for each of the 10 pieces of data, so that 4*10 pieces of data can be generated in total. In this way, it can be understood that by generating the fourth plurality of triangular patch data based on the generated third plurality of triangular patch data, a more delicate rendering effect can be obtained, and thus the user experience can be improved.

In some embodiments, a polygon decomposition algorithm or a vertex normal vector interpolation algorithm may be used to generate more fine-grained multiple triangular patch data, and a tessellation shader may be used to generate the rendered target scene.

By using the polygon decomposition algorithm or the vertex normal vector interpolation algorithm, the surface of the geometric body can be simulated and expressed with more delicate multi-elements. Therefore, the rendered target scene can enhance the user experience.

In some embodiments, the view frustum is determined by generating a bounding box for each of the plurality of geometries using a hull shader in the GPU rendering pipeline based on the rendering parameters remaining in the corresponding buffer. Through matrix transformation, the bounding box of each geometry is transformed into standard device space, and the transformation satisfies the display characteristics of Normalized Device Coordinates. And the bounds of the transform are determined as the bounds of the view frustum.

In some embodiments, the plurality of geometries are classified into respective types by a scene management tree indicating the types of geometries and the relationship between subtypes of each type.

In some embodiments, the types of the geometry include: solid, wherein the geometry belonging to the solid has a geometry that can be represented using parameters; curvilinear surfaces, wherein the geometry belonging to the curvilinear surface has a geometry that can be represented using equations The surface of ; a triangular patch in which geometry that does not belong to the solid or the curvilinear surface belongs to the triangular patch.

In some embodiments, the plurality of geometries are represented using Building Information Modeling BIM data.

Pseudocode for a computer program implementing embodiments of the present disclosure is provided below.

The architecture of the GPU-driven rendering algorithm used in the embodiment of the present invention is as follows, and the main steps are reflected in the code comments.

The GPU-driven sphere generation algorithm used in the embodiment of the present invention is as follows, wherein the main steps are reflected in the code comments:

The GPU-driven rational Bezier curve surface generation algorithm used in the embodiment of the present invention is as follows, and the main steps are reflected in the code comments.

It can be understood that, through the method 600, a part of the process performed in the original CPU (such as the processes shown in block 606 and block 608) can be transferred to the GPU for completion, so that both the CPU and the GPU can perform parallel computing, reducing the CPU compliance rate. At the same time, the computing efficiency is improved, the load between the CPU and the GPU is balanced, the amount of data communicated between the CPU and the GPU is reduced, and the rendering frame rate is improved. In addition, through the use of different shaders in each rendering stage, the rendering effect is more delicate and the user experience is increased.

FIG. 7 schematically shows a block diagram of an apparatus for fast rendering of geometry based on GPU driven according to an exemplary implementation of the present disclosure.

The buffer determining module 702 is configured to determine corresponding buffers in the cache of the GPU according to the corresponding types and corresponding rendering attributes of the multiple geometric shapes in the target scene, and the corresponding buffers correspond to multiple GPU renderings in the GPU The corresponding GPU rendering pipeline in the pipeline.

The filling module 704 is configured to fill the rendering parameters of each geometric shape in the plurality of geometric shapes into the corresponding buffer according to the priority according to the predetermined priority.

The rendering parameter removal module 706 is configured to generate a viewing frustum based on a plurality of geometric shapes in the target scene and viewing angle parameters associated with the target scene, and use the GPU to change the rendering parameters of the geometric shapes outside the range of the viewing frustum from the corresponding ones. removed from the buffer.

The rendering module 708 is configured to generate a rendered target scene using at least one shader in the GPU rendering pipeline based on the remaining rendering parameters in the corresponding buffer, wherein the remaining rendering parameters represent the geometry to be rendered.

It can be understood that the apparatus 700 can also achieve beneficial technical effects as can be achieved by the method 600 .

FIG. 8 shows a schematic block diagram of a device 800 that can be used to implement an embodiment of the present disclosure, and the device 800 can be the device or apparatus described in the embodiment of the present disclosure. As shown in FIG. 8, device 800 includes a central processing unit (CPU) 801 that may be loaded into random access memory (RAM) 803 according to computer program instructions stored in read only memory (ROM) 802 or from storage unit 808 computer program instructions to perform various appropriate actions and processes. In the RAM 803, various programs and data necessary for the operation of the device 800 can also be stored. The CPU 801 , the ROM 802 , and the RAM 803 are connected to each other through a bus 804 . An input/output (I/O) interface 805 is also connected to bus 804 . Although not shown in Figure 8, device 800 may also include a co-processor.

Various components in the device 800 are connected to the I/O interface 805, including: an input unit 806, such as a keyboard, mouse, etc.; an output unit 807, such as various types of displays, speakers, etc.; a storage unit 808, such as a magnetic disk, an optical disk, etc. ; and a communication unit 809, such as a network card, a modem, a wireless communication transceiver, and the like. The communication unit 809 allows the device 800 to exchange information/data with other devices through a computer network such as the Internet and/or various telecommunication networks.

The various methods or processes described above may be performed by the processing unit 801 . For example, in some embodiments, a method may be implemented as a computer software program tangibly embodied on a machine-readable medium, such as storage unit 808 . In some embodiments, part or all of the computer program may be loaded and/or installed on device 800 via ROM 802 and/or communication unit 809 . When a computer program is loaded into RAM 803 and executed by CPU 801, one or more steps or actions in the methods or processes described above may be performed.

In some embodiments, the methods and processes described above may be implemented as a computer program product. The computer program product may include a computer-readable storage medium having computer-readable program instructions loaded thereon for carrying out various aspects of the present disclosure.

A computer-readable storage medium may be a tangible device that can hold and store instructions for use by the instruction execution device. The computer-readable storage medium may be, for example, but not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (non-exhaustive list) of computer readable storage media include: portable computer disks, hard disks, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM) or flash memory), static random access memory (SRAM), portable compact disk read only memory (CD-ROM), digital versatile disk (DVD), memory sticks, floppy disks, mechanically coded devices, such as printers with instructions stored thereon Hole cards or raised structures in grooves, and any suitable combination of the above. Computer-readable storage media, as used herein, are not to be construed as transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (eg, light pulses through fiber optic cables), or through electrical wires transmitted electrical signals.

The computer readable program instructions described herein can be downloaded to various computing/processing devices from a computer readable storage medium, or to an external computer or external storage device over a network, eg, the Internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and/or edge servers. A network adapter card or network interface in each computing/processing device receives computer-readable program instructions from a network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in each computing/processing device .

Computer program instructions for carrying out operations of the present disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, or instructions in one or more programming languages. Source or object code written in any combination of programming languages, including object-oriented programming languages, and conventional procedural programming languages. The computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server implement. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (eg, using an Internet service provider through the Internet connect). In some embodiments, custom electronic circuits, such as programmable logic circuits, field programmable gate arrays (FPGAs), or programmable logic arrays (PLAs), can be personalized by utilizing state information of computer readable program instructions. Computer readable program instructions are executed to implement various aspects of the present disclosure.

These computer readable program instructions may be provided to a processing unit of a general purpose computer, special purpose computer or other programmable data processing device to produce a machine that causes the instructions when executed by the processing unit of the computer or other programmable data processing device , resulting in means for implementing the functions/acts specified in one or more blocks of the flowchart and/or block diagrams. These computer readable program instructions can also be stored in a computer readable storage medium, these instructions cause a computer, programmable data processing apparatus and/or other equipment to operate in a specific manner, so that the computer readable medium on which the instructions are stored includes An article of manufacture comprising instructions for implementing various aspects of the functions/acts specified in one or more blocks of the flowchart and/or block diagrams.

Computer readable program instructions can also be loaded onto a computer, other programmable data processing apparatus, or other equipment to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus, or other equipment to produce a computer-implemented process , thereby causing instructions executing on a computer, other programmable data processing apparatus, or other device to implement the functions/acts specified in one or more blocks of the flowcharts and/or block diagrams.

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of instructions, which contains one or more operables for implementing the specified logical function(s) Execute the instruction. In some alternative implementations, the functions noted in the blocks may occur out of the order noted in the figures. For example, two blocks in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It is also noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented in dedicated hardware-based systems that perform the specified functions or actions, or It may be implemented in a combination of special purpose hardware and computer instructions.

Various embodiments of the present disclosure have been described above, and the foregoing descriptions are exemplary, not exhaustive, and not limiting of the disclosed embodiments. Numerous modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein was chosen to best explain the principles of the various embodiments, the practical application or technical improvement over technology in the marketplace, or to enable others of ordinary skill in the art to understand the various embodiments disclosed herein.

Although the disclosure has been described in language specific to structural features and/or methodological logical acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are merely example forms of implementing the claims.

Claims (19)

1. A geometry fast rendering method based on GPU drive comprises the following steps:

determining, in a cache of the GPU, respective buffers according to respective types and respective rendering attributes of a plurality of geometric shapes in a target scene, the respective buffers corresponding to respective ones of a plurality of GPU rendering pipelines in the GPU;

filling rendering parameters of each geometric body in the plurality of geometric bodies into the corresponding buffer area according to the priority determined in advance;

generating a view frustum based on the plurality of geometric shapes in the target scene and perspective parameters associated with the target scene, rendering parameters for geometric shapes outside the view frustum range being removed from the respective buffers using the GPU; and

generating a rendered target scene using at least one shader in the GPU rendering pipeline based on remaining rendering parameters in a respective buffer, wherein the remaining rendering parameters represent a geometric form to be rendered.

2. The method of claim 1, wherein generating a rendered target scene using at least one shader in the GPU rendering pipeline comprises:

discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate a first plurality of triangular patch data; and

rendering the target scene based on the first plurality of triangular patch data.

3. The method of claim 1, wherein generating a rendered target scene using at least one shader in the GPU rendering pipeline comprises:

discretizing the remaining rendering parameters using a geometry shader in the GPU rendering pipeline to generate a second plurality of triangular patch data; and

rendering the target scene based on the second plurality of triangular patch data.

4. The method of claim 1, wherein generating a rendered target scene using at least one shader in the GPU rendering pipeline comprises:

discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate a third plurality of triangular patch data;

generating, using a geometry shader in the GPU rendering pipeline, a fourth plurality of triangular patch data based on the third plurality of triangular patch data, wherein a number of the fourth plurality of triangular patch data is greater than a number of the third plurality of triangular patch data; and

rendering the target scene based on the fourth plurality of triangular patch data.

5. The method of claim 1, the view frustum being determined by:

generating, using a hull shader in the GPU rendering pipeline, bounding boxes for each geometry in the plurality of geometries based on rendering parameters remaining in a respective buffer;

transforming the bounding box of each geometric shape to a standard device space by matrix transformation, the transformation satisfying display characteristics of normalized device coordinates; and

determining the boundary of the transformation as the boundary of the view frustum.

6. The method of claim 1, wherein the plurality of geometric forms are classified into respective types by a scenario management tree indicating types of geometric forms and relationships between sub-types of each type.

7. The method of claim 1, the type of geometric form comprising:

an entity, wherein a geometric form belonging to said entity has a geometric shape that can be represented using parameters;

a curved surface, wherein a geometric shape belonging to the curved surface has a curved surface that can be expressed using an equation; and

a triangular patch to which a geometric shape that does not belong to the entity or the curvilinear surface belongs.

8. The method of claim 1, wherein the plurality of geometric forms are represented using Building Information Model (BIM) data.

9. An electronic device, comprising:

a processor;

a Graphics Processing Unit (GPU); and

a memory coupled, either in common with or separately from the processor and the GPU, the memory having instructions stored therein that, when executed by the processor, cause the electronic device to perform the actions of:

determining, in a cache of the GPU, respective buffers according to respective types and respective rendering attributes of a plurality of geometric shapes in a target scene, the respective buffers corresponding to respective ones of a plurality of GPU rendering pipelines in the GPU; and

filling rendering parameters of each geometric body in the plurality of geometric bodies into the corresponding buffer area according to the priority determined in advance;

the instructions, when executed by the GPU, cause the electronic device to perform the following:

generating a view frustum based on the plurality of geometric shapes in the target scene and perspective parameters associated with the target scene, rendering parameters for geometric shapes outside the view frustum range being removed from the respective buffers using the GPU; and

generating a rendered target scene using at least one shader in the GPU rendering pipeline based on remaining rendering parameters in a respective buffer, wherein the remaining rendering parameters represent a geometric form to be rendered.

10. The electronic device of claim 9, wherein generating a rendered target scene using at least one shader in the GPU rendering pipeline comprises:

discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate a first plurality of triangular patch data; and

rendering the target scene based on the first plurality of triangular patch data.

11. The electronic device of claim 9, wherein generating a rendered target scene using at least one shader in the GPU rendering pipeline comprises:

discretizing the remaining rendering parameters using a geometry shader in the GPU rendering pipeline to generate a second plurality of triangular patch data; and

rendering the target scene based on the second plurality of triangular patch data.

12. The electronic device of claim 9, wherein generating a rendered target scene using at least one shader in the GPU rendering pipeline comprises:

discretizing the remaining rendering parameters using a tessellation shader in the GPU rendering pipeline to generate a third plurality of triangular patch data;

generating, using a geometry shader in the GPU rendering pipeline, a fourth plurality of triangular patch data based on the third plurality of triangular patch data, wherein a number of the fourth plurality of triangular patch data is greater than a number of the third plurality of triangular patch data; and

rendering the target scene based on the fourth plurality of triangular patch data.

13. The method of claim 9, the view frustum being determined by:

generating, using a hull shader in the GPU rendering pipeline, bounding boxes for each geometry in the plurality of geometries based on the rendering parameters remaining within the respective buffer;

transforming the bounding box of each geometric shape to a standard device space by matrix transformation, the transformation satisfying display characteristics of normalized device coordinates; and

determining the boundary of the transformation as the boundary of the view frustum.

14. The electronic device of claim 9, wherein the plurality of geometric forms are classified into respective types by a scene management tree that indicates types of geometric forms and relationships between sub-types of each type.

15. The electronic device of claim 9, the types of geometric features comprising:

an entity, wherein a geometric form belonging to said entity has a geometric shape that can be represented using parameters;

a curved surface, wherein a geometric shape belonging to the curved surface has a curved surface that can be expressed using an equation; and

a triangular patch to which a geometric shape that does not belong to the entity or the curvilinear surface belongs.

16. The electronic device of claim 9, wherein the plurality of geometric forms are represented using Building Information Model (BIM) data.

17. An apparatus for Graphics Processing Unit (GPU) -driven geometry fast rendering, comprising:

a buffer determination module configured to determine, in accordance with respective types and respective rendering attributes of a plurality of geometric shapes in a target scene, a respective buffer in a cache of the GPU, the respective buffer corresponding to a respective GPU rendering pipeline of a plurality of GPU rendering pipelines in the GPU;

a filling module configured to fill rendering parameters of each of the plurality of geometric shapes to the respective buffer according to a predetermined priority;

a rendering parameter removal module configured to generate a view frustum based on the plurality of geometric shapes in the target scene and perspective parameters associated with the target scene, the rendering parameters for geometric shapes outside the view frustum range being removed from the respective buffers using the GPU; and

a rendering module configured to generate a rendered target scene using at least one shader in the GPU rendering pipeline based on remaining rendering parameters in a respective buffer, wherein the remaining rendering parameters represent geometric shapes to be rendered.

18. A computer readable storage medium having one or more computer instructions stored thereon, wherein the one or more computer instructions are executed by a processor to implement the method of any one of claims 1 to 8.

19. A computer program product comprising one or more computer instructions, wherein the one or more computer instructions are executed by a processor to implement the method of any one of claims 1 to 8.

Images