Rendering systems, chips, devices, and rendering methods used in rendering systems.
By introducing a rendering pipeline manager to merge the bounding boxes of GPU cores, the problem of low pixel processing efficiency and unbalanced load caused by small element size in tile rendering is solved, thus improving processing efficiency and balance.
Patent Information
- Application Number
- CN202511862192.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2025-12-10
- Publication Date
- 2026-11-10
- Estimated Expiration
- 2045-12-10
AI Technical Summary
In tile rendering (TBR), when the element size generated by the geometry processing pipeline is small and the number of tiles covered is small, the processing efficiency of the pixel processing pipeline will decrease, and there will be problems of wasted empty tile processing and unbalanced load.
A rendering pipeline manager is introduced to merge the first bounding box generated by the GPU core into a second bounding box, thereby unifying the management of tile processing in the pixel processing pipeline and reducing empty tile processing and load imbalance.
It improves the processing efficiency of the pixel processing pipeline, reduces empty tile processing time, and reduces load imbalance between pixel processing pipelines.
Smart Images

Figure CN121708181B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of image rendering technology, and in particular to a rendering system, chip, device, and rendering method applied to the rendering system. Background Technology
[0002] A graphics processing unit (GPU) is used to render images displayed on electronic devices.
[0003] Among related technologies, there exists a GPU architecture called Tile Based Rendering (TBR). In TBR, the screen of an electronic device is divided into multiple tiles, and rendering is performed tile by tile. Specifically, multiple geometry processing pipelines first process the input data stream to generate the elements on the screen, and then divide the elements on the screen into multiple rendering data sets based on tiles. Further, multiple pixel processing pipelines read and process these multiple rendering data sets to obtain the final rendering result.
[0004] However, in the aforementioned related technologies, when the element size generated by the geometry processing pipeline is small and the number of tiles covered is small, the processing efficiency of the pixel processing pipeline will decrease. Summary of the Invention
[0005] This application provides a rendering system, a chip, a device, and a rendering method applied to the rendering system. The technical solutions provided by this application include the following.
[0006] According to one aspect of the embodiments of this application, a rendering system is provided, the rendering system comprising: a rendering pipeline manager and at least two GPU cores, wherein the GPU cores include a geometry processing pipeline and / or a pixel processing pipeline; The GPU core is used to determine a first bounding box based on rendering data generated by the geometry processing pipeline inside the GPU core; wherein the first bounding box is the smallest region that covers all elements in the rendering data; The GPU core is also used to send first data to the rendering pipeline manager, the first data being used to instruct the first bounding box; The rendering pipeline manager is used to determine a second bounding box based on first data sent by at least two of the GPU cores respectively; wherein each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two of the first bounding boxes; The rendering pipeline manager is also configured to send second data to the pixel processing pipeline, the second data being used to indicate the second bounding box; The GPU core is also used to generate rendering results based on the second data through the pixel processing pipeline.
[0007] According to one aspect of the embodiments of this application, a GPU chip is provided, the GPU chip including the rendering system described above.
[0008] According to one aspect of the embodiments of this application, an electronic device is provided, the electronic device including a GPU chip, the GPU chip including the rendering system described above.
[0009] According to one aspect of the embodiments of this application, a rendering method is provided for use in a rendering system, the rendering system comprising: a rendering pipeline manager and at least two GPU cores, wherein the GPU cores include a geometry processing pipeline and / or a pixel processing pipeline; The method includes: The GPU core determines a first bounding box based on the rendering data generated by the geometry processing pipeline inside the GPU core; wherein, the first bounding box is the smallest region that covers all elements in the rendering data; The GPU core sends first data to the rendering pipeline manager, the first data being used to indicate the first bounding box; The rendering pipeline manager determines a second bounding box based on first data sent by at least two of the GPU cores respectively; wherein each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two of the first bounding boxes; The rendering pipeline manager sends second data to the pixel processing pipeline, the second data being used to indicate the second bounding box; The GPU core generates a rendering result based on the second data through the pixel processing pipeline. The technical solution provided in this application embodiment may include the following beneficial effects.
[0010] In this embodiment, the rendering pipeline manager can collect and merge the first bounding boxes of each GPU core to obtain a second bounding box, and send the second bounding box to the pixel processing pipeline. For each data segment, the GPU core calculates the screen space occupied by all its corresponding elements, takes a union, and finds the smallest region that can enclose all elements, called the first bounding box. When each GPU core finishes processing any data segment, it sends the first data indicating the first bounding box of that data segment to the rendering pipeline manager. The rendering pipeline manager maintains a data structure to collect the first data of each data segment sent by each GPU core. When the rendering pipeline manager sends a pixel processing pipeline task, it takes a union of all the first bounding boxes of all data segments included in this task based on the first data to determine a smallest region, namely the second bounding box. This second bounding box can enclose the first bounding boxes of all the aforementioned data segments, and sends the second data indicating the second bounding box to the pixel processing pipeline of each GPU core. For each GPU core's pixel processing pipeline, it no longer needs to traverse all tiles on the entire screen; it only needs to traverse all tiles within the second bounding box of the data segment involved in the current task. Through unified management by the rendering pipeline manager, the proportion of empty tiles processed by the pixel processing pipeline is reduced, thereby decreasing the processing time for empty tiles. Furthermore, since most tiles are covered by elements, the load on different pixel processing pipelines is similar, reducing load imbalance. Therefore, when the geometry processing pipeline generates small element sizes and covers a small number of tiles, the rendering system in this embodiment can improve the processing efficiency of the pixel processing pipeline. Attached Figure Description To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0011] Figure 1 This is a schematic diagram of a rendering system provided in one possible implementation of this application; Figure 2 This is a schematic diagram of the first bounding box provided in one possible implementation of this application; Figure 3 This is a schematic diagram illustrating the determination of the second bounding box in one possible implementation of this application; Figure 4This is a flowchart of a rendering method applied to a rendering system provided in one possible implementation of this application; Figure 5 This is a simplified structural block diagram of an electronic device provided in one possible implementation of this application. Detailed Implementation
[0012] To make the objectives, technical solutions, and advantages of this application clearer, the embodiments of this application will be described in further detail below with reference to the accompanying drawings.
[0013] Before introducing the rendering system proposed in this application, the following is a brief description of the image rendering technologies involved in related technologies.
[0014] Among the related technologies, there is a GPU architecture called TBR.
[0015] In some embodiments, TBR mainly includes the following components.
[0016] 1. Tiled Rendering. TBR divides the screen of an electronic device into several small rectangular blocks, or tiles, and each tile is rendered independently. The GPU core first converts all the geometric data into rendering data in screen space coordinates, and then categorizes this rendering data according to the tiles it covers. For the rendering data in each tile, the GPU core concatenates them and stores them in external memory. For example, the external memory is video memory.
[0017] Because the length of rendering data is uncertain, a common practice is to use a linked list data structure for storage. That is, for each tile on the screen that is covered by an element in the rendering data, a linked list of tiles is generated. Specifically, for a given tile, for each element covering that tile, the GPU core allocates a storage unit in external memory. This storage unit contains at least the rendering data and a pointer, where the pointer points to the storage unit of the next element covering that tile. The GPU connects these scattered storage units in external memory through the pointers within the storage units, forming a linked list of tiles.
[0018] For the entire screen, the GPU core pre-allocates a fixed-size head pointer array in pre-allocated space (the aforementioned external memory) based on the size of the current rendering target and the size of each tile. The length of this head pointer array is equal to the total number of tiles on the screen, and each position in the array corresponds to a tile on the screen, used to store the head pointer of that tile. If a tile is covered by an element, the GPU core creates and maintains a tile linked list in external memory for it, and fills the starting address of the linked list (i.e., the head pointer) into the corresponding position in the head pointer array. If a tile is not covered by any element, the corresponding head pointer is set to a null value (such as NULL), indicating that this tile is not covered by any element.
[0019] Therefore, in the subsequent tile-by-tile rendering stage, the GPU core can quickly locate and traverse all the elements required to render any tile using the head pointer array.
[0020] 2. Tile Buffer. When processing each tile, the GPU core loads the necessary geometry and texture data for that tile from external memory into a small cache (usually stored on-chip). Once the data is on-chip, all core rendering operations are performed internally, greatly reducing the number of accesses to external memory during rendering and thus improving efficiency.
[0021] 3. Tile-by-tile rendering. The GPU cores process each tile sequentially until the entire screen has been rendered. After each tile is rendered in its independent tile buffer, the result is written to the final frame buffer.
[0022] For example, the main advantages of TBR include the following aspects.
[0023] On the one hand, memory bandwidth is saved. Since the TBR architecture only needs to access local geometric and texture data within each tile, it can significantly reduce read and write operations to external memory, thereby reducing memory bandwidth requirements.
[0024] On the other hand, energy saving. Reducing the need for memory bandwidth also means reducing power consumption, which is why the TBR architecture is widely used in mobile devices.
[0025] On the other hand, some algorithms can be used to reduce overdraw, thereby reducing the workload of the fragment shader.
[0026] For example, the main disadvantages of TBR include the following aspects.
[0027] On the one hand, pointers are wasted. If a rendering target is large and the tile size is small, the number of tiles will be very large. Even if a tile is not eventually covered by an element, its head pointer is still needed because it is unknown whether an element will cover the tile in the future. Although a tile may never be covered by an element, that is, it does not generate a tile list, the GPU core will still generate a head pointer for that tile.
[0028] On the other hand, the process is complex. Piece rendering is a complex process, involving steps such as slicing, storing to external memory, and retrieving. Especially when dealing with advanced graphics effects (such as global illumination and complex transparency processing), more hardware and software support may be required.
[0029] On the other hand, there is a delay. Because TBR needs to process the screen in slices, the entire rendering process may have a certain delay, especially in scenarios that require frequent updates.
[0030] On the other hand, insufficient memory. Because a large amount of data (tile linked lists) needs to be stored in external storage, it may lead to Out of Memory (OOM).
[0031] In summary, for TBR, the entire rendering process needs to be broken down into the following two steps. The entire rendering process includes a geometry processing pipeline and a pixel processing pipeline. First, the input data stream undergoes a series of processing steps in the geometry processing pipeline, including vertex shader, tessellation shader, geometry shader, matrix transformation, clipping, etc., to generate rendering data. Second, a screen overlay test is performed, that is, the rendering data is divided into multiple data streams (tile lists) based on tiles. The resulting data (tile lists and head pointer arrays) is stored in the cache of external memory (i.e., video memory). Then, the pixel processing pipeline reads the data of each tile from the external memory cache for subsequent processing. For the pixel processing pipeline, it accesses the head pointer corresponding to each tile in the head pointer array to determine whether the tile is covered by an element. If it is covered, it reads the rendering data from the corresponding tile list for subsequent processing.
[0032] For multi-core GPU systems, the input data stream is typically split and sent to different geometry processing pipelines for processing. Each GPU core generates an independent array of head pointers and a corresponding linked list of tiles. This leads to the following issues.
[0033] Firstly, for multi-core systems, if the pixel processing pipeline needs to process the content of any tile, since each GPU core generates an independent array of head pointers and a corresponding linked list of tiles, it needs to access N head pointers (although they may be empty), resulting in a certain degree of wasted operations. Here, N represents the number of GPU cores.
[0034] Secondly, if a pixel processing pipeline task contains small-sized elements concentrated within a few tiles, a large number of empty tiles will appear. Empty tiles are tiles that are not covered by any elements in a single rendering task, resulting in a large number of empty header pointers. If each header pointer needs to be read and checked for emptiness, it will lead to some operational waste.
[0035] Thirdly, generally speaking, a GPU core has multiple pixel processing pipelines. When reading the head pointer corresponding to a tile, it does not know whether it contains valid data. Therefore, this will cause a certain degree of load imbalance, that is, some pixel processing pipelines process valid data, while some pixel processing pipelines process empty tiles.
[0036] To address the aforementioned problems, this application provides a rendering system. This rendering system introduces a rendering pipeline manager to uniformly manage data segments processed by the geometry processing pipeline. Specifically, the GPU core determines a first bounding box based on the rendering data generated by the geometry processing pipeline, where the first bounding box is the smallest region covering all elements in the rendering data. The GPU core sends first data indicating the first bounding box to the rendering pipeline manager. The rendering pipeline manager determines a second bounding box based on the first data from at least two GPU cores, where the second bounding box is the smallest region covering at least two first bounding boxes. The rendering pipeline manager sends second data indicating the second bounding box to the pixel management pipeline, and the pixel processing pipeline generates the rendering result based on the second data.
[0037] In this embodiment, the rendering pipeline manager can collect and merge the first bounding boxes of each GPU core to obtain a second bounding box, and send the merged second bounding box to the pixel processing pipeline. For each data segment, the GPU core calculates the screen space occupied by all its corresponding elements, takes a union, and finds the smallest region that can enclose all elements, called the first bounding box. When each GPU core finishes processing any data segment, it sends the first data indicating the first bounding box of that data segment to the rendering pipeline manager. The rendering pipeline manager maintains a data structure to collect the first data of each data segment sent by each GPU core. When the rendering pipeline manager sends a pixel processing pipeline task, it takes a union of all the first bounding boxes of all data segments included in this task based on the first data to determine a smallest region, namely the second bounding box. This second bounding box can enclose the first bounding boxes of all the aforementioned data segments, and sends the second data indicating the second bounding box to the pixel processing pipeline of each GPU core. For each GPU core's pixel processing pipeline, it no longer needs to traverse all tiles on the entire screen; it only needs to traverse all tiles within the second bounding box of the data segment involved in the current task. Through unified management by the rendering pipeline manager, the proportion of empty tiles processed by the pixel processing pipeline is reduced, thereby decreasing the processing time for empty tiles. Furthermore, since most tiles are covered by elements, the load on different pixel processing pipelines is similar, reducing load imbalance. Therefore, when the element size generated by the geometry processing pipeline is small and covers a small number of tiles, the rendering system in this embodiment can improve the processing efficiency of the pixel processing pipeline. See the following explanation of the embodiments for details.
[0038] Please refer to Figure 1 , Figure 1 This is a schematic diagram of a rendering system provided in one possible implementation of this application.
[0039] In some embodiments, such as Figure 1 As shown, the rendering system includes a rendering pipeline manager 110 and at least two GPU cores 120, wherein the GPU cores 120 include a geometry processing pipeline 130 and / or a pixel processing pipeline 140.
[0040] GPU core 120 is used to determine a first bounding box based on rendering data generated by the geometry processing pipeline 130 inside GPU core 120; wherein the first bounding box is the smallest region that covers all elements in the rendering data.
[0041] GPU core 120 is also used to send first data to rendering pipeline manager 110, the first data being used to indicate the first bounding box.
[0042] The rendering pipeline manager 110 is used to determine a second bounding box based on first data sent by at least two GPU cores 120 respectively; wherein each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two first bounding boxes.
[0043] The rendering pipeline manager 110 is also used to send second data to the pixel processing pipeline 140, the second data being used to indicate a second bounding box.
[0044] GPU core 120 is also used to generate rendering results based on the second data through pixel processing pipeline 140.
[0045] Exemplarily, a GPU core is a unit used to perform geometry processing and pixel processing during graphics rendering. The GPU core may internally include a geometry processing pipeline and / or a pixel processing pipeline. In different embodiments, the structure of the GPU core may be the same or different. Exemplarily, in some embodiments, the GPU core internally includes both a geometry processing pipeline and a pixel processing pipeline. Exemplarily, in other embodiments, the GPU core internally includes only a geometry processing pipeline, or only a pixel processing pipeline. Exemplarily, in other embodiments, some GPU cores internally include both a geometry processing pipeline and a pixel processing pipeline, while some GPU cores internally include only a geometry processing pipeline or a pixel processing pipeline. It is worth noting that the above-described GPU core is merely an illustrative example, and this embodiment does not limit its scope.
[0046] Exemplarily, the geometry processing pipeline is used to perform geometric processing on the input data stream or data segments based on the input data stream. Exemplarily, the geometry processing pipeline's geometric processing of the data segments includes, but is not limited to, at least one of the following: vertex shader, tessellation, geometry shader, viewport transformation, etc. Exemplarily, each GPU core includes one or more geometry processing pipelines. The number of geometry processing pipelines may be the same or different in different GPU cores. In some embodiments, a GPU core includes M geometry processing pipelines, that is, the number of GPU cores corresponding to M geometry processing pipelines is 1, where M is a positive integer. In other embodiments, a GPU core includes 1 geometry processing pipeline, that is, the number of GPU cores corresponding to M geometry processing pipelines is M, where M is a positive integer. It is worth noting that the above geometry processing pipeline is merely an illustrative example, and this embodiment does not limit it.
[0047] Exemplarily, the pixel processing pipeline is used to perform pixel processing on the rendering data obtained after processing by the geometry processing pipeline to obtain the final rendering result. Exemplarily, the pixel processing of the rendering data by the pixel processing pipeline includes, but is not limited to, at least one of the following: rasterization and fragment shader, depth and stencil testing, and color mixing output. Exemplarily, each GPU core includes one or more pixel processing pipelines. The number of pixel processing pipelines in different GPU cores may be the same or different. Exemplarily, the pixel processing pipeline may also be distributed outside the GPU core. Exemplarily, each pixel processing pipeline is used to process and implement the rendering of multiple tiles on the screen. In some embodiments, a GPU core includes N pixel processing pipelines, that is, the number of GPU cores corresponding to N pixel processing pipelines is 1, where N is a positive integer. In other embodiments, a GPU core includes 1 pixel processing pipeline, that is, the number of GPU cores corresponding to N pixel processing pipelines is N, where N is a positive integer. In some embodiments, M equals N. It is worth noting that the above pixel processing pipeline is only an illustrative example, and this embodiment does not limit it.
[0048] For example, the input data stream is the raw data fed into the rendering system for rendering an image. This input data stream includes multiple element-related data, where elements typically refer to the basic visual units that constitute a scene. In some embodiments, an element can represent a complete 3D object, such as a model defined by a mesh; it can also represent the basic geometric primitives (i.e., primitives) that constitute the object, such as points, lines, and triangles; in some embodiments, it can refer to basic vertex data. For example, vertex data is data provided for subsequent geometry processing pipelines, including at least one of vertex attributes such as vertex coordinates, texture coordinates, vertex normals, and vertex colors. In some embodiments, the input data stream is divided into multiple data segments, each input to the geometry processing pipeline of its respective GPU core. For example, multiple data segments are allocated to geometry processing pipelines within multiple GPU cores for processing. For example, no two data segments are identical, any two data segments are different, or there is no overlap between any two data segments.
[0049] In some embodiments, the input data stream is simultaneously fed into the geometry processing pipelines of multiple GPU cores. Exemplarily, the input data stream is segmented using a certain algorithm and processed separately in different geometry processing pipelines. The entire input data stream is segmented into data segments according to certain rules, and these data segments are distributed to multiple GPU cores in a round-robin manner.
[0050] In this embodiment, each data stream (i.e., each data segment) is assigned a number, starting from 0, with each data segment numbered sequentially. Each data segment's number is a non-negative number. Exemplarily, adjacent data segments are also numbered consecutively. For example, in a 4-core GPU system (including GPU core 0, GPU core 1, GPU core 2, and GPU core 3), data segment 0 (where 0 is the data segment's number) is distributed to the geometry processing pipeline within GPU core 0, data segment 1 is distributed to the geometry processing pipeline within GPU core 1, data segment 2 is distributed to the geometry processing pipeline within GPU core 2, data segment 3 is distributed to the geometry processing pipeline within GPU core 3, and data segment 4 is again distributed to the geometry processing pipeline on GPU core 0, and so on.
[0051] This approach ensures that the number of data segments allocated to each GPU core is relatively consistent, without significant differences, which helps to balance the number of data segments processed by each GPU core and achieve parallel processing.
[0052] For example, the data segments are numbered sequentially according to the order in which they are allocated to the GPU cores for processing. For example, the geometry processing pipeline in each GPU core processes the data segments one by one in the order they are received. For example, the geometry processing pipeline processes the data segments with smaller numbers first, and then processes the data segments with larger numbers, such as processing the data segments numbered 0, 4, 8, and 12 in sequence. For example, the geometry processing pipeline processes the allocated data segments in the order they are allocated. It is worth noting that the embodiments of this application do not limit the method of dividing the input data stream; the input data stream is divided into multiple data segments according to a preset division rule.
[0053] In some embodiments, the GPU core is used to determine a first bounding box based on rendering data generated by the geometry processing pipeline within the GPU core. The first bounding box is the smallest region that covers all elements in the rendering data.
[0054] For example, when dividing the input data stream, the resulting multiple data segments are numbered to obtain the number of each data segment. For example, starting from 0, each data segment is numbered sequentially, and each data segment number is a non-negative number. For example, the numbers of adjacent data segments are also consecutive.
[0055] For example, data segments are allocated to L GPU cores in a certain order, where L is a positive integer. For example, the method for allocating data segments to the L GPU cores is as follows: For example, a first value is set. Starting with data segment numbered 0, a data segment of the first value is allocated to the first GPU core of the L GPU cores, the second GPU core of the L GPU cores, the third GPU core of the L GPU cores, and so on, until each of the L GPU cores has a data segment of the first value. If there are still unallocated data segments, starting from the first GPU core of the L GPU cores, the allocation of data segments of the first value continues until all data segments have been allocated. In this embodiment, the first value is 1.
[0056] In some embodiments, data segments are fed into a geometry processing pipeline within the GPU core for geometric processing to generate rendering data. Exemplarily, the geometry processing pipeline is a module for performing geometric processing on an input data stream or data segments partitioned based on the input data stream. Exemplarily, geometric processing is a pre-configured process in the geometry processing pipeline, and the geometric processing performed by the pipeline is used to make the data segments conform to the requirements for subsequently determining a first bounding box, i.e., generating rendering data for determining the first bounding box. In embodiments of this application, any processing procedure performed on a data segment by the geometry processing pipeline can be referred to as geometric processing. In some embodiments, geometric processing includes, but is not limited to, at least one of the following processing methods for the data segments: vertex shader, tessellation, geometry shader, viewport transformation, etc.
[0057] The vertex shader processes the vertex information in the input data segment to generate the basic data used to construct primitives. Specifically, the vertex shader can perform calculations such as model, view, and projection transformations based on the input vertex attributes such as vertex coordinates, normals, and texture coordinates, and output vertex coordinate data in clip space or screen space. This processed vertex data is the basis for assembling the initial primitives (such as points, lines, and triangles).
[0058] The tessellation function is an optional stage following the vertex shader, used to dynamically subdivide the initial input primitives (such as a triangle or quadrilateral patch). Its function is to further divide the relatively coarse primitives into a large number of smaller, finer primitives, thereby improving the geometric details and smoothness of the model surface without increasing the complexity of the original data. Through the tessellation function, a greater number of geometric structures with more precise boundaries can be generated in the rendered data.
[0059] A geometry shader is a programmable stage that takes a complete primitive (such as a triangle, a line segment, or a point) as input and performs geometric operations on it. Its core capability lies in its ability to dynamically generate new primitives, modify the shape of existing primitives, or perform operations such as copying and culling primitives. For example, it can expand a point into a triangle or decompose a triangle into multiple new triangles, thereby forming primitive outputs that meet preset requirements.
[0060] Viewport transformation refers to mapping elements (including the aforementioned primitives) that conform to preset requirements to screen coordinate space, ensuring that the spatial position of elements in the rendered data corresponds to the preset area. Through viewport transformation, the screen position of each element in the rendered data is defined, allowing the rendered data to be directly used for subsequent processing.
[0061] It is worth noting that the above geometric processing is merely an illustrative example and is not intended to limit the scope of this embodiment.
[0062] For example, the data segments input to the GPU core are processed through the geometry processing pipeline within the GPU core to generate rendering data. Through the geometry processing pipeline, the GPU core converts the data segments into rendering data in screen space coordinates. Each element in the rendering data is mapped to screen space to ensure that the spatial position of the elements in the rendering data corresponds to a preset area. Specifically, in the geometry processing stage, elements are typically materialized as primitives (such as points, lines, and triangles) and their constituent vertices. Therefore, the rendering data mainly includes: 1. Vertex coordinates: This data determines the geometric shape and position of the primitive on the screen. For example, it includes the pixel coordinates (X, Y) of each vertex of the primitive. The vertex coordinates of the primitive define the shape and position of the primitive on the screen; 2. Vertex attributes: This data provides necessary parameters for subsequent pixel processing stages. For example, it includes texture coordinates (used to sample color information from texture maps and map it to the primitive surface), vertex colors (used to provide a base color for each vertex of the primitive), normal vectors (used for lighting calculations on the primitive surface to simulate a sense of depth), and other custom attributes used to achieve complex visual effects. It is worth noting that the above rendering data is only an illustrative example. In the embodiments of this application, the rendering data may cover any information describing the geometric features, appearance attributes and behavioral logic of elements (including but not limited to primitives), and is not limited to the types listed above.
[0063] For example, for the entire screen, the GPU core determines the screen division method based on the system's preset tile size parameters. Specifically, assuming the screen resolution is W×H pixels, and the width and height of the tiles are P and Q pixels respectively, the entire screen can be divided into a tile grid of (W / P) columns and (H / Q) rows. Here, W represents the number of pixels in the screen width direction, H represents the number of pixels in the screen height direction, and W, H, P, and Q are all positive integers. For example, a tile grid refers to a two-dimensional grid formed by uniformly dividing the screen space into multiple tiles. Each tile is identified by its unique column index (usually along the horizontal direction of the screen, i.e., the X-axis) and row index (usually along the vertical direction of the screen, i.e., the Y-axis). The starting point for index counting (e.g., starting from 0 or 1) and the direction of increase (e.g., from left to right, from top to bottom, or from bottom to top) are predefined by the system. It is worth noting that the above tile division method is only an illustrative example, and this embodiment does not limit it.
[0064] For example, in the middle of a tile-based screen, there is a mapping relationship between the vertex coordinates of primitives and tiles. Specifically, this includes: 1. For a vertex coordinate of (X, Y) in screen space, a tile can be uniquely identified, that is, the above-mentioned tile includes only one vertex coordinate; 2. A tile simultaneously contains multiple vertex coordinates of one or more different primitives. It is worth noting that the above-mentioned mapping relationship between tiles and vertex coordinates is only an illustrative example, and this embodiment does not limit it.
[0065] For example, the GPU core, based on the rendering data generated by the geometry processing pipeline, traverses the vertex coordinates of each primitive to determine its geometric shape and position in screen space. Specifically, the geometric shape of a primitive is defined by the number of vertex coordinates it contains and the connectivity between those vertex coordinates. For instance, a primitive consisting of three vertex coordinates represents a triangle, while a primitive consisting of two vertex coordinates represents a line segment. In this embodiment, a triangle is used as an example to illustrate the geometric shape of the primitive.
[0066] After determining the geometry and position of the primitives in screen space, the GPU core can determine the first bounding box. In this embodiment, the first bounding box is the smallest region covering all elements in the rendered data, that is, the smallest region covering all primitives of the corresponding data segment in screen space. In some embodiments, the first bounding box is a data structure used to characterize the distribution range of all primitives within its corresponding data segment in screen space, which at least includes boundary coordinate information for defining the aforementioned minimum region. Exemplarily, it includes, but is not limited to, one of the following forms: 1. Rectangular Bounding Box: Its data representation can be four boundary values, typically the minimum X-coordinate (X_min), the maximum X-coordinate (X_max), the minimum Y-coordinate (Y_min), and the maximum Y-coordinate (Y_max). These four values uniquely define a rectangular region whose sides are parallel to the screen coordinate axes, i.e., the first bounding box. For example, a first bounding box can be represented as the data sequence [32, 176, 48, 224], representing the coordinates of its left, right, top, and bottom boundaries in the screen pixel coordinate system, respectively.
[0067] 2. Bounding Sphere: Its data is represented by three values: the X-coordinate and Y-coordinate of the sphere's center, and the radius of the sphere. For example, the first bounding box can be represented as (Center_x, Center_y, Radius).
[0068] 3. Other convex bounding boxes: such as arbitrary convex polygons, etc.
[0069] It is worth noting that the specific implementation of the first bounding box described above is merely an illustrative example. In the embodiments of this application, any method capable of recording and characterizing the minimum boundary of the distribution range of all primitives within its corresponding data segment in screen space falls within the scope of possible implementations of the first bounding box.
[0070] In some embodiments, such as Figure 2 As shown, Figure 2 This is a schematic diagram of the first bounding box 210 provided in one possible implementation of this application. The first bounding box 210 is the smallest rectangular region covering all elements in the rendered data.
[0071] For example, each primitive in the element (i.e., the triangular primitive mentioned above) contains three vertex coordinates. The GPU core can uniquely determine the area covered by a triangular primitive on the screen by traversing the coordinates of the three vertices of a primitive in screen space. Specifically, the GPU core traverses the three vertex coordinates (X1, Y1), (X2, Y2), and (X3, Y3) of a primitive and calculates the minimum X coordinate value of the primitive on the screen, i.e., X_min = min(X1, X2, X3), the maximum X coordinate value, X_max = max(X1, X2, X3), the minimum Y coordinate value, Y_min = min(Y1, Y2, Y3), and the maximum Y coordinate value, Y_max = max(Y1, Y2, Y3). Using the four coordinate values mentioned above, the GPU core can uniquely determine a rectangular region with four vertex coordinates of (X_min, Y_min), (X_max, Y_min), (X_min, Y_max), and (X_max, Y_max). This rectangular region is the minimum bounding rectangle of the primitive, which is also the coverage area of the corresponding element. For example, for primitives with polygonal or line segment geometry, the minimum bounding rectangle of the primitive, i.e., the coverage area of the corresponding element, can also be determined using the maximum and minimum values of each vertex along the X and Y axes of the screen coordinate system. It is worth noting that the above method of determining the coverage area of an element is merely an illustrative example, and this embodiment does not limit it.
[0072] For example, after calculating the coverage area of each element, the GPU core merges the coverage areas of all elements to obtain the minimum coverage area. Specifically, this merging process includes comparing the coordinates of the upper, lower, left, and right boundaries of the coverage area of each element (the minimum bounding rectangle of the primitives mentioned above), and taking the maximum and minimum values in the X and Y directions of the screen coordinate system, respectively, to determine the minimum area that covers all elements, i.e., to determine the minimum coverage area.
[0073] In this embodiment, the GPU core merges the minimum bounding rectangles of all primitives to determine the minimum rectangular region (the aforementioned minimum coverage area). Exemplarily, the merging process is implemented by taking the extreme values of the boundaries along the X and Y axes of the screen coordinate system. Specifically: along the X-axis, the minimum left boundary (X_min) and maximum right boundary (X_max) of the bounding rectangles of all primitives are taken; along the Y-axis, the minimum lower boundary (Y_min) and maximum upper boundary (Y_max) of the bounding rectangles of all primitives are taken. The minimum left boundary (X_min) of the X-axis and the minimum lower boundary (Y_min) of the Y-axis are combined, and their intersection (X_min, Y_min) is the coordinates of the lower left vertex. The maximum right boundary (X_max) of the X-axis and the maximum upper boundary (Y_max) of the Y-axis are combined, and their intersection (X_max, Y_max) is the coordinates of the upper right vertex. Similarly, the coordinates of the upper left and lower right vertex can be obtained. Using the coordinates of the four vertices mentioned above as the vertex coordinates of the minimum rectangular region, the GPU core can determine a minimum rectangular region.
[0074] In some embodiments, to ensure that the minimum rectangular region does not extend beyond the screen area, the GPU core limits the coordinates of the four vertices of the minimum rectangular region to the effective display area of the screen. Specifically, the GPU core obtains the boundary parameters of the preset effective display area of the screen, which typically include: the left boundary position, the right boundary position, the top boundary position, and the bottom boundary position of the screen; 1. The GPU core compares the left boundary coordinates of the smallest rectangular region with the left boundary coordinates of the screen. If the left boundary coordinates of the smallest rectangular region are less than the left boundary coordinates of the screen, the left boundary coordinates of the smallest rectangular region are corrected to the left boundary coordinates of the screen; otherwise, the original left boundary coordinates of the smallest rectangular region are retained.
[0075] 2. The GPU core compares the right boundary coordinates of the smallest rectangular region with the right boundary coordinates of the screen. If the right boundary coordinates of the smallest rectangular region are greater than the right boundary coordinates of the screen, the right boundary coordinates of the smallest rectangular region are corrected to the right boundary coordinates of the screen; otherwise, the original right boundary coordinates of the smallest rectangular region are retained.
[0076] 3. The GPU core compares the upper boundary coordinates of the smallest rectangular region with the upper boundary coordinates of the screen. If the upper boundary coordinates of the smallest rectangular region are greater than the upper boundary coordinates of the screen, the upper boundary coordinates of the smallest rectangular region are corrected to the upper boundary coordinates of the screen; otherwise, the original upper boundary coordinates of the smallest rectangular region are retained.
[0077] 4. The GPU core compares the lower boundary coordinates of the smallest rectangular region with the lower boundary coordinates of the screen. If the lower boundary coordinates of the smallest rectangular region are less than the lower boundary coordinates of the screen, the lower boundary coordinates of the smallest rectangular region are corrected to the lower boundary coordinates of the screen; otherwise, the original lower boundary coordinates of the smallest rectangular region are retained.
[0078] For example, based on the above steps, the GPU core processes the four boundaries of the minimum rectangular region to obtain a minimum rectangular region that is completely within the effective display area of the screen. It is worth noting that the method for determining the minimum rectangular region described above is merely an illustrative example, and this embodiment does not limit it.
[0079] By setting the first bounding box as a rectangle, the GPU core only needs to calculate the minimum bounding rectangle of all primitives using the vertex coordinates in the rendering data and then merge them to determine the first bounding box. This reduces computational complexity and improves the processing efficiency of the GPU core in determining the first bounding box.
[0080] In some embodiments, such as Figure 2 As shown, the boundary of the first bounding box 210 is aligned with the tile boundary covered by all elements in the rendering data.
[0081] For example, after determining the minimum rectangular region, the GPU core can align the boundary of the minimum rectangular region with the tile boundary to determine the first bounding box. In some embodiments, the GPU core maps the boundary of the minimum rectangular region from pixel coordinates to tile indices, and after performing a rounding operation on the tile indices, obtains the first bounding box aligned with the tile boundary. For example, the specific implementation process includes: 1. The GPU core converts each boundary of the smallest rectangular region from pixel coordinates to the corresponding tile index. Specifically: The GPU core obtains the system's preset tile size parameters, including the tile width W and tile height H; for the left boundary pixel coordinates (X=X1) of the smallest rectangular region, the GPU core divides the left boundary coordinate value X1 by the tile width W, and the integer part of the resulting floating-point result is the tile column index of the left boundary of the first bounding box; for the right boundary pixel coordinates (X=X2) of the smallest rectangular region, the GPU core divides the right boundary coordinate value X2 by the tile width, and the integer part of the resulting floating-point result is the tile column index of the right boundary of the first bounding box; for the lower boundary pixel coordinates (Y=Y1) of the smallest rectangular region, the GPU core divides the lower boundary coordinate value Y1 by the tile height, and the integer part of the resulting floating-point result is the tile row index of the lower boundary of the first bounding box; for the upper boundary pixel coordinates (Y=Y2) of the smallest rectangular region, the GPU core divides the upper boundary coordinate value Y2 by the tile height, and the integer part of the resulting floating-point result is the tile row index of the upper boundary of the first bounding box.
[0082] Through the above steps, the pixel coordinates of each boundary of the smallest rectangular region are mapped to the tile index. It is worth noting that the above mapping method is an illustrative example and is not limited to this embodiment.
[0083] 2. In some embodiments, after mapping the boundary values of the minimum rectangular region from pixel coordinates to tile indices, the GPU core performs a rounding operation on the resulting tile indices to ensure that the generated first bounding box can completely cover all elements within the minimum rectangular region. Specifically, for the tile column index corresponding to the left boundary and the tile row index corresponding to the lower boundary of the minimum rectangular region, the GPU core uses a rounding-down process, ensuring that the left edge of the tile corresponding to the rounded left boundary column index is less than or equal to the pixel coordinates of the left boundary of the minimum rectangular region, and simultaneously ensuring that the lower edge of the tile corresponding to the rounded lower boundary row index is less than or equal to the pixel coordinates of the lower boundary of the minimum rectangular region. For the tile column index corresponding to the right boundary and the tile row index corresponding to the upper boundary, the GPU core uses a rounding-up process, ensuring that the right edge of the tile corresponding to the rounded right boundary column index is greater than or equal to the pixel coordinates of the right boundary of the minimum rectangular region, and simultaneously ensuring that the upper edge of the tile corresponding to the rounded upper boundary row index is greater than or equal to the pixel coordinates of the upper boundary of the minimum rectangular region. For example, the GPU core uses the rounded left and right boundary tile column indices and the lower and upper boundary tile row indices to define the tile range covered by the first bounding box.
[0084] For example, suppose the screen is divided into a 16×16 pixel tile grid, with the bottom left corner pixel coordinates of the smallest rectangular area being (37, 45) and the top right corner pixel coordinates being (123, 97). After mapping, its left boundary is approximately at tile column 2.31, its bottom boundary is approximately at tile row 2.81, its right boundary is approximately at tile column 7.69, and its top boundary is approximately at tile row 6.06. When performing this step: 1. Round down the left boundary tile column index (2.31) and the bottom boundary tile row index (2.81) to obtain index 2 and index 2, respectively; round up the right boundary tile column index (7.69) and the top boundary tile row index (6.06) to obtain index 8 and index 7, respectively.
[0085] The rounding operation described above ensures that the tile index range (columns 2 to 8, rows 2 to 7) used to determine the first bounding box completely covers the smallest rectangular area. It is worth noting that the rounding operation described above is merely an illustrative example and is not intended to limit the scope of this embodiment.
[0086] 3. In some embodiments, the GPU core maps the tile indices of the four boundaries back to the screen pixel coordinate system to obtain the pixel coordinates of the four boundaries of the first bounding box. Specifically, for the rounded left boundary tile column index, the GPU core performs a calculation, multiplying the index value by the tile width; the resulting product is the left boundary pixel coordinate of the first bounding box. For the rounded right boundary tile column index, the GPU core performs a calculation, multiplying the index value by the tile width; the resulting product is the right boundary pixel coordinate of the first bounding box. For the rounded lower boundary tile row index, the GPU core performs a calculation, multiplying the index value by the tile height; the resulting product is the lower boundary pixel coordinate of the first bounding box. For the rounded upper boundary tile row index, the GPU core performs a calculation, multiplying the index value by the tile height; the resulting product is the upper boundary pixel coordinate of the first bounding box.
[0087] In some embodiments, after obtaining the pixel coordinates of the four boundaries of the first bounding box, the GPU core determines the first bounding box based on these four coordinates. Specifically, for example: the lower left corner vertex of the first bounding box is determined by the pixel coordinates of the left and lower boundaries, and the upper right corner vertex is determined by the pixel coordinates of the right and upper boundaries. From these lower left and upper right corner vertices, a first bounding box whose boundary is aligned with the tile boundary can be determined. It is worth noting that the above method of determining the first bounding box based on boundary pixel coordinates is merely an illustrative example, and this embodiment does not limit it.
[0088] By aligning the boundary of the first bounding box with the tile boundary, the rendering pipeline manager no longer needs to perform operations such as calculating the minimum rectangular area of all elements within its coverage and aligning the minimum rectangular area to the tile boundary when determining the second bounding box. The rendering pipeline manager can directly ensure that the boundary of the second bounding box is aligned with the tile boundary by aligning it to the boundaries of all first bounding boxes covered by the second bounding box. This reduces the computational complexity of the rendering pipeline manager in determining the second bounding box and improves the processing efficiency of the rendering pipeline manager.
[0089] In some embodiments, the GPU core is further configured to send first data to the rendering pipeline manager. The first data is used to indicate a first bounding box. Optionally, the first data includes: coordinate data of the first bounding box, and the number of the data segment corresponding to the first bounding box. The data segment corresponding to the first bounding box is used to generate rendering data corresponding to that first bounding box.
[0090] For example, the coordinate data of the first bounding box is used to determine the position and extent of the first bounding box in screen space. In some embodiments, the coordinate data of the first bounding box is based on the pixel coordinates of the four boundaries of the first bounding box, that is, the position and extent of the first bounding box are determined by the pixel coordinates of each boundary of the first bounding box in the screen pixel coordinate system. For example, the coordinate data of the first bounding box includes four values, namely the coordinates of the left boundary, the right boundary, the top boundary, and the bottom boundary of the first bounding box. After the GPU core calculates these four coordinate data, it can directly determine the first bounding box. For example, assuming the screen resolution is 1920×1080 pixels and the system's preset tile size is 16×16 pixels. After the GPU core determines the position of the boundary of the first bounding box in screen space and aligns the above boundaries with the tile boundaries, the left boundary of the first bounding box is located at the 32nd pixel, the right boundary is located at the 176th pixel, the top boundary is located at the 48th pixel, and the bottom boundary is located at the 224th pixel. Then the coordinate data of the first bounding box can be specifically represented as the numerical sequence: 32, 176, 48, 224. It is worth noting that the above coordinate data determination method and specific values are only illustrative examples, and this embodiment does not limit them.
[0091] In some embodiments, the number of the data segment corresponding to the first bounding box is used to identify the data segment and GPU core corresponding to the first bounding box. For example, a data segment refers to a data unit that can be processed independently, formed by dividing the complete input data stream according to a preset strategy before it enters the geometry processing pipeline inside the GPU core. The purpose of dividing the data into multiple segments is to decompose the large rendering task into multiple smaller, more manageable units so that they can be allocated to different GPU cores for parallel processing. For example, the logical rules for the division may include, but are not limited to: by timing (such as the order of rendering instructions), by primitive type (such as static objects and dynamic objects), or by spatial region (such as different parts of the rendering scene). Regardless of the specific rules used, each data segment should contain the set of geometric information necessary to generate the corresponding rendering data.
[0092] In this embodiment, each data segment is assigned a number, starting from 0, with each data segment numbered sequentially. Each data segment's number is a non-negative number. Exemplarily, adjacent data segments are also numbered consecutively. For example, in a 4-core GPU system (including GPU core 0, GPU core 1, GPU core 2, and GPU core 3), data segment 0 (where 0 is the segment's number) is distributed to the geometry processing pipeline within GPU core 0, data segment 1 is distributed to the geometry processing pipeline within GPU core 1, data segment 2 is distributed to the geometry processing pipeline within GPU core 2, data segment 3 is distributed to the geometry processing pipeline within GPU core 3, and data segment 4 is again distributed to the geometry processing pipeline on GPU core 0, and so on.
[0093] For example, when the GPU core determines the first bounding box, it can generate the corresponding first data and send it to the rendering pipeline manager. In some embodiments, after processing any data segment, the GPU core sends the first data corresponding to that data segment to the rendering pipeline manager. In some embodiments, the GPU core sends the first data to the rendering pipeline manager immediately after generating the first data, or sends it only when the first data reaches a preset quantity. The rendering pipeline manager receives and stores the first data sent from different GPU cores. It is worth noting that the above sending methods are merely illustrative examples, and this embodiment does not limit them.
[0094] By using the segment numbers in the first data stream, the rendering pipeline manager can determine the positional relationship of different data segments within the input data stream. Specifically, the rendering pipeline manager can determine which data segments are consecutive by judging whether they are consecutive (e.g., whether the number of the previous data segment follows the number of the next data segment). The rendering pipeline manager can merge only the first bounding boxes corresponding to consecutively numbered data segments according to the order of their numbers, thereby determining the second bounding box and effectively avoiding merging the first bounding boxes corresponding to non-consecutive data segments. Secondly, the data segment number also identifies the GPU core processing that data segment. Since data segments are allocated to each GPU core according to preset rules (such as the polling strategy mentioned above), the data segment number can be directly mapped to the GPU core processing that data segment. While determining the second bounding box, the rendering pipeline manager can also determine the GPU core corresponding to that second bounding box, improving the accuracy of the rendering pipeline manager in determining the second bounding box.
[0095] In some embodiments, the rendering pipeline manager includes a first data storage module for each GPU core. Exemplarily, the first data includes: coordinate data of a first bounding box and the number of the data segment corresponding to the first bounding box. The storage module maintains a dynamic set of first data; each time a piece of first data is received, the storage module allocates a certain storage area for its storage. In some embodiments, the storage module in the rendering pipeline manager can be implemented using various different hardware storage resources, specifically including: 1. Dedicated On-Chip Cache: A high-speed cache memory located inside or tightly coupled to the rendering pipeline manager. It is typically composed of Static Random-Access Memory (SRAM) cells. The first data received by the rendering pipeline manager is stored in the dedicated on-chip cache, and the rendering pipeline manager can directly access the records in the dedicated on-chip cache with extremely low latency.
[0096] 2. Register File: A high-speed memory array within the rendering pipeline manager, consisting of numerous flip-flops. The first data received by the rendering pipeline manager is split and stored in multiple adjacent registers in the register file. The rendering pipeline manager accesses the first data directly in a very short clock cycle by specifying the register address.
[0097] 3. First-In-First-Out Memory (FIFO): A data structure used internally by the rendering pipeline manager to implement a sequential queue. The rendering pipeline manager writes the first data to the tail of the FIFO memory in the order it is received, and reads records from the head of the memory in the same order for processing, ensuring the timing consistency of the first data before merging.
[0098] It is worth noting that the above storage module is only an illustrative example, and this embodiment does not limit it.
[0099] In some embodiments, the rendering pipeline manager is used to determine a second bounding box based on first data sent by at least two GPU cores respectively. Each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two first bounding boxes.
[0100] like Figure 3 As shown, Figure 3This is a schematic diagram illustrating the determination of the second bounding box in one possible implementation of this application. In this embodiment, the rendering pipeline manager determines the second bounding box 310 based on the coordinate data of the first bounding box 210 in the first data sent by GPU core 0, the coordinate data of the first bounding box 220 in the first data sent by GPU core 1, and the coordinate data of the first bounding box 230 in the first data sent by GPU core 2.
[0101] For example, before determining the second bounding box, the rendering pipeline manager first reads first data sent by at least two GPU cores from the storage module. For example, the first data includes the coordinate data of the first bounding box and the corresponding data segment number. The rendering pipeline manager calculates the coverage area of each first bounding box by traversing the coordinate data of the first bounding boxes in at least two sets of first data.
[0102] In some embodiments, the coordinate data of the first bounding box in the first data are pixel coordinates in the screen pixel coordinate system. For example, when the shape of the first bounding box is rectangular, its coordinate data includes four specific values: the left boundary pixel coordinates, right boundary pixel coordinates, top boundary pixel coordinates, and bottom boundary pixel coordinates of the first bounding box. After reading a certain first data, the rendering pipeline manager directly reads these four coordinate values to uniquely determine a rectangular region, which is the coverage area of the corresponding first bounding box. For example, suppose the rendering pipeline manager reads a first data with coordinate data of the numerical sequence: 32, 176, 48, 224. Then the rendering pipeline manager can determine that the left boundary of the first bounding box corresponding to the first data is located at 32 pixels on the screen X-axis, the right boundary is located at 176 pixels, the top boundary is located at 48 pixels, and the bottom boundary is located at 224 pixels. Therefore, the rectangle defined by the diagonal lines defined by points (32, 48) and (176, 224) is the coverage area of the first bounding box. It is worth noting that the method described above for determining the coverage area of the first bounding box using pixel coordinates is merely an illustrative example, and this embodiment does not limit it.
[0103] In some embodiments, after calculating the coverage areas of at least two first bounding boxes, the rendering pipeline manager merges the coverage areas of the first bounding boxes to obtain a second bounding box. Exemplarily, this merging process includes comparing the coordinates of the top, bottom, left, and right boundaries of each first bounding box, taking the minimum value between the coordinates of the left boundary and the bottom boundary of all first bounding boxes, and the maximum value between the coordinates of the right boundary and the top boundary, to determine the minimum area covering all elements, i.e., determining the second bounding box.
[0104] For example, such as Figure 2As shown, the rendering pipeline manager determines the second bounding box 310 based on the coordinate data of the first bounding box 210 in the first data sent by GPU core 0, the coordinate data of the first bounding box 220 in the first data sent by GPU core 1, and the coordinate data of the first bounding box 230 in the first data sent by GPU core 2. Specifically, the process of determining the second bounding box is as follows: The rendering pipeline manager reads the coordinate data of the first bounding box 210 as follows: left boundary 10, right boundary 50, top boundary 50, bottom boundary 10; The rendering pipeline manager reads the coordinate data of the first bounding box 220 as follows: left boundary 0, right boundary 50, top boundary 40, bottom boundary 10; The rendering pipeline manager reads the coordinate data of the first bounding box 230 as follows: left boundary 10, right boundary 40, top boundary 30, bottom boundary 0.
[0105] The rendering pipeline manager calculates the boundary of the second bounding box 310 by comparing the above coordinate values: The left boundary of the second bounding box 310 is the minimum of the three left boundaries: min(10, 0, 10) = 0; The right boundary of the second bounding box 310 is the maximum value among the three right boundaries: max(50, 50, 40) = 50; The upper boundary of the second bounding box 310 is the maximum value among the three upper boundaries: max(50, 40, 30) = 50; The lower boundary of the second bounding box 310 is the minimum of the three lower boundaries: min(10, 10, 0) = 0.
[0106] Therefore, the rectangle defined by the diagonal lines of points (0, 50) and (50, 0) is the smallest rectangular area covering the first bounding boxes 210, 220, and 230, which is the coverage area of the second bounding box 310. It is worth noting that the method for determining the second bounding box described above is merely an illustrative example, and this embodiment does not limit it.
[0107] In some embodiments, the second bounding box is the smallest rectangular region that covers at least two first bounding boxes. By setting the shape of the second bounding box to rectangle, the second bounding box is determined based on the first data of the corresponding at least two first bounding boxes. The rendering pipeline manager only needs to perform simple comparison operations (such as taking the minimum and maximum values) to complete the boundary merging between different first bounding boxes. This eliminates the need for complex geometric calculations, resulting in low computational complexity. Furthermore, it makes it easy to align the second bounding box with the pixel grid or tile grid in screen space, facilitating subsequent processing and improving the efficiency of the rendering pipeline manager in determining the second bounding box.
[0108] In some embodiments, the boundary of the second bounding box is aligned with the boundaries of at least two first bounding boxes covered by the second bounding box. For example, when the GPU core determines the first bounding box, the boundary of the first bounding box is already aligned with the tile boundary. Therefore, the boundary of the second bounding box determined based on the first data sent by at least two GPU cores is also aligned with the boundaries of at least two first bounding boxes covered by the second bounding box.
[0109] By aligning the boundaries of the second bounding box to the boundaries of at least two first bounding boxes it covers, when the rendering pipeline manager needs to determine a new second bounding box based on at least two different first data sets, or needs to merge a first bounding box corresponding to at least one different first data set into an already determined second bounding box, the merging process does not require complex boundary calculations because the boundaries of all first / second bounding boxes are aligned to the tile boundaries. The rendering pipeline manager can directly read the coordinate data of the first bounding boxes in the first data set and generate a new second bounding box aligned with the tile boundaries by selecting the minimum / maximum coordinates of each boundary, thus reducing the computational complexity and processing latency of the rendering pipeline manager.
[0110] In some embodiments, the rendering pipeline manager is further configured to send second data to the pixel processing pipeline, the second data being used to indicate a second bounding box. Optionally, the second data includes: coordinate data of the second bounding box, and the numbers of data segments corresponding to at least two first bounding boxes covered by the second bounding box.
[0111] Exemplarily, the coordinate data of the second bounding box is used to determine the position and extent of the second bounding box in screen space. In some embodiments, the coordinate data of the second bounding box is based on the pixel coordinates of the four boundaries of the second bounding box, that is, the position and extent of the second bounding box are determined by the pixel coordinates of each boundary of the second bounding box in the screen pixel coordinate system. Exemplarily, the rendering pipeline manager reads the first data sent by at least two GPU cores in the storage module, calculates the pixel coordinates of each boundary of the second bounding box in the screen pixel coordinate system, and thus determines the coordinate data of the second bounding box. Exemplarily, the shape of the second bounding box is rectangular. The coordinate data of the second bounding box in the second data includes four values, namely the coordinates of the left boundary, right boundary, top boundary, and bottom boundary of the second bounding box. After the rendering pipeline manager calculates these four coordinate data, it can directly determine the coordinate data of the second bounding box in the second data. It is worth noting that the above coordinate data determination method is only an illustrative example, and this embodiment does not limit it.
[0112] In some embodiments, the second data includes the numbers of data segments corresponding to at least two first bounding boxes covered by the second bounding box. The rendering pipeline manager can determine the numbers of the data segments corresponding to the at least two GPU cores when it reads the first data sent by at least two GPU cores from the storage module.
[0113] In some embodiments, the storage module is further configured to store second data sent by the rendering pipeline manager. For example, when the rendering pipeline manager reads the coordinate data of the first bounding box from the first data sent by at least two GPU cores from the storage module, it also reads the corresponding data segment number. After the rendering pipeline manager determines the second bounding box and calculates its coordinate data, it sends the coordinate data of the second bounding box and the data segment number corresponding to the first bounding box covered by the second bounding box, i.e., the second data, to the storage module. For example, each time a piece of second data is received, the storage module allocates a certain storage area for its storage. It is worth noting that the above storage module is merely an illustrative example, and this embodiment does not limit its scope.
[0114] By using the coordinates of the second bounding box and the data segment numbers corresponding to at least two first bounding boxes covered by the second bounding box as the second data, the pixel processing pipeline can directly obtain complete rendering task information after receiving the second data: Based on the coordinates of the second bounding box, the pixel processing pipeline can determine the range of tiles to be processed, avoiding invalid traversal of the entire screen tiles. Through the data segment numbers, the pixel processing pipeline can determine the set of GPU cores to be accessed, directly querying the head pointer array within the GPU cores in the aforementioned GPU core set to obtain the rendering data, without needing to traverse all GPU cores. This method reduces the latency and query overhead caused by data access in the pixel processing pipeline, improving its processing efficiency.
[0115] In some embodiments, the data segments corresponding to at least two first bounding boxes covered by the second bounding box are continuous, and the data segments corresponding to the first bounding boxes are used to generate the rendering data corresponding to the first bounding box.
[0116] For example, the input data stream is divided into multiple data segments, such as data segment 0, data segment 1, data segment 2, etc. These data segments are sent to the geometry processing pipelines in different GPU cores for geometry processing, with each GPU core responsible for processing one or more data segments. Because the complexity of different data segments varies, the speed at which different GPU cores generate the first data differs. Therefore, the order in which different GPU cores send the first data to the rendering pipeline manager is asynchronous and may not necessarily conform to the logical order of the data segments themselves. For example, the rendering pipeline manager might receive the first data corresponding to data segment 2 first, and then receive the first data corresponding to data segment 0.
[0117] In some embodiments, the storage module inside the rendering pipeline manager is responsible for receiving and storing the first data sent by different GPU cores. Exemplarily, the storage module inside the rendering pipeline manager maintains a data structure for recording the arrival status and content of the first data corresponding to each data segment. In some embodiments, the data structure is organized by data segment numbering. When the rendering pipeline manager detects that at least two consecutively numbered data segments corresponding to the first data have arrived, it determines these first data segments as a consecutive ready sequence. Exemplarily, the rendering pipeline manager reads at least two first data segments from the consecutive ready sequence, determines a second bounding box based on the coordinate data of the first bounding box in the first data, and combines the numbers of these consecutive data segments with the coordinate data of the second bounding box to form the second data.
[0118] The rendering pipeline manager determines the second bounding box based on the first data corresponding to consecutive data segments. This ensures that the second data received by the pixel processing pipeline strictly follows the logical order of the input data stream, guaranteeing the correctness of the subsequent rendering order. The data segment numbers contained in the second data allow the pixel processing pipeline to access data only according to the GPU core indicated by the data segment number, without having to traverse all GPU cores. This significantly reduces the overhead of data lookup and improves the processing efficiency of the pixel processing pipeline.
[0119] In some embodiments, the rendering pipeline manager is also configured to delete the first data sent by at least two GPU cores respectively after determining the second bounding box.
[0120] After determining the second bounding box, the rendering pipeline manager deletes the corresponding first data, ensuring that each data segment participates in the merge calculation only once, thus avoiding the problem of data segment order disorder that may be caused by data residue.
[0121] The rendering pipeline manager can maintain precise control over the logical order of data segments in complex environments with asynchronous processing across multiple GPU cores, thereby improving the accuracy of subsequent processing by the pixel processing pipeline.
[0122] In some embodiments, the GPU core is further configured to process the tiles covered by the second bounding box based on the second data via a pixel processing pipeline to generate a rendering result. The pixel processing pipeline does not process tiles not covered by the second bounding box.
[0123] For example, after receiving the second data, the pixel processing pipeline inside the GPU core performs pixel processing on the tiles covered by the second bounding box based on the second data to generate a rendering result. In this embodiment, any processing performed by the pixel processing pipeline based on the second data can be called pixel processing. In some embodiments, pixel processing includes, but is not limited to, at least one of rasterization, pixel shading, depth testing, stencil testing, and color blending. Rasterization refers to the process of converting elements within the second bounding box into covered pixel fragments. Specifically, rasterization determines which pixels are located inside the elements based on the vertex data of the primitives and generates a fragment for each such pixel; pixel shading refers to calculating the final color value of each fragment generated by rasterization. Specifically, the pixel shader can perform operations such as texture sampling, lighting calculation, and color interpolation to output the color, transparency, and other attributes of the fragment; depth testing refers to comparing the depth value of the current fragment with the existing depth values stored in the depth buffer to determine whether the current fragment is occluded. Depth testing discards occluded segments, ensuring the accuracy of the final rendering result. Stencil testing uses values stored in the stencil buffer to conditionally evaluate the current segment, enabling special effects such as outline drawing and shadow volume. Color blending combines the color of the current segment with colors stored in the frame buffer. Specifically, color blending uses a preset blending formula (such as transparency-based blending) to combine the color of the new segment with the background color to generate the final display color. It is worth noting that the pixel processing described above is merely illustrative and is not intended to limit the scope of this embodiment.
[0124] In some embodiments, the pixel processing pipeline receives second data from the rendering pipeline manager, the second data including coordinate data of a second bounding box and the numbers of data segments corresponding to at least two first bounding boxes covered by the second bounding box.
[0125] For example, the pixel processing pipeline first reads the coordinate data of the second bounding box from the second data, determines the screen space region to be processed based on the coordinate data, and generates a corresponding list of tiles to be processed. Tiles not covered by the second bounding box will not be processed by the pixel processing pipeline. For example, after determining the list of tiles to be processed, the pixel processing pipeline iterates through each tile in the list sequentially.
[0126] For example, for the tile currently to be processed, the pixel processing pipeline initiates a data query request only to the corresponding GPU core based on the data segment number in the second data. Specifically, the pixel processing pipeline determines at least two GPU cores that need to be accessed through the data segment number, and then queries the head pointer array in the aforementioned at least two GPU cores to obtain the head pointer of the current tile in the tile linked list of each of the aforementioned GPU cores.
[0127] For example, after obtaining the head pointer of the tile list, the pixel processing pipeline traverses the corresponding tile list and loads the relevant rendering data into the tile buffer. Subsequently, the pixel processing pipeline performs pixel processing operations such as rasterization and shading in the tile buffer. After all pixel processing for the current tile is completed, the rendering result is written to the final frame buffer.
[0128] The pixel processing pipeline repeats the above process for each tile covered by the second bounding box until all specified tiles have been processed.
[0129] It is worth noting that the processing procedure of the pixel processing pipeline described above is only an illustrative example, and this embodiment does not limit it.
[0130] By limiting the pixel processing range to the tile area covered by the second bounding box, it ensures that the pixel processing pipeline only performs rendering calculations on the screen area containing the element, effectively avoiding a large amount of invalid calculations caused by traversing the entire screen tiles, and reducing power consumption caused by invalid calculations. It is particularly suitable for application scenarios with high energy efficiency requirements, such as mobile devices.
[0131] The rendering system proposed in this application introduces a rendering pipeline manager to uniformly manage the data segments processed by the geometry processing pipeline. Specifically, the GPU core determines a first bounding box based on the rendering data generated by the geometry processing pipeline, where the first bounding box is the smallest region covering all elements in the rendering data. The GPU core sends first data indicating the first bounding box to the rendering pipeline manager. The rendering pipeline manager determines a second bounding box based on the first data from at least two GPU cores, where the second bounding box is the smallest region covering at least two first bounding boxes. The rendering pipeline manager sends second data indicating the second bounding box to the pixel management pipeline, and the pixel processing pipeline generates the rendering result based on the second data. Elements in the rendering data are covered by tiles; tiles not covered by elements are empty tiles. Therefore, the pixel processing pipeline only needs to process the tiles covered by the second bounding box based on the second data, and does not process the tiles not covered by the second bounding box; that is, the tiles processed by the pixel processing pipeline are mostly tiles covered by elements. Through unified management by the rendering pipeline manager, the proportion of empty tiles processed by the pixel processing pipeline is reduced, thereby decreasing the processing time for empty tiles. Furthermore, since most tiles are covered by elements, the load on different pixel processing pipelines is similar, reducing load imbalance. Therefore, the processing efficiency of the pixel processing pipeline is improved in this embodiment.
[0132] The technical solutions provided in the embodiments of this application will be described in detail below using method embodiments. For content not described in the method embodiments, please refer to the above embodiments, which will not be repeated here.
[0133] Please refer to Figure 4 This illustrates a flowchart of a rendering method applied to a rendering system, as provided in one possible implementation of this application. The method may include at least one of the following steps.
[0134] In some embodiments, the rendering system includes a rendering pipeline manager and at least two graphics processing unit (GPU) cores, wherein the GPU cores include a geometry processing pipeline and / or a pixel processing pipeline.
[0135] Step 410: The GPU core determines the first bounding box based on the rendering data generated by the geometry processing pipeline within the GPU core. The first bounding box is the smallest region covering all elements in the rendering data.
[0136] In some embodiments, for the input data stream, each GPU core segments it into different data segments, and each data segment is input into its respective core's geometry processing pipeline. The data segments input to the GPU core pass through the geometry processing pipeline within the GPU core to generate rendering data. Through the geometry processing pipeline, the GPU core converts the data segments into rendering data in screen space coordinates. Each element in the rendering data is mapped to screen space to ensure that the spatial position of the elements in the rendering data corresponds to a preset area. Specifically, the rendering data includes: 1. Vertex coordinates: This is data that determines the geometric shape and position of elements (i.e., primitives) on the screen. For example, it includes the vertex coordinates (X, Y) of each vertex of the primitive. The vertex coordinates of the primitive define the shape and position of the primitive on the screen; 2. Vertex attributes: Data that provides necessary parameters for subsequent pixel processing stages. For example, it includes texture coordinates (for sampling from texture maps), vertex colors, normal vectors (for lighting calculations), and other custom attributes used to achieve complex visual effects.
[0137] The GPU core calculates the coverage area of each element using the vertex coordinates in the rendering data, and then merges the coverage areas of all elements to obtain the minimum coverage area. Specifically, this merging process involves comparing the coordinates of the upper, lower, left, and right boundaries of the coverage area of each element (the aforementioned minimum bounding rectangle), and taking the maximum and minimum values in the X and Y axes of the screen coordinate system, respectively, to determine the minimum area that covers all elements, i.e., determining the minimum coverage area.
[0138] After determining the minimum coverage area, the GPU core maps the boundary of the minimum coverage area from pixel coordinates to tile indices. After rounding the tile indices, it obtains the first bounding box aligned with the tile boundaries. At the end of the geometry processing pipeline for each data segment, the GPU core counts the tiles covered by all elements within that segment and uses a minimum first bounding box aligned with the tile boundaries to describe the region.
[0139] Step 420: The GPU core sends first data to the rendering pipeline manager, which is used to indicate the first bounding box.
[0140] Each GPU core, after processing a data segment and calculating its first bounding box, sends it to the rendering pipeline manager. When a GPU core determines the first bounding box, it generates the corresponding first data and sends it to the rendering pipeline manager. In some embodiments, a GPU core sends the first data corresponding to any data segment to the rendering pipeline manager after processing it. In other embodiments, a GPU core sends the first data to the rendering pipeline manager immediately after generating it, or it sends it only when the first data reaches a preset quantity. The rendering pipeline manager receives and stores the first data sent from different GPU cores.
[0141] Step 430: The rendering pipeline manager determines the second bounding box based on the first data sent by at least two GPU cores respectively. Each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two first bounding boxes.
[0142] The rendering pipeline manager merges the first bounding box data sent from each GPU core. Merging means finding a minimum bounding box that can encompass these first bounding boxes sent from different GPU cores.
[0143] The coordinates of the first bounding box in the first data are pixel coordinates in the screen pixel coordinate system. For example, when the shape of the first bounding box is rectangular, its coordinate data includes four specific values: the left, right, top, and bottom boundary pixel coordinates of the first bounding box. After reading a certain set of first data, the rendering pipeline manager directly reads these four coordinate values to uniquely determine a rectangular region, which is the coverage area of the corresponding first bounding box.
[0144] After calculating the coverage areas of at least two first bounding boxes, the rendering pipeline manager merges the coverage areas of the first bounding boxes to obtain a second bounding box. For example, this merging process includes comparing the coordinates of the top, bottom, left, and right boundaries of each first bounding box, taking the minimum value between the coordinates of the left and bottom boundaries of all first bounding boxes, and the maximum value between the coordinates of the right and top boundaries, to determine the minimum area covering all elements, i.e., determining the second bounding box.
[0145] The rendering pipeline manager continuously collects data segment completion information and corresponding first bounding box information reported by different GPU cores, i.e., the first data mentioned above, and merges them together.
[0146] Step 440: The rendering pipeline manager sends second data to the pixel processing pipeline, the second data being used to indicate the second bounding box.
[0147] When the rendering pipeline manager is ready to start a pixel processing pipeline task, it sends the range of the data segment and the second bounding box (i.e., the second data) of all the data segments to be rendered downstream, i.e., the pixel processing pipeline.
[0148] In step 450, the GPU core generates a rendering result based on the second data through the pixel processing pipeline.
[0149] The pixel processing pipeline will render all tiles within the second bounding box one by one; tiles outside the second bounding box will not be rendered.
[0150] The pixel processing pipeline receives second data from the rendering pipeline manager. This second data includes the coordinates of a second bounding box and the data segment numbers corresponding to at least two first bounding boxes covered by the second bounding box. The pixel processing pipeline first reads the coordinates of the second bounding box from the second data, determines the screen space region to be processed based on these coordinates, and generates a corresponding list of tiles to be processed. Tiles not covered by the second bounding box are not processed by the pixel processing pipeline. For example, after determining the list of tiles to be processed, the pixel processing pipeline iterates through each tile in the list sequentially.
[0151] For example, for the tile currently being processed, the pixel processing pipeline initiates a data query request only to the corresponding GPU core based on the data segment number in the second data. Specifically, the pixel processing pipeline determines at least two GPU cores that need to be accessed based on the data segment number, and then queries the head pointer arrays of the aforementioned at least two GPU cores to obtain the head pointer of the tile linked list of the current tile in each of the aforementioned GPU cores. After obtaining the head pointer of the tile linked list, the pixel processing pipeline traverses the corresponding tile linked list and loads the relevant rendering data into the tile buffer. Subsequently, the pixel processing pipeline performs pixel processing operations such as rasterization and shading in the tile buffer. After all pixel processing of the current tile is completed, the rendering result is written to the final frame buffer.
[0152] The pixel processing pipeline repeats the above process for each tile covered by the second bounding box until all specified tiles have been processed.
[0153] In summary, the rendering system proposed in this application introduces a rendering pipeline manager to uniformly manage the data segments processed by the geometry processing pipeline. Specifically, the GPU core determines a first bounding box based on the rendering data generated by the geometry processing pipeline, where the first bounding box is the smallest region covering all elements in the rendering data. The GPU core sends first data indicating the first bounding box to the rendering pipeline manager. The rendering pipeline manager determines a second bounding box based on the first data from at least two GPU cores, where the second bounding box is the smallest region covering at least two first bounding boxes. The rendering pipeline manager sends second data indicating the second bounding box to the pixel management pipeline, and the pixel processing pipeline generates the rendering result based on the second data. Elements in the rendering data are covered by tiles; tiles not covered by elements are empty tiles. Therefore, the pixel processing pipeline only needs to process the tiles covered by the second bounding box based on the second data, and does not process the tiles not covered by the second bounding box; that is, most of the tiles processed by the pixel processing pipeline are tiles covered by elements. Through unified management by the rendering pipeline manager, the proportion of empty tiles processed by the pixel processing pipeline is reduced, thereby decreasing the processing time for empty tiles. Furthermore, since most tiles are covered by elements, the load on different pixel processing pipelines is similar, reducing load imbalance. Therefore, the processing efficiency of the pixel processing pipeline is improved in this embodiment.
[0154] In some embodiments, a GPU chip is also provided, which includes the rendering system described above.
[0155] Please refer to Figure 5 This is a simplified structural block diagram of an electronic device provided in one possible implementation of this application. For example... Figure 5As shown, the electronic device 500 includes the aforementioned GPU chip, and the GPU chip includes the aforementioned rendering system. The electronic device 500 can be used to implement the rendering method applied to the rendering system provided in the above embodiments.
[0156] Typically, electronic device 500 includes a processor 510 and a memory 520.
[0157] Processor 510 may include one or more processing cores, such as a quad-core processor, an octa-core processor, etc. Processor 510 may be implemented using at least one hardware form selected from DSP (Digital Signal Processing), FPGA (Field Programmable Gate Array), and PLA (Programmable Logic Array). Processor 510 may also include a main processor and a coprocessor. The main processor, also known as a CPU (Central Processing Unit), is used to process data in the wake-up state; the coprocessor is a low-power processor used to process data in the standby state. In some embodiments, processor 510 may integrate a GPU, which is responsible for rendering and drawing the content to be displayed on the screen. In some embodiments, processor 510 may also include an AI (Artificial Intelligence) processor, which is used to handle computational operations related to machine learning.
[0158] The memory 520 may include one or more computer-readable storage media, which may be non-transitory. The memory 520 may also include high-speed random access memory and non-volatile memory, such as one or more disk storage devices or flash memory devices. In some embodiments, the non-transitory computer-readable storage media in the memory 520 are used to store a computer program configured to be executed by one or more processors to implement the rendering method described above applied to the rendering system.
[0159] Those skilled in the art will understand that Figure 5 The structure shown does not constitute a limitation on the electronic device 500, and may include more or fewer components than shown, or combine certain components, or use different component arrangements.
[0160] In some embodiments, the electronic device 500 may be a server, a server cluster, an artificial intelligence computing cluster, a cloud computing cluster, etc., wherein the artificial intelligence computing cluster may also be simply referred to as an intelligent computing cluster or a smart computing cluster, and this application does not limit it in this regard.
[0161] It should be understood that "multiple" as mentioned herein refers to two or more. Furthermore, the step numbers described herein are merely illustrative of one possible order of execution. In some other embodiments, the steps may not be executed in numerical order, such as two steps with different numbers being executed simultaneously, or two steps with different numbers being executed in the reverse order of the illustration. This application does not limit this practice.
[0162] The above description is merely an exemplary embodiment of this application and is not intended to limit this application. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the protection scope of this application.
Claims
1. A rendering system, characterized in that, The rendering system includes: a rendering pipeline manager and at least two graphics processing unit (GPU) cores, wherein the GPU cores include a geometry processing pipeline and / or a pixel processing pipeline; The GPU core is used to determine a first bounding box based on rendering data generated by the geometry processing pipeline inside the GPU core; wherein the first bounding box is the smallest region that covers all elements in the rendering data; The GPU core is also used to send first data to the rendering pipeline manager, the first data being used to instruct the first bounding box; The rendering pipeline manager is used to take the union of the first bounding boxes indicated by the first data sent by the at least two GPU cores respectively, and determine the second bounding box; wherein each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two first bounding boxes; The rendering pipeline manager is also configured to send second data to the pixel processing pipeline, the second data being used to indicate the second bounding box; The GPU core is also used to generate rendering results based on the second data through the pixel processing pipeline.
2. The rendering system according to claim 1, characterized in that, The first bounding box is the smallest rectangular area that covers all elements in the rendered data.
3. The rendering system according to claim 1, characterized in that, The second bounding box is the smallest rectangular region that covers at least two of the first bounding boxes.
4. The rendering system according to claim 1, characterized in that, The first data includes: the coordinate data of the first bounding box, and the number of the data segment corresponding to the first bounding box; And / or, The second data includes: the coordinate data of the second bounding box, and the numbers of the data segments corresponding to at least two first bounding boxes covered by the second bounding box; The data segment corresponding to the first bounding box is used to generate the rendering data corresponding to the first bounding box.
5. The rendering system according to claim 1, characterized in that, The elements in the rendering data cover the tiles, and the boundary of the first bounding box is aligned with the boundary of the tiles covered by all the elements in the rendering data. And / or, The boundary of the second bounding box is aligned with the boundaries of at least two of the first bounding boxes covered by the second bounding box.
6. The rendering system according to claim 1, characterized in that, The data segments corresponding to at least two of the first bounding boxes covered by the second bounding box are continuous, and the data segments corresponding to the first bounding boxes are used to generate the rendering data corresponding to the first bounding box.
7. The rendering system according to claim 1, characterized in that, The GPU core is also used to process the tiles covered by the second bounding box based on the second data through the pixel processing pipeline to generate the rendering result.
8. The rendering system according to claim 1, characterized in that, The rendering pipeline manager is also configured to delete the first data sent by at least two of the GPU cores after determining the second bounding box.
9. A GPU chip, characterized in that, The GPU chip includes the rendering system as described in any one of claims 1 to 8.
10. An electronic device, characterized in that, The electronic device includes a GPU chip, which includes a rendering system as described in any one of claims 1 to 8.
11. A rendering method applied to a rendering system, characterized in that, The rendering system includes: a rendering pipeline manager and at least two graphics processing unit (GPU) cores, wherein the GPU cores include a geometry processing pipeline and / or a pixel processing pipeline; The method includes: The GPU core determines a first bounding box based on the rendering data generated by the geometry processing pipeline inside the GPU core; wherein, the first bounding box is the smallest region that covers all elements in the rendering data; The GPU core sends first data to the rendering pipeline manager, the first data being used to instruct the first bounding box; The rendering pipeline manager takes the union of the first bounding boxes indicated by the first data sent by the at least two GPU cores respectively, and determines the second bounding box; wherein each piece of first data corresponds to a first bounding box, and the second bounding box is the smallest region covering at least two first bounding boxes; The rendering pipeline manager sends second data to the pixel processing pipeline, the second data being used to indicate the second bounding box; The GPU core generates rendering results based on the second data through the pixel processing pipeline.
Citation Information
Patent Citations
Graph hybrid rendering method and device based on OpenGL and storage medium
CN116912395A
Rendering optimization method, electronic equipment and computer readable storage medium
CN119698638A
