Application program performance monitoring method and system, electronic equipment and program product

Abstract

The invention provides an application program performance monitoring method and system, electronic equipment and a program product. According to the scheme, a resource configuration file of a role model in a target application program is obtained; performing model resource analysis calculation processing on the resource configuration file to obtain model resource data; performing data report generation processing on the model resource data to obtain an application program performance report; and performing performance optimization processing on the role model according to the application program performance report to obtain an optimization result. According to the scheme, the efficiency of application program performance monitoring can be improved, and the method can be widely applied to the fields of animation game making engine software and development systems, digital culture product making software, digital culture creative software and the like in the digital creative industry.

Description

Technical Field

[0001] This application relates to the technical field of animation and game production engine software and development system, and in particular to an application performance monitoring method, system, electronic device and program product. Background Technology

[0002] During game development or testing, it is necessary to monitor and test game performance. However, when testing game performance, related technologies typically monitor overall performance data during game runtime, such as frame rate data. Further analysis of the frame rate data is then required to pinpoint the specific cause, which is inefficient and affects the game's performance and user experience. Summary of the Invention

[0003] This application aims to address at least one of the technical problems existing in the prior art. To this end, this application proposes an application performance monitoring method, system, electronic device, and program product that can improve the efficiency of game performance monitoring.

[0004] To achieve the above objectives, one aspect of this application provides an application performance monitoring method, comprising: Obtain the resource configuration files for the character models in the target application; The resource configuration file is subjected to model resource analysis and calculation to obtain model resource data; The model resource data is processed to generate a data report, resulting in an application performance report; The role model is optimized based on the application performance report to obtain the optimization result.

[0005] According to some embodiments of this application, the step of performing model resource analysis and calculation processing on the resource configuration file to obtain model resource data includes: The resource configuration file is subjected to file format recognition processing to obtain the file format; The resource configuration file is parsed according to its file format to obtain a parsed file. The parsed file is processed to extract character model data, resulting in the model resource data. The model resource data includes the number of model faces, bone data, rigging configuration data, and inverse dynamics component data.

[0006] According to some embodiments of this application, the step of performing character model data extraction processing on the parsed file to obtain the model resource data includes: The target model is obtained by performing model localization processing on the parsed file. The vertex data and face index data of the target model are extracted and processed to obtain the number of faces of the model; The target model is subjected to skeletal hierarchy analysis and skeletal node identification processing based on the skinned mesh component to obtain the skeletal data. The skeletal binding constraints of the target model are identified and processed based on the skeletal data to obtain the binding configuration data; The animation blueprint and state machine of the target model are analyzed and processed to obtain the inverse dynamics component data.

[0007] According to some embodiments of this application, the step of performing data report generation processing on the model resource data to obtain an application performance report includes: The model resource data is summarized and statistically processed to obtain statistical data; The statistical data are compared and processed according to a preset model resource threshold to obtain the out-of-standard model; The performance of the model resource data of the out-of-standard model is analyzed and processed to generate optimization suggestions; The statistical data is then visualized to obtain visual charts; Based on the optimization suggestions and the visualization charts, generate the application performance report.

[0008] According to some embodiments of this application, the step of performing performance analysis on the model resource data of the out-of-standard model to generate optimization suggestions includes: The rendering complexity and computational logic complexity of the model resource data of the over-standard model are calculated to obtain a complexity score; Based on the complexity score, resource correlation analysis is performed on the over-standard model to obtain the analysis results; The analysis results are input into a large language model for natural language analysis and processing to generate optimization suggestions.

[0009] According to some embodiments of this application, the step of performing performance optimization processing on the role model based on the application performance report to obtain optimization results includes: Determine the model resource data to be adjusted based on the application performance report; The resource data of the model to be adjusted is optimized based on the application scenario, operating environment, and interaction behavior of the target application to obtain the optimization result.

[0010] According to some embodiments of this application, before obtaining the resource configuration file of the role model in the target application, the method includes establishing a model resource threshold, including: The target application is subjected to scenario analysis to obtain the application scenario and operating environment; The operating environment is subjected to performance analysis and processing to obtain terminal performance data; Based on the application scenario and the terminal performance data, the model resource data of the role model is processed to define a threshold, thereby obtaining the model resource threshold.

[0011] To achieve the above objectives, another aspect of this application proposes an application performance monitoring system, applied to the application performance monitoring method described above, comprising: The data acquisition module is configured to acquire resource configuration files for the role models in the target application; The resource analysis module is configured to perform model resource analysis and calculation on the resource configuration file to obtain model resource data; The report generation module is configured to perform data report generation processing on the model resource data to obtain an application performance report; The performance optimization module is configured to perform performance optimization processing on the role model based on the application performance report to obtain the optimization result.

[0012] To achieve the above objectives, another aspect of this application provides an electronic device including at least one control processor and a memory for communicatively connecting to the at least one control processor; the memory stores instructions executable by the at least one control processor, which, when executed by the at least one control processor, enables the at least one control processor to perform the application performance monitoring method as described above.

[0013] To achieve the above objectives, another aspect of this application provides a computer-readable storage medium storing computer-executable instructions for performing the application performance monitoring method as described above.

[0014] To achieve the above objectives, another aspect of this application provides a computer program product storing computer-executable instructions for executing the application performance monitoring method described above.

[0015] One of the above technical solutions has the following advantages or beneficial effects: This application provides an application performance monitoring method, system, electronic device, and program product. This solution obtains the resource configuration file of the character model in the target application; performs model resource analysis and calculation on the resource configuration file to obtain model resource data; performs data report generation processing on the model resource data to obtain an application performance report; and performs performance optimization processing on the character model based on the application performance report to obtain the optimization result. This solution directly monitors the model resource data that affects game performance and can generate data reports based on the model resource data for optimization processing, saving time and effort and improving the efficiency of game performance monitoring. Attached Figure Description

[0016] Figure 1 This is a flowchart of an application performance monitoring method provided in one embodiment of this application; Figure 2 yes Figure 1 Flowchart of step S102; Figure 3 yes Figure 2 Flowchart of step S203; Figure 4 yes Figure 1 Flowchart of step S103; Figure 5 yes Figure 4 Flowchart of step S403; Figure 6 yes Figure 1 Flowchart of step S104; Figure 7 This is a flowchart illustrating the establishment of a model resource threshold according to an embodiment of this application; Figure 8 This is a flowchart of model resource data monitoring provided in one embodiment of this application; Figure 9 This is a schematic diagram of the structure of an application performance monitoring system provided in one embodiment of this application; Figure 10 This is a structural diagram of an electronic device provided in another embodiment of this application. Detailed Implementation

[0017] The embodiments of this application are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain this application, and should not be construed as limiting this application.

[0018] In the description of this application, it should be understood that the orientation descriptions, such as up, down, front, back, left, right, etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. They are only for the convenience of describing this application and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on this application.

[0019] In the description of this application, "several" means one or more, "more than" means two or more, "greater than," "less than," and "exceeding" are understood to exclude the stated number, while "above," "below," and "within" are understood to include the stated number. The use of "first" and "second" in the description is merely for distinguishing technical features and should not be construed as indicating or implying relative importance, or implicitly indicating the number of indicated technical features, or implicitly indicating the order of the indicated technical features.

[0020] In the description of this application, unless otherwise expressly defined, terms such as "setup," "installation," and "connection" should be interpreted broadly, and those skilled in the art can reasonably determine the specific meaning of the above terms in this application in conjunction with the specific content of the technical solution.

[0021] Before providing a detailed description of the embodiments of this application, some of the nouns and terms involved in the embodiments of this application will be explained first. The nouns and terms involved in the embodiments of this application are subject to the following interpretations.

[0022] 1) Artificial Intelligence (AI) is a technological science that studies and develops technologies that simulate, extend, and expand human intelligence. It encompasses multiple fields and technologies, aiming to enable machines to perform tasks that traditionally require human intelligence. Core areas of AI include machine learning, natural language processing, computer vision, and robotics. Machine learning, which learns and predicts from data through algorithms, is one of the foundational technologies of AI. Natural language processing focuses on understanding and generating human language, applied in machine translation, dialogue systems, and other scenarios. Computer vision enables machines to understand and analyze images and videos, used for facial recognition, object detection, and more. Robotics involves the design and development of intelligent physical devices, such as autonomous driving and service robots.

[0023] 2) Inverse Kinematics (IK) refers to controlling and influencing the movement of a character's body parts by using various objects in the scene. Generally speaking, skeletal animation is a traditional method of driving from parent node to child node (i.e., forward kinematics), while IK is the reverse, with the child nodes of the skeleton driving the parent nodes of the skeleton. For example, if a character steps on a stone while walking, the child nodes of the foot need to drive the entire skeleton to respond to stepping on the stone.

[0024] 3) Large Language Models (LLMs) are deep learning models trained on large amounts of text data, enabling them to generate natural language text or understand the meaning of language text. These models can provide in-depth knowledge and language production on a wide range of topics by training on massive datasets. Their core idea is to learn patterns and structures of natural language through large-scale unsupervised training, thus mimicking human language cognition and generation processes to some extent.

[0025] In the development and testing of game software, relevant technologies primarily monitor game performance by uniformly monitoring game performance metrics, such as frame rate data. Testing typically begins after the game is packaged and manufactured. However, multiple factors can influence game performance, including character, scene, and special effects resources. These factors may act individually or cumulatively. Even if performance monitoring detects a performance drop, manual reproduction and further analysis are needed to pinpoint which resources or logic within the game client are causing the degradation. It doesn't directly monitor the root cause of the performance issue; it only provides overall game performance monitoring. Because game client performance can be affected by various factors, and application scenarios are composed of diverse resources, while it's possible to monitor runtime performance and then analyze CPU or GPU hotspots by reproducing the problem, each instance requires significant time and manpower for performance analysis to pinpoint the specific cause.

[0026] Therefore, this application provides an application performance monitoring method, system, electronic device, and program product, which can be applied to fields such as animation and game production engine software and development systems, digital cultural product production software, and digital cultural creative software. This solution obtains the resource configuration file of the character model in the target application and performs model resource analysis and calculation on the resource configuration file to obtain model resource data. The model resource data may include the number of model faces, skeleton data, binding configuration data, and inverse dynamics component data. This solution directly monitors these data indicators that affect performance. Once an increase in resource production-related quantities is detected, the corresponding character's data can be directly optimized, eliminating the need for manual effort to further analyze and locate the cause of performance degradation through performance data, thus improving the efficiency of game performance monitoring and the user experience. Furthermore, this solution can also generate data reports from the model resource data. Through large language model analysis, corresponding data performance reports are generated, facilitating developers to quickly locate problems. The optimization suggestions in the data performance reports can be combined to optimize the character model's performance, improving the efficiency of performance optimization.

[0027] This application provides an application performance monitoring method, system, electronic device, and program product, which will be described in detail in the following embodiments.

[0028] The application performance monitoring method provided in this application covers most application scenarios for game performance monitoring in game software or digital cultural products. It is applicable to fields such as animation and game production engine software and development systems, and game and animation software. It allows terminal devices to directly monitor model resource data affecting game performance when running specified game software, improving the compatibility of the device running the game, reducing unnecessary manual analysis, speeding up the game program's operation, and enhancing the user experience. Specifically, in scenarios where users interact with game software or applications, the performance of the game software can be monitored through a pre-set monitoring program or platform on the server. By acquiring and processing data from the target application running on the terminal device, the resource configuration file of the character model in the target application is obtained and transmitted to the server. Upon receiving the resource configuration file, the server performs model resource analysis and calculation processing, i.e., monitors the model resource data. By identifying and parsing the resource configuration file, the corresponding model resource data can be obtained. It is important to note that this model resource data is closely related to game performance. By directly monitoring the model resource data, potential problems in game performance can be quickly located, reducing the cost of manual analysis. This application embodiment also generates an application performance report by processing the model resource data into a data report. Developers can quickly locate game performance problems based on the application performance report, and can also optimize the performance of character models in the target application by combining the optimization suggestions given in the application performance report, thereby improving the efficiency of game performance optimization.

[0029] The application performance monitoring method provided in this application embodiment can be applied to the interaction between a terminal device and a server, or it can be software or an application running on the server for monitoring game performance. The terminal, as a client, can run a specified target application software or application, and the server performs game performance monitoring on the target application. In some embodiments, the terminal can be a smartphone, tablet, laptop, desktop computer, etc.; the server can be configured as an independent physical server, a server cluster or distributed system composed of multiple physical servers, or a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, CDN, and big data and artificial intelligence platforms; the software can be an application implementing the application performance monitoring method, but is not limited to the above forms.

[0030] This application can be used in a wide variety of general-purpose or special-purpose computer system environments or configurations. Examples include: personal computers, server computers, handheld or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable consumer electronics devices, network PCs, minicomputers, mainframe computers, and distributed computing environments including any of the above systems or devices. This application can be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform specific tasks or implement specific abstract data types. This application can also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0031] Reference Figure 1 , Figure 1 This application provides a flowchart of an application performance monitoring method, which includes, but is not limited to, steps S101 to S104: Step S101: Obtain the resource configuration file of the character model in the target application; Step S102: Perform model resource analysis and calculation on the resource configuration file to obtain model resource data; Step S103: Perform data report generation processing on the model resource data to obtain an application performance report; Step S104: Perform performance optimization processing on the role model based on the application performance report to obtain the optimization result.

[0032] This application embodiment can be applied to the interaction scenario between client 105 and server 106. The client can be a computer device such as a mobile terminal or personal computer. The server monitors and processes the target application running on the client, obtains the application performance report and returns it to the client for display to the target object. It can also automatically optimize the performance of the character model in the target application based on the application performance report, thereby improving the automated processing capability of the game software.

[0033] Specifically, this application embodiment can acquire data from the target application running on the terminal device by deploying a monitoring platform on the server side or by pre-deploying a resource acquisition interface on the terminal device. By acquiring the resource configuration files of the character models in the target application, this application embodiment can analyze and calculate the model resource data in the resource configuration files, thereby monitoring model resource data closely related to game performance. By monitoring this model resource data, this application embodiment can directly analyze the game performance of the target application based on the monitored data. This application embodiment can also combine artificial intelligence technology to generate a visualized application performance report by processing the model resource data into a data report. This application embodiment can display the application performance report through the client's interactive interface, allowing developers to more clearly and directly understand changes or problems in game performance. Furthermore, this application embodiment can also perform performance optimization processing on the corresponding character models in the target application based on the application performance report, improving the automation level of game performance optimization. Automated game performance optimization can improve the user experience and is applicable to application fields such as animation and game production engine software and development systems, game and animation software, animation, and game digital content services.

[0034] In step S101 of some embodiments, the resource configuration file of the character model in the target application is obtained.

[0035] Specifically, the target application refers to game software or other applications running on a terminal device. The terminal device can include smartphones, laptops, desktop computers, and other devices capable of running game software. Taking game software as an example, a character model refers to a virtual entity controlled or interacted with by the player in the game, including player characters, NPCs (non-player characters), enemies, etc., with independent visual representation, behavioral logic, and attribute settings. A resource configuration file refers to a data file that stores the various resource definitions and parameter settings of the character model, including but not limited to model files, material files, skeleton files, animation files, and configuration files.

[0036] In practical applications, embodiments of this application can set up event listeners on the server side. When the target application runs on the terminal device, the corresponding resource configuration files can be obtained through the event listeners. Embodiments of this application can analyze the engine type used by the target application to browse the game installation directory, locate folders and packaged files that may contain character resources, and thus obtain the resource configuration files. In some embodiments, the resource configuration files are obtained by extracting the main character resource configuration files from a target application developed using the Unity engine, locating the folder under the game installation directory based on the game engine, identifying character model-related files by resource name and preview, and exporting the files using the corresponding data acquisition interface.

[0037] For example, when the target is a developer, the developer can run the target application on the client and monitor the performance of the target application through the server. The server can obtain the resource configuration file of the target application in real time, thereby analyzing the resource configuration file and improving the efficiency of game performance monitoring. It is conceivable that this application embodiment can set a timer to perform periodic monitoring of the target application, or set specific events to monitor the target application, for example, monitoring can be performed when the application scenario or character model state of the target application changes. Specifically, the resource configuration file of the character model can be obtained periodically, and the resource configuration file of the character model after the state transition can also be obtained when the character model changes from a static state to a dynamic state. This application embodiment avoids the performance overhead of per-frame calculation by establishing a performance monitoring cycle and performing comprehensive analysis periodically (e.g., every 2-5 seconds). Simultaneously, an event-based triggering mechanism is set up to immediately recalculate when character creation, destruction, or significant state changes are detected. The client includes the ability to run the target application and perform human-computer interaction through the game page or interface of the target application, while the server is a platform for monitoring the performance of the target application.

[0038] Please see Figure 2 In step S102 of some embodiments, the process of performing model resource analysis and calculation on the resource configuration file to obtain model resource data includes: Step S201: Perform file format recognition processing on the resource configuration file to obtain the file format; Step S202: Perform structural parsing processing on the resource configuration file according to the file format to obtain a parsed file; Step S203: Extract character model data from the parsed file to obtain the model resource data; the model resource data includes the number of model faces, bone data, binding configuration data, and inverse dynamics component data.

[0039] Specifically, the resource configuration file is a data file that stores the resource definitions and parameter settings of the character model, used for analyzing the resource data of the character model. The file format refers to the format of the resource configuration file, which can include ZIP, RAR, PAK, YAML, etc. Since the resource configuration file format can be diverse, it is necessary to identify the file format of the resource configuration file and then perform structural parsing processing according to different file formats to obtain a parsed file. The parsed file is the file after decompression and analysis of the resource configuration file. The character model refers to the model corresponding to the character model in the game. This character model is created through steps such as concept art design, model building, texture baking, skeletal skinning, and animation production. Model resource data refers to the resource data used in the character model construction process, including model polygon count, bone data, rigging configuration data, and inverse kinematics component data. Among these, the model facets refer to the number of triangles that make up the surface of the 3D model, determining the model's geometric accuracy and rendering load; skeletal data defines the skeletal hierarchy of the character animation, including parent-child relationships between bones, initial poses, and transformation information; rigging configuration data establishes the weight associations between bones and model vertices, controlling the smooth deformation of the model during skeletal movement; and inverse kinematics component data stores algorithm parameters for automatically calculating joint rotations based on target positions, used to achieve natural pointing of limbs, head, and other parts of the character and realistic animation of their interaction with the environment. These data collectively constitute the technical foundation of the character animation system, supporting the visual performance and movement behavior of the character model from four dimensions: rendering complexity, skeletal structure, skinning deformation, and intelligent motion.

[0040] In this embodiment, the server receives resource configuration files for all character models in the target application through a monitoring platform. The server then performs file format recognition processing on the resource configuration files to obtain their file formats. These resource configuration files can include various file types and different file formats. This embodiment identifies the file formats of the resource configuration files and performs structural parsing processing, obtaining parsed files through decompression and other methods. Finally, by extracting character model data from the parsed files, the server obtains the model face count, skeletal data, binding configuration data, and inverse kinematics component data corresponding to the character model. These model resource data are closely related to the performance of the character model. For example, the model face count affects GPU rendering performance; an increase in face count leads to a higher number of GPU rendering operations, thus increasing rendering time. Skeletal data affects the character's computational logic; an increase in skeletal data increases the complexity of calculating the character model's motion state, directly leading to a decrease in game performance. Therefore, this embodiment obtains model resource data by performing model resource analysis and calculation processing on the resource configuration files, enabling direct monitoring of model resource data and thus improving the efficiency of game performance monitoring.

[0041] In step S201 of some embodiments, the resource configuration file is subjected to file format recognition processing to obtain the file format.

[0042] In this embodiment, the resource configuration file undergoes file format identification processing. Its core principle is to accurately determine its true format by parsing the file's internal characteristic data, rather than relying solely on the file extension. This processing typically begins by reading the file's binary signature, i.e., the specific magic number in the file header, and matching it against a known format database. Simultaneously, it analyzes the file's overall structure, such as the layout of data blocks, indexing methods, and string encoding, to identify whether it is a general standard format or a specific engine-specific format. For compressed or encrypted files, further detection of the compression algorithm or encryption method is required. Finally, this embodiment outputs the file format of the resource configuration file by comprehensively analyzing all these features.

[0043] For example, in a game resource analysis scenario, this application embodiment obtains the resource configuration file of the character model through a monitoring platform. The file header of this resource configuration file can be viewed using a hexadecimal editor, and the characters corresponding to the starting bytes of the file header can be translated to determine the type of the obtained resource configuration file. Then, its structure is further analyzed to identify the data segment containing serialized objects and directory information used for resource location, thus confirming the complete format of the resource configuration file. Subsequently, a dedicated unpacking tool can be used for resource extraction.

[0044] In step S202 of some embodiments, the resource configuration file is subjected to structural parsing processing according to the file format to obtain a parsed file.

[0045] In this embodiment, the resource configuration file is structurally parsed based on the identified file format. Specifically, internal information is extracted by decoding the specific data organization structure of the format, thereby obtaining a parsed file. First, according to the file format specification, the metadata in the file header is located and interpreted to obtain key parameters such as version information, data block layout, and index table location. Then, according to the serialization rules defined in the format, the data segments in the file are deconstructed layer by layer, converting binary or encoded data into readable structured information, such as model meshes, texture references, bone hierarchies, or animation keyframes. Finally, by verifying data integrity and reconstructing internal reference relationships, a parsed file containing all extracted resource components and their interrelationships is generated.

[0046] For example, in a game resource analysis project, this embodiment of the application, after confirming the file format of the target file, launches a dedicated structure parsing tool. This tool first reads the file header, locates the export table and name table, and then, according to the game engine's serialization rules, progressively extracts the static mesh data, material instance parameters, and bone mesh references. During the parsing process, the tool successfully reconstructs the soft reference relationships between materials and textures and converts the bone hierarchy and skinning weight information into a standard JSON structure. Finally, it generates a parsing file containing a complete resource tree, attribute list, and dependencies, which can be directly used for subsequent performance analysis and resource optimization.

[0047] One of the above technical solutions has the following advantages or beneficial effects: The embodiments of this application obtain model resource data by performing model resource analysis and calculation on the resource configuration file. Based on the model resource data, the game performance can be directly monitored, and the game performance can be improved by adjusting the model resource data, thereby improving the accuracy and efficiency of game performance monitoring.

[0048] Please see Figure 3 In step S203 of some embodiments, the step of extracting character model data from the parsed file to obtain the model resource data includes: Step S301: Perform model localization processing on the character model according to the parsed file to obtain the target model; Step S302: Extract and calculate the vertex data and face index data of the target model to obtain the number of faces of the model; Step S303: Perform bone hierarchy analysis and bone node recognition processing on the target model based on the skinned mesh component to obtain the bone data; Step S304: Based on the skeletal data, identify and process the skeletal binding constraints of the target model to obtain the binding configuration data; Step S305: Analyze and process the animation blueprint and state machine of the target model to obtain the inverse dynamics component data.

[0049] Specifically, this application embodiment performs character model data extraction processing on the parsed file to extract model resource data, which includes model face count, skeleton data, rigging configuration data, and inverse kinematics component data. This application embodiment can locate the character model in the target application by analyzing the parsed file, obtaining the corresponding target model. Then, feature extraction processing is performed based on the target model to obtain the corresponding model resource data.

[0050] In step S301 of some embodiments, the character model is subjected to model localization processing according to the parsed file to obtain the target model.

[0051] Specifically, a parsed file refers to processed structured data containing detailed information about game resources. A character model is a virtual entity in the game with independent identity, appearance, and behavior; its complete representation is defined by various resources such as models, skeletons, animations, and materials. A target model is a character model corresponding to a specific game character, obtained through localization processing. This target model is constructed from the 3D mesh data of the visual subject of the specific game character and its directly associated resources, such as materials and textures.

[0052] In this embodiment, candidate models are first screened based on role identifiers or resource naming rules in the parsed resource structure; then their dependencies are analyzed, and all associated bone, material, and texture resources are traced and confirmed to ensure the integrity of the resource chain; finally, through uniqueness verification and resource binding status checks, a target model that can be imported into a game engine or 3D editing software is generated.

[0053] In step S302 of some embodiments, the vertex data and face index data of the target model are extracted and calculated to obtain the number of faces of the model; Specifically, the target model refers to the character model of the corresponding game character obtained through localization processing, which is the specific 3D mesh object currently selected for resource analysis. Vertex data refers to the set of geometric attributes stored in the model data buffer, used to describe the points in 3D space. Each vertex typically includes, but is not limited to, its position coordinates in the coordinate system, and may also include normal vectors, texture coordinates, etc. Face index data refers to the list of vertices that define the order of a polygon facet (usually a triangle), which is a sequence of integer indices pointing to specific positions in the vertex data array. Model face count refers to the total number of triangular faces contained in the target model, which is a key performance indicator used to measure the geometric complexity of the model and evaluate the rendering load.

[0054] In this embodiment, the mesh data resource of the target model is first accessed. By obtaining the component in the Unity engine and accessing its vertex array and triangle index array properties, vertex position data and face index data are extracted. Then, a calculation is performed on the extracted face index data array, and the value is divided by 3. Because each triangle is precisely defined by 3 indices, the quotient is the total number of triangles in the model, i.e., the number of faces in the model. It should be noted that this embodiment can also verify the process of calculating the number of faces by checking whether the array length is divisible by 3. If it is, the calculation result is output as the number of faces in the model; if not, a data format exception is thrown, indicating that the model data may contain corrupted or unsupported topological structures.

[0055] In step S303 of some embodiments, the target model is subjected to skeletal hierarchy analysis and skeletal node identification processing based on the skinned mesh component to obtain the skeletal data; Specifically, a skinned mesh component refers to a rendering component in a 3D graphics system that associates mesh vertices with the skeletal system. It contains mesh data, bone references, and skinning weight information, used to achieve model deformation based on skeletal animation. This application's embodiment constructs a tree-like topology of the skeletal system by parsing the parent-child relationship chain between bones, thereby clarifying the relative position and dependencies of each bone node in the hierarchy. Furthermore, by extracting bone transformation nodes from the skinned mesh component, identifying their types (such as root bones, limb bones, end effectors, etc.), and establishing unique identifiers, bone data is obtained. Here, bone data refers to a structured set of bone information obtained after analysis and processing, including core parameters such as the number of bones, hierarchical relationships, node attributes, binding pose, and transformation matrix.

[0056] In this embodiment, the bone transformation reference array is extracted from the skinned mesh component. For example, by performing bone data analysis on the SkinnedMeshRender component of a character model in the Unity engine, all bone nodes directly involved in skinning are obtained. Then, by recursively traversing the parent-child relationships of these bone nodes, a complete bone hierarchy tree is constructed, the root bone is identified, and the depth and path of each bone in the hierarchy are determined. Next, the transformation attributes, naming patterns, and functional characteristics of each bone node are analyzed, and they are classified and labeled (such as identifying the spinal chain, limb chain, finger bones, etc.). At the same time, the binding pose matrix and local transformation matrix of the bones are extracted, and their relationship with the model space and bone space is calculated. Finally, all analysis results are integrated into a structured bone data set containing complete information such as the number of bones, hierarchical structure, node type, and transformation data.

[0057] In step S304 of some embodiments, the skeletal binding constraints of the target model are identified and processed according to the skeletal data to obtain the binding configuration data; Specifically, skeletal data refers to a structured set of information containing the skeletal hierarchy, node attributes, transformation matrices, and rigging poses, used to describe the skeleton system of a character model. Skeletal rigging constraints refer to the rules and parameters that limit the range of motion of bones in a skeletal animation system, including rotational constraints, positional constraints, parent-child relationship constraints, IK constraints, and other boundary conditions that control skeletal behavior. This application's embodiments analyze skeletal data and model structure to automatically detect, classify, and extract various constraint types to obtain rigging configuration data. Here, rigging configuration data refers to a set of structured constraint information obtained after identification and processing, containing configuration information such as all detected constraint types, parameter settings, scope of application, and constraint strength.

[0058] In this embodiment, by analyzing the parent-child relationships and transformation data in the skeletal hierarchy, inherent constraints based on the hierarchy can be identified, including parent-child transformation propagation rules and continuity constraints of the skeletal chain. Then, this embodiment detects local rotational limitations of the bones by analyzing the Euler angle range or four-quadrant constraint parameters of the bones, identifying the motion boundaries of each bone on the pitch, yaw, and roll axes. Next, special markers and attribute data in the skeletal system are scanned to identify advanced constraint types such as IK constraints, polar vector constraints, and target point constraints, and the corresponding target bones, weight parameters, and solver settings are extracted. Simultaneously, the spatial relationships and collision volumes between bones are analyzed to detect physical constraints and collision avoidance mechanisms. Finally, all identified constraint information is structured according to type, scope, and parameter strength to generate a complete binding configuration data set.

[0059] In step S305 of some embodiments, the animation blueprint and state machine of the target model are analyzed and processed to obtain the inverse dynamics component data.

[0060] Specifically, an animation blueprint refers to a visual programming system in a game engine used to control character animation logic. It includes a state machine, blending space, and animation node network, and is responsible for managing animation playback, blending, and transitions. A state machine is the logical framework in an animation system that manages different animation states and their transition conditions, consisting of state nodes, transition rules, and parameter drivers. This application embodiment extracts, identifies, and interprets inverse dynamics component data by analyzing the data structures of the animation blueprint and state machine. The inverse dynamics component data refers to the structured IK system information obtained after analysis and processing, including core data such as IK chain configuration, solver parameters, objective settings, weight control, and constraints.

[0061] In this embodiment, by parsing the node network structure of the animation blueprint, all inverse dynamics-related nodes are identified, and their connected skeletal chain information, target object references, and weight control parameters are extracted. Then, the state nodes and transition conditions of the state machine are analyzed, the enabling or disabling logic of the IK system is detected, and the changing patterns of IK configuration under different animation states are identified. Next, the variable and parameter system in the animation blueprint is traversed to extract dynamic parameters affecting IK behavior, such as IK weights, target position offsets, and skeletal rotation constraints, and a mapping relationship between parameters and state transitions is established. Simultaneously, the solver configuration of the IK nodes is analyzed, including the number of iterations, tolerance thresholds, rotation constraints, and hybrid settings. Finally, this embodiment integrates all analysis results to construct an inverse dynamics component dataset containing IK chain topology, solving algorithms, state dependencies, and runtime parameters.

[0062] One of the above technical solutions has the following advantages or beneficial effects: By performing character model data extraction processing on the parsed file, the embodiments of this application can extract model resource data, which can provide an accurate data foundation for animation debugging, performance optimization and performance monitoring, and is suitable for reverse engineering and performance analysis scenarios of complex character animation systems.

[0063] Please see Figure 4 In step S103 of some embodiments, the process of generating a data report from the model resource data to obtain an application performance report includes: Step S401: Summarize and statistically process the model resource data to obtain statistical data; Step S402: Compare and process the statistical data according to the preset model resource threshold to obtain the out-of-standard model; Step S403: Perform performance analysis on the model resource data of the out-of-standard model to generate optimization suggestions; Step S404: Visualize the statistical data to obtain a visual chart; Step S405: Generate the application performance report based on the optimization suggestions and the visualization charts.

[0064] In this embodiment, model resource data refers to a set of structured technical indicators extracted from the character model, including quantitative parameters such as face count, bone count, material complexity, texture memory usage, and animation data volume. This embodiment transforms the raw model resource data into a structured, readable document or visually displayed data through analysis, calculation, classification, and organization to obtain an application performance report. The application performance report is a comprehensive technical document generated based on model resource data analysis, containing performance evaluation, bottleneck identification, optimization suggestions, and trend predictions, used to guide technical decisions and resource optimization.

[0065] In step S401 of some embodiments, the model resource data is summarized and statistically processed to obtain statistical data; Specifically, model resource data refers to the set of raw technical indicators extracted from the character model, including dispersed quantitative parameters such as face count, vertex count, bone count, material quantity, texture size, and memory usage. This application's embodiments convert the dispersed raw model resource data into statistically significant comprehensive data indicators through aggregation, classification, calculation, and analysis, thus obtaining statistical data. The statistical data refers to a structured data set obtained after summary statistical processing, containing statistical information such as total indicators, average values, distribution characteristics, trend analysis, and comparative relationships.

[0066] In some feasible embodiments, this application establishes a unified data collection framework, extracts standardized fields from various model resource files to ensure data format consistency and comparability; then, it applies data aggregation algorithms to classify and summarize data according to dimensions such as model type, scenario purpose, and performance level, calculating the total amount, average value, extreme value, and distribution characteristics of each category; next, it employs statistical analysis techniques, including analysis of variance, correlation calculation, and cluster identification, to reveal the inherent relationships and distribution patterns among the data; simultaneously, it constructs a time series analysis model to track the changing trends and evolution patterns of resource data; finally, through data reduction and feature extraction, it refines massive amounts of raw data into core statistical indicators, generating a complete statistical data set that includes descriptive statistics, comparative analysis, trend prediction, and anomaly detection.

[0067] In step S402 of some embodiments, the statistical data is compared and processed according to a preset model resource threshold to obtain an out-of-standard model; Specifically, model resource thresholds refer to the upper limits of various model resource indicators pre-set based on target platform performance standards, project technical specifications, and best practices, including face count thresholds, skeleton count thresholds, and memory usage thresholds. Statistical data refers to the set of model resource data obtained after aggregation and statistical processing, containing quantitative indicators and classification information for each model. This application embodiment systematically compares and analyzes the various model resource indicators in the statistical data set with preset thresholds to identify abnormal situations exceeding the allowable range, thus obtaining out-of-standard models exhibiting abnormalities. Among these, out-of-standard models refer to model instances identified during the comparison process where at least one key resource indicator exceeds the preset threshold, requiring focused attention and optimization.

[0068] In some feasible embodiments, different resource limitation standards are set for different model types, such as game protagonists, non-player characters, and environmental objects, and for different platforms, such as consoles and mobile devices. Then, each model instance in the statistical data is traversed, and its key performance indicators, such as the number of model faces, the number of bones, texture memory, and the number of materials, are compared one by one with the preset thresholds for the corresponding type. For each exceeding indicator, the exceeding range and severity level are calculated, and the specific exceeding value and relative percentage are recorded. Next, a composite judgment logic is applied to identify serious problem models with multiple indicators exceeding the limit at the same time, as well as edge cases with only slight exceeding of a single indicator. At the same time, considering the scene importance and usage frequency of the model, a stricter threshold standard is adopted for key role models. Finally, all identified exceeding models are summarized and classified and sorted according to the severity of exceeding the limit, the urgency of optimization, and the scope of impact to generate a structured exceeding model.

[0069] Please see Figure 5 In step S403 of some embodiments, the performance analysis processing of the model resource data of the out-of-standard model to generate optimization suggestions includes: Step S501: Calculate the rendering complexity and computational logic complexity of the model resource data of the over-standard model to obtain a complexity score. Step S502: Perform resource association analysis on the over-standard model based on the complexity score to obtain the analysis results; Step S503: Input the analysis results into a large language model for natural language analysis and processing to generate optimization suggestions.

[0070] Specifically, an out-of-limit model refers to a model instance identified in a resource threshold comparison where at least one key performance indicator exceeds a preset limit. Model resource data refers to the specific resource data set of the out-of-limit model, including detailed model facet distribution, skeleton hierarchy, material configuration, texture usage, and other model resource data. This application embodiment, through in-depth technical analysis of the resource data of the out-of-limit model, can identify the root causes of performance bottlenecks, assess optimization potential, and obtain corresponding optimization suggestions. These optimization suggestions refer to targeted improvement schemes generated based on the performance analysis results, including specific technical measures, expected performance, and implementation priorities.

[0071] In this embodiment, each out-of-specification model undergoes multi-dimensional in-depth analysis. This analysis identifies high-density geometric regions by analyzing facet distribution characteristics, examines the skeletal hierarchy to find redundant or overly complex skeletal chains, and evaluates material and texture usage efficiency to detect duplicate or unoptimized resources. Then, based on model type, usage scenario, and performance exceedance level, an optimization rule engine is applied to match the most suitable technical solution. Next, the expected effects of each optimization measure are calculated, including the facet reduction ratio, memory savings, and performance improvement estimates. Simultaneously, the implementation costs and risks of the optimization solution are assessed, balancing visual effects and performance requirements. Finally, a structured optimization suggestion report is generated, including problem diagnosis, specific measures, implementation steps, and priority ranking.

[0072] In step S501 of some embodiments, the rendering complexity and computational logic complexity of the model resource data of the over-standard model are calculated to obtain a complexity score. Specifically, an over-standard model refers to a 3D model that exceeds a preset threshold in terms of rendering performance or computational resource consumption, typically manifested as an excessive number of polygons, excessively high texture resolution, or an overly complex material system. Model resource data refers to the collection of various resources constituting a 3D model, including but not limited to geometric data, texture maps, material parameters, skeletal animation data, and shader programs. Rendering complexity is a quantitative indicator used to measure the degree of hardware resource consumption of a model in the graphics rendering pipeline. The main influencing factors include the number of vertices, pixel fill rate, texture sampling times, and shader instruction complexity. This application's embodiments assess the model's computational resource usage in non-rendering stages, including the computational load of processes such as physical simulation, skeletal transformation, skinning calculation, and dynamic deformation, to obtain a complexity score. The complexity score is a comprehensive evaluation value obtained by weighting rendering complexity and computational logic complexity using a specific algorithm, used to quantify the overall resource requirement level of the model.

[0073] In some feasible implementations, when calculating the complexity of model resource data for out-of-specification models, the geometric data structure of the model is first analyzed, and the number of vertices and triangles is counted as basic parameters for rendering complexity. Simultaneously, the shader code in the material system is analyzed, and the number of texture sampling instructions and arithmetic logic instructions is counted using static analysis techniques as an evaluation basis for shader complexity. For calculating computational logic complexity, the skeletal animation data of the model is analyzed, and the computational load of the animation system is evaluated based on the number of bone nodes and the number of transformation matrices to be calculated per frame. The computational requirements of the physics simulation are quantified by combining the complexity of the physical colliders and the number of constraints. Finally, the rendering complexity parameters and computational logic complexity parameters are normalized separately and then weighted and fused according to a 6:4 weight ratio to generate a standardized complexity score ranging from 0 to 1. When this score exceeds a threshold of 0.7, the system automatically marks the model as a high-complexity resource requiring optimization.

[0074] In step S502 of some embodiments, resource association analysis is performed on the over-standard model based on the complexity score to obtain the analysis results; Specifically, this application embodiment uses complexity scores to perform systematic correlation analysis on various resources on which the over-standard model depends, identify the dependencies between resources, performance bottlenecks and optimization priorities, and obtain structured data output after correlation analysis, including key analysis conclusions such as resource dependency graphs, bottleneck location information and optimization suggestion priorities.

[0075] In some feasible embodiments, when performing resource association analysis on models exceeding the complexity score, this application decomposes the complexity score into various resource component dimensions by establishing a model resource dependency graph: For models with high rendering complexity, the focus is on analyzing high-resolution texture maps in their material system, such as diffuse maps above 4K, and complex shader programs, such as shaders containing multi-lighting models and real-time reflection calculations, as well as subdivision surface parameters; for models with high computational logic complexity, the analysis delves into the skeletal chain hierarchy depth of their skeletal animation system, the mesh accuracy of physical colliders, and the number of emitters in their real-time particle system. This application uses a dependency tracking algorithm to construct a complete resource call chain from basic geometric data to the final rendering output, identifying high-frequency resources shared among multiple model instances, such as general-purpose material spheres and common texture sets, as well as model-specific resources, such as custom shaders and specific animation sequences. The final analysis results include: a resource performance impact weight matrix, a cross-model resource sharing relationship graph, and a list of improvement suggestions sorted by optimization benefits, such as downsampling the 2048x2048 diffuse map to 1024x1024, replacing complex surface subdivision with normal map simulation, and reducing the number of bones from 87 to 45. The expected reduction in complexity score is estimated for each optimization item, forming a complete resource optimization roadmap.

[0076] In step S503 of some embodiments, the analysis results are input into a large language model for natural language analysis processing to generate optimization suggestions.

[0077] Specifically, a large language model refers to an artificial intelligence system trained on massive amounts of text data, capable of understanding and generating natural language text, and possessing capabilities such as semantic understanding, knowledge reasoning, and content generation. This application's embodiments convert structured data into natural language descriptions, utilize the reasoning capabilities of the large language model to identify problem patterns and analyze causal relationships, and generate text output that conforms to technical logic, thus obtaining optimization suggestions. These optimization suggestions refer to specific, actionable technical improvement schemes and implementation paths proposed for specific problems based on professional knowledge and best practices.

[0078] In some feasible implementations, the structured data obtained from resource correlation analysis is converted into natural language descriptions, clearly annotating the specific values ​​and interrelationships of key performance indicators. Based on the 3D graphics optimization knowledge and performance tuning patterns learned during training, the large language model performs deep semantic understanding on the input analysis results, identifying the core contradictions in resource usage, such as excessive face count leading to long rendering times. Combined with the application scenario context of the model, such as the target platform being a mobile VR device, it generates targeted hierarchical optimization suggestions: including high-priority optimization items to be executed immediately, downsampling shared 4K environment maps to 2K and establishing texture maps, providing mid-term architecture adjustment suggestions, such as migrating the CPU-based skeleton calculation part to GPU computing shaders, and establishing a LOD-based streaming loading mechanism for long-term technical improvement directions. At the same time, the large language model also estimates the expected performance improvement and possible visual quality loss of each optimization measure, forming a complete technical trade-off analysis report to provide decision support for the development team.

[0079] One of the above technical solutions has the following advantages or beneficial effects: This application embodiment generates optimization suggestions by performing performance analysis on the model resource data of the out-of-standard model, which can evaluate the rendering complexity and computational logic complexity of the model, and provide corresponding optimization suggestions through a large language model, thus providing decision support for game performance monitoring.

[0080] In step S404 of some embodiments, the statistical data is visualized to obtain a visual chart; Specifically, statistical data refers to the structured data set of model resources obtained after aggregation and statistical processing, including statistical information such as total indicators, average values, distribution characteristics, and trend analysis. This application embodiment visually displays abstract statistical data using visual elements such as graphics, charts, colors, and sizes, resulting in visualized charts. Here, visualized charts refer to graphical data displays generated through visualization processing, including various statistical charts, heatmaps, distribution maps, and other visual representations.

[0081] In some feasible implementations, the most suitable visualization format is determined by analyzing the type and characteristics of statistical data, including selecting chart type, color scheme, and layout structure. Then, a mapping rule from data to visual elements is established, converting numerical values ​​into visual attributes such as graphic size, color intensity, and position coordinates. Next, data visualization algorithms are applied to generate basic charts, including standard statistical charts such as bar charts, pie charts, scatter plots, and box plots. Simultaneously, interactive functions are enhanced, including support for user operations such as data filtering, detailed display, zooming, and panning. Finally, visual optimization and layout adjustments are performed to ensure that the charts are clear and easy to read, with reasonable information density, and output files in multiple formats are generated to adapt to different usage scenarios.

[0082] Step S405: Generate the application performance report based on the optimization suggestions and the visualization charts.

[0083] Specifically, optimization suggestions refer to targeted improvement plans generated based on performance analysis of the out-of-specification model, including specific technical measures, expected performance, and implementation priorities. Visualization charts refer to graphical data displays generated through visualization processing, including statistical charts, heatmaps, distribution maps, and other visual representations. This application embodiment integrates optimization suggestions and visualization charts to generate a comprehensive technical document, namely an application performance report, which can provide complete analysis, diagnosis, and solutions for game performance optimization.

[0084] In some feasible implementations, a report structure framework is established to organically integrate the technical details of optimization suggestions with the intuitive presentation of visual charts. Then, a data-driven narrative logic is applied, using visual charts as supporting evidence to guide readers in understanding the severity and distribution characteristics of performance issues. Next, specific optimization suggestions are directly linked to corresponding chart data to ensure that each suggestion has clear data support. Simultaneously, an execution summary and key findings are generated to extract core information for decision-makers to quickly grasp the key points. Finally, all analysis content, optimization schemes, and visual evidence are integrated to generate a comprehensive performance report that is structurally complete, logically clear, and highly operable, and provides multiple output formats to adapt to different use cases.

[0085] One of the above technical solutions has the following advantages or beneficial effects: This application embodiment generates an application performance report by processing model resource data into a data report. This transforms technical optimization suggestions and abstract visual charts into a comprehensive performance report with practical guidance, providing game development teams with complete technical guidance from problem diagnosis to solutions. By generating an application performance report, this application embodiment helps the team understand the current performance status. More importantly, it provides a clear optimization path and measurable improvement goals, ensuring that performance optimization work can be systematically and data-driven.

[0086] Please see Figure 6 In step S104 of some embodiments, the performance optimization process of the role model based on the application performance report to obtain the optimization result includes: Step S601: Determine the model resource data to be adjusted based on the application performance report; Specifically, the application performance report refers to a comprehensive analysis document collected and generated through performance monitoring tools, containing key performance indicators such as frame rate curves, peak memory usage, GPU load distribution, and number of draw calls. The model resource data to be adjusted refers to the set of model resources identified through performance analysis that have a significant negative impact on game performance; these are the target resources that need to be prioritized for optimization.

[0087] In some feasible embodiments, this application can locate high-complexity models with rendering times exceeding 2ms by analyzing the correlation between peak GPU load periods in performance reports and model rendering times in the scene; identify memory surges caused by excessively large model resources by comparing the timing relationship between memory usage curves and resource loading events; and locate model resources with too many material instances that cannot be batched by analyzing specific cases of batch merging failures in rendering call statistics. The system uses a weighted scoring algorithm to comprehensively consider the severity and impact of each performance indicator, calculates a performance impact score for each model resource, and selects the top 20% of models with scores exceeding a threshold as high-priority resources to be adjusted. At the same time, it combines resource usage frequency analysis to ensure that optimization work focuses on frequently used core resources rather than peripheral content, and finally generates a list of model resources to be adjusted that includes specific model names, performance bottleneck descriptions, and recommended optimization directions.

[0088] Step S602: Optimize the resource data of the model to be adjusted according to the application scenario, operating environment and interaction behavior of the target application to obtain the optimization result.

[0089] Specifically, the application scenario refers to the specific environmental settings in the game, including indoor and outdoor scenes, lighting conditions, viewing distance, and the number of models on screen simultaneously—environmental factors affecting rendering requirements. The runtime environment refers to the target hardware platform configuration for the game, including hardware limitations such as GPU performance, video memory capacity, CPU processing power, and RAM size. Interactive behavior refers to the way players interact with game models, including operational modes affecting model detail requirements such as viewing distance, interaction frequency, and viewing angle change speed. This application's embodiments, based on multi-dimensional constraints, make targeted adjustments to model resource data to balance visual quality and performance, resulting in optimized results. The optimized results refer to the model resource dataset that achieves the best balance between performance and quality in a specific scenario environment after systematic optimization processing.

[0090] In some feasible embodiments, this application establishes a hierarchical optimization strategy based on scene type: for architectural models in distant scenes, an aggressive polygon simplification algorithm is used to reduce the number of triangles from 150,000 to 30,000, while downsampling the 2048×2048 texture map to 512×512; for close-up prop models where the main character frequently interacts, the original number of faces is retained, but instantiation rendering technology is enabled to reduce drawing calls. To address hardware limitations in the runtime environment, the complexity of the material system is dynamically adjusted based on GPU performance testing results. Real-time reflection and tessellation effects are disabled on low-end mobile devices, and PBR material spheres are replaced with simplified Blinn-Phong shaders; texture streaming is intelligently managed based on video memory capacity, establishing a mipmap-based texture chain and a view distance-based texture resolution switching mechanism. Combined with interactive behavior analysis, complete skeletal animation data and facial expression fusion systems are retained for frequently interacting character models, while pre-baked animations are used instead of real-time skeletal calculations for environmental decorations. The final optimization result is a set of model resources that has been adapted to the scene, matched the hardware, and balanced the interaction requirements. On the target platform, the frame rate has been steadily increased from 45fps to 60fps, memory usage has been reduced by 40%, and the visual fidelity of the core game experience has been guaranteed.

[0091] One of the above technical solutions has the following advantages or beneficial effects: The embodiments of this application optimize the model resource data to be adjusted according to the application scenario, operating environment and interactive behavior of the target application, and can adjust the model resource data of the character model in a targeted manner according to the game performance monitoring effect, thereby improving the efficiency of performance optimization.

[0092] Please see Figure 7 In some embodiments, before obtaining the resource configuration file of the character model in the target application, the method includes establishing a model resource threshold, including: Step S701: Perform scenario analysis processing on the target application to obtain the application scenario and operating environment; Specifically, this application embodiment uses automated tools and algorithms to systematically detect and analyze the environmental characteristics, resource usage patterns, and performance characteristics of a game during runtime, thereby obtaining the application scenario and runtime environment of the target application. The application scenario refers to the specific set of environmental characteristics during game runtime, including environmental factors affecting performance such as scene type, lighting conditions, field of view, number of entities on screen, and effect density. The runtime environment refers to the hardware and software platform configuration upon which the game execution depends, including technical parameters such as GPU model and memory capacity, CPU core count and frequency, memory size, operating system version, and graphics API type.

[0093] In some feasible implementations, a performance analysis module integrated into the game engine automatically collects scene feature data during game execution: a scene graph traversal algorithm is used to count the number of model instances and the total number of triangles rendered on screen simultaneously; a lighting calculator analyzes the number of real-time light sources and shadow mapping resolution; and frustum detection determines the density of visible entities within the player's field of view. Simultaneously, a runtime environment analysis component obtains hardware configuration information via system APIs, including the number of GPU shader cores and memory bandwidth, the number of CPU physical cores and single-core performance, and memory capacity and frequency parameters. This information is then combined with graphics API feature detection to construct a complete runtime environment profile. The system inputs the collected raw data into a scene classification model, which automatically identifies high-load scenes in the game based on machine learning algorithms. Examples include city centers in open worlds, boss battle scenes with complex particle effects, and regular scenes such as indoor dialogue scenes and simple geometric areas. A correspondence between scene types and performance indicators is established, and a comprehensive analysis report including scene complexity scores, hardware bottleneck analysis, and performance prediction models is output, providing accurate scene and environment data for subsequent resource optimization.

[0094] Step S702: Perform performance analysis on the operating environment to obtain terminal performance data; In this embodiment, when performing performance analysis on the operating environment, a standardized benchmark test suite is first executed: by running a series of pre-made rendering scenes with increasing complexity, the frame time curves are recorded and analyzed to calculate the stable average frame rate and frame rate fluctuation variance of the environment. Simultaneously, a specific compute shader program is used to perform general computing capability tests to evaluate the GPU's parallel floating-point operation capabilities. Next, the system undergoes resource stress testing: by continuously loading high-resolution textures and complex models until system warnings or severe stuttering are triggered, the upper limits of the environment's video memory and system memory capacity are detected; by analyzing the CPU rendering thread consumption and GPU idle time under different rendering batch numbers, the bottleneck in rendering call throughput is evaluated to determine whether it is CPU-limited or GPU-limited. Finally, all test results are combined to generate structured terminal performance data. This dataset not only includes hardware specifications but, more importantly, its quantified capability indicators, such as: "Recommended number of triangles per frame: <1.5M", "Recommended maximum texture resolution: 2048x2048", "Supports complex post-processing effects: Yes", and "Main bottleneck: GPU fill rate". This data will provide precise and actionable decision-making basis for subsequent resource optimization.

[0095] Step S703: Perform threshold definition processing on the model resource data of the role model according to the application scenario and the terminal performance data to obtain the model resource threshold.

[0096] In this embodiment, based on the performance requirements of displaying 20+ characters simultaneously in a large-scale battle scene, and considering the GPU's triangle processing capability in terminal performance data (e.g., rendering 150 million triangles per second), the threshold for the number of triangles in a single character model is calculated to be controlled within 50,000. Then, according to the typical distance distribution between characters and the camera in the scene, characters are divided into three detail levels—near, medium, and far—based on viewing distance, with different material complexity and texture resolution thresholds set for each level. Near-view characters are allowed to use four sets of 4K PBR textures and complex skeletal skinning, while far-view characters are limited to one set of 1K textures and simplified vertex animations. Simultaneously, combined with terminal memory capacity and bandwidth data, strict memory usage limits are set for each level of character model. The resulting model resource threshold is a dynamic, multi-level standard system that can automatically adjust according to the complexity of the actual running scene, ensuring smooth operation in performance bottleneck scenarios while providing optimal visual fidelity in resource-rich scenarios.

[0097] This application's embodiments can be applied to animation and game production engine software and development systems, digital cultural product production software, and digital cultural creative software technology fields within the digital creative industry. They are suitable for debugging and development environments of different games on terminal devices and are widely used in interactive scenarios such as game applications. In one feasible embodiment, please refer to... Figure 8 This application embodiment obtains character resource-related configuration tables. For example, for player character resource data, the server obtains model resources for each part of a single character, and then obtains the corresponding resource data through the corresponding components. The SkinnedMeshRender component determines whether the model uses a skinned mesh. If so, the corresponding model face count and model bone count are calculated. If not, the next step is to obtain the configuration files for each part of the character. The Cons Config component obtains the corresponding configuration files. If a binding configuration file exists, the model Rig (binding configuration) count is calculated. Otherwise, the next step is to calculate the model IK count through the LODController component. This accumulates the corresponding character's face count, bone count, Rig count, and IK count. The above steps are iterated until data for multiple characters in the game is obtained, all character data is calculated, and a corresponding data report is generated. By monitoring the data report in real time through a monitoring platform and visualizing the data report, developers can quickly optimize game performance.

[0098] Corresponding to the above method embodiments, this application also provides embodiments of an application performance monitoring system. Figure 9 A schematic diagram of the structure of an application performance monitoring system according to an embodiment of this application is shown. Figure 9 As shown, the application's performance monitoring system includes: The data acquisition module 901 is configured to acquire the resource configuration files of the role models in the target application; Resource analysis module 902 is configured to perform model resource analysis and calculation on the resource configuration file to obtain model resource data; The report generation module 903 is configured to perform data report generation processing on the model resource data to obtain an application performance report; The performance optimization module 904 is configured to perform performance optimization processing on the role model based on the application performance report to obtain the optimization result.

[0099] The above is an illustrative scheme of an application performance monitoring system according to this embodiment. It should be noted that the technical solution of this application performance monitoring system and the technical solution of the application performance monitoring method applied to the application performance monitoring system described above belong to the same concept. Details not described in detail in the technical solution of the application performance monitoring system can be found in the description of the technical solution of the application performance monitoring method described above.

[0100] like Figure 10 As shown, Figure 10 A structural block diagram of an electronic device 1000 according to an embodiment of this application is shown. The components of the electronic device 1000 include, but are not limited to, a memory 1010 and a processor 1020. The processor 1020 is connected to the memory 1010 via a bus 1030, and a database 1050 is used to store data.

[0101] Electronic device 1000 also includes access device 1040, which enables electronic device 1000 to communicate via one or more networks 1060. Examples of such networks include a Public Switched Telephone Network (PSTN), a Local Area Network (LAN), a Wide Area Network (WAN), a Personal Area Network (PAN), or a combination of communication networks such as the Internet. Access device 1040 may include one or more of any type of wired or wireless network interface (e.g., a Network Interface Card (NIC)), such as an IEEE 1002.11 Wireless Local Area Network (WLAN) wireless interface, a Global System for Microwave Access (GSM) interface, or a Wi-Fi interface. MAX interface, Ethernet interface, Universal Serial Bus (USB) interface, Cellular network interface, Bluetooth interface, Near Field Communication (NFC) interface, etc.

[0102] In one embodiment of this application, the above-mentioned components of the electronic device 1000 and Figure 10 Other components, not shown, can also be connected to each other, for example, via a bus. It should be understood that... Figure 10The illustrated electronic device block diagram is for illustrative purposes only and is not intended to limit the scope of this application. Those skilled in the art can add or replace other components as needed.

[0103] Electronic device 1000 can be any type of stationary or mobile electronic device, including mobile computers or mobile electronic devices (e.g., tablet computers, personal digital assistants, laptop computers, notebook computers, netbooks, etc.), mobile phones (e.g., smartphones), wearable electronic devices (e.g., smartwatches, smart glasses, etc.) or other types of mobile devices, or stationary electronic devices such as desktop computers or PCs. Electronic device 1000 can also be a mobile or stationary server.

[0104] The processor 1020 is used to execute computer-executable instructions for the application performance monitoring method.

[0105] The above is an illustrative scheme of an electronic device according to this embodiment. It should be noted that the technical solution of this electronic device and the technical solution of the application performance monitoring method described above belong to the same concept. For details not described in detail in the technical solution of the electronic device, please refer to the description of the technical solution of the application performance monitoring method described above.

[0106] This application embodiment also provides a storage medium, which is a computer-readable storage medium, storing a computer program that, when executed by a processor, implements the above-described application performance monitoring method.

[0107] Memory, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs and non-transitory computer-executable programs. Furthermore, memory may include high-speed random access memory, and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some embodiments, memory may optionally include memory remotely located relative to the processor, and these remote memories can be connected to the processor via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof. The device embodiments described above are merely illustrative, and the units described as separate components may or may not be physically separate, and may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of the embodiments of this application, depending on actual needs.

[0108] It will be understood by those skilled in the art that all or some of the steps and systems in the methods disclosed above can be implemented as software, firmware, hardware, and suitable combinations thereof. Some or all of the physical components can be implemented as software executed by a processor, such as a central processing unit, digital signal processor, or microprocessor, or as hardware, or as an integrated circuit, such as an application-specific integrated circuit. Such software can be distributed on a computer-readable medium, which can include computer storage media (or non-transitory media) and communication media (or transient media). As is known to those skilled in the art, the term computer storage media includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information (such as computer-readable instructions, data structures, program modules, or other data). Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technologies, CD-ROM, digital versatile disc (DVD) or other optical disc storage, magnetic cartridges, magnetic tape, disk storage or other magnetic storage devices, or any other medium that can be used to store desired information and is accessible to a computer. Furthermore, as is known to those skilled in the art, communication media typically include computer-readable instructions, data structures, program modules, or other data in modulated data signals such as carrier waves or other transmission mechanisms, and may include any information delivery medium.

[0109] The above is a detailed description of the preferred embodiments of this application. However, this application is not limited to the above embodiments. Those skilled in the art can make various equivalent modifications or substitutions without departing from the spirit of this application. All such equivalent modifications or substitutions are included within the scope defined by the claims of this application.

Claims

1. A method for monitoring application performance, characterized in that, include: Obtain the resource configuration files for the character models in the target application; The resource configuration file is subjected to model resource analysis and calculation to obtain model resource data; The model resource data is processed to generate a data report, resulting in an application performance report; The role model is optimized based on the application performance report to obtain the optimization result.

2. The method according to claim 1, characterized in that, The process of performing model resource analysis and calculation on the resource configuration file to obtain model resource data includes: The resource configuration file is subjected to file format recognition processing to obtain the file format; The resource configuration file is parsed according to its file format to obtain a parsed file. The parsed file is processed to extract character model data, resulting in the model resource data. The model resource data includes the number of model faces, bone data, rigging configuration data, and inverse dynamics component data.

3. The method according to claim 2, characterized in that, The step of extracting character model data from the parsed file to obtain the model resource data includes: The target model is obtained by performing model localization processing on the parsed file. The vertex data and face index data of the target model are extracted and processed to obtain the number of faces of the model; The target model is subjected to skeletal hierarchy analysis and skeletal node identification processing based on the skinned mesh component to obtain the skeletal data. The skeletal binding constraints of the target model are identified and processed based on the skeletal data to obtain the binding configuration data; The animation blueprint and state machine of the target model are analyzed and processed to obtain the inverse dynamics component data.

4. The method according to claim 1, characterized in that, The process of generating an application performance report from the model resource data includes: The model resource data is summarized and statistically processed to obtain statistical data; The statistical data are compared and processed according to a preset model resource threshold to obtain the out-of-standard model; The performance of the model resource data of the out-of-standard model is analyzed and processed to generate optimization suggestions; The statistical data is then visualized to obtain visual charts; Based on the optimization suggestions and the visualization charts, generate the application performance report.

5. The method according to claim 4, characterized in that, The process of performing performance analysis on the model resource data of the out-of-standard model and generating optimization suggestions includes: The rendering complexity and computational logic complexity of the model resource data of the over-standard model are calculated to obtain a complexity score; Based on the complexity score, resource correlation analysis is performed on the over-standard model to obtain the analysis results; The analysis results are input into a large language model for natural language analysis and processing to generate optimization suggestions.

6. The method according to claim 1, characterized in that, The step of performing performance optimization on the role model based on the application performance report to obtain the optimization result includes: Determine the model resource data to be adjusted based on the application performance report; The resource data of the model to be adjusted is optimized based on the application scenario, operating environment, and interaction behavior of the target application to obtain the optimization result.

7. The method according to any one of claims 1 to 6, characterized in that, Before obtaining the resource configuration file of the character model in the target application, the method includes establishing a model resource threshold, including: The target application is subjected to scenario analysis to obtain the application scenario and operating environment; The operating environment is subjected to performance analysis and processing to obtain terminal performance data; Based on the application scenario and the terminal performance data, the model resource data of the role model is processed to define a threshold, thereby obtaining the model resource threshold.

8. An application performance monitoring system, characterized in that, include: The data acquisition module is configured to acquire resource configuration files for the role models in the target application; The resource analysis module is configured to perform model resource analysis and calculation on the resource configuration file to obtain model resource data; The report generation module is configured to perform data report generation processing on the model resource data to obtain an application performance report; The performance optimization module is configured to perform performance optimization processing on the role model based on the application performance report to obtain the optimization result.

9. An electronic device, characterized in that, It includes at least one control processor and a memory for communicatively connecting to the at least one control processor; the memory stores instructions executable by the at least one control processor, the instructions being executed by the at least one control processor to enable the at least one control processor to perform the application performance monitoring method as described in any one of claims 1 to 7.

10. A computer program product, characterized in that, The computer program product stores computer-executable instructions for causing the computer to perform the application performance monitoring method as described in any one of claims 1 to 7.

Images