A method of operation execution, an electronic device, and a storage medium

Abstract

This application discloses an operation execution method, electronic device, and storage medium, relating to the field of game technology. The method involves receiving natural language instructions; assembling the natural language in the instructions using domain knowledge context to obtain assembled natural language instructions, where domain knowledge context assembly represents assembling the natural language based on content related to game audio middleware; translating the assembled natural language instructions to generate middleware instructions to be processed, which include middleware query statements for querying target domain engineering objects and / or multi-step call sequences for operating target domain engineering objects, thereby achieving automatic and accurate generation of middleware instructions; and performing corresponding processing operations on the target domain engineering objects based on the middleware instructions to be processed to obtain execution results, thereby improving operational efficiency.

Description

Technical Field

[0001] This disclosure relates to the field of game technology, and more specifically to an operating method, electronic device, and storage medium. Background Technology

[0002] In computer-aided management scenarios for game audio engineering, as project data scales, projects based on professional audio middleware (such as game audio middleware (Wave Works Interactive Sound Engine, Wwise)) often involve tens of thousands of audio objects. In related technologies, such projects typically encompass various sound effects, voice, and music resources, and possess complex bus structures, event reference relationships, and multi-platform resource libraries, leading to high data processing complexity when performing automated batch management of project objects.

[0003] In related technologies, querying and modifying audio engineering objects typically involves operators manually writing query statements based on syntax specifications or assembling interface call sequences one by one. Due to the lack of automated syntax validation and semantic adaptation mechanisms, manually generated instructions are prone to syntax errors or content that does not conform to engineering specifications, causing the target system to frequently return parsing failures or execution exceptions during execution, resulting in low operational efficiency. Summary of the Invention

[0004] This application provides an operation execution method, an electronic device, and a storage medium to achieve automatic and accurate generation of Wwise instructions, improve the generation efficiency of Wwise instructions, and thereby improve the operation efficiency of Wwise objects.

[0005] In a first aspect, embodiments of this application provide an operation execution method, including: Receive natural language commands; The natural language in the natural language instruction is assembled using domain knowledge context to obtain the assembled natural language instruction; wherein, the domain knowledge context assembly means assembling the natural language based on content related to the game audio middleware; The assembled natural language instructions are translated to generate middleware instructions to be processed; wherein, the middleware instructions to be processed include middleware query statements for querying target domain engineering objects and / or multi-step call sequences for operating target domain engineering objects; Based on the middleware instruction to be processed, corresponding processing operations are performed on the target domain engineering object to obtain the execution result; wherein, the middleware instruction to be processed indicates change and / or query; the processing operation includes change operation and / or query operation.

[0006] In one possible design, the middleware instruction to be processed indicates a change; the processing operation includes a change operation. The step of performing corresponding processing operations on the target domain engineering object based on the middleware instruction to be processed includes: Add multiple of the aforementioned change operations to the undo group; Perform the change operation in the revocation group.

[0007] In one possible design approach, adding the multiple change operations to the undo group includes: If the change operation is a destructive operation, add multiple of the change operations to the undo group; wherein, the destructive operation refers to an operation that can change the state of the domain project.

[0008] In one possible design, before translating the assembled natural language instructions to generate middleware instructions to be processed, the method further includes: The assembled natural language instructions are matched with historical correct samples in the historical correct sample library for similarity. The similarity matching is based on at least one scoring dimension among keyword overlap, sequence similarity, object type consistency, attribute keyword matching, and Chinese-English synonym mapping. Historical correct samples that match the assembled natural language instructions are injected as few-shot learning examples into the translation context of the large language model; The process of translating the assembled natural language instructions to generate middleware instructions to be processed includes: The assembled natural language instructions are translated using a translation context with injected few-sample learning examples to generate the middleware instructions to be processed.

[0009] Secondly, embodiments of this application provide an operation execution device, including: The user interface module is used to receive natural language commands; An assembly module is used to assemble the natural language in the natural language instruction with domain knowledge context to obtain the assembled natural language instruction; wherein, the domain knowledge context assembly means assembling the natural language based on content related to the game audio middleware Wwise; The natural language translation module is used to translate the assembled natural language instructions to generate middleware instructions to be processed; wherein, the middleware instructions to be processed include middleware query statements for querying target domain engineering objects and / or multi-step call sequences for operating target domain engineering objects; An execution module is used to perform corresponding processing operations on the target domain engineering object based on the middleware instruction to be processed, and obtain the execution result; wherein, the middleware instruction to be processed indicates change and / or query; the processing operation includes change operation and / or query operation.

[0010] Thirdly, embodiments of this application also provide an electronic device, including a memory storing multiple instructions; a processor loading instructions from the memory to execute the steps of any of the operation execution methods provided in embodiments of this application.

[0011] Fourthly, embodiments of this application also provide a computer-readable storage medium storing a plurality of instructions adapted for loading by a processor to execute the steps of any of the operation execution methods provided in embodiments of this application.

[0012] Fifthly, embodiments of this application also provide a computer program product, including a computer program or instructions, which, when executed by a processor, implement the steps in any of the operation execution methods provided in embodiments of this application.

[0013] The solution adopted in this application, upon receiving a natural language instruction, assembles the natural language within the instruction using domain knowledge context to inject middleware professional information, eliminating issues such as colloquialism and ambiguity in natural language expression, and significantly improving the accuracy of natural language to middleware instruction conversion. Subsequently, the assembled natural language instruction is translated to achieve the conversion of natural language into professional middleware instructions, generating middleware instructions to be processed that conform to middleware specifications, thus achieving automatic and accurate generation of Wwise instructions to be processed. Furthermore, these middleware instructions to be processed include middleware query statements and multi-step call sequences to meet different user business needs. Afterwards, operations such as changes and queries can be performed using the middleware instructions to be processed, improving operational efficiency. In addition, the middleware instructions to be processed are automatically generated, reducing the probability of errors in middleware instructions caused by manual writing. Attached Figure Description

[0014] To more clearly illustrate the technical solutions in the embodiments of this application, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0015] Figure 1 This is a schematic diagram of a system architecture provided in an embodiment of this application; Figure 2 This is a flowchart illustrating an operation execution method provided in an embodiment of this application. Figure 1 ; Figure 3 This is a schematic diagram of a preview content provided in an embodiment of this application; Figure 4 This is a flowchart illustrating an operation execution method provided in an embodiment of this application. Figure 2 ; Figure 5 This is a schematic diagram of an operation interface provided in an embodiment of this application; Figure 6 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0016] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of the embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application. At the same time, in the description of the embodiments of this application, the terms "first," "second," etc., are only used to distinguish descriptions and should not be construed as indicating or implying relative importance. Thus, features defined with "first" and "second" may explicitly or implicitly include one or more features. In the description of the embodiments of this application, "multiple" means two or more, unless otherwise explicitly specified.

[0017] To facilitate understanding of this application, the technical knowledge and terms involved in this application will be explained below.

[0018] Wwise is a professional audio middleware widely used in game development. It is used to manage in-game audio resources, event triggering, mixing routing, interaction parameters, audio resource library (soundbank) packaging, and runtime behavior control.

[0019] The Wwise Authoring API (WAAPI) is an Authoring interface provided by Wwise for external tools and scripting systems, typically communicating via WebSocket. External programs can use WAAPI to query project objects, create objects, modify properties, move objects, generate SoundBanks, and invoke Undo Groups, among other operations.

[0020] Wwise Authoring Query Language (WAQL) is a query language provided by Wwise for retrieving objects within an Authoring project by object type, hierarchical path, attribute conditions, etc. It has a structure similar to database query languages ​​and supports expressive capabilities such as `from`, `where`, `select`, `orderby`, `descendants`, and `referencesTo`.

[0021] A Large Language Model (LLM) is a model that can understand and generate natural language, code, and structured text. For example, a Large Language Model may include support for various model services such as Claude, GPT, Gemini, and Qwen to achieve translation, error correction, and assisted generation of natural language into WAQL / WAAPI.

[0022] JSON (JavaScript Object Notation) is a lightweight structured data format. WAAPI request parameters, return results, locally cached interface metadata (Schema), sample libraries, and error correction records can all be stored or transmitted using JSON structures.

[0023] CSV (comma separated values) is a tabular data exchange format. This application supports exporting query results and batch modification preview results as CSV, facilitating auditing, reporting, and external collaboration.

[0024] Audio objects (also known as Wwise project objects, Wwise objects, objects, etc.) refer to various authoring objects in a Wwise project, including but not limited to sound, random container, sequence container, blend container, actor-mixer, bus, aux bus, event, action, state, switch, game parameter, soundbank, and work unit. These constitute the structured asset system of a game audio project.

[0025] Among them, sound is the most basic sound-generating object in Wwise, usually corresponding to one or more audio source files. The sound object may have configurations such as playback properties, volume, pitch, loop, fade in / out, positioning, and bus routing.

[0026] An event is the entry point in Wwise for game applications to access. Game logic typically doesn't directly manipulate specific sounds, but rather triggers one or more actions through events, which then drive actions such as playing, stopping, and setting parameters for objects.

[0027] A bus is a unit in Wwise's mixing routing structure, used to carry configurations such as volume, effects, routing, sidechains, and output device mappings. Different audio objects are ultimately aggregated into different buses.

[0028] A soundbank is a packaged unit for audio resources loaded during game runtime, containing events, media resources, and related structured data. Soundbank management often involves scenarios such as resource ownership checks, redundant content lookup, and auditing for missing packages.

[0029] A property is a configuration item attached to a Wwise object, such as volume, pitch, loop, output bus, virtualization behavior, positioning mode, randomization range, etc. Properties have different types, such as boolean, floating-point, integer, string, reference object path / ID, etc.

[0030] In related technologies, relevant personnel can perform operations such as querying and modifying Wwise objects in the Wwise project through the following methods.

[0031] Method 1: Use Wwise's built-in interface to manually search and modify each item. Relevant personnel (such as audio designers) use Wwise's built-in interface tools, such as the object tree, search box, property panel, and List View, to filter and edit. However, Method 1 has the following drawbacks: its search capabilities are heavily reliant on name retrieval, making it difficult to filter based on attribute combinations; it lacks support for advanced conditions such as numerical ranges, Boolean states, reference relationships, and complex hierarchies; its batch modification capabilities are limited, and it is difficult to create a "one-time safe operation" after filtering based on conditions. For example, if an audio designer wants to find "all looping sounds with volumes below -12dB that are output to a certain SFX Bus," it usually cannot be done directly in one step through the native interface. It needs to first search for a portion, then manually filter another portion, and finally modify them one by one.

[0032] Method 2: Use WAQL to manually write queries For audio designers familiar with the Wwise authoring API, complex queries can be executed directly by writing WAQL. WAQL can significantly improve retrieval capabilities and, theoretically, can cover multi-dimensional filtering needs such as object type, hierarchical path, attribute conditions, and relationships. However, method 2 has the following drawbacks: a high learning curve. Audio designers need to master syntax structures such as from, where, select, and descendants; attribute naming relies entirely on formal English fields, and different object types have different available attributes; the precedence of and and or in logical conditions can easily lead to misjudgments; some syntaxes are "grammatically correct" but semantically unsuitable for the target object type; errors in query writing often require multiple rounds of trial and error, resulting in high time costs.

[0033] Method 3: Use WAAPI to write scripting tools Some teams have tool developers or audio engineers write scripts in Python, C#, JavaScript, etc., to automate queries and batch modifications via WAAPI. However, method 3 has the following drawbacks: tools are often developed around fixed requirements and lack generalization ability; each new audit logic usually requires rewriting or modifying the script; audio designers themselves cannot flexibly express new requirements and still rely heavily on development support. The lack of a unified natural language entry point makes it impossible to quickly translate "what I want to check / modify" into operational results; many scripts lack security mechanisms such as visual preview, bug fixing, and undoing grouping.

[0034] Method 4: Consult the official documentation and manually construct the WAAPI request. WAAPI covers a large number of endpoints and has broad capabilities, but standard technical documentation is usually scattered across website pages. Audio designers, when using it, need to constantly search for interface names, compare parameter structures, confirm whether fields are required, and identify return value formats. This process disrupts the creative and engineering experience, requiring audio designers to have professional knowledge of WAAPI.

[0035] In summary, the above implementation method has the following drawbacks: Defect 1: Wwise's built-in search function is limited and cannot meet the needs of engineering audit level. In large Wwise projects, a common problem isn't finding a Wwise object with a specific name, but rather finding Wwise objects that meet a set of conditions. For example: finding all weapon sound effects with volumes below a certain threshold; or finding all objects belonging to a specific path that still retain a temporary attribute value.

[0036] Second drawback: WAQL has a high learning cost. Audio designers think in a way that's closer to natural language, such as "find all sound effects with loops" or "check which gunshots are too quiet." WAQL, however, requires users to translate this into formal syntax and field names. There's a clear cognitive translation layer between the two. If this translation layer is left to the user, it leads to the following problems: users must remember dozens of English attribute names; users must understand type compatibility relationships; users must master syntax combinations; users must know which objects support which attributes; and users must constantly debug incorrect statements. This prevents WAQL from becoming widely adopted in most audio designers' daily work.

[0037] Defect 3: Batch modification carries high risks, lacks security protection and preview confirmation. Batch modification is a high-frequency but high-risk operation. For example, if an audio designer wants to adjust the volume of a certain type of object from -18dB to -12dB, change the output bus of objects in a certain folder to a new bus, or close a batch of incorrectly enabled loops, without automation support, they can only modify them one by one; if they use a script, they may accidentally affect a large number of objects due to incorrect conditions.

[0038] Fourthly, the WAAPI documentation and interface information are too scattered, which is not conducive to audio designers' self-use. While WAAPI offers rich functionality, its 153 endpoints, numerous parameter structures, and return formats make it more like a developer tool than a designer tool. Audio designers often need to look up the API in the web documentation, switch to external debugging tools to configure parameters, return to Wwise to verify the effect, and then switch back to the documentation to confirm field details in order to complete a simple task. This fragmented process significantly reduces the willingness to use it and leaves many automatable capabilities idle for extended periods.

[0039] Defect 5: Lack of intelligent understanding and contextual self-learning The methods described above typically involve executing instructions without understanding intent. Audio designers often rely heavily on vague expressions, experience-driven approaches, and context-dependent processes. For example: checking recently added scripting resources for incorrect loops, finding content still attached to the old bus in the UI, identifying new weapon events not yet in the Bank, and noting which environments have noticeably low volume.

[0040] Therefore, to address the aforementioned issues, this application provides an intelligent query and batch modification system for game audio middleware engineering based on natural language processing. It revolves around the real workflow of audio designers and can achieve functions such as natural language translation, WAQL self-verification, sample self-learning, schema browsing, multi-step execution, modification preview, and undo protection. This solves problems such as the difficulty in expressing complex queries; the high cost of WAQL learning and debugging; the lack of preview, safe undo, and type constraints in batch modifications; the high barrier to entry for using WAAPI documentation; and workflow interruptions due to AI service instability.

[0041] For example, the aforementioned intelligent query and batch modification system for game audio middleware projects based on natural language processing may include, for instance, Figure 1 The user interface layer, communication layer, and Wwise Authoring engineering layer are shown.

[0042] The user interface layer can include a PyQt5 GUI, which is a Python implementation based on the Qt5 graphical programming framework. For example, the user interface layer can be divided into three core tabs (including a query and modification tab, a schema tab, and a WAAPI call tab), each serving different work scenarios.

[0043] The Query and Modify tab includes at least one of the following sub-areas: Natural Language Input Area, Template Quick Area, AI Translation Results Area, Results List Area, Attribute Modification Area, Modification Preview Area, and Execute and Undo Prompt Area.

[0044] The natural language input area is used by users to input Chinese or English to query and modify their intent. For example: find all sounds with a volume below -12dB, check which sound effects are looping, and change the output bus of all sounds in the user interface (UI) folder to New_UI_Bus.

[0045] The template shortcut area provides several common query templates. For example: query objects not referenced by an event; query all loop sounds under a specified path; query all objects under a certain bus; query soundbank contents; batch modify volume, pitch, output bus, and whether looping is enabled (isLoopingEnabled), etc.

[0046] The AI ​​translation results area displays the WAQL generated and verified by the system, making it convenient for advanced users to check or manually fine-tune it.

[0047] The results list area displays a list of Wwise objects matched by the query. Fields can include name, type, path, ID, key attribute values, etc., and it supports copying, sorting, and exporting to CSV / JSON.

[0048] The attribute editing area allows users to select a target attribute from a drop-down list. Correspondingly, the system automatically switches the input control based on the attribute type.

[0049] The preview area is used to display the current and target values ​​of each object before the actual write operation, and highlights the changed parts.

[0050] The execution and undo prompt area is used to indicate whether the current modification will wrap an undo group, whether the number of objects exceeds the warning threshold, etc.

[0051] The Schema Browser tab is used to solve the problem of difficulty in finding WAAPI documentation. It may include: The left side is a classification tree, displaying 153 endpoints across 72 categories; The top provides a keyword search function, allowing users to search by function name, category name, or parameter name. The right side displays endpoint details, including the full endpoint name; function description; request parameter structure; required and optional fields; enumerated value list; return value example; and usage example. It should be understood that the positions and quantities described here are merely examples, and this application does not impose restrictions on the display position of content in the Schema browser tab.

[0052] The Schema browser tab transforms the WAAPI documentation from a web-based instruction manual into an interface dictionary that can be easily accessed within the tool.

[0053] The WAAPI call tab can include functions such as selecting any WAAPI endpoint, filling in JSON parameters, making a direct call, viewing the return results, and saving successful calls as templates or samples. Furthermore, the WAAPI call tab is geared towards users with some knowledge of Wwise. Thus, it is suitable not only for natural language-driven applications but also retains a finely tuned control interface for professional users.

[0054] The aforementioned intelligent query and batch modification system for game audio middleware projects based on natural language processing can be used to implement intelligent query and batch modification methods (or alternatively, operation execution methods) for game audio middleware projects based on natural language processing. The execution subject of the operation execution method can be an electronic device. For example... Figure 2 As shown, the implementation process of this operation execution method may include: S201, Receive natural language instructions.

[0055] In this application, users can input natural language to implement natural language commands, such as finding all sound effects with a volume below -12dB. For example, users can input natural language through the aforementioned user interface layer. Alternatively, users can also input natural language in other ways, such as through voice.

[0056] S202. Perform domain knowledge context assembly on the natural language in the natural language instructions to obtain the assembled natural language instructions. Domain knowledge context assembly means assembling the natural language based on content related to the game audio middleware.

[0057] S203. Translate the assembled natural language instructions to generate middleware instructions to be processed. These middleware instructions include middleware query statements for querying target domain engineering objects and / or multi-step call sequences for operating target domain engineering objects.

[0058] Optionally, the middleware instructions to be processed include Wwise instructions to be processed. The target domain engineering object includes a Wwise engineering object. Accordingly, the multi-step call sequence includes a Wwise engineering object WAAPI multi-step call sequence. The middleware query statement includes a WAQL query statement.

[0059] Alternatively, the game audio middleware can be Wwise.

[0060] In this embodiment of the application, the electronic device performs domain knowledge context assembly (or context enhancement) on the received natural language instructions to enhance the information of the original natural language instructions that are colloquial and concise, so as to obtain natural language instructions that are semantically complete and conform to the professional logic of audio development, thus obtaining the assembled natural language instructions.

[0061] The system translates the assembled natural language instructions and automatically generates pending middleware instructions that conform to the Wwise specification for game audio middleware (such as Wwise). These pending middleware instructions indicate changes and / or queries. Changes can include creation, deletion, modification, etc.

[0062] In some embodiments, the aforementioned Wwise instructions to be processed may include WAQL query statements, which are used to find, filter, and retrieve audio objects in the Wwise project. In addition, they can also be used to query the attributes of audio objects.

[0063] And / or, The aforementioned pending Wwise instructions may include a WAAPI multi-step call sequence for performing the aforementioned changes and / or queries on the Wwise project.

[0064] Optionally, the above query may refer to querying an audio object and / or the attributes of an audio object. A change may refer to changing an audio object and / or changing the attributes of an audio object.

[0065] In some embodiments, the assembly process described above may include: the electronic device assembling natural language based on at least one of the following data: a preset Wwise attribute mapping table, WAQL syntax rules, object type constraints, and historical correct samples, to obtain assembled natural language. In this embodiment, before translation, the electronic device can utilize Wwise-related content such as the Wwise attribute mapping table, WAQL syntax rules, object type constraints, and historical correct samples to inject Wwise-related information into the natural language instructions, thus transforming the user's colloquial, simplified, and vague natural language into a more professional and complete instruction expression that Wwise can understand.

[0066] Optionally, the Wwise attribute mapping table refers to a standard mapping table built into electronic devices for commonly used Wwise attributes. It is used to establish the correspondence between natural language expressions commonly used by audio designers and field names in WAQL / WAAPI. In other words, the Wwise attribute mapping table includes the mapping relationship between standard Wwise attributes and natural language. For example, the Wwise attribute mapping table can cover 8 major categories and 60+ attributes. For instance, it can uniformly map loop, whether it's a loop, and whether it's open / closed in natural language to IsLoopingEnabled or corresponding valid query expressions to improve the accuracy and consistency of AI translation. Another example is mapping volume to Volume, output bus to outputbus, mute to mute, pitch to pitch, and whether it's 3D to location-related fields.

[0067] Object type constraints define the objects to which Wwise attributes apply. They restrict the attributes (such as volume and pitch) supported by each object type (e.g., sound, bus, event, container). Based on this, adding object type constraints to natural language instructions prevents subsequent large models from applying attributes applicable only to one object to other objects, such as incorrectly using sound attributes for objects like actor-mixer. Furthermore, object type constraints can also define which attributes are read-only and which are writable.

[0068] WAQL syntax rules (also known as the WAQL syntax reference) include standard syntax rules such as from, where select, orderby, and descendants. By injecting WAQL syntax rules corresponding to the intent type, object type, conditions (such as query conditions), and structure (such as query structure) involved in natural language instructions, the natural language instructions are specialized, thereby constraining and guiding the generation of Wwise instructions that conform to the Wwise specification during the natural language instruction translation process.

[0069] In some embodiments, after receiving a natural language instruction, the electronic device can perform intent recognition on the natural language instruction to obtain the corresponding intent type. For example, intent types include read-only query, batch modification after query, WAAPI operation request, document browsing, or interface exploration request. In general, intent types can include read-only query and change, and changes can include creation, deletion, modification, etc.

[0070] Historical correct samples represent historical natural language and their corresponding correct WAQL query statements and / or WAAPI multi-step call sequences. For example, upon receiving a natural language instruction, a similarity match can be performed between the natural language instruction and historical correct samples to select the sample most similar to the current natural language instruction from the historical correct samples. Furthermore, this sample is injected as a few-shot example into the input context of the large model for the model to learn from, constraining the format and writing style of the large model's output translation results. In other words, similar samples are automatically extracted from historical correct samples as "input-output" examples, allowing the large model to reason by mimicking samples instead of starting from scratch, improving inference efficiency and ensuring accuracy.

[0071] Similarity matching can include at least one of the following: keyword overlap, sequence similarity, object type consistency, attribute keyword matching, and Chinese-English synonym mapping. For example, electronic devices can perform similarity matching based on a combined scoring method of keyword overlap and sequence similarity. Sequence similarity represents the similarity of sentence structure. The combined scoring method can be a weighted summation.

[0072] Optionally, historical correct samples can be generated by the electronic device automatically recording the original natural language input, the final correct Wwise instruction (such as WAQL), ​​error correction comparisons, keywords, and sequence features during the execution of historical operations. Additionally, historical correct samples can be stored in a local sample library. Furthermore, when the output of the large model is incorrect, it can be corrected by the validator or manually by the user, and the electronic device can record the mapping between incorrect and correct expressions. These error correction records can be used as negative sample knowledge or supplementary correction rules to continuously improve stability.

[0073] Optionally, the aforementioned large model can be an AI model. Furthermore, there can be multiple large models, with different large models corresponding to different model service providers. When the primary service provider returns insufficient quota, request rate limiting, service unavailability, or timeout exceptions, it automatically switches to a backup service provider to continue processing natural language commands. In other words, when the primary large model is unavailable, the electronic device can use a backup large model for translation to ensure the reliability of the translation.

[0074] In one implementation, the process of determining the Wwise attribute mapping table may include: reading the WAAPISchema definition file; parsing the WAAPI Schema definition file to obtain WAAPI structured metadata; extracting Wwise standard attributes from the WAAPI structured metadata; and generating a mapping relationship between the Wwise standard attributes and their corresponding natural language representations to obtain the Wwise attribute mapping table.

[0075] In this embodiment, the electronic device can dynamically read the WAAPI Schema from the local Wwise installation directory and parse out structural metadata such as WAAPI endpoint names, parameter definitions, required fields, enumeration values, and example information. Then, the electronic device can traverse the WAAPI structured metadata, filter out configurable attribute fields describing the state and parameters of Wwise project objects, remove non-attribute content such as interface names, method names, and enumeration definitions, and extract Wwise standard attributes. Next, based on preset natural language mapping rules and Wwise domain knowledge, the electronic device configures corresponding natural language descriptions for the Wwise standard attributes, establishing a one-to-one or many-to-one standardized mapping relationship to form a Wwise attribute mapping table. This allows for rapid conversion of user-input colloquial attribute descriptions into Wwise-recognizable standard attribute names during natural language command processing, improving command translation accuracy.

[0076] Optionally, electronic devices can cache the Wwise property mapping table as local JSON and prioritize reading the cache upon subsequent startup to reduce the overhead of repeated parsing. If a Wwise version change is detected or the user manually refreshes the page, the table is parsed again.

[0077] Therefore, this application does not rely on manual maintenance of static documents. Instead, it dynamically reads and parses the WAAPISchema from the local Wwise installation directory and caches it as local JSON. This approach is compatible with different Wwise versions and provides a more designer-friendly browsing experience.

[0078] In some embodiments, electronic devices can translate assembled natural language instructions using large models (such as large language models). These large models may include Claude, GPT, Gemini, Qwen, and others. Different large models can share a unified prompt skeleton, but can be adapted separately in terms of parameter format, maximum context length, and output pruning strategy, thereby avoiding dependence on a single model and enabling flexible selection of large models.

[0079] In this embodiment, the electronic device invokes a large language model, inputting assembled natural language instructions with injected domain knowledge context into the model. The model then generates middleware instructions to be processed end-to-end, such as generating WAQL query statements and / or WAAPI multi-step call sequences. For example, the assembled natural language instructions are matched with historical correct samples in a historical correct sample library for similarity. The similarity matching is based on at least one scoring dimension among keyword overlap, sequence similarity, object type consistency, attribute keyword matching, and Chinese-English synonym mapping.

[0080] Historically correct samples that match the assembled natural language instructions are injected into the translation context of the large language model as few-shot learning examples. Specifically, when the similarity between a historically correct sample and the assembled natural language instructions is greater than or equal to a preset similarity threshold, the historically correct sample is determined to match the assembled natural language instructions. When the similarity between a historically correct sample and the assembled natural language instructions is less than the preset similarity threshold, the historically correct sample is determined to not match the assembled natural language instructions.

[0081] Accordingly, by injecting a translation context with few sample learning examples, the assembled natural language instructions are translated to generate middleware instructions to be processed.

[0082] Historical correct samples that match the assembled natural language instructions are injected into the translation context of the large language model as few-shot learning examples to provide the large language model with input-output pairing examples of "historical normalized natural language - correct middleware instructions", guiding the large language model to convert the assembled natural language instructions into legal middleware instructions to be processed.

[0083] Taking the middleware instructions to be processed as Wwise instructions to be processed, and the middleware query statements as WAQL query statements as an example, the output of the large model can follow a fixed structure. That is, the structure of the aforementioned Wwise instructions to be processed can include a summary of the query intent, recommended Wwise instructions to be processed (such as recommended WAQL query statements), attribute mapping descriptions, notes, or potential ambiguities. However, it should be understood that electronic devices can extract only the Wwise instructions to be processed into the validator, thus balancing readability and executability.

[0084] In other embodiments, the electronic device can also translate the assembled natural language instructions in other ways. For example, a direct conversion method based on structured rule template matching and semantic parsing trees can be used. The electronic device can perform translation based on a locally pre-set structured rule template library: first, dependency parsing is performed on the assembled natural language instructions to extract operation predicates, target object types, and conditional constraints; then, according to the pre-set statement skeleton in the rule template library, the extracted semantic elements are mapped to WAQL standard field names and filled into the corresponding slots, or combined into a WAAPI endpoint call sequence, thereby completing the translation without relying on external AI services. Through the rule template path, the determinism and response speed of translation can be improved in common standardized query scenarios, complementing the large model path.

[0085] S204. Based on the middleware instructions to be processed, perform corresponding processing operations on the target domain engineering object to obtain the execution result. These processing operations include change operations and / or query operations.

[0086] In this embodiment of the application, the electronic device can perform corresponding processing operations based on the generated middleware instructions to be processed, so as to realize the corresponding business processing and meet the user's business needs.

[0087] In some embodiments, upon receiving a Wwise instruction to be processed, the electronic device may not execute it directly. Instead, it first enters a self-verification engine to verify and correct the Wwise instruction based on preset rules, resulting in a corrected Wwise instruction. This verification and correction is used to detect and correct any anomalies in the Wwise instruction that do not conform to WAQL syntax rules and / or Wwise engineering specifications. Afterward, the electronic device performs corresponding processing operations on the Wwise engineering object based on the corrected Wwise instruction. Therefore, since verification and correction are based on static preset rules, there is no need to call related models, improving the stability of verification and correction, increasing the speed of verification and correction, and reducing costs.

[0088] Optionally, the above-mentioned preset rules include at least one of the following verification rules: Boolean attribute expression for missing validation rules; Rules for validating the reasonableness of object type and attribute combinations; Logical operation priority trap verification rules; Path representation specification validation rules; Type name spelling validation rules; Redundant structure validation rules for all objects (descendants) in the folder and type filtering.

[0089] Accordingly, the above verification includes at least one of the following operations: Boolean attribute missing expression detection; Detection of the reasonableness of object type and attribute combination; Logical operation priority trap detection; Path representation standardization detection; Type name spelling check; Redundancy detection for all objects (descendants) in the folder with type filtering.

[0090] In addition, the preset rules may also include at least one of the following modification rules: Boolean attribute expression missing correction rules; Rules for correcting the reasonableness of object type and attribute combinations; Logical operation priority trap correction rules; Path representation specification correction rules; Type name spelling correction rules; Redundant structure correction rules for filtering all objects and types in the folder.

[0091] Among them, the Boolean attribute expression missing correction rule is used to complete Boolean attributes (or Boolean attribute explicit comparison completion). Some natural language involves Boolean states, such as "loop on", "mute", "option enabled", however, large models may output incomplete comparison expressions. Based on the Boolean attribute expression missing verification rule, electronic devices can perform Boolean attribute expression missing detection to check whether the Boolean attributes of the Wwise instruction to be processed are missing. If missing, the missing Boolean attribute is completed into a standard comparison form, such as =true or =false, based on the Boolean attribute expression missing correction rule, avoiding execution ambiguity and realizing Boolean attribute expression missing correction.

[0092] The object type and attribute combination rationality correction rule is used to perform at least one corrective operation, such as adjusting the query type, removing meaningless filters, or prompting the user that the query semantics are incorrect. Considering that audio designers typically think in terms of "functional semantics" rather than "object class inheritance structure," attribute mismatches may occur. For example, some playback attributes that only apply to Sound may be used in Actor-Mixer. Therefore, it is necessary to check whether the target type in the electronic device query translation result (i.e., the Wwise instruction to be processed) matches the filter attributes. If they do not match, operations such as adjusting the query type, removing meaningless filters, or prompting the user that the query semantics are incorrect can be performed.

[0093] Logical operator precedence trap correction rules are used to complete parentheses and / or suggest modified interpretation logic. In complex conditions containing AND and OR, missing parentheses can easily lead to query results that are too large or too small. Therefore, electronic devices detect potential precedence risks and automatically complete parentheses or suggest modified interpretation logic.

[0094] The path representation specification correction rules are used to correct path representations in translation results based on the Wwise specification. Large models may output mixed expressions such as "from a certain type + a certain path," while in actual WAQL queries, the descendant pattern is clearer and more robust for the semantics of finding descendant objects under a certain path. Therefore, this application can automatically convert to a syntax more suitable for the semantics of the Wwise engineering level.

[0095] Type name spelling correction rules are used to correct spelling errors and / or capitalization. Wwise object type names have formal spelling rules, such as sound, event, bus, etc. Electronic devices use a built-in dictionary to validate type names and automatically correct common capitalization or spelling errors.

[0096] The redundant structure correction rules for all objects and type filters in the folder are used to simplify (i.e., correct) redundant structures in the translation results. If both `descendants` and similar filtering conditions are repeatedly specified in the `where` clause, it may lead to redundant or even misleading expressions. Therefore, this application can identify and simplify such structures as much as possible, making the corrected translation results more concise and readable.

[0097] In some embodiments, preset rules are used to verify and correct any abnormal content in the Wwise instruction to be processed that does not conform to WAQL syntax rules or Wwise engineering specifications. For example, preset rules are used to verify whether the statements in the Wwise instruction to be processed conform to WAQL specifications and to correct statements that do not conform to WAQL specifications, and / or to verify whether the business semantics of the Wwise instruction to be processed conform to Wwise engineering specifications and to correct business semantics that do not conform to Wwise engineering specifications.

[0098] Optionally, the electronic device can perform verification and correction based on preset rules in the preset rule base. The preset rule base can be stored locally, and the preset rules are static rules that do not require the model to execute the preset rules.

[0099] In some embodiments, the validation rules in the aforementioned preset rules may include WAQL syntax validation rules and Wwise engineering specification validation rules. WAQL syntax validation rules may include at least one of the following: Boolean attribute missing expression validation rules, logical operation precedence trap validation rules, and type name spelling validation rules. Wwise engineering specification validation rules may include at least one of the following: object type and attribute combination rationality validation rules, path expression specification validation rules, and redundant structure validation rules for descendants and type filtering.

[0100] Optionally, validation can be performed based on the priority of the validation rules. For example, WAQL syntax validation rules have a higher priority than Wwise engineering specification validation rules, and WAQL syntax validation rules are blocking-level validation rules. Therefore, the validation rules in the WAQL syntax validation rules are executed in parallel first, meaning that the validation rules in the WAQL syntax validation rules have the same priority. If an anomaly is found during validation, validation stops, and the anomaly is corrected. After all anomalies are successfully corrected, validation continues. If no anomalies are found, the Wwise engineering specification validation rules are executed only after all WAQL syntax validation rules have been completed.

[0101] In one example, when executing Wwise engineering specification validation rules, all validation rules within the Wwise engineering specification validation rules have the same priority. Therefore, all validation rules within the Wwise engineering specification validation rules can be executed concurrently. In another example, the priority of each validation rule within the Wwise engineering specification validation rules can be set according to requirements. For example, the priority of core semantic validation rules can be higher than that of optimized semantic validation rules. Core semantic validation rules are blocking-level validation rules; that is, when executing core semantic validation rules, if an anomaly is found during validation, validation stops and the anomaly is corrected. Validation continues only after all anomalies have been corrected.

[0102] Optimized semantic validation rules are not considered blocking-level validation rules. This means that if anomalies are detected during the execution of optimized semantic validation rules, validation will continue. After validation is complete, the anomalies will be corrected.

[0103] Optionally, the core semantic validation rules may include validation rules for the reasonableness of object type and attribute combination.

[0104] Optimizing semantic validation rules can include path expression specification validation rules and / or redundant structure validation rules for descendants and type filtering.

[0105] It should be understood that continuing verification can refer to restarting the verification from the verification rule corresponding to the one that stopped verification, or it can refer to re-executing the verification process; this application does not restrict either. Additionally, if the anomaly cannot be automatically corrected, a corresponding anomaly message can be output to prompt relevant personnel to correct the anomaly.

[0106] In some embodiments, the electronic device can validate and correct WAQL query statements. Of course, the electronic device can also validate and correct WAAPI multi-step call sequences.

[0107] The above section introduced the relevant content on verification and correction. The following section will continue with the relevant content on execution.

[0108] In some embodiments, the electronic device supports previewing. The above processing operations include modification operations. Based on the middleware instruction to be processed (such as the Wwise instruction to be processed), multiple target domain (such as Wwise) engineering objects to be modified are selected. Then, a preview of the original data and target data corresponding to the multiple target domain engineering objects is displayed. In response to the user's confirmation operation, a batch modification operation is performed on the original data of the multiple target Wwise engineering objects to modify the original attributes of each target domain engineering object to the corresponding target data. It should be understood that the middleware instruction to be processed (such as the Wwise instruction to be processed) here can refer to a WAAPI multi-step call sequence.

[0109] The confirmation action can be an operation on a confirmation control, a confirmation message entered by the user via voice, or a specific gesture entered by the user indicating the confirmation action. The original data represents the attribute value before modification, and the target data represents the attribute value after modification.

[0110] Optionally, the above preview content can also include object identifiers (such as...) Figure 3 (as shown), path, etc.

[0111] For example, taking the middleware instructions to be processed as a WAAPI multi-step call sequence and the target domain as Wwise, the electronic device automatically filters out the target Wwise project objects to be modified based on the WAAPI multi-step call sequence. Then, it displays preview content including the original data and target data corresponding to multiple target Wwise project objects, forming a preview of the old and new attribute data, allowing the user to intuitively verify the modified content. After the user verifies that everything is correct, they input a confirmation operation. The electronic device responds to the confirmation operation and performs attribute rewriting on the target Wwise project objects in batches. Based on this, the data preview step is added, allowing users to check the modification range and parameter values ​​in advance, effectively avoiding errors caused by misreading objects or entering incorrect parameters. Furthermore, it supports simultaneous batch modification of multiple objects, eliminating the need for manual parameter adjustment one by one, significantly improving the efficiency of unified parameter configuration for large audio projects.

[0112] For example, an electronic device can display a comparison table of original and target data, with changed fields highlighted. Additionally, if the original data of an object is already equal to the target data, it can be marked as "unchanged" to avoid meaningless writes.

[0113] Alternatively, when the execution result involves property modification, object creation, deletion, moving, or changes in reference relationships, a modification preview can be generated before execution.

[0114] In some embodiments, the electronic device can filter out multiple target domain engineering objects to be modified based on the middleware instructions to be processed, and determine the target attributes to be modified. Accordingly, the aforementioned raw data represents the raw values ​​of the target attributes. The aforementioned target data represents the target values ​​of the target attributes.

[0115] In some embodiments, the electronic device can support manual modification of attributes by the user. For example, the aforementioned WAAPI multi-step call sequence includes a query step and a modification step. During the query step, the electronic device can display an interface including the query results. This interface can also include input controls matching the target attribute to be modified, allowing the user to input the corresponding target data, preventing users from randomly entering invalid values ​​and achieving intelligent and standardized data entry. For example, after the user selects an attribute, the interface automatically switches input controls. For instance, Boolean types correspond to dropdown lists; floating-point types correspond to spinners; integer types correspond to integer controls; text types correspond to free text boxes; and reference types correspond to object selection or text path input.

[0116] The query results can be the target Wwise project object and its corresponding target attributes.

[0117] Subsequently, in response to the user's modification, the electronic device can display a preview, which includes the original data and target data of the target attribute. In response to the user's confirmation, the electronic device can perform the corresponding modification.

[0118] In some embodiments, the electronic device also supports a quantity warning mechanism. When the number of matched objects exceeds a preset threshold (e.g., 100), the system automatically displays a secondary confirmation warning. In response to the confirmation operation, the electronic device outputs a risk warning message if the number of engineering objects in the target domain is greater than or equal to the preset number. If the number of engineering objects in the target domain is less than the preset number, the electronic device does not need to output a risk warning message. After outputting the risk warning message, upon receiving another confirmation operation, in response to this second confirmation operation, a batch modification operation is performed on the original data of multiple engineering objects in the target domain.

[0119] The output of risk warning information may include voice output and / or display of risk warning information. Optionally, displaying risk warning information may include pop-up window display. The risk warning information is used to indicate the number of objects that will be affected by this modification operation. For example, the risk warning information may state that 198 objects will be affected, and ask the user to confirm whether to continue with this batch modification, thereby effectively reducing the risk of large-scale accidental modification.

[0120] When displaying risk warning information, a confirmation control is also shown. After the user confirms the preview content, if the electronic device receives another confirmation operation from the user on this control, it can execute the WAAPI multi-step call sequence normally. In other words, secondary confirmation occurs after preview confirmation. Specifically, the electronic device can display preview content, which includes the original data and target data of the target attributes. In response to the user's confirmation operation, since the number of target Wwise project objects to be modified is greater than or equal to a preset number, a secondary confirmation based on the quantity threshold is required, outputting a risk warning message including the number of objects affected by this modification operation. Only after receiving another confirmation operation from the user is the batch modification operation executed, implementing a security mechanism independent of preview confirmation.

[0121] Optionally, the above WAAPI multi-step call sequence may include multiple sequential steps. For example, a WAAPI multi-step call sequence may include: Step 1: Query all Sounds under a certain path. Step 2: Filter the results to find objects whose Volume is less than a certain threshold. Step 3: Set new Volumes for these objects in batches. Step 4: Return a summary of the modified results.

[0122] WAAPI multi-step call sequences support inter-step variable references, allowing object identifiers, paths, attribute values, or quantity information returned by a previous step to be invoked by subsequent steps. During the execution of a WAAPI multi-step call sequence, electronic devices can use variable reference mechanisms to execute corresponding steps, referencing data returned by the previous step in subsequent steps using variable syntax, such as: $result1[0].id: references the ID of the first object; $result1[ `].id`: references the IDs of all objects; `$result2.count`: references the number of results from the second step. This allows us to represent the actual chain of business actions, rather than isolated commands.

[0123] In this embodiment, the electronic device can not only perform queries, but also execute complex processes such as query-then-modify, retrieve objects first and then create references, and perform batch operations based on results. Through the variable referencing mechanism, the results of the previous step can be directly used in the next step, realizing workflow-oriented automation, rather than just single-instruction-oriented automation.

[0124] In some embodiments, an electronic device can add multiple change operations to an undo group; execute the change operations in the undo group to automatically wrap destructive operations in the Undo group during execution, thereby enabling one-click undo of a batch of automated change operations.

[0125] Optionally, if the change operation is a destructive operation, the electronic device can add multiple change operations to the undo group; wherein, a destructive operation refers to an operation that can change the project state of the target domain (such as Wwise), thereby avoiding unnecessary activation of the undo group. Optionally, destructive operations can include operations that change the project state, such as creating, deleting, modifying, and moving.

[0126] The following will describe one possible execution process for the above operation method. For example... Figure 4 As shown, the user inputs natural language commands (i.e., natural language instructions) in languages ​​such as Chinese and English. The electronic device can then perform intent recognition and routing based on the natural language. After recognizing the intent type, the natural language command can be routed to different execution paths, i.e., to a WAQL query path or a WAAPI modification path. When the intent is recognized as a read-only query, a WAQL query statement is generated and executed directly without changing the project state. For example, ... Figure 5 As shown, the user's input in natural language is "Find all objects with a volume equal to -96db, and see if there are any abandoned resources that I forgot to delete." The intent type of this natural language is a read-only query.

[0127] When an intent is identified as a change operation, a multi-step WAAPI call sequence is generated. Before execution, it may require previewing, confirmation, secondary confirmation, and wrapping with an Undo Group to prevent destructive operations from being executed without security checks. This routing ensures that queries and change operations undergo different processing flows.

[0128] Next, the electronic device can perform similarity matching between the natural language and a sample database. Then, based on attribute mapping (i.e., Wwise attribute mapping table), WAQL syntax rules, and the matched samples, the electronic device can assemble the natural language into a domain knowledge context. Finally, the electronic device uses an AI model to translate the assembled natural language, generating WAQL statements or WAAPI steps (i.e., WAAPI multi-step call sequences).

[0129] The electronic device can then perform self-validation and automatic correction on the WAQL statement. Based on the corrected WAQL statement or WAAPI steps, it determines whether the natural language query is a read-only query or a modification request, and performs the corresponding processing operation.

[0130] In some embodiments, the above operation execution method can be applied to the following scenarios: Scenario 1: Find all sound effects with a volume below -12dB. The user inputs a natural language command: "Find all sound effects with a volume below -12dB." The corresponding electronic device can execute the following process: First, the query is recognized as read-only based on the natural language command. Next, it searches the sample library for historical correct samples related to volume, below the threshold, and sound. Then, it uses a Wwise attribute mapping table to determine the corresponding volume. Since it's a read-only query, the large model can generate a WAQL query statement. Next, a validator checks the object type and numerical comparison syntax to correct the WAQL query statement. Then, the query operation is executed based on the corrected WAQL query statement to obtain the corresponding query results, which can be used as the execution result. Finally, the query results can be displayed to show all matched objects. Additionally, the query results can be exported in CSV format.

[0131] Based on this, a quick project check can be performed without manually expanding the hierarchy tree or viewing each attribute individually.

[0132] Scenario 2: Find which Sounds are looping. The user inputs a natural language command: "Which sounds have looping enabled?" The corresponding electronic device executes the following process: First, it identifies the keywords "sound" and "looping" in the natural language command. Then, using the Wwise attribute mapping table, it maps the keywords to "isLoopingEnabled". Next, the large model outputs the corresponding WAQL query. Then, the validator automatically completes the Boolean comparison to correct the WAQL query. Finally, the electronic device executes the corrected WAQL query to obtain the corresponding query results. Additionally, the user can click "Save as Correct Sample" to save the input natural language command and WAQL query as a single correct sample and add it to the sample library.

[0133] This allows audio designers to transform actions that require memorizing the English names of Boolean properties into colloquial expressions.

[0134] Scenario 3: Batch close incorrectly enabled loops in a folder The user inputs a natural language command: "Turn off the loop for all sound effects in the SFX / Footstep folder that are currently looping." Correspondingly, the electronic device can break down the process into two stages: query and modification. Specifically, the process includes: First, querying all sound descendants in the target path. Then, filtering audio objects with IsLoopingEnabled=true, obtaining the query results including the filtered audio objects. Next, the electronic device can display the query results. Then, the electronic device can automatically enter the attribute modification area, with the target attribute being "Loop," and the user confirms the preview table. Finally, the electronic device can initiate Undo Group to perform batch modifications, and upon completion, report the number of successful modifications.

[0135] Therefore, what would otherwise require lengthy manual checks and individual shutdowns can be compressed into a single, safe, and reversible batch operation.

[0136] Scenario 4: Batch switching of output bus after query The user's natural language command is: "Change the output buses of all Sound items under the UI folder to New_UI_Bus." The corresponding electronic device can execute the following process: First, parse the query range to obtain the UI folder (descendants). Parse the target object type to obtain the Sound item. Then, parse the modification attributes to obtain the output bus. Next, query the matched objects and display the current bus (i.e., the original bus). Display the current bus and New_UI_Bus in the preview area. If the number of matched objects is greater than or equal to a preset number, display a risk warning message. In response to user confirmation, add the batch modification operation to the Undo Group.

[0137] Therefore, it avoids dragging or switching Buses one by one, making it suitable for stages such as version migration and structural restructuring.

[0138] The scenarios listed above are merely examples. The operation execution method provided in this application can also be applied to other scenarios, and this application does not limit them.

[0139] It should be noted that the operations performed by the above-described functional modules are merely examples; the operations performed by one functional module may also be performed by other modules, and this application does not limit them. In general, all of the above operations are performed by the electronic device.

[0140] Accordingly, this application also provides an electronic device, which can be a terminal (or mobile terminal), such as a smartphone, tablet computer, laptop computer, touch screen, game console, personal computer (PC), personal digital assistant (PDA), or other terminal device. Alternatively, the electronic device can be a server.

[0141] like Figure 6 As shown, Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. The electronic device 1100 includes a processor 1101 with one or more processing cores, a memory 1102 with one or more computer-readable storage media, and a computer program stored on the memory 1102 and executable on the processor. The processor 1101 and the memory 1102 are electrically connected. Those skilled in the art will understand that the electronic device structure shown in the figure does not constitute a limitation on the electronic device, and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0142] The processor 1101 is the control center of the electronic device 1100. It connects various parts of the electronic device 1100 via various interfaces and lines. By running or loading software programs and / or units stored in the memory 1102, and by calling data stored in the memory 1102, it executes various functions of the electronic device 1100 and processes data, thereby providing overall monitoring of the electronic device 1100. The processor 1101 can be a central processing unit (CPU), a graphics processing unit (GPU), a network processor (NP), etc., and can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of this application.

[0143] In this embodiment, the processor 1101 in the electronic device 1100 loads the instructions corresponding to the processes of one or more applications into the memory 1102 according to the following steps, and the processor 1101 runs the applications stored in the memory 1102 to realize various functions, such as: Receive natural language commands; The natural language in the natural language instruction is assembled using domain knowledge context to obtain the assembled natural language instruction; wherein, the domain knowledge context assembly means assembling the natural language based on content related to the game audio middleware Wwise; The assembled natural language instructions are translated to generate Wwise instructions to be processed; wherein, the Wwise instructions to be processed include Wwise Query Language (WAQL) query statements for querying Wwise project objects and / or Wwise External Programming Interface (WAAPI) multi-step call sequences for operating Wwise project objects; Based on the Wwise instruction to be processed, corresponding processing operations are performed on the Wwise project object to obtain the execution result; wherein, the Wwise instruction to be processed indicates change and / or query; the processing operation includes change operation and / or query operation.

[0144] In this application, upon receiving a natural language instruction, domain-knowledge context is assembled into the natural language within the instruction to inject Wwise professional information, eliminating issues such as colloquialism and ambiguity in natural language expression, and significantly improving the accuracy of natural language to Wwise instruction conversion. Subsequently, the assembled natural language instruction is translated to achieve the conversion of natural language into professional Wwise instructions, generating Wwise instructions conforming to the Wwise specification, thus achieving automatic and accurate generation of Wwise instructions to be processed. Furthermore, these Wwise instructions to be processed include WAQL query statements and WAAPI multi-step call sequences to meet different user business needs. Afterwards, operations such as changes and queries can be performed using the Wwise instructions to be processed, improving operational efficiency. In addition, the automatic generation of the Wwise instructions to be processed reduces the probability of errors caused by manually writing Wwise instructions.

[0145] For details on the implementation of each of the above operations, please refer to the previous examples, which will not be repeated here.

[0146] Optional, such as Figure 6As shown, the electronic device 1100 also includes: a touch display screen 1103, a radio frequency circuit 1104, an audio circuit 1105, an input unit 1106, and a power supply 1107. The processor 1101 is electrically connected to the touch display screen 1103, the radio frequency circuit 1104, the audio circuit 1105, the input unit 1106, and the power supply 1107. Those skilled in the art will understand that... Figure 6 The electronic device structure shown does not constitute a limitation on the electronic device and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0147] The touch display screen 1103 can be used to display a graphical user interface (GUI) and receive operation commands generated by the user interacting with the GUI. The touch display screen 1103 may include a display panel and a touch panel. The display panel can be used to display information input by the user or information provided to the user, as well as various graphical user interfaces of the electronic device. These graphical user interfaces can be composed of graphics, text, icons, video, and any combination thereof. Optionally, the display panel can be configured using a liquid crystal display (LCD), organic light-emitting diode (OLED), or other similar technologies. The touch panel can be used to collect touch operations performed by the user on or near it (such as operations performed by the user using a finger, stylus, or any suitable object or accessory on or near the touch panel), generate corresponding operation commands, and execute the corresponding program according to the operation commands. Optionally, the touch panel may include a touch detection device and a touch controller. The touch detection device detects the user's touch location and the signal generated by the touch operation, transmitting the signal to the touch controller. The touch controller receives touch information from the touch detection device, converts it into touch point coordinates, and sends it to the processor 1101. It can also receive and execute commands from the processor 1101. The touch panel can cover the display panel. When the touch panel detects a touch operation on or near it, it transmits the information to the processor 1101 to determine the type of touch event. Subsequently, the processor 1101 provides corresponding visual output on the display panel based on the type of touch event. In this embodiment, the touch panel and the display panel can be integrated into the touch display screen 1103 to achieve input and output functions. However, in some embodiments, the touch panel and the touch display screen 1103 can be implemented as two independent components to achieve input and output functions. That is, the touch display screen 1103 can also be used as part of the input unit 1106 to achieve input functions.

[0148] The radio frequency circuit 1104 can be used to transmit and receive radio frequency signals to establish wireless communication with network devices or other electronic devices, and to transmit and receive signals with network devices or other electronic devices.

[0149] Audio circuit 1105 can be used to provide an audio interface between a user and an electronic device via a speaker and a microphone. Audio circuit 1105 can convert received audio data into electrical signals and transmit them to the speaker, where the speaker converts them into sound signals for output. Conversely, the microphone converts collected sound signals into electrical signals, which are then received by audio circuit 1105, converted back into audio data, and then processed by processor 1101 before being transmitted via radio frequency circuit 1104 to, for example, another electronic device, or output to memory 1102 for further processing. Audio circuit 1105 may also include an earphone jack to provide communication between peripheral headphones and electronic devices.

[0150] The input unit 1106 can be used to receive input numbers, characters, or user characteristic information (such as fingerprints, iris, facial information, etc.), and to generate keyboard, mouse, joystick, optical, or trackball signal inputs related to user settings and function control.

[0151] Power supply 1107 is used to supply power to various components of electronic device 1100. Optionally, power supply 1107 can be logically connected to processor 1101 through a power management system, thereby enabling functions such as charging, discharging, and power consumption management through the power management system. Power supply 1107 may also include one or more DC or AC power supplies, recharging systems, power fault detection circuits, power converters or inverters, power status indicators, and other arbitrary components.

[0152] although Figure 6 As not shown in the diagram, the electronic device 1100 may also include a camera, sensor, wireless fidelity module, Bluetooth module, etc., which will not be described in detail here.

[0153] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions in other embodiments.

[0154] Those skilled in the art will understand that all or part of the steps in the various methods of the above embodiments can be performed by instructions, or by instructions controlling related hardware. These instructions can be stored in a computer-readable storage medium and loaded and executed by a processor.

[0155] Therefore, embodiments of this application provide a computer-readable storage medium storing multiple computer programs that can be loaded by a processor to execute any of the interface display methods provided in this application. The computer program can perform the following steps of the method execution: Receive natural language commands; The natural language in the natural language instruction is assembled using domain knowledge context to obtain the assembled natural language instruction; wherein, the domain knowledge context assembly means assembling the natural language based on content related to the game audio middleware Wwise; The assembled natural language instructions are translated to generate Wwise instructions to be processed; wherein, the Wwise instructions to be processed include Wwise Query Language (WAQL) query statements for querying Wwise project objects and / or Wwise External Programming Interface (WAAPI) multi-step call sequences for operating Wwise project objects; Based on the Wwise instruction to be processed, corresponding processing operations are performed on the Wwise project object to obtain the execution result; wherein, the Wwise instruction to be processed indicates change and / or query; the processing operation includes change operation and / or query operation.

[0156] In this application, upon receiving a natural language instruction, domain-knowledge context is assembled into the natural language within the instruction to inject Wwise professional information, eliminating issues such as colloquialism and ambiguity in natural language expression, and significantly improving the accuracy of natural language to Wwise instruction conversion. Subsequently, the assembled natural language instruction is translated to achieve the conversion of natural language into professional Wwise instructions, generating Wwise instructions conforming to the Wwise specification, thus achieving automatic and accurate generation of Wwise instructions to be processed. Furthermore, these Wwise instructions to be processed include WAQL query statements and WAAPI multi-step call sequences to meet different user business needs. Afterwards, operations such as changes and queries can be performed using the Wwise instructions to be processed, improving operational efficiency. In addition, the automatic generation of the Wwise instructions to be processed reduces the probability of errors caused by manually writing Wwise instructions.

[0157] For details on the implementation of each of the above operations, please refer to the previous examples, which will not be repeated here.

[0158] The computer-readable storage medium may include: read-only memory (ROM), random access memory (RAM), disk or optical disk, etc.

[0159] Since the computer program stored in the computer-readable storage medium can execute any of the resource processing methods provided in the embodiments of this application, the beneficial effects that any of the resource processing methods provided in the embodiments of this application can achieve can be realized, as detailed in the preceding embodiments, and will not be repeated here.

[0160] According to one aspect of this application, a computer program product or computer program is also provided, comprising computer instructions stored in a computer-readable storage medium. A processor of an electronic device reads the computer instructions from the computer-readable storage medium and executes the computer instructions, causing the electronic device to perform the methods provided in the various optional implementations of the above embodiments.

[0161] In the above embodiments of the computer-readable storage medium, electronic device, and computer program product, the descriptions of each embodiment have different focuses. Parts not described in detail in a particular embodiment can be referred to in the relevant descriptions of other embodiments. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes and beneficial effects of the computer-readable storage medium, computer program product, electronic device, and their corresponding units described above can be referred to the description of the interface display method in the above embodiments, and will not be repeated here.

[0162] The above provides a detailed description of an operating method, electronic device, computer-readable storage medium, and computer program product provided in the embodiments of this application. Specific examples have been used to illustrate the principles and implementation methods of this application. The descriptions of the above embodiments are only for the purpose of helping to understand the method and core ideas of this application. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this application. Therefore, the content of this specification should not be construed as a limitation of this application.

Claims

1. An operation execution method, characterized in that, include: Receive natural language commands; The natural language in the natural language instruction is assembled using domain knowledge context to obtain the assembled natural language instruction; wherein, the domain knowledge context assembly means assembling the natural language based on content related to the game audio middleware; The assembled natural language instructions are translated to generate middleware instructions to be processed; wherein, the middleware instructions to be processed include middleware query statements for querying target domain engineering objects and / or multi-step call sequences for operating target domain engineering objects; Based on the middleware instruction to be processed, corresponding processing operations are performed on the target domain engineering object to obtain the execution result; wherein, the middleware instruction to be processed indicates change and / or query; the processing operation includes change operation and / or query operation.

2. The method according to claim 1, characterized in that, The middleware instructions to be processed include Wwise instructions to be processed; the middleware query statements include Wwise query language (WAQL) query statements; and the target domain engineering objects include target Wwise engineering objects. After generating the middleware instruction to be processed, the method further includes: Based on preset rules, the Wwise instruction to be processed is verified and corrected to obtain a corrected Wwise instruction; wherein, the verification and correction are used to detect abnormal content in the Wwise instruction to be processed that does not conform to WAQL syntax rules and / or Wwise engineering specifications, and to correct the abnormal content. The step of performing corresponding processing operations on the target domain engineering object based on the middleware instruction to be processed includes: The target Wwise project object is processed based on the modified Wwise instructions.

3. The method according to claim 2, characterized in that, The verification includes at least one of the following operations: Boolean attribute missing expression detection; Detection of the reasonableness of object type and attribute combination; Logical operation priority trap detection; Path representation standardization detection; Type name spelling check; Redundancy detection for all objects descendants in the folder with type filtering.

4. The method according to any one of claims 1 to 3, characterized in that, The middleware instructions to be processed include Wwise instructions to be processed, and the middleware query statements include WAQL query statements; the assembly of the natural language in the natural language instructions using domain knowledge context to obtain the assembled natural language instructions includes: The natural language is assembled based on at least one of the following: a preset Wwise attribute mapping table, WAQL syntax rules, object type constraints, and historical correct samples, to obtain the assembled natural language.

5. The method according to claim 4, characterized in that, The Wwise attribute mapping table includes the mapping relationship between Wwise standard attributes and natural language; The object type constraint indicates the object to which the Wwise attribute applies; The historical correct samples represent historical natural language and its corresponding correct WAQL query statements and / or multi-step call sequences.

6. The method according to claim 5, characterized in that, The multi-step call sequence of the target domain engineering object includes the multi-step call sequence of the Wwise middleware external programming interface (WAAPI) of the target Wwise engineering object; before assembling the natural language based on at least one of the following data: a preset Wwise attribute mapping table, WAQL syntax rules, object type constraints, and historical correct samples, to obtain the assembled natural language, the method further includes: Read the WAAPI interface metadata schema definition file; The Schema definition file is parsed to obtain WAAPI structured metadata; Wwise standard attributes are extracted from the WAAPI structured metadata; Generate the mapping relationship between the Wwise standard attributes and their corresponding natural language to obtain the Wwise attribute mapping table.

7. The method according to any one of claims 1 to 3, characterized in that, The change includes modification; the processing operation includes modification operation; the step of performing corresponding processing operations on the target domain engineering object based on the middleware instruction to be processed, and obtaining the execution result, includes: Based on the middleware instructions to be processed, multiple target domain engineering objects to be modified are selected. Displays a preview of the original and target data corresponding to the multiple target domain engineering objects; In response to the user's confirmation, a batch modification operation is performed on the original data of the multiple target domain engineering objects to modify the original attributes of each target domain engineering object to the corresponding target data.

8. The method according to claim 7, characterized in that, The response to the user's confirmation operation involves performing batch modification operations on the original data of the multiple target domain engineering objects, including: In response to the confirmation operation, if the number of engineering objects in the target area is greater than or equal to a preset number, a risk warning message is output. In response to the reconfirmation operation, a batch modification operation is performed on the original data of the multiple target domain engineering objects.

9. An electronic device, characterized in that, The device includes a processor and a memory, the memory storing multiple instructions; the processor loads instructions from the memory to perform the steps of the operation execution method as described in any one of claims 1 to 8.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a plurality of instructions adapted for loading by a processor to perform the steps of the operation execution method as described in any one of claims 1 to 8.

Images