JP5336067B2 - Method and apparatus for processing graphics - Google Patents

Abstract

A graphics processor 20 includes a graphics object list building unit 28 that determines the location of each draw call in a scene to be rendered and generates a list of draw calls for each sub-region (tile) that the scene to be rendered is divided into. The draw call lists are stored in a memory 23. A graphics object selection unit 29 of a renderer 22 of the graphics processor 20 then determines which draw call is to be rendered next by considering the draw call list 26 stored in the memory 23 for the sub-region (tile) of the scene that is currently being rendered.

Description

  The present invention relates to a method and apparatus for processing graphics, and in particular to such a method and apparatus for use in a tile-based graphics processing system.

  Although the present invention will be described with particular reference to processing 3D graphics, it will be understood by those skilled in the art that it is equally applicable to processing 2D graphics.

  As is known in the art, graphics processing generally divides a scene to be displayed into several similar basic components or “primitives”, and then these primitives to the desired graphics processing. It is executed by performing an operation. Graphics “primitives” usually take the form of simple polygons, such as triangles, and are usually described by defining their vertices.

  With respect to graphics processing operations, as is known in the art, each graphics primitive is typically further divided into a plurality of discrete graphic entities or elements commonly referred to as “fragments”, for which The actual graphics processing operation (rendering operation etc.) is executed. Each such graphics fragment represents and corresponds to a given position within the primitive and effectively contains a set of data (such as color and depth values) for that position.

  Each graphics fragment (data element) typically corresponds to a single pixel (picture element) in the final display (the graphics processor acts because the pixel is a singularity of the final image to be displayed. There is usually a one-to-one mapping between "fragments" and pixels in the display). However, if certain forms of post-processing, such as reduction, are performed on the rendered image, for example, before the final image is displayed, it is directly between “fragment” and “pixel”. There may be no correspondence.

  Therefore, two aspects of the graphics processing that are typically performed are to “rasterize” graphics “primitive” (polygon) position data into graphics fragment position data (ie, each primitive in the scene to be displayed). Determine the (x, y) position of the graphics fragment used to represent the image), and then `` render '' the `` rasterized '' fragment so that it appears on the display screen (i.e. Color, shading, etc.).

  (In the graphics field, the term "rasterization" is sometimes used to mean both the conversion of primitives to fragments and the rendering of primitives. "Is used to refer only to the conversion from primitive data to fragment addresses.)

  Many graphics processing systems use so-called “tile-based” rendering. In tile-based rendering, a two-dimensional scene to be displayed is subdivided or segmented into a plurality of smaller sub-regions, commonly referred to as “tiles”. Each tile (subregion) is rendered separately (typically in order). The rendered subregions (tiles) are then recombined to display the complete frame. In such a configuration, the scene is typically divided into small areas (tiles) of regular size and shape (usually in the form of squares, rectangles, etc.), but this is not essential.

  Other terms commonly used for “tiling” and “tile-based” rendering include “chunking” (multiple subregions are also called “chunks”) and “bucket” rendering. In the following, the terms “tile” and “tiling” are used for convenience, but it should be understood by those skilled in the art that these terms encompass all alternative and equivalent terms and techniques. .

  The advantage of such tile-based rendering is that primitives that do not appear in a given tile need not be processed for that tile and can therefore be ignored when the tile is processed. As a result, the total amount of graphics processing required for a given scene can be reduced.

  Thus, tile-based rendering systems typically identify those primitives that actually exist within a given subregion (tile), for example, to avoid unnecessary rendering of primitives that do not actually exist within a tile. It is desirable to be able to know. In order to facilitate this, it is known to prepare for each small region (tile) a list of primitives to be rendered with respect to the small region (eg appearing in the small region). Such a “tile list” (sometimes referred to as a “primitive list”) identifies the primitives to be rendered for that tile (small region) (eg, by referring to a primitive indicator).

  Thus, the process of creating a tile list for each subregion (tile) to be rendered basically involves determining the primitives to be rendered for a given subregion (tile). This process typically determines the primitives (with the desired level of accuracy) that cross the appropriate tile (i.e., at least part of it appears in the appropriate tile), and then the primitive list is determined by the graphics processing system. Performed by creating for future use. (Note that if a primitive enters more than one tile (often), that primitive will be included in the tile list of each tile it contains.) A (tile) can be considered as having a bin (tile list) containing virtually any primitive found to enter (i.e. cross) the subregion (in fact, in this manner). The process of sorting primitives by tile is commonly referred to as “binning”).

  As is known in the art, the process of determining the primitives to list (render) for a given tile is dependent on, for example, optimization of the efficiency of the various parts of the tiling and rendering process. May be performed at various levels of accuracy. For example, at the highest level of accuracy, after accurately determining the tiles in which a given primitive appears at least partially, the primitive can only be included in the tile list for those tiles. This is commonly referred to as “exact” binning.

  Figure 1 shows the exact binning process. As shown in FIG. 1, the display target scene 1 is divided into 16 small regions, ie, tiles 2 having a regular size. Then, for each primitive in the scene, the tile or tiles in which the primitive actually appears (enters) is determined. The primitive is added to the tile list for each tile that it finds itself to enter. Thus, considering the example shown in FIG. 1, primitive 3 is added to the tile list of tile 4, primitive 5 is included in the tile list of tiles 6 and 7, and primitive 8 is tiles 9, 10, 11 , And 12 are included in the tile list, and primitive 13 is included in the tile list of tile 12. (It should be noted that FIG. 1 shows only a small number of tiles and primitives for clarity of the drawing. As will be appreciated by those skilled in the art, the actual graphics processing operations typically (There will be more primitives and tiles.)

  It is also known to create a tile list with a lower accuracy than that achieved with accurate binning. This can help, for example, simplify the creation of tile lists. One common “less precise” binning technique is “bounding box” binning. In this case, a so-called “bounding box” is drawn around a primitive or a set of primitives, and then the tiles covered by the bounding box are determined. Then, for each tile found to be covered (at least part of) by the bounding box, one or more primitives represented by the bounding box (i.e. encompassed by the bounding box) are listed. (Binning).

  Thus, this configuration uses a bounding box rather than the primitive itself to list a given primitive to determine which tile to render. This means that, for example, tiles that do not actually contain a primitive (for example, if the bounding box does not sufficiently surround the primitive in a tight or precise manner) can be listed for rendering. On the other hand, the use of bounding boxes in this manner can simplify the creation of tile lists.

  When a list of primitives to be rendered (tile list) for each small area (tile) is created in this way, the (tile) list is stored, and this list is considered when rendering the corresponding tile, for example. Used to allow the system to identify the primitives that need to be rendered.

  Such tile-based rendering arrangements have been found to work well, for example, because they can help avoid processing primitives down to areas of the scene where no primitives exist.

  However, applicants believe that there is room for improvement in existing tile-based rendering systems.

According to a first aspect of the present invention, in a graphics processing system in which a scene to be rendered is divided into a plurality of small regions for rendering, an apparatus for sorting graphics data for processing,
An apparatus is provided comprising means for sorting graphics descriptors relating to or associated with the location or locations of a scene to be rendered into subregions or subregions into which the scene is divided.

According to a second aspect of the present invention, in a graphics processing system in which a scene to be rendered is divided into a plurality of small regions for rendering, a method for sorting graphics data for processing,
A method is provided that includes means for sorting graphics descriptors relating to or associated with the location or locations of the scene to be rendered into subregions or subregions into which the scene is divided.

According to a third aspect of the present invention, in a graphics processing system in which a scene to be rendered is divided into a plurality of small regions for rendering, an apparatus for sorting graphics data for processing,
An apparatus is provided comprising means for associating a graphics descriptor associated with or associated with the location or locations of the scene to be rendered with the subregion or regions where the scene is divided.

According to a fourth aspect of the present invention, there is provided a method for processing graphics data for processing in a graphics processing system in which a scene to be rendered is divided into a plurality of small regions for rendering,
A method is provided that includes associating a graphics descriptor associated with or associated with the location or locations of the scene to be rendered with the subregion or regions where the scene is divided.

According to a fifth aspect of the present invention, in a graphics processing system in which a scene to be rendered is divided into a plurality of small areas for rendering, an apparatus for sorting graphics data for processing,
A graphics descriptor list for one or more subregions into which the scene can be divided, preferably for processing, each graphics descriptor being other than a single primitive of the scene to be rendered An apparatus is provided comprising means for creating a child list.

According to a sixth aspect of the present invention, in a graphics processing system in which a scene to be rendered is divided into a plurality of small regions for rendering, a method for sorting graphics data for processing,
A graphics descriptor list for one or more subregions into which the scene can be divided, preferably for processing, each graphics descriptor being other than a single primitive of the scene to be rendered A method is provided that includes means for creating a child list.

  The present invention is directed to a tile-based rendering system (ie, a rendering system in which a scene to be rendered is divided into a plurality of sub-regions). However, unlike conventional tile-based rendering systems, other graphics of the present invention where the scene to be rendered is not a single primitive, rather than simply being sorted into “tiles” and included in a “tile list”. Basic primitives, such as “single” polygons (ie, the smallest “polygon” description of a scene) such as triangles, squares, lines, or points described with respect to image descriptors, are tile-by-tile (small area by small Can be sorted on a (region) basis and placed (included) in a “tile list”.

  Applicants recognize that there are advantages to sorting not only the basic single primitive that describes and defines the scene to be rendered in the tile, but also other types of scene (graphics) descriptions (descriptors). Yes.

  For example, the tile list can be replaced (or selectively) stored with a graphics descriptor indicating a plurality of individual primitives in common, such as a draw call, which is then used, for example, in the tile list The amount of memory can be changed and / or reduced. Thus, the present invention facilitates relatively good control and recognition of memory usage requirements for the tile listing process. This is particularly advantageous in graphics systems that run on relatively limited devices such as portable devices (eg, mobile phones, PDAs, handheld devices, etc.).

  Applicants have also recognized that performing tiling operations or operations on graphics descriptors other than individual primitives provides other benefits. For example, it allows the graphics data to be sorted and selected in the form of these other graphics descriptors.

  Also, it is a relatively short tiling operation itself and is resource intensive, so it executes relatively quickly, for example for the purpose of a relatively coarse initial sort of graphics data (descriptors). Means that For example, it is a relatively high graphic to see if any graphics descriptor can be immediately discarded (selected) from further processing without having to create a tile list at the basic primitive level for that purpose. Can be used to perform initial coarse tiling of graphics data at the descriptor level.

  Thus, the present invention can be facilitated prior to, for example, selection and / or hidden surface removal, eg, and preferably rendering.

  The plurality of small regions (tiles) into which the scene to be rendered is divided can be any suitable small region desired. As is known in the art, they are preferably all the same size and shape (i.e., regular size and shape tiles are preferably used), but this is not essential. Absent. These small areas are preferably square or rectangular. The size and number of subregions can be selected as desired. In one preferred configuration, each subregion (tile) is a fragment of size 16x16 or 32x32 (however, the scene is later divided into as many subregions as needed for the display (frame) size in use. Will be done).

  In a preferred embodiment, a tile list (a list of graphics descriptors) can be created for one or more sets of subregions including individual subregions and / or more than one subregion. A tile list (graphic descriptor list) (a commonly stored tile list) is created for a set of more than one subregion, after which a set of more than one subregion is an integer subregion. And preferably a group of continuous subregions.

  Graphics descriptors, such as sorted into subregions and / or listed for subregions, can be any suitable and desirable such descriptor. As will be apparent to those skilled in the art, they may be used to describe a scene for the actual rendering process and may be used as a single triangle, square, line, or point. There needs to be something other than a single basic primitive such as a polygon (thus not in the form of a single primitive such as a triangle, line, square, or point).

  Analogously, a graphics descriptor (when making it appropriate or desirable to sort them by their location in the scene) or the location or location in the processing-symmetric scene associated with it, or a specific Or it must have or contain a descriptor (preferably relating to the scene to be rendered or of (some)) having a selected location or location type. Thus, the graphics descriptor preferably includes or is associated with geography and / or information including location or location in a scene for a subsequent stage or stages of graphics processing.

  In fact, the present invention relates to graphics processing (associated with location), such as descriptors that define where graphics processing (procedures) should be performed, where an object or objects should be drawn, etc. It can be applied to any graphics descriptor that communicates location information.

  In one preferred embodiment, the graphics descriptor is a given specific process, such as an indication that a particular graphics process or process needs to be activated at a given location or area or area of the scene. Contains a descriptor of some form of graphics processing (procedure) to be performed at a scene location or area.

  For example, a graphics descriptor may define a routine or procedure, such as a program, for generating a set of primitives (say to generate to the system) at a given location in the scene to be rendered. They can include, for example, procedural draw calls.

  In one preferred embodiment, the graphics descriptor indicates or includes the object to be rendered, but is in a form other than a single polygon or primitive. Thus, in one preferred embodiment, the graphics descriptor includes graphics objects, but not individual single primitives.

  For example, the graphics descriptor is also or alternatively, and preferably, a relatively high of the object to be rendered, such as the descriptor of the object before it is preferably converted to a primitive (eg, triangular) display. Contains descriptors in order or at a relatively high level.

  An example of such a relatively high order or relatively high level rendered object descriptor is a smooth surface that represents the object (eg, “object” includes a smooth, eg curved surface). . In this case, the smooth surface descriptor (s) for the smooth surface (s) in the scene may be stored in aspects of the present invention.

  Another form of relatively high order definition of graphic objects to which the present invention is applicable is a program or procedure that tells a graphics system how to generate a set of primitives at a given location in a scene.

  Thus, in a preferred embodiment, the graphics descriptor or descriptors are preferably non-rendered objects used for the target object or objects before the object's “primitive” descriptor is present, for example. Contains primitive and / or pre-primitive descriptors. That is, in the preferred embodiment, the graphic descriptor includes a precursor descriptor (description) of the object to be rendered (ie, the description precedes the primitive level description of the object). In these cases, the graphics descriptor indicates the object to be rendered and is not yet a “primitive level” or primitive-based description of the object; rather, the graphics descriptor is a primitive-based description of the object in time. It is intended to be converted, but no primitive-based description of the object yet exists.

  For example, the non-primitive based graphics descriptor can be viewed as a “meta-primitive” that is later transformed into a “single” primitive, for example.

  The graphics descriptor may also include and / or indicate a group or set of primitives, such as a set of continuous triangles. In this case, a primitive level description of the object may exist but a group of primitives may be sorted together rather than sorting each primitive individually. This effectively allows a rough display of the object to be rendered to be "tileable" once there can be a "primitive" description of the object. An example of such an arrangement is to use a bounding box that contains multiple primitives, for example as a graphic descriptor that is sorted in an aspect of the invention.

  In the preferred embodiment, the graphics descriptor or descriptors include a draw call (or multiple draw calls). (As will be appreciated by those skilled in the art, in graphics processing, primitives are typically grouped together in pairs, for example, for a particular scene region, and programmers intend to be rendered together as a group at once. (The group of primitives that are processed together are usually referred to as “draw calls”.) Thus, in a particularly preferred embodiment, the scene draw calls are sorted into tiles (placed in a tile list). The draw call in the arrangement may be a procedural draw call (for example, a draw call that defines a procedure for generating a primitive) as necessary.

  As will be appreciated by those skilled in the art, in the use of draw calls, for example, any given draw call may indicate and include multiple primitives, while there may be draw calls that include or indicate only a single primitive. . However, this is still at least within the scope of the preferred embodiment of the present invention because a draw call shows multiple primitives in common, even though in practice it may not always behave that way. Because it is a graphics descriptor that can.

  That is, as will be appreciated by those skilled in the art, the intent of the present invention is to use a graphics descriptor that is not simply a single primitive (and it is a single primitive descriptor for the object being rendered). Which can include or indicate or indicate a plurality of primitives in common and / or a non-primitive based descriptor of the rendered object or a descriptor of the graphics processing to be performed, And / or a descriptor of the graphics object to be rendered and / or a descriptor of the graphics processing to be performed, which may include, indicate or indicate a plurality of primitives.

  Thus, in a particularly preferred embodiment, the graphics descriptor may include or indicate or indicate a rendered object and / or a graphic description of the rendered object and / or a plurality of primitives, Contains non-primitive based descriptors of the graphics processing to be performed.

  In the preferred embodiment, a tile list (graphics descriptor list) is created for a given type of graphics descriptor. That is, a given type of graphics descriptor, such as a draw call, is sorted into small areas (tiles). In one preferred embodiment, only a single type or class of graphics descriptor is included in any given list.

  However, it is possible to include different types of graphics descriptors in the same list, so in another preferred embodiment, each different type of graphics descriptor is each for a given subregion (or set of subregions). ) List (tile list).

  Also, a single primitive, such as a graphics primitive in the form of a single polygon, such as a triangle, square, line or point, can be included in the tile list along with other graphics descriptors as needed. (The present invention does not exclude the creation of additional (eg, simultaneously or sequentially) tile lists of basic graphics primitives for rendering as needed.)

  Although a list of graphics descriptors can be created, for example, only for selected subregions (tiles), in a preferred embodiment, a graphics descriptor list is created for each subregion (tile) into which the scene is divided. Created.

  Sorting graphics descriptors into small areas and creating graphic descriptors for small areas can be performed in any suitable and desired manner. Any technique already known and used for sorting and binning primitives into tile lists such as, for example, exact binning, or bounding box binning, or anything in between is used for this process. Also good.

  Thus, for example, the initial determination of the small region in which the graphics descriptor is processed is based on the determined location of the graphics descriptor in the scene (the location encloses the graphics descriptor as known in the art, for example). It can be an approximation of the location of the graphics descriptor based on the bounding box or the exact location of the graphics descriptor.), Then the graphics description listed in the same or all subregions indicated by the determined location The child needs to be rendered. This is then, for example and preferably, repeated for each graphics descriptor in the scene, creating a complete set of graphics descriptor lists for the scene.

  Thus, in the preferred embodiment, the location for a given graphics descriptor in the scene is determined and compared against the subregion and / or multiple subregions into which the scene is divided to determine which subregion and set of subregions. Determine whether graphics descriptors can or should be processed for multiple subregions (e.g., appear (included) in range).

  In these arrangements, the location of the graphics descriptor can be derived and preferably as desired from the location or position data of the graphics descriptor or associated therewith. Similarly, the location of subregions can be derived in any desired and appropriate manner. If desired, any location or location of the graphics descriptor or associated with it is preferably transformed into a location that the descriptor has in the scene when it is to be rendered, and then the descriptor is a small region Etc. to help ensure the “last” correct location of possible descriptors.

  If bounding box technology is used, then the bounding box can be generated if and when desired. For example, the bounding box can be generated on a graphics descriptor basis or for a set or sets of graphics descriptors, as is known in the art. The bounding box can be generated by, for example, a graphics processor API or driver on the host system.

  The individual graphics descriptor lists and the graphics descriptors in them can be arranged in any desired and appropriate manner and can include any desired and appropriate data. The lists are preferably arranged in the same or similar manner already used in the art for such or similar graphics descriptors, tile lists, etc., and contain data.

  Once the graphics descriptors are sorted and the graphics descriptor list is created for the small area as described above, this information is then processed into the graphics descriptors (and the primitives they represent, for example). Can be used. The process can include any suitable and desired process.

  In one preferred embodiment, this process includes rendering of a graphics descriptor. That is, when rendering a scene, and preferably to determine which graphics descriptors (and hence eg primitives) need to be processed (rendered) for each subregion. Includes using descriptor lists.

  This rendering process can and is preferably performed in a manner similar to known tile-based rendering systems. Thus, preferably each subregion (tile) is processed and rendered separately, i.e. separate individual subregions are rendered one by one. This rendering can be performed in any desired manner, for example by rendering individual subregions, or in a parallel manner. Once all subregions (tiles) have been rendered, they can then be recombined, for example with a conventionally known display frame buffer.

  In another preferred embodiment, a graphics descriptor list or the like is used in addition or instead to perform a (preferably initial) selection operation (eg, hidden surface removal) before the scene is rendered. For example, and preferably, removing processing after the graphics descriptor that can be determined is not seen in the displayed scene. The selection includes, for example, determining if any graphics descriptors are outside the visible area of the scene (in which case they are discarded). More sophisticated selection settings can of course be used additionally or alternatively.

  In the preferred embodiment, the location or location of the graphics descriptor (s) is compared to the location or location for one or more areas or subregions, etc. of the scene.

  As discussed above, the present invention facilitates this operation, for example sorting and tiling of relatively large graphics objects rather than individual primitives can result in a relatively low processing concentration.

  Although the present invention has been particularly described with respect to sorting graphics descriptors etc. with reference to small areas (tiles) into which the scene is divided for rendering, as those skilled in the art will appreciate, such sorting is necessary. Depending on and with respect to other areas in the scene. For example, in the case of a selection operation, it is desirable to simply compare the position of the graphics descriptor to the scene's visible area (for example, if any descriptor is included outside the scene's visible area for reference).

Therefore, according to the seventh aspect of the present invention, there is provided an apparatus for sorting graphics data for processing in a graphics processing system,
An apparatus is provided comprising means for sorting graphics descriptors relating to or associated with a location or multiple locations of a scene to be rendered into a specific area or subregion of the scene.

According to an eighth aspect of the present invention, there is provided a method for sorting graphics data for processing in a graphics processing system,
A method is provided comprising sorting graphics descriptors relating to or associated with a location or multiple locations of a scene to be rendered into a specific area or subregion of the scene.

According to a ninth aspect of the present invention, there is provided an apparatus for processing graphics data for processing in a graphics processing system,
An apparatus is provided comprising means for associating a particular area or areas for a small area or areas of a scene with a graphics descriptor relating to or associated with the location or areas of the scene to be rendered. .

According to a tenth aspect of the present invention, there is provided a method for processing graphics data for processing in a graphics processing system,
A method is provided that includes associating graphics descriptors relating to or associated with the location or locations of the scene to be rendered to a particular area or areas for a subregion or regions of the scene. .

According to an eleventh aspect of the present invention, there is provided an apparatus for processing graphics data for processing in a graphics processing system,
Graphics descriptor list for one or more areas or subregions of the scene to be rendered, preferably for processing, each graphics descriptor being other than a single primitive of the scene to be rendered An apparatus is provided comprising means for creating a descriptor list.

According to a twelfth aspect of the present invention, there is provided a method for processing graphics data for processing in a graphics processing system,
Graphics descriptor list for one or more areas or subregions of the scene to be rendered, preferably for processing, each graphics descriptor being other than a single primitive of the scene to be rendered A method is provided that includes creating a descriptor list.

According to a thirteenth aspect of the present invention, there is provided an apparatus for processing graphics data for processing in a graphics processing system,
An apparatus is provided comprising means for comparing the position or location of a graphics descriptor of a scene to be rendered with a specific or selected area or areas or sub-areas or sub-areas or positions of a scene. .

According to a fourteenth aspect of the present invention, there is provided an apparatus for processing graphics data for processing in a graphics processing system,
A method is provided that includes comparing a position or location of a graphics descriptor of a scene to be rendered with a position or location of a specific or selected area or areas or subregions or subregions of a scene. .

  As those skilled in the art will appreciate, these aspects and embodiments of the present invention include one or more and all of the preferred optional features of the present invention as described herein, as appropriate. And preferably contain. Thus, for example, the graphics descriptor can take any of the forms discussed above. Similarly, the selected area or areas of the scene where the graphics descriptors are sorted preferably includes small areas (tiles) into which the scene is divided for rendering purposes, but this is not always necessary. Rather, the area can be associated additionally or alternatively with the visible and invisible regions of the scene, as desired.

  The various functions of the present invention can be performed in any suitable manner as desired. In one particularly preferred embodiment, they are run on a single graphics processing platform that generates and outputs graphics data that is written to a frame buffer for a display device. These functions can be implemented in hardware or software as required. In a preferred embodiment, the system is implemented as a hardware element (eg, ASIC). Accordingly, in another aspect, the invention comprises a hardware element that includes or is operated according to a method in any one or more of the aspects of the invention described herein.

  It should be noted here that the various functions of the present invention, etc. can be replicated and / or executed in parallel on a given processor, as will be appreciated by those skilled in the art.

  The present invention is applicable to any form or configuration of graphics processor and renderer such as a renderer having a "pipeline" configuration (in which case, the renderer will take the form of a rendering pipeline). is there.

  As will be appreciated from the above, the present invention is not particularly exclusive, but is applicable to 3D graphics processors and processing devices, and thus is among the aspects of the invention described herein. 3D graphics processors and 3D graphics processing platforms that include or operate in accordance with the method in any one or more of the above. Such a 3D graphics processor may include any one or more of the normal functional units included in the 3D graphics processor, provided that there is any hardware necessary to perform the individual functions described above. Or you can include them all.

  In addition, the aspects and embodiments described with respect to the present invention may include, as appropriate, one or more of the preferred and optional features described herein. Those skilled in the art will appreciate that they can also be included.

  The method according to the invention can be implemented at least in part using software, for example a computer program. Thus, considering further aspects, the present invention is directed to computer software specially adapted to perform the methods described herein when installed on a data processing means, A computer program element comprising computer software code portions for performing the methods described herein when the program element is executed on a data processing means, and when the program is executed on a data processing system; It will be appreciated that there is provided a computer program comprising code means adapted to perform all the steps relating to the methods described herein. The invention also relates to each method of the invention when the processor, renderer or system of the data processing means is used to operate a graphics processor, renderer or microprocessor system comprising data processing means. It is also extended to a computer software carrier with software that comes to perform each step. Such a computer software carrier may be a physical storage medium such as a ROM chip, a CD-ROM, or a disk, or may be a signal such as an electronic signal on a wiring, an optical signal, or a radio signal with a satellite.

  Further, not all steps for each method of the present invention need to be performed by computer software, and thus a broader aspect of the present invention provides for computer software and each method described in detail herein. It will be appreciated that software installed on a computer software carrier to perform at least one of each step is provided.

  Accordingly, the present invention can be suitably implemented as a computer program product for use with a computer system. One such implementation is fixed on a tangible medium such as a computer readable medium such as a diskette, CD-ROM, ROM, or hard disk, or a tangible medium including but not limited to light or an analog communication line. A series of data that can be transmitted to a computer system via a modem or other interface device using intangible wireless usage techniques including, but not limited to, microwave, infrared, and other transmission techniques Computer readable instructions may be included. The series of computer readable instructions implements all or part of the functions described earlier in this specification.

  Those skilled in the art will appreciate that such computer readable instructions can be written in a number of programming languages for use with many computer architectures or operating systems. Further, such instructions may be stored using any current or future memory technology including, but not limited to, semiconductor, magnetic or optical, and are not limited to light, infrared or microwave. Can be transmitted using any current or future communication technique, including Such computer program products can be distributed as removable media, such as shrink wrap software, preloaded with a computer system on a removable medium, such as a system ROM or fixed disk, to which a printed or electronic document is attached, or can be distributed over a network such as It is contemplated that it can also be distributed from a server or electronic bulletin board via the wide web or the like.

  In the following, by way of example only, some preferred embodiments of the present invention will be described with reference to the accompanying drawings.

  A preferred embodiment of the present invention will now be described with reference to FIGS.

  In an embodiment of the present invention, the “tile” in the tile list and the graphics descriptor listed include a graphics object in the form of a draw call. However, as discussed above, other arrangements are of course possible.

  FIG. 2 schematically illustrates a graphics processor 20 that can be operated in accordance with the present invention. The graphics processor 20 includes a geometry processor 21 and a renderer 22, both of which can access the memory 23. Memory 23 may be “on-chip” with geometry processor 21 and renderer 22 as known to those skilled in the art, or it may be external memory that can be accessed by geometry processor 21 and renderer 22.

  The memory 23, among other things, as shown in FIG. 2, is a set of raw geometry data 24 (e.g., from a graphics processor driver as known in the art or from the host system of the graphics processor 20 ( (Provided by the API running on the microprocessor) and a set of transformed geometry data 25 (also various transformations performed on the raw geometry 24, also known in the art) And one obtained as a result of the processing operation) and a set of graphics object (descriptor) lists 26. Graphic object list 26 is created in accordance with the present invention. This process is described in more detail below.

  The transformed geometry data 25 includes, for example, transformed vertices (vertex data) as is known in the art.

  The geometry processor 21 comprises, among other things, a programmable vertex shader 27 and a graphics object (descriptor) list construction unit 28. Programmable vertex shader 27 interprets raw geometry data 24 stored in memory 23 as its own input, processes the data, and prepares the geometry data in a form ready to display 2D placement in the frame. Provide transformed geometry data 25 containing (and store it in memory 23). Programmable vertex shader 27 and the process it performs itself may take any suitable form and may be any suitable process desired, as is known in the art.

  The graphics object list construction unit 28 executes the process of the present invention for allocating a plurality of graphics objects (descriptors—draw calls in this case) to a plurality of graphics object (descriptor) lists, and the plurality of graphics objects. The list is then used by the renderer 22 to identify a plurality of graphics objects (descriptors) to be rendered for each subregion of the scene to be rendered. To do this, the graphics object list construction unit 28 interprets the transformed and processed vertex data from the programmable vertex shader 27 (i.e. the location of the graphics object in the scene) as its own input, and The data is used to build a graphics object (tile) list and the list is stored in the memory 23 as a graphics object list 26. This process is described in more detail below.

  The renderer 22 includes a graphics object (descriptor) selection unit 29, a graphics object list cache 30, a vertex selection unit 31, a vertex data cache 32, a rasterization unit 33, a rendering unit 34, and a tile buffer 35. Including.

  In this embodiment, rasterization unit 33, rendering unit 34, and tile buffer 35 operate in the same manner as each such unit operates in an existing graphics processing system. Thus, rasterization unit 33 interprets certain primitives and their respective vertices as its own input, rasterizes the primitives into fragments, and supplies those fragments to rendering unit 34. The rendering unit 34 then performs several rendering processes, such as texture mapping, blending, and shading on the fragment to generate rendered fragment data that is tiled for supply to the frame buffer for display. Store in buffer 35.

  The graphics object selection unit 29 of the renderer 22 determines the graphics object (in this case, a draw call) and then determines the primitive to be rendered. The primitive selection unit 29 takes this into account the graphics object list 26 stored in the memory 23 and selects the next graphics object (draw call) to be rendered from one of the lists. Do by.

  The graphics object selection unit 29 can also accommodate one or more graphic object lists in the graphics object list cache 30.

  The graphics object selection unit 29 supplies the selected primitive to the vertex selection unit 31 for next rendering. In response, the vertex selection unit 31 retrieves the appropriate transformed vertex data for the corresponding primitive from the transformed geometry data 25 stored in the memory 23, and then retrieves the primitive (i.e., transformed vertex data). Supply to rasterization unit 33 for processing. The vertex selection unit 31 can also cache the vertex data retrieved from the memory 23 in the vertex data cache 32 as necessary.

  FIG. 3 shows an example scene to be displayed that is used as an example scene for display in the descriptor of this embodiment of the invention.

  As can be seen from FIG. 3, the scene 50 includes four primitives, which are grouped into two “draw calls”, draw call 1 and draw call 2. Primitives 0, 1, and 2 are grouped as draw call 1, and primitive 3 belongs to draw call 2. (As is known in the art, grouping primitives with “draw calls” basically means that the application programmer wants to draw all the primitives of a draw call at once, usually for performance reasons. (Call primitives usually share the same state and shader program data.)

  Also, given that there are two separate draw calls where primitive 2 is in one draw call and primitive 3 is in another draw call, vertex 8 shown in FIG. Note that they are not shared but instead are shown as two different vertices with the same vertex location and vertex attributes.

  As shown in FIG. 4, the scene to be rendered 50 is divided into a plurality of individual small areas or tiles 51. (As will be appreciated by those skilled in the art, in practice, any given scene to be rendered typically includes more primitives and draw calls than the four primitives and two draw calls shown in FIG. FIG. 3 shows four primitives and two draw calls only for simplicity and clarity.)

  In the embodiment of the present invention, the graphics object list construction unit 28 determines the location of each draw call (graphics descriptor), draw call 1 and draw call 2, and each small area (tile) including the draw call. List draw calls in the graphics object (descriptor) list for. In this way, the system can identify which draw call (graphics descriptor) is to be rendered for each subregion.

  This is done, for example, using an accurate binning technique, in which case the graphics object list construction unit 28 uses the determined and deformed vertex position it was provided for for a given draw call by the programmable vertex shader 27. Thus, it is identified which small area and a set of small areas contain (cross) the draw call.

  As will be appreciated by those skilled in the art, other techniques for determining and positioning for draw calls in the scene and for small regions (tiles) 51 may be used as desired. For example, bounding box techniques may be used in a similar manner, as is known in the art. FIG. 3 shows exemplary bounding boxes 52, 53, draw call 1 and draw call 2 for a draw call. (If bounding box techniques are used, it is preferred that the bounding box be generated as part of the graphics object (descriptor) listing process, for example by the graphics object list construction unit, but of course other It should be possible to configure

  This process in turn renders the graphics objects of the scene to be rendered until a complete graphics object list 26 (a list of graphics objects (descriptors)) is generated for each subregion into which the scene to be rendered is divided. Repeated by the graphics object list construction unit 28 for each (draw call).

  The graphics object list construction unit 28 places graphics objects (descriptors) in the graphics object list 26 in the order in which it receives graphics objects from the programmable vertex shader 27. This is, as long as each here graphics object list 26 is involved, the graphics objects (descriptors) in the list are the order in which they were created, which usually renders the graphics objects as is known in the art. It means to correspond to the desired order.

  As described above, the renderer 22 also includes a graphics object list cache 30 and a vertex data cache 32. These caches are provided on the renderer 22, as is known in the art, from the renderer's processing unit more quickly than the main memory 23 (in particular, the graphics object selection unit 29 and the vertex selection unit 31). Have local memory that can be accessed respectively.

  The graphics object selection unit 29 is configured to store in the graphics object list cache 30 one or more graphics object lists 26 that are themselves read from the main memory 23.

  Similarly, the vertex selection unit 31 can cache the vertex data retrieved from the converted geometry data 25 in the memory 23 in the vertex data cache 32, and in particular, the vertex data is required again for a certain primitive. It can also be cached where it can be identified.

  While the above embodiments have been described with respect to using graphics objects (descriptors) to indicate the rendered primitives for the rendering process, these lists of graphics data and descriptors (eg, (Initial) selection and / or can be used in addition or instead for other purposes, such as hidden surface removal.

  As will be appreciated by those skilled in the art, the present embodiment (and the present invention) can be implemented in the form of any tile-based rendering system as desired. The present embodiments and the various components and functions of the present invention can also be implemented in any desired manner using any suitable technique known in the art.

  From the above, the present invention, at least in its preferred embodiments, provides better control and knowledge of memory usage and memory requirements, particularly with respect to, for example, the tile listing (primitive sorting (binning)) process. Provides a configuration and list of graphics data for tile-based rendering systems that can be easily obtained and / or provide an opportunity for more rapid removal (selection) of data from subsequent processing To do.

  This is particularly valuable for devices where resource and memory requirements can be limited, such as embedded devices and / or portable devices such as cell phones.

  This is achieved, at least in the preferred embodiments of the present invention, simply by sorting the basic non-primitive graphics descriptors (descriptions) into a tile list (on a per subregion basis).

It is the schematic of one structure of tile-based graphics processing. 1 is a schematic diagram of one configuration of a graphics processor that can operate in accordance with the present invention. FIG. 6 is a schematic diagram of one embodiment of a process for assigning multiple primitives to multiple primitive lists.

Explanation of symbols

21 Geometry processor
22 Renderer
23 memory
24 Graphics object selection unit

Claims (15)

An apparatus for sorting graphics data for processing in a graphics processing system,
Means for sorting graphics descriptors relating to or associated with a location or multiple locations of a scene to be rendered into a specific area or sub-region of the scene, wherein each graphics descriptor A means of sorting that is not a single primitive;
Means for creating a graphics descriptor list for one or more areas or subregions of the scene to be rendered, each graphics descriptor being other than a single primitive of the scene to be rendered;
With
A graphics descriptor is an indication of graphics processing performed at a particular scene location or area, and a relatively high order or relatively high level descriptor and / or pre-primitive descriptor of the object to be rendered. A device comprising one or more of a group or set of primitives and a draw call.   The apparatus of claim 1, wherein the area or subregion of the scene comprises a subregion into which the scene is divided for rendering purposes.   The apparatus according to claim 1 or 2, wherein the scene area or subregion comprises a visible or invisible scene area.   4. The apparatus according to any one of claims 1 to 3, comprising means for creating a graphics descriptor list that is commonly used for more than one subregion or area.   5. Apparatus according to any one of the preceding claims, comprising means for using a sorted graphics descriptor and / or graphics descriptor list when rendering a display scene.   The means according to any one of claims 1 to 5, comprising means for using the sorted graphics descriptor and / or graphics descriptor list to perform a selection operation before the scene is rendered. apparatus.   Means for comparing the location or location of the graphics descriptor of the scene to be rendered with the location or location of a specific or selected area or areas or subregions or subregions of the scene; The apparatus according to claim 1, wherein the child is other than a single primitive of the scene to be rendered. A method of sorting graphics data for processing in a graphics processing system,
Sorting graphics descriptors relating to or associated with the location or locations of the scene to be rendered into a specific area or sub-region of the scene, each graphics descriptor of the scene being rendered Sorting, other than a single primitive,
A graphics descriptor list for one or more areas or small areas of the scene to be rendered, each graphics descriptor creating a graphics descriptor list that is not a single primitive of the scene to be rendered. Prepared,
A graphics descriptor is an indication of graphics processing performed at a particular scene location or area, and a relatively high order or relatively high level descriptor and / or pre-primitive descriptor of the object to be rendered. A method comprising one or more of a group or set of primitives and a draw call.   9. The method of claim 8, wherein the scene area or subregion comprises a subregion into which the scene is divided for rendering purposes.   10. A method according to claim 8 or 9, wherein the scene area or subregion comprises a visible or invisible scene area.   11. A method according to any one of claims 8 to 10, comprising means for creating a graphics descriptor list that is commonly used for more than one subregion or area.   12. A method according to any one of claims 8 to 11, comprising means for using a sorted graphics descriptor and / or graphics descriptor list when rendering a display scene.   13. A means according to any one of claims 8 to 12, comprising means for using the sorted graphics descriptor and / or graphics descriptor list to perform a selection operation before the scene is rendered. Method. When the program element is running on a data processing unit, the computer program comprising computer software code portions for performing the method according to any one of claims 8 13. Or comprising a device according to any one of claims 1 7, or operates in accordance with the method according to any one of claims 8 13, 3D graphics-processor.

Images