A method and apparatus for outputting operational data of a special effect

Abstract

The embodiment of the present disclosure provides a method and device for outputting running data of special effects, in the technical field of special effect editing. The method comprises: generating a special effect package of a target special effect, wherein the special effect package comprises a monitoring list, and the monitoring list comprises at least one data object of the target special effect; sending the special effect package of the target special effect to a running instance; receiving running data corresponding to each data object in the monitoring list sent by the running instance; and outputting the running data corresponding to each data object in the monitoring list. The embodiment of the present disclosure is used to solve the problem that the running data of the special effect cannot be observed in the process of editing the special effect.

Description

TECHNICAL FIELD

[0001] The present disclosure relates to the technical field of special effect processing, and particularly relates to a method and device for outputting running data of a special effect. BACKGROUND

[0002] With the continuous development of science and technology, special effects are more and more used in selfie, short video production, film production, video live broadcast and other scenes. The works processed by special effects can surpass the visual effects that can be achieved by actual shooting, and therefore special effects provide strong technical support for improving the quality of works.

[0003] Generally, the process of making a special effect package includes: first, adding resource files of a special effect in an editing instance according to requirements, and configuring the running logic of the special effect; then, packaging the special effect resources and the running logic of the special effect to generate a special effect package; and finally, importing the special effect package into a running instance to preview the effect of the special effect. If the effect of the special effect is normal, the special effect package obtained by packaging can be directly published. If the effect of the special effect is abnormal, the editing instance needs to be returned to, and the resource files or the running logic of the special effect in the editing instance needs to be modified. Then, the special effect package is re-generated and imported into the running instance for running until the effect of the special effect is normal. In the process of configuring the running logic of the special effect, the editor cannot observe the running data of the special effect, and therefore cannot intuitively determine whether the running logic of the special effect is abnormal and the step of the logic that is abnormal. When the effect of the special effect is abnormal, the editor cannot quickly determine the cause of the abnormal effect of the special effect, and therefore the editing efficiency of the special effect is low, and debugging is very difficult. SUMMARY

[0004] Therefore, the present disclosure provides a method and device for outputting running data of a special effect, which are used to solve the problem that the running data of a special effect cannot be observed in the process of editing the special effect.

[0005] To achieve the above object, the technical solutions of the embodiments of the present disclosure are provided as follows.

[0006] In a first aspect, the embodiments of the present disclosure provide a method for outputting running data of a special effect, applied to an editing instance, and the method comprises the following steps.

[0007] generating a special effect package of a target special effect, wherein the special effect package comprises a monitoring list, and the monitoring list comprises at least one data object of the target special effect;

[0008] sending the special effect package of the target special effect to a running instance;

[0009] receiving running data corresponding to each data object in the monitoring list sent by the running instance;

[0010] Output the running data corresponding to each data object in the monitoring list.

[0011] As an optional implementation of this disclosure, the method further includes:

[0012] Receive editing operations from the user for the effects package of the target effects;

[0013] Based on the editing operation, the effect package of the target effect corresponding to the editing instance is edited, and an editing command is sent to the running instance according to the editing operation. The editing command is used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation.

[0014] The system receives update data sent by the running instance. The update data includes running data corresponding to each data object in the monitoring list obtained by the running instance running the update effect package. The update effect package is an effect package obtained by the running instance after editing the effect package of the target effect according to the editing operation.

[0015] Output the updated data.

[0016] As an optional implementation of this disclosure, the effects package for generating the target effects includes:

[0017] Load the resource file for the target effect;

[0018] In response to a user's input to add a node, display at least two logical nodes;

[0019] In response to the user's connection operation to the node ports of the at least two logical nodes, the effect logic of the target effect is obtained;

[0020] The monitoring list is generated in response to at least one data object input by the user;

[0021] The monitoring list, the resource files of the target effect, and the effect logic of the target effect are packaged together to generate the effect package of the target effect.

[0022] As an optional implementation of this disclosure, the monitoring list further includes the identifier of the node port of the logical node corresponding to each data object;

[0023] The receipt of runtime data corresponding to each data object in the monitoring list sent by the running instance includes:

[0024] Receive the running data corresponding to each data object in the monitoring list sent by the running instance, as well as the node port identifier of the logical node corresponding to each running data.

[0025] As an optional implementation of this disclosure, the identifier of the node port of the logical node corresponding to any data object includes:

[0026] The identifier of the node port of the logical node that takes this data object as input.

[0027] As an optional implementation of this disclosure, the step of outputting the running data corresponding to each data object in the monitoring list includes:

[0028] Based on the identifier of the node port of the logical node corresponding to each running data, each running data is displayed in the data display area corresponding to the node port.

[0029] Secondly, embodiments of this disclosure provide a method for outputting runtime data of special effects, applied to a runtime instance, the method comprising:

[0030] Receive an effect package of a target effect sent by an editing instance, the effect package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0031] Run the special effects package to obtain the running data corresponding to each data object in the monitoring list;

[0032] The runtime data corresponding to each data object in the monitoring list is sent to the editing instance so that the editing instance can output the runtime data corresponding to each data object in the monitoring list.

[0033] As an optional implementation of this disclosure, the method further includes:

[0034] The system receives an editing command sent by the editing instance, the editing command being used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation;

[0035] Edit the effect package of the target effect corresponding to the running instance according to the editing operation, and generate an updated effect package;

[0036] Run the update effects package to obtain update data, which includes the running data corresponding to each data object in the monitoring list obtained by running the update effects package;

[0037] Send the updated data to the edit instance.

[0038] As an optional implementation of this disclosure, the monitoring list further includes the identifier of the node port of the logical node corresponding to each data object;

[0039] Sending the runtime data corresponding to each data object in the monitoring list to the editing instance includes:

[0040] Send the running data corresponding to each data object in the monitoring list and the node port identifier of the logical node corresponding to each running data to the editing instance.

[0041] Thirdly, embodiments of this disclosure provide a method for outputting runtime data of special effects, including:

[0042] An edit instance generates an effects package for the target effect, the effects package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0043] The editing instance sends the effect package of the target effect to the running instance;

[0044] The running instance runs the special effects package and obtains the running data corresponding to each data object in the monitoring list;

[0045] The running instance sends the running data corresponding to each data object in the monitoring list to the editing instance;

[0046] The editing instance outputs the running data corresponding to each data object in the monitoring list.

[0047] Fourthly, embodiments of this disclosure provide an apparatus for outputting runtime data of special effects, the apparatus having an editing instance running on it, the apparatus comprising:

[0048] A generation unit is used to generate an effects package for a target effect, the effects package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0049] The sending unit is used to send the effect package of the target effect to the running instance;

[0050] The receiving unit is used to receive the running data corresponding to each data object in the monitoring list sent by the running instance;

[0051] The output unit is used to output the running data corresponding to each data object in the monitoring list.

[0052] As an optional implementation of this disclosure, the apparatus further includes:

[0053] The user input unit is used to receive editing operations from the user on the effect package of the target effect;

[0054] An editing unit is used to edit the effect package of the target effect corresponding to the editing instance based on the editing operation;

[0055] The sending unit is further configured to send an editing command to the running instance according to the editing operation, the editing command being used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation;

[0056] The receiving unit is further configured to receive update data sent by the running instance. The update data includes running data corresponding to each data object in the monitoring list obtained by the running instance running the update effect package. The update effect package is an effect package obtained by the running instance after editing the effect package of the target effect according to the editing operation.

[0057] The output unit is also used to output the updated data.

[0058] As an optional implementation of this disclosure, the generation unit is specifically configured to: load the resource file of the target effect; display at least two logical nodes in response to a user-inputted node addition operation; obtain the effect logic of the target effect in response to a user-inputted connection operation to the node ports of the at least two logical nodes; generate the monitoring list in response to at least one data object input by the user; and package the monitoring list, the resource file of the target effect, and the effect logic of the target effect to generate the effect package of the target effect.

[0059] As an optional implementation of this disclosure, the monitoring list further includes the identifier of the node port of the logical node corresponding to each data object;

[0060] The receiving unit is specifically used to receive the running data corresponding to each data object in the monitoring list sent by the running instance, as well as the node port identifier of the logical node corresponding to each running data.

[0061] As an optional implementation of this disclosure, the identifier of the node port of the logical node corresponding to any data object includes:

[0062] The identifier of the node port of the logical node that takes this data object as input.

[0063] As an optional implementation of this disclosure, the output unit is specifically used to display each running data in the data display area corresponding to the node port according to the identifier of the node port of the logical node corresponding to each running data.

[0064] Fifthly, embodiments of this disclosure provide an apparatus for outputting runtime data of special effects, wherein a runtime instance is running on the apparatus, and the apparatus includes:

[0065] A receiving unit is configured to receive an effect package of a target effect sent by an editing instance, the effect package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0066] The acquisition unit is used to run the special effects package and acquire the running data corresponding to each data object in the monitoring list;

[0067] The sending unit is used to send the running data corresponding to each data object in the monitoring list to the editing instance, so that the editing instance can output the running data corresponding to each data object in the monitoring list.

[0068] As an optional implementation of this disclosure, the apparatus further includes: an editing unit;

[0069] The receiving unit is further configured to receive an editing command sent by the editing instance, the editing command being configured to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation;

[0070] The editing unit is used to edit the effect package of the target effect corresponding to the running instance according to the editing operation, and generate an updated effect package;

[0071] The acquisition unit is further configured to run the update effect package to acquire update data, the update data including the running data corresponding to each data object in the monitoring list acquired by running the update effect package;

[0072] The sending unit is also used to send the updated data to the editing instance.

[0073] As an optional implementation of this disclosure, the monitoring list further includes the identifier of the node port of the logical node corresponding to each data object;

[0074] The sending unit is specifically used to send the running data corresponding to each data object in the monitoring list and the node port identifier of the logical node corresponding to each running data to the editing instance.

[0075] Sixthly, embodiments of this disclosure provide an apparatus for outputting runtime data of special effects, the apparatus having an editing instance and a runtime instance running on it, the apparatus comprising:

[0076] A generation unit is configured to generate an effects package of a target effect through the editing instance, the effects package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0077] The first sending unit is used to send the effect package of the target effect to the running instance through the editing instance;

[0078] The first receiving unit is configured to receive the effect package of the target effect sent by the editing instance through the running instance;

[0079] The acquisition unit is used to run the special effects package through the running instance and acquire the running data corresponding to each data object in the monitoring list;

[0080] The second sending unit is used to send the running data corresponding to each data object in the monitoring list to the editing instance through the running instance;

[0081] The second receiving unit is used to receive running data corresponding to each data object in the monitoring list sent by the running instance through the editing instance;

[0082] The output unit is used to output the running data corresponding to each data object in the monitoring list through the editing instance.

[0083] In a seventh aspect, embodiments of this disclosure provide an electronic device, including: a memory and a processor, the memory being used to store a computer program; the processor being used to, when executing the computer program, cause the electronic device to implement the method of running data for output effects provided in any of the above embodiments.

[0084] Eighthly, embodiments of this disclosure provide a computer-readable storage medium storing a computer program that, when executed by a computing device, causes the computing device to implement the method for running data of output effects provided in any of the above embodiments.

[0085] Ninthly, embodiments of this disclosure provide a computer program product that, when the computer program product is run on a computer, enables the computer to implement the running data of the output effects provided in any of the above embodiments.

[0086] The method for outputting runtime data of special effects provided in this disclosure includes: after an editing instance generates a special effects package including a monitoring list, it sends the special effects package to a running instance; then, it receives runtime data corresponding to each data object in the monitoring list sent by the running instance; and outputs the runtime data corresponding to each data object in the monitoring list. Based on the method for outputting runtime data of special effects provided in this disclosure, special effects editors can add groups of data objects to be observed in the special effects package, and obtain the runtime data corresponding to each data object through the running instance and send the runtime data corresponding to each data object to the editing instance. The editing instance will also output the runtime data corresponding to each data object. Therefore, special effects editors can intuitively observe the runtime data they want to observe through the method for outputting runtime data of special effects provided in this disclosure, thereby improving the editing efficiency of special effects and reducing the debugging difficulty of special effects. Attached Figure Description

[0087] The accompanying drawings, which are incorporated in and form a part of this specification, illustrate embodiments consistent with this disclosure and, together with the description, serve to explain the principles of this disclosure.

[0088] To more clearly illustrate the technical solutions in the embodiments of this disclosure or the prior art, the accompanying drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0089] Figure 1 One of the scenario architecture diagrams for the method of generating runtime data for output effects provided in embodiments of this disclosure;

[0090] Figure 2 A second schematic diagram of the scenario architecture for the method of generating runtime data for output effects provided in the embodiments of this disclosure;

[0091] Figure 3 One of the flowcharts of the method for generating runtime data for output effects provided in this embodiment of the disclosure;

[0092] Figure 4 The second flowchart of the method for generating runtime data for output effects provided in this embodiment of the disclosure;

[0093] Figure 5 A schematic diagram of the interface for a method of generating runtime data for output effects provided in embodiments of this disclosure;

[0094] Figure 6 The third step of the method for generating runtime data for output effects provided in this embodiment of the disclosure;

[0095] Figure 7One of the schematic diagrams of an apparatus for generating runtime data of output effects provided in embodiments of this disclosure;

[0096] Figure 8 A second schematic diagram of a device for generating runtime data of output effects provided in embodiments of this disclosure;

[0097] Figure 9 A third schematic diagram of a device for generating runtime data for output effects provided in embodiments of this disclosure;

[0098] Figure 10 Schematic diagram four of the apparatus for generating runtime data of output effects provided in the embodiments of this disclosure;

[0099] Figure 11 Fifth schematic diagram of a device for generating runtime data for output effects provided in embodiments of this disclosure;

[0100] Figure 12 This is a schematic diagram of the hardware structure of an electronic device provided in an embodiment of this disclosure. Detailed Implementation

[0101] To better understand the above-mentioned objectives, features, and advantages of this disclosure, the solutions disclosed herein will be further described below. It should be noted that, unless otherwise specified, the embodiments and features described herein can be combined with each other.

[0102] Numerous specific details are set forth in the following description in order to provide a full understanding of this disclosure, but this disclosure may also be implemented in other ways different from those described herein; obviously, the embodiments in the specification are only some, and not all, of the embodiments of this disclosure.

[0103] The terms "first" and "second," etc., in this disclosure and its claims are used to distinguish objects being synchronized, not to describe a specific order of objects. For example, "first transmitting unit" and "second transmitting unit," etc., are used to distinguish different transmitting units, not to describe a specific order of transmitting units.

[0104] In this disclosure, the terms "exemplary" or "for example" are used to indicate that something is an example, illustration, or description. Any embodiment or design described as "exemplary" or "for example" in this disclosure should not be construed as being more preferred or advantageous than other embodiments or designs. Specifically, the use of terms such as "exemplary" or "for example" is intended to present the relevant concepts in a specific manner. Furthermore, in the description of the embodiments in this disclosure, unless otherwise stated, "a plurality of" means two or more.

[0105] The following section first describes the scenario architecture of the method for generating runtime data for output effects provided in the embodiments of this disclosure.

[0106] Reference Figure 1 As shown in the embodiments of this disclosure, a possible scenario architecture for the method of outputting special effects running data includes: a first terminal device 11 and a second terminal device 12. The first terminal device 11 runs an editing instance 110 for editing a special effects package, and the second terminal device 12 runs a running instance 120 for running the special effects package. A network connection is established between the first terminal device 11 and the second terminal device 12, and the editing instance 110 and the running instance 120 can transmit data through the network connection between the first terminal device 11 and the second terminal device 12.

[0107] Reference Figure 2 As shown, another possible scenario architecture for the method of outputting special effects running data provided in this embodiment includes a terminal device 20. The terminal device 20 runs an editing instance 21 for editing data packets of special effects packages, a running instance 22 for running special effects packages, and a communication module 23. Data transmission between the editing instance 21 and the running instance 22 can be performed via the communication module 23. The communication module 23 may include a bus or socket interface of the terminal device 20.

[0108] Based on the above, this disclosure provides a method for outputting runtime data of special effects, referring to... Figure 3 As shown, the method for generating runtime data for output effects provided in this embodiment includes the following steps:

[0109] S301. Edit the instance to generate the effect package of the target effect.

[0110] The special effects package includes a monitoring list, which includes at least one data object of the target special effects.

[0111] Specifically, special effects packages generated by editing instances are typically implemented by editing scripts. Therefore, when editing the script corresponding to the special effects package in the editing instance, the data objects to be observed can be added to the relevant script fragments of the script corresponding to the special effects package, thereby adding the monitoring list to the special effects package. That is, the monitoring list in this embodiment can be a script fragment that includes at least one data object.

[0112] S302. The edit instance sends the effect package of the target effect to the running instance.

[0113] Correspondingly, the running instance receives the effect package of the target effect sent by the editing instance.

[0114] Optionally, in this embodiment of the disclosure, the method by which the editing instance sends the effect package of the target effect to the running instance can be:

[0115] The editing instance uses the data synchronization function between instances to synchronize the effect package of the target effect to the running instance.

[0116] Specifically, the data synchronization function between instances can be implemented based on network communication or through the communication mechanism inside the device. This embodiment of the invention does not limit this.

[0117] Optionally, in this embodiment of the disclosure, the method by which the editing instance sends the effect package of the target effect to the running instance can also be:

[0118] The editing instance exports the effect package of the target effect to a preset storage location, and then the running instance reads the effect package of the target effect from the preset storage location.

[0119] S303. Run the special effects package and obtain the running data corresponding to each data object in the monitoring list.

[0120] Specifically, since the effects package includes a monitoring list, and the monitoring list includes at least one data object of the target effects, the running instance can parse the effects package to determine each data object in the monitoring list, and read the running data corresponding to each data object in the monitoring list when running the effects package, so as to obtain the running data corresponding to each data object in the monitoring list.

[0121] It should be noted that the running data in this embodiment can be of any type. For example, running data may include: position coordinates, color values, one-dimensional vectors, two-dimensional vectors, Boolean values, hash values, numerical values ​​in numerical operations, elements in logical operations, and status data used to characterize the running state of special effects. This embodiment does not limit the type of running data.

[0122] S304. The running instance sends the running data corresponding to each data object in the monitoring list to the editing instance.

[0123] Correspondingly, the editing instance receives the running data corresponding to each data object in the monitoring list sent by the running instance.

[0124] Similarly, the implementation of sending the running data corresponding to each data object in the monitoring list to the editing instance can include: the running instance synchronizing the running data corresponding to each data object in the monitoring list to the editing instance through the data synchronization function between instances; or the running instance exporting the running data corresponding to each data object in the monitoring list to a preset storage location, and then the editing instance reading the running data corresponding to each data object in the monitoring list from the preset storage location.

[0125] S305. Edit the instance output to show the running data corresponding to each data object in the monitoring list.

[0126] The method for outputting runtime data of special effects provided in this disclosure includes: after an editing instance generates a special effects package including a monitoring list, it sends the special effects package to a running instance; then, it receives runtime data corresponding to each data object in the monitoring list sent by the running instance; and outputs the runtime data corresponding to each data object in the monitoring list. Based on the method for outputting runtime data of special effects provided in this disclosure, special effects editors can add groups of data objects to be observed in the special effects package, and obtain the runtime data corresponding to each data object through the running instance and send the runtime data corresponding to each data object to the editing instance. The editing instance will also output the runtime data corresponding to each data object. Therefore, special effects editors can intuitively observe the runtime data they want to observe through the method for outputting runtime data of special effects provided in this disclosure, thereby improving the editing efficiency of special effects and reducing the debugging difficulty of special effects.

[0127] Furthermore, based on the above embodiments, referring to... Figure 4 As shown, the method for generating runtime data for output effects provided in this embodiment of the disclosure further includes:

[0128] S401, The editing instance receives the user's editing operation input for the effect package of the target effect.

[0129] The editing operations in this embodiment may specifically include: editing operations for adding objects, editing operations for deleting objects, editing operations for modifying the attribute values ​​of objects, etc. This embodiment does not limit the editing operations and may include one or more of the above-mentioned editing operations.

[0130] S402. The editing instance edits the effect package of the target effect corresponding to the editing instance based on the editing operation.

[0131] In this embodiment of the disclosure, the effect package of the target effect corresponding to the editing instance can refer to the effect package of the target effect loaded by the editing instance. In the editing scenario, all editing operations input by the effect editor on the effect package of the target effect are performed on the effect package of the target effect corresponding to the editing instance.

[0132] S403. The editing instance sends an editing command to the running instance according to the editing operation.

[0133] Correspondingly, the running instance receives editing commands sent by the editing operation.

[0134] The edit command is used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the edit operation.

[0135] Unlike the effect package of the target effect corresponding to the editing instance, in this embodiment of the disclosure, the effect package of the target effect corresponding to the running instance can refer to the effect package of the target effect loaded by the running instance. The running instance can output the target effect according to the effect package of the target effect corresponding to the running instance so that the effect editor can view the effect of the effect in real time. However, the editing operation input by the effect editor to the effect package of the target effect will not directly affect the effect package of the target effect corresponding to the running instance, but will affect the effect package of the target effect corresponding to the editing instance.

[0136] Optionally, the implementation of the editing instance sending editing commands to the running instance based on the editing operation may include:

[0137] The editing instance periodically sends editing commands to the running instance at a preset time interval.

[0138] For example, the preset duration can be 100ms, 200ms, etc., and this disclosure does not limit it.

[0139] Optionally, the implementation of the editing instance sending editing commands to the running instance based on the editing operation may further include:

[0140] The editing instance sends the editing command corresponding to each editing operation to the running instance.

[0141] That is, each time the editing instance receives an editing operation, it immediately generates the corresponding editing command and sends it to the running instance. When it receives multiple consecutive editing operations, the editing instance sends multiple consecutive editing commands to the running instance.

[0142] S404. The running instance edits the effect package of the target effect corresponding to the running instance according to the editing operation, and generates an updated effect package.

[0143] Since the editing operations performed by the running instance on the effect package of the target effect are the same as those performed by the editing instance on the effect package of the target effect, the essence of the above steps S401 to S404 is that the editing instance synchronizes the modifications made to the effect package of the corresponding target effect to the effect package of the running instance.

[0144] S405. Run the instance to run the updated effects package and obtain the updated data.

[0145] The updated data includes the running data corresponding to each data object in the monitoring list obtained by the running instance running the updated effects package.

[0146] That is, the running instance executes the effect package of the target effect after the editing operation, re-acquires the running data corresponding to each data object in the monitoring list, and uses the re-acquired running data as the updated data.

[0147] S406. The running instance sends the updated data to the editing instance.

[0148] Correspondingly, the editing instance receives the updated data sent by the running instance.

[0149] Optionally, the running instance and the editing instance can transfer updated data through the data synchronization function between instances.

[0150] S407. Edit the instance output of the updated data.

[0151] The method for outputting special effects running data provided in the above embodiments can send an editing command to the running instance when the editor edits the special effects package, instructing the running instance to edit the special effects package corresponding to the running instance according to the editing operation. After the running instance runs the special effects package after the editing operation is performed, it will send updated data to the editing instance. Therefore, by adopting the above implementation method, the running data after editing can be observed in real time while avoiding frequent export of special effects packages, thus improving the real-time observation of special effects running data.

[0152] As an optional implementation of this disclosure, the above step S301 (generating the effect package of the target effect) is implemented by including the following steps a to e:

[0153] Step a: Load the resource file of the target effect.

[0154] Specifically, the resource files for the target effect include materials and parameters for generating the target effect. The materials for the target effect may include animations, images, text, etc., but this embodiment does not limit the specific materials used.

[0155] Step b: In response to the user's input of a node addition operation, display at least two logical nodes.

[0156] That is, select at least two logical nodes from the predefined logical nodes to configure the target effect.

[0157] The node addition operation can specifically include one or more of the following: touch click operation, long press operation, selection operation in a drop-down menu, and special gesture. In this embodiment of the invention, the user can be an editor of special effects.

[0158] Step c: In response to the user's connection operation to the node ports of the at least two logical nodes, obtain the effect logic of the target effect.

[0159] That is, users can configure the effect logic of a target effect by connecting the node ports of at least two logical nodes. For example, if a user connects the output node port A of logical node 1 and the input node port B of logical node 2 through a connection operation, the obtained effect logic of the target effect includes: using the running data output from node port A as the input of node port B.

[0160] In the process of generating the special effects logic of the target special effects in the above embodiments, the special effects editors do not need to input text code. They only need to add the predefined logic nodes to the script area and configure the data flow between the nodes through the connection between the node ports. The editor can automatically generate program code that conforms to the running logic of the special effects. Therefore, the above embodiments can simplify the writing of special effects-related program code.

[0161] Step d: In response to at least one data object input by the user, generate the monitoring list.

[0162] For example, the implementation of at least one data object input by the user can be: typing the identifier of the data object to be observed through a physical keyboard, virtual keyboard, etc., or the user selecting the data object to be observed from the data objects of the target effect.

[0163] Step e: Package the monitoring list, the resource file of the target effect, and the effect logic of the target effect to generate the effect package of the target effect.

[0164] As an optional implementation of this disclosure, the monitoring list also includes the identifier of the node port of the logical node corresponding to each data object.

[0165] That is, the monitoring list includes at least one data object and the identifier of the node port of the logical node corresponding to each data object.

[0166] For example, the table structure of the monitoring list can be as follows:

[0167] (“Identifier of the node port of the logical node” — “Data object”).

[0168] Optionally, the identifier of the node port of the logical node corresponding to any data object includes:

[0169] The identifier of the node port of the logical node that takes this data object as input.

[0170] For example, the identification of a node port may include the node port's Identity Document (ID).

[0171] For example, in the special effects logic, a certain data object is input from the output port a2 of logical node A to the input port b1 of logical node B. Then, the identifier of the node port of the logical node corresponding to the data object is the identifier of the input port b1 of logical node B.

[0172] It should be noted that since a data object can serve as input to multiple logical nodes, the identifier of the node port corresponding to the running data can be one or multiple. For example, if the identifier of the node port corresponding to data object A is 100, and the running data corresponding to data object A is (125, 0, 255), then the identifier of the node port corresponding to the running data (125, 0, 255) is 100.

[0173] If the monitoring list also includes the node port identifier of the logical node corresponding to each data object, the running instance sends the running data corresponding to each data object in the monitoring list to the editing instance, including:

[0174] Send the running data corresponding to each data object in the monitoring list and the node port identifier of the logical node corresponding to each running data to the editing instance.

[0175] Correspondingly, the running instance receives the running data corresponding to each data object in the monitoring list, including:

[0176] The editing instance receives the running data corresponding to each data object in the monitoring list sent by the running instance, as well as the node port identifier of the logical node corresponding to each running data.

[0177] For example, the data structure of the data sent by the running instance to the editing instance is as follows:

[0178] (“Identifier of the logical node’s port” — “Runtime data”)

[0179] In practical use, editors may need to view multiple data objects. If only the runtime data corresponding to each data object is output, editors still need to identify the corresponding data object one by one, or even be unable to identify it, which is time-consuming and laborious. The above embodiment adds the node port identifier of the logical node corresponding to each data object to the monitoring list. Furthermore, when the runtime instance sends runtime data to the editing instance, it also sends the node port identifier of the logical node corresponding to each runtime data to the runtime instance. Therefore, the above embodiment can quickly identify the node port of the logical node corresponding to the runtime data by displaying the node port identifier of the logical node corresponding to the runtime data to the editor.

[0180] As an optional implementation of this disclosure, step S305 (outputting the running data corresponding to each data object in the monitoring list) includes:

[0181] Based on the identifier of the node port of the logical node corresponding to each running data, each running data is displayed in the data display area corresponding to the node port.

[0182] For example, refer to Figure 5 As shown, the running data corresponding to data object "value A" is "1.00", and the running data corresponding to data object "value B" is "2.00". The node port of the logical node corresponding to data object "value A" is the first input port 51 of the logical node "addition operation" 500, and the node port of the logical node corresponding to data object "value B" is the second input port 52 of the logical node "addition operation" 500. The data display area of ​​the first input port 51 of the logical node "addition operation" 500 is 501, and the data display area of ​​the second input port 52 of the logical node "addition operation" 500 is 502. Therefore, the running data "1.00" is displayed in the data display area 501 corresponding to the first input port 51 of the logical node "addition operation" 500, and the running data "2.00" is displayed in the data display area 502 corresponding to the second input port 52 of the logical node "addition operation" 500.

[0183] This disclosure also provides another method for outputting runtime data for special effects, referring to... Figure 6 As shown, the methods for generating the runtime data for this output effect include:

[0184] S601, Edit the instance to generate the effect package of the target effect.

[0185] The special effects package includes a monitoring list, which includes at least one data object of the target special effects.

[0186] S602. The editing instance sends the effect package of the target effect to the running instance.

[0187] S603. Run the special effects package and obtain the running data corresponding to each data object in the monitoring list.

[0188] S604. The running instance sends the running data corresponding to each data object in the monitoring list to the editing instance.

[0189] S605. Edit the instance output to show the running data corresponding to each data object in the monitoring list.

[0190] The method for generating runtime data for output effects provided in the above embodiments and Figure 3 The methods for outputting special effects shown can achieve similar technical results, and will not be elaborated upon here.

[0191] Based on the same inventive concept, as an implementation of the above method, this disclosure also provides a device for outputting special effects running data. This device embodiment corresponds to the aforementioned method embodiment. For ease of reading, this device embodiment will not repeat the details of the aforementioned method embodiment one by one, but it should be clear that the device for outputting special effects running data in this embodiment can correspondingly implement all the contents of the aforementioned method embodiment.

[0192] This disclosure provides an apparatus for outputting runtime data of special effects, wherein an editing instance is running on the apparatus. Figure 7 A schematic diagram of the device that generates the operating data for this output effect, as shown below. Figure 7 As shown, the device 700 for outputting special effects running data includes:

[0193] The generation unit 71 is used to generate an effect package for the target effect, the effect package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0194] Sending unit 72 is used to send the effect package of the target effect to the running instance;

[0195] The receiving unit 73 is used to receive the running data corresponding to each data object in the monitoring list sent by the running instance;

[0196] Output unit 74 is used to output the running data corresponding to each data object in the monitoring list.

[0197] As an optional implementation of this disclosure, refer to Figure 8 As shown, the device 700 for outputting special effects running data further includes:

[0198] User input unit 75 is used to receive editing operations from the user on the effect package of the target effect;

[0199] Editing unit 76 is used to edit the effect package of the target effect corresponding to the editing instance based on the editing operation;

[0200] The sending unit 72 is further configured to send an editing command to the running instance according to the editing operation, the editing command being used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation;

[0201] The receiving unit 73 is further configured to receive update data sent by the running instance. The update data includes running data corresponding to each data object in the monitoring list obtained by the running instance running the update effect package. The update effect package is an effect package obtained by the running instance after editing the effect package of the target effect according to the editing operation.

[0202] The output unit 74 is also used to output the updated data.

[0203] As an optional implementation of this disclosure, the generation unit 71 is specifically used to load the resource file of the target effect; display at least two logical nodes in response to a user-inputted node addition operation; obtain the effect logic of the target effect in response to a user-inputted connection operation to the node ports of the at least two logical nodes; generate the monitoring list in response to at least one data object input by the user; and package the monitoring list, the resource file of the target effect, and the effect logic of the target effect to generate the effect package of the target effect.

[0204] As an optional implementation of this disclosure, the monitoring list further includes the identifier of the node port of the logical node corresponding to each data object;

[0205] The receiving unit 73 is specifically used to receive the running data corresponding to each data object in the monitoring list sent by the running instance, as well as the node port identifier of the logical node corresponding to each running data.

[0206] As an optional implementation of this disclosure, the identifier of the node port of the logical node corresponding to any data object includes:

[0207] The identifier of the node port of the logical node that takes this data object as input.

[0208] As an optional implementation of this disclosure, the output unit 74 is specifically used to display each running data in the data display area corresponding to the node port according to the identifier of the node port of the logical node corresponding to each running data.

[0209] This disclosure provides an apparatus for outputting runtime data of special effects, wherein a runtime instance is running on the apparatus. Figure 9 A schematic diagram of the device that generates the operating data for this output effect, as shown below. Figure 9 As shown, the device 900 for outputting special effects running data includes:

[0210] The receiving unit 91 is configured to receive an effect package of a target effect sent by an editing instance, the effect package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0211] The acquisition unit 92 is used to run the special effects package and acquire the running data corresponding to each data object in the monitoring list;

[0212] The sending unit 93 is used to send the running data corresponding to each data object in the monitoring list to the editing instance, so that the editing instance can output the running data corresponding to each data object in the monitoring list.

[0213] As an optional implementation of this disclosure, refer to Figure 10 As shown, the device 900 for outputting special effects running data further includes: an editing unit 94;

[0214] The receiving unit 91 is further configured to receive an editing command sent by the editing instance, the editing command being configured to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation;

[0215] The editing unit 94 is used to edit the effect package of the target effect corresponding to the running instance according to the editing operation, and generate an updated effect package;

[0216] The acquisition unit 92 is further configured to run the update effect package to acquire update data, the update data including the running data corresponding to each data object in the monitoring list acquired by running the update effect package;

[0217] The sending unit 93 is also used to send the updated data to the editing instance.

[0218] As an optional implementation of this disclosure, the monitoring list further includes the identifier of the node port of the logical node corresponding to each data object;

[0219] The sending unit 93 is specifically used to send the running data corresponding to each data object in the monitoring list and the node port identifier of the logical node corresponding to each running data to the editing instance.

[0220] This disclosure provides an apparatus for outputting runtime data of special effects, wherein an editing instance and a runtime instance are running on the apparatus. Figure 11 A schematic diagram of the device that generates the operating data for this output effect, as shown below. Figure 11 As shown, the device 110 for outputting special effects running data includes:

[0221] The generation unit 111 is configured to generate an effect package of the target effect through the editing instance, the effect package including a monitoring list, the monitoring list including at least one data object of the target effect;

[0222] The first sending unit 112 is used to send the effect package of the target effect to the running instance through the editing instance;

[0223] The first receiving unit 113 is used to receive the effect package of the target effect sent by the editing instance through the running instance;

[0224] The acquisition unit 114 is used to run the special effects package through the running instance and acquire the running data corresponding to each data object in the monitoring list;

[0225] The second sending unit 115 is used to send the running data corresponding to each data object in the monitoring list to the editing instance through the running instance;

[0226] The second receiving unit 116 is used to receive running data corresponding to each data object in the monitoring list sent by the running instance through the editing instance;

[0227] The output unit 117 is used to output the running data corresponding to each data object in the monitoring list through the editing instance.

[0228] The apparatus for generating output effect running data provided in the above embodiments can execute the method for generating output effect running data provided in the above method embodiments. Its implementation principle and technical effect are similar, and will not be repeated here.

[0229] Based on the same inventive concept, this disclosure also provides an electronic device. Figure 12 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this disclosure, such as... Figure 12As shown, the electronic device provided in this embodiment includes: a memory 121 and a processor 122. The memory 121 is used to store computer programs; the processor 122 is used to execute the method of running data of output effects provided in the above embodiment when executing the computer program.

[0230] This disclosure also provides a computer-readable storage medium storing a computer program that, when executed by a computing device, causes the computing device to implement the method for running data of output effects provided in the above embodiments.

[0231] This disclosure also provides a computer program product that, when run on a computer, enables the computer to implement the method for generating output effects and running data provided in the above embodiments.

[0232] Those skilled in the art will understand that embodiments of this disclosure can be provided as methods, systems, or computer program products. Therefore, this disclosure can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this disclosure can take the form of a computer program product embodied on one or more computer-usable storage media including computer-usable program code.

[0233] The processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor can be a microprocessor or any conventional processor.

[0234] Memory may include non-persistent memory in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0235] Computer-readable media include both permanent and non-permanent, removable and non-removable storage media. Storage media can store information using any method or technology; the information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0236] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of this disclosure, and are not intended to limit them. Although this disclosure has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the embodiments of this disclosure.

Claims

1. A method for outputting runtime data of special effects, characterized in that, Applied to editing instances, the method includes: An effects package for generating a target effect is provided. The effects package includes a monitoring list, which includes at least one data object of the target effect. The effects package is implemented by editing a script, and the monitoring list is a script fragment that includes the at least one data object. Send the effect package of the target effect to the running instance; Receive the running data corresponding to each data object in the monitoring list sent by the running instance; Output the running data corresponding to each data object in the monitoring list.

2. The method according to claim 1, characterized in that, The method further includes: Receive editing operations from the user for the effects package of the target effects; Based on the editing operation, the effect package of the target effect corresponding to the editing instance is edited, and an editing command is sent to the running instance according to the editing operation. The editing command is used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation. The system receives update data sent by the running instance. The update data includes running data corresponding to each data object in the monitoring list obtained by the running instance running the update effect package. The update effect package is an effect package obtained by the running instance after editing the effect package of the target effect according to the editing operation. Output the updated data.

3. The method according to claim 1, characterized in that, The effects package for generating the target effects includes: Load the resource file for the target effect; In response to a user's input to add a node, display at least two logical nodes; In response to the user's connection operation to the node ports of the at least two logical nodes, the effect logic of the target effect is obtained; The monitoring list is generated in response to at least one data object input by the user; The monitoring list, the resource files of the target effect, and the effect logic of the target effect are packaged together to generate the effect package of the target effect.

4. The method according to claim 3, characterized in that, The monitoring list also includes the identifier of the node port of the logical node corresponding to each data object; The receipt of runtime data corresponding to each data object in the monitoring list sent by the running instance includes: Receive the running data corresponding to each data object in the monitoring list sent by the running instance, as well as the node port identifier of the logical node corresponding to each running data.

5. The method according to claim 4, characterized in that, The identifier of the node port of the logical node corresponding to any data object includes: The identifier of the node port of the logical node that takes this data object as input.

6. The method according to claim 4, characterized in that, The output of the running data corresponding to each data object in the monitoring list includes: Based on the identifier of the node port of the logical node corresponding to each running data, each running data is displayed in the data display area corresponding to the node port.

7. A method for outputting runtime data of special effects, characterized in that, Applied to a running instance, the method includes: The system receives an effect package containing a target effect sent by an editing instance. The effect package includes a monitoring list, which includes at least one data object of the target effect. The effect package is implemented by editing a script, and the monitoring list is a script fragment that includes the at least one data object. Run the special effects package to obtain the running data corresponding to each data object in the monitoring list; The runtime data corresponding to each data object in the monitoring list is sent to the editing instance so that the editing instance can output the runtime data corresponding to each data object in the monitoring list.

8. The method according to claim 7, characterized in that, The method further includes: The system receives an editing command sent by the editing instance, the editing command being used to instruct the running instance to edit the effect package of the target effect corresponding to the running instance according to the editing operation; Edit the effect package of the target effect corresponding to the running instance according to the editing operation, and generate an updated effect package; Run the update effects package to obtain update data, which includes the running data corresponding to each data object in the monitoring list obtained by running the update effects package; Send the updated data to the edit instance.

9. The method according to claim 7, characterized in that, The monitoring list also includes the identifier of the node port of the logical node corresponding to each data object; Sending the runtime data corresponding to each data object in the monitoring list to the editing instance includes: Send the running data corresponding to each data object in the monitoring list and the node port identifier of the logical node corresponding to each running data to the editing instance.

10. A method for outputting runtime data of special effects, characterized in that, include: An edit instance generates an effects package for the target effect. The effects package includes a monitoring list, which includes at least one data object of the target effect. The effects package is implemented by editing a script, and the monitoring list is a script fragment that includes the at least one data object. The editing instance sends the effect package of the target effect to the running instance; The running instance runs the special effects package and obtains the running data corresponding to each data object in the monitoring list; The running instance sends the running data corresponding to each data object in the monitoring list to the editing instance; The editing instance outputs the running data corresponding to each data object in the monitoring list.

11. A device for outputting runtime data of special effects, characterized in that, The device runs an editing instance, and the device includes: A generation unit is used to generate an effects package for a target effect. The effects package includes a monitoring list, which includes at least one data object of the target effect. The effects package is implemented by editing a script, and the monitoring list is a script fragment that includes the at least one data object. The sending unit is used to send the effect package of the target effect to the running instance; The receiving unit is used to receive the running data corresponding to each data object in the monitoring list sent by the running instance; The output unit is used to output the running data corresponding to each data object in the monitoring list.

12. A device for outputting runtime data of special effects, characterized in that, The device has running instances, and the device includes: A receiving unit is configured to receive a target effect package sent by an editing instance. The effect package includes a monitoring list, which includes at least one data object of the target effect. The effect package is implemented by editing a script, and the monitoring list is a script fragment that includes the at least one data object. The acquisition unit is used to run the special effects package and acquire the running data corresponding to each data object in the monitoring list; The sending unit is used to send the running data corresponding to each data object in the monitoring list to the editing instance.

13. A device for outputting runtime data of special effects, characterized in that, The device runs an editing instance and a running instance. The device includes: A generation unit is configured to generate an effect package of a target effect through the editing instance. The effect package includes a monitoring list, which includes at least one data object of the target effect. The effect package is implemented by editing a script, and the monitoring list is a script fragment that includes the at least one data object. The first sending unit is used to send the effect package of the target effect to the running instance through the editing instance; The first receiving unit is configured to receive the effect package of the target effect sent by the editing instance through the running instance; The acquisition unit is used to run the special effects package through the running instance and acquire the running data corresponding to each data object in the monitoring list; The second sending unit is used to send the running data corresponding to each data object in the monitoring list to the editing instance through the running instance; The second receiving unit is used to receive running data corresponding to each data object in the monitoring list sent by the running instance through the editing instance; The output unit is used to output the running data corresponding to each data object in the monitoring list through the editing instance.

14. An electronic device, characterized in that, include: A memory and a processor, the memory being used to store a computer program; the processor being used to, when executing the computer program, cause the electronic device to implement the method of running data for output effects as described in any one of claims 1-10.

15. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a computing device, causes the computing device to implement the method of generating output effect data as described in any one of claims 1-10.

16. A computer program product, characterized in that, When the computer program product is run on a computer, it causes the computer to implement the method of outputting special effects according to any one of claims 1-10.

Images