Multi-shape batch rendering method suitable for GPU without hardware batch processing capability
By converting graphics and text into path instruction sequences and coordinate parameters in smart wearable devices and merging them into a single command according to the rendering level, the problem of low rendering efficiency in low-power devices is solved, and efficient and smooth graphics and text fusion rendering is achieved.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- ASR MICROELECTRONICS CO LTD
- Filing Date
- 2026-02-06
- Publication Date
- 2026-05-05
AI Technical Summary
Existing technologies cannot efficiently integrate the rendering of graphics and text in low-power, small-sized smart wearable devices, resulting in low rendering frame rates and severe resource consumption, which cannot meet the needs of dynamic dashboards and real-time data reports.
By employing a method of defining, parsing, separating, storing, sorting, and merging path instruction templates, graphic and text elements are converted into path instruction sequences and coordinate parameters, which are then merged into a single drawing command according to the rendering level and submitted to the GPU for rendering.
Significantly improves rendering frame rate, reduces GPU calls, lowers resource consumption, ensures visual hierarchy correctness, adapts to lightweight GPUs that only support basic path drawing, and enables efficient rendering of complex interfaces.
Smart Images
Figure CN121982153A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of computer graphics rendering technology, and more specifically, to a multi-shape batch rendering method suitable for GPUs without hardware batch processing capabilities. Background Technology
[0002] Currently, highly customized lightweight 2D graphics processing units (GPUs), such as VeriSilicon's VGLite, are commonly used in low-power, small-size smart wearable devices. These GPUs are designed to provide basic graphics acceleration within an extremely tight power and area budget. Their architecture typically has the following core characteristics: they only support path-based 2D primitive drawing commands; they do not include a hardware rasterizer for triangle mesh processing, nor do they support standard features in modern graphics APIs such as vertex buffer objects (VBOs); more importantly, their hardware instruction sets and driver interfaces do not provide any form of hardware-level draw call batching mechanism. Furthermore, their on-chip video memory and overall CPU clock speed are extremely limited.
[0003] Under the aforementioned hardware constraints, traditional UI rendering workflows face significant efficiency bottlenecks. Specifically, applications need to define each basic graphic element in the interface (such as a line segment, a circle, or a triangle) as a separate drawing path and initiate an independent GPU drawing call for each path. For text rendering, the situation is even more complex: the system font engine typically needs to rasterize each character into a bitmap or convert it into a path, and then initiate an independent drawing operation for each character or its corresponding bitmap block. Therefore, in a complex interface containing simple charts and multiple lines of text, the number of drawing calls per frame can easily reach dozens or even hundreds.
[0004] On general-purpose computing platforms (such as desktops or high-performance mobile platforms), underlying graphics libraries (such as Skia in Android) can leverage the powerful hardware capabilities of GPUs or use software to effectively batch process large numbers of path or text drawing requests, thereby significantly reducing communication overhead between the CPU and GPU. However, for the aforementioned lightweight wearable device GPUs that only support basic path drawing, such advanced batch processing capabilities are completely lacking at the hardware and underlying driver levels. This directly leads to the following problems: the CPU needs to frequently perform preparatory work such as path construction, state switching (such as fonts and colors), and command submission, resulting in a heavy computational load; the GPU spends a lot of time receiving and parsing frequent and fragmented command streams, rather than focusing on the actual pixel drawing work; the end result is low rendering frame rate, sluggish interface response, and severe consumption of already strained system power and bandwidth resources, making it difficult to meet the needs of application scenarios with high smoothness requirements, such as dynamic health monitoring dashboards and real-time data reports.
[0005] Existing high-performance graphics rendering technologies (such as OpenGL ES-based rendering pipelines or game engines like Unity) heavily rely on triangle primitive rendering or standard texture text rendering pipelines. Their underlying implementations are completely incompatible with the GPU hardware architecture of wearable devices, which only supports path drawing, making direct porting impossible. More importantly, existing solutions have not yet disclosed how to unify heterogeneous primitives such as line segments, circles, and triangles with vector text characters at the path representation level, and further integrate and encode them into a single instruction stream at the visual level, thereby achieving an effective method for single-submission rendering on such resource-constrained and feature-limited GPU platforms.
[0006] Therefore, there is an urgent need in this field for a general technical solution that can adapt to GPUs without hardware batch processing capabilities and achieve efficient fusion rendering of graphics and text. Summary of the Invention
[0007] To address the shortcomings of existing technologies, this invention provides a multi-shape batch rendering method suitable for GPUs without hardware batch processing capabilities.
[0008] According to the present invention, a multi-shape batch rendering method suitable for GPUs without hardware batch processing capabilities is provided, the scheme of which is as follows: Firstly, a method for batch rendering of multiple shapes suitable for GPUs without hardware batch processing capabilities is provided, the method comprising: Path instruction template definition step S1: Predefine path drawing instruction templates for various graphic elements and text characters; Parsing step S2: Traverse all elements to be rendered in the current frame, including graphic elements and text elements; convert each graphic element into a path instruction sequence and coordinate parameters according to its corresponding path drawing instruction template; for each character in the text element, call the font outline parser to convert it into a path instruction sequence and coordinate parameters composed of path instructions; Separate storage step S3: Store all the converted path instructions in the global instruction array in order, and store all the corresponding coordinate parameters in the global parameter array in the same order; Sorting and merging step S4: Assign a rendering level to each element to be rendered, and merge the path instructions and coordinate parameters corresponding to all elements to be rendered into the final global instruction stream and parameter stream in order of the rendering level from low to high. Single rendering step S5: Package the final global instruction stream and parameter stream into a single drawing command and submit it to the GPU for rendering at once.
[0009] Preferably, in step S1, the graphic primitives include line segments, quadrilaterals, triangles, circles, and semicircles; wherein, The path drawing instruction template for the line segment is constructed as a degenerate quadrilateral containing 5 instructions; The path drawing instruction templates for the quadrilateral and the semicircle each contain 5 instructions; The path drawing instruction templates for the triangle and the circle each contain four instructions. Preferably, in steps S1 and S2, the path drawing instruction template and the path instructions generated by the font outline parser are both composed of multiple preset atomic instruction types; the atomic instruction types include at least: The Move To command is used to define the starting point of a path or the starting point of a new subpath; The line segment to command is used to draw a straight line from the current point to a specified point; The Arc to command is used to draw an arc from the current point to a specified point; The path end instruction is used to mark the end of a complete path or group of paths.
[0010] Preferably, in step S3, the global instruction array stores integer enumeration values corresponding to the atomic instruction type; the global parameter array stores all floating-point coordinate values associated with each instruction in sequence; wherein, The move command is associated with the X and Y coordinates of its target point; The line segment is associated with the X and Y coordinates of its target point by the instruction; The arc is associated with the X and Y coordinates of its first control point and the X and Y coordinates of its second control point.
[0011] Preferably, in step S2, the specific process of calling the font outline parser to convert each text character into a path instruction sequence includes: Parse the vector outline of the character, convert the straight segments into line segments to instructions, convert the curved segments into arcs to instructions, insert the move to instruction at the beginning of the character path, and insert the path end instruction at the end of the character path.
[0012] Preferably, in step S4, the rendering level is the z-order value; the step of sorting and merging by level specifically includes: S4.1: Assign a z-order value to each graphic primitive or each individual text character; S4.2: Sort all primitives and characters to be rendered stably according to their z-order values from smallest to largest; S4.3: In the sorted order, append the path instruction sequence of each primitive or character to the final global instruction stream, and append its coordinate parameter sequence to the final global parameter stream.
[0013] Preferably, in step S5, the GPU is a lightweight graphics processing unit that does not support hardware-level drawing call batching, vertex buffer objects, and triangle rasterization, but only supports path-based 2D primitive drawing commands; the single drawing command includes memory address references and data length information of the global instruction stream and the global parameter stream.
[0014] Preferably, the lightweight graphics processing unit is a GPU based on the VeriSilicon VGLite architecture.
[0015] Preferably, the method is suitable for rendering a data visualization interface containing dynamic charts and multi-line text on a smartwatch or health bracelet.
[0016] In a second aspect, a computer-readable storage medium is provided storing a computer program that, when executed by a processor, implements the steps of the multi-shape batch rendering method applicable to GPUs without hardware batching capabilities.
[0017] Compared with the prior art, the present invention has the following beneficial effects: 1. This invention significantly improves the rendering frame rate by merging all graphics and text elements within a frame into a single drawing command, compressing dozens of GPU calls into one. 2. This invention parses text characters into path instructions that are isomorphic to graphics, achieving for the first time unified batch processing of graphics and text at the path level; 3. This invention adopts a structure that separates the instruction stream and parameter stream for storage, which facilitates efficient streaming parsing by the GPU and reduces resource consumption; 4. This invention performs a global sorting and merging of all elements according to the rendering level, ensuring the correctness of the visual hierarchy and avoiding erroneous overwriting; 5. This invention does not rely on hardware batch processing or advanced graphics APIs and is fully compatible with the GPUs of lightweight wearable devices that only support basic path drawing. 6. This invention provides an efficient rendering solution for dynamic charts and multi-text interfaces on smart wearable devices, improving the feasibility of implementing complex data visualization interfaces.
[0018] Other beneficial effects of the present invention will be explained in detail through the introduction of specific technical features and technical solutions in specific embodiments. Those skilled in the art should be able to understand the beneficial technical effects brought about by these technical features and technical solutions through the introduction of these technical features and technical solutions. Attached Figure Description
[0019] Other features, objects, and advantages of the present invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings: Figure 1 This is a schematic diagram of the overall process of the present invention. Detailed Implementation
[0020] The present invention will now be described in detail with reference to specific embodiments. These embodiments will help those skilled in the art to further understand the present invention, but do not limit the invention in any way. It should be noted that those skilled in the art can make several changes and improvements without departing from the concept of the present invention. These all fall within the protection scope of the present invention.
[0021] This invention provides a multi-shape batch rendering method suitable for GPUs without hardware batch processing capabilities, applicable to rendering data visualization interfaces containing dynamic charts and multi-line text on smartwatches or health bracelets. (See also...) Figure 1 As shown, the method specifically includes the following: Path instruction template definition step S1: Predefine path drawing instruction templates for various graphic elements and text characters.
[0022] In this step, the graphic primitives include line segments, quadrilaterals, triangles, circles, and semicircles; among them, the path drawing instruction template for line segments is constructed as a degenerate quadrilateral containing 5 instructions; the path drawing instruction templates for quadrilaterals and semicircles each contain 5 instructions; and the path drawing instruction templates for triangles and circles each contain 4 instructions.
[0023] Parsing step S2: Traverse all elements to be rendered in the current frame, including graphic elements and text elements; convert each graphic element into a path instruction sequence and coordinate parameters according to its corresponding path drawing instruction template; for each character in the text element, call the font outline parser to convert it into a path instruction sequence and coordinate parameters composed of path instructions.
[0024] Furthermore, the path drawing instruction template and the path instructions generated by the font outline parser are both composed of a variety of preset atomic instruction types; the atomic instruction types include at least: move to instruction, used to define the starting point of the path or the starting point of a new sub-path; line segment to instruction, used to draw a straight line from the current point to a specified point; arc to instruction, used to draw an arc from the current point to a specified point; and path end instruction, used to identify the end of a complete path or path group.
[0025] The specific process of calling the font outline parser to convert each text character into a sequence of path instructions includes: Parse the vector outline of the character, convert the straight segments into line segments to instructions, convert the curved segments into arcs to instructions, insert the move to instruction at the beginning of the character path, and insert the path end instruction at the end of the character path.
[0026] Separate storage step S3: Store all converted path instructions sequentially into the global instruction array, and store all corresponding coordinate parameters in the same order into the global parameter array. The global instruction array stores integer enumeration values corresponding to atomic instruction types; the global parameter array stores all floating-point coordinate values associated with each instruction sequentially; where, The command moves to the X and Y coordinates of its target point; The command associates the X and Y coordinates of the target point with the line segment; The arc is associated with the X and Y coordinates of its first control point and the X and Y coordinates of its second control point.
[0027] Sorting and merging step S4: Assign a rendering level to each element to be rendered, and merge the path instructions and coordinate parameters corresponding to all elements to be rendered into the final global instruction stream and parameter stream in order of rendering level from low to high.
[0028] In this step, the rendering level is the z-order value; the step of sorting and merging by level specifically includes: S4.1: Assign a z-order value to each graphic primitive or each individual text character; S4.2: Sort all primitives and characters to be rendered stably according to their z-order values from smallest to largest; S4.3: In the sorted order, append the path instruction sequence of each graphic element or character to the final global instruction stream, and append its coordinate parameter sequence to the final global parameter stream.
[0029] Single rendering step S5: Package the final global instruction stream and parameter stream into a single drawing command and submit it to the GPU for rendering at once.
[0030] The GPU is a lightweight graphics processing unit that does not support hardware-level batch rendering, vertex buffer objects, and triangle rasterization; it only supports path-based 2D primitive rendering commands. A single rendering command contains memory address references and data length information for the global instruction stream and global parameter stream. The lightweight graphics processing unit is a VeriSilicon VGLite architecture GPU.
[0031] The present invention will now be described in more detail.
[0032] This invention provides a multi-shape batch rendering method suitable for GPUs without hardware batch processing capabilities, mainly comprising a processor, memory, a GPU, and a display screen. The GPU is a lightweight graphics processing unit that lacks hardware batch processing capabilities and only supports path-based 2D primitive rendering, such as VeriSilicon's VGLite. The processor executes the logic of each step of the rendering method of this invention, while the memory stores program instructions, path templates, and constructed instruction and parameter streams. Finally, the GPU completes the rendering and outputs the results to the display screen.
[0033] The following is a detailed explanation of the implementation process of the present invention using a specific example of a health data display scenario in a smartwatch. In this scenario, an interface containing a heart rate curve, data points, and text labels needs to be drawn. The specific elements include: a heart rate curve composed of 20 short line segments, 3 data points (circles) used to mark specific heart rate values, and a text label "Heart Rate: 72 bpm" (16 characters in total).
[0034] The steps by which the processor executes the method of the present invention are as follows: 1. Definition of Path Instruction Templates for Graphic Elements and Text During system initialization, path drawing instruction templates for various basic graphic primitives are predefined in memory. Each template consists of a series of atomic instructions, including: MOVE_TO (move to, encoded 0), LINE_TO (line segment to, encoded 1), ARC_TO (arc to, encoded 2), and END (path end, encoded 3). For example: Line segment: Defined as a degenerate quadrilateral path template containing 5 instructions.
[0035] Circle: Defined as a path template containing 4 instructions (usually MOVE_TO, ARC_TO, etc.).
[0036] Triangles, quadrilaterals, semicircles, etc., each have their corresponding fixed instruction sequence templates.
[0037] Simultaneously, a lightweight font outline parser (such as a simplified version of FreeType) is integrated to parse character outlines into the aforementioned atomic instruction sequence at runtime.
[0038] 2. Primitive and Text Analysis The processor iterates through all elements to be rendered in the current frame.
[0039] For graphic elements (lines, circles, triangles, etc.): Each of the 20 segments of the heart rate curve is matched with a "segment" template to generate 20 independent quadrilateral path instruction sequences and their coordinate parameters.
[0040] Each of the three data points is matched with a "circle" template to generate three circular path instruction sequences and their coordinate parameters.
[0041] For text elements (string, font size, font, position, color, z-order) "Heart Rate: 72 bpm": The integrated font outline parser is invoked to process the 16 characters sequentially. The parser reads the font file, converts the outline information of each character into a sequence of instructions consisting of MOVE_TO, LINE_TO, and ARC_TO, and adds an END instruction to the end of each character path. For example, the character "7" might be converted into 3 LINE_TO instructions, and the character "2" might be converted into 2 LINE_TO instructions and 1 ARC_TO instruction. This process simultaneously generates the precise coordinate parameters corresponding to each instruction in each character path.
[0042] 3. Instruction stream and parameter stream are stored separately. The processor creates two global linear arrays: the instruction array and the parameter array.
[0043] Instruction array: In the order in which the graphics and text elements are parsed, the atomic instructions (such as MOVE_TO, LINE_TO, etc.) in each path instruction sequence are stored in the array with their corresponding integer codes (0,1,2,3).
[0044] Parameter array: Strictly following the order of instructions in the instruction array, store the coordinate parameters (floating-point numbers) required by each instruction sequentially. For example, after a MOVE_TO instruction, store the x and y coordinates of its target point; after an ARC_TO instruction, store the x1 and y1 coordinates of control point 1 and the x2 and y2 coordinates of control point 2 sequentially.
[0045] At this point, all the drawing information for graphics and text has been transformed into a compact instruction stream and a corresponding coordinate parameter stream.
[0046] 4. Sort and merge by level (z-order) Assign a z-order value representing the rendering level to each element to be rendered (including each individual graphic primitive and each text character). In this embodiment: The z-order value of the background heart rate curve is set to 0 (lowest).
[0047] The z-order value of the three circular data points is set to 1.
[0048] The z-order value of the text label is set to 2 (the highest).
[0049] The processor performs a stable sorting of all elements (20 line segments + 3 circles + 16 characters) in ascending order based on their z-order values. After sorting, the instruction sequence corresponding to each element is appended to the final global instruction stream in the new order, and its coordinate parameters are appended to the final global parameter stream. This step ensures that lower-level graphics (such as curves) are drawn first, followed by upper-level graphics (such as data points) and text, which are then drawn and correctly overlaid.
[0050] 5. Single GPU submission and rendering The processor sorts and merges the complete global instruction stream and global parameter stream, along with necessary rendering states (such as color information), and packages them into a single drawing command package. This command package is then submitted to the GPU via a single GPU driver interface call.
[0051] After receiving the command packet, the GPU sequentially parses each instruction in the global instruction stream and reads the corresponding number of coordinate parameters from the global parameter stream according to the instruction type. Internally, it reconstructs all paths from line segments and circles to character outlines and applies the specified colors for filling or outlining. Finally, the entire frame is rendered in one go within the GPU and output to the display screen.
[0052] As can be seen from the above examples, the rendering task that originally required at least 39 independent GPU calls (20 line segments + 3 circles + 16 characters) has been compressed into only 1 call, which greatly reduces the interaction burden between the CPU and GPU, thereby achieving smooth rendering of complex interfaces on resource-constrained devices.
[0053] Those skilled in the art will understand that, besides implementing the system and its various devices, modules, and units provided by this invention in the form of purely computer-readable program code, the same functions can be achieved entirely through logical programming of the method steps, making the system and its various devices, modules, and units of this invention function in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers. Therefore, the system and its various devices, modules, and units provided by this invention can be considered as a hardware component, and the devices, modules, and units included therein for implementing various functions can also be considered as structures within the hardware component; alternatively, the devices, modules, and units for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.
[0054] Specific embodiments of the present invention have been described above. It should be understood that the present invention is not limited to the specific embodiments described above, and those skilled in the art can make various changes or modifications within the scope of the claims, which do not affect the essence of the present invention. Unless otherwise specified, the embodiments and features described in this application can be arbitrarily combined with each other.
Claims
1. A multi-shape batch rendering method suitable for GPUs without hardware batch processing capabilities, characterized in that, include: Path instruction template definition step S1: Predefine path drawing instruction templates for various graphic elements and text characters; Parsing step S2: Traverse all elements to be rendered in the current frame, including graphic elements and text elements; convert each graphic element into a path instruction sequence and coordinate parameters according to its corresponding path drawing instruction template; for each character in the text element, call the font outline parser to convert it into a path instruction sequence and coordinate parameters composed of path instructions; Separate storage step S3: Store all the converted path instructions in the global instruction array in order, and store all the corresponding coordinate parameters in the global parameter array in the same order; Sorting and merging step S4: Assign a rendering level to each element to be rendered, and merge the path instructions and coordinate parameters corresponding to all elements to be rendered into the final global instruction stream and parameter stream in order of the rendering level from low to high. Single rendering step S5: Package the final global instruction stream and parameter stream into a single drawing command and submit it to the GPU for rendering at once.
2. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 1, characterized in that, In step S1, the graphic primitives include line segments, quadrilaterals, triangles, circles, and semicircles; wherein, The path drawing instruction template for the line segment is constructed as a degenerate quadrilateral containing 5 instructions; The path drawing instruction templates for the quadrilateral and the semicircle each contain 5 instructions; The path drawing instruction templates for the triangle and the circle each contain four instructions.
3. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 1 or 2, characterized in that, In steps S1 and S2, the path drawing instruction template and the path instructions generated by the font outline parser are both composed of a variety of preset atomic instruction types; The atomic instruction types include at least: The Move To command is used to define the starting point of a path or the starting point of a new subpath; The line segment to command is used to draw a straight line from the current point to a specified point; The Arc to command is used to draw an arc from the current point to a specified point; The path end instruction is used to mark the end of a complete path or group of paths.
4. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 3, characterized in that, In step S3, the global instruction array stores integer enumeration values corresponding to the atomic instruction types; the global parameter array stores, sequentially, all floating-point coordinate values associated with each instruction; wherein, The move command is associated with the X and Y coordinates of its target point; The line segment is associated with the X and Y coordinates of its target point by the instruction; The arc is associated with the X and Y coordinates of its first control point and the X and Y coordinates of its second control point.
5. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 4, characterized in that, In step S2, the specific process of calling the font outline parser to convert each text character into a sequence of path instructions includes: Parse the vector outline of the character, convert the straight segments into line segments to instructions, convert the curved segments into arcs to instructions, insert the move to instruction at the beginning of the character path, and insert the path end instruction at the end of the character path.
6. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 1, characterized in that, In step S4, the rendering level is the z-order value; the step of sorting and merging by level specifically includes: S4.1: Assign a z-order value to each graphic primitive or each individual text character; S4.2: Sort all primitives and characters to be rendered stably according to their z-order values from smallest to largest; S4.3: In the sorted order, append the path instruction sequence of each primitive or character to the final global instruction stream, and append its coordinate parameter sequence to the final global parameter stream.
7. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 1, characterized in that, In step S5, the GPU is a lightweight graphics processing unit that does not support hardware-level drawing call batching, vertex buffer objects, and triangle rasterization, but only supports path-based 2D primitive drawing commands; the single drawing command includes memory address references and data length information of the global instruction stream and the global parameter stream.
8. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 7, characterized in that, The lightweight graphics processing unit is a GPU based on the VeriSilicon VGLite architecture.
9. The multi-shape batch rendering method for GPUs without hardware batch processing capabilities according to claim 1, characterized in that, The method is applicable to rendering data visualization interfaces containing dynamic charts and multi-line text on smartwatches or fitness trackers.
10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the steps of any one of the methods for multi-shape batch rendering applicable to GPUs without hardware batching capabilities, as described in any one of claims 1 to 9.