WO2023273617A1

WO2023273617A1 - Engine capability-based entity function implementation method and apparatus and electronic device

Info

Publication number: WO2023273617A1
Application number: PCT/CN2022/091676
Authority: WO
Inventors: 徐远; 马锐锋
Original assignee: 北京字跳网络技术有限公司
Priority date: 2021-06-29
Filing date: 2022-05-09
Publication date: 2023-01-05
Also published as: CN115543262A

Abstract

An engine capability-based entity function implementation method and apparatus and an electronic device, the method comprising: in response to a triggering operation on a target object name, displaying an entity node corresponding to the target object name in a configuration panel (101); searching for pre-built node names representing engine capability, and in response to a triggering operation on at least one target node name in the node names that is associated with the target object name and that implements a target function, displaying the least one target node corresponding to the at least one target node name in the configuration panel (102); and in response to a triggering operation on the connection between an entity node and each target node according to a logical requirement, driving each target node to run the engine capability so as to achieve the target function (103). By using the described technical solution, developers do not need to write a large amount of code to expose engine capability, which achieves high-efficiency development and reduces development costs.

Description

Entity function realization method, device and electronic equipment based on engine capability

Cross References to Related Applications

This application is based on the Chinese application with the application number 202110729945.7 and the filing date is June 29, 2021, and claims its priority. The disclosure content of the Chinese application is hereby incorporated into this application as a whole.

technical field

The present disclosure relates to the technical field of visual programming, and in particular to a method, device and electronic device for implementing entity functions based on engine capabilities.

Background technique

Under the Entity Component System (Entity-Component-System, ECS) architecture, the calling sequence of using a certain function of the engine is: entity Entity-> get component component-> use attribute or method.

Contents of the invention

According to one aspect of the present disclosure, an embodiment of the present disclosure provides a method for realizing an entity function based on an engine capability, the method comprising: in response to a trigger operation on the name of the target object, displaying on the configuration panel the Corresponding entity node; searching for a pre-built node name representing engine capability, in response to a trigger operation on at least one target node name associated with the target object name among the node names and realizing the target function, in the At least one target node corresponding to the name of the at least one target node is displayed on the configuration panel; and in response to triggering an operation on the connection between the entity node and each of the target nodes according to logical requirements, driving each of the target nodes to run Engine capabilities to achieve the stated target functionality.

According to another aspect of the present disclosure, an embodiment of the present disclosure also provides an apparatus for implementing entity functions based on engine capabilities, the apparatus including: a first display module, configured to respond to a trigger operation on the name of the target object, and configure The entity node corresponding to the name of the target object is displayed on the panel; the second display module searches the pre-built node name representing the engine capability, and responds to the node name associated with the name of the target object and achieves the goal A trigger operation of at least one target node name of the function, displaying at least one target node corresponding to the at least one target node name on the configuration panel; and a driving module, configured to respond to the physical node and the The connection between each of the target nodes triggers an operation to drive each of the target nodes to run engine capabilities to realize the target function.

According to another aspect of the present disclosure, an embodiment of the present disclosure further provides an electronic device, the electronic device comprising: a processor; a memory for storing instructions executable by the processor; The executable instruction is read from the memory, and the instruction is executed to implement the engine capability-based entity function implementation method provided by the embodiment of the present disclosure.

According to another aspect of the present disclosure, the embodiment of the present disclosure further provides a computer-readable storage medium, the storage medium stores a computer program, and the computer program is used to execute the engine capability-based engine provided by the embodiment of the present disclosure. Entity function realization method.

According to another aspect of the present disclosure, an embodiment of the present disclosure further provides a computer program, including: instructions, which when executed by a processor cause the processor to execute the engine capability-based Entity function realization method.

According to another aspect of the present disclosure, an embodiment of the present disclosure further provides a computer program product, including instructions, the instructions, when executed by a processor, cause the processor to execute the engine capability-based Entity function realization method.

Description of drawings

The above and other features, advantages and aspects of the various embodiments of the present disclosure will become more apparent with reference to the following detailed description in conjunction with the accompanying drawings. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic and that elements and elements are not necessarily drawn to scale.

FIG. 1 is a schematic flowchart of a method for implementing an entity function based on an engine capability provided by an embodiment of the present disclosure;

Fig. 2A is an example Fig. 1 of searching for a node name representing an engine capability;

Fig. 2B is an example Fig. 2 of searching for a node name representing an engine capability;

Fig. 2C is an example Fig. 3 of searching for a node name representing an engine capability;

FIG. 3 is a schematic flowchart of another method for implementing entity functions based on engine capabilities provided by an embodiment of the present disclosure;

Figure 4A is an example diagram of a generated component node;

Figure 4B is an example diagram of the generated read attribute node and set attribute node;

Figure 4C is an example diagram of a generated function node;

FIG. 5 is an example diagram of visual programming for realizing the function of clicking the screen to shift the position of the sticker by using the engine capability-based entity function implementation scheme provided by the present disclosure;

FIG. 6 is a schematic structural diagram of an apparatus for realizing an entity function based on an engine capability provided by an embodiment of the present disclosure;

FIG. 7 is a schematic structural diagram of another device for implementing entity functions based on engine capabilities provided by an embodiment of the present disclosure;

FIG. 8 is a schematic structural diagram of an electronic device provided by an embodiment of the present disclosure.

detailed description

Embodiments of the present disclosure will be described in more detail below with reference to the accompanying drawings. Although certain embodiments of the present disclosure are shown in the drawings, it should be understood that the disclosure may be embodied in various forms and should not be construed as limited to the embodiments set forth herein; A more thorough and complete understanding of the present disclosure. It should be understood that the drawings and embodiments of the present disclosure are for exemplary purposes only, and are not intended to limit the protection scope of the present disclosure.

It should be understood that the various steps described in the method implementations of the present disclosure may be executed in different orders, and/or executed in parallel. Additionally, method embodiments may include additional steps and/or omit performing illustrated steps. The scope of the present disclosure is not limited in this respect.

As used herein, the term "comprise" and its variations are open-ended, ie "including but not limited to". The term "based on" is "based at least in part on". The term "one embodiment" means "at least one embodiment"; the term "another embodiment" means "at least one further embodiment"; the term "some embodiments" means "at least some embodiments." Relevant definitions of other terms will be given in the description below.

It should be noted that concepts such as "first" and "second" mentioned in this disclosure are only used to distinguish different devices, modules or units, and are not used to limit the sequence of functions performed by these devices, modules or units or interdependence.

It should be noted that the modifications of "one" and "multiple" mentioned in the present disclosure are illustrative and not restrictive, and those skilled in the art should understand that unless the context clearly indicates otherwise, it should be understood as "one or more" multiple".

The inventors of the present disclosure found that in software development, there are hundreds of components, attributes, and methods in the engine. If each component, attribute, etc. is written in code, it will bring high development costs and low efficiency .

In view of this, an embodiment of the present disclosure provides a method for implementing an entity function based on an engine capability, and the method will be introduced in conjunction with specific embodiments below.

Fig. 1 is a schematic flowchart of a method for realizing an entity function based on engine capability provided by an embodiment of the present disclosure. The method can be executed by a device for realizing an entity function based on engine capability, wherein the device can be implemented by software and/or hardware, generally Can be integrated in electronic equipment. As shown in FIG. 1 , the method includes step 101 to step 103 .

Step 101 , in response to a trigger operation on the name of the target object, display the entity node corresponding to the name of the target object on the configuration panel.

Wherein, the target object includes an entity, the name of the target object is the name of the entity, and the target object refers to the object that needs to be operated to realize the target function. For example, the target function to be realized is to control the rotation of the camera, then the camera is the target object. For another example, if the target function to be realized is to control the position movement of a 2D image, then the 2D image is the target object.

In the embodiment of the present disclosure, the entity node corresponding to the name of the target object can be pre-packaged and displayed in the toolbar area of the configuration panel. When it is necessary to control the target object to achieve a certain function, the developer can find the The name of the target object of the target object, and a trigger operation is performed on the name of the target object. In response to the trigger operation, the device for realizing the entity function based on the engine capability displays the entity node corresponding to the name of the target object on the configuration panel.

Wherein, the triggering operation includes but not limited to mouse click, touch pen click, finger click, mouse drag, touch pen drag, finger drag, etc., which is not limited in the present disclosure.

Step 102: Search for pre-built node names that represent engine capabilities, and respond to trigger operations on at least one target node name that is associated with the target object name and realizes the target function in the node name, and displays on the configuration panel that is related to at least one target node name At least one target node corresponding to the node name.

Among them, the node name representing the engine capability refers to the name of the visualization node that needs to be relied upon to realize a certain function. A visualization node represents a specific engine capability. Visualization nodes can include component nodes, read attribute nodes, function nodes, etc. Among them, the engine capabilities of component nodes and read attribute nodes can provide data for other nodes, and the engine capabilities of function nodes can open logic control capabilities and complex engines to users Function.

It can be understood that for developers, it is the basic knowledge of which engine capabilities to implement a certain function. When the target function is realized for the target object, the node names of the pre-built nodes can be searched, and at least one target node name can be determined from each node name, wherein at least one target node name is associated with the target object and used for The name of the node that implements the target function. The developer performs a trigger operation on at least one target node name, and in response to the trigger operation, the entity function realization device based on the engine capability displays the target node corresponding to each target node name on the configuration panel.

For example, assuming that the target function that the developer needs to achieve is to shift the position of the sticker when the screen is tapped, the target object is a sticker, and the name of the target object is recorded as Sprite2D. Developers know that the Transform2D component is required to implement the position offset function, so they can search the pre-built node names to find the Transform2D component. In the embodiment of the present disclosure, different ways may be used to find the Transform2D component associated with the target object name Sprite2D, which will be introduced respectively below.

As an example, FIG. 2A is a first example of searching for a node name representing an engine capability. As shown in Figure 2A, because the component is to be searched, the developer can input the index string "comp" of the component component in the pre-built node name to search for the existing component name, and then according to the current target object (Sprite2D ) and the target component (Transform2D) to be searched, find the target node name associated with the target object (Sprite2D) from the multiple node names displayed in the search result list, as shown in Figure 2A, the target node name is "comp:: getTransform2D(Sprite2D)".

As another example, FIG. 2B is a second example of searching for node names representing engine capabilities. As shown in Figure 2B, since the Transform2D component is to be searched, the developer can input the character string "Transform2D" or input a part of the character string of Transform2D (for example, input Tran or tran) to search. In Figure 2B, the input character string tran is used as For example, according to the current target object (Sprite2D), find the target node name associated with the target object (Sprite2D) from the node names of all Transform2D components displayed in the search result list, as shown in Figure 2B, the target node name is "comp::getTransform2D(Sprite2D)".

As another example, Fig. 2C is an example Fig. 3 of searching for a node name representing an engine capability. As shown in Figure 2C, the developer can call up the search box by drawing a connection line from the entity node (Sprite2D) corresponding to the target object name, and all nodes associated with the target object (Sprite2D) will be displayed below the search box Name, the developer can find the name of the target node by looking it up from the list, or by entering a character string related to the Transform2D component to be found in the search box (such as entering Transform) to search, as shown in Figure 2C, the target node The name is "comp::getTransform2D(Sprite2D)", which realizes focused search and can improve search efficiency.

Afterwards, when the developer triggers (for example, mouse clicks) the searched target node name, the target node corresponding to the target node name is displayed on the configuration panel.

Step 103 , in response to triggering an operation on the connection between the entity node and each target node according to the logic requirement, driving each target node to run the engine capability to realize the target function.

In the embodiment of the present disclosure, after the entity node and multiple target nodes are displayed on the configuration panel, the developer can configure the connection relationship between the entity node and each target node according to the logical requirements, and execute the connection trigger operation, such as the entity node and the target node The input of the target node representing the component in the node is connected to obtain the component associated with the target object, the output of the target node representing the component is connected to the input of the target node representing the attribute to set the attribute information of the component, and so on. The entity function realization device based on the engine capability responds to the connection trigger operation between the entity node and each target node, configures the connection relationship between each node, and then drives each target node to run the engine capability according to the connection relationship, so as to realize the target function.

In the implementation method of the entity function based on the engine capability in the embodiment of the present disclosure, in response to the trigger operation on the target object name, the entity node corresponding to the target object name is displayed on the configuration panel, and the pre-built node name representing the engine capability is searched for, and the response Based on the trigger operation on at least one target node name associated with the target object name in the node name and realizing the target function, at least one target node corresponding to the at least one target node name is displayed on the configuration panel, and then in response to the logical requirement Trigger the operation on the connection between the entity node and each target node, and drive the engine capability of each target node to realize the target function. With the above technical solution, only need to search for the pre-built node name and trigger the required target node name, the target node corresponding to the target node name can be displayed, and then the connection relationship between each node can be configured according to the logical requirements to achieve the goal Functions, developers do not need to write a large amount of code to expose engine capabilities, achieving high-efficiency development and reducing development costs.

In some embodiments, the target node includes a control-type target node with a control trigger port and a data-type target node with all ports as data ports, so that each target node is driven to run the engine to realize the target function, including: when the control-type target When the node is triggered, obtain the data information provided by the data target node connected to the control target node; process according to the operation logic and data information of the control target node, and output the corresponding processing results to realize the target function.

Exemplarily, a set attribute node with a control trigger port is a control type target node, and a read attribute node for obtaining an attribute value corresponding to a certain attribute of a component node is a type of data type target node.

In the embodiment of the present disclosure, the developer executes the connection trigger operation between the entity node and the control target node and the data target node to configure the connection relationship between each node, and the entity function realization device based on the engine capability responds to the connection trigger Operation, configure the connection relationship among entity nodes, control target nodes, and data target nodes. When the control target node is triggered, the control target node reads data information from the data target node connected to it, and Complete the specific control task operation according to its own operation logic and read data information, and then output the corresponding processing results to achieve the target function.

For example, assuming that the target function to be realized is to change the size of the sticker when the screen is clicked, then when the screen is clicked, the node corresponding to the clicked screen inputs the control flow to the control target node, and the control target node used to change the size of the sticker is Triggered, at this time, the control target node obtains the data provided by the data target node connected to the control target node, so as to calculate the size of the sticker according to the operation logic of the control target node and the obtained data, and then output the calculated sticker Size to achieve sticker size change.

In the above scheme, when the control target node is triggered, the data information provided by the data target node connected to the control target node is obtained, processed according to the operation logic and data information of the control target node, and the corresponding processing results are output as To realize the target function, it only needs to configure the connection relationship between each target node to realize the target function based on the engine capability of each target node, avoiding manual programming code and improving development efficiency.

FIG. 3 is a schematic flowchart of another method for implementing entity functions based on engine capabilities provided by an embodiment of the present disclosure. On the basis of the above embodiments, this embodiment further optimizes the method for implementing entity functions based on engine capabilities. As shown in FIG. 3 , the method includes step 201 to step 205 .

Step 201, acquiring a configuration file for storing engine data.

Among them, the engine data can be determined according to the engine running instance, and the engine running instance depends on the engine capability implemented by several components, attributes, function methods and other data. Therefore, in the embodiments of the present disclosure, the engine data can include but not limited to the engine running instance All the components, properties, function methods and other data that are dependent on time.

In the embodiment of the present disclosure, the configuration file may be pre-generated and stored locally, or obtained from the server, or generated according to the engine runtime instance, which is not limited in the present disclosure.

As a possible implementation, the configuration file can be generated in real time, and the configuration file for saving the engine data is obtained, including: obtaining the runtime type information RTTI (Runtime Type Information) attribute of the current engine through the engine running instance; obtaining according to the RTTI attribute The RTTI object contains the class name, attribute, function and inheritance relationship, and saves it as a configuration file in json format.

Among them, the inheritance relationship refers to the inheritance relationship between the RTTI classes of the engine, that is, which parent class a certain RTTI class inherits from, and the inherited attributes and function methods can be obtained through the inheritance relationship.

It can be understood that the engine has RTTI attributes, which can obtain information such as runtime type and object attributes. When the engine is loaded, all RTTI information of the engine runtime can be obtained through the engine running instance, and the inheritance of each RTTI class can be obtained through the RTTI information. Relationships, as well as the properties and function methods exposed by the RTTI class, parse out the relevant information of each RTTI class, which can be recorded in the json file and saved as a configuration file in json format.

As an example, the configuration file in json format may include the class name of the RTTI class, the parent class inherited by the RTTI class, attribute information and function information of the RTTI class. Among them, the subclass can inherit the attributes and function methods of the parent class. The attribute information includes but not limited to the attribute name, the attribute RTTI type, whether the attribute is readable and writable; the function information includes but not limited to the function name, the RTTI type returned by the function, the The number of parameters required by the function and the RTTI type of the parameter.

In the above technical solution, since the runtime instance includes all components, attributes and functions available in the current engine version and runtime environment, all RTTI attributes of the current engine are obtained through the engine running instance, and the class name contained in the RTTI object is obtained according to the RTTI attribute , attributes, functions, and inheritance relationships, and save them as configuration files in json format. The configuration file records all engine data that meets the current engine version and operating environment. When using it, it can effectively avoid calling closed, Restricted or isolated functionality creates a risk of engine crashes. Moreover, saving the class name, attribute, function and inheritance relationship contained in the RTTI object as a configuration file in json format can realize flexible function configuration and distribution, and realize a fast node search function.

It should be noted that the json format of the configuration file is only an example, and the configuration file may also be in other formats, such as YAML format, INI format, etc., which is not limited in this disclosure.

As another possible implementation, the configuration file can be delivered by the server along with the engine version, and the server will pre-generate the configuration file corresponding to each instance according to the instances that the current version of the engine can run and send it along with the engine version. Send it to the client, and the client saves the configuration file locally when installing the engine, so that when implementing the engine capability-based entity function implementation solution of the present disclosure, the engine capability-based entity function implementation device can obtain and save the engine capability from the local Data profile.

Step 202, constructing node names representing engine capabilities according to the configuration file, and constructing nodes corresponding to each node name for display on the configuration panel.

In the embodiment of the present disclosure, after obtaining the configuration file for saving engine data, according to the configuration file, a node name indicating the engine capability can be constructed for searching, and a node name corresponding to each node name can be constructed for display on the configuration panel. node.

As a possible implementation, you can generate the corresponding class node name, attribute node name and function node name according to the class name, attribute and function recorded in the configuration file, and generate The property node corresponding to the property node name generates a function node corresponding to the function node name according to the function name, return type and function parameters.

As another possible implementation, when the configuration file is in json format, construct node names representing engine capabilities according to the configuration files, and construct nodes corresponding to each node name for display on the configuration panel, including: parsing json format configuration file to obtain the class name of the RTTI object, and generate the node name of the component node according to the class name; wherein, the component node includes: the input port for inputting the entity node to which the component node belongs and the output for outputting the functional object related to the component node port.

Among them, the output of the output port of the component node is related to the function of the component node. For example, the function of the component node "comp::getTransform" is to obtain the Transform component of the entity node, and the output object of the output port of the component node is the Transform component.

For example, assume that the content recorded in the configuration file in json format includes: the RTTI class name is "Transform2d", the parent class inherited by the RTTI class is "Transform", and in the attribute information corresponding to the RTTI class, the attribute name is "Position ", the attribute RTTI type is "Vector2f", the attribute is readable and writable, in the function information corresponding to the RTTI class, the function name is "setWorldPosition", the function return RTTI type is "Vector3f", and the number of input parameters required by the function There are 2, and the parameter RTTI type of each input parameter is "Vector3f". Parsing the configuration file in the above json format shows that the parent class of the RTTI class is Transform, and the class name of the RTTI class is "Transform2d", and the node name of the component node that can be generated according to the class name is "comp::getTransform2d". In order to facilitate developers to distinguish the entity to which the component belongs, RTTI objects can be used for marking. Assuming that the RTTI object corresponding to the above class name Transform2d is a 2D image, the above component node name can be recorded as "comp::getTransform2d(2D image)".

Since the component node itself does not need to have logic control functions, as long as it provides data, these pure data nodes do not provide control flow input and output, so the component node does not contain control input, and the component node input holds the entity Entity of the component (RTTI object ), output the component object you want to get. That is to say, a component node includes an input port and an output port. The input port is used to input the entity node to which the component node belongs, and the output port is used to output the related functional object of the component. If the component does not exist in the Entity, the output is empty. Figure 4A is an example diagram of the generated component node, as shown in Figure 4A, the component node only includes an input port (Entity) and an output port, the input data stream of the input port is a 2D image of the entity node, and the output data of the output port The stream is Transform2d for this component.

Optionally, parsing the configuration file in json format can also generate attribute node names and corresponding attribute nodes. Specifically, it includes: parsing the configuration file in json format, obtaining the attribute information array of the RTTI object according to the class and inheritance relationship of the RTTI object, and generating the node name of the attribute node according to the attribute name of the attribute information array; wherein, the attribute node includes the read attribute Nodes and set attribute nodes, wherein the read attribute node includes: an input port for inputting the component node to which the read attribute node belongs and an output port for outputting the corresponding attribute value of the read attribute node; the set attribute node includes: for controlling An input port for triggering, an input port for inputting the component node to which the property node belongs, an input port for obtaining the property value, an output port for controlling the trigger, and an output port for outputting the set property value.

Specifically, the attribute node can be generated according to the attribute information in the configuration file in json format. Since the parent class of the RTTI class is recorded, the parent class of the RTTI component can be known and the inherited attributes can be obtained. According to whether the attribute is readable and writable, a read attribute node (when the attribute is readable) and a set attribute node (when the attribute is writable) can be generated. The read attribute node is used to provide data for other nodes, and it does not have a logic control function. Therefore, the read attribute node includes an input port and an output port. The input port is used to input the component node to which the read attribute node belongs, that is, the input The component that needs to get attributes, the output port is used to output the attribute value corresponding to the read attribute node. Setting attribute nodes needs to be open to developers to control logic, allowing developers to control under what conditions the node sets attributes. Therefore, setting attribute nodes has control flow input ports and output ports. Setting attribute nodes requires input components and attribute data, and will This data is used as the output data of the output port. Therefore, the setting attribute node includes three input ports, which are the input port for controlling the trigger, the input port for inputting the component node to which the setting attribute node belongs, the input port for obtaining the attribute value, and two output ports, They are the output port used to control the trigger and the output port used to output the set property value respectively. When the input port of the set attribute node used to control the trigger has data stream input, the set attribute node obtains the component whose attribute needs to be set, and sets the corresponding attribute value of the component as the input value.

Continuing to take the aforementioned configuration file in json format as an example, according to the attribute information array recorded in the configuration file, it can be determined that the attribute name is "Position", and it can be determined that the attribute is readable and writable. Parsing the configuration file shows that the attribute array inherits Based on the class name "Transform2d", the read property node name can be generated as "getPosition(Transform2d)", and the set property node name can be generated as "setPosition(Transform2d)". Moreover, a read property node and a set property node may be generated according to the configuration file, as shown in FIG. 4B . As can be seen from Figure 4B, the read attribute node (getPosition) includes an input port (Transform2d) for inputting the component node to which the read attribute node belongs and an output port for outputting the corresponding attribute value of the read attribute node. The node (setPosition) includes three input ports and two output ports. The input ports are the control port (Trigger), the port (Transform2d) used to input the component node to which the attribute node belongs, and the port to obtain the attribute value (use the attribute value type Vector2f representation).

Optionally, parsing the configuration file in json format can also generate function node names and corresponding function nodes. Specifically, it includes: parsing the configuration file in json format, obtaining the function information array of the RTTI object according to the class and inheritance relationship of the RTTI object, and generating the node name of the function node according to the function name of the function information array; wherein, the function node includes: for An input port for controlling triggering, an input port for inputting component nodes or entity nodes to which a function node belongs, an input port for obtaining one or more function parameters, an output port for controlling triggering, and an output function return Output port for attribute values.

Function nodes need to be open to developers for logic control capabilities, allowing developers to control the conditions under which nodes execute functions, so function nodes have control flow input ports and output ports. Function nodes need input components and function parameters, and output function return value data. When generating a function node, the function node can be generated according to the function information in the configuration file in json format. Since the parent class of the RTTI class is recorded, the parent class of the RTTI component can be known, and the inherited function method can be obtained. In the function information array It also records the function name, input parameters and return value type, and the function node port can be generated according to these information. The function node includes multiple input ports, which are the input port used to control the trigger, the input port used to input the component node or entity node to which the function node belongs, and the input port used to obtain one or more function parameters. The function node It includes two output ports, which are the output port used to control the trigger and the output port used to output the attribute value returned by the function. When the input port used to control the trigger is activated, the function node executes the function according to the parameters input in each input port used to obtain the function input parameters, and outputs the execution result.

Continuing to take the aforementioned configuration file in json format as an example, according to the function information array recorded in the configuration file, it can be determined that the function name is "setWorldPosition". After parsing the configuration file, it can be known that the function array inherits from the parent class "Transform", then you can generate The function node name is "func::setWorldPosition(Transform)". The function array also records that the data type of the output value of the function is "Vector3f", and there are two input parameters of the function, both of type "Vector3f", so the function node func::setWorldPosition can be generated as shown in Figure 4C. As can be seen from Figure 4C, the function node includes four input ports and two output ports, the four input ports are the control port (Trigger), the port of the component node to which the input function node belongs (expressed by Transform) and two parameters The input port (both represented by the parameter type Vector3f), and the two output ports are the control port (Trigger) and the function return value output port (represented by the return value class Vector3f).

The solution of the embodiment of the present disclosure generates visual nodes by parsing configuration files in json format, realizes the use of unified rules to generate node styles, generates formatted running codes, avoids a lot of repetitive mechanical development, and can improve development efficiency.

It should be noted that the execution sequence of steps 201-202 in FIG. 3 is only used as an example to explain the present disclosure, but not as a limitation to the present disclosure. Steps 201-202 only need to be executed before step 204.

Step 203, in response to the trigger operation on the name of the target object, display the entity node corresponding to the name of the target object on the configuration panel.

It should be noted that, in the embodiment of the present disclosure, for the description of step 203, reference may be made to the description of step 101 in the foregoing embodiments, and details are not repeated here.

Step 204: Search for pre-built node names representing engine capabilities, and in response to a trigger operation on at least one target node name that is associated with the target object name and realizes the target function in the node name, display on the configuration panel that is related to at least one target node name At least one target node corresponding to the node name.

It should be noted that, in the embodiment of the present disclosure, the description of searching for the pre-built node name representing the engine capability may refer to the relevant content of the foregoing embodiments, and details are not repeated here.

In the embodiment of the present disclosure, the atomized nodes generated by parsing the configuration file can be divided into three categories, component nodes, attribute nodes (including setting attribute nodes and reading attribute nodes) and function nodes, then in response to the node name and target object The trigger operation of at least one target node name associated with the name and realizing the target function, displaying at least one target node corresponding to the at least one target node name on the configuration panel, including: responding to the node name associated with the target object name , the trigger operation of the target component node name used to realize the target function, and display the target component node corresponding to the target component node name on the configuration panel; The target property node name of , and/or, the trigger operation of the target function node name, display the target property node corresponding to the target property node name on the configuration panel, and/or, display the target function node corresponding to the target function node name.

In the embodiment of the present disclosure, when the developer needs to implement a certain function, he can search for the pre-built node name representing the engine capability, find out the target component node name associated with the target object name for realizing the target function, and execute the trigger Operation, the entity function implementing device based on the engine capability responds to the trigger operation, displays the target component node on the configuration panel, and continues to search for the target attribute node name and/or target associated with the target component node name and used to realize the target function name of the function node and execute a trigger operation, and the device for realizing the entity function based on the engine capability responds to the trigger operation and displays the target property node and/or the target function node on the configuration panel.

Step 205 , in response to triggering an operation on the connection between the entity node and each target node according to the logic requirement, driving each target node to run the engine capability to realize the target function.

In the embodiment of the present disclosure, after the target nodes required to realize the target function are displayed in the configuration panel, the developer can configure the connection relationship between the entity node and each target node according to the logical requirements, execute the connection trigger operation, and the entity function based on the engine capability In response to the connection triggering operation, the realizing device drives each target node to run the engine capability to realize the target function.

It can be understood that different target nodes have different engine capabilities. In the embodiment of the present disclosure, driving each target node to run engine capabilities includes at least one of the following: the component node obtains the entity to which it belongs, and outputs the component object of the entity; reads the attribute The node obtains the component it belongs to, and outputs the current attribute value of the component; when the control port of the set attribute node is triggered, obtains the component whose attribute needs to be set, and sets the attribute value of the component; or when the input control port of the function node is triggered, according to the function parameter Execute the function output return value.

In the embodiment of the disclosure, when each target node is driven to run the engine capability, the component node is used to obtain the entity to which it belongs, and output the component object of the entity, read the property node to obtain the component to which it belongs, and output the current attribute value of the obtained component, for setting Property node, when the control port of the setting property node is triggered, obtain the component that needs to be set, and set the property value of the obtained component. For the function node, when the input control port of the function node is triggered, according to the obtained The function parameter executes the corresponding function and outputs the return value.

In the above technical solution, the developer performs a connection trigger operation to configure the connection relationship of each target node, and responds to the connection trigger operation to drive the engine capability of each target node to achieve the target function, and completes the exposure of the engine capability without writing code, realizing The ability to control the runtime is improved, and the development efficiency is improved.

The implementation method of the entity function based on the engine capability provided by the embodiment of the present disclosure obtains the configuration file for saving the engine data, constructs the node name representing the engine capability according to the configuration file, and constructs the node name corresponding to each node name for displaying on the configuration panel. , and then by searching each node name, in response to a trigger operation on at least one target node name associated with the target object name in the node name and realizing the target function, the corresponding node name corresponding to the at least one target node name is displayed on the configuration panel At least one target node, in response to the trigger operation of the connection between the entity node and each target node according to the logical requirements, drives each target node to run the engine capability to achieve the target function, thereby realizing visual programming, and the required in the engine instance Components, properties and functions are reflected into atomic nodes, the runtime logic is configured through connections, and the engine capabilities can be exposed without manual coding, realizing special effect production.

In order to facilitate the understanding of the engine capability-based entity function implementation solution provided by the present disclosure, an example is given below for illustration.

FIG. 5 is an example diagram of visual programming for realizing the function of clicking the screen to shift the position of stickers by adopting the entity function implementation solution based on engine capability provided by the present disclosure.

As shown in Figure 5, the target function that the developer wants to achieve is to tap the screen to shift the position of the sticker during playback (x:100, y:200). The configuration steps for visual programming to realize this function are: because it is necessary to set is the position attribute of the sticker, and the name of the target object is a sticker (2D picture), so you can first drag in the entity node from the special effect information panel, and the name of the entity node is the 2D picture, where the entity node is pre-packaged and What is displayed in the special effect information panel can be directly displayed on the configuration panel by dragging and dropping without searching. Developers know that the set position attribute is controlled by the Transform2d component, so search and find Transform2d on the configuration panel, add the component node "comp::getTransform2d", and connect the entity node (2D image) with the component node comp::getTransform2d Entity port connection. If you want to offset the position of the sticker, you need to get the current position of the sticker. You can get the current position of the sticker from the component Transform2d through the read attribute node getPosition; add a numerical observation node, and input the observation value X to 100, Y is 200; through the addition operation node, add the current position of the sticker to the observation value input by the numerical observation node to obtain the desired end position, where, in the addition operation node, the value A is the current position obtained, and the value B is the input observation value. Add the setting property node of setPosition by searching, connect the output port of the component node comp::getTransform2d to the input port (Transform2d) of the setPosition node to indicate the component it belongs to, and connect the end position data output by the addition node to the setPosition node The input port (Vector2f) used to obtain the attribute value, and add a click screen control node, and connect the click screen control node to the control flow input port (Trigger) of the setPosition node, thus configuring the connection relationship of each node.

In Figure 5, the touch screen control node, numerical observation node, and addition operation node can be pre-packaged nodes for realizing script functions, which can be directly dragged and used without searching. When the developer clicks on the screen, the setPosition node is activated. It traces back to find the data input of the node, obtains the end position of the output of the Transform2d component and the addition operation node, and then sets its own position attribute to change the sticker position from the original position (x:100, y:200) to the end position (x:200, y:400), realizing the function of offsetting the sticker position (x:100, y:200) when the screen is tapped. As a result, the function of tapping the screen to shift the position of the sticker is realized without the need for developers to manually write code.

FIG. 6 is a schematic structural diagram of an apparatus for realizing an entity function based on an engine capability provided by an embodiment of the present disclosure. The apparatus may be implemented by software and/or hardware, and may generally be integrated into an electronic device. As shown in FIG. 6 , the apparatus for implementing entity functions based on engine capabilities includes: a first display module 301 , a second display module 302 and a driving module 303 .

The first display module 301 is configured to display an entity node corresponding to the target object name on the configuration panel in response to a trigger operation on the target object name.

The second display module 302 searches for pre-built node names representing engine capabilities, responds to a trigger operation on at least one target node name associated with the target object name among the node names and realizes the target function, in the At least one target node corresponding to the at least one target node name is displayed on the configuration panel.

The driving module 303 is configured to drive each of the target nodes to run an engine capability to realize the target function in response to triggering an operation on the connection between the entity node and each of the target nodes according to a logic requirement.

Optionally, the target node includes a control target node with a control trigger port and a data target node with all ports being data ports, and the driving module 303 is specifically configured to: when the control target node is triggered, Obtaining data information provided by the data target node connected to the control target node; and processing according to the operation logic of the control target node and the data information, and outputting corresponding processing results to achieve the target Function.

Optionally, as shown in FIG. 7 , the device 30 for implementing entity functions based on engine capabilities further includes: an acquisition module 304, configured to acquire a configuration file for storing engine data; and a construction module 305, configured to construct a configuration file according to the configuration file. The node names representing engine capabilities, and nodes corresponding to each node name are constructed for display on the configuration panel.

Optionally, the obtaining module 304 is specifically used to: obtain the runtime type information RTTI attribute of the current engine through the engine running instance; and obtain the class name, attribute, function and inheritance relationship contained in the RTTI object according to the RTTI attribute, and save it as Configuration file in json format.

Optionally, the construction module 305 is specifically configured to: parse the configuration file in the json format to obtain the class name of the RTTI object, and generate a node name of the component node according to the class name; the component node includes: An input port for inputting the entity node to which the component node belongs and an output port for outputting the functional object related to the component node.

Optionally, the construction module 305 is further configured to: parse the configuration file in json format, obtain the property information array of the RTTI object according to the class and inheritance relationship of the RTTI object, and obtain the property information array of the RTTI object according to the properties of the property information array The name generates the node name of the attribute node; wherein, the attribute node includes a read attribute node and a set attribute node, wherein the read attribute node includes: an input port for inputting the component node to which the read attribute node belongs and An output port for outputting the attribute value corresponding to the read attribute node; the set attribute node includes: an input port for controlling triggering, an input port for inputting the component node to which the set attribute node belongs, and an input port for obtaining An input port for the property value, an output port for controlling the trigger, and an output port for outputting the set property value.

Optionally, the construction module 305 is further configured to: parse the configuration file in the json format, obtain the function information array of the RTTI object according to the class and inheritance relationship of the RTTI object, and generate the function information array according to the function name of the function information array The node name of the function node; wherein, the function node includes: an input port for controlling triggering, an input port for inputting the component node or entity node to which the function node belongs, and obtaining one or more function parameters The input port for the , the output port for controlling the trigger, and the output port for the output function to return the property value.

Optionally, the second display module 302 is specifically configured to: respond to a trigger operation on the target component node name associated with the target object name in the node name and used to realize the target function, in the configuration The target component node corresponding to the target component node name is displayed on the panel; in response to the target attribute node name associated with the target component node name in the node name and used to realize the target function, and/or , a trigger operation of the target function node name, displaying the target attribute node corresponding to the target property node name on the configuration panel, and/or displaying the target function node corresponding to the target function node name.

Optionally, the driving module 303 is specifically configured to: the component node obtains the entity to which it belongs, and outputs the component object of the entity; the read attribute node obtains the component to which it belongs, and outputs the current attribute value of the component; the When the control port of the property setting node is triggered, obtain the component whose property needs to be set, and set the property value of the component; or when the input control port of the function node is triggered, execute the function according to the function parameter and output the return value.

The device for implementing an entity function based on engine capability provided by an embodiment of the present disclosure can execute the method for implementing an entity function based on engine capability provided by any embodiment of the present disclosure, and has corresponding functional modules and beneficial effects for executing the method.

In order to implement the above embodiments, the present disclosure further proposes a computer program product, including computer programs/instructions, and when the computer programs/instructions are executed by a processor, the methods for implementing entity functions based on engine capabilities in the above embodiments are implemented.

Referring to FIG. 8 in detail below, it shows a schematic structural diagram of an electronic device 400 suitable for implementing an embodiment of the present disclosure. The electronic device 400 in the embodiment of the present disclosure may include, but is not limited to, mobile phones, notebook computers, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Tablet Computers), PMPs (Portable Multimedia Players), vehicle-mounted terminals ( Mobile terminals such as car navigation terminals) and stationary terminals such as digital TVs, desktop computers and the like. The electronic device shown in FIG. 8 is only an example, and should not limit the functions and scope of use of the embodiments of the present disclosure.

As shown in FIG. 8, an electronic device 400 may include a processing device (such as a central processing unit, a graphics processing unit, etc.) Various appropriate actions and processes are executed by programs in the memory (RAM) 403 . In the RAM 403, various programs and data necessary for the operation of the electronic device 400 are also stored. The processing device 401, the ROM 402, and the RAM 403 are connected to each other through a bus 404. An input/output (I/O) interface 405 is also connected to bus 404 .

Typically, the following devices can be connected to the I/O interface 405: input devices 406 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, etc.; including, for example, a liquid crystal display (LCD), speaker, vibration an output device 407 such as a computer; a storage device 408 including, for example, a magnetic tape, a hard disk, etc.; and a communication device 409. The communication means 409 may allow the electronic device 400 to perform wireless or wired communication with other devices to exchange data. While FIG. 8 shows electronic device 400 having various means, it should be understood that implementing or having all of the means shown is not a requirement. More or fewer means may alternatively be implemented or provided.

In particular, according to an embodiment of the present disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product, which includes a computer program carried on a non-transitory computer readable medium, where the computer program includes program code for executing the method shown in the flowchart. In such an embodiment, the computer program may be downloaded and installed from a network via communication means 409, or from storage means 408, or from ROM 402. When the computer program is executed by the processing device 401, the above-mentioned functions defined in the engine capability-based entity function implementation method of the embodiment of the present disclosure are executed.

It should be noted that the above-mentioned computer-readable medium in the present disclosure may be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. A computer readable storage medium may be, for example, but not limited to, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to, electrical connections with one or more wires, portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable Programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination of the above. In the present disclosure, a computer-readable storage medium may be any tangible medium that contains or stores a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In the present disclosure, however, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave carrying computer-readable program code therein. Such propagated data signals may take many forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the foregoing. A computer-readable signal medium may also be any computer-readable medium other than a computer-readable storage medium, which can transmit, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device . Program code embodied on a computer readable medium may be transmitted by any appropriate medium, including but not limited to wires, optical cables, RF (radio frequency), etc., or any suitable combination of the above.

In some embodiments, the client and the server can communicate using any currently known or future network protocols such as HTTP (HyperText Transfer Protocol, Hypertext Transfer Protocol), and can communicate with digital data in any form or medium The communication (eg, communication network) interconnections. Examples of communication networks include local area networks ("LANs"), wide area networks ("WANs"), internetworks (e.g., the Internet), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future developed network of.

The above-mentioned computer-readable medium may be included in the above-mentioned electronic device, or may exist independently without being incorporated into the electronic device.

The above-mentioned computer-readable medium carries one or more programs, and when the above-mentioned one or more programs are executed by the electronic device, the electronic device: in response to a trigger operation on the name of the target object, displays on the configuration panel the An entity node corresponding to the target object name; searching for a pre-built node name representing the engine capability, in response to a trigger operation on at least one target node name associated with the target object name among the node names and realizing the target function, Display at least one target node corresponding to the name of the at least one target node on the configuration panel; in response to triggering an operation on the connection between the entity node and each of the target nodes according to logical requirements, drive each of the targets The node runs the engine capability to realize the target function.

Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, or combinations thereof, including but not limited to object-oriented programming languages—such as Java, Smalltalk, C++, and Includes conventional procedural programming languages - such as the "C" language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In cases involving a remote computer, the remote computer can be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (such as through an Internet service provider). Internet connection).

The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, program segment, or portion of code that contains one or more logical functions for implementing specified executable instructions. It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified functions or operations , or may be implemented by a combination of dedicated hardware and computer instructions.

The units involved in the embodiments described in the present disclosure may be implemented by software or by hardware. Wherein, the name of a unit does not constitute a limitation of the unit itself under certain circumstances.

The functions described herein above may be performed at least in part by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), System on Chips (SOCs), Complex Programmable Logical device (CPLD) and so on.

In the context of the present disclosure, a machine-readable medium may be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media would include one or more wire-based electrical connections, portable computer discs, hard drives, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), optical fiber, compact disk read only memory (CD-ROM), optical storage, magnetic storage, or any suitable combination of the foregoing.

According to one or more embodiments of the present disclosure, the present disclosure provides a method for implementing entity functions based on engine capabilities, including: in response to a trigger operation on the name of the target object, displaying on the configuration panel the entity node; search for pre-built node names representing engine capabilities, and in response to a trigger operation on at least one target node name associated with the target object name among the node names and realizing the target function, in the configuration Displaying on the panel at least one target node corresponding to the name of the at least one target node; and in response to triggering an operation on the connection between the entity node and each of the target nodes according to logical requirements, driving each of the target nodes to run an engine ability to achieve the stated objective functions.

According to one or more embodiments of the present disclosure, in the engine capability-based entity function implementation method provided by the present disclosure, the target node includes a control-type target node with a control trigger port and a data-type target node with all ports being data ports , the driving each of the target nodes to run the engine capability to realize the target function includes: when the control target node is triggered, obtaining the data provided by the data target node connected to the control target node information; and process according to the operation logic of the control target node and the data information, and output corresponding processing results to realize the target function.

According to one or more embodiments of the present disclosure, the engine capability-based entity function implementation method provided in the present disclosure further includes: before searching for the pre-built node name representing the engine capability, obtaining a configuration file storing engine data; and Construct the node names representing engine capabilities according to the configuration file, and construct nodes corresponding to each node name for display on the configuration panel.

According to one or more embodiments of the present disclosure, in the engine capability-based entity function implementation method provided by the present disclosure, the acquisition of the configuration file saving the engine data includes: obtaining the current engine runtime type information RTTI attribute through the engine running instance ; and obtain the class name, attribute, function and inheritance relationship contained in the RTTI object according to the RTTI attribute, and save it as a configuration file in json format.

According to one or more embodiments of the present disclosure, in the engine capability-based entity function implementation method provided by the present disclosure, the construction of the node name representing the engine capability according to the configuration file, and the construction of the corresponding node name The node for displaying on the configuration panel includes: parsing the configuration file in the json format to obtain the class name of the RTTI object, and generating the node name of the component node according to the class name; wherein, the component node It includes: an input port for inputting the entity node to which the component node belongs and an output port for outputting the functional object related to the component node.

According to one or more embodiments of the present disclosure, the engine capability-based entity function implementation method provided by the present disclosure further includes: parsing the configuration file in json format, and obtaining the The attribute information array of the RTTI object generates the node name of the attribute node according to the attribute name of the attribute information array; wherein the attribute node includes a read attribute node and a set attribute node, wherein the read attribute node includes: using The input port for inputting the component node to which the read attribute node belongs and the output port for outputting the corresponding attribute value of the read attribute node; the set attribute node includes: an input port for controlling triggering, an input port for inputting the Set the input port of the component node to which the attribute node belongs, the input port used to obtain the attribute value, the output port used to control the trigger, and the output port used to output the set attribute value.

According to one or more embodiments of the present disclosure, the engine capability-based entity function implementation method provided by the present disclosure further includes: parsing the configuration file in json format, and obtaining the function of the RTTI object according to the class and inheritance relationship of the RTTI object An information array, generating the node name of the function node according to the function name of the function information array; wherein, the function node includes: an input port for controlling triggering, and an input port for inputting the component node to which the function node belongs or the entity node to which it belongs An input port, an input port for obtaining one or more function parameters, an output port for controlling a trigger, and an output port for outputting a function return attribute value.

According to one or more embodiments of the present disclosure, in the engine capability-based entity function realization method provided by the present disclosure, the response to at least A trigger operation of a target node name, displaying at least one target node corresponding to the at least one target node name on the configuration panel includes: responding to the use of In response to the trigger operation of the target component node name for realizing the target function, the target component node corresponding to the target component node name is displayed on the configuration panel; and in response to the node name associated with the target component node name The name of the target attribute node used to realize the target function, and/or, the trigger operation of the target function node name, the target attribute node corresponding to the target attribute node name is displayed on the configuration panel, and/or , to display the objective function node corresponding to the objective function node name.

According to one or more embodiments of the present disclosure, in the engine capability-based entity function realization method provided by the present disclosure, the driving each target node to run the engine capability to realize the target function includes at least one of the following: The component node obtains the entity to which it belongs, and outputs the component object of the entity; the read property node obtains the component to which it belongs, and outputs the current attribute value of the component; when the control port of the set property node is triggered, it obtains the component, and set the attribute value of the component; or when the input control port of the function node is triggered, execute the function according to the function parameter and output the return value.

According to one or more embodiments of the present disclosure, the present disclosure provides an apparatus for implementing entity functions based on engine capabilities, including: a first display module, configured to display on the configuration panel in response to a trigger operation on the name of the target object The entity node corresponding to the name of the target object; the second display module, searching for a pre-built node name representing the engine capability, in response to at least one of the node names associated with the name of the target object and realizing the target function A trigger operation of a target node name, displaying on the configuration panel at least one target node corresponding to the at least one target node name; and a driving module, configured to respond to the logical requirements of the entity node and each of the The connection between the target nodes triggers an operation, and drives each target node to run an engine capability to realize the target function.

According to one or more embodiments of the present disclosure, in the device for implementing entity functions based on engine capabilities provided in the present disclosure, the target nodes include a control target node with a control trigger port and a data target node with all ports being data ports , the driving module is specifically configured to: when the control target node is triggered, obtain the data information provided by the data target node connected to the control target node; and according to the control target node The operation logic and the data information are processed, and corresponding processing results are output to realize the target function.

According to one or more embodiments of the present disclosure, the device for implementing entity functions based on engine capabilities provided by the present disclosure further includes: an acquisition module, configured to acquire a configuration file that saves engine data; and a construction module, configured to The configuration file constructs the node names representing engine capabilities, and constructs nodes corresponding to each node name for display on the configuration panel.

According to one or more embodiments of the present disclosure, in the apparatus for implementing entity functions based on engine capabilities provided by the present disclosure, the obtaining module is specifically configured to: obtain the RTTI attribute of the current engine runtime type information through the engine running instance; and according to the The above RTTI attribute obtains the class name, attribute, function and inheritance relationship contained in the RTTI object, and saves it as a configuration file in json format.

According to one or more embodiments of the present disclosure, in the device for implementing entity functions based on engine capabilities provided by the present disclosure, the building module is specifically configured to: parse the configuration file in json format to obtain the class name of the RTTI object , generating a node name of the component node according to the class name; wherein, the component node includes: an input port for inputting an entity node to which the component node belongs and an output port for outputting a functional object related to the component node.

According to one or more embodiments of the present disclosure, in the device for implementing entity functions based on engine capabilities provided by the present disclosure, the building module is further configured to: parse the configuration file in json format, according to the class of the RTTI object and The inheritance relationship acquires the attribute information array of the RTTI object, and generates the node name of the attribute node according to the attribute name of the attribute information array; wherein, the attribute node includes a read attribute node and a set attribute node, wherein the read The attribute node includes: an input port for inputting the component node to which the read attribute node belongs and an output port for outputting the corresponding attribute value of the read attribute node; the set attribute node includes: an input port for controlling triggering , an input port for inputting the component node to which the set attribute node belongs, an input port for obtaining the attribute value, an output port for controlling the trigger, and an output port for outputting the set attribute value.

According to one or more embodiments of the present disclosure, in the device for implementing entity functions based on engine capabilities provided by the present disclosure, the building module is further configured to: parse the configuration file in json format, according to the class of the RTTI object and The inheritance relationship acquires the function information array of the RTTI object, and generates the node name of the function node according to the function name of the function information array; wherein, the function node includes: an input port for controlling triggering, and an The input port of the component node or the entity node it belongs to, and the input port used to obtain one or more function parameters, the output port used to control the trigger, and the output port used to output the property value returned by the function.

According to one or more embodiments of the present disclosure, in the device for implementing entity functions based on engine capabilities provided by the present disclosure, the second display module is specifically configured to: respond to the association between the node name and the target object name The trigger operation of the target component node name for realizing the target function, displaying the target component node corresponding to the target component node name on the configuration panel; and responding to the target component node in the node name The target attribute node name associated with the node name for realizing the target function, and/or, the trigger operation of the target function node name, displaying the target attribute node corresponding to the target attribute node name on the configuration panel, And/or, displaying an objective function node corresponding to the name of the objective function node.

According to one or more embodiments of the present disclosure, in the device for implementing entity functions based on engine capabilities provided by the present disclosure, the driving module is specifically configured to: the component node obtains the entity to which it belongs, and outputs the component object of the entity; The read attribute node obtains the component to which it belongs, and outputs the current attribute value of the component; when the control port of the set attribute node is triggered, obtains the component whose attribute needs to be set, and sets the attribute value of the component; or the function When the input control port of the node is triggered, the function is executed according to the function parameters and the return value is output.

According to one or more embodiments of the present disclosure, the present disclosure provides an electronic device, including: a processor; a memory for storing instructions executable by the processor; The executable instructions are read, and executed to implement any method for implementing entity functions based on engine capabilities as provided in the present disclosure.

According to one or more embodiments of the present disclosure, the present disclosure provides a computer-readable storage medium, the storage medium stores a computer program, and the computer program is used to execute any one of the methods based on the present disclosure. Entity function implementation method of engine capability.

According to one or more embodiments of the present disclosure, the present disclosure provides a computer program, including: instructions, which, when executed by a processor, cause the processor to perform any one of the methods based on the present disclosure. Entity function implementation method of engine capability.

According to one or more embodiments of the present disclosure, the present disclosure provides a computer program product, including instructions, which, when executed by a processor, cause the processor to perform any one of the methods based on the present disclosure. Entity function implementation method of engine capability. The above description is only a preferred embodiment of the present disclosure and an illustration of the applied technical principles. Those skilled in the art should understand that the disclosure scope involved in this disclosure is not limited to the technical solution formed by the specific combination of the above-mentioned technical features, but also covers the technical solutions formed by the above-mentioned technical features or Other technical solutions formed by any combination of equivalent features. For example, a technical solution formed by replacing the above-mentioned features with (but not limited to) technical features with similar functions disclosed in this disclosure.

In addition, while operations are depicted in a particular order, this should not be understood as requiring that the operations be performed in the particular order shown or performed in sequential order. Under certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while the above discussion contains several specific implementation details, these should not be construed as limitations on the scope of the disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are merely example forms of implementing the claims.

Claims

A method for implementing entity functions based on engine capabilities, including:

In response to a trigger operation on the name of the target object, displaying an entity node corresponding to the name of the target object on the configuration panel;

Searching for pre-built node names representing engine capabilities, in response to a trigger operation on at least one target node name associated with the target object name among the node names and realizing the target function, displaying on the configuration panel the same at least one target node corresponding to the at least one target node name; and

In response to triggering an operation on the connection between the entity node and each of the target nodes according to a logic requirement, each of the target nodes is driven to run an engine capability to realize the target function.
The method according to claim 1, wherein the target node comprises a control target node having a control trigger port and a data target node in which all ports are data ports;

Said driving each said target node to run engine capability to realize said target function includes:

When the control target node is triggered, acquire data information provided by the data target node connected to the control target node; and

Processing is performed according to the operation logic of the control target node and the data information, and a corresponding processing result is output to realize the target function.
The method according to claim 1, further comprising:

prior to said searching for pre-built node names representing engine capabilities, obtaining a configuration file holding engine data; and

Construct the node names representing engine capabilities according to the configuration file, and construct nodes corresponding to each node name for display on the configuration panel.
The method according to claim 3, wherein said obtaining the configuration file for saving engine data comprises:

Obtain the runtime type information RTTI attribute of the current engine through the engine running instance; and

Obtain the class name, attribute, function and inheritance relationship contained in the RTTI object according to the RTTI attribute, and save it as a configuration file in json format.
The method according to claim 4, wherein said constructing the node names representing engine capabilities according to the configuration file, and constructing nodes corresponding to each node name for displaying on the configuration panel include:

Parse the configuration file in the json format to obtain the class name of the RTTI object, and generate the node name of the component node according to the class name; wherein,

The component node includes: an input port for inputting an entity node to which the component node belongs and an output port for outputting a functional object related to the component node.
The method according to claim 5, further comprising:

Parsing the configuration file in the json format, obtaining the attribute information array of the RTTI object according to the class and inheritance relationship of the RTTI object, and generating the node name of the attribute node according to the attribute name of the attribute information array; wherein,

The attribute node includes a read attribute node and a set attribute node, wherein,

The read attribute node includes: an input port for inputting a component node to which the read attribute node belongs and an output port for outputting an attribute value corresponding to the read attribute node;

The setting attribute node includes: an input port for controlling triggering, an input port for inputting component nodes to which the setting attribute node belongs, an input port for obtaining attribute values, an output port for controlling triggering, and an input port for An output port that outputs the value of the property being set.
The method of claim 6, further comprising:

Parse the configuration file in the json format, obtain the function information array of the RTTI object according to the class and inheritance relationship of the RTTI object, and generate the node name of the function node according to the function name of the function information array, wherein,

The function node includes: an input port for controlling the trigger, an input port for inputting the component node or entity node to which the function node belongs, an input port for obtaining one or more function parameters, and an input port for controlling the trigger , and the output port used to output the property value returned by the output function.
The method according to claim 7, wherein, in response to the trigger operation on at least one target node name associated with the target object name among the node names and realizing the target function, on the configuration panel Displaying at least one target node corresponding to the at least one target node name includes:

In response to a trigger operation on the target component node name associated with the target object name in the node name and used to realize the target function, displaying the target component node corresponding to the target component node name on the configuration panel ;with

In response to a trigger operation on the target attribute node name associated with the target component node name in the node name and used to realize the target function, and/or the target function node name, displaying on the configuration panel A target attribute node corresponding to the name of the target attribute node, and/or, displaying a target function node corresponding to the name of the target function node.
The method according to claim 8, wherein said driving each of said target nodes to run an engine capability to realize said target function comprises at least one of the following:

The component node obtains the entity to which it belongs, and outputs the component object of the entity;

The read attribute node obtains the component to which it belongs, and outputs the current attribute value of the component;

When the control port of the setting attribute node is triggered, obtain the component whose attribute needs to be set, and set the attribute value of the component; or

When the input control port of the function node is triggered, the function is executed according to the function parameter and the return value is output.
A device for implementing entity functions based on engine capabilities, comprising:

The first display module is configured to display on the configuration panel the entity node corresponding to the name of the target object in response to a trigger operation on the name of the target object;

The second display module searches for pre-built node names representing engine capabilities, responds to a trigger operation on at least one target node name associated with the target object name among the node names and realizes the target function, in the at least one target node corresponding to the at least one target node name is displayed on the configuration panel; and

The driving module is configured to drive each of the target nodes to run an engine capability to realize the target function in response to triggering an operation on the connection between the entity node and each of the target nodes according to a logic requirement.
An electronic device comprising:

processor; and

memory for storing said processor-executable instructions;

The processor is configured to read the executable instruction from the memory, and execute the instruction to implement the engine capability-based entity function implementation method according to any one of claims 1-9.
A computer-readable storage medium, the storage medium stores a computer program, and the computer program is used to execute the method for implementing an entity function based on an engine capability according to any one of claims 1-9.
A computer program comprising:

An instruction, when the instruction is executed by the processor, causes the processor to execute the method for realizing the entity function based on the engine capability according to any one of claims 1-9.
A computer program product, comprising instructions, which, when executed by a processor, cause the processor to execute the method for implementing entity functions based on engine capabilities according to any one of claims 1-9.