TECHNICAL FIELD

The disclosure relates generally to computer graphics, and more particularly, the disclosure relates to graphics rendering acceleration device and method.

BACKGROUND

In computer graphics, there are several major approaches for 3D renderings, such as rasterization, Bounding Volume Hierarchy (BVH)-based ray-tracing, tile-based architecture, etc. Existing real-time 3D rendering addresses three main issues; performance, flexibility, and quality. For example, the performance of the flexible methods (e.g. the BVH-based raytracing) are non-acceptable, as it is 100-1000000 times slower than the mainstream real-time solutions. Further, development of impressive special graphical effects based on the standard technologies is complex, expensive for business, and does not provide expected level of quality. Additionally, the mobile platforms are about 20 times slower in comparison with the same age desktops.

In the conventional tile-based rendering method, the geometry must be transformed into screen space and assigned to the tiles of frame-buffer. This requires some storage for the lists of triangles for each tile. Then the driver can rasterize tiles, one by one. Thereby temporary data for rasterization fit into a small high-speed cache. The other side of the rendering is the complex special effects, such as global illumination, volumetric fog, etc. Rendering of these effects requires understanding how elements of the scene are distributed in the space, relative to each other.

There are different methods to accelerate spatial requests such as BVH, kdTree, OctTree, MeshGrid, etc. They allow finding the interested objects in some 3D sub-space as fast as possible. Hereinafter they will be titles as acceleration structure or “AS”. It is possible to create a unified architecture of AS that allows to use most appropriate algorithm for the current situation, for example, BVH on the top level, and MeshGrid on the bottom. Typically, acceleration structure is a tree data structure with a different number of children’s nodes (2, 4, 8, N). Depth of the tree, a number of nodes, and other parameters depend on the use-cases and specifics of the platform. The last nodes (leaves) usually contain one or more triangles or other geometry. Usually, each node has information about its bounding volume. Important to understand that universal spatial acceleration structure can contain not only triangles or other geometry primitives but also any other spatial structures, for example, information about distribution of the light, fog, etc, if they have some certain volume in space.

Let’s define “acceleration structure” here as “spatial acceleration tree structure based on the nodes with volume”. BVH is an example of such an acceleration structure, not limiting the acceleration structure to BVH in the content of the present disclosure. In computer graphics, a shader is a type of computer program that was originally used for shading (the production of appropriate levels of light, darkness, and color within an image), but which now performs a variety of specialized functions in various fields of computer graphics special effects.

There are many complex special effects, which require access to the spatial structure of the scene such as advanced lighting, fog, projective texturing, and the like. If the computation power of GPU is limited, it will then be impossible to calculate all desired special effects. For example, calculation of the bidirectional reflectance distribution function (BRDF) for too many lights can be too complex. Further mixing of the different volumetric special effects can be too complex. Good optimization is to apply the volumetric special effect only to the pixels which will be significantly affected.

Typically, each light in the game engines has a function of power in the space. This defines “color” of the light, brightness, fading, and the volume in which that light is manifested. Usually, it can be a sphere, frustum, cone, and other dimensional shapes or all space for directional light. Optionally a shadow map can be added, that additionally specify the field of applicability of the light inside the shape and the combination of all in one structure will form a titled “light stream”.

A light stream can be placed into the acceleration structure, such as BVH, because it has some 3D volume. The 3D object in the spatial tree can be located with complexity O (log N), or in the mesh grid with O (1). For example, the developer can find all volumetric special effects intersecting some 3D object, triangle, or pixel, and use only necessary calculations. In real-time solutions, it can be difficult to apply a big number of spatial special effects in a plurality of specific places in a scene. Further, processing of multiple lights at a rasterization stage can be too complex and inaccurate for complex scenes, because conflict occurs between the required decomposition of the geometry and the number of draw-calls to send a lot of objects to rasterization. Especially it is complex for dynamic lights, because they require dynamic decomposition that contribute not only computation power, but also complicate the memory usage.

The pre-render procedures can be pretty long, because the object, volumetric special effects, and suitable shader need to be selected for the combination of all factors. As noted above, it can be too complex to mix the different volumetric special effects. For example, applying light in the fog, or dynamically processing lighting on the scene with a lot of clouds of smoke.

Therefore, there arises a need to address the aforementioned technical drawbacks in existing 3D graphics rendering integrated acceleration structures.

SUMMARY

It is an object of the disclosure to provide a graphics rending acceleration device and a graphics rendering acceleration method while avoiding one or more disadvantages of prior art approaches.

This object is achieved by the features of the independent claims. Further implementation forms are apparent from the dependent claims, the description, and the figures.

The disclosure provides a graphics rending acceleration device and a graphics rendering acceleration method.

According to a first aspect, there is provided a graphics rendering acceleration device. The device is configured to obtain an acceleration structure that includes a tree of nodes. Each node is associated with a bounding volume. Each leaf node is associated with a bounding volume and one or more primitives, and one or more nodes comprise one or more references to volume properties. Each volume property is a physical property set in a limited volume. The device being configured to obtain a projection volume, the projection volume is defined with respect to a camera in a scene. The device being configured to traverse the acceleration structure to process nodes within the projection volume so as to add references to volume properties from the node to a set of volume properties for each processed node and send the set of volume properties to a fragment shader for using the volume properties during rasterization of primitives from the leaf node for each processed leaf node.

Thus, the acceleration structure effectively expands functionals of the tile architecture so that the rasterized triangles receive information about volume properties in the corresponding space of a scene without significant increase in memory consumption. This sub-system of rendering pipeline allows to accelerate and increase power efficiency of complex special 3D effects. The graphics rendering acceleration system enables that the volumetric special effects, such as light, fog, space-specific light- and reflection- probes, and others, can be applied on affected triangles only. The graphics rendering acceleration system can be used in 10.000- 100.000 lights on the scene, even on mobile platforms, provided that only a small number of light sources affect individual parts of the scene. The graphics rendering acceleration system enables to simplify Tenderers of graphical engines.

Optionally, the references to volume properties comprise references to blocks of memory, such as a GPU memory, comprising data that describe corresponding physical properties.

Optionally, the set of volume properties is configured as a temporary stack.

Optionally, the one or more nodes comprising one or more references to volume properties are leaf nodes.

Optionally, the set of volume properties is written into a layer of a preliminary render target by the fragment shader.

Optionally, the device is configured to operate with a tile-based graphics rendering system and the projection volume comprises one or more frustums.

According to a second aspect, there is provided a graphics rendering acceleration method. The method includes obtaining an acceleration structure comprising a tree of nodes. Each node is associated with a bounding volume. Each leaf node is associated with a bounding volume and one or more primitives, and one or more nodes comprise one or more references to volume properties. Each volume property is a physical property set in a limited volume. The method includes obtaining a projection volume. The method includes traversing the acceleration structure to process nodes within the projection volume so as to for each processed node adding references to volume properties from the node to a set of volume properties; and for each processed leaf node, sending the set of volume properties to a fragment shader for using the volume properties during rasterization of primitives from the leaf node.

The graphics rendering acceleration method disclosed herein provides access to the volumetric properties specific for a processed node, such that volumetric special effects such as light, fog, space-specific light and reflection probes are applied only on the selected processed node. Further, parallelization of the processing stages of the processed node allows optimization of the memory usage. The graphics rendering acceleration method can be used in 10000-100000 lights on the scene, even on mobile platforms. The graphics rendering acceleration method doesn’t depend from a division space algorithm. The graphics rendering acceleration method can be applied to BVH, kdTree, OctTree, MeshGrid, and other methods, or their modifications. The graphics rendering acceleration method is easy to combine with other techniques of real-time rendering, for example, method ray-tracing. The graphics rendering acceleration method enables to simplify tenderers of graphical engines because it significantly simplifies management of objects on the scene.

Optionally, the references to volume properties comprise references to blocks of memory, such as a GPU memory, comprising data that describe corresponding physical properties.

Optionally, the set of volume properties is configured as a temporary stack.

Optionally, the one or more nodes comprising one or more references to volume properties are leaves.

Optionally, the method further includes writing the set of volume properties into a layer of a preliminary render target by the fragment shader.

Optionally, the method is used in a tile-based graphics rendering pipeline and the projection volume comprises one or more frustums.

A technical problem in the prior art is resolved, where the technical problem is how to support the volume properties of nodes in integrated spatial acceleration structures.

Therefore, in contradistinction to the prior arts, the graphics rendering acceleration device and method provided in the disclosure, allows to move the object scene into the spatial acceleration structure, configure corresponding volume properties and rasterize the scene using traversing. Further, the volume properties are collected in the acceleration structure hierarchy and the volume properties are locally processed in the corresponded primitives. This provides instant access to the properties of the space around the primitives. The graphics rendering acceleration system enables that the volumetric special effects, such as light, fog, space-specific light- and reflection- probes, and others, can be applied on affected triangles only. The graphics rendering acceleration system can be used in 10000-100000 lights on the scene, even on mobile platforms. The graphics rendering acceleration system enables to simplify Tenderers of graphical engines because it significantly simplifies management of objects on the scene

These and other aspects of the disclosure will be apparent from and the implementation (s) described below.

BRIEF DESCRIPTION OF DRAWINGS

Implementations of the disclosure will now be described, by way of example only, with reference to the following diagrams in which:

FIG. 1 is a block diagram that illustrates a graphics rendering acceleration device, in accordance with an implementation of the disclosure;

FIGS. 2A-2B illustrate examples of an integrated acceleration structure, in accordance with an implementation of the disclosure;

FIGS. 3A-3B illustrate examples of rendering pipelines with collecting volume properties, in accordance with an implementation of the disclosure;

FIG. 4 is an example illustration of parallelization of processing stages of the acceleration method, in accordance with an implementation of the disclosure; and

FIG. 5 is a flow diagram of a graphics rendering acceleration method in accordance with another implementation of the disclosure. DETAILED DESCRIPTION OF THE DRAWINGS

Implementations of the disclosure provide a graphics rendering acceleration system and a graphics rendering acceleration method which can be integrated into a system driver so that rasterized triangles receive information about volume properties in a corresponding space of a scene without significant costs.

To make the solutions of the disclosure more comprehensible for a person skilled in the art, the following Implementations of the disclosure are described with reference to the accompanying drawings.

Terms such as "a first", "a second", "a third", and "a fourth" (if any) in the summary, claims, and foregoing accompanying drawings of the disclosure are used to distinguish between similar objects and are not necessarily used to describe a specific sequence or order. It should be understood that the terms so used are interchangeable under appropriate circumstances, so that the Implementations of the disclosure described herein are, for example, capable of being implemented in sequences other than the sequences illustrated or described herein. Furthermore, the terms "include" and "have" and any variations thereof, are intended to cover a non-exclusive inclusion. For example, a process, a method, a system, a product, or a device that includes a series of steps or units, is not necessarily limited to expressly listed steps or units, but may include other steps or units that are not expressly listed or that are inherent to such process, method, product, or device.”

FIG. 1 is a block diagram that illustrates a graphics rendering acceleration device 100, in accordance with an implementation of the disclosure. The graphics rendering acceleration device 100 is configured to obtain an acceleration structure 102 that includes a tree of nodes 104A-N. Each node of the tree of nodes 104A-N is associated with a bounding volume. For example, nodes can include bounding volumes. Alternatively, a node can be associated with some volume (for example, a node in a mesh grid can be associated with certain area in the bounding volume of a parent node). In the latter case, the bounding volume associated with the node is calculated during the traversing of the tree. Each leaf node is associated with a bounding volume and one or more primitives, and one or more nodes comprise one or more references to volume properties. Each volume property is a physical property set in a limited volume. The graphics rendering acceleration device 100 is configured to obtain a projection volume. The projection volume is defined with respect to a camera in the scene. The graphics rendering acceleration device 100 is configured to traverse the acceleration structure 102 to process nodes 104A-N within the projection volume so as to add references to volume properties from the node to a set of volume properties for each processed node. The graphics rendering acceleration device 100 is configured to send the set of volume properties to a fragment shader for using the volume properties during rasterization of primitives from the leaf node for each processed leaf node.

Modem complex effects require multiple requests to the scene, as to process camera, shadows, reflections, refractions and transparency, and so on. The acceleration structure 102 disclosed herein allows a driver to manage the scene many times using the logic written in the shaders. Further, these integrated acceleration structure allows to use hardware or low-level optimizations that can dramatically increase performance. The graphics rendering acceleration system 100 enables that the volumetric special effects, such as light, fog, space-specific light- and reflection- probes, and others, can be applied on affected triangles only. The graphics rendering acceleration system 100 can be used in 10000-100000 lights on a scene, even on mobile platforms. The graphics rendering acceleration system 100 enables to simplify renderers of graphical engines because it significantly simplifies management of objects on the scene.

Optionally, the references to volume properties include references to blocks of memory, such as a GPU memory, including data that describe corresponding physical properties. Optionally, the set of volume properties is configured as a temporary stack. Optionally, the one or more nodes include one or more references to volume properties are leaf nodes. Optionally, the set of volume properties is written into a layer of a preliminary render target by the fragment shader.

Optionally, the graphics rendering acceleration device 100 is configured to operate with a tilebased graphics rendering system and the projection volume comprises one or more frustums. FIGS. 2A-2B illustrate examples of an integrated acceleration structure, in accordance with an implementation of the disclosure. FIG. 2A illustrates an acceleration structure 200 that is to be integrated into a driver to be used for selection of triangles during ray-tracing, rasterization, or other high-performance rendering methods. For example, the acceleration structure 200 can be a BVH acceleration structure. The triangles for rasterization may be selected from the acceleration structure 200. Here a volumetric property can be a property of space or scene such as a light stream, a volumetric frog, a space-specific light- or reflection- probe, and the like. The acceleration structure 200 is then integrated into a tile-based architecture 202 of a graphical processing unit and replaces a tiler functionality to requests of the triangles in the acceleration structure 200. Optionally, nodes of the acceleration structure with triangles 204A-B include a list of volumetric properties 206A-D which are specific for sub-space where the triangles 204A-B are present. The driver then selects triangles from the acceleration structure and rasterizes the triangles. Optionally, rasterizer and shader language provides access to the list of volumetric properties 206A-D specific for a current triangle.

For rasterization, a number of triangles in the node can be greater than it is typical for raytracing, and less than for the typical acceleration structure of game engines. For example, a typical number of triangles per node can be 32-128. This balance has a beneficial effect due to compromise between distribution of the groups of triangles in the space and contribution of the memory, such that wide triangles can be tessellated.

Based on the acceleration structure implementation, all nodes, or some nodes, or only leaves of the triangle, contain references associated with some blocks in a GPU memory. Optionally, a block in the GPU memory can have a predefined format and it represents a volume property. To support “instanced” objects (one structure for many objects), parallel data layer structure can be created that may include only references to the list of volume properties 206 A-D. For small objects, it is possible to use only one reference for whole instanced object.

FIG. 2B illustrates schematically an acceleration structure represented as a tree structure that includes a hierarchical set of volumes with triangles in leaves of a tree. The hierarchical acceleration structure further includes nodes 210A-B representing volumes that enclose the new set of primitives. The individual geometric objects are wrapped in bounding volumes that form leaf nodes 212A-D of the tree. These leaf nodes 212A-D are then grouped as small sets and enclosed within larger bounding volumes. These, in turn, are also grouped and enclosed within other larger bounding volumes in a recursive fashion, eventually resulting in a tree structure with a single bounding volume, represented by the root node 208, at the top of the tree. Bounding volume hierarchies are used to efficiently support a variety of operations on sets of geometric objects, such as collision detection, primitive culling, and ray traversal/intersection operations used in ray tracing. During traversing in the acceleration structure, each encountered valid reference to the volume property may be placed into the list of volume properties 206A-D (for example organized as the stack data structure). Further, a new API is added to control the volume properties in shader languages/shader programs. The API may manage the volume properties. The API defines data structure of the volume properties, allocation methods, and a system of compact references to the volatile number of volume properties. For example, it can be a fixed size array, or the list data structure, or chunked list (4-8 references in block).

The APIs then push the volume properties into the acceleration structure and these volume properties are then received in a shader. For example, the volume properties can be defined like additional “layout” in the “glsl” language. The shader then saves the list of volume properties 206A-D for transfer between rendering stages.

Optionally, real-time rendering methods often use G-Buffer or deferred rendering. G-Buffer allows to execute complex fragment shader only one time per pixel, while in the normal rendering some pixels can overlap to each other, so fragment shaders can be executed several times without visual effect. If the list of volume properties 206 A-D is stored in a leaf 212 A, 212B, 212C, or 212D of the acceleration structure, then only one reference to the list is presented, so it can be stored in one int32, int48, or int64 variable, depends on memory structure. Thus, only one layer is to be added into the G-Buffer and all volume properties that can be interesting for the current pixel is to be stored for deferred shading. This may be most efficient for the tile-based architecture because such approach may not consume too many memories as all data can be stored in the small fast cache of the GPU.

FIGS. 3A and 3B are example illustrations of volume properties collected in a rendering pipeline, in accordance with an implementation of the disclosure as in a direct rendering pipeline (FIG.3A) as in a deferred rendering with G-Buffer (FIG. 3B).

With reference to FIG. 3A, at a block 302, a direct rendering process is initiated with obtaining data of a scene, an acceleration structure, and a projection volume. At a block 30, the acceleration structure is traversed within the projection volume. At a block 306, a leaf node is found and data from the leaf node is sent to a rasterization and shading stage. Finally, at a block 308, the rasterization and shading processes are conducted. With the present disclosure, the direct rendering pipeline is supplemented with a new stage of collecting volume properties at a block 310, the volume properties being collected from nodes of the acceleration structure during the traversing at the block 304, to create a stack of volume properties. The stack of volume properties is then provided to the rasterization and shading stage at the block 308.

With reference to FIG.3B, at a block 312 a deferred rendering process is initiated with obtaining data of a scene, an acceleration structure, and a projection volume. At a block 314, the acceleration structure is traversed within the projection volume, similarly to the abovedescribed direct rendering pipeline. At a block 316, a leaf node is found and data from the leaf node is sent to a G-Buffer rendering stage (a block 318). At the block 318, the G-Buffer rendering is conducted. Finally, at a block 320 the shading process is conducted. With the present disclosure, the deferred rendering pipeline is supplemented with a new stage of collecting references to volume properties at a block 322, the references being collected from leaf nodes of the acceleration structure at the block 316, and then the references are sent to the G-Buffer rendering stage at the block 318 wherein the volume properties are obtained using the references and saved for future usage in the shading process at the block 320. In both cases, the sub-system for handling volume properties build according to the present disclosure in the rendering pipeline allows to accelerate and increase power efficiency of processing complex special effects, due to instant access to properties of the space around each primitive of the scene in the rasterization and shading stages.

FIG. 4 is an example illustration of parallelization of processing stages of an acceleration method in accordance with an implementation of the disclosure. Optionally, parallelization allows to synchronize access to memory which performing computation of independent volume properties. The parallelization of computation enables GPU load balancing and optimization of cache usage. Optionally, fragment shaders include three stages such as pixel parameters estimation 402, processing of volume properties 404 and post processing 406. During the pixel parameters estimation 402 of an object, normal and base material properties are obtained. For example, extracting the normal from a normal map and reading of several textures (diffuse color, specular parameters and so on). The parallelization further includes processing of a variate number of volume properties 404, for instance computation of the lighting. The parallelisation further includes post-processing of the volume properties 406 such as, gamma-correction, and the like. Thus, for any complex scene, parallelization allows to reduce the cache misses due to working with the same kind of data in each moment. Also, first and third stages typically have the constant execution time, but number of volume properties are variate. So, different GPU cores will be loaded differently. Parallelization allows to distribute loading more evenly.

FIG. 5 is a flow diagram of a graphics rendering acceleration method in accordance with another implementation of the disclosure. At a step 502, an acceleration structure that includes a tree of nodes is obtained. Each node is associated with a bounding volume. Each leaf node is associated with a bounding volume and one or more primitives, and one or more nodes include one or more references to volume properties. Each volume property is a physical property set in a limited volume. At a step 504, a projection volume is obtained. At a step 506, the acceleration structure is traversed to process nodes within the projection volume. At a step 508, references to volume properties from the node to a set of volume properties are added for each process nodes. At a step 510, a set of volume properties are sent to a fragment shade for using the volume properties using rasterization of primitives from the leaf node for each processed node.

The graphics rendering acceleration method disclosed herein provides access to the volumetric properties specific for a processed node, such that volumetric special effects such as light, fog, space-specific light, and reflection probes are applied only on the selected processed node. Further, parallelization of the processing stages of the processed node allows optimization of the memory usage. The graphics rendering acceleration method can be used in 10000-100000 lights on the scene, even on mobile platforms. The graphics rendering acceleration method doesn’t depend from a division space algorithm. The graphics rendering acceleration method can be applied to BVH, kdTree, OctTree, MeshGrid and other methods, or their modifications. The graphics rendering acceleration method is easy to combine with other techniques of real-time rendering, for example, method ray-tracing. The graphics rendering acceleration method enables to simplify Tenderers of graphical engines because it significantly simplifies management of objects on the scene.

Optionally, the references to volume properties comprise references to blocks of memory, such as a GPU memory, comprising data that describe corresponding physical properties.

Optionally, the set of volume properties is configured as a temporary stack. Optionally, the one or more nodes comprising one or more references to volume properties are leaves.

Optionally, the method further includes writing the set of volume properties into a layer of a preliminary render target by the fragment shader. Optionally, the method is used in a tile-based graphics rendering pipeline and the projection volume comprises one or more frustums.

Optionally, there are different methods as how to organize the allocation of the memory for the volume lists. It can be simple unidirectional list (index to volume+index to the next element), a list of (3-15 indices to volume+index to the next element) or nodes with triangles can contain fixed number of indices to volumes, if the complexity of computations is to be limited.

The system and method herein are compatible and give additional benefits over the tile-based architecture, because this allows to effectively transfer volume properties from the triangle rasterizer to the shading stage.

Optionally, a vertex, fragment or other suitable shader have access to a list of the volume properties identified during traversing. For example:

// User defined volume property struct LightStream vec3 Position; float Near; vec3 Direction; float Far; vec4 Power;

// Pixel parameters layout(location = 0) in vec3 pos; layout(location = 1) in vec3 norm;

// Extended shader API: access to the traversing info layout(bvh) LightStream lightStreamsf]; vec4 main()

{ vec4 diffuse = tex2D(sampler, inp.tex); vec4 color(0., 0., 0., 1.); // Some method to iterate array for (LightStream light_stream : lightStreams)

// User-defined function to calculate lighting using volume property color += calcLight(light_stream, pos, norm); return color * diffuse;

It should be understood that the arrangement of components illustrated in the figures described are exemplary and that other arrangement may be possible. It should also be understood that the various system components (and means) defined by the claims, described below, and illustrated in the various block diagrams represent components in some systems configured according to the subject matter disclosed herein. For example, one or more of these system components (and means) may be realized, in whole or in part, by at least some of the components illustrated in the arrangements illustrated in the described figures.

In addition, while at least one of these components are implemented at least partially as an electronic hardware component, and therefore constitutes a machine, the other components may be implemented in software that when included in an execution environment constitutes a machine, hardware, or a combination of software and hardware.

Although the disclosure and its advantages have been described in detail, it should be understood that various changes, substitutions and alterations can be made herein without departing from the spirit and scope of the invention as defined by the appended claims.