Non-integrated single-engine background rendering method, system and device for multiple applications

Abstract

A non-integrated single-engine background rendering method for multiple applications, comprising: a single engine providing creation and offscreen rendering of an offscreen rendering buffer area, so that the single engine normally operates the rendering process of the whole single engine when separated from the offscreen rendering buffer area, and generates a rendered picture; providing a multi-View rendering output, and isolating input click processing; abstracting a generic View component; providing a cross-process communication mechanism and a general protocol formulation; providing a rendering service library; and executing one-click packaging and project generation.

Description

Non-integrated single-engine background rendering method, system and device for multiple applications

[0001] This application claims priority to the Chinese patent application filed with the China Patent Office on July 14, 2023, with application number 202310870965.5, the entire contents of which are incorporated by reference into this application. Technical Field

[0002] The present application relates to the field of computers, and in particular to a non-integrated single-engine background rendering method, system, and device for multiple applications. Background Art

[0003] In the automotive industry's Human Machine Interface (HMI) scenarios, multiple application functions are separated into independent applications for stability reasons. This ensures that abnormal exits of some applications do not affect other functions. When these independent applications all require engine integration to achieve three-dimensional (3D) rendering capabilities, the typical approach is for each application to integrate the engine separately. This results in multiple engine instances existing at runtime, significantly consuming system resources. How to eliminate the need for separate engine integration for multiple applications while ensuring stability and achieving efficiency and resource conservation is a problem that needs to be solved.

[0004] Summary of the Invention

[0005] This application provides a non-integrated single-engine background rendering method for multiple applications, including:

[0006] The single engine provides off-screen rendering buffer creation and off-screen rendering, allowing it to run the entire single engine rendering process and generate rendered images normally without the external on-screen rendering buffer; provides multi-View rendering output and isolates input click processing; abstracts common View components; provides cross-process communication mechanism and general protocol formulation; provides rendering service library; and performs one-click packaging and project generation.

[0007] The present application also provides a computer-readable storage medium having a computer program stored thereon. When the computer program is executed by a processor, the non-integrated single-engine background rendering method for multiple applications is performed.

[0008] This application also provides a non-integrated single-engine background rendering device for multiple applications, including:

[0009] The memory is configured to store a software application, and the processor is configured to execute the software application. The program of the software application correspondingly executes the non-integrated single-engine background rendering method for multiple applications.

[0010] The present application also provides a non-integrated single-engine background rendering system for multiple applications, including a background service system and multiple foreground application systems. The background service system is configured to package a single engine and a 3D scene, output 3D content to the multiple foreground application systems through cross-process communication between applications, and accept instructions and execute corresponding logic. The single engine of the background service system is configured to support the creation and off-screen rendering of an off-screen rendering buffer, so that the single engine can normally run the entire single-engine rendering process and generate a rendering screen without an external on-screen rendering buffer. The background service system is also configured to provide multi-View rendering output and isolate input click processing. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] FIG1 is an architecture diagram of a non-integrated single-engine background rendering system for multiple applications provided in an embodiment of the present application;

[0012] FIG2 is a schematic diagram of a configuration interface of a non-integrated single-engine background rendering system for multiple applications provided in an embodiment of the present application;

[0013] FIG3 is a schematic diagram of a configuration interface of another non-integrated single-engine background rendering system for multiple applications provided in an embodiment of the present application;

[0014] FIG4 is a schematic diagram of a configuration interface of another non-integrated single-engine background rendering system for multiple applications provided in an embodiment of the present application;

[0015] FIG5 is a schematic diagram of a configuration interface of another non-integrated single-engine background rendering system for multiple applications provided in an embodiment of the present application. DETAILED DESCRIPTION

[0016] The following description is intended to disclose the present application so that those skilled in the art can implement the present application. The embodiments described below are for illustrative purposes only.

[0017] The terms “a” and “an” should be understood as “at least one” or “one or more”, that is, in one embodiment, the number of an element may be one, while in another embodiment, the number of the element may be plural.

[0018] This application relates to a computer program application. This application describes a solution for solving the problems raised in this application, based on a computer program processing flow, by executing a computer program compiled according to the above flow to control or process external or internal objects of the computer. Through the non-integrated single-engine background rendering method for multiple applications in this application, a single engine and 3D scene are packaged into a background service application. Through cross-process communication between applications, other applications are enabled to output 3D content, receive instructions, and execute corresponding logic.

[0019] In the embodiment of the non-integrated single-engine background rendering method for multiple applications described in this application, the single engine is described using a single Unity engine as an example. The single engine can also be applied to other types of single engines. This application is only used as an example in this regard.

[0020] In the embodiment of the non-integrated single-engine background rendering method for multiple applications described in the present application, the off-screen rendering buffer is implemented as a PBuffer Surface. The off-screen rendering buffer can also be implemented as other types. This application is only used as an example in this regard.

[0021] In the embodiment of the non-integrated single-engine background rendering method for multiple applications described in the present application, multiple applications are implemented as multiple Android applications. Multiple applications can also be implemented as other types. This application is only used as an example in this regard.

[0022] The non-integrated single-engine background rendering method for multiple applications includes the following steps:

[0023] S100: A single engine, such as a Unity engine, provides creation of a PBuffer Surface and off-screen rendering, so that the entire single-engine rendering process can be run normally without an external on-screen Surface and a rendering image can be generated.

[0024] S200: Provides multi-View rendering output and isolates input click processing.

[0025] We use the Camera as the output carrier and introduce a Scene-based isolation method to ensure that a single engine can correctly respond to input clicks and convey them to the logic script. At the same time, we also make corresponding modifications to the Unity Graphical User Interface (UGUI) to ensure the correctness of UI input clicks in the case of multiple Views.

[0026] S300: Abstract universal UnityView component.

[0027] S400: Provides cross-process communication mechanism and general protocol formulation.

[0028] S500: providing a rendering service library, for example, providing a universal Android module unity rendering service library.

[0029] S600: Perform one-click packaging and project generation. A new export cross-process option is added. By simply checking the box, you can export the target platform development project corresponding to cross-process rendering, such as an Android project. At the same time, disabling this option will not affect the export of ordinary Android projects.

[0030] In the embodiment of the non-integrated single-engine background rendering method for multiple applications described in the present application, the target platform development project is implemented as an Android project. The target platform development project can also be implemented as other types. This application is only used as an example in this regard.

[0031] As shown in the overall architecture diagram of Figure 1, the background service (such as the unityService background service) and the foreground application 1 and the foreground application 2 interact through cross-process communication or inter-process communication (IPC).

[0032] In the public version of the Unity engine, Unity only supports on-screen rendering, requiring an external on-screen Surface (render buffer) to be provided to the Unity engine for rendering, and the rendered image must be output to the control. By improving step S100, the entire engine rendering process can be run normally and the rendered image can be generated without the external on-screen Surface.

[0033] In the step S200, the corresponding transformation is implemented in the embodiment to isolate the unityUGUI click event processing function and make a corresponding response.

[0034] The component in step S300 is used to receive the 3D image rendered off-screen by the Unity engine, and is associated with the rendered output image in the Unity engine through a Token. In addition, the component in step S300 supports IPC to communicate with the Unity engine.

[0035] The UnityView component is a general-purpose component abstraction at the Android layer. It implements lifecycle management, synchronizes resizing with the Unity engine's rendering output, responds to various input and gesture events, synchronizes logic processing with the Unity engine, and supports independent control of rendering frequency. As a general-purpose component at the Android layer, UnityView can be easily and conveniently embedded into multiple native Android applications.

[0036] In step S400, a protocol for communication between the native application (Application, APP) and the unityService background service is established. With the help of this protocol, the unityService background service can pass the 3D content image output by the camera to the native APP, and the native APP can also send instructions to the unityService to let the engine execute logic.

[0037] Traditional Unity Android projects primarily consist of two modules: the launcher and the UnityLibrary. Native apps must copy the UnityLibrary module into the project. This module contains the engine scene package, which takes up a large amount of space. Furthermore, any changes to the 3D scene require the native app to re-copy the UnityLibrary module. Step S500 adds a new, general-purpose Android module, the Unity Render Service Library, to the existing project. This module is lightweight, containing only general interface protocols and no complex scene content. Native apps only need to integrate it once.

[0038] In an embodiment of the present application, as shown in Figure 2, the non-integrated single-engine background rendering method for multiple applications also includes the following steps: building a 3D scene in the unity engine editor, and then adding the abstract universal UnityView component in step S300: Render Service Renderer to the scene camera, and setting a token as a unique identifier.

[0039] As shown in FIG3 , the non-integrated single-engine background rendering method for multiple applications further includes the following steps: exporting the constructed 3D scene into an Android project in the Unity engine editor, selecting the Export as Render Service option, and invoking Inter-Process Mode.

[0040] As shown in Figure 4, the non-integrated single-engine background rendering method for multiple applications also includes the following steps: calling the target platform integrated development environment (IDE), such as calling Android Studio to open the Android project exported in the above steps, and when it is installed on an electronic device such as a mobile phone or a car computer, the application self-start permission is enabled.

[0041] As shown in FIG5 , the non-integrated single-engine background rendering method for multiple applications further includes the following steps: calling the unity rendering service library and embedding it into the native APP.

[0042] The non-integrated single-engine background rendering method for multiple applications also includes the following steps: calling the UnityView class provided by the Unity rendering service library and setting the token attribute to the unique identifier configured in the previous step, so that the view can render 3D content into the native app. The corresponding code is as follows: Var unityView = UnityView(vpaContainer.context, attrs:null); unityView.init(buildingToken:"vpa", renderFrameIntral:1); vpaContainer.addView(unityView);

[0043] The Unity Render Service uses tokens to bind different 3D scenes to different UnityViews and output rendering results for them. At the same time, native apps can also send events to the Unity Render Service through UnityView for inter-process communication.

[0044] The non-integrated single-engine background rendering method for multiple applications described in the present application, in this embodiment, separates the Unity engine from the Android Activity binding and implements off-screen rendering; integrates the Unity engine into the Android application without forcing full-screen rendering; adds a Unity Render Service as an independent background rendering service; provides an independent Unity Render Service code library for other Android applications to quickly integrate, provides a service call interface and an inter-process communication interface, and provides a UnityView UI component for easy integration into Android applications; Android applications can pull up the Unity Render Service background service and receive rendering results, and can also send click events and other inter-process communication with the Unity Render Service.

[0045] The non-integrated single-engine background rendering method for multiple applications described in this application can use a single engine as a background rendering service based on a cross-process rendering service, and render screens for multiple applications, so that multiple applications can obtain the common capabilities of all engines without integrating the engine into their own applications; it is convenient for app makers to quickly access and is well packaged, so developers only need a small amount of code; it supports off-screen rendering and can output multiple screens at the same time; only one engine instance is started, avoiding the memory overhead brought by multiple engine instances.

[0046] It will be appreciated by those skilled in the art that the embodiments of the present application may be provided in the form of a method, system, or computer program product. Therefore, the present application may take the form of an all-hardware embodiment, an all-software embodiment, or a combination of software and hardware. The method of the present application may be implemented by hardware, software, or a combination of software and hardware. The present application may be implemented in a centralized manner in at least one computer system, or in a decentralized manner by different parts distributed across several interconnected computer systems. Any computer system or other device that can implement the method is applicable. A common combination of hardware and software may be a general-purpose computer system with a computer program installed, which controls the computer system by installing and executing the program so that it operates according to the method.

[0047] The present application may be embedded in a computer program product, which includes all the features that enable the method described herein to be implemented. The computer program product is contained in one or more computer-readable storage media, and the computer-readable storage medium has a computer-readable program code contained therein. According to another aspect of the present application, a computer-readable storage medium is also provided, on which a computer program is stored, and when the computer program is executed by a processor, the steps of the method of the present application are capable of executing. A computer storage medium is a medium for storing a discontinuous physical quantity in a computer memory. Computer storage media include but are not limited to semiconductors, disk memories, magnetic cores, magnetic drums, magnetic tapes, laser discs, non-transitory storage media, etc. Computer storage media are not limited to the aforementioned examples, and the aforementioned examples are merely examples.

[0048] Corresponding to the embodiment of the method of the present application, according to another aspect of the present application, a non-integrated single-engine background rendering system for multiple applications is also provided, which is an application of the non-integrated single-engine background rendering method for multiple applications of the present application in computer program improvement. The system includes a background service system and multiple foreground application systems. The background service system is configured as a packaging engine such as a unity engine (implemented as unity RenderService) and a 3D scene (implemented as unityPlayer), and outputs 3D content to multiple other foreground application systems through cross-process communication between applications (implemented as IPC), and receives instructions and executes corresponding logic.

[0049] In the embodiment of the non-integrated single-engine background rendering system for multiple applications described in this application, the single engine is described using a single Unity engine as an example. The single engine can also be applied to other types of single engines. This application is only used as an example in this regard.

[0050] In the embodiment of the non-integrated single-engine background rendering system for multiple applications described in the present application, the off-screen rendering buffer is implemented as a PBuffer Surface. The off-screen rendering buffer can also be implemented as other types. This application is only used as an example in this regard.

[0051] In the embodiment of the non-integrated single-engine background rendering system for multiple applications described in the present application, multiple applications are implemented as multiple Android applications. Multiple applications can also be implemented as other types. This application is only used as an example in this regard.

[0052] The Unity engine of the background service system is configured to support the creation of PBuffer Surface and off-screen rendering, so that the Unity engine can normally run the rendering process of the entire engine and generate a rendered image without the external on-screen Surface.

[0053] The background service system also provides multi-View rendering output and isolates input click processing; the background service system is provided with a Camera rendering module, which is configured as the output carrier. The background service system is provided with a Scene unit isolation module, which is configured to execute the isolation method based on Scene units to ensure that the engine can correctly respond to input clicks and convey them to the logic script. The background service system is provided with a unity UGUI transformation module, which is configured to make corresponding modifications to the unity UGUI to ensure the correctness of UI input clicks in the case of multiple Unity Views of multiple foreground application systems.

[0054] The backend service system also includes a UnityView component, which is configured to receive 3D images rendered off-screen by the Unity engine. It is associated with the rendered output within the Unity engine via a token and supports IPC communication with the Unity engine. The UnityView component is also configured to perform lifecycle management, synchronize resizing with Unity engine rendering output, respond to various input and gesture events, synchronize logic processing with the Unity engine, and support independent control of rendering frequency.

[0055] The background service system is also provided with a background service communication protocol module, which is configured to provide a cross-process communication mechanism and the formulation of a general protocol, and to formulate a protocol for communication between the native APP and the unityService background service. Through this protocol, the unityService background service transmits the 3D content image output by the camera to the native APP, and the native APP sends instructions to the unityService to allow the engine to execute the logic.

[0056] The background service system is also provided with a rendering service library module. In this embodiment of the present application, the rendering service library module is implemented as a universal Android unity rendering service library module, wherein the universal Android unity rendering service library module only includes a universal interface protocol, so that the native APP is only integrated once.

[0057] The non-integrated, single-engine background rendering system for multiple applications also includes a one-click packaging and project generation module. This module is configured to add a new cross-process export option to the Unity engine. This option, in response to a selected call instruction, exports a target platform development project corresponding to the cross-process rendering, such as an Android project. This option can also be disabled without affecting the export of standard Android projects.

[0058] The non-integrated single-engine background rendering system for multiple applications is further provided with a scene building configuration module, which is configured to build a 3D scene in the unity engine editor, add a Render Service Renderer component to the scene camera, and set a token as a unique identifier.

[0059] The non-integrated single-engine background rendering system for multiple applications is further provided with a scene export module, which is configured to export the constructed 3D scene in the Unity engine editor into an Android project and call Inter-Process Mode.

[0060] The non-integrated single-engine background rendering system for multiple applications is also provided with a target platform integrated development environment module. In the embodiment of the present application, the target platform integrated development environment module is implemented as an Android Studio integrated development module. The Android Studio integrated development module is configured to open the Android project exported by the scene export module, and when installed on an electronic device such as a mobile phone or a car computer, the application self-start permission is enabled.

[0061] The non-integrated single-engine background rendering system for multiple applications is further provided with an implantation module, and the implantation module is configured to implant the unity rendering service library into the native APP.

[0062] The non-integrated single-engine background rendering system for multiple applications also sets a property setting module, which is configured to use the UnityView class in the unity rendering service library and set the token attribute to the token set as a unique identifier in the scene building configuration module, so that this type of view renders 3D content into the native APP.

[0063] The Unity Render Service in this application's non-integrated, single-engine backend rendering system for multiple applications uses tokens to bind different 3D scenes to different UnityViews and output rendering results for them. Native apps can also send events to the Unity Render Service through UnityViews for inter-process communication.

[0064] The non-integrated single-engine background rendering system for multiple applications described in this application, through the architecture and interaction of multiple modules, decouples the Unity engine from the Android Activity and implements off-screen rendering. Integrating the Unity engine into an Android application eliminates the need for forced full-screen rendering. The Unity Player Runtime can be transformed into an independent background service. An independent Unity Render Service code library is provided for rapid integration with other Android applications, providing a service call interface and an inter-process communication interface, while also providing a UnityView UI component for easy integration into Android applications. Android applications can launch the Unity Render Service background service and receive rendering results. They can also send click events and other inter-process communication with the Unity Render Service.

[0065] According to another aspect of the present application, a non-integrated single-engine background rendering device for multiple applications is provided. The non-integrated single-engine background rendering device for multiple applications includes: a software application, a memory for storing the software application, and a processor configured to execute the software application. The software application program can correspondingly execute the steps of the non-integrated single-engine background rendering method for multiple applications of the present application.

[0066] The combination of hardware and software can be a general-purpose computer system with a computer program. When the program is loaded and executed, it controls the computer system to perform the non-integrated single-engine background rendering method for multiple applications disclosed in this application.

[0067] The present application has been described with reference to the flowcharts and / or block diagrams of the methods, systems, and computer program products according to the present application. Each block in the flowcharts and / or block diagrams, and combinations of blocks in the flowcharts and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions (the instructions are passed through the processor of the computer or other programmable data processing device) generate means for implementing the functions specified in one or more blocks of the flowcharts and / or block diagrams.

Claims

1. A non-integrated single-engine background rendering method for multiple applications, comprising: The single engine provides creation of an off-screen rendering buffer and off-screen rendering, so that the single engine runs the entire single engine rendering process and generates a rendering picture without an external on-screen rendering buffer; Provides multiple View rendering outputs and isolates input click processing; Abstract generic View component; Provide cross-process communication mechanism and general protocol formulation; Provide rendering service library; as well as Perform one-click packaging and project generation.

2. The non-integrated single-engine background rendering method for multiple applications according to claim 1, further comprising: Build a 3D scene in the engine editor, add a Render Service Renderer component to the scene camera, and set the token as the unique identifier.

3. The non-integrated single-engine background rendering method for multiple applications as claimed in claim 2, further comprising: In the engine editor, the constructed 3D scene is exported as a target platform development project.

4. The non-integrated single-engine background rendering method for multiple applications as claimed in claim 3, further comprising: Call the target platform integrated development environment to open the exported target platform development project.

5. The non-integrated single-engine background rendering method for multiple applications as claimed in claim 4, further comprising: The rendering service library is called and embedded into the native application APP.

6. The non-integrated single-engine background rendering method for multiple applications as claimed in claim 5, further comprising: Call the View class provided in the rendering service library, set the token attribute to the configured token as the unique identifier, and render the 3D content to the native APP.

7. The non-integrated single-engine background rendering method for multiple applications as claimed in any one of claims 1 to 6, wherein: The View component is used to receive the 3D image rendered off-screen by the single engine, is associated with the rendering output image in the single engine through a token, and supports the cross-process communication mechanism to communicate with the single engine.

8. The non-integrated single-engine background rendering method for multiple applications as claimed in any one of claims 1 to 6, further comprising: The View component performs lifecycle management, synchronizes the rendering output of the single engine with size changes, responds to various input and gesture events and synchronizes the single engine for logic processing, and supports independent control of rendering frequency.

9. The non-integrated single-engine background rendering method for multiple applications as claimed in any one of claims 1 to 6, wherein: The single engine is a single Unity engine.

10. The non-integrated single-engine background rendering method for multiple applications as claimed in any one of claims 1 to 6, wherein: The multiple applications are multiple Android applications.

11. The non-integrated single-engine background rendering method for multiple applications as claimed in any one of claims 4 to 6, wherein: The target platform development project is an Android project, and the target platform integrated development environment is Android Studio.

12. A computer-readable storage medium storing a computer program, wherein when the computer program is executed by a processor, the non-integrated single-engine background rendering method for multiple applications according to any one of claims 1 to 11 is executed.

13. A non-integrated single-engine background rendering device for multiple applications, comprising: a memory configured to store software applications; A processor is configured to execute the software application, wherein the program of the software application correspondingly executes the non-integrated single-engine background rendering method for multiple applications as described in any one of claims 1 to 11.

14. A non-integrated single-engine background rendering system for multiple applications, comprising a background service system and multiple foreground application systems, wherein the background service system is configured to package a single engine and a three-dimensional 3D scene, output 3D content for the multiple foreground application systems through cross-process communication between applications, and accept instructions and execute corresponding logic, wherein: The single engine of the background service system is configured to support the creation and off-screen rendering of an off-screen rendering buffer, runs the entire single-engine rendering process and generates a rendering screen without an external on-screen rendering buffer. The background service system is also configured to provide multi-View rendering output and isolate input click processing.

15. The non-integrated single-engine background rendering system for multiple applications as claimed in claim 14, wherein: The background service system is also provided with a Camera rendering module, a View component and a background service communication protocol module, wherein the Camera rendering module is configured as an output carrier, the View component is configured to receive the 3D image rendered off-screen by a single engine, is associated with the rendering output image in the single engine through a token, and supports the cross-process communication to communicate with the single engine, and the background service communication protocol module is configured to provide a cross-process communication mechanism and the formulation of a general protocol, and to formulate a protocol for communication between the native application APP and the background service.

16. The non-integrated single-engine background rendering system for multiple applications as claimed in claim 15 is further provided with a rendering service library module, wherein the rendering service library module only includes a universal interface protocol so that the native APP is integrated only once.

17. The non-integrated single-engine background rendering system for multiple applications as claimed in claim 15, wherein: The View component is also configured to: perform lifecycle management, synchronize the single engine rendering output with size changes, respond to multiple input and gesture events and synchronize the single engine for logic processing, and support independent control of rendering frequency.

18. The non-integrated single-engine background rendering system for multiple applications as claimed in claim 15, wherein: The background service transmits the 3D content image output by the camera to the native APP, and the native APP sends instructions to the background service to let the single engine execute logic.

19. The non-integrated single-engine background rendering system for multiple applications as claimed in claim 14, further comprising a one-click packaging and project generation module, wherein the one-click packaging and project generation module is configured to add a new export cross-process option in the single engine.

20. The non-integrated single-engine background rendering system for multiple applications as claimed in any one of claims 14 to 19, further comprising a scene building configuration module, wherein the scene building configuration module is configured to build a 3D scene in an engine editor, add a Render Service Renderer component to a scene camera, and set a token as a unique identifier.

21. The non-integrated single-engine background rendering system for multiple applications as claimed in any one of claims 14 to 19, wherein: The single engine is a single Unity engine, and the View component is a UnityView component.

22. The non-integrated single-engine background rendering system for multiple applications as claimed in any one of claims 14 to 19, wherein: The multiple applications are multiple Android applications.

Images