Animation generation method and device, storage medium and electronic equipment

Abstract

The embodiment of the invention discloses an animation generation method and device, a storage medium and electronic equipment. The method comprises the following steps: reading animation configuration information of a target event animation by adopting a first object; configuring a second object for each virtual character through the first object based on the animation configuration information; executing the event node of the virtual character configured for the second object through the second object; when the event node executed by the second object is the performance synchronization node, not entering a next event node after the performance synchronization node, and sending a completion instruction for the performance synchronization node to the first object; and if the first object receives a completion instruction which is sent by all target second objects to which the same performance synchronization node belongs and aims at the same performance synchronization node, controlling the target second objects to execute a next event node of the same performance synchronization node so as to generate a target event animation. Therefore, the event animation generation process can be effectively simplified, the animation production cost is reduced, and the animation generation efficiency is improved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to an animation generation method, device, storage medium and electronic device. Background Art

[0002] With the rapid development of life and technology, people often use game applications for entertainment. In the production of some role-playing games, in order to increase game content and enhance player participation, a large number of event animations are designed to promote the development of the game plot. The characteristics of this type of animation are that there are a large number of them, low personalization requirements, and high versatility of characters.

[0003] In the existing animation generation method, the event animation is often produced through the traditional customized animation production process through the cutscene animation editor provided by the game engine. However, the production process of this animation generation method is cumbersome. Using this animation generation method to produce event animation will lead to huge production costs and make the animation generation efficiency low. Summary of the invention

[0004] The embodiments of the present application provide an animation generation method, device, storage medium and electronic device, which can realize rapid splicing and configuration of event animations in a modular manner, effectively simplify the animation generation process, reduce the animation production cost, and thus improve the animation generation efficiency.

[0005] The present application provides an animation generation method, including:

[0006] Reading, through a first object, animation configuration information of a target event animation, wherein the animation configuration information includes at least one virtual character in the target event animation and event configuration information of the virtual character, wherein the event configuration information includes a plurality of event nodes with specified execution orders, wherein the event nodes include at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters;

[0007] Based on the animation configuration information, configuring a second object for each virtual character through the first object;

[0008] Executing the event node of the virtual character configured for the second object through the second object;

[0009] When the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object;

[0010] If the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation.

[0011] Accordingly, an embodiment of the present application provides an animation generating device, including:

[0012] An acquisition unit is used to read the animation configuration information of the target event animation through the first object, wherein the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, wherein the event configuration information includes a plurality of event nodes with specified execution order, wherein the event nodes include at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters;

[0013] A configuration unit, configured to configure a second object for each virtual character through the first object based on the animation configuration information;

[0014] an execution unit, configured to execute, through the second object, the event node of the virtual character configured for the second object;

[0015] a sending unit, configured to send a completion instruction for the performance synchronization node to the first object without entering the next event node after the performance synchronization node when the event node executed by the second object is a performance synchronization node;

[0016] A generating unit is used to control the target second object to execute the next event node of the same performance synchronization node to generate the target event animation if the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node.

[0017] In addition, an embodiment of the present application further provides a computer-readable storage medium, which stores a computer program, and the computer program is suitable for loading by a processor to execute the steps in any animation generation method provided in the embodiment of the present application.

[0018] In addition, an embodiment of the present application also provides an electronic device, including a processor and a memory, wherein the memory stores an application program, and the processor is used to run the application program in the memory to implement the animation generation method provided in the embodiment of the present application.

[0019] An embodiment of the present application also provides a computer program product, which includes a computer program, and the computer program is stored in a computer-readable storage medium; when a processor of an electronic device reads the computer program from the computer-readable storage medium, the processor executes the computer program, so that the electronic device performs the steps in the animation generation method provided in the embodiment of the present application.

[0020] The embodiment of the present application adopts a first object to read the animation configuration information of the target event animation, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution order, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; based on the animation configuration information, a second object is configured for each virtual character through the first object; the event node of the virtual character configured for it is executed through the second object; when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; if the first object receives a completion instruction for the same performance synchronization node from all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation. In this way, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, the second object is configured for each virtual character through the first object, the second object is triggered to execute the event node of the virtual character configured for it, and when the event node is a performance synchronization node, the second object configured with the performance synchronization node is controlled to perform plot synchronization of the target event animation, so as to generate the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object, and realize rapid splicing and configuration of event animation in a modular manner, which effectively simplifies the animation generation process, reduces the production cost of animation, and thus improves the animation generation efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For those skilled in the art, other drawings can be obtained based on these drawings without creative work.

[0022] Figure 1 This is a schematic diagram of an implementation scenario of an animation generation method provided in an embodiment of the present application;

[0023] Figure 2It is a flowchart of an animation generation method provided in an embodiment of the present application;

[0024] Figure 3a It is a specific flow chart of an animation generation method provided in an embodiment of the present application;

[0025] Figure 3b It is a schematic diagram of an animation configuration framework of an animation generation method provided in an embodiment of the present application;

[0026] Figure 3c It is a schematic diagram of event configuration information of an animation generation method provided in an embodiment of the present application;

[0027] Figure 3d It is a schematic diagram of event execution of an animation generation method provided in an embodiment of the present application;

[0028] Figure 4 is another specific flow chart of an animation generation method provided in an embodiment of the present application;

[0029] Figure 5 is a structural schematic diagram of an animation generating device provided in an embodiment of the present application;

[0030] Figure 6 It is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0031] The following will be combined with the drawings in the embodiments of the present application to clearly and completely describe the technical solutions in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of this application.

[0032] The embodiments of the present application provide an animation generation method, device, storage medium and electronic device. The animation generation device can be integrated in an electronic device, which can be a server or a terminal.

[0033] Among them, the server can be an independent physical server, or a server cluster or distributed system composed of multiple physical servers, or a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, network acceleration services (Content Delivery Network, CDN), and basic cloud computing services such as big data and artificial intelligence platforms. Terminals may include but are not limited to mobile phones, computers, intelligent voice interaction devices, smart home appliances, vehicle-mounted terminals, aircraft, etc. Terminals and servers can be directly or indirectly connected via wired or wireless communications, and this application does not limit this.

[0034] See also Figure 1 , taking the animation generation device integrated into an electronic device as an example, Figure 1 A schematic diagram of an implementation scenario of the animation generation method provided in an embodiment of the present application, wherein the electronic device can be a terminal, and the electronic device can read the animation configuration information of the target event animation through a first object, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes a plurality of event nodes with specified execution orders, the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; based on the animation configuration information, a second object is configured for each virtual character through the first object; the event node of the virtual character configured for it is executed through the second object; when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; if the first object receives a completion instruction for the same performance synchronization node from all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation.

[0035] It should be noted that Figure 1 The implementation environment scenario diagram of the animation generation method shown is only an example. The implementation environment scenario of the animation generation method described in the embodiment of the present application is to more clearly illustrate the technical solution of the embodiment of the present application, and does not constitute a limitation on the technical solution provided by the embodiment of the present application. It is known to those skilled in the art that with the evolution of data processing and the emergence of new business scenarios, the technical solution provided by the present application is also applicable to similar technical problems.

[0036] The solutions provided by the embodiments of the present application are specifically described by the following embodiments. It should be noted that the description order of the following embodiments is not intended to limit the preferred order of the embodiments.

[0037] This embodiment will be described from the perspective of an animation generating device. The animation generating device may be integrated into an electronic device. The electronic device may be a terminal and / or a server, and this application does not limit this.

[0038] See also Figure 2 , Figure 2 : is a flow chart of an animation generation method provided in an embodiment of the present application. The animation generation method comprises:

[0039] In step 101, animation configuration information of a target event animation is read through a first object.

[0040] Among them, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution orders, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters.

[0041] Among them, the first object can be an object for controlling the generation of the target event animation based on the animation configuration information, similar to the role type of the director function in the real world, for reading the animation configuration information of the target event animation, controlling the event synchronization of each role in the target event animation, and directing the role to perform the next action, so as to generate the target event animation. For example, the first object can be a blueprint object (Actor). In Unreal Engine (UE), Actor can be a basic component unit in the game, representing an object that can be placed or generated in a virtual scene. Blueprint (Blueprint) can be a visual language in Unreal Engine, which is a complete game script system that can use a node-based interface to create game playable elements. Like some other common scripting languages, the usage of blueprint is also to define object-oriented classes or objects in the engine. The target event animation can be an event animation to be generated, and the event animation can be an animation that advances the plot in the game. Its characteristics can be that the animation content is relatively simple, the production difficulty is not high, and there is almost no strong customization demand, but the production volume of the animation is huge, and a large number of existing resources (animation, special effects, scenes) in the game need to be reused. In addition, the type and number of roles that appear in the event animation are not fixed, and need to be adjusted in real time according to the state of the player in the game.

[0042] The animation configuration information may be information used to generate a target event animation. For example, the animation configuration information may be similar to a script of a target event animation, and may include the performance location of an event occurring in the target event animation, the name of a virtual character appearing in the target event animation, and event configuration information corresponding to the virtual character.

[0043] The virtual character may be a character that appears in the target event animation, and may refer to a dynamic object that can be controlled in a virtual scene. Optionally, the dynamic object may be an object such as a virtual person, a virtual animal, or a cartoon character. The event configuration information may be configuration information of a performance event configured for the virtual character in the target event animation. The performance event may be an event configured for the virtual character in the target event animation, and is used to control the activities of the virtual character in the target event animation. For example, it may include events such as character movement, action execution, and special effects playback. The event configuration information may include multiple event nodes that specify an execution order. The event node may be a node corresponding to the performance event, and may store event data required to be read in order to execute the event. For example, for a performance event of character movement, the event data stored in the event node of the event may include data such as the position of arrival, the speed of movement, and the mode of movement.

[0044] The performance synchronization node can be a node in the event node used to synchronize the plot of the target event animation. Each performance synchronization node can belong to an event node shared by at least two virtual characters. If a virtual character executes to a performance synchronization node, all virtual characters assigned to the performance synchronization node must execute to this performance synchronization node before they can enter the execution of the next event node.

[0045] For example, see Figure 3a , Figure 3a: This is a specific flow chart of an animation generation method provided by an embodiment of the present application. Assuming that the target event animation includes virtual character 1, virtual character 2, virtual character 3 and virtual character 4, based on the event configuration information of each virtual character, it can be determined that the event node corresponding to virtual character 1 can include the event node in event list 1, performance synchronization node 2 and event node corresponding to event list 8, the event node corresponding to virtual character 2 can include the event node in event list 2, performance synchronization node 1, event node corresponding to event list 5, performance synchronization node 2 and event node corresponding to event list 9, the event node corresponding to virtual character 3 can include the event node in event list 3, performance synchronization node 1, event node corresponding to event list 6, performance synchronization node 2 and event node corresponding to event list 10, and the event node corresponding to virtual character 4 can include the event node in event list 4, performance synchronization node 1 and event node corresponding to event list 7. Among them, performance synchronization node 1 can be an event node shared by virtual character 2, virtual character 3 and virtual character 4, and performance synchronization node 2 can be an event node shared by virtual character 2, virtual character 3 and virtual character 1. Among them, if the virtual character executes to the performance synchronization node 1, all virtual characters assigned to the performance synchronization node 1 must execute to this performance synchronization node, that is, virtual character 2, virtual character 3, and virtual character 4 must all execute to the performance synchronization node 1, then virtual character 2, virtual character 3, and virtual character 4 can enter the execution of the next event node.

[0046] Optionally, the animation configuration information may be similar to the script (DramaData) of the target event animation, and may include the performance location (DramaTransform) of the events constituting the target event animation, the character name list (DramaCharList) of the virtual characters performed in the target event animation, and the event list (CharDramaEventList) of the events corresponding to all virtual characters, wherein the event list includes the event nodes of the events corresponding to the virtual characters. Among them, DramaTransform may be the position coordinates of the target event animation production (during rehearsal), may include data such as the performance location (Location), rotation parameters (Rotation), and may represent the coordinates of the performance location of the target event animation and the overall rotation, etc. DramaCharList may be a list of the character names of the virtual characters appearing in the target event animation, a list consisting of a single element DramaChar (character name). CharDramaEventList may be represented as a list of events corresponding to each virtual character in the target event animation, a list consisting of a single element DramaEventList, i.e., a list of performance events that each virtual character needs to execute in the performance of the target event animation. The number of CharDramaEventLists can be the same as the number of the character names of the virtual characters in the character name list, indicating that each virtual character has its own performance event (drama track). DramaEventList can be represented as an event list of all performance events of a single virtual character.

[0047] In one embodiment, please refer to Figure 3b , Figure 3b It is a schematic diagram of an animation configuration framework of an animation generation method provided in an embodiment of the present application. The animation configuration information of the target event animation may include a performance location, a character name list, and an event list of performance events. The character name list may include character names of virtual characters such as virtual character 1, virtual character 2...virtual node N, and the event list may include event lists such as event list 1, event list 2...event list N, and each event list may include event nodes corresponding to events such as event 1, event 2...event N.

[0048] In one embodiment, please refer to Figure 3c , Figure 3cThis is a schematic diagram of event configuration information of an animation generation method provided in an embodiment of the present application. The event configuration information corresponding to the virtual character may include event nodes with an execution order, for example, may include event node 1, event node 2...event node N, each event node corresponds to a performance event of the virtual character, for example, may include events such as character movement, execution of actions, and playing of special effects, and the event node may also include at least one performance synchronization node, for example, event node 4 may be represented as a performance synchronization node, which is used to synchronize the plot of the target event animation.

[0049] In step 102, based on the animation configuration information, a second object is configured for each virtual character through the first object.

[0050] Among them, the second object can be an object of the event node that executes the virtual character, which is used to realize the virtual character in the target event animation. Each virtual character can be assigned to a second object, which is used to execute the performance event of the corresponding virtual character dispatched by the first object, and report to the first object whether the performance event currently being executed has been completed. Optionally, the second object can be an Actor object of a blueprint type, which can be the character actually performed in the target event animation.

[0051] For example, the first object may be a role type (Director) of a director function in a target event animation, the second object may be a role type (Actor) of an actor function in a target event animation, and the animation configuration information may be a script (Drama) of the target event animation. Thus, the first object (director) may drive all second objects (actors) in the target event animation to perform and play according to the animation configuration information (script), thereby obtaining the target event animation.

[0052] Among them, the first object assigns the character name list in the animation configuration information in order according to the character list of the actual characters (second objects) in the received game, and assigns the event configuration information corresponding to each virtual character to the corresponding second object, so as to configure the second object for each virtual character through the first object. Then, the first object can send performance instructions to each second object and enter the waiting mode. When the second object finishes the performance and enters the performance synchronization node, it can send the completion instruction of the event to the first object. The first object detects that when all the second objects with this performance synchronization node have arrived at this performance synchronization node, it sends the instruction to execute the next event node to the second object, otherwise, the first object continues to wait. When all the second objects have run all their event nodes, the performance execution for the target event animation ends, and the first object destroys itself.

[0053] As for the second object, the second object accepts the virtual role assigned by the first object and the corresponding event configuration information. Then, the second object checks its own event list in order, queries the first performance synchronization node, and queries the synchronization node identifier (EventDramaPoint) of the performance synchronization node, such as 1, or 2, 3, etc. Then, the value of its own second attribute parameter (DramaPoint) is set to the synchronization node identifier EventDramaPoint-1 of the first performance synchronization node queried. For example, assuming that the synchronization node identifier of the first performance synchronization node is 3, the value of its own second attribute parameter (DramaPoint) can be set to 3-1=2. Then, the second object can execute the event node in the assigned event configuration information. When the second object executes to the performance synchronization node, it can set its own second attribute parameter to the numerical value EventDramaPoint of the performance synchronization node executed, and send a completion instruction to the first object, and enter the waiting mode. Further, the second object can wait for the instruction of the next performance of the first object until all event nodes of the virtual objects assigned to it are completed.

[0054] For each event node, the event node can be configured to read and write its corresponding node data to implement the logic of event completion. After the event is completed, the event node identifier (EventID) of its parent Actor is driven to increase by 1. The event node identifier indicates the event node currently executed by the second object. Further, a function interface (process_func virtual function) for executing events can be set for each event node. The event node can execute the function interface to implement the performance event corresponding to the event node. Subsequent events derived from this basic class must implement this function. Among them, for the performance synchronization node, the performance synchronization node inherits from the basic event node, and has only one attribute, namely the synchronization node identifier (DramaPoint). When the second object runs to the performance synchronization node, it will drive the second object to send a completion instruction for the performance synchronization node to the first object.

[0055] Furthermore, during the generation of the target event animation, the events corresponding to the second object can be performed in parallel. After completing an event list, when running to the performance synchronization node, the second object can report to the first object that the event before the performance synchronization node it is currently executing has been completed, and wait for the events of other second objects assigned to the same performance synchronization node to be processed. Among them, only when all second objects assigned to the same performance synchronization node have completed their event lists, will the next event list be performed. For example, please continue to refer to Figure 3aAfter virtual character 2, virtual character 3, and virtual character 4 have completed the performance of their event lists (2, 3, 4) and reached performance synchronization node 1, they can continue with their corresponding event lists (5, 6, 7). Virtual character 1 can only continue to execute the event nodes in event list 8 after completing event list (1, 5, 6) and reaching performance synchronization node 2.

[0056] In step 103, the event node of the virtual character configured for the second object is executed.

[0057] There may be multiple ways to execute the event node of the virtual character configured for the second object through the second object. For example, the first object may send an execution instruction to all second objects, triggering the second object to query the value of the first attribute parameter configured for it, and obtain the event node identifier of the event node to be executed by the second object. Based on the event node identifier, the event node of the virtual character configured for it may be executed by the second object.

[0058] The execution instruction may be an instruction for instructing the second object to execute the next event node. For example, the execution instruction (TakeAction_Func) may be an instruction function for driving the second object to execute the event node from the current performance synchronization node (DramaPoint) to the next performance synchronization node. The first attribute parameter may include information of an event node identifier of the event node to be executed by the second object, which is used to indicate the event node to be executed by the second object. The event node identifier may be information for indicating an event node.

[0059] Among them, based on the event node identifier, there can be multiple ways to execute the event node of the virtual character configured for it through the second object. For example, the event node corresponding to the event node identifier can be executed by the second object in the event node of the virtual character configured for it. When the event node corresponding to the event node identifier is executed, the value of the first attribute parameter of the second object is increased by one, and the step of executing the event node corresponding to the event node identifier in the event node of the virtual character configured for it through the second object is returned until the event node executed by the second object is a performance synchronization node.

[0060] For example, after the first object assigns a virtual role and an event list EventList in the corresponding event configuration information to each second object, the value of the first attribute parameter (EventPoint) of each second object can be set by the first object as the event node identifier corresponding to the first event node, such as 0 or 1, so that an execution instruction (TakeAction_Func) can be sent to all second objects, triggering the second object to query the value of the first attribute parameter configured for it, and obtaining the event node identifier (EventID) of the event node to be executed by the second object, so that the second object starts to execute the first event node corresponding to the index and event node identifier in EventList, and at the same time, the first object enters a waiting state. After the second object executes the event node corresponding to the event node identifier, the event completion function (FinishEvent_Func) can be called to add one to the value of the first attribute parameter of the second object, and at the same time, the event node (Event) indexed by the new EventPoint in EventList can be executed until the event node executed is a performance synchronization node. Among them, Event is the event node of the performance event, and the interface and operation can be defined by the user himself. It is a virtual class, and the performance event can include events such as role movement, play action, special effect, execution command or performance synchronization node.

[0061] There are many ways to execute the event node corresponding to the event node identifier in the event node of the virtual character configured for it through the second object. For example, the second object can be used to determine the event node matching the event node identifier in the event node of the virtual character configured for it, obtain the event data corresponding to the event node matching the event node identifier, and the operation data corresponding to the second object, and based on the event data and the operation data, execute the event node corresponding to the event node identifier through the second object.

[0062] The event data (EventData) may be the node data of the event node, and may be the data that needs to be read in order to execute the event. For example, for the event node of the character's movement, the required event data includes the target position, the moving speed and other data. The running data may be the data of the actual running of the game, which is associated with the running game, the player account and the second object. Different games, different players or different second objects may have different running data. For example, please refer to Figure 3d , Figure 3dIt is an event execution schematic diagram of an animation generation method provided by an embodiment of the present application, wherein the operation data may include data of a runtime character (i.e., a second object), equipment and clothing configured by the player for the second object, and data such as the operation scene of the game, and the event data may include data such as a character id, a special effect id, and an animation key, wherein the character id is an identifier of a virtual character (Identity Document, referred to as ID), which is used to uniquely identify a virtual character, the special effect id may be an identifier of a special effect, which is used to indicate data of special effects to be played, and the animation key may be a keyword of an animation, for example, it may include keywords such as dancing, shaking hands, and running, which may be used to indicate corresponding animation data. In this way, the function interface (Process_Func) of the execution event can be called, combined with the event data and operation data of the event node, to control the second object to realize the performance event corresponding to the currently executed event node.

[0063] Optionally, the event data may be configured when the animation configuration information is generated, and the running data may be obtained when the target event animation is generated during the actual game process.

[0064] In one embodiment, when the first object assigns a virtual role and an event node in the corresponding event configuration information to each second object, the second attribute parameter of each second object may be initialized and set. The second attribute parameter may be information indicating a synchronization node identifier of a performance synchronization node that has been most recently executed by the second object. The synchronization node identifier may be an identifier indicating a sequence number of the performance synchronization node, for example, it may be a sequence number of the performance synchronization node, for example, it may be a numerical identifier such as 1, 2, 3, or a sequence number identifier such as a, b, c. For example, before the second object executes the event node of the virtual role configured for it, the second object may determine the first performance synchronization node corresponding to the second object according to the execution order of the event node of the virtual role configured for it, so that the synchronization node identifier of the first performance synchronization node may be reduced by one, and the reduced synchronization node identifier may be stored as the value of the second attribute parameter of the second object.

[0065] For example, when the second object receives the event configuration information of the assigned virtual character, the event list inside the second object can be set to the event list EventList of the event node assigned by the first object. At the same time, the values ​​of the internal first attribute parameter EventPoint and the second attribute parameter DramaPoint can be set to 0, and the object enters a waiting state. When the second object receives the execution instruction of TakeAction_Func sent by the first object, it can sequentially query the event nodes from EventPoint to the entire EventList length (sizeof(EventList)). When the event node is a performance synchronization node, the query is stopped to obtain the first performance synchronization node DramaPointEvent of the second object, obtain the synchronization node identifier (EventDramaPoint) in the performance synchronization node data (DramaPointData) of the performance synchronization node, and set the value of the second attribute parameter (ActorDramaPoint) of the second object to EventDramaPoint-1. For example, please continue to refer to Figure 3a , assuming that the first object 1 is configured for virtual character 1, the first object 2 is configured for virtual character 2, the first object 3 is configured for virtual character 3, and the first object 4 is configured for virtual character 4, wherein the performance synchronization node closest to virtual character 1 is performance synchronization node 2, that is, for performance synchronization node 1, virtual character 1 does not participate in the synchronization of the performance synchronization node. Therefore, at the beginning of execution, the value of the second attribute parameter of virtual character 1 can be set to 1 to prevent obstruction of other virtual characters that need to synchronize with performance synchronization node 1, because as long as the value of the second attribute parameter of the second object 1 is set to 1, when the other three characters subsequently run to performance synchronization node 1, the first object will detect that the second attribute parameters of all second objects are 1, which is greater than the synchronization node identifier 0 corresponding to the first object. Therefore, the first object will send the execution instruction TakeAction_Func to all second objects, and the second objects 2, 3 and 4 will execute the event nodes between performance synchronization node 1 and performance synchronization node 2, and the second object 1 is originally in the execution process of the event node and is not affected by the synchronization process of performance synchronization node 1.

[0066] In one embodiment, when the first object assigns a virtual role and an event node in the corresponding event configuration information to each second object, the third attribute parameter of the first object may also be initialized and set. The third attribute parameter may be information indicating the synchronization node identifier of the performance synchronization node that has recently completed synchronization. For example, before the second object starts to execute the event node, the value of the third attribute parameter of the first object may be set to 0. When the second objects assigned with performance synchronization node 1 have completed the execution of performance synchronization node 1, the value of the third attribute parameter of the first object may be updated from 0 to 1 to indicate that the performance synchronization node 1 has been synchronized.

[0067] Optionally, since the second object updates the value of its second attribute parameter based on the synchronization node identifier of the executed performance synchronization node when executing the performance synchronization node, and the first object updates the value of its third attribute parameter based on the synchronization node identifier of the current performance synchronization node when receiving the completion instruction sent by all second objects belonging to the performance synchronization node, the value of the second attribute parameter of the second object is greater than or equal to the value of the second attribute parameter of the first object. The first object sends the execution instruction TakeAction_Func according to the value of its own third attribute parameter, so that the second object executes the event node whose value is greater than the third attribute parameter of the first object.

[0068] In step 104, when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object.

[0069] The completion instruction may be an instruction to send information to the first object indicating that the second object has completed the current performance synchronization node. For example, when the event node executed by the second object is a performance synchronization node, the event completion function (FinishEvent_Func) may be called. After the FinishEvent_Func function is run, the notification function (Report_Func) may be executed to notify the first object that the current second object has executed to the current performance synchronization node and needs to wait for the next command of the first object, otherwise it enters a waiting state. The waiting state may not be a real wait, and may just continue to execute the previous event node without being required to execute a new event node.

[0070] Optionally, each performance synchronization node can be configured with a synchronization node identifier, and the synchronization node identifiers of all performance synchronization nodes are set in a preset order. For example, the performance synchronization nodes can set their corresponding synchronization node identifiers based on a preset order, such as synchronization node identifiers 1, 2, 3, etc. The synchronization order of synchronization node identifier 1 is greater than that of synchronization node identifier 2, the synchronization order of synchronization node identifier 2 is greater than that of synchronization node identifier 3, and so on. Correspondingly, performance synchronization node 1 can be represented as the performance synchronization node corresponding to synchronization node identifier 1, performance synchronization node 2 can be represented as the performance synchronization node corresponding to synchronization node identifier 2, and so on.

[0071] Among them, when the first object receives a completion instruction for a performance synchronization node sent by the second object, the first synchronization node identifier of the performance synchronization node corresponding to the completion instruction can be determined, and the second synchronization node identifier of the latest performance synchronization node executed by all second objects can be queried. If the queried second synchronization node identifiers are not before the order of the first synchronization node identifiers, it is determined that the first object has received completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node.

[0072] The first synchronization node identifier may be the synchronization node identifier of the performance synchronization node corresponding to the completion instruction, and the second synchronization node identifier may be the synchronization node identifier of the latest performance synchronization node executed by all second objects.

[0073] For example, please refer to Figure 3a , when the first object receives the completion instruction for the performance synchronization node 1 sent by the second object 2 corresponding to the virtual character 2, it can be determined that the first synchronization node identifier of the performance synchronization node 1 corresponding to the completion instruction is 1, and the second synchronization node identifier of the latest performance synchronization node executed by all the second objects is queried. If the virtual character 3 has not yet executed the performance synchronization node 1, the first synchronization node identifier of the virtual character 3 is 0. At this time, there is a synchronization node identifier 0 in the queried second synchronization node identifier that is before the order of the first synchronization node identifier 1. Therefore, the first object and the virtual character 2 need to continue waiting. When the virtual characters 3 and 4 execute the performance synchronization node 1, the synchronization node identifiers of the virtual characters 3 and 4 are updated to 1. Regardless of whether the virtual character 1 executes the performance synchronization node 2, its corresponding synchronization node identifier is greater than or greater than 1. Therefore, the second synchronization node identifiers queried at this time are not before the order of the first synchronization node identifier. It can be determined that the first object receives the completion instruction for the performance synchronization node 1 sent by all the target second objects belonging to the performance synchronization node 1 (the second object 2 corresponding to the virtual character 2, the second object 3 corresponding to the virtual character 3, and the second object 4 corresponding to the virtual character 4).

[0074] In one embodiment, before executing the event node of the virtual character configured for the second object through the second object, the first performance synchronization node corresponding to the second object can be determined through the second object in the execution order of the event nodes of the virtual character configured for the second object, the synchronization node identifier of the first performance synchronization node can be reduced by one, and the reduced synchronization node identifier can be stored as the value of the second attribute parameter of the second object.

[0075] Among them, when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and there are multiple ways to send a completion instruction for the performance synchronization node to the first object. For example, when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, the synchronization node identifier of the performance synchronization node is obtained to update the value of the second attribute parameter of the second object, and the completion instruction for the performance synchronization node is sent to the first object;

[0076] There may be multiple steps for querying the second synchronization node identifier of the latest performance synchronization node executed by all second objects. For example, the values ​​of the second attribute parameters of all second objects may be queried to obtain the second synchronization node identifier.

[0077] For example, when a completion instruction for a performance synchronization node is received from the second object, the synchronization node identification query function (GetAllCharDramaPoint_Func) can be called to obtain the current value of the second attribute parameter of all second objects of the target event animation, and obtain the second synchronization node identification of the latest performance synchronization node executed by all second objects.

[0078] In step 105, if the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate a target event animation.

[0079] In this way, the first object controls the second object to execute the event node of the virtual character assigned to it, so that based on the execution of the event node by the second object, a target event animation can be generated, which greatly improves the generation efficiency of the event animation.

[0080] For example, see Figure 4 , Figure 4It is another specific flow chart of an animation generation method provided by an embodiment of the present application. Assuming that the target event animation includes 5 virtual characters, the animation configuration information of the target event animation can be read by the created first object to assign the virtual characters and the corresponding event configuration information to the second object 1, the second object 2, the second object 3 and the second object 4, so that the first object can drive each second object to execute the event node of the virtual character assigned to it. For example, the second object 1 executes the event nodes in the event list 1, the performance synchronization node 2, the event nodes in the event list 8, the performance synchronization node 3 and other event nodes in the execution order; the second object 2 executes the event nodes in the event list 2, the performance synchronization node 1, the event nodes in the event list 5, the performance synchronization node 2, the event nodes in the event list 9, the performance synchronization node 3 and other event nodes in the execution order; the second object 3 executes the event nodes in the event list 3, the performance synchronization node 1, the event nodes in the event list 6, the performance synchronization node 2, the event nodes in the event list 10, the performance synchronization node 3 and other event nodes in the execution order; the second object 4 executes the event nodes in the event list 4, the performance synchronization node 1, the event nodes in the event list 7 and other event nodes in the execution order. Among them, after the second object 2, the second object 3 and the second object 4 have all executed the performance synchronization node 1, the first object calls the execution instruction TakeAction_Func, drives the second object 2, the second object 3 and the second object 4 to query the current value of the first attribute parameter (EventPoint), and starts to execute the event node corresponding to the index of the assigned event list EventList and the queried value EventPoint of the first attribute parameter, that is, drives the second object 2, the second object 3 and the second object 4 to execute the next event node of the performance synchronization node 1, that is, the event node in the event list 5, event list 6, and event list 7, and the first object enters a waiting state, and the execution of the second object 1 before reaching the performance synchronization node 2 is not affected by other second objects. After the second object 2, the second object 3 and the second object 1 have all executed the performance synchronization node 2, the first object will drive the second object 2, the second object 3 and the second object 1 to execute the next event node of the performance synchronization node 2, that is, the event node in the event list 8, event list 9, and event list 10. When the first object 1, the second object 2, the second object 3 and the second object 4 have all executed the performance synchronization node 3, the generation process of the target event animation is completed.

[0081] Optionally, if all event nodes of the virtual character corresponding to the second object are executed, the value of the second attribute parameter of the second object can be set to the target value to indicate that all event nodes required to be executed by the second object are executed.

[0082] Among them, the target value can be a value indicating that all event nodes required to be executed by the second object have been executed, which can be different from the value of the synchronization node identifier of the performance synchronization node. For example, it can be -1, or a value that is not less than the maximum synchronization node identifier of the performance synchronization nodes corresponding to all second objects.

[0083] In one embodiment, when the second object has executed all event nodes of the virtual character configured for it, it can set its second attribute parameter to -1, indicating that the virtual character corresponding to the second object has been completely executed. In the subsequent synchronization process of the performance synchronization node, the first object does not need to wait for this second object, and can drive other second objects to enter the execution of the event node in the next event list.

[0084] For example, please refer to Figure 4 , after the second object 4 executes all the event nodes in the event list 7, it indicates that the second object 4 has executed all the event nodes of the virtual character configured for it, so that the value of the second attribute parameter of the second object 4 can be set to the target value -1 or 3 to indicate that all the event nodes that the second object needs to execute have been executed. In the subsequent synchronization process, the first object does not need to wait for this second object, and can drive other second objects to enter the execution of the event nodes in the next event list according to the value of the second attribute parameter of other second objects.

[0085] In the existing event animation generation method, the cutscene editor provided by the game engine is often used, and the traditional customized animation production process is used, that is, the script-3D storyboard-animation-special effects-lighting workflow. The animation time frame is used as the synchronization standard for all characters and special effects to produce event animations. That is, on the same time frame, the character's position, action, and special effects are consistent. This animation generation method has a cumbersome production process. Using this animation generation method to produce event animations will result in huge production costs.

[0086] It can be seen that traditional custom animations are indeed synchronized with a fixed timeline, and the playback of animations is usually predetermined and not controlled by players, while event animations are synchronized with player interactions, which means that the playback of animations and the progress of the plot are determined by the player's behavior, such as the triggering of events such as clicking, dragging, or completing a task, and the plot animation with event triggering as the core needs to respond more dynamically to the player's operations and inputs to ensure that the plot story can be coherently unfolded according to the player's actions. In addition, the animations produced by the existing animation production methods are highly customizable and have low resource reusability. The time lengths of various animations are not the same, and it is difficult to apply other actions or special effects in the form of a template, thereby increasing the cost of animation production. At the same time, the existing animation generation method does not support the synchronization of multiple character events, and cannot handle the parallel activities of different characters at the same time. The system may require events to occur in sequence. Before the event of one character is completed, the parallel event of another character cannot be started, which makes the animation generation efficiency low.

[0087] To this end, the embodiment of the present application provides a node-based performance event editing framework through a proposed animation generation method, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, thereby configuring the second object for each virtual character through the first object, triggering the second object to execute the event node of the virtual character configured for it, and, when the event node is a performance synchronization node, controlling the second object configured with the performance synchronization node to perform plot synchronization of the target event animation, thereby generating the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object. This method allows operation planners and other personnel to quickly splice and configure event animations in a modular manner, thereby enhancing the interactivity of the game and the continuity of the plot. There is no need to customize unique animations for each scene, effectively simplifying the animation generation process, reducing the production cost of the animation, thereby optimizing resource allocation while ensuring the quality of the game, and thereby improving the efficiency of animation generation.

[0088] Among them, the performance event editing framework based on the node designed by the embodiment of the present application is independent of the specific game engine, and can be specially developed and integrated according to different engine requirements, which greatly improves the engine versatility of the animation generation method. At the same time, based on the execution of event nodes, it can be expanded according to the specific needs of the game. At the same time, the performance event editing framework provided by the embodiment of the present application can realize basic events such as character movement, action playback, special effects display and performance lens call, which can improve the scalability of event animation generation. In addition, the embodiment of the present application provides an intuitive node editing system, which can allow non-professionals to quickly combine events to form animations based on user-friendly node editing, which is convenient for viewing plot performances. In addition, the embodiment of the present application can customize unique playback effects for different virtual characters by realizing the function interface defined by the event, which exceeds the animation production effect of the replacement of simple models or actions, and can support modification and addition of content on the basis of existing event animations, and improve animation production flexibility and iteration speed. In addition, the animation generation method provided in the embodiment of the present application can reuse a large number of existing animations, special effects and character resources within the game, thereby reducing the cost of animation production and enhancing the overall relevance to the game. At the same time, it can have a more suitable synchronization mechanism. For games with a large number of event animations, performance synchronization nodes can be used to achieve plot synchronization of virtual characters, solving the problems of synchronization difficulties caused by the inconsistency of the duration of different character actions and the uncertainty of player interaction encountered in traditional time frame-based synchronization, greatly improving the efficiency of animation generation.

[0089] From the above, it can be seen that the embodiment of the present application adopts a first object to read the animation configuration information of the target event animation, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution order, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; based on the animation configuration information, a second object is configured for each virtual character through the first object; the event node of the virtual character configured for it is executed through the second object; when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; if the first object receives a completion instruction for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation. In this way, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, the second object is configured for each virtual character through the first object, the second object is triggered to execute the event node of the virtual character configured for it, and when the event node is a performance synchronization node, the second object configured with the performance synchronization node is controlled to perform plot synchronization of the target event animation, so as to generate the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object, and realize rapid splicing and configuration of event animation in a modular manner, which effectively simplifies the animation generation process, reduces the production cost of animation, and thus improves the animation generation efficiency.

[0090] In order to better implement the above method, an embodiment of the present invention further provides an animation generating device, which can be integrated in an electronic device, and the electronic device can be a terminal or a server.

[0091] For example, Figure 5 As shown, it is a schematic diagram of the structure of the animation generating device provided in the embodiment of the present application, and the animation generating device may include an acquiring unit 201, a configuring unit 202, an executing unit 203, a sending unit 204 and a generating unit 205, as follows:

[0092] The acquisition unit 201 is used to read the animation configuration information of the target event animation through the first object, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes a plurality of event nodes with specified execution order, the event nodes include at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters;

[0093] A configuration unit 202, configured to configure a second object for each virtual character through the first object based on the animation configuration information;

[0094] An execution unit 203, configured to execute, through the second object, an event node of the virtual character configured for the second object;

[0095] The sending unit 204 is used for sending a completion instruction for the performance synchronization node to the first object without entering the next event node after the performance synchronization node when the event node executed by the second object is a performance synchronization node;

[0096] The generation unit 205 is used to control the target second object to execute the next event node of the same performance synchronization node to generate a target event animation if the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node.

[0097] In some embodiments, the execution unit 203 includes:

[0098] An event identifier query subunit, used to send an execution instruction to all second objects through the first object, trigger the second object to query the value of the first attribute parameter configured for it, and obtain the event node identifier of the event node to be executed by the second object;

[0099] The event node execution subunit is used to execute the event node of the virtual role configured for it through the second object based on the event node identifier.

[0100] In some embodiments, the event node execution subunit includes:

[0101] A first execution module, configured to execute, through the second object, an event node of the virtual character configured for it, the event node corresponding to the event node identifier;

[0102] An attribute processing module, used for adding one to the value of the first attribute parameter of the second object when the event node corresponding to the event node identifier is executed;

[0103] The second execution module is used to return to the step of executing the event node corresponding to the event node identifier in the event node of the virtual character configured for it through the second object, until the event node executed by the second object is a performance synchronization node.

[0104] In some embodiments, the first execution module is used to:

[0105] Determine, by means of the second object, an event node matching the event node identifier among the event nodes of the virtual character configured for the second object;

[0106] Acquire event data corresponding to the event node matching the event node identifier, and operation data corresponding to the second object;

[0107] Based on the event data and the operation data, an event node corresponding to the event node identifier is executed by the second object.

[0108] In some embodiments, each performance synchronization node is configured with a synchronization node identifier, and the synchronization node identifiers of all performance synchronization nodes are arranged in a preset order, and the animation generation device further includes an event synchronization unit, including:

[0109] An identification determination subunit, configured to determine a first synchronization node identification of a performance synchronization node corresponding to the completion instruction when the first object receives a completion instruction for a performance synchronization node sent by the second object;

[0110] An identification acquisition subunit, used for querying the second synchronization node identification of the latest performance synchronization node executed by all second objects;

[0111] The synchronization subunit is used to determine that the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node if the queried second synchronization node identifiers are not before the order of the first synchronization node identifiers.

[0112] In some embodiments, the animation generating device further includes a second attribute parameter determining unit, which is used to:

[0113] Determine, through the second object, the first performance synchronization node corresponding to the second object according to the execution order of the event nodes of the virtual character configured for the second object;

[0114] Decrement the synchronization node identifier of the first performance synchronization node by one, and store the decremented synchronization node identifier as the value of the second attribute parameter of the second object;

[0115] The sending unit 204 is used for:

[0116] When the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, the synchronization node identifier of the performance synchronization node is obtained to update the value of the second attribute parameter of the second object, and a completion instruction for the performance synchronization node is sent to the first object;

[0117] Identifies the acquisition subunit, which is used to:

[0118] The values ​​of the second attribute parameters of all the second objects are queried to obtain the second synchronization node identifier.

[0119] In some embodiments, the animation generating device further includes a property setting unit, which is used to:

[0120] If all event nodes of the virtual character corresponding to the second object are executed, the value of the second attribute parameter of the second object is set to the target value to indicate that all event nodes required to be executed by the second object are executed.

[0121] In specific implementation, the above units can be implemented as independent entities, or can be arbitrarily combined to be implemented as the same or several entities. The specific implementation of the above units can refer to the previous method embodiments, which will not be repeated here.

[0122] As can be seen from the above, the embodiment of the present application reads the animation configuration information of the target event animation through the first object by the acquisition unit 201, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution order, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; the configuration unit 202 configures the second object for each virtual character through the first object based on the animation configuration information; the execution unit 203 executes the event node of the virtual character configured for it through the second object; the sending unit 204 does not enter the next event node after the performance synchronization node when the event node executed by the second object is a performance synchronization node, and sends a completion instruction for the performance synchronization node to the first object; the generation unit 205 controls the target second object to execute the next event node of the same performance synchronization node if the first object receives the completion instruction for the same performance synchronization node from all target second objects belonging to the same performance synchronization node, so as to generate the target event animation. In this way, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, the second object is configured for each virtual character through the first object, the second object is triggered to execute the event node of the virtual character configured for it, and when the event node is a performance synchronization node, the second object configured with the performance synchronization node is controlled to perform plot synchronization of the target event animation, so as to generate the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object, and realize rapid splicing and configuration of event animation in a modular manner, which effectively simplifies the animation generation process, reduces the production cost of animation, and thus improves the animation generation efficiency.

[0123] The present application also provides an electronic device, such as Figure 6 As shown, it shows a schematic diagram of the structure of an electronic device involved in an embodiment of the present application, and the electronic device may be a terminal or a server. Specifically:

[0124] The electronic device 300 includes a processor 301 having one or more processing cores, a memory 302 having one or more computer-readable storage media, and a computer program stored in the memory 302 and executable on the processor. The processor 301 is electrically connected to the memory 302. Those skilled in the art will appreciate that the electronic device structure shown in the figure does not constitute a limitation on the electronic device, and may include more or fewer components than shown in the figure, or combine certain components, or arrange the components differently.

[0125] The processor 301 is the control center of the electronic device 300. It uses various interfaces and lines to connect various parts of the entire electronic device 300, executes various functions of the electronic device 300 and processes data by running or loading software programs and / or modules stored in the memory 302, and calling data stored in the memory 302, thereby monitoring the electronic device 300 as a whole.

[0126] In the embodiment of the present application, the processor 301 in the electronic device 300 will load instructions corresponding to the processes of one or more application programs into the memory 302 according to the following steps, and the processor 301 will run the application programs stored in the memory 302 to implement various functions:

[0127] Reading animation configuration information of a target event animation through a first object, the animation configuration information including at least one virtual character in the target event animation and event configuration information of the virtual character, the event configuration information including a plurality of event nodes with specified execution order, the event nodes including at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters;

[0128] Based on the animation configuration information, configuring a second object for each virtual character through the first object;

[0129] Execute the event node of the virtual character configured for the second object through the second object;

[0130] When the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object;

[0131] If the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate a target event animation.

[0132] This solution can use a first object to read the animation configuration information of the target event animation, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution order, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; based on the animation configuration information, a second object is configured for each virtual character through the first object; the event node of the virtual character configured for it is executed through the second object; when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; if the first object receives a completion instruction for the same performance synchronization node from all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation. In this way, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, the second object is configured for each virtual character through the first object, the second object is triggered to execute the event node of the virtual character configured for it, and when the event node is a performance synchronization node, the second object configured with the performance synchronization node is controlled to perform plot synchronization of the target event animation, so as to generate the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object, and realize rapid splicing and configuration of event animation in a modular manner, which effectively simplifies the animation generation process, reduces the production cost of animation, and thus improves the animation generation efficiency.

[0133] The specific implementation of the above operations can be found in the previous embodiments, which will not be described in detail here.

[0134] Optional, such as Figure 6 As shown, the electronic device 300 further includes: a touch screen 303, a radio frequency circuit 304, an audio circuit 305, an input unit 306, and a power supply 307. The processor 301 is electrically connected to the touch screen 303, the radio frequency circuit 304, the audio circuit 305, the input unit 306, and the power supply 307, respectively. Those skilled in the art can understand that Figure 6 The electronic device structure shown in the figure does not constitute a limitation of the electronic device, and may include more or less components than shown in the figure, or combine certain components, or arrange the components differently.

[0135] The touch display screen 303 can be used to display a graphical user interface and receive operation instructions generated by the user acting on the graphical user interface. The touch display screen 303 may include a display panel and a touch panel. Among them, the display panel can be used to display information input by the user or information provided to the user and various graphical user interfaces of the electronic device, and these graphical user interfaces can be composed of graphics, text, icons, videos and any combination thereof. Optionally, the display panel can be configured in the form of a liquid crystal display (LCD, Liquid Crystal Display), an organic light-emitting diode (OLED, Organic Light-Emitting Diode) and the like. The touch panel can be used to collect the user's touch operation on or near it (such as the user uses any suitable object or attachment such as a finger, a stylus, etc. on the touch panel or near the touch panel), and generate corresponding operation instructions, and the operation instructions execute corresponding programs. Optionally, the touch panel may include two parts: a touch detection device and a touch controller. Among them, the touch detection device detects the user's touch direction, detects the signal brought by the touch operation, and transmits the signal to the touch controller; the touch controller receives the touch information from the touch detection device, converts it into the touch point coordinates, and then sends it to the processor 301, and can receive the command sent by the processor 301 and execute it. The touch panel can cover the display panel. When the touch panel detects a touch operation on or near it, it is transmitted to the processor 301 to determine the type of touch event, and then the processor 301 provides a corresponding visual output on the display panel according to the type of touch event. In an embodiment of the present application, the touch panel and the display panel can be integrated into the touch display screen 303 to realize the input and output functions. However, in some embodiments, the touch panel and the touch panel can be used as two independent components to realize the input and output functions. That is, the touch display screen 303 can also be used as a part of the input unit 306 to realize the input function.

[0136] The radio frequency circuit 304 may be used to send and receive radio frequency signals, so as to establish wireless communication with a network device or other electronic devices through wireless communication, and to send and receive signals with the network device or other electronic devices.

[0137] The audio circuit 305 can be used to provide an audio interface between the user and the electronic device through a speaker and a microphone. The audio circuit 305 can transmit the electrical signal converted from the received audio data to the speaker, which is converted into a sound signal for output; on the other hand, the microphone converts the collected sound signal into an electrical signal, which is received by the audio circuit 305 and converted into audio data, and then the audio data is output to the processor 301 for processing, and then sent to another electronic device through the radio frequency circuit 304, or the audio data is output to the memory 302 for further processing. The audio circuit 305 may also include an earplug jack to provide communication between an external headset and the electronic device.

[0138] The input unit 306 may be used to receive input numbers, character information or user feature information (such as fingerprint, iris, facial information, etc.), and generate keyboard, mouse, joystick, optical or trackball signal input related to user settings and function control.

[0139] The power supply 307 is used to supply power to various components of the electronic device 300. Optionally, the power supply 307 can be logically connected to the processor 301 through a power management system, so that the power management system can manage charging, discharging, and power consumption. The power supply 307 can also include one or more DC or AC power supplies, recharging systems, power failure detection circuits, power converters or inverters, power status indicators, and other arbitrary components.

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

[0141] In the above embodiments, the description of each embodiment has its own emphasis. For the parts not described in detail in a certain embodiment, please refer to the relevant description of other embodiments. It should be noted that the electronic device provided in the embodiment of the present application and the method for generating animation in the above embodiment belong to the same concept. The specific implementation process is detailed in the above method embodiment and will not be repeated here.

[0142] As can be seen from the above, the electronic device provided by the embodiment of the present application can read the animation configuration information of the target event animation by adopting the first object, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution order, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; based on the animation configuration information, the second object is configured for each virtual character through the first object; the event node of the virtual character configured for it is executed through the second object; when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; if the first object receives a completion instruction for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation. In this way, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, the second object is configured for each virtual character through the first object, the second object is triggered to execute the event node of the virtual character configured for it, and when the event node is a performance synchronization node, the second object configured with the performance synchronization node is controlled to perform plot synchronization of the target event animation, so as to generate the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object, and realize rapid splicing and configuration of event animation in a modular manner, which effectively simplifies the animation generation process, reduces the production cost of animation, and thus improves the animation generation efficiency.

[0143] Those skilled in the art will appreciate that all or part of the steps in the various methods of the above embodiments may be completed by a computer program, or by controlling related hardware through a computer program. The computer program may be stored in a computer-readable storage medium and loaded and executed by a processor.

[0144] To this end, an embodiment of the present application provides a computer-readable storage medium, in which a computer program is stored, and the computer program can be loaded by a processor to execute the steps in any animation generation method provided in the embodiment of the present application. For example, the computer program can execute the following steps:

[0145] Reading animation configuration information of a target event animation through a first object, the animation configuration information including at least one virtual character in the target event animation and event configuration information of the virtual character, the event configuration information including a plurality of event nodes with specified execution order, the event nodes including at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters;

[0146] Based on the animation configuration information, configuring a second object for each virtual character through the first object;

[0147] Execute the event node of the virtual character configured for the second object through the second object;

[0148] When the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object;

[0149] If the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate a target event animation.

[0150] This solution can use a first object to read the animation configuration information of the target event animation, the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, the event configuration information includes multiple event nodes with specified execution order, and the event nodes include at least one performance synchronization node, wherein each performance synchronization node belongs to an event node shared by at least two virtual characters; based on the animation configuration information, a second object is configured for each virtual character through the first object; the event node of the virtual character configured for it is executed through the second object; when the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; if the first object receives a completion instruction for the same performance synchronization node from all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation. In this way, by configuring the target event animation to be composed of multiple virtual characters and event nodes of multiple events corresponding to the virtual characters, the second object is configured for each virtual character through the first object, the second object is triggered to execute the event node of the virtual character configured for it, and when the event node is a performance synchronization node, the second object configured with the performance synchronization node is controlled to perform plot synchronization of the target event animation, so as to generate the target event animation based on the process control of the first object and the execution of the configured event nodes by each second object, and realize rapid splicing and configuration of event animation in a modular manner, which effectively simplifies the animation generation process, reduces the production cost of animation, and thus improves the animation generation efficiency.

[0151] The specific implementation of the above operations can be found in the previous embodiments, which will not be described in detail here.

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

[0153] Since the computer program stored in the computer-readable storage medium can execute the steps in any animation generation method provided in the embodiments of the present application, the beneficial effects that can be achieved by any animation generation method provided in the embodiments of the present application can be achieved. Please refer to the previous embodiments for details and will not be repeated here.

[0154] Among them, according to one aspect of the present application, a computer program product is provided, which includes a computer program, and the computer program is stored in a computer-readable storage medium; when a processor of an electronic device reads the computer program from the computer-readable storage medium, the processor executes the computer program, so that the electronic device executes the methods provided in the various optional implementations provided in the above embodiments.

[0155] The above is a detailed introduction to an animation generation method, device, storage medium and electronic device provided in the embodiments of the present application. Specific examples are used in this article to illustrate the principles and implementation methods of the present application. The description of the above embodiments is only used to help understand the method of the present application and its core idea; at the same time, for technical personnel in this field, according to the idea of ​​the present application, there will be changes in the specific implementation method and application scope. In summary, the content of this specification should not be understood as a limitation on the present application.

Claims

1. An animation generation method, characterized in that: include: Reading, through a first object, animation configuration information of a target event animation, wherein the animation configuration information includes at least one virtual character in the target event animation and event configuration information of the virtual character, wherein the event configuration information includes a plurality of event nodes with specified execution orders, wherein the event nodes include at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters; Based on the animation configuration information, configuring a second object for each virtual character through the first object; Executing the event node of the virtual character configured for the second object through the second object; When the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, and a completion instruction for the performance synchronization node is sent to the first object; If the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, the target second object is controlled to execute the next event node of the same performance synchronization node to generate the target event animation.

2. The animation generation method according to claim 1, characterized in that: The executing, by the second object, the event node of the virtual character configured for it comprises: Sending an execution instruction to all second objects through the first object, triggering the second object to query the value of the first attribute parameter configured for it, and obtaining the event node identifier of the event node to be executed by the second object; Based on the event node identifier, the event node of the virtual character configured for the second object is executed by the second object.

3. The animation generation method according to claim 2, characterized in that: The executing, by the second object, the event node of the virtual character configured for the event node identifier comprises: The event node corresponding to the event node identifier is executed by the second object in the event node of the virtual character configured for it; When the event node corresponding to the event node identifier is executed, adding one to the value of the first attribute parameter of the second object; Return to the step of executing the event node of the virtual character configured for it by the second object, wherein the event node identifies the corresponding event node, until the event node executed by the second object is a performance synchronization node.

4. The animation generation method according to claim 3, characterized in that: In the event node of the virtual character configured for the second object, the event node corresponding to the event node identifier includes: Determine, through the second object, an event node matching the event node identifier among the event nodes of the virtual character configured for the second object; Acquire event data corresponding to the event node matching the event node identifier, and operation data corresponding to the second object; Based on the event data and the operation data, an event node corresponding to the event node identifier is executed through the second object.

5. The animation generation method according to any one of claims 1 to 4, characterized in that: Each performance synchronization node is configured with a synchronization node identifier, and the synchronization node identifiers of all performance synchronization nodes are arranged in a preset order. If the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node, before controlling the target second object to execute the next event node of the same performance synchronization node, it also includes: When the first object receives the completion instruction sent by the second object for the performance synchronization node, determining the first synchronization node identifier of the performance synchronization node corresponding to the completion instruction; Query the second synchronization node identifier of the latest performance synchronization node executed by all the second objects; If the queried second synchronization node identifiers are not before the order of the first synchronization node identifiers, it is determined that the first object receives completion instructions sent by all target second objects belonging to the same performance synchronization node for the same performance synchronization node.

6. The animation generation method according to claim 5, characterized in that: Before executing the event node of the virtual character configured for the second object, the method further includes: Determine, by means of the second object, a first performance synchronization node corresponding to the second object according to the execution order of the event nodes of the virtual character configured for the second object; Subtract one from the synchronization node identifier of the first performance synchronization node, and store the subtracted synchronization node identifier as the value of the second attribute parameter of the second object; When the event node executed by the second object is a performance synchronization node, not entering the next event node after the performance synchronization node, and sending a completion instruction for the performance synchronization node to the first object, including: When the event node executed by the second object is a performance synchronization node, the next event node after the performance synchronization node is not entered, the synchronization node identifier of the performance synchronization node is obtained to update the value of the second attribute parameter of the second object, and a completion instruction for the performance synchronization node is sent to the first object; The querying of the second synchronization node identifier of the latest performance synchronization node executed by all the second objects includes: The values ​​of the second attribute parameters of all the second objects are queried to obtain the second synchronization node identifier.

7. The animation generation method according to claim 6, characterized in that: The method further comprises: If all event nodes of the virtual character corresponding to the second object are executed, the value of the second attribute parameter of the second object is set to the target value to indicate that all event nodes required to be executed by the second object are executed.

8. An animation generating device, characterized in that: include: An acquisition unit is used to read the animation configuration information of the target event animation through the first object, wherein the animation configuration information includes at least one virtual character in the target event animation and the event configuration information of the virtual character, wherein the event configuration information includes a plurality of event nodes with specified execution order, wherein the event nodes include at least one performance synchronization node, wherein each performance synchronization node is an event node shared by at least two virtual characters; a configuration unit, configured to configure a second object for each virtual character through the first object based on the animation configuration information; an execution unit, configured to execute, through the second object, the event node of the virtual character configured for the second object; a sending unit, configured to send a completion instruction for the performance synchronization node to the first object without entering the next event node after the performance synchronization node when the event node executed by the second object is a performance synchronization node; A generating unit is used to control the target second object to execute the next event node of the same performance synchronization node to generate the target event animation if the first object receives completion instructions for the same performance synchronization node sent by all target second objects belonging to the same performance synchronization node.

9. An electronic device, characterized in that: It comprises a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed by the processor, the processor executes the steps of any one of the methods of claims 1 to 7.

10. A computer-readable storage medium, characterized in that: It comprises a computer program. When the computer program is run on an electronic device, the computer program is used to make the electronic device execute the steps of any one of the methods of claims 1 to 7.

Images