Resource processing system and method and resource loading plug-in

Abstract

The invention provides a resource processing system and method and a resource loading plug-in. The resource processing system comprises a resource making tool, a resource editor and a game engine. Wherein the resource making tool is configured to create a 2D resource to be processed; the resource editor is configured to receive the to-be-processed 2D resource, generate at least one key frame animation based on the to-be-processed 2D resource, create a resource model configuration file based on each key frame animation, and send the resource model configuration file to the game engine; and the game engine is configured to add the to-be-processed 2D resource according to the resource loading plug-in and the resource model configuration file. By means of the system, technicians can directly apply the 2D resources to be processed in the game engine, and the working efficiency and flexibility are greatly improved.

Description

[0001] This application claims priority to Chinese Patent Application No. 202411095851.9, filed on August 9, 2024, entitled “Resource Processing System, Method, and Resource Loading Plugin”, the entire contents of which are incorporated herein by reference. Technical Field

[0002] This application relates to the field of computer technology, and in particular to a resource processing system, method, and apparatus. It includes a computing device, a computer-readable storage medium, and a computer program. Background Technology

[0003] With the development of internet technology, the gaming industry has experienced rapid growth, and game content has become increasingly rich and diverse. 2D games are widely popular due to their high compatibility and low resource consumption.

[0004] Animation is a crucial aspect of 2D game development. Live2D is a graphics rendering technology used in video games, generating a 2D image resembling a 3D model through a series of continuous images and character modeling. Currently, Live2D development requires tedious manual adaptation of existing Live2D resources, consuming significant time and effort for developers. Summary of the Invention

[0005] In view of this, embodiments of this application provide a resource processing system to address the technical deficiencies existing in the prior art. Embodiments of this application also provide a resource processing method, an apparatus, a computing device, a computer-readable storage medium, and a computer program.

[0006] According to a first aspect of the embodiments of this application, a resource processing system is provided, including a resource creation tool, a resource editor, and a game engine; wherein, The resource creation tool is configured to create 2D resources to be processed; The resource editor is configured to receive the 2D resource to be processed, generate at least one keyframe animation based on the 2D resource to be processed, create a resource model configuration file based on each keyframe animation, and send the resource model configuration file to the game engine. The game engine is configured to add the 2D resources to be processed based on the resource loading plugin and the resource model configuration file.

[0007] According to a second aspect of the embodiments of this application, a resource processing method is provided, including: Receive 2D resources to be processed; Generate at least one keyframe animation based on the 2D resource to be processed; A resource model configuration file is created based on each keyframe animation, wherein the resource model configuration file is used by the game engine to add the 2D resources to be processed.

[0008] According to a third aspect of the embodiments of this application, a resource loading plugin is provided, the resource loading plugin being created based on a resource loading toolkit, including a resource vertex shader and a resource pixel shader; The resource vertex shader is configured to process the vertex data of the 2D resource to be processed; The resource pixel shader is configured to process the pixel-level image resources of the 2D resource to be processed.

[0009] According to a fourth aspect of the embodiments of this application, a computing device is provided, comprising: Memory and processor; The memory is used to store computer-executable instructions, and the processor implements the steps of the resource processing method when executing the computer-executable instructions.

[0010] According to a fifth aspect of the present application, a computer-readable storage medium is provided that stores computer-executable instructions that, when executed by a processor, implement the steps of the resource processing method.

[0011] According to a sixth aspect of the present application, a chip is provided that stores a computer program, which, when executed by the chip, implements the steps of the resource processing method.

[0012] According to a seventh aspect of the embodiments of this specification, a computer program product is provided, including a computer program / instructions that, when executed by a processor, implement the steps of the resource processing method described above.

[0013] The resource processing system provided in this application includes a resource creation tool, a resource editor, and a game engine. The resource creation tool is configured to create 2D resources to be processed. The resource editor is configured to receive the 2D resources to be processed, generate at least one keyframe animation based on the 2D resources, create a resource model configuration file based on each keyframe animation, and send the resource model configuration file to the game engine. The game engine is configured to add the 2D resources to be processed according to the resource loading plugin and the resource model configuration file.

[0014] This resource processing system enables data interaction between resource creation tools and the game engine, allowing for the seamless use of 2D resources created by these tools within the game engine editor. There's no need to worry about damaging the original structure of the 2D resources or losing any animation data; therefore, the content of all 2D resources is preserved and displayed. Technicians can directly apply these 2D resources within the game engine, significantly improving work efficiency and flexibility. Attached Figure Description

[0015] Figure 1 This is a schematic diagram of the structure of a resource processing system provided in one embodiment of this application; Figure 2 This is a schematic diagram of the processing flow of a resource processing system provided in an embodiment of this application; Figure 3 This is a flowchart of a resource processing method provided in one embodiment of this application; Figure 4 This is a schematic diagram of a resource loading plugin provided in one embodiment of this application; Figure 5 This is a structural block diagram of a computing device provided in one embodiment of this application. Detailed Implementation

[0016] Many specific details are set forth in the following description to provide a full understanding of this application. However, this application can be implemented in many other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of this application; therefore, this application is not limited to the specific embodiments disclosed below.

[0017] The terminology used in one or more embodiments of this application is for the purpose of describing particular embodiments only and is not intended to limit the scope of one or more embodiments of this application. The singular forms “a,” “the,” and “the” used in one or more embodiments of this application and the appended claims are also intended to include the plural forms unless the context clearly indicates otherwise. It should also be understood that the term “and / or” used in one or more embodiments of this application refers to and includes any or all possible combinations of one or more associated listed applications.

[0018] It should be understood that although the terms first, second, etc., may be used to describe various information in one or more embodiments of this application, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, first may also be referred to as second without departing from the scope of one or more embodiments of this application, and similarly, second may also be referred to as first.

[0019] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, data stored, data displayed, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties. Furthermore, the collection, use and processing of the relevant data must comply with the relevant laws, regulations and standards of the relevant regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.

[0020] First, the terminology used in one or more embodiments of the present invention will be explained.

[0021] Live2D Cubism: A drawing rendering technology and animation software designed to translate, rotate, and deform 2D images to achieve a three-dimensional representation and generate an object model with natural animation effects.

[0022] Cubism SDK for Native is a development kit for using Live2D Cubism models in applications. It is provided by Live2D Cubism and is used to embed Live2D Cubism-created models into various applications.

[0023] Cubism SDK for Native is a software development kit provided by Live2D Cubism for native application development. It allows developers to integrate Live2D 2D animation technology into native applications without relying on a specific game engine. This tool greatly expands the application scope of Live2D technology, enabling developers to seamlessly integrate Live2D animations across multiple operating systems. However, it does not natively support game engines. This means that developers need to perform certain technical adaptations and bridging work to use Live2D animations in game engines. This includes creating middleware to connect the Cubism SDK and the game engine's API, or developing specialized plugins to facilitate data and command exchange between the two.

[0024] The resource processing system provided in this application compensates for the lack of support for Live2D Cubism resources in game engines, allowing Live2D Cubism resources to be used directly in game engines without worrying about the game engine destroying the original structure of the resources or losing any animation data. This ensures that all Live2D Cubism resources are preserved and displayed. Simultaneously, developers can directly use 2D resources within the game engine's Blueprint system, greatly improving work efficiency and flexibility.

[0025] This application provides a resource processing system, and also relates to a resource processing method, apparatus, computing device, computer-readable storage medium, and computer program, which will be described in detail in the following embodiments.

[0026] See Figure 1 , Figure 1 A schematic diagram of the structure of a resource processing system provided in an embodiment of this application is shown, as follows: Figure 1 As shown, the resource processing system includes a resource creation tool 102, a resource editor 104, and a game engine 106.

[0027] The resource creation tool 102 is configured to create 2D resources to be processed; The resource editor 104 is configured to receive the 2D resource to be processed, generate at least one keyframe animation based on the 2D resource to be processed, create a resource model configuration file based on each keyframe animation, and send the resource model configuration file to the game engine. The game engine 106 is configured to add the 2D resources to be processed based on the resource loading plugin and the resource model configuration file.

[0028] Among them, resource creation tools can be understood as tools used to create and generate 2D resources to be processed, such as graphics software. Resource editors can be understood as Live2D Cubism Editors, which are used to generate corresponding dynamic 2D resources based on the 2D resources to be processed. In practical applications, game engine 106 can specifically refer to Unreal Engine (UE).

[0029] See Figure 2 , Figure 2 A schematic diagram of the processing flow of a resource processing system provided in an embodiment of this application is shown, as follows: Figure 2 As shown, the resource processing system provided in this application embodiment includes three parts: resource creation, resource editing, and game engine loading.

[0030] First, create or modify the original artwork in a resource creation tool (such as Photoshop). Specifically, break down the original artwork into different layers for easier subsequent processing. When there are updates to the layers, re-import them into the PSD file.

[0031] Next, these layers are divided into a grid in resource editor 104, and appropriate animation parameters are assigned to each grid region as needed. Keyframe animations are then created using these settings. A ModelJson file is configured to store all relevant information.

[0032] Finally, with the game engine being Unreal Engine, the generated resources are read using the Live2D plugin within Unreal Engine. These resources are then rendered in real-time. Ultimately, these rendered resources can be used to create dynamic effects within Unreal Engine.

[0033] In one specific embodiment provided in this application, the system further includes a resource loading toolkit; The game engine is also configured to create a resource loading plugin based on the resource loading toolkit. Embodiments of this application will be described using Unreal Engine as an example.

[0034] The method provided in this application embodiment includes a resource loading toolkit (Cubism SDK for Native) that enables developers to implement and run Live2D animations on various native platforms. Cubism SDK for Native is a software development kit provided by Live2D Cubism for native application development. It allows developers to integrate Live2D 2D animation technology into native applications, such as iOS, Android, or desktop platform applications, without relying on a specific game engine.

[0035] The resource loading toolkit expands the application scope of Live2D technology, allowing developers to seamlessly integrate Live2D animations across multiple operating systems. The Cubism SDK for Native provides a series of APIs and libraries that enable developers to directly call Live2D animations on native platforms, achieving efficient animation playback and interaction. These include APIs for model and resource loading, animation control, dynamic parameter adjustment, and user input response. These APIs allow developers to control animation performance more precisely, such as adjusting animation speed, responding to user input, and dynamically changing animation states.

[0036] However, the Cubism SDK for Native does not natively support Unreal Engine. This means that to use Live2D animations in Unreal Engine, developers need to create a method to achieve technical compatibility and bridging between the two. This application provides a resource processing system and resource loading plugin to enable data and command transfer between Unreal Engine and the resource loading toolkit, thereby making it possible to apply Live2D technology more widely to games and applications developed with Unreal Engine.

[0037] Based on this, in another specific embodiment provided by this application, the game engine is further configured to create an initial resource loading plugin, add the resource loading toolkit to the initial resource loading plugin, and modify the calling interface file of the initial resource loading plugin to generate the resource loading plugin.

[0038] In this implementation, a resource loading plugin was designed and developed to achieve seamless integration between Live2D Cubism and the game engine, facilitating compatibility between the two systems. Specifically, the plugin's main function is to establish a bidirectional communication bridge, encapsulating the Cubism SDK's native C++ interfaces into a UE-callable module, while also handling data format conversion and resource management. The overall architecture of the resource loading plugin consists of three layers: 1. Game engine layer, used to provide blueprint interfaces and rendering support for the game engine.

[0039] 2. The bridging plugin layer is used to encapsulate the functionality of the Cubism SDK and adapt it to the game engine.

[0040] 3. The native layer of the Cubism SDK is responsible for loading, animation control, and rendering of Live2D models.

[0041] Specifically, the technical staff edited the Cubism SDK library, integrated the C++ libraries of the Cubism SDK (such as CubismCore.lib) into the game engine project, and made the corresponding configurations in the Build.cs file of the resource loading plugin.

[0042] This application creates a compatible Cubism model class. Specifically, it defines a class UCubismModel that inherits from UObject to manage the loading and control of Live2D models. The technical solution of this application also encapsulates the animation control interface of CubismSDK and provides it to the game engine's blueprint, enabling the game engine to control and interact with animations. It also supports the game engine in adjusting the facial expressions and perspective parameters of Live2D models in real time through the blueprint.

[0043] Furthermore, the technical solution in this application will select the corresponding Cubism SDK library in the Build.cs file according to the target platform to be released, thus ensuring cross-platform compatibility. The resource loading plugin enables seamless adaptation between the game engine and Live2D Cubism, bridging the creation workflow between Live2D and the game engine.

[0044] The method provided in this application embodiment develops a corresponding resource loading plugin for game engines, which is used to load Live2D animations. The interface design of the resource loading plugin is a core element, ensuring not only comprehensive plugin functionality but also improved usability, seamlessly bridging the creation workflow between Live2D and Unreal Engine. This plugin specializes in efficiently importing and integrating Live2D assets, streamlining their rendering process in the game engine, and ensuring the same visual and performance experience as in the resource editor. The interface needs to be designed to smoothly handle various files (models, animations, textures, etc.) output from the resource editor, employing advanced data processing and rendering techniques to preserve all the detail of the models and the smoothness of the animations.

[0045] Resource loading plugins can be understood as tools used in game engine development to solve the problem of game engines not being able to smoothly use Live2D assets. In existing technologies, integrating Live2D assets into a game engine is a complex and time-consuming task, involving multiple conversion steps and potential compatibility issues. This not only increases development complexity but may also compromise the final quality and integrity of the assets. Resource loading plugins address the insufficient support for Live2D assets in game engines, allowing Live2D assets to be used directly within the game engine without worrying about damaging the asset's original structure or losing any animation data. By developing a customized resource loading plugin, this application enables the direct use of Live2D Cubism assets: First, a dedicated asset importer was created to automatically convert Live2D files such as .model3.json into UAsset resources recognizable by the game engine; second, the ULive2DComponent component was developed, encapsulating the core functionality of the Cubism SDK and providing a Blueprint interface; then, a real-time preview window and parameter editing panel were built, supporting direct debugging of model animations in the editor; finally, through a custom material system and rendering pipeline adaptation, the original animation effects and visual performance of Live2D models are ensured to be maintained in the game engine, allowing personnel without coding skills, such as artists, to drag and drop Live2D resources without writing code. This greatly improves work efficiency and flexibility.

[0046] The resource loading plugin in this application is built upon the game engine's global shader system, allowing for deep customization and adjustment of the graphics rendering process. Based on this, the resource loading plugin develops dedicated resource vertex shaders and resource pixel shaders to ensure high-quality rendering of Live2D resources, enabling 2D models to retain their unique artistic style while also exhibiting rich visual effects in a 3D environment.

[0047] In another specific embodiment provided in this application, the resource vertex shader is configured to process the vertex data of the 2D resource to be processed; The resource pixel shader is configured to process the pixel-level image resources of the 2D resource to be processed.

[0048] The resource vertex shader processes the vertex data of the Live2D model to achieve diverse deformations and dynamic effects, such as model twisting, bending, and stretching, which is crucial for achieving more natural animation effects. It primarily receives basic data from the Live2D model, including vertex coordinates, bone weights, and animation parameters (such as deformation amplitude and angle). By precisely calculating the position offset of each vertex and combining it with the weight distribution of the skeletal animation, it adjusts the vertex position in 3D space in real time, enabling the 2D model to simulate 3D-like stereoscopic dynamic effects, ensuring the smoothness and naturalness of the animation. By precisely manipulating the position of each vertex, the model can exhibit more complex and delicate movements in the animation, such as subtle changes in facial expressions or the flowing dynamics of clothing.

[0049] Resource pixel shaders focus on pixel-level image processing, enabling developers to add advanced lighting, shadow casting, and environmental interactions to Live2D models. This refined processing enhances the model's visual depth, three-dimensionality, and realism. They receive vertex coordinates, texture information, lighting parameters (such as light source direction and intensity), and environmental reflection data after processing by the vertex shader. Color calculations are performed on each pixel, and the pixel color is adjusted using lighting and shadow algorithms to simulate real-world light and shadow interactions (such as dynamic lighting and environmental reflections). This ensures consistency in the model's visual effects under different lighting conditions, enhancing the visual impact and ultimately improving the model's realism and visual appeal.

[0050] In one specific embodiment provided in this application, taking subtle changes in facial expressions (such as blinking, raising the corners of the mouth, etc.) as an example, the processing flow of vertex data is as follows: In the Live2D Cubism Editor, facial models are split into multiple independent layers (such as eyes, eyebrows, and mouth), each containing a large amount of vertex coordinate data. These vertices are pre-bound to facial expression control parameters (such as "blink amplitude" and "corner of the mouth upturn angle") to form a relationship.

[0051] For example, vertices in the eye region are bound to the "blink" parameter, and vertices in the mouth region are bound to the "smile" parameter. Each vertex is assigned a corresponding weight based on its influence on the expression change, that is, the proportion of the vertex affected by the parameter change.

[0052] When facial expression changes are triggered (such as a character smiling due to player interaction), Unreal Engine passes the corresponding expression parameters (such as "corner of the mouth upturn angle = 30°") to the vertex shader through the plugin's animation control interface.

[0053] After receiving this parameter, the vertex shader combines it with preset vertex weight data to calculate the target position offset for each vertex. For example, the vertices around the mouth determine the distance they need to move upwards or to the sides based on the intensity of the "smile" parameter and their own weights.

[0054] Real-time adjustment of vertex positions: The vertex shader adjusts the original coordinates of each vertex in real time based on the calculated offset. For the vertices in the corner of the mouth area, the vertices with higher weights will move upward along the Y-axis (vertical direction) and stretch to both sides along the X-axis (horizontal direction) to simulate the shape of the corners of the mouth turning up.

[0055] For the apex of the cheek area, the apex with lower weight will be accompanied by a slight displacement, presenting a natural facial muscle stretching effect and avoiding a stiff expression.

[0056] This adjustment is achieved through mathematical operations (such as linear interpolation and matrix transformation) to ensure the smoothness of vertex movement, thus presenting the gradual process from a slight grin to a full smile when "smiling".

[0057] 4. Collaboration with other systems The adjusted vertex data is passed to the pixel shader, and combined with lighting, shadow and other effects, the visual performance is further optimized. For example, when the corners of the mouth are turned up, the shadows on the facial wrinkles are updated in real time as the vertex position changes.

[0058] Meanwhile, the plugin continuously monitors vertex position changes through a dynamic parameter adjustment interface to ensure the continuity of facial expression animation. For example, when switching from "smiling" to "surprised", the vertex will gradually adjust its position according to the new parameters to avoid frame skipping.

[0059] Through the above process, vertex data is precisely manipulated, allowing subtle changes in facial expressions to be presented through the orderly displacement of vertices, ultimately achieving a natural and delicate animation effect.

[0060] Based on this, and by combining the simple low-level access and control functions of the Cubism Native SDK (a software development kit provided by Live2D for native platforms such as Windows, macOS, iOS, and Android), the resource loading plugin in this application's technical solution can perform more refined animation processing, thereby bringing users a smoother and more delicate visual experience. Furthermore, the resource loading plugin can be used to directly import Live2D assets into the game engine for use.

[0061] In its implementation, the resource loading plugin includes the following interfaces: Animation Control Interface: A comprehensive set of functions empowers developers with precise control over Live2D model animations, including play, pause, resume, and terminate, adapting to diverse game scene logic. Animation commands are encapsulated using the command pattern, providing atomic operations such as PlayAnimation() / PauseAnimation(). Precise control is achieved at the underlying level through the Cubism SDK's StartMotion() and StopAllMotions() methods. Animation Blending Support: Allows smooth transitions between two actions (e.g., from walking to running); Priority Management: Handles animation conflicts via the EPriority enumeration (e.g., injury actions interrupting idle actions); Timeline Control: Provides SetAnimationProgress(0.5f) for precise jumps in animation progress.

[0062] Dynamic parameter adjustment interface: Allows real-time adjustment of model parameters, such as facial expression changes and viewpoint control, enhancing the dynamism and interactive feedback of animations, making characters vividly respond to in-game events. A parameter mapping table is established to expose Live2D parameters such as "Param_AngleX" as editable Blueprint variables, enabling automatic parameter binding. / / Automatically synchronize UE properties to Live2D parameters void UpdateParameters() { for(auto&Param :ParameterMap) { CubismModel->SetParameterValue(Param.Key, Param.Value);}}.

[0063] Event Binding Interface: Enables model actions or state changes to be bound to game events, such as character interactions or state changes, facilitating the creation of rich and complex interactive storylines. The Event Binding Interface uses the observer pattern to implement multi-path event distribution. Key event types include: animation events (OnAnimationBegin / OnAnimationEnd), interaction events (OnHitTest / OnDrag), and state events (OnParameterChanged).

[0064] Real-time resource update interface: Supports a hot update mechanism for Live2D resources, allowing new models or textures to be applied without restarting the game. This is particularly suitable for application scenarios with frequent content iterations, such as serialized games or applications. Specifically, the hot reloading process is as follows: 1. The file monitoring thread detects changes to the resource directory; 2. Asynchronously load new resources into the temporary memory area; 3. A secure switching mechanism ensures smooth rendering without any stuttering; 4. Version rollback support (retains resources from the previous version); In addition, Unreal Engine's AsyncLoading system can be used to achieve smooth loading, memory management uses reference counting to ensure the safe release of resources, and differential updates, which means only reloading changed texture or motion data.

[0065] Multi-model management interface: Enhances collaborative work among multiple Live2D models in a single scene, supports hierarchical structure settings and interactions between models, facilitating multi-character scenes without performance loss. Scene management solution: Hierarchy system: Establishes parent-child model relationships (e.g., character + pet); Spatial partitioning: Attachment point management based on usceneComponent. Batch processing optimization: Merges rendering calls with the same material; LOD system adjusts model precision based on distance.

[0066] Intuitive user interface: Establishes a direct connection between the model and user input. Whether it is touch or mouse operation, it can affect the model's behavior in real time, deepening the player's immersion and participation.

[0067] Through these comprehensive interface designs, the resource processing system and resource loading plugin of this application not only simplify the integration work for developers, but also greatly expand the possibilities for creating dynamic 2D content in Unreal Engine, pushing the visual performance and user experience of games and applications to new heights.

[0068] In one specific embodiment provided in this application, the resource processing system selects Spine, Adobe Animate, and Live2D Cubism as key technical supports.

[0069] Spine utilizes its advanced skeletal animation system to design and create dynamic limb movements and complex motion scenes. Spine's 3D-style 2D animation creation method not only enhances the naturalness and realism of animations but also seamlessly integrates with Unreal Engine. Through the official Spine Runtime plugin (a cross-platform runtime library provided by Spine), it ensures rapid import and efficient rendering of animation data, providing a solid foundation for games that pursue physical interaction and motion details.

[0070] Adobe Animate: For compatibility with traditional frame-based animation and Flash games, Adobe Animate is the top choice due to its powerful authoring toolset and wide range of industry applications. It not only supports rich creative expression but also allows technical staff familiar with the Adobe ecosystem to quickly get started, accelerating the content production process.

[0071] Live2D Cubism: This application specifically highlights Live2D's ability to enhance character expressiveness. Through its innovative 2D-to-3D conversion technology, it preserves the original hand-drawn art style while endowing characters with subtle facial expressions and natural body language, greatly enhancing the immersive experience of visual novels and character-driven games.

[0072] In another specific implementation provided in this application, visual debugging within the game engine can also be achieved. This solution enables seamless conversion of Live2D assets into Actors and UMG objects (Unreal Motion Graphics UI Designer, the user interface manager in the game engine) in the game engine editor. Users can directly create Cubism Object classes and easily render Live2D characters using RenderTarget technology, then flexibly place them in game scenes or integrate them into UI designs. This innovative feature significantly expands the application boundaries of Live2D assets, allowing these exquisite 2D animations to break free from the limitations of static display and be freely arranged and interacted with in the game world like 3D objects.

[0073] Developers can now seamlessly integrate these 2D animations into 3D space, enabling dynamic interactions with other elements in the scene, thereby creating more vivid and realistic interface elements and immersive interactive experiences. Imagine a UI where character expressions and movements are entirely driven by Live2D animations, responding in real-time to player actions and in-game events; this would undoubtedly add immense visual appeal to the game and deepen the player's emotional experience.

[0074] Furthermore, thanks to the powerful features of UMG, these Live2D animations can be transformed into interactive UI components, such as dynamic buttons and scrollbars, providing more intuitive and dynamic visual feedback for user interaction and enriching the gaming experience.

[0075] Furthermore, integrating Live2D animations into Actor objects within the game not only endows these 2D assets with a sense of space and physical properties similar to 3D models, but also provides developers with a completely new means of creation and debugging. Now, developers can easily set physical boundaries for these 2D animations, enabling them to respond to collision events, or, through precise script control, achieve movement, rotation, and diverse interactions with other objects within the game world. This innovation greatly enhances the usability and interactivity of 2D elements in 3D game environments, injecting more innovative vitality into game design.

[0076] By deeply integrating the game engine with the Live2D Cubism Editor, developers can create entirely new interaction modes. For example, specific Live2D animations can be triggered by touchscreen or mouse clicks, making the user interface of games or applications more intuitive and engaging. When a user gently touches a character on the touchscreen, the character immediately performs a series of preset, lively actions, such as waving, blinking, or other rich facial expressions. This highly interactive interface design not only enhances the user experience's friendliness and fun but also significantly strengthens the user's immersion and connection to the game world.

[0077] From a technical perspective, the Live2D Cubism Editor provides developers with powerful tools for creating high-quality 2D animations. Through our specially developed resource loading plugin, these exquisite animations can be seamlessly imported into the game engine, fully preserving all the unique styles and effects of the original animations. Within the game engine's Blueprint system, developers can easily write logic code, handle various input events, and precisely trigger corresponding Live2D animations, thereby achieving rich and varied visual presentations and interactive experiences in the game world.

[0078] Figure 3 The flowchart of a resource processing method according to an embodiment of this application is shown, specifically including the following steps: Step 302: Receive the 2D resources to be processed.

[0079] Step 304: Generate at least one keyframe animation based on the 2D resource to be processed.

[0080] Step 306: Create a resource model configuration file based on each keyframe animation, wherein the resource model configuration file is used by the game engine to add the 2D resources to be processed.

[0081] Figure 4 A schematic diagram of a resource loading plugin provided in an embodiment of this application is shown, such as... Figure 4 As shown, this resource loading plugin is created based on the resource loading toolkit and includes a resource vertex shader 402 and a resource pixel shader 404. The resource vertex shader 402 is configured to process the vertex data of the 2D resource to be processed; The resource pixel shader 404 is configured to process the pixel-level image resources of the 2D resource to be processed.

[0082] Figure 5 A structural block diagram of a computing device 500 according to an embodiment of this application is shown. The components of the computing device 500 include, but are not limited to, a memory 510 and a processor 520. The processor 520 is connected to the memory 510 via a bus 530, and a database 550 is used to store data.

[0083] The computing device 500 also includes an access device 540, which enables the computing device 500 to communicate via one or more networks 560. Examples of these networks include Public Switched Telephone Network (PSTN), Local Area Network (LAN), Wide Area Network (WAN), Personal Area Network (PAN), or combinations of communication networks such as the Internet. The access device 540 may include one or more of any type of wired or wireless network interface (e.g., a network interface card (NIC)), such as an IEEE 802.11 Wireless Local Area Network (WLAN) wireless interface, a Wi-MAX (Worldwide Interoperability for Microwave Access) interface, an Ethernet interface, a Universal Serial Bus (USB) interface, a cellular network interface, a Bluetooth interface, a Near Field Communication (NFC) interface, and so on.

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

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

[0086] The processor 520 is used to execute computer-executable instructions of the resource processing method.

[0087] The above is an illustrative scheme of a computing device according to this embodiment. It should be noted that the technical solution of this computing device and the technical solution of the resource processing method described above belong to the same concept. For details not described in detail in the technical solution of the computing device, please refer to the description of the technical solution of the resource processing method described above.

[0088] An embodiment of this application also provides a computer-readable storage medium storing computer instructions that, when executed by a processor, are used for a resource processing method.

[0089] The above is an illustrative scheme of a computer-readable storage medium according to this embodiment. It should be noted that the technical solution of this storage medium and the technical solution of the resource processing method described above belong to the same concept. For details not described in detail in the technical solution of the storage medium, please refer to the description of the technical solution of the resource processing method described above.

[0090] One embodiment of this application also provides a chip that stores a computer program, which, when executed by the chip, implements the steps of the resource processing method.

[0091] An embodiment of this specification also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the resource processing method described above.

[0092] The above is an illustrative scheme of a computer program product according to this embodiment. It should be noted that the technical solution of this computer program product and the technical solution of the resource processing method described above belong to the same concept. For details not described in detail in the technical solution of the computer program product, please refer to the description of the technical solution of the resource processing method described above.

[0093] The foregoing has described specific embodiments of this application. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired results. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0094] The computer instructions include computer program code, which may be in the form of source code, object code, executable file, or certain intermediate forms. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording media, USB flash drive, portable hard drive, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium may be appropriately added or removed according to the requirements of patent practice. For example, in some regions, according to patent practice, computer-readable media may not include electrical carrier signals and telecommunication signals.

[0095] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this application is not limited to the described order of actions, as some steps may be performed in other orders or simultaneously according to this application. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are preferred embodiments, and the actions and modules involved are not necessarily essential to this application.

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

[0097] The preferred embodiments disclosed above are merely illustrative of this application. The optional embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the content of this application. These embodiments are selected and specifically described in this application to better explain the principles and practical applications of this application, thereby enabling those skilled in the art to better understand and utilize this application. This application is limited only by the claims and their full scope and equivalents.

Claims

1. A resource processing system, characterized in that, The system includes resource creation tools, a resource editor, and a game engine; among which... The resource creation tool is configured to create 2D resources to be processed; The resource editor is configured to receive the 2D resource to be processed, generate at least one keyframe animation based on the 2D resource to be processed, create a resource model configuration file based on each keyframe animation, and send the resource model configuration file to the game engine. The game engine is configured to add the 2D resources to be processed based on the resource loading plugin and the resource model configuration file.

2. The resource processing system as described in claim 1, characterized in that, The system also includes a resource loading toolkit; The game engine is also configured to create a resource loading plugin based on the resource loading toolkit.

3. The resource processing system as described in claim 2, characterized in that, The game engine is further configured to create an initial resource loading plugin, add the resource loading toolkit to the initial resource loading plugin, and modify the call interface file of the initial resource loading plugin to generate the resource loading plugin.

4. The resource processing system as described in claim 2, characterized in that, The resource loading plugin includes a resource vertex shader and a resource pixel shader.

5. The resource processing system as described in claim 4, characterized in that, The resource vertex shader is configured to process the vertex data of the 2D resource to be processed; The resource pixel shader is configured to process the pixel-level image resources of the 2D resource to be processed.

6. A resource processing method, characterized in that, include: Receive 2D resources to be processed; Generate at least one keyframe animation based on the 2D resource to be processed; A resource model configuration file is created based on each keyframe animation, wherein the resource model configuration file is used by the game engine to add the 2D resources to be processed.

7. A resource loading plugin, characterized in that, The resource loading plugin is created based on the resource loading toolkit and includes resource vertex shaders and resource pixel shaders; The resource vertex shader is configured to process the vertex data of the 2D resource to be processed; The resource pixel shader is configured to process the pixel-level image resources of the 2D resource to be processed.

8. A computing device, characterized in that, include: Memory and processor; The memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to implement the steps of the method of claim 6.

9. A computer-readable storage medium storing computer instructions, characterized in that, When executed by the processor, this instruction implements the steps of the method of claim 6.

10. A computer program product comprising a computer program / instructions, characterized in that, When the computer program / instructions are executed by the processor, they implement the steps of the method of claim 6.

Images