Method and system for rendering a model image interface

Abstract

The present application relates to the technical field of image rendering, in particular to a rendering method and system for a model image interface, comprising the following steps: obtaining a view angle parameter and generating a screen pixel mapping result set of a surface patch, calculating a screen occupation ratio of the surface patch, generating a screen change feature of the surface patch in combination with a frame difference, generating a rendering scheduling sequence set based on the occupation ratio and the change feature, calling data in sequence to perform rasterization processing, and generating a rendering result of the model image interface. In the present application, the visual presentation weight under the current visual field is calculated by extracting vertex coordinate mapping, the difference in occupation ratio between the front and back frames is analyzed by using the finite difference method to capture the dynamic change trend, the dynamic rendering scheduling sequence is constructed based on the double dimensions of the occupation ratio and the change feature, the calculation resources are accurately tilted to the high screen occupation ratio and the high dynamic change area, the rendering quality of the core visual area is ensured, the invalid calculation overhead is greatly reduced, and the interface rendering real-time performance and frame rate stability in complex scenes are effectively improved.

Description

Rendering methods and systems for model image interfaces Technical Field

[0001] This invention relates to the field of image rendering technology, and in particular to a rendering method and system for model image interfaces. Background Technology

[0002] Image rendering technology refers to a collection of technologies related to the visualization of digital model data by computer systems. Its core aspects include the data organization methods of 3D models or 2D graphics, the representation of geometric structure and attribute information, the setting of viewpoint and coordinate system, the calculation rules of lighting parameters and material properties, and the processing flow of converting model data into screen pixels. It usually relies on graphics processing hardware and display devices, and realizes the continuous display and interactive presentation of the model in the interface by sequentially processing the model vertex coordinate texture mapping relationship, color value and depth information. Therefore, it is widely used in industrial design simulation software visualization modeling platforms and various human-computer interaction interfaces.

[0003] The traditional model image interface rendering method and system refers to loading the vertex information, face connection relationship and corresponding texture and color data of the model into the rendering pipeline according to the preset model data structure during the display of the model image interface. Then, the model is calculated frame by frame according to fixed view parameters and lighting parameters. By determining the projection position of the model in the screen coordinate system and generating the corresponding pixel display content, the overall rendering of the model image interface is completed.

[0004] Traditional rendering techniques rely on preset data structures to load model vertices and texture information into the pipeline sequentially, and perform frame-by-frame calculations according to fixed view and lighting parameters. This static processing logic ignores the differences in the actual screen occupancy of model faces and the frequency of dynamic changes during the rendering process. As a result, the graphics processing unit has difficulty in differentiating resource allocation for different visual weight areas. This leads to low-attention areas consuming too much computing power while core visual areas lack detail enhancement, resulting in low overall rendering scheduling efficiency and redundant computing resource load, causing interface display response delays and frame rate fluctuations. Summary of the Invention

[0005] To address the technical problems existing in the prior art, embodiments of the present invention provide a rendering method for a model image interface, comprising the following steps:

[0006] S1: Obtain the viewpoint parameters of the model image interface, extract the vertex coordinates of the model face and transform them into screen coordinates, calculate the pixel index of the transformed screen coordinates, and generate a set of face screen pixel mapping results.

[0007] S2: Count the number of model patch pixel indices in the current rendering frame in the patch screen pixel mapping result set, calculate the ratio of the number of model patch pixel indices to the total number of pixels in the screen resolution, and generate the patch screen occupancy ratio.

[0008] S3: Based on the screen occupancy ratio of the facets, calculate the difference between the screen occupancy ratio of the same model facets in the current rendering frame and the previous rendering frame, and input the first-order backward finite difference method to calculate the facet change rate, generating facet screen change features.

[0009] S4: Based on the screen change characteristics of the patch and the screen occupancy ratio of the patch, perform order relationship sorting calculation, combine the order relationship of the screen occupancy ratio and screen change characteristics sorting results, and generate a rendering scheduling order set;

[0010] S5: Based on the rendering scheduling order set, the model facet geometry data and material parameters are called in the scheduling order, the model facet data is input into the rasterization process, and a depth buffer comparison is performed based on the pixel-by-pixel depth value to generate the model image interface rendering result.

[0011] As a further aspect of the present invention, the patch screen pixel mapping result set includes patch identification information, screen pixel index set, and pixel index spatial distribution range; the patch screen occupancy ratio includes the patch pixel quantity ratio, screen pixel normalization ratio, and patch occupancy ratio scalar; the patch screen change characteristics include occupancy ratio difference sequence, inter-frame change rate value, and patch change trend quantity; the rendering scheduling order set includes patch sorting sequence, scheduling priority identifier, and order index relationship table; and the model image interface rendering result includes color buffer pixels, depth buffer status, and screen pixel display data.

[0012] As a further aspect of the present invention, the specific steps of S1 are as follows:

[0013] S101: Obtain the view parameters of the model image interface. Based on the projection information and view information in the view parameters, perform coordinate transformation on the vertex coordinates of the model face, convert the vertex space coordinates into clip space coordinates, and perform homogeneous normalization operation on the clip space coordinates to generate a clip-normalized vertex coordinate set.

[0014] S102: Based on the clipped normalized vertex coordinate set, perform a proportional mapping operation according to the screen width parameter and the screen height parameter, map the normalized coordinates to the screen coordinate system, and perform rounding judgment on the mapping result to limit the coordinate boundary, and obtain the screen vertex coordinate set of the patch.

[0015] S103: Based on the set of vertex coordinates of the patch screen, perform scan line interpolation operation on the vertex coordinates within the same patch, calculate the pixel index of the continuous screen coordinates generated by interpolation, and aggregate the index value with the corresponding patch identifier to generate a set of patch screen pixel mapping results.

[0016] As a further aspect of the present invention, the specific steps of S2 are as follows:

[0017] S201: Based on the pixel mapping result set of the patch screen, count the pixel index records corresponding to multiple model patches in the current rendering frame, perform deduplication judgment and sequence counting operation on the index number, accumulate and summarize the number of associated indexes of the same patch, and generate the number of pixel indexes of the model patch.

[0018] S202: Based on the number of pixel indices of the model patch, obtain the screen resolution parameters of the current rendering frame, perform a product operation on the number of horizontal pixels and the number of vertical pixels in the resolution parameters, analyze the screen pixel scale of a single frame, and configure the calculation result as a frame-level static constant to obtain the total number of screen resolution pixels.

[0019] S203: Calculate the ratio between the number of pixel indices of the model patch and the total number of pixels of the screen resolution. Use the number of pixel indices as the dividend and the total number of screen pixels as the divisor to obtain the occupancy ratio. Normalize the results of the ratios that exceed the preset patch occupancy threshold to generate the patch screen occupancy ratio.

[0020] As a further aspect of the present invention, the patch occupancy threshold is determined by obtaining the screen occupancy ratio of all model patches in the current rendering frame, performing a sequence aggregation operation on each occupancy ratio value, calculating the average value of the set of occupancy ratio values, and performing a scaling operation on the average value using a scaling factor. The scaling factor is a preset rendering load weight value, and its value range is set to 1.0 to 1.5.

[0021] As a further aspect of the present invention, the specific steps of S3 are as follows:

[0022] S301: Based on the screen occupancy ratio of the surface, obtain the corresponding occupancy ratio values ​​of the same model surface in the current rendering frame and the previous rendering frame, perform matching verification on the occupancy ratios of the two frames, perform difference calculation on the successfully matched occupancy ratios, and generate the surface occupancy ratio difference amount.

[0023] S302: Based on the difference in the area occupancy ratio, obtain the time identifier of the current rendering frame and the time identifier of the previous rendering frame, perform interval calculation on the two time identifiers, analyze the time span value corresponding to the difference in the area occupancy ratio, and convert it into a scalar value to obtain the inter-frame time difference.

[0024] S303: Based on the difference in the area occupancy ratio and the inter-frame time difference, perform ratio calculation to obtain the area change rate value, aggregate and mark the change rate values ​​that exceed the preset change rate threshold, and generate area screen change features.

[0025] As a further aspect of the present invention, the rate of change threshold is determined by obtaining a sample sequence of the change rate of the patch occupancy ratio during the rendering process, sorting the change rate values ​​of all sampling points in the sequence in ascending order, and calculating the arithmetic mean of the sequence and a preset three times the standard deviation.

[0026] As a further aspect of the present invention, the specific steps of S4 are as follows:

[0027] S401: Based on the screen change characteristics of the facets, sort the change rate values ​​of the multiple facets by numerical value, establish a linear sequence expression of the change rate values ​​in descending order, associate each change rate value with the facet identifier and perform ordinal encoding processing to generate a change feature order relationship sequence.

[0028] S402: Based on the screen occupancy ratio of the facets, perform numerical sorting operation on the occupancy ratio values ​​corresponding to the multiple facets, establish a linear sequence expression form for the occupancy ratio values ​​in descending order, associate each occupancy ratio value with the facet identifier and perform ordinal encoding processing to generate an occupancy ratio order relationship sequence.

[0029] S403: Based on the change feature order relationship sequence and the occupancy ratio order relationship sequence, perform order alignment operation on the two types of order indexes of the same patch identifier, perform weighted summation operation on the aligned double order indexes to obtain a comprehensive order value, and perform re-sorting according to the size to generate a rendering scheduling order set.

[0030] As a further aspect of the present invention, the specific steps of S5 are as follows:

[0031] S501: Based on the rendering scheduling sequence set, call the corresponding model patch geometric data and material parameters in the sequence index order, perform consistency verification on the geometric vertex coordinates, topological connection relationship and material parameter values, and aggregate and reorganize the verified geometric data and material parameters to generate a patch data sequence.

[0032] S502: Based on the facet data sequence, perform rasterization processing on the multifacet data in the sequence, perform screen space coordinate transformation on the geometric vertices of the facets, perform scan transformation on the transformed polygons, discretize the continuous geometric region into pixel segments and assign corresponding material parameter interpolation results to obtain pixel segment data.

[0033] S503: Based on the pixel fragment data, call the pixel-by-pixel depth value for each pixel fragment, compare it with the depth value stored in the current depth buffer, write the depth and color for pixel fragments that meet the update conditions, complete the traversal update of all pixel positions, and generate the model image interface rendering result.

[0034] The rendering system for the model's graphical interface includes:

[0035] The viewpoint mapping module obtains the viewpoint parameters of the model image interface, extracts the vertex coordinates of the model face and performs screen coordinate transformation, calculates the pixel index of the transformed screen coordinates, generates a face screen pixel mapping result set and passes it to the occupancy statistics module.

[0036] The occupancy statistics module counts the number of model patch pixel indices in the current rendering frame of the patch screen pixel mapping result set, calculates the ratio of the number of model patch pixel indices to the total number of pixels in the screen resolution, generates the patch screen occupancy ratio, and passes it to the change calculation module.

[0037] The change calculation module calculates the difference between the screen occupancy ratio of the same model face in the current rendering frame and the previous rendering frame based on the face screen occupancy ratio, and inputs the finite difference method to calculate the face change rate, generating face screen change features and passing them to the scheduling and sorting module.

[0038] The scheduling and sorting module performs order relationship sorting calculation based on the screen change characteristics of the patch and the screen occupancy ratio of the patch, combines the order relationship of the sorting results of the screen occupancy ratio and screen change characteristics, generates a rendering scheduling order set and passes it to the rendering execution module.

[0039] The rendering execution module, based on the rendering scheduling order set, calls the model facet geometric data and material parameters according to the scheduling order, inputs the model facet data into the rasterization process, and performs depth buffer comparison based on the pixel-by-pixel depth value to generate the model image interface rendering result.

[0040] Compared with the prior art, the advantages and positive effects of the present invention are as follows:

[0041] In this invention, the screen occupancy ratio of the model facets is generated by extracting the vertex coordinates and performing screen mapping calculations to quantify the visual presentation weight under the current view. The difference in occupancy ratio between consecutive frames is analyzed using the finite difference method to generate dynamic change features. A dynamic rendering scheduling order is constructed based on the dual order relationship of occupancy ratio and change features. Geometric data and material parameters are called according to priority to perform rasterization processing, so as to tilt computing resources towards areas with high screen occupancy and high dynamic change. While ensuring the rendering quality of the core visual area, the invalid computing overhead is reduced, and the real-time performance and frame rate stability of the interface rendering in complex scenes are improved. Attached Figure Description

[0042] To more clearly illustrate the technical solutions in the embodiments of the present invention, 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 the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0043] Figure 1 is a schematic diagram of the steps of the present invention;

[0044] Figure 2 is a detailed schematic diagram of S1 of the present invention;

[0045] Figure 3 is a detailed schematic diagram of S2 in this invention;

[0046] Figure 4 is a detailed schematic diagram of S3 in this invention;

[0047] Figure 5 is a detailed schematic diagram of S4 in this invention;

[0048] Figure 6 is a detailed schematic diagram of S5 of the present invention;

[0049] Figure 7 is a system module diagram of the present invention. Detailed Implementation

[0050] The technical solution of the present invention will now be described with reference to the accompanying drawings.

[0051] To make the technical problems, technical solutions and advantages of the present invention clearer, a detailed description will be given below in conjunction with the accompanying drawings and specific embodiments.

[0052] Please refer to Figure 1. This embodiment of the invention provides a method for rendering a model image interface, including the following steps:

[0053] S1: Obtain the viewpoint parameters of the model image interface, extract the vertex coordinates of the model face and transform them into screen coordinates, calculate the pixel index of the transformed screen coordinates, and generate a set of face screen pixel mapping results.

[0054] S2: Count the number of model patch pixel indices in the current rendering frame in the patch screen pixel mapping result set, calculate the ratio of the number of model patch pixel indices to the total number of pixels in the screen resolution, and generate the patch screen occupancy ratio.

[0055] S3: Based on the screen occupancy ratio of the facets, calculate the difference between the screen occupancy ratio of the same model facets in the current rendering frame and the previous rendering frame, and input the first-order backward finite difference method to calculate the facet change rate, generating facet screen change features.

[0056] S4: Calculate the order relationship based on the screen change characteristics of the patch and the screen occupancy ratio of the patch, combine the order relationship of the screen occupancy ratio and the screen change characteristics sorting results, and generate a rendering scheduling order set;

[0057] S5: Based on the rendering schedule set, the model facet geometry data and material parameters are called in the scheduling order. The model facet data is input into the rasterization process, and a depth buffer comparison is performed based on the pixel-by-pixel depth value to generate the model image interface rendering result.

[0058] The patch screen pixel mapping result set includes patch identification information, screen pixel index set, and pixel index spatial distribution range. The patch screen occupancy ratio includes the patch pixel quantity ratio, screen pixel normalization ratio, and patch occupancy ratio scalar. The patch screen change characteristics include the occupancy ratio difference sequence, inter-frame change rate value, and patch change trend. The rendering scheduling order set includes the patch sorting sequence, scheduling priority identifier, and order index relationship table. The model image interface rendering result includes color buffer pixels, depth buffer status, and screen pixel display data.

[0059] Please refer to Figure 2. The specific steps of S1 are as follows:

[0060] S101: Obtain the view parameters of the model image interface. Based on the projection information and view information in the view parameters, perform coordinate transformation on the vertex coordinates of the model face, convert the vertex space coordinates into clip space coordinates, and perform homogeneous normalization operation on the clip space coordinates to generate a clip-normalized vertex coordinate set.

[0061] The process involves obtaining view parameters including camera position coordinates, target point coordinates, and an up vector. The observation direction vector is obtained by calculating and normalizing the difference between the target point coordinates and the camera position coordinates. A right vector is generated using the cross product of the observation direction vector and the up vector. The up vector is then corrected using the cross product of the right vector and the observation direction vector. A view transformation matrix is ​​constructed based on the right vector, the corrected up vector, and the observation direction vector to transform the model's face vertices from the world coordinate system to the observation coordinate system. Subsequently, the process yields parameters including the field of view, aspect ratio, near clipping plane distance, and far clipping plane distance. The projection information is calculated based on the tangent of the field of view and the aspect ratio. A depth mapping relationship is constructed using the difference between the distances to the near and far clipping planes, generating a perspective projection matrix. The vertex coordinates in the viewing coordinate system are then multiplied sequentially with the view transformation matrix and the perspective projection matrix to obtain clipping space coordinates containing X, Y, Z, and W components. Homogeneous division is then performed on the clipping space coordinates, dividing the X, Y, and Z components by the W component, thereby mapping the vertex coordinates to the standard device coordinate system with values ​​ranging from -1 to 1. For example, in a real-world scenario, the camera position coordinates are set to 0, 0, 50, the target point coordinates are 0, 0, 0, the world coordinates of a vertex of a model face are 10, 10, 0, the field of view is set to 60 degrees, the aspect ratio is 1.77, the near clipping plane distance is 0.1, and the far clipping plane distance is 1000. Based on these parameters, half of the field of view is 30 degrees, its tangent is approximately 0.577, and the calculated vertical scaling factor is approximately 1.732, and the horizontal scaling factor is approximately 0.978. After... After the view transformation matrix operation, the coordinates of the vertex in the view coordinate system change to 10, 10, -50. Then, after the perspective projection matrix operation, the X component of the clipping space coordinates is 9.785, the Y component is 17.32, the Z component is 49.8, and the W component is 50. Finally, homogeneous division is performed, dividing the X, Y, and Z components by 50 respectively, resulting in clipping normalized coordinates of the vertex where the X component is approximately 0.196, the Y component is approximately 0.346, and the Z component is approximately 0.996. This calculation process accurately maps a 3D point to a standardized 2D projection plane, providing reference data for subsequent screen mapping.

[0062] S102: Based on the clipped normalized vertex coordinate set, a proportional mapping operation is performed according to the screen width and screen height parameters to map the normalized coordinates to the screen coordinate system, and the mapping result is rounded to limit the coordinate boundary, thereby obtaining the screen vertex coordinate set of the face.

[0063] Read the data of each vertex in the clipped normalized vertex coordinate set, obtain the preset screen width and screen height parameters. For the horizontal coordinate, sum the normalized X coordinate with the value 1, multiply by the value 0.5, and then multiply the result by the screen width parameter to obtain the preliminary screen horizontal coordinate. For the vertical coordinate, subtract the normalized Y coordinate from the value 1, multiply by the value 0.5, and then multiply the result by the screen height parameter to obtain the preliminary screen vertical coordinate. Perform a rounding operation on the preliminary screen horizontal and vertical coordinates. This operation uses the zero-rounding logic, that is, directly discard the decimal part and keep the integer part. At the same time, a boundary constraint logic is introduced: if the calculated coordinate value is less than 0, it is forcibly assigned to 0; if the horizontal coordinate is greater than the screen width parameter minus 1, it is forcibly assigned to the screen width parameter minus 1; if the vertical coordinate is greater than the screen height parameter minus 1, it is forcibly assigned to the screen height parameter minus 1. In this process, the screen width parameter is set to 1920 pixels and the screen height parameter is set to 1080 pixels. The normalized coordinate data calculated in step S101 above is directly used, namely X component 0.196 and Y component 0.346. First, the horizontal coordinate of the screen is calculated: 0.196 + 1 = 1.196, 1.196 * 0.5 * 1920 = 1148.16, and after rounding, the horizontal coordinate of the screen is 1148. Then, the vertical coordinate of the screen is calculated: 1 - 0.346 = 0.654, 0.654 * 0.5 = 0.327, and then multiplied by 1080 to get 353.16, and after rounding, the vertical coordinate of the screen is 353. The advantage of this operation logic is that by linearly stretching the standardized coordinate range to the pixel resolution range of the actual display device, and combined with strict boundary clamping, it ensures that all rendering points fall precisely within the addressable range of physical video memory, avoiding out-of-bounds overflow errors.

[0064] S103: Based on the vertex coordinate set of the patch screen, perform scan line interpolation operation on the vertex coordinates within the same patch, calculate the pixel index of the continuous screen coordinates generated by interpolation, and aggregate the index value with the corresponding patch identifier to generate a patch screen pixel mapping result set.

[0065] The algorithm iterates through the set of screen vertex coordinates of the facet, identifies the coordinates of three vertices under the same facet identifier, and sorts the three vertices in ascending order based on their screen ordinate values ​​to determine the start and end ordinates of the scan line. Within the range from the start to the end ordinate, scan line interpolation is performed row by row. For each scan line, the algorithm uses the linear equation logic of the facet edges, i.e., by calculating the ratio of the difference in ordinates to the difference in abscissas of adjacent vertices, to determine the inverse of the slope, and then derives the abscissa of the intersection point between the current scan line height and the left and right boundaries of the facet. The abscissas of the left and right intersection points are rounded to determine the start and end pixel abscissas within the current scan line. Each integer abscissa within this range is used as the column index of the current pixel, combined with the row index of the current scan line, to generate continuous screen coordinates. Then, pixel index calculation is performed, multiplying the current row index by the screen width parameter and adding it to the current column index to obtain a unique linear pixel index value. This index value is then aggregated as a key-value pair with the corresponding facet identifier. For example, let's define the currently processed patch as ID-1024. This patch is a right-angled triangle with three vertices: V1 (1147, 352), V2 (1150, 352), and V3 (1147, 355). When the scan line row index is 353, the x-coordinate of the intersection point of the left boundary (V1-V3 sides) is fixed at 1147, and the slope of the right boundary (V2-V3 sides) is -1, so the x-coordinate of the intersection point is calculated to be 1149. Then, the x-coordinates of the pixels to be filled in this row are 1147, 1148, and 1149, respectively. Combining this with the screen width of 1920, we can perform linear index calculation. For the x-coordinate of 1147, we can calculate 353 * 1920 = 677760, and 677760 + 1147 = 678907. We can then calculate the indexes of the remaining pixels in this row in the same way. The experimental results show that by using the above scan line interpolation and index aggregation, vector patch information can be transformed into discrete pixel matrix information. Compared with the traditional bounding box determination method, this scheme improves the accuracy of edge pixel coverage determination for complex geometric figures and effectively solves the problems of edge jaggedness and pixel belonging ambiguity in graphics rendering. The specific mapping data is shown in Table 1.

[0066] Table 1. Example of pixel mapping results for patch screens.

[0067]

[0068] As shown in Table 1, patch ID-1024 occupies a specific pixel area on different scan lines. The table records in detail the start and end positions of the intersection between each scan line and the patch, as well as the globally unique set of pixel indices calculated, which verifies the accuracy and continuity of scan line interpolation in the pixel-level discretization process.

[0069] Please refer to Figure 3. The specific steps of S2 are as follows:

[0070] S201: Based on the pixel mapping result set of the facet screen, count the pixel index records corresponding to multiple model faces in the current rendering frame, perform deduplication judgment and sequence counting operation on the index number, accumulate and summarize the number of associated indexes of the same facet, and generate the number of pixel indexes of the model facet.

[0071] The generated facet screen pixel mapping result set is retrieved. This result set stores the correspondence between all geometric faces in the rendering scene and the list of pixel indices they cover in the form of key-value pairs. The result set is traversed and the model identifiers of the faces it contains are extracted to construct a multi-model facet index aggregation pool. For each independent model identifier, all its associated facet branches are retrieved, and the discrete pixel index sequences corresponding to each facet are extracted to a temporary buffer. The sequence merging operation is performed to form the global pixel index set of the model in the current frame. A deduplication judgment operation is performed on the global pixel index set. This operation is performed by constructing a boolean bitmap array or hash set, reading each pixel index value in the set in turn, and checking whether the index value has been marked as existing in the bitmap. If it has existed, it is confirmed as an overlapping pixel and is removed. If it does not exist, it is marked and retained, thereby eliminating redundant counts caused by facet geometric adjacency or view occlusion. After the deduplication process is completed, a sequence counting operation is performed on the remaining unique pixel indices to count the total number of activated marks in the bitmap. This number is stored as the number of model facet pixel indices. For example, when processing a vehicle model identified as Model-A, the index data of its 500 facets is extracted and initially merged to obtain 50,000 pixel records. After deduplication and removal of 2,000 overlapping pixel records shared by facet edges, the final count shows that the effective number of model facet pixel indices for Model-A is 48,000. The advantage of this operation logic is that by removing duplicates at the pixel level, the area calculation error caused by the overlap of facets inside the geometry is accurately eliminated, ensuring the physical accuracy of the object's screen projection area statistics.

[0072] S202: Based on the number of pixel indices of the model patch, obtain the screen resolution parameters of the current rendering frame, perform a product operation on the number of horizontal pixels and the number of vertical pixels in the resolution parameters, analyze the screen pixel scale of a single frame, and configure the calculation results as frame-level static constants to obtain the total number of screen resolution pixels.

[0073] The display configuration interface of the graphics rendering pipeline is invoked to read the screen width and screen height parameters bound to the current rendering frame. These two parameters define the number of horizontal pixel columns and vertical pixel rows in the output buffer, respectively. Based on the obtained parameter values, a product operation is performed, using the screen width parameter as the multiplier and the screen height parameter as the multiplicand, to calculate the total pixel capacity of the current viewport. The product result is then solidified and written into a read-only global state variable as the denominator for all subsequent proportional calculations, preventing calculation jitter caused by dynamic resolution adjustments. In this process, using the parameters set in the previous steps, the screen width parameter is obtained as 1920 pixels and the screen height parameter as 1080 pixels. Substituting these two values ​​into the multiplication logic, 1920 * 1080 = 2073600 is calculated; that is, the total number of pixels in the current rendering environment's screen resolution is 2073600 pixels. This solidification process clarifies the physical display limit of the current frame, providing a standardized dimensional basis for subsequent evaluation of the model's visual proportion in the image.

[0074] S203: Calculate the ratio between the number of pixel indices of the model patch and the total number of pixels of the screen resolution. Use the number of pixel indices as the dividend and the total number of screen pixels as the divisor to obtain the occupancy ratio. Normalize the results of the ratio that exceeds the preset patch occupancy threshold to generate the patch screen occupancy ratio.

[0075] The system reads the calculated number of pixel indices of the model facets and the total number of pixels at the determined screen resolution. It then performs a floating-point division operation, using the number of pixel indices of the model facets as the numerator and the total number of pixels at the screen resolution as the denominator, to calculate the initial occupancy ratio. A facet occupancy threshold ratio is then set. This threshold is used to determine whether the model is in an abnormal close-range full-screen coverage state. The system reads this preset threshold and compares it with the initial occupancy ratio. If the initial occupancy ratio exceeds the preset facet occupancy threshold ratio, the normalization constraint logic is triggered, forcibly correcting the ratio result to the preset maximum saturation value, i.e., the value 1.0. If the threshold is not exceeded, the original calculation result is retained. For example, in the current frame, Model-A has a pixel index of 48,000, a total screen resolution of 2,073,600 pixels, and a preset pixel occupancy threshold of 0.95. Substituting 48,000 and 2,073,600 into the division operation yields approximately 0.023148, or 2.31%. Meanwhile, if another background model, Model-B, exists with a pixel index of 2,000,000, substituting it into the calculation yields 0.9645. Since 0.9645 is greater than the preset threshold of 0.95, normalization is performed, forcibly correcting Model-B's pixel screen occupancy ratio to 1.0. This experimental result shows that the occupancy ratio data generated through pixel-level precise comparison, compared to the traditional bounding box projection area estimation method, reduces the area assessment error rate when dealing with irregular objects (such as hollow structures and slender objects), and can more realistically reflect the visual weight of objects in the user's field of vision. Specific implementation data is shown in Table 2.

[0076] Table 2 Implementation Data Table for Model Screen Occupancy Ratio Calculation

[0077]

[0078] As shown in Table 2, a standardized screen occupancy ratio index was generated by performing a unified baseline division and threshold determination on model pixel data of different magnitudes. Among them, Model-B had a pixel count exceeding the threshold limit due to its close viewing distance. The algorithm correctly identified and normalized it to a full-screen occupancy state, which verified the boundary control capability of the logic.

[0079] Please refer to Figure 4. The specific steps of S3 are as follows:

[0080] S301: Based on the screen occupancy ratio of the facet, obtain the corresponding occupancy ratio values ​​of the same model facet in the current rendering frame and the previous rendering frame, perform matching verification on the occupancy ratio of the two frames, perform difference calculation on the successfully matched occupancy ratio, and generate the facet occupancy ratio difference amount.

[0081] The system reads the generated facet screen occupancy ratio data, which represents the normalized area weight of each model facet in the screen space in the current rendering frame. It accesses the cache area and retrieves the historical state list stored in the previous rendering frame. This list records the screen occupancy ratio of each facet at the previous moment, indexed by a combination of the model's unique identifier and the facet index number. A matching verification operation is performed, iterating through each facet record in the current frame and using the combination key to perform a hash lookup in the historical state list. If the lookup is successful, the corresponding occupancy ratio value from the previous frame is extracted. For successfully matched facet entries, a difference calculation is performed, using the current rendering frame's facet screen occupancy ratio as the minuend and the previous rendering frame's facet occupancy ratio with the same ID as the subtrahend, performing a floating-point subtraction operation and taking the absolute value of the result. For example, the current model being processed is a dynamic model identified as Model-C. In the current rendering frame (frame N), its screen occupancy ratio is read as 0.5000 (i.e., occupying half of the screen area). Simultaneously, in the cached record of the previous rendering frame (frame N-1), the screen occupancy ratio of the same name Model-C is found to be 0.4800. Substituting these two values ​​into the difference calculation logic, we first use 0.5000 - 0.4800 = 0.0200, then take its absolute value, finally determining that the difference in screen occupancy ratio of Model-C within this frame interval is 0.0200. If there is another model, Model-A, whose current frame occupancy ratio is 0.0231, and the previous frame was also 0.0231, then the calculated difference is 0. The advantage of this operation logic is that, through precise alignment and difference calculation of inter-frame data, it is possible to quantify and separate the visually significant change areas in the scene caused by viewpoint movement or object deformation, providing a basic quantitative indicator for subsequent dynamic rendering resource allocation.

[0082] S302: Based on the difference in the occupancy ratio of the patches, obtain the time identifier of the current rendering frame and the time identifier of the previous rendering frame, perform interval calculation on the two time identifiers, analyze the time span value corresponding to the difference in the occupancy ratio, and convert it into a scalar value to obtain the inter-frame time difference;

[0083] Based on the obtained difference in the area occupancy ratio, the time synchronization interface is triggered to obtain the first timestamp when the current rendering frame is submitted to the GPU pipeline, and the second timestamp when the previous rendering frame is submitted. Both timestamps are measured in milliseconds and have nanosecond-level high precision. An interval calculation operation is performed, using the first timestamp as the minuend and the second timestamp as the subtrahend, and the values ​​are subtracted to calculate the physical rendering interval between the two frames. Then, the time unit standardization processing is performed on the interval value, dividing it by the value 1000 to convert the millisecond-level data into a second-level floating-point number, and scalar solidification processing is performed to lock the converted result as a global constant for the current processing batch. During this process, the time stamp value of the current rendering frame was detected as 145200 milliseconds, and the time stamp value of the previous rendering frame was 145184 milliseconds. Substituting 145200 and 145184 into the subtraction operation, the original time interval was found to be 16 milliseconds. Then, a normalization transformation was performed, and 16 / 1000 = 0.016 seconds was used as a fixed inter-frame time difference for the calculation of the change rate of all subsequent patches. This value corresponds to a real-time rendering frame rate of approximately 62.5 Hz. This scalar solidification process ensures that in the parallel computing task of the same frame, all pixel-level or patch-level rate evaluations are based on a unified time reference, avoiding calculation deviations caused by small clock jitters.

[0084] S303: Based on the difference in patch occupancy ratio and the inter-frame time difference, perform ratio calculation to obtain the patch change rate value, aggregate and mark the change rate values ​​that exceed the preset change rate threshold, and generate patch screen change features.

[0085] The generated patch occupancy ratio difference and the determined inter-frame time difference are read, and a ratio calculation is performed. The patch occupancy ratio difference is used as the numerator and the inter-frame time difference is used as the denominator. A floating-point division operation is performed to calculate the patch change rate, which describes the speed at which the patch visual area scales. A change rate judgment threshold is set. The threshold is based on the human eye visual persistence experiment: at a standard viewing distance, when the area change rate of the screen content exceeds 10% per second (i.e., 0.1), the human eye will produce obvious flickering or visual attention shift. Therefore, the threshold is set to 0.15 through experiments to filter out significant areas with high dynamic changes. The calculated patch change rate value is compared with the preset change rate threshold. If the change rate value is greater than the preset threshold, the corresponding patch is included in the high-frequency change set for aggregation and marking. For example, for the aforementioned Model-C, its patch occupancy difference is 0.0200, and its inter-frame time difference is 0.016 seconds. Substituting 0.0200 and 0.016 into the division operation, the calculated patch change rate is 1.25. Since 1.25 is much greater than the preset threshold of 0.15, Model-C is determined to be in a state of rapid change (such as rapidly approaching the camera) and is marked as a high dynamic feature patch. For Model-A, its difference is 0, and its change rate is 0, which is less than the threshold, so it is marked as a static feature. The experimental results show that by introducing change rate analysis in the time dimension, the most visually impactful dynamic elements in the scene can be accurately identified. Compared with static area weight analysis, this method improves the accuracy of dynamic rendering priority allocation. The specific change rate analysis data is shown in Table 3.

[0086] Table 3. Implementation Data Table for Analysis of Screen Variation Characteristics

[0087]

[0088] As shown in Table 3, based on the comparison between the calculated rate of change and the threshold, the model patches in the scene are accurately divided into different dynamic levels. Model-C is identified as a key rendering object because its rate of change significantly exceeds the threshold, while Model-D, although it changes, does not reach the threshold and is classified as a non-significant change. This verifies the sensitivity and screening effectiveness of the change feature extraction logic.

[0089] Please refer to Figure 5. The specific steps of S4 are as follows:

[0090] S401: Based on the screen change characteristics of the facets, sort the change rate values ​​of the multiple facets by numerical value, establish a linear sequence expression of the change rate values ​​in descending order, associate each change rate value with the facet identifier and perform ordinal encoding processing to generate a change feature order relationship sequence.

[0091] The generated set of screen change features for each active facet in the scene is read, explicitly recording the unique identifiers of all active faces and their corresponding change rate values. A contiguous linear storage space is allocated in memory, and the facet identifiers and change rate values ​​are encapsulated into structured objects and sequentially filled into this storage space. A numerical sorting operation is performed, specifically using quicksort logic. The first change rate value in the sequence is selected as the pivot element, and each remaining change rate value is compared with the pivot element. Elements with values ​​greater than the pivot element are moved to the left partition, and elements with values ​​less than the pivot element are moved to the right partition. This partitioning process is recursively executed until all subsequences have a length of 1, thus constructing an ordered list that strictly decreases in size. After sorting, the ordered list is traversed, and each structured object in the list is assigned an integer index starting from 1 and increasing. This index is the change feature sequence number, representing the salience level of the facet at the dynamic visual level. The smaller the value, the more intense the dynamic change. Finally, the facet identifier is bound to the corresponding change feature sequence number using a key-value pair. In this process, the processed objects include Model-C, Model-D, the background model Model-B, and the reference model Model-E. The rate of change for Model-C is 1.25, for Model-E it is 0.85, for Model-D it is 0.125, and for Model-B it is 0.01 (approximately static). According to the sorting logic, Model-C, with the highest value, is ranked 1st, Model-E 2nd, Model-D 3rd, and Model-B 4th; their corresponding ordinal codes are 1, 2, 3, and 4, respectively. The advantage of this operational logic is that, through strict linear sorting and ordinal mapping, the continuous and unevenly distributed floating-point rates of change are transformed into discrete and continuous integer priorities, eliminating the nonlinear interference caused by the large differences in the magnitude of the original data in subsequent weighted calculations.

[0092] S402: Based on the screen occupancy ratio of the facets, perform numerical sorting operations on the corresponding occupancy ratio values ​​of multiple facets, establish a linear sequence expression form for the occupancy ratio values ​​in descending order, associate each occupancy ratio value with the facet identifier and perform ordinal encoding processing to generate an occupancy ratio order relationship sequence.

[0093] The system retrieves the calculated screen occupancy ratio data for each patch, reflecting the proportion of the projected area of ​​each model within the current view frustum. A temporary sorting buffer is established, and the patch identifiers and their corresponding screen occupancy ratio values ​​are imported into the buffer. A numerical sorting operation is performed, employing a merge sort strategy to ensure stability. The data in the buffer is divided into several subsequences, and each subsequence is sorted in descending order. Subsequences are then merged pairwise, always prioritizing larger values ​​during the merging process, ultimately forming a globally ordered occupancy ratio sequence. This sequence is traversed, and elements are assigned sequential numbers starting from 1 as their occupancy ratio order based on their physical location. This order directly reflects the visual weight of the object on the screen; the earlier the order, the larger the pixel area occupied by the object. The patch identifiers are then associated with and stored in relation to the calculated occupancy ratio order. In this process, the aforementioned model objects are continued to be used, and the screen occupancy ratio values ​​read are as follows: Model-B (full-screen background) is 1.00, Model-C (primary dynamic target) is 0.50, Model-D (secondary target) is 0.45, and Model-E (distant target) is 0.10. After sorting in descending order, Model-B is ranked first, Model-C second, Model-D third, and Model-E last. The occupancy ratio order is then assigned as follows: Model-B corresponds to order 1, Model-C to order 2, Model-D to order 3, and Model-E to order 4. The advantage of this calculation logic is that, by ordering the area weights, it ensures that objects occupying the main part of the screen can be identified first under limited rendering computing resources.

[0094] S403: Based on the change feature order relationship sequence and the occupancy ratio order relationship sequence, perform order alignment operation on the two types of order indexes of the same patch identifier, perform weighted summation operation on the aligned double order indexes to obtain a comprehensive order value, and perform re-sorting according to the size to generate a rendering scheduling order set;

[0095] The algorithm reads the change feature order sequence and the occupancy ratio order sequence separately. Using the unique identifier of the facet as the primary key, it performs a hash join operation to align and merge the order data of the same facet in the two sequences, constructing a comprehensive attribute table containing the change order and occupancy order. Dynamic and static weight coefficients are set. Based on the ratio of human eye sensitivity to the contours of moving and stationary objects in visual saliency psychology experiments, the dynamic weight coefficient is set to 0.6, and the static weight coefficient is set to 0.4, with their sum strictly equal to 1. A weighted summation operation is performed. For each facet, the dynamic weight coefficient is multiplied by the change feature order to obtain the dynamic component, and the static weight coefficient is multiplied by the occupancy order to obtain the static component. Then, the dynamic and static components are summed to calculate the comprehensive attribute table. The overall sequence value is used to perform a re-sorting operation, using ascending order. A smaller overall sequence value indicates a higher rendering priority. The specific calculation is as follows: For Model-C, the change sequence number is 1, and the occupied sequence number is 2, calculated as 0.6×1+0.4×2=0.6+0.8=1.4; for Model-B, the change sequence number is 4, and the occupied sequence number is 1, calculated as 0.6×4+0.4×1=2.4+0.4=2.8; for Model-E, the change sequence number is 2, and the occupied sequence number is 4, calculated as 0.6×2+0.4×4=1.2+1.6=2.8; for Model-D, the change sequence number is 3, and the occupied sequence number is 3, calculated as 0.6×3+0.4×3=1.8+1.2=3.0. When Model-B and Model-E have the same overall order value, a secondary sort is performed based on the lexicographical order of the patch identifier IDs (Model-B takes precedence over Model-E). The final sorting result is Model-C, Model-B, Model-E, and Model-D. This experimental result shows that through weighted fusion of dual order values, the dynamic blurring requirement and texture resolution requirement can be intelligently balanced. The specific scheduling data is shown in Table 4.

[0096] Table 4 Implementation Data Table for Rendering Scheduling Order Generation

[0097]

[0098] As shown in Table 4, Model-C, despite not occupying the largest area, achieved the highest rendering priority (overall order value 1.4) due to its extremely high dynamic change rate. Model-B, although occupying the entire screen, was placed at a lower priority because it remained stationary. Model-E and Model-D were ranked in order based on their overall scores, which verifies that the multi-dimensional weighted scheduling logic can accurately match the focus of human visual attention in resource allocation in complex scenarios.

[0099] Please refer to Figure 6. The specific steps of S5 are as follows:

[0100] S501: Based on the rendering scheduling sequence set, the corresponding model patch geometric data and material parameters are called in the sequence index order. Consistency checks are performed on the geometric vertex coordinates, topological connection relationships and material parameter values. The checked geometric data and material parameters are then aggregated and recombined to generate a patch data sequence.

[0101] Based on the generated rendering schedule set, Model-C, which is at the beginning of the schedule, is prioritized as the current processing object, and Model-B, Model-E, and Model-D are traversed sequentially. By accessing the vertex buffer and index buffer objects in video memory, the geometric data of 3500 vertices contained in Model-C, including 3D spatial coordinates, normal vectors, and texture coordinates, is read. Simultaneously, the corresponding diffuse map path, specular coefficient, and opacity parameters are retrieved from the material library. A consistency check is performed, first setting the validity boundary of the geometric coordinates, for example, the scene bounding box range is -50. Within the range of 00 to +5000 units, the coordinates of a vertex in Model-C are detected as (120.5, 300.2, -50.1). This value is within the valid range, indicating that the geometric data is valid. Next, the topological connectivity is verified, checking for out-of-bounds triangle indices. If the maximum index value is 3499 and the actual number of vertices is 3500, the topological structure is considered complete. Finally, material parameters are verified to confirm the existence of texture map IDs in the video memory texture array. All verified geometric vertex data and material attribute parameters are aggregated into memory blocks to construct a compact drawing instruction package, generating a sequence of facet data. The advantage of this verification logic is that, through preprocessing filtering before rendering, invalid or erroneous geometric primitives are eliminated, preventing GPU pipeline crashes or rendering anomalies caused by illegal data access.

[0102] S502: Based on the facet data sequence, perform rasterization processing on the multifacet data in the sequence, perform screen space coordinate transformation on the geometric vertices of the facets, perform scan transformation on the transformed polygons, discretize the continuous geometric region into pixel segments and assign corresponding material parameter interpolation results to obtain pixel segment data.

[0103] The system receives the output facet data sequence and initiates the rasterization pipeline of the graphics processor. It then performs a screen space coordinate transformation on the geometric vertices of the facets, calling the model-view projection matrix to multiply and accumulate the vertex model space coordinates with the matrix elements, mapping the 3D coordinates to the 2D screen pixel coordinate system. For example, for a vertex in Model-C, its original coordinates are (0, 0, 5). After matrix transformation, its screen x-coordinate is converted to 960, y-coordinate to 540, and depth is normalized to 0.45. A scan transformation is performed on the transformed polygon primitives to determine the screen pixel range covered by the triangles, discretizing the continuous geometric triangles into a series of specific pixel segments. Simultaneously, attribute interpolation is performed, using a centroid coordinate algorithm to calculate the color attributes of internal pixels based on the weighted allocation of vertex colors. If vertex A has a red channel value of 255, vertex B has a red channel value of 0, and the currently processed pixel segment is located at the geometric midpoint between the two, then linear interpolation calculates the red channel value of the segment to be 127.5, thus obtaining pixel segment data containing position information and material attributes. The advantage of this operational logic is that it can quickly transform abstract mathematical geometric models into a set of visualized pixel arrays through hardware-accelerated coordinate transformation and interpolation calculations.

[0104] S503: Based on pixel fragment data, call the pixel-by-pixel depth value for each pixel fragment, compare it with the depth value stored in the current depth buffer, write the depth and color for pixel fragments that meet the update conditions, complete the traversal and update of all pixel positions, and generate the model image interface rendering result.

[0105] For each generated pixel fragment, its depth value information is read, and the current depth cache value at the corresponding pixel position in the frame buffer is accessed. A value comparison operation is performed, using a "less than, pass" depth test rule. The depth value of the current fragment is used as the comparison object, and the depth value in the cache is used as the reference object. If the depth value of the current fragment is less than the cached depth value, it means that the fragment is closer to the viewing point and is not occluded. At this time, a write update operation is performed, overwriting the depth value of the current fragment into the depth buffer and writing the calculated color value into the color buffer. If the depth value of the current fragment is greater than the cached value, the fragment is discarded directly. For example, at screen coordinates (960, 540), the current depth value of the Model-C fragment is 0.45, while the original value in the depth buffer is 0.99 (corresponding to the depth of the background Model-B). Comparing these values, 0.45 is found to be less than 0.99, so the test is considered passed. Therefore, 0.45 is written to the depth buffer, and the material color of Model-C is written to the frame buffer. Conversely, if the depth of the Model-E fragment is 0.60, which is greater than the already written 0.45, then this fragment is discarded. After traversing all pixel positions on the screen and completing the above operations, the final model image interface rendering result is generated. This experimental result shows that the depth-priority-based pixel update mechanism can accurately handle object occlusion relationships in complex scenes. Specific depth test data is shown in Table 5.

[0106] Table 5. Implementation Data Table for Pixel Fragment Depth Test

[0107]

[0108] As shown in Table 5, different model segments were processed sequentially at the same pixel point (960, 540), and the color and depth information of the Model-C closest to the viewpoint were correctly preserved, verifying the core role of the depth test logic in the hidden surface removal process.

[0109] Please refer to Figure 7, the rendering system for the model image interface, which includes:

[0110] The viewpoint mapping module obtains the viewpoint parameters of the model image interface, extracts the vertex coordinates of the model face and performs screen coordinate transformation, calculates the pixel index of the transformed screen coordinates, generates a face screen pixel mapping result set and passes it to the occupancy statistics module.

[0111] The occupancy statistics module counts the number of model patch pixel indices in the current rendering frame in the patch screen pixel mapping result set, calculates the ratio of the number of model patch pixel indices to the total number of pixels in the screen resolution, generates the patch screen occupancy ratio, and passes it to the change calculation module.

[0112] The change calculation module calculates the difference between the screen occupancy ratio of the same model face in the current rendering frame and the previous rendering frame based on the face screen occupancy ratio, and inputs the difference into the finite difference method to calculate the face change rate, generating face screen change features and passing them to the scheduling and sorting module.

[0113] The scheduling and sorting module performs order relationship sorting calculations based on the screen change characteristics of the facets and the screen occupancy ratio of the facets, combines the order relationship of the sorting results of the screen occupancy ratio and screen change characteristics, generates a rendering scheduling order set, and passes it to the rendering execution module.

[0114] The rendering execution module, based on the rendering scheduling order set, calls the model facet geometry data and material parameters according to the scheduling order, inputs the model facet data into the rasterization process, and performs depth buffer comparison based on the pixel-by-pixel depth value to generate the model image interface rendering result.

[0115] The above are merely specific embodiments of the present invention, but the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the technical scope disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A rendering method for a model image interface, characterized in that, Includes the following steps: S1: Obtain the viewpoint parameters of the model image interface, extract the vertex coordinates of the model face and transform them into screen coordinates, calculate the pixel index of the transformed screen coordinates, and generate a set of face screen pixel mapping results. S2: Count the number of model patch pixel indices in the current rendering frame in the patch screen pixel mapping result set, calculate the ratio of the number of model patch pixel indices to the total number of pixels in the screen resolution, and generate the patch screen occupancy ratio. S3: Based on the screen occupancy ratio of the facets, calculate the difference between the screen occupancy ratio of the same model facets in the current rendering frame and the previous rendering frame, and input the first-order backward finite difference method to calculate the facet change rate, generating facet screen change features. The specific steps of S3 are as follows: S301: Based on the panel screen occupancy ratio, obtain the corresponding occupancy ratio values ​​of the same model panels in the current rendering frame and the previous rendering frame, perform matching verification on the occupancy ratios of the two frames, perform difference calculation on the successfully matched occupancy ratios, and generate the panel occupancy ratio difference amount; S302: According to the panel occupancy ratio difference amount, obtain the time identifier of the current rendering frame and the time identifier of the previous rendering frame, perform interval calculation on the time identifiers of the two frames, analyze the time span value corresponding to the occupancy ratio difference amount, and convert it into a scalar value to obtain the inter-frame time difference amount; S303: Based on the panel occupancy ratio difference amount and the inter-frame time difference amount, perform ratio calculation to obtain the panel change rate value, aggregate and mark the change rate values ​​that exceed the preset change rate threshold, and generate panel screen change features; S4: Based on the screen change characteristics of the patch and the screen occupancy ratio of the patch, perform order relationship sorting calculation, combine the order relationship of the screen occupancy ratio and screen change characteristics sorting results, and generate a rendering scheduling order set; S5: Based on the rendering scheduling order set, the model facet geometry data and material parameters are called in the scheduling order, the model facet data is input into the rasterization process, and a depth buffer comparison is performed based on the pixel-by-pixel depth value to generate the model image interface rendering result.

2. The rendering method for the model image interface according to claim 1, characterized in that, The patch screen pixel mapping result set includes patch identification information, screen pixel index set, and pixel index spatial distribution range. The patch screen occupancy ratio includes the patch pixel quantity ratio, screen pixel normalization ratio, and patch occupancy ratio scalar. The patch screen change characteristics include occupancy ratio difference sequence, inter-frame change rate value, and patch change trend quantity. The rendering scheduling order set includes patch sorting sequence, scheduling priority identifier, and order index relationship table. The model image interface rendering result includes color buffer pixels, depth buffer status, and screen pixel display data.

3. The rendering method for the model image interface according to claim 1, characterized in that, The specific steps of S1 are as follows: S101: Obtain the view parameters of the model image interface. Based on the projection information and view information in the view parameters, perform coordinate transformation on the vertex coordinates of the model face, convert the vertex space coordinates into clip space coordinates, and perform homogeneous normalization operation on the clip space coordinates to generate a clip-normalized vertex coordinate set; S102: Based on the clip-normalized vertex coordinate set, perform proportional mapping operation according to the screen width parameter and screen height parameter, map the normalized coordinates to the screen coordinate system, and perform rounding judgment on the mapping result to limit the coordinate boundary, thereby obtaining the face screen vertex coordinate set; S103: Based on the face screen vertex coordinate set, perform scanline interpolation operation on the vertex coordinates within the same face, calculate the pixel index of the continuous screen coordinates generated by interpolation, and aggregate the index value with the corresponding face identifier to generate a face screen pixel mapping result set.

4. The rendering method for the model image interface according to claim 1, characterized in that, The specific steps of S2 are as follows: S201: Based on the pixel mapping result set of the facets, count the pixel index records corresponding to multiple model facets in the current rendering frame, perform deduplication judgment and sequence counting operation on the index number, accumulate and summarize the number of associated indexes of the same facet, and generate the number of pixel indexes of the model facets; S202: Based on the number of pixel indexes of the model facets, obtain the screen resolution parameters of the current rendering frame, perform a product operation on the number of horizontal pixels and the number of vertical pixels in the resolution parameters, analyze the screen pixel scale value of a single frame, and configure the calculation result as a frame-level static constant to obtain the total number of pixels at the screen resolution. S203: Calculate the ratio between the number of pixel indices of the model patch and the total number of pixels of the screen resolution. Use the number of pixel indices as the dividend and the total number of screen pixels as the divisor to obtain the occupancy ratio. Normalize the results of the ratios that exceed the preset patch occupancy threshold to generate the patch screen occupancy ratio.

5. The rendering method for the model image interface according to claim 4, characterized in that, The panel occupancy threshold is determined by obtaining the screen occupancy ratio of all model panels in the current rendering frame, performing a sequence aggregation operation on each occupancy ratio value, calculating the average value of the set of occupancy ratio values, and performing a scaling operation on the average value. The scaling factor is a preset rendering load weight value, and its value range is set to 1.0 to 1.

5.

6. The rendering method for the model image interface according to claim 1, characterized in that, The rate of change threshold is determined by obtaining a sample sequence of the change rate of the area occupancy ratio during the rendering process, sorting the change rate values ​​of all sampling points in the sequence in ascending order, and calculating the arithmetic mean of the sequence and three times the preset standard deviation.

7. The rendering method for the model image interface according to claim 1, characterized in that, The specific steps of S4 are as follows: S401: Based on the screen change characteristics of the facets, sort the change rate values ​​of the multiple facets by numerical size, establish a linear sequence expression form for the change rate values ​​in descending order, associate each change rate value with the facet identifier and perform ordinal encoding processing to generate a change feature order relationship sequence. S402: Based on the screen occupancy ratio of the facets, perform a numerical sorting operation on the corresponding occupancy ratio values ​​of the multiple facets, establish a linear sequence expression for the occupancy ratio values ​​in descending order, associate each occupancy ratio value with a facet identifier and perform ordinal encoding processing to generate an occupancy ratio order relationship sequence; S403: Based on the change feature order relationship sequence and the occupancy ratio order relationship sequence, perform an ordinal alignment operation on the two types of ordinal indices of the same facet identifier, perform a weighted summation operation on the aligned double ordinal indices to obtain a comprehensive ordinal value, and perform a re-sorting based on the size to generate a rendering scheduling order set.

8. The rendering method for the model image interface according to claim 1, characterized in that, The specific steps of S5 are as follows: S501: Based on the rendering scheduling sequence set, the corresponding model facet geometric data and material parameters are called in sequence index order. Consistency checks are performed on the geometric vertex coordinates, topological connection relationships and material parameter values. The checked geometric data and material parameters are aggregated and recombined to generate a facet data sequence. S502: According to the facet data sequence, a rasterization process is performed on the multi-facet data in the sequence. Screen space coordinate transformation is performed on the facet geometric vertices. Scan transformation is performed on the transformed polygons. The continuous geometric region is discretized into pixel fragments and the corresponding material parameter interpolation results are assigned to obtain pixel fragment data. S503: Based on the pixel fragment data, the pixel-by-pixel depth value is called for each pixel fragment. The value is compared with the depth value stored in the current depth buffer. The depth and color are written for the pixel fragments that meet the update conditions. The traversal and update of all pixel positions are completed to generate the model image interface rendering result.

9. A rendering system for a model image interface, characterized in that, The system is used to implement the rendering method of the model image interface according to any one of claims 1-8. The system includes: a viewpoint mapping module, which acquires viewpoint parameters of the model image interface, extracts the vertex coordinates of the model facets and performs screen coordinate transformation, calculates pixel indices on the transformed screen coordinates, generates a facet screen pixel mapping result set and passes it to the occupancy statistics module; the occupancy statistics module, which counts the number of model facet pixel indices in the current rendering frame in the facet screen pixel mapping result set, calculates the ratio of the number of model facet pixel indices to the total number of pixels in the screen resolution, generates a facet screen occupancy ratio and passes it to the change calculation module; and the change calculation module, which, based on the facet screen occupancy ratio, compares the current rendering frame with the previous rendering frame. In the rendering frame, the screen occupancy ratio of the same model facet is calculated by difference, and the finite difference method is used to calculate the facet change rate, generating facet screen change features and passing them to the scheduling and sorting module. The scheduling and sorting module performs order relationship calculation based on the facet screen change features and the facet screen occupancy ratio, combines the order relationship of the screen occupancy ratio and screen change feature sorting results, generates a rendering scheduling order set, and passes it to the rendering execution module. The rendering execution module, based on the rendering scheduling order set, calls the model facet geometric data and material parameters according to the scheduling order, inputs the model facet data into the rasterization process, and performs depth buffer comparison based on pixel-by-pixel depth values ​​to generate the model image interface rendering result.

Images