Method, device and equipment for editing virtual resources of a meta-universe live room and medium

Abstract

The application relates to the field of network live broadcast, and provides a virtual resource editing method and device of a meta universe live broadcast room, an electronic device and a computer readable storage medium; the method comprises the following steps: initializing a configuration file according to a resource file of a 3D model uploaded by a user; creating a model instance of the 3D model on an editor and editing the attributes of the 3D model on the configuration file; associating the 3D model with a personalized script selected by the user and debugging according to the personalized script; finally, saving the resource file of the 3D model, the configuration file and the associated personalized script as a 3D model file and uploading the 3D model file to an editor server for loading and use. According to the technical scheme, an editor with 3D animation special effects can be provided for an editor, the editor is applied to a 3D animation editing scene, the 3D effect of virtual resource played by a client is improved, the interactivity between the virtual resource played by the client and the user is enhanced, and the viewing retention rate and viewing time of the user are improved.

Description

Technical Field

[0001] This application relates to the field of live streaming technology, and in particular to a method, apparatus, electronic device, and computer-readable storage medium for editing virtual resources in a metaverse live streaming room. Background Technology

[0002] With the development of metaverse technology, it is being used more and more in the field of live streaming. Virtual live streaming spaces built on metaverse can display various virtual resources, allowing streamers and viewers to have more immersive live streaming interactions.

[0003] Currently, virtual animation effects are widely used in the live streaming industry for things like gifting virtual items, entrance shows, and virtual avatars. However, the mainstream virtual resource editors are based on game engines. They use virtual object models created on the game creation interface and set rotation operations to control the virtual object models to rotate. These virtual effect models can generally only be played in 2D on the client using MP4 players, SVGA players, etc., and the angle can only be switched by controlling the rotation operation. They cannot effectively interact with the user, resulting in insufficient overall playback effect and interactivity.

[0004] However, the 2D animation effects created by conventional editors have a weak sense of depth when played on the client and lack interactivity with users. With the continuous development of live streaming technology, they cannot provide the higher 3D effects and interactive requirements of the metaverse scene and are difficult to adapt to the development of metaverse live streaming technology. Summary of the Invention

[0005] Therefore, it is necessary to address one of the aforementioned technical problems by providing a method, apparatus, electronic device, and computer-readable storage medium for editing virtual resources in a metaverse live streaming room, thereby improving the 3D effect of the edited virtual resources and their interactivity during playback.

[0006] Firstly, this application provides a method for editing virtual resources in a metaverse live streaming room, including:

[0007] Obtain the resource file of the 3D model of the Metaverse live room uploaded through the editor page, and generate an initial configuration file based on the attribute information of the 3D model;

[0008] Using the resource files of the 3D model, a corresponding model instance is created in the editor. In response to the input model instance configuration operation, the attributes of the 3D model instance are configured and updated to the configuration file.

[0009] In response to the script selection operation, the corresponding personalized script is downloaded from the plugin scripts pre-stored in the editor server, the personalized script is associated with the 3D model, and the model instance of the associated 3D model is debugged according to the personalized script in the scene of the metaverse live broadcast room.

[0010] After successful debugging, the resource files, configuration files, and associated personalized scripts of the 3D model are saved as 3D model files using the editor and uploaded to the editor server for loading and use.

[0011] In one embodiment, generating the initial configuration file based on the attribute information of the 3D model includes:

[0012] In response to a resource file uploaded by a user on the editor page, a project is initialized on the editor to hold the resource file; wherein, the resource file includes model files and particle files;

[0013] Copy the resource files to the project, and initiate a build process in the project to generate and save the 3D model package file;

[0014] The packaged file of the 3D model is analyzed and resource attribute parameters are extracted. An initial configuration file is then generated based on the resource attribute parameters.

[0015] In one embodiment, a corresponding model instance is created in an editor using the resource file of the 3D model. In response to an input model instance configuration operation, the attributes of the 3D model instance are configured and updated in the configuration file, including:

[0016] Find the target resource in the list of imported resource files in the editor;

[0017] In response to the user's instruction to create a model instance, a corresponding model instance is created on the editor page based on the target resource;

[0018] In response to user input of configuration operations for model instances of the 3D model, the attribute configuration of the model instances of the 3D model is edited, and the edited attribute configuration information is updated to the configuration file;

[0019] Render the 3D model on the editor page.

[0020] In one embodiment, the personalized script is associated with the 3D model, and the model instance of the associated 3D model is debugged according to the personalized script in the scene of the Metaverse live broadcast room, including:

[0021] Obtain the personalized script selected by the user in the editor; wherein the personalized script is pre-written and its data interface and the data returned by the interface are defined, and the personalized script is used to control the rendering process of the 3D model.

[0022] The personalized script is attached to the model instance of the 3D model;

[0023] In the context of the Metaverse live streaming room, the personalized script is launched to debug the data interface and obtain the returned data;

[0024] The 3D model and the personalized script are associated based on the debugging results and added to the project.

[0025] In one embodiment, retrieving the personalized script selected by the user in the editor includes:

[0026] Add pre-written personalized scripts to the editor;

[0027] Set a script button on the editor page, wherein the script button is configured to invoke the corresponding personalized script in response to a click event;

[0028] Get the script button clicked by the user and select the corresponding personalized script.

[0029] In one embodiment, the data interface is the anchor face data interface;

[0030] In the context of the Metaverse live stream, the personalized script is launched to debug the data interface and obtain the returned data, including:

[0031] Simulate the scene of a metaverse live streaming room in the editor, and simulate the anchor's facial data based on a unified data structure;

[0032] The system retrieves the 3D model selected by the user through the editor, debugs the anchor's face data interface according to the personalized script, and returns the anchor's face position.

[0033] The 3D model is controlled to move in accordance with the position of the anchor's face.

[0034] In one embodiment, the data interface is a location coordinate interface for the voice room operator;

[0035] In the context of the Metaverse live stream, the personalized script is launched to debug the data interface and obtain the returned data, including:

[0036] Simulate the scene of the metaverse live broadcast room in the editor, and simulate the interface data of each seat in the voice room in this scene;

[0037] The user selects an animation model through the editor and debugs the position coordinate interface according to the personalized script, returning the position coordinate data of the voice room agent;

[0038] Control the animation model to move to the position coordinates corresponding to the voice room operator.

[0039] In one embodiment, the personalized script further includes a pre-written general script; wherein the general script includes a touch rotation model script, a touch rotation lens script, or a touch vibration script;

[0040] The method further includes:

[0041] Add the general script to the list of personalized scripts;

[0042] Get the user-selected general script and record in the editor that the current 3D model has started the function of rotating the model;

[0043] Package the selected generic script into the project and record the relationship between the 3D model and the generic script in the configuration file.

[0044] In one embodiment, the configuration file of the 3D model and the associated personalized scripts are saved as a 3D model file for loading and editing, including:

[0045] In response to the user's confirmation and save operation, the resource files, configuration files, and associated personalized scripts of the 3D model are saved in a repository address of the editor, and the current model repository address is recorded.

[0046] The next time the user opens the editor, the resource files, configuration files, and associated personalized scripts of the saved 3D model are loaded according to the model repository address and then restored and loaded onto the editor.

[0047] Secondly, this application provides an editing device for virtual resources in a metaverse live streaming room, comprising:

[0048] The initialization module is used to obtain the resource files of the 3D model of the Metaverse live room uploaded through the editor page, and generate an initial configuration file based on the attribute information of the 3D model.

[0049] The attribute configuration module is used to create corresponding model instances in the editor using the resource files of the 3D model, and in response to the input model instance configuration operation, configure the attributes of the model instance of the 3D model and update the configuration file.

[0050] The script editing module is used to download the corresponding personalized script from the plugin scripts pre-stored in the editor server in response to the script selection operation, associate the personalized script with the 3D model, and debug the model instance of the associated 3D model according to the personalized script in the scene of the metaverse live broadcast room.

[0051] The model saving module is used to save the resource files, configuration files, and associated personalized scripts of the 3D model as a 3D model file through the editor after debugging, and upload it to the editor server for loading and use.

[0052] Thirdly, this application provides an electronic device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the method for editing virtual resources in the metaverse live streaming room.

[0053] Fourthly, this application provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of an editing method for virtual resources in the metaverse live streaming room.

[0054] The aforementioned method, apparatus, electronic device, and computer-readable storage medium for editing virtual resources in the Metaverse live streaming room first initializes a configuration file based on the resource file of the 3D model uploaded by the user, generating a configuration file. Then, using the 3D model's resource file, a model instance of the 3D model is created in the editor, and the attributes of the 3D model are edited in the configuration file according to the attribute data input by the user. Simultaneously, based on a pre-written personalized script selected by the user, the 3D model and the personalized script are associated and debugged within the Metaverse live streaming room scene. Finally, the debugged 3D model configuration file and the associated personalized script are saved as a 3D model file and uploaded to the editor server for loading and use. This technical solution provides editors with an editor featuring 3D animation effects, applicable to 3D animation editing scenarios within the Metaverse live streaming room, enhancing the 3D effect of virtual resources played on the client, increasing interactivity between the virtual resources and the user, and improving user retention and viewing time.

[0055] Furthermore, the uploaded 3D resources allow for the editing of model and particle combination effects, enriching the 3D editing animation interface, optimizing the 3D effects of virtual gifts played on the Metaverse live streaming client, improving the sense of layering, space, and three-dimensionality of the image, enriching the styles of virtual gifts, entrance shows, and virtual avatars in Metaverse live streaming, which can incentivize users to give gifts, display entrance shows and virtual avatars, promote interaction between the streamer and the audience, and increase the activity level of the live streaming room.

[0056] Furthermore, the addition of personalized scripts provides interactive control functionality for the interaction between users and virtual resource models. When playing virtual resources, users can interact with the models in real time, realizing the real-time dynamic interactive function of the Metaverse live streaming room. Especially when applied to VR devices, it can provide an immersive 3D playback effect. Attached Figure Description

[0057] Figure 1 This is a block diagram of an example metaverse live streaming system.

[0058] Figure 2 This is a flowchart illustrating a method for editing virtual resources in a metaverse live streaming room, as exemplified by one of the embodiments.

[0059] Figure 3 This is an example initialization flowchart;

[0060] Figure 4 This is a sample editor page illustration;

[0061] Figure 5 This is a flowchart of the creation phase as an example;

[0062] Figure 6 This is a flowchart of the personalized script processing stage as an example;

[0063] Figure 7 This is a sample diagram illustrating the binding of a click event;

[0064] Figure 8 This is a sample diagram illustrating the restoration of an editor;

[0065] Figure 9 This is a sample overall page layout diagram of an editor;

[0066] Figure 10 This is a sequence diagram of the overall editing scheme for virtual resources in a sample metaverse live stream room;

[0067] Figure 11 This is a sample illustration of an entrance show effect;

[0068] Figure 12 This is a schematic diagram of the structure of a virtual resource editing device in a metaverse live streaming room according to one embodiment;

[0069] Figure 13 This is a diagram of the internal structure of an example electronic device. Detailed Implementation

[0070] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0071] like Figure 1 As shown, Figure 1 This is a sample structural diagram of a metaverse live streaming system. The live stream consists of a broadcaster and multiple viewer terminals (e.g., viewer 1, viewer 2, ...). The broadcaster and viewer terminals can communicate with a server via the internet. The server provides live streaming services to both the broadcaster and viewer terminals. The terminals can be, but are not limited to, smartphones, tablets, and head-mounted virtual reality devices. The server can be a standalone server or a server cluster.

[0072] In the metaverse live streaming scenario, the server can create an independent metaverse scene for the live streamer and viewers, building a virtual space that runs parallel to the real world. By using technological means to link and create a virtual world that maps and interacts with the real world, various three-dimensional virtual images such as people and animals can be displayed in this virtual space. The streamer and viewers can freely interact with the three-dimensional virtual images in this virtual space. For example, in the metaverse scenario, when users wear VR devices, their eyes will see three-dimensional visual content and obtain more and richer stereoscopic interaction and 3D special effects rendering effects.

[0073] Users in the live stream can interact with the computer using terminals such as mobile phones or head-mounted virtual reality devices (VR devices) to perform basic control operations, such as gesture-based movement and exiting. The terminal can receive and display data sent by the server, such as live video streams and virtual gifts, providing information for the metaverse scene and offering metaverse information to users. In live stream scenarios that include, but are not limited to, metaverse scenarios, based on the virtual resource editing method for the metaverse live stream provided in this application, the terminal can play 3D models in the virtual reality live stream room using a head-mounted virtual reality device. Viewers can send virtual gift requests through their head-mounted virtual reality devices, and the terminal can play the 3D model of the virtual effect in the virtual reality live stream room.

[0074] The technical solution of this application, in the metaverse playback scenario, utilizes an editor to achieve personalized script editing and association of 3D virtual effects. When it is necessary to play 3D models with specific requirements on the client, editors can use the editing solution of virtual resources in the metaverse live streaming room provided in this application to edit 3D virtual effects with stronger 3D playback effects and interactivity on the editor. Thus, during playback, the host or viewer can control the playback status of the 3D model by inputting touch actions through touch devices and sensors (such as controllers for wearable devices, sensors for VR devices), making the playback more vivid. It is particularly suitable for head-mounted virtual reality devices, such as VR devices. When users wear VR devices, they can see a completely 3D spatial vision and can combine the controllers, sensors, cameras, etc. of wearable devices for touch control to obtain richer interaction and 3D effect rendering effects, enriching the presentation style and playback form of virtual effects in metaverse live streaming, and promoting the interaction between hosts and viewers in metaverse live streaming.

[0075] For ease of description of the embodiments, the following will use the Cocos game engine as an example for auxiliary description, such as... Figure 2 As shown, Figure 2 This is a flowchart of a method for editing virtual resources in a metaverse live streaming room, which may include the following steps:

[0076] Step S10: Obtain the resource file of the 3D model of the Metaverse live room uploaded through the editor page, and generate an initial configuration file based on the attribute information of the 3D model.

[0077] In this step, users can upload resource files of 3D models, such as virtual models, virtual effects, and 3D animations, from the locally edited Metaverse live stream to the editor, initialize a project, and save the project's model resources and configuration files to the editor server.

[0078] In one embodiment, the resource file may include model files and particle files, etc.; the initialization process of step S10 is referred to... Figure 3 As shown, Figure 3 This is an example initialization flowchart, which may include the following steps:

[0079] S101, in response to the resource file uploaded by the user on the editor page, initialize a project on the editor to hold the resource file.

[0080] Specifically, the resource files include model files and particle files. Users can upload the resource files corresponding to the 3D models of the Metaverse live stream through the editor page, and initialize a project in the editor to host these resource files.

[0081] For example, refer to Figure 4 As shown, Figure 4 This is a sample editor page illustration; in the editor based on the Cocos game engine, you can upload the resource files of the edited 3D model of the Metaverse live room locally, such as FBX model files or Cocos particle files; after receiving the uploaded files, the editor server initializes a Cocos project to host the model files or particle files, and copies the resource files to the created Cocos project directory.

[0082] S102, copy the resource file to the project, and generate and save the 3D model package file by initiating the build process in the project process.

[0083] Specifically, the editor server initiates the process of building the project in the Cocos process, and generates a Cocos package file after the project is built, which is then stored in the editor server.

[0084] S103, Analyze the packaged file of the 3D model and extract resource attribute parameters, and generate an initial configuration file based on the resource attribute parameters.

[0085] Specifically, the editor server performs structural analysis on the Cocos package file of the 3D model, extracts the required FBX model or Cocos particles and their attribute parameters, including the position, rotation angle and other attribute parameters of the FBX model or Cocos particles, and initializes a default configuration file, thereby completing the creation phase of the Cocos project.

[0086] The steps in the above embodiments complete the uploading of resource files for the 3D model in the Metaverse live streaming room and the creation of the project. As a result, users can import the required models or particles into the editor according to their needs. This allows them to edit the combination effects of models and particles. In particular, when applied to gift interactions in the Metaverse live streaming room, it can optimize the 3D effects of client-side gift effects.

[0087] Step S20: Using the resource file of the 3D model, create a corresponding model instance in the editor. In response to the input model instance configuration operation, configure the attributes of the model instance of the 3D model and update it to the configuration file.

[0088] In this step, after the initialization phase, a 3D model instance is created in the editor using the 3D model's resource files. Then, in the editor, the user can configure the properties of the model instance. The editor can edit the 3D model based on the user's property configuration of the 3D model instance, and finally save the updated property parameters in the configuration file.

[0089] In one embodiment, the project creation process in step S20 is referenced. Figure 5 As shown, Figure 5 This is an example flowchart of the creation phase, which may include the following steps:

[0090] S201: Locate the target resource in the list of imported resource files in the editor.

[0091] Specifically, after the initialization phase, the uploaded virtual model resources and particles will be added to the resource list, through which users can search and select the models or particles they need.

[0092] For example, after a project is created, the corresponding model or particle can be found in the editor list, such as... Figure 4 As shown in the image, dragon is the model and fire2 is the particle, corresponding to a fire-breathing "flying dragon".

[0093] S202, in response to the user's instruction to create a model instance, create a corresponding model instance on the editor page according to the target resource.

[0094] Specifically, users can enter commands to create model instances in the editor. The editor receives these commands and initializes a model or particle instance, thus enabling the construction of an initialized 3D model within the editor. For example... Figure 4 The dashed box indicates that a model instance is created by clicking the "Create Model Instance" button on the editor page. A "flying dragon" model is initialized in the editor, and "fire2" is clicked to create a "fire-breathing" particle. The initial coordinates of the "flying dragon" model and the "fire-breathing" particle can be set to (0, 0, 0). The effect is as follows. Figure 3 As shown on the left.

[0095] S203, in response to the user's input configuration operation for the model instance of the 3D model, the attribute configuration of the model instance of the 3D model is edited, and the edited attribute configuration information is updated to the configuration file.

[0096] Edit the properties of the 3D model on the configuration file.

[0097] Specifically, users can edit the attribute configuration of 3D model instances. The editor configures the model or particle's position, angle, scaling, and other attribute parameters based on the user's input of the configuration operations for the 3D model instance, and then updates and saves the edited configuration information to the configuration file. For example... Figure 4 Within the dashed box, you can edit the position, angle, scale, and other attributes of the "Flying Dragon" model and "Fire-Breathing" particles by clicking the "Edit Attributes" button.

[0098] S204, Render the 3D model on the editor page.

[0099] Specifically, the created models or particles are displayed at specified locations on the editor page. As shown in the image, the "flying dragon" model and "fire-breathing" particles are placed in an appropriate position on the editor page and displayed at a set size.

[0100] As described in the above embodiments, the editor can define objects with editor properties, including animation sequence properties, model properties, particle properties, etc. of 3D models. These properties can be changed in the corresponding configuration files and saved to the entire project.

[0101] Step S30: In response to the script selection operation, download the corresponding personalized script from the plugin scripts pre-stored in the editor server, associate the personalized script with the 3D model, and debug the model instance of the associated 3D model according to the personalized script in the scene of the Metaverse live broadcast room.

[0102] In this step, users can associate personalized scripts with 3D models through the editor, thereby enabling script control over the 3D models. For example, developers can first write personalized plugin scripts to control the playback of the 3D model on the client side. These personalized scripts are then pre-attached to the editor via the editor server. When editing virtual 3D model resources, users can select the corresponding personalized script on the editor page, associate it with the selected 3D model, and then begin debugging. Typically, after successful debugging, the association is confirmed, thus attaching the personalized script to the 3D model and enabling script control over its playback.

[0103] In one embodiment, the personalized script processing in step S30 refers to... Figure 6 As shown, Figure 6 This is an example flowchart of the personalized script processing stages, which may include the following steps:

[0104] S301, Obtain the personalized script selected by the user in the editor; wherein, the personalized script is pre-written and its data interface and the data returned by the interface are defined, and the personalized script is used to control the rendering process of the 3D model.

[0105] Here, personalized scripts are pre-written by developers and attached to the editor. These personalized scripts can control the rendering process of the 3D model when the client plays the 3D model. Developers define personalized data interfaces and simulate the data returned by the interfaces for debugging when personalized scripts are attached to the model. When in use, editors can select the required personalized scripts to package into the 3D model project.

[0106] As an example, the above-mentioned acquisition of the personalized script selected by the user in the editor includes:

[0107] a. Add the pre-written personalized script to the editor; specifically, the personalized script processing flow is as follows: define the interface and data fields of the current personalized script, and simulate all data returned by the data interface; the editor selects the personalized script to start, and after starting, obtains the returned data from the data interface, and selects virtual special effects animation or plugin script.

[0108] b. Set a script button on the editor page, wherein the script button is configured to call the corresponding personalized script in response to a click event.

[0109] Specifically, to facilitate use in the editor, personalized scripts are simplified into script buttons, and click events are set on the script buttons. For example, by selecting the node to which the model is attached and assigning a click event, it means that the corresponding personalized script is attached.

[0110] c. Obtain the script button clicked by the user and select the corresponding personalized script; specifically, by clicking the script button, the corresponding personalized script is attached to the model, realizing the function of introducing personalized scripts to the model.

[0111] The technical solution of the above embodiment first involves developers writing various personalized scripts to control the rendering process of 3D models and attaching them to the editor. Then, when editing 3D models, editors select the corresponding personalized scripts according to their needs, debug them in the editor, and package them into the 3D model project.

[0112] S302, Attach the personalized script to the model instance of the 3D model.

[0113] Specifically, the personalized script is attached to a model instance of the 3D model. When attaching the personalized script, refer to... Figure 7 As shown, Figure 7 This is an example of binding a click event. A transparent sphere with a set radius can be set on the skeletal node of a 3D model. By binding a click event within the radius of the transparent sphere, when the sphere is touched within that radius, the corresponding click view is drawn on the interface. The personalized script responds to the click event and executes the corresponding code function, such as touch control function.

[0114] S303, In the context of the Metaverse live streaming room, the personalized script is launched to debug the data interface and obtain the returned data.

[0115] Specifically, since the 3D model instance is generated based on the resource files edited for the Metaverse Live Room, when debugging the 3D model, the Metaverse Live Room scene is created using the editor page. By setting the current running environment to the Metaverse Live Room environment, personalized scripts can be debugged within the Metaverse Live Room scene.

[0116] S304. Based on the debugging results, associate the 3D model with the personalized script and add it to the project.

[0117] In one example, the data interface is the anchor face data interface; accordingly, the debugging process in step S301 may include the following steps:

[0118] 1) Simulate the scene of the metaverse live broadcast room on the editor and simulate the anchor's face data based on a unified data structure; specifically, simulate the scene of the metaverse live broadcast room on the editor page, and then set a unified data structure to simulate the anchor's face data.

[0119] 2) Obtain the 3D model selected by the user through the editor, and debug the anchor face data interface according to the personalized script, and return the anchor face position; specifically, the user can select the required 3D model through the editor and use the associated personalized script to debug the face data.

[0120] 3) Control the 3D model to move following the position of the anchor's face.

[0121] Specifically, the editor controls the 3D model to follow the anchor's face position; when the anchor moves, the face recognition position also moves accordingly. For example, developers define an anchor face data interface, and in the editor, a unified data structure is used to simulate anchor face data for debugging purposes. Figure 4In the editor, select the "Flying Dragon" model, click the personalized script button, and select the model to follow the anchor's face data. In the editor, the "Flying Dragon" model is placed next to the anchor's face position according to the anchor's face position. When the anchor's face position changes, the position of the "Flying Dragon" model also moves accordingly.

[0122] In another example, the data interface is a location coordinate interface for the voice room operator; accordingly, the debugging process in step S301 may include the following steps:

[0123] 1) Simulate the scene of the Metaverse live broadcast room in the editor, and simulate the interface data of each seat in the voice room in this scene; specifically, first simulate the scene of the Metaverse live broadcast room in the editor, and then simulate the interface data of each seat in the voice room based on this scene, for debugging the voice room.

[0124] 2) Load the animation model selected by the user through the editor, and debug the position coordinate interface according to the personalized script, and return the position coordinate data of the voice room agent.

[0125] 3) Control the animation model to move to the position coordinates corresponding to the voice room operator.

[0126] For example, developers define the coordinate interfaces of each position of the voice room operator. In the editor, the interface data of each interface is simulated. The editor selects the model or particle, edits the personalized script, selects a certain position of the operator, and then executes the animation effect to load the model. After the loading is successful, the animation effect moves from the original position to the coordinates of the operator's seat.

[0127] In one embodiment, to enable the use of personalized scripts in more customized scenarios, the personalized scripts may preferably include pre-written general scripts; wherein the general scripts may include touch rotation model scripts, touch rotation lens scripts, or touch vibration scripts, etc.

[0128] Accordingly, the method for editing virtual resources in the metaverse live streaming room of this embodiment may further include the following steps:

[0129] 1) Add the general script to the personalized script list; specifically, add the general script to the script list of personalized scripts in the editor, and users can search for and use the relevant general scripts in the list.

[0130] 2) Obtain the general script selected by the user and record in the editor that the current 3D model has started the function of rotating the model; specifically, the user can select a general script as needed, and the editor records the corresponding model function that the current 3D model has used according to the function of the general script, such as the function of rotating the 3D model mentioned above.

[0131] 3) Package the selected generic script into the project and record the relationship between the 3D model and the generic script in the configuration file.

[0132] For example, developers can write general scripts such as touch-to-rotate models and touch-to-rotate cameras, and place them in a list of personalized scripts. Users can select a model or particle, then choose the desired general script. The editor records when the current model or particle activates the touch-to-rotate model or touch-to-rotate camera script. Finally, the general scripts are packaged into the 3D model's project, and their relationships are recorded in a configuration file. Additionally, touch vibration scripts can be included, providing vibration feedback when the user clicks on the model. In practical use, more personalized scripts can be customized according to the specific needs of the scenario.

[0133] As described in the above embodiments, the editor allows for the generation, application, and configuration of personalized and general scripts. Personalized scripts can be developed and configured according to scenarios such as live streaming rooms and voice chat rooms. After generation, personalized scripts can be downloaded and used in the corresponding scenarios. General scripts can include common scripts for path editing, rotation, touch control, and scaling. General scripts are configurable and exportable. The edited attributes are used to generate a configuration file, and the personalized scripts and their models are packaged and uploaded to the server, generating an access address for clients to access.

[0134] Step S40: After successful debugging, the resource files, configuration files, and associated personalized scripts of the 3D model are saved as a 3D model file using the editor, and then uploaded to the editor server for loading and use.

[0135] In this step, after successful debugging, the personalized script associated with the 3D model is confirmed. Then, the resource files, configuration files, and associated personalized scripts of the 3D model are saved as a single 3D model file and uploaded to the editor server for loading and use. For example, it can be downloaded to the Metaverse live streaming room for playing virtual gifts, or provided to other users for download and editing through the editor.

[0136] In one embodiment, the holding phase process of step S40 may include the following steps:

[0137] S401, in response to the user's confirmation and save operation, save the resource files, configuration files and associated personalized scripts of the 3D model to a repository address in the editor, and record the current model repository address.

[0138] Specifically, after completing various scene settings for the 3D model, users can confirm and save on the editor page, such as by clicking the save button. This saves the initialized model or particles, model attributes, personalized scripts, animation sequences, etc. The editor saves the project to a repository address and records the current model repository address information.

[0139] S402, the next time the user opens the editor, the resource files, configuration files and associated personalized scripts of the saved 3D model are loaded according to the model repository address, and then restored and loaded onto the editor.

[0140] Specifically, when the editor reopens the editor, the editor can load the saved 3D model's resource files, configuration files, and associated personalized scripts, including configuration files, model, particle and other attribute parameters, and restore them all to the editor for continued editing and use.

[0141] like Figure 8 As shown, Figure 8 This is a sample editor restoration diagram; editors can download the current 3D model file on the client, read the configuration file, and execute the corresponding script code to edit and use the virtual resources of the Metaverse live stream room for scenarios such as gift-giving and entrance shows in the Metaverse live stream room.

[0142] Based on the technical solutions of the above embodiments, this application provides a processing solution for a personalized script editor for models and particles. Taking the Cocos game engine as an example, refer to... Figure 9 As shown, Figure 9 This is a sample overall page diagram of the editor. The image shows the editor page for editing the combined 3D effect of the "flying dragon" model and "fire-breathing" particles. Users can edit the 3D model of the "fire-breathing flying dragon" as shown in the image. When the "fire-breathing flying dragon" is played on the client, it can have a 3D stereoscopic effect and can interact with the user in real time during playback through touch control functions provided by personalized scripts.

[0143] refer to Figure 10 As shown, Figure 10 This is a sequence diagram of an example of an overall editing scheme for virtual resources in a metaverse live stream, including the following steps:

[0144] s1: When the user selects a local resource file (FBX model / Cocos particles) on the editor page, the editor page uploads the resource file to the remote server;

[0145] s2: Create a Cocos project on the remote server and copy the resource files to the Cocos project directory;

[0146] s3: The remote server sends a build request to the Cocos process;

[0147] s4: The Cocos process completes the build and returns the result to the remote server;

[0148] S5: The remote server analyzes the Cocos project structure, extracts the converted resource content, generates the corresponding configuration file, and returns it to the editor page;

[0149] s6: Users create character models on the editor page, download the models according to the configuration file, create animations, and edit model properties;

[0150] S7: When a user selects a personalized script, the editor page will select the personalized script and upload it to the remote server.

[0151] s8: The user confirms the save on the editor page, and the updated configuration file and personalized script are uploaded to the remote server;

[0152] s9: Remote server stores personalized scripts and configuration files.

[0153] The aforementioned technical solution can provide editors with 3D animation effects, which can be applied to 3D animation editing scenarios to enhance the 3D effect of virtual resources played on the client side, increase the interactivity between virtual resources and users during playback, and use uploaded 3D resources to edit the combination effects of models and particles. This enriches the 3D animation editing interface, optimizes the 3D effect of virtual gifts played on the client side, improves the sense of layering, space, and three-dimensionality of the image, and enriches the styles of virtual gifts, entrance shows, and virtual avatars in the metaverse live stream. It can incentivize users to send gifts, promote interaction between the streamer and the audience, increase user retention and viewing time, and enhance the activity of the live stream.

[0154] The following example illustrates how to use the editing scheme of virtual resources in the metaverse live streaming room of this application to play 3D virtual effects within a metaverse scenario. This example, applied in a metaverse live streaming room, mainly includes the following steps:

[0155] Step (1), create a 3D model.

[0156] Specifically, art designers can design 3D models and related materials; music creators can create the necessary audio resources. A management system can be used to manage the production and storage of 3D models and personalized scripts, and upload 3D models, related materials and music resources to the management system.

[0157] For example, 3D models can be designed by designers according to certain specifications (specific design can maintain the reusability of motion scripts). The skeletal joints of the 3D model need to be designed, and the skeletal joints need to indicate the level of precision of the movement. Generally, the higher the precision of the 3D model, the more detailed the number of skeletal joints and the number of faces. In addition, 3D models also need sound resources, background music, and facial expression music, such as the voice resource package for the virtual character's speech. These voice resource packages can also be pre-produced and recorded by music producers.

[0158] Step (2) Use the editor to edit the personalized script during playback and add touch-enabled capabilities to the 3D model.

[0159] Personalized scripts are mainly used to control and bind model actions and sounds through code scripts, such as the actions of virtual character models, such as walking, standing, raising hands, talking, dancing, etc. Corresponding code scripts are also written for the model's skeletal joints and music materials.

[0160] Touch capabilities and script control capabilities include the ability to control data generated by touch, combined with data from sensors such as accelerometers, speed sensors, pedometers, orientation sensors, gyroscopes, light sensors, and sound sensors. When adding touch capabilities, a transparent sphere with a set radius can be set on the skeletal nodes of the 3D model. When the sphere is touched within its radius, the terminal device is notified in real time of the clicked area. After being notified of the clicked area, the terminal device draws the corresponding click view on the interface. The user can click on the view and notify the player to execute the corresponding click event.

[0161] Step (3) Export the 3D model and personalized script and store them in the database.

[0162] After editing the code scripts for model actions and adding attachments using the editor, the code scripts for model actions and attachments are generated into personalized scripts. The 3D model's actions are previewed in the editor to verify the effect. The 3D model and personalized scripts are then exported and stored in the database. To facilitate the reuse and management of personalized scripts, different scripts need to be uniformly managed for various types of model actions. Each script is bound to a unique model ID, and descriptive information such as name and action meaning is added. Personalized scripts are categorized by scene, action, time, object, etc., and then stored in the database according to their categories. When needed later, the model ID can be directly searched from the database. This allows for direct reuse when developing the same actions for 3D models, thereby improving the efficiency of personalized script creation.

[0163] Step (4): Determine the business scenario displayed on the client and load the corresponding 3D model and personalized script from the database.

[0164] For example, in a live video streaming room, business scenarios could include gift effects playback, entrance shows, IM chat interfaces, personal homepage interfaces, and so on.

[0165] For different user types, different permissions can be set for different business scenarios. For example, privileged users can use a variety of special effects playback functions, while non-privileged users can use basic special effects playback functions.

[0166] During the playback of 3D models, personalized scripts can be run to perform touch operations on the 3D models. Since the database stores various 3D models and personalized scripts, and different personalized scripts are configured with different control modes, after the client selects a 3D model according to its needs, the corresponding personalized script is loaded to the client's local machine. For example, the virtual character model can walk, stand, raise its hand, talk, and dance, as well as the character model can jump and fly.

[0167] Step (5) involves binding the downloaded personalized script to the 3D model and calling the player to play it.

[0168] Specifically, after downloading the image materials, music resources, and personalized scripts that come with the code scripts corresponding to the 3D model, the personalized scripts are bound to the 3D model. The personalized scripts can define touch capabilities for the 3D model, and then call the player to play the music, controlling the 3D model to perform corresponding actions according to the personalized script instructions. During playback, specific actions, audio playback capabilities, and so on can be displayed.

[0169] For example, taking a virtual character model as an example, a personalized script can be used to control the virtual character model to walk, specifying the model's skeleton, direction of movement, coordinates of movement, and movement time; since in the metaverse live streaming scenario, viewers may watch the live stream on different terminal devices, such as mobile devices, PC devices, and VR devices.

[0170] Step (6): During the playback of the 3D model by the player, the model's actions and additional capabilities are used to control the 3D model to perform corresponding actions to render the relevant screen content.

[0171] Specifically, by utilizing the touch capabilities configured in the personalized scripts, corresponding touch functions can be executed when the user touches the 3D model. For example, in the metaverse scene, the clicking process is completed through the interaction of the player, the touch layer, and the client interface. When a transparent sphere on the skeletal node of the 3D model is clicked, the client is notified in real time of the location of the clicked area. After being notified of the clicked area, the client interface draws the corresponding click view. The user can then use the click view to notify the player to execute the corresponding click event.

[0172] In addition, it also has the ability to control the script based on sensor data such as accelerometer, speed, pedometer, orientation sensor, gyroscope, light, and sound added by the personalized script. During the playback of the 3D model, the data interface can be used to read this sensor data to control the playback perspective and special effects of the 3D model. Thus, users can use personalized scripts to view the rendered 3D model from different visual angles and add effects such as sunlight.

[0173] In the context of an entrance show, the effect of the entrance show should be considered in the following ways: Figure 11 As shown, Figure 11 This is an example of an entrance show effect illustration. The image shows a "fire-breathing dragon" model moving in 3D mode. During the playback, it interacts with the user through personalized scripts. Users can use touch to make the "fire-breathing dragon" present different interactive effects.

[0174] The technical solution described above, within the metaverse scenario, addresses the client's need to play 3D virtual effects. It pre-creates scripts in an editor to configure corresponding touch capabilities for the 3D virtual effects. During client playback, the bound 3D virtual effects and personalized scripts provide an interactive control solution for users to edit and interact with virtual resources in the 3D metaverse livestream room. Users can interact with the 3D virtual effects in real time, enhancing the interactivity of editing virtual resources in the metaverse livestream room. This is particularly effective when applied to VR devices, resulting in a more stunning playback effect.

[0175] Based on the technical solutions of the above embodiments, when playing virtual effects in a live broadcast room, the forms of virtual effects can be enriched, and the sense of layering, space and three-dimensionality of virtual effects can be improved, making the live broadcast more vivid. In particular, it can be applied to the editing of virtual resources in the metaverse live broadcast scene, enriching the styles of virtual gifts, entrance shows and virtual images in the metaverse live broadcast and promoting the interaction between the anchor and the audience in the metaverse live broadcast.

[0176] It should be understood that although the steps in the flowcharts of the embodiments described above are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some steps in the flowcharts of the embodiments described above may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages of other steps.

[0177] Based on the same inventive concept, this application also provides an apparatus for editing virtual resources in a metaverse livestream room to implement the above-described method for editing virtual resources in a metaverse livestream room. The solution provided by this apparatus is similar to the solution described in the above-described method. Therefore, the specific limitations of one or more embodiments of the apparatus for editing virtual resources in a metaverse livestream room provided below can be found in the limitations of the method for editing virtual resources in a metaverse livestream room described above, and will not be repeated here.

[0178] In one embodiment, such as Figure 12 As shown, Figure 12 This is a schematic diagram of the structure of a virtual resource editing device in a metaverse live streaming room according to one embodiment, which may include the following:

[0179] Initialization module 10 is used to obtain the resource files of the 3D model of the Metaverse live room uploaded through the editor page, and generate an initial configuration file based on the attribute information of the 3D model.

[0180] The attribute configuration module 20 is used to create a corresponding model instance on the editor using the resource file of the 3D model, and in response to the input model instance configuration operation, configure the attributes of the model instance of the 3D model and update it to the configuration file.

[0181] The script editing module 30 is used to download the corresponding personalized script from the plugin scripts pre-stored in the editor server in response to the script selection operation, associate the personalized script with the 3D model, and debug the model instance of the associated 3D model according to the personalized script in the scene of the metaverse live broadcast room.

[0182] The model saving module 40 is used to save the resource files, configuration files and associated personalized scripts of the 3D model as a 3D model file through the editor after debugging, and upload it to the editor server for loading and use.

[0183] The modules in the virtual resource editing device of the aforementioned metaverse live streaming room can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in an electronic device, or stored in the memory of an electronic device in software form, so that the processor can call and execute the operations corresponding to each module.

[0184] The virtual resource editing device for the metaverse live streaming room in this embodiment can execute the virtual resource editing method for the metaverse live streaming room provided in the embodiments of this application. The implementation principle is similar. The actions performed by each module in the virtual resource editing device for the metaverse live streaming room in each embodiment of this application correspond to the steps in the virtual resource editing method for the metaverse live streaming room in each embodiment of this application. For detailed functional descriptions of each module of the virtual resource editing device for the metaverse live streaming room, please refer to the descriptions in the corresponding virtual resource editing methods for the metaverse live streaming room shown above. They will not be repeated here.

[0185] This application provides an electronic device, which can be a terminal, and its internal structure diagram can be as follows: Figure 13 As shown, the electronic device includes a processor, memory, communication interface, display screen, and input device connected via a system bus. The processor provides computing and control capabilities. The memory includes a non-volatile storage medium and internal memory. The non-volatile storage medium stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage medium. The communication interface is used for wired or wireless communication with external devices; wireless communication can be achieved through Wi-Fi, mobile cellular networks, NFC (Near Field Communication), or other technologies. When the computer program is executed by the processor, it implements a method for editing virtual resources in a metaverse live streaming room. The display screen can be an LCD screen or an e-ink screen. The input device can be a touch layer covering the display screen, buttons, a trackball, or a touchpad mounted on the device's casing, or an external keyboard, touchpad, or mouse.

[0186] Those skilled in the art will understand that Figure 13 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the electronic device to which the present application is applied. The specific electronic device may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0187] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps in the above-described embodiments of the method for editing virtual resources in various metaverse live streaming rooms.

[0188] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory can include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can take many forms, such as Static Random Access Memory (SRAM) or Dynamic Random Access Memory (DRAM). The databases involved in the embodiments provided in this application may include at least one type of relational database and non-relational database. Non-relational databases may include, but are not limited to, blockchain-based distributed databases. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited to these.

[0189] 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.

[0190] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0191] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A method for editing virtual resources in a metaverse live streaming room, characterized in that, Used to edit 3D virtual effects with 3D playback effects in the editor, including: Obtain the resource file of the 3D model of the Metaverse live room uploaded through the editor page, and generate an initial configuration file based on the attribute information of the 3D model; Using the resource files of the 3D model, a corresponding model instance is created in the editor. In response to the input model instance configuration operation, the attributes of the 3D model instance are configured and updated to the configuration file. In response to the script selection operation, the corresponding personalized script is downloaded from the plugin scripts pre-stored in the editor server, the personalized script is associated with the 3D model, and the model instance of the associated 3D model is debugged according to the personalized script in the scene of the metaverse live broadcast room. After successful debugging, the resource files, configuration files, and associated personalized scripts of the 3D model are saved as 3D model files using the editor and uploaded to the editor server for loading and use.

2. The method for editing virtual resources in a metaverse live streaming room according to claim 1, characterized in that, The step of generating an initial configuration file based on the attribute information of the 3D model includes: In response to a resource file uploaded by a user on the editor page, a project is initialized on the editor to hold the resource file; wherein, the resource file includes model files and particle files; Copy the resource files to the project, and initiate a build process in the project to generate and save the 3D model package file; The packaged file of the 3D model is analyzed and resource attribute parameters are extracted. An initial configuration file is then generated based on the resource attribute parameters.

3. The method for editing virtual resources in a metaverse live streaming room according to claim 2, characterized in that, Using the resource files of the 3D model, a corresponding model instance is created in the editor. In response to the input model instance configuration operation, the attributes of the 3D model instance are configured and updated in the configuration file, including: Find the target resource in the list of imported resource files in the editor; In response to the user's instruction to create a model instance, a corresponding model instance is created on the editor page based on the target resource; In response to user input of configuration operations for model instances of the 3D model, the attribute configuration of the model instances of the 3D model is edited, and the edited attribute configuration information is updated to the configuration file; Render the 3D model on the editor page.

4. The method for editing virtual resources in a metaverse live streaming room according to claim 2, characterized in that, Associating the personalized script with the 3D model, and debugging the model instance of the associated 3D model according to the personalized script in the Metaverse live streaming room scene, including: Obtain the personalized script selected by the user in the editor; wherein the personalized script is pre-written and its data interface and the data returned by the interface are defined, and the personalized script is used to control the rendering process of the 3D model. The personalized script is attached to the model instance of the 3D model; In the context of the Metaverse live streaming room, the personalized script is launched to debug the data interface and obtain the returned data; The 3D model and the personalized script are associated based on the debugging results and added to the project.

5. The method for editing virtual resources in a metaverse live streaming room according to claim 4, characterized in that, Retrieve the personalized script selected by the user in the editor, including: Add pre-written personalized scripts to the editor; Set a script button on the editor page, wherein the script button is configured to invoke the corresponding personalized script in response to a click event; Get the script button clicked by the user and select the corresponding personalized script.

6. The method for editing virtual resources in a metaverse live streaming room according to claim 4, characterized in that, The data interface is the anchor's face data interface; In the context of the Metaverse live stream, the personalized script is launched to debug the data interface and obtain the returned data, including: Simulate the scene of a metaverse live streaming room in the editor, and simulate the anchor's facial data based on a unified data structure; The system retrieves the 3D model selected by the user through the editor, debugs the anchor's face data interface according to the personalized script, and returns the anchor's face position. The 3D model is controlled to move in accordance with the position of the anchor's face.

7. The method for editing virtual resources in a metaverse live streaming room according to claim 4, characterized in that, The data interface is the location coordinate interface for the voice room operator; In the context of the Metaverse live stream, the personalized script is launched to debug the data interface and obtain the returned data, including: Simulate the scene of the metaverse live broadcast room in the editor, and simulate the interface data of each seat in the voice room in this scene; The user selects an animation model through the editor and debugs the position coordinate interface according to the personalized script, returning the position coordinate data of the voice room agent; Control the animation model to move to the position coordinates corresponding to the voice room operator.

8. The method for editing virtual resources in a metaverse live streaming room according to claim 4, characterized in that, The personalized script also includes pre-written general scripts; wherein, the general scripts include touch rotation model scripts, touch rotation lens scripts, or touch vibration scripts; The method further includes: Add the general script to the list of personalized scripts; Get the user-selected general script and record in the editor that the current 3D model has started the function of rotating the model; Package the selected generic script into the project and record the relationship between the 3D model and the generic script in the configuration file.

9. The method for editing virtual resources in a metaverse live streaming room according to claim 1, characterized in that, The configuration file of the 3D model and its associated personalized scripts are saved as 3D model files for loading and editing, including: In response to the user's confirmation and save operation, the resource files, configuration files, and associated personalized scripts of the 3D model are saved in a repository address of the editor, and the current model repository address is recorded. The next time the user opens the editor, the resource files, configuration files, and associated personalized scripts of the saved 3D model are loaded according to the model repository address and then restored and loaded onto the editor.

10. An editing device for virtual resources in a metaverse live streaming room, characterized in that, Used to edit 3D virtual effects with 3D playback effects in the editor, including: The initialization module is used to obtain the resource files of the 3D model of the Metaverse live room uploaded through the editor page, and generate an initial configuration file based on the attribute information of the 3D model. The attribute configuration module is used to create corresponding model instances in the editor using the resource files of the 3D model, and in response to the input model instance configuration operation, configure the attributes of the model instance of the 3D model and update the configuration file. The script editing module is used to download the corresponding personalized script from the plugin scripts pre-stored in the editor server in response to the script selection operation, associate the personalized script with the 3D model, and debug the model instance of the associated 3D model according to the personalized script in the scene of the metaverse live broadcast room. The model saving module is used to save the resource files, configuration files, and associated personalized scripts of the 3D model as a 3D model file through the editor after debugging, and upload it to the editor server for loading and use.

11. An electronic device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method for editing virtual resources in the Metaverse Live Room as described in any one of claims 1 to 9.

12. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method for editing virtual resources in the Metaverse Live Room as described in any one of claims 1 to 9.

Images