CN113407259A

CN113407259A - Scene loading method, device, equipment and storage medium

Info

Publication number: CN113407259A
Application number: CN202110793043.XA
Authority: CN
Inventors: 郑学兴
Original assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Current assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Priority date: 2021-07-13
Filing date: 2021-07-13
Publication date: 2021-09-17
Anticipated expiration: 2041-07-13
Also published as: CN113407259B

Abstract

The present disclosure provides a method, an apparatus, a device, a storage medium, and a program product for loading a scene, which relate to the technical field of artificial intelligence such as computers and deep learning, and in particular to the technical field of augmented reality AR. The specific implementation scheme is as follows: aiming at a target application in an active state in a plurality of applications, creating a local subspace corresponding to the target application, and storing first scene data corresponding to the target application to the local subspace; responding to a target scene loading operation aiming at a target application, and acquiring first scene data corresponding to the target scene loading operation in a local subspace and/or second scene data corresponding to the target scene loading operation in a created global subspace; and loading the target scene according to the first scene data and/or the second scene data by using the created virtual machine, wherein the plurality of applications are based on the host language, and the virtual machine is based on the embedded language different from the host language.

Description

Scene loading method, device, equipment and storage medium

Technical Field

The present disclosure relates to the field of artificial intelligence technologies such as computers, deep learning, and in particular to the field of augmented reality AR technologies.

Background

Lua is a small scripting language designed to be embedded in applications to provide flexible extension and customization of the applications. Lua is written in standard C language and can be compiled and run on many operating systems and platforms. Nowadays, Lua is widely used in the fields of AR (augmented reality), games, and the like.

Disclosure of Invention

The present disclosure provides a method, apparatus, device, storage medium, and program product for loading a scene.

According to an aspect of the present disclosure, there is provided a method of loading a scene, including: aiming at a target application in an active state in a plurality of applications, creating a local subspace corresponding to the target application, and storing first scene data corresponding to the target application to the local subspace; responding to a target scene loading operation aiming at the target application, and acquiring first scene data corresponding to the target scene loading operation in the local subspace and/or second scene data corresponding to the target scene loading operation in the created global subspace; and loading a target scene according to the first scene data and/or the second scene data by using the created virtual machine, wherein the plurality of applications are based on a host language, and the virtual machine is based on an embedded language different from the host language.

According to another aspect of the present disclosure, there is provided an apparatus for loading a scene, including: the system comprises a creating module, a judging module and a processing module, wherein the creating module is used for creating a local subspace corresponding to a target application in an active state in a plurality of applications and storing first scene data corresponding to the target application to the local subspace; an obtaining module, configured to, in response to a target scene loading operation for the target application, obtain first scene data in the local subspace and corresponding to the target scene loading operation and/or second scene data in the created global subspace and corresponding to the target scene loading operation; and a loading module, configured to load a target scene according to the first scene data and/or the second scene data by using a created virtual machine, where the multiple applications are based on a host language, and the virtual machine is based on an embedded language different from the host language.

Another aspect of the present disclosure provides an electronic device including: at least one processor; and a memory communicatively coupled to the at least one processor; wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of the embodiments of the present disclosure.

According to another aspect of the disclosed embodiments, there is provided a non-transitory computer readable storage medium having stored thereon computer instructions for causing the computer to perform the method shown in the disclosed embodiments.

According to another aspect of the embodiments of the present disclosure, there is provided a computer program product, a computer program, which when executed by a processor implements the method shown in the embodiments of the present disclosure.

It should be understood that the statements in this section do not necessarily identify key or critical features of the embodiments of the present disclosure, nor do they limit the scope of the present disclosure. Other features of the present disclosure will become apparent from the following description.

Drawings

The drawings are included to provide a better understanding of the present solution and are not to be construed as limiting the present disclosure. Wherein:

FIG. 1 is a program diagram of a method to which a loading scenario may be applied, according to an embodiment of the present disclosure;

FIG. 2A schematically illustrates a flow diagram of a method of loading a scenario, in accordance with an embodiment of the present disclosure;

FIG. 2B schematically illustrates a flow diagram of a method of loading a scenario according to another embodiment of the present disclosure;

FIG. 3 schematically illustrates a flow diagram of a method of loading a scenario according to another embodiment of the present disclosure;

FIG. 4 schematically illustrates a method diagram of a loading scenario according to another embodiment of the present disclosure;

FIG. 5 schematically illustrates a block diagram of an apparatus for loading a scenario according to an embodiment of the present disclosure; and

FIG. 6 illustrates a schematic block diagram of an example electronic device that can be used to implement embodiments of the present disclosure.

Detailed Description

Exemplary embodiments of the present disclosure are described below with reference to the accompanying drawings, in which various details of the embodiments of the disclosure are included to assist understanding, and which are to be considered as merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the present disclosure. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.

An application scenario of the method and apparatus for loading a scenario provided by the present disclosure will be described below with reference to fig. 1.

Fig. 1 is a program diagram of a method to which a loading scenario may be applied according to an embodiment of the present disclosure.

As shown in fig. 1, the program 100 includes an Application controller (Application controller)110, a virtual machine 120, and a plurality of applications (applications) 130.

According to an embodiment of the present disclosure, the program body of the program 100 may be developed based on an SDK (Software Development Kit), containing one or more SDK functional modules. The SDK function modules include, for example, a 3D model loading module that may be used to load a 3D model, a sticker effect module that may be used to implement a sticker effect, a scene rendering module that may be used for scene rendering, and the like.

According to embodiments of the present disclosure, the application controller 110 may be used to control the state and behavior of the plurality of applications 130. For example, the application controller 110 may be used to create a plurality of applications 130, may be used to delete a plurality of applications 130, and the application controller 110 may also control each application 130 to be in an active state or an inactive state. If the application 130 is in an active state, it indicates that the application 130 is currently operable, otherwise, it indicates that the application 130 is not currently operable. In this embodiment, at most one application 130 is operable at a time, i.e., at most one application 130 is active at a time.

According to an embodiment of the present disclosure, the virtual machine 120 may be configured to execute a script file written in a language different from the main program body, and the script file may call the SDK function module included in the program 100 to perform a corresponding operation, such as an image processing operation of makeup, skin polishing, and the like. In this embodiment, the language on which the main body of the program 100 is based may be referred to as a host language, and the language on which the virtual machine 120 and the script file are based may be referred to as an embedded language. Illustratively, in this embodiment, the host language may include a C language or a C + + language, and the embedded language may include a Lua language, for example.

According to an embodiment of the present disclosure, the virtual machine 120 may be created when the plurality of applications 130 are created, and the virtual machine 120 may be deleted when the plurality of applications 130 are deleted, i.e., the life cycle of the virtual machine 120 may coincide with the application controller 110.

According to an embodiment of the present disclosure, the virtual machine 120 is a global variable that can be accessed by each application 130.

According to embodiments of the present disclosure, a global subspace 140 may be created for a plurality of applications 130. The global subspace 140 is a global variable, which can be used by each application 130 and can be used to store scene data commonly used by multiple applications 130. In addition, a local subspace 150 may be created for an application 130 of the plurality of applications 130 that is in an active state. In addition, when the application 130 changes from an active state to an inactive state, the corresponding local subspace 150 may be deleted to free up space. The local subspace 150 is a local variable, which can be used by the application 130 in the active state to store other scene data related to the application 130 besides the scene data used together with other applications. As an alternative embodiment, global subspace 140 and local subspace 150 may be located in virtual machine 120.

According to an embodiment of the present disclosure, the scene data may be data required when performing a scene loading operation, and may include, for example, a script file, a scene configuration file, a model file, and associated resources, and the like. The model file may include, for example, files in fbx, glft, and the like. The associated resources may include, for example, bin binaries for describing model composition, texture files for describing model appearance, and the like. The texture file may include, for example, picture description files in the formats of png, jpg, jpeg, ktx, bmp, etc.

The virtual machine according to the embodiment of the disclosure provides a global embedded script execution environment, can be used by a plurality of applications, and can interact with corresponding functional modules in different scenes to realize scene effects corresponding to the scenes.

Taking the camera program as an example, the functions of whitening, peeling and the like are independent of any scene in the use process of the camera program. When the camera program does not load the AR special effect scene, the makeup function still needs to be started. After the camera program loads other scenes except the AR special effect scene, the global makeup effect can be shielded according to the requirement, and the interaction is carried out through the virtual machine and the functional module corresponding to the global makeup effect, so that the customized makeup effect corresponding to the scene is realized.

The method for loading the scenario provided by the present disclosure will be described below with reference to fig. 2A.

Fig. 2A schematically illustrates a flow diagram of a method of loading a scenario according to an embodiment of the present disclosure.

As shown in FIG. 2A, the method of loading a scene includes operations S210-S230.

In operation S210, for a target application in an active state among a plurality of applications, a local subspace corresponding to the target application is created, and first scene data corresponding to the target application is stored to the local subspace.

Then, in operation S220, in response to a target scene loading operation for a target application, first scene data corresponding to the target scene loading operation in a local subspace and/or second scene data corresponding to the target scene loading operation in a created global subspace is obtained.

In operation S230, a target scene is loaded according to the first scene data and/or the second scene data using the created virtual machine.

According to the embodiment of the disclosure, a virtual machine may be created in advance, and a global subspace may be created for storing first scene data, where the first scene data includes scene data used by a target application alone, and the second scene data includes scene data that may be used by a plurality of applications. The first scene data and the second scene data may each include any one or more of a script file, a scene configuration file, a model file, and an associated resource. Wherein the script file may be used to perform a corresponding operation, such as suggesting an operation comprising calling a functional module of the system. The scene configuration file may include configuration information in the application scene, and may be in JSON format, for example. The model file may include files in the format of fbx, gltf, etc., for example. The associated resources may include, for example, bin binaries for describing model composition, texture files for describing model appearance, and the like. The texture file may include, for example, picture description files in the formats of png, jpg, jpeg, ktx, bmp, etc.

According to the embodiment of the disclosure, a plurality of applications can run in the system, the states of the applications can comprise an active state and an inactive state, and the states of the applications can be switched. The target application may be an application of the plurality of applications that is currently active. Illustratively, in this embodiment, there is at most one application that is active at the same time.

According to other embodiments of the present disclosure, a local subspace corresponding to a target application is deleted in response to the target application transitioning from an active state to an inactive state.

According to embodiments of the present disclosure, a target application scenario load operation may include, for example, a plurality of sub-operations. The sub-operations may include, for example, image processing operations such as cosmetic special effects, add-on-sticker special effects, and the like.

According to the embodiment of the disclosure, a sub-operation set corresponding to a target scene loading operation can be obtained, wherein the sub-operation set comprises at least one first sub-operation and/or at least one second sub-operation; and acquiring first scene data corresponding to at least one first sub-operation in the local subspace and/or second scene data corresponding to at least one second sub-operation in the global subspace.

The method for loading the scenario shown above is further described with reference to fig. 2B in conjunction with specific embodiments. Those skilled in the art will appreciate that the following example embodiments are only for the understanding of the present disclosure, and the present disclosure is not limited thereto.

Illustratively, in the present embodiment, a plurality of applications may be created by the application controller. Application a of the plurality of applications may be used to add special effects to the image.

FIG. 2B schematically illustrates a flow diagram of a method of loading a scenario according to another embodiment of the present disclosure. As shown in fig. 2B, in the case where the application a is in an active state, a scene loading operation needs to be performed. The scene loading operation comprises sub-operations b1 and b2, wherein scene data C1 corresponding to the sub-operation b1 is located in a global subspace, and scene data C2 corresponding to the sub-operation b2 is located in a local subspace. The virtual machine acquires C1 in the global subspace and C2 in the local subspace. The Lua scripts in C1 and C2 are executed to call corresponding function modules, and special effects are added to the image according to the scene configuration files, model files and texture files in C1 and C2.

According to embodiments of the present disclosure, the plurality of applications may be based on a host language, and the virtual machine may be based on an embedded language different from the host language. Illustratively, in this embodiment, the host language may include a C language or a C + + language, and the embedded language may include a Lua language, for example.

According to an embodiment of the present disclosure, the first scene data and the second scene data include script files, wherein the script files may be used to call the host-based function module to implement the corresponding function. The script file may be based on the same embedded language as the virtual machine. Based on this, loading the first scene data and/or the second scene data may include, for example, executing a script file in the first scene data and the second scene data by using a virtual machine, where the script file may be used to call a function module of the system to implement a corresponding function.

In the related art, when the application is converted into the active state, the virtual machine is dynamically generated, the scene data required by the application is loaded by using the virtual machine, and when the application is converted into the inactive state, the virtual machine is deleted. In this case, however, scene data cannot be shared among a plurality of applications.

According to the embodiment of the disclosure, the scene data used by all applications is stored by using the global subspace, and when the applications are in an active state, the local subspace is created to store the scene data used by the applications in the active state independently, so that the scene data can be shared among a plurality of applications. In addition, a plurality of applications share one virtual machine, and when the applications need to load a scene, the virtual machine is used for acquiring corresponding scene data from the global subspace and the local subspace respectively to load the scene data. The virtual machine does not need to be frequently created and deleted, and the operation expense is reduced.

FIG. 3 schematically shows a flow diagram of a method of loading a scenario according to another embodiment of the present disclosure.

As shown in FIG. 3, the method 300 of loading a scene includes operations S310 to S360.

In operation S310, an application controller is created.

According to embodiments of the present disclosure, an application controller may be used to control the state and behavior of an application.

In operation S320, a plurality of applications and virtual machines are created using the application controller.

According to the embodiment of the disclosure, when a plurality of applications are created, a virtual machine can be created, and the virtual machine can be shared and used by the plurality of applications.

In operation S330, a global subspace is created and second scene data corresponding to the plurality of applications is stored to the global subspace.

According to an embodiment of the present disclosure, the global subspace may be a global object, which may be used by multiple applications. In this embodiment, scene data commonly used by a plurality of applications may be stored in the global subspace.

In operation S340, for a target application in an active state among the plurality of applications, a local subspace corresponding to the target application is created, and first scene data corresponding to the target application is stored to the local subspace.

According to the embodiment of the disclosure, the scene data used by the application in the active state can be stored in the local subspace.

In operation S350, in response to a target scene loading operation for a target application, first scene data corresponding to the target scene loading operation in a local subspace and/or second scene data corresponding to the target scene loading operation in a created global subspace is obtained.

In operation S360, a target scene is loaded according to the first scene data and/or the second scene data using the created virtual machine.

According to further embodiments of the present disclosure, the application controller may also delete the plurality of applications. In the event that the plurality of applications are deleted, the virtual machine may be deleted accordingly to free up resources occupied by the virtual machine.

According to the method for loading the scene, the message transmission channel between each application and the corresponding functional module can be independent, and each application can transmit the customized message to the corresponding functional module when the scene is loaded so as to call the functional module to realize the customized effect. In addition, message interference among different scenes can be avoided, and compatibility is improved.

The method for loading the scenario shown above is further described with reference to fig. 4 in conjunction with specific embodiments. Those skilled in the art will appreciate that the following example embodiments are only for the understanding of the present disclosure, and the present disclosure is not limited thereto.

For example, in this embodiment, the program body may be based on a C + + language, the virtual machine may be a Lua virtual machine, the script file may be a Lua script, and both the Lua virtual machine and the Lua script are based on a Lua language.

Fig. 4 schematically illustrates a method diagram of a loading scenario according to another embodiment of the present disclosure.

In fig. 4, program 400 includes program body 410 and Lua virtual machine 420. The program main body 410 includes a function module 411, a C + + interface 412 corresponding to the function module 411, and a glue function 413, and the virtual machine 420 includes a Lua interface 421 and scene data 422. The scene data 422 includes a Lua script 4221. It should be noted that the numbers of the function modules, the C + + interfaces, the Lua interfaces, the scene data, and the Lua scripts in fig. 4 are merely examples, and any number of the function modules, the C + + interfaces, the Lua interfaces, the scene data, and the Lua scripts may be used in practical applications.

According to an embodiment of the present disclosure, the functional module 411 may be provided by an SDK integrated by the program 400. Each functional module may be used to provide corresponding basic capabilities, such as the ability to implement 3D model loading, sticker effects, scene rendering, and the like.

C + + interface 412 may be used to provide an external interface. The corresponding functional module may be loaded by calling C + + interface 412 to implement the corresponding base capability.

And a glue function 413, which can be used for converting the C + + interface into an interface that the Lua script can call. According to an embodiment of the present disclosure, interface function 413 may be implemented based on a third party software package. Illustratively, in this embodiment, the glue function 413 may be implemented based on tolua + +. tolua + + may be used to convert calls to the Lua interface into calls to the corresponding functional modules at program run time.

According to an embodiment of the present disclosure, each application may correspond to one or more scene data 422, and each scene data 422 may contain one or more Lua scripts 4221. It should be noted that, besides the Lua script 4221, the scene data 422 may also include other data, such as a configuration file, a model file, a texture file, and the like, which is not specifically limited by the present disclosure.

According to the embodiment of the disclosure, a global subspace may be created in the Lua virtual machine 420 for storing scene data shared by applications, and a local subspace may be created for an application currently in an active state for storing other scene data that the application needs to use in addition to the shared scene data.

According to the embodiment of the disclosure, when an application in an active state loads a scene, the Lua virtual machine acquires required scene data from the global subspace and the local subspace corresponding to the application, and then executes the Lua script in the scene data to call the corresponding Lua interface, and the glue function converts the call to the Lua interface into the call to the corresponding C + + interface, so that the application can use the capability provided by the function module to realize the loading of the scene.

Fig. 5 schematically shows a block diagram of an apparatus for loading a scenario according to an embodiment of the present disclosure.

As shown in fig. 5, the apparatus 500 for loading a scene includes a creating module 510, an obtaining module 520, and a loading module 530.

The creating module 510 is configured to create, for a target application in an active state among a plurality of applications, a local subspace corresponding to the target application, and store first scene data corresponding to the target application in the local subspace.

An obtaining module 520, configured to, in response to a target scene loading operation for the target application, obtain first scene data in the local subspace and corresponding to the target scene loading operation and/or second scene data in the created global subspace and corresponding to the target scene loading operation.

A loading module 530, configured to load a target scene according to the first scene data and/or the second scene data by using a created virtual machine, where the plurality of applications are based on a host language, and the virtual machine is based on an embedded language different from the host language.

It should be noted that, in the technical solution of the present disclosure, the acquisition, storage, application, and the like of the personal information of the related user all conform to the regulations of the relevant laws and regulations, and do not violate the common customs of the public order.

The present disclosure also provides an electronic device, a readable storage medium, and a computer program product according to embodiments of the present disclosure.

FIG. 6 illustrates a schematic block diagram of an example electronic device 600 that can be used to implement embodiments of the present disclosure. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The electronic device may also represent various forms of mobile devices, such as personal digital processing, cellular phones, smart phones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be examples only, and are not meant to limit implementations of the disclosure described and/or claimed herein.

As shown in fig. 6, the apparatus 600 includes a computing unit 601, which can perform various appropriate actions and processes according to a computer program stored in a Read Only Memory (ROM)602 or a computer program loaded from a storage unit 608 into a Random Access Memory (RAM) 603. In the RAM 603, various programs and data required for the operation of the device 600 can also be stored. The calculation unit 601, the ROM 602, and the RAM 603 are connected to each other via a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.

A number of components in the device 600 are connected to the I/O interface 605, including: an input unit 606 such as a keyboard, a mouse, or the like; an output unit 607 such as various types of displays, speakers, and the like; a storage unit 608, such as a magnetic disk, optical disk, or the like; and a communication unit 609 such as a network card, modem, wireless communication transceiver, etc. The communication unit 609 allows the device 600 to exchange information/data with other devices via a computer network such as the internet and/or various telecommunication networks.

The computing unit 601 may be a variety of general and/or special purpose processing components having processing and computing capabilities. Some examples of the computing unit 601 include, but are not limited to, a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), various dedicated Artificial Intelligence (AI) computing chips, various computing units running machine learning model algorithms, a Digital Signal Processor (DSP), and any suitable processor, controller, microcontroller, and so forth. The calculation unit 601 performs the respective methods and processes described above, such as the method of loading a scene. For example, in some embodiments, the method of loading a scenario may be implemented as a computer software program tangibly embodied in a machine-readable medium, such as storage unit 608. In some embodiments, part or all of the computer program may be loaded and/or installed onto the device 600 via the ROM 602 and/or the communication unit 609. When the computer program is loaded into the RAM 603 and executed by the computing unit 601, one or more steps of the method of loading a scenario described above may be performed. Alternatively, in other embodiments, the computing unit 601 may be configured by any other suitable means (e.g., by means of firmware) to perform the method of loading a scene.

Various implementations of the systems and techniques described here above may be implemented in digital electronic circuitry, integrated circuitry, Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), system on a chip (SOCs), load programmable logic devices (CPLDs), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs that are executable and/or interpretable on a programmable system including at least one programmable processor, which may be special or general purpose, receiving data and instructions from, and transmitting data and instructions to, a storage system, at least one input device, and at least one output device.

Program code for implementing the methods of the present disclosure may be written in any combination of one or more programming languages. These program codes may be provided to a processor or controller of a general purpose computer, special purpose computer, or other programmable data processing apparatus, such that the program codes, when executed by the processor or controller, cause the functions/operations specified in the flowchart and/or block diagram to be performed. The program code may execute entirely on the machine, partly on the machine, as a stand-alone software package partly on the machine and partly on a remote machine or entirely on the remote machine or server.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

To provide for interaction with a user, the systems and techniques described here can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and a pointing device (e.g., a mouse or a trackball) by which a user can provide input to the computer. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic, speech, or tactile input.

The systems and techniques described here can be implemented in a computing system that includes a back-end component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), Wide Area Networks (WANs), and the Internet.

The computer system may include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.

It should be understood that various forms of the flows shown above may be used, with steps reordered, added, or deleted. For example, the steps described in the present disclosure may be executed in parallel, sequentially, or in different orders, as long as the desired results of the technical solutions disclosed in the present disclosure can be achieved, and the present disclosure is not limited herein.

The above detailed description should not be construed as limiting the scope of the disclosure. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may be made in accordance with design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present disclosure should be included in the scope of protection of the present disclosure.

Claims

1. A method of loading a scene, comprising:

aiming at a target application in an active state in a plurality of applications, creating a local subspace corresponding to the target application, and storing first scene data corresponding to the target application to the local subspace;

responding to a target scene loading operation aiming at the target application, and acquiring first scene data corresponding to the target scene loading operation in the local subspace and/or second scene data corresponding to the target scene loading operation in the created global subspace; and

and loading a target scene according to the first scene data and/or the second scene data by using the created virtual machine, wherein the plurality of applications are based on a host language, and the virtual machine is based on an embedded language different from the host language.

2. The method of claim 1, wherein the first scene data and the second scene data each comprise a script file for calling a function module corresponding to the script file;

the loading a target scene according to the first scene data and/or the second scene data by using the created virtual machine includes:

and executing script files in the first scene data and the second scene data by using the virtual machine so as to call a function module corresponding to the script file.

3. The method of claim 1, wherein the obtaining first scene data and/or second scene data corresponding to the target scene load operation comprises:

acquiring a sub-operation set corresponding to the target scene loading operation, wherein the sub-operation set comprises at least one first sub-operation and/or at least one second sub-operation; and

and acquiring first scene data corresponding to the at least one first sub-operation in the local subspace and/or second scene data corresponding to the at least one second sub-operation in the global subspace.

4. The method of claim 1, further comprising:

creating an application controller;

creating the plurality of applications and the virtual machine with the application controller; and

creating a global subspace and storing second scene data corresponding to the plurality of applications to the global subspace.

5. The method of claim 1, further comprising:

in response to the target application transitioning from an active state to an inactive state, deleting a local subspace corresponding to the target application.

6. The method of claim 1, further comprising:

deleting the virtual machine if the plurality of applications are deleted.

7. The method of claim 1, wherein the host language comprises a C language or a C + + language and the embedded language comprises a Lua language.

8. An apparatus for loading a scene, comprising:

the system comprises a creating module, a judging module and a processing module, wherein the creating module is used for creating a local subspace corresponding to a target application in an active state in a plurality of applications and storing first scene data corresponding to the target application to the local subspace;

an obtaining module, configured to, in response to a target scene loading operation for the target application, obtain first scene data in the local subspace and corresponding to the target scene loading operation and/or second scene data in the created global subspace and corresponding to the target scene loading operation; and

and the loading module is used for loading the target scene according to the first scene data and/or the second scene data by utilizing the created virtual machine, wherein the plurality of applications are based on a host language, and the virtual machine is based on an embedded language different from the host language.

9. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-7.

10. A non-transitory computer readable storage medium having stored thereon computer instructions for causing the computer to perform the method of any one of claims 1-7.

11. A computer program product comprising a computer program which, when executed by a processor, implements the method according to any one of claims 1-7.