Runtime editor design method based on 3D scene engine

Abstract

The invention particularly relates to a runtime editor design method based on a 3D scene engine. According to the runtime editor design method based on the 3D scene engine, a dynamic scene building system, a scene data exchange module and an expansion tool system are constructed, key interaction logic is designed, an LOD system special for an edition state is developed, rendering optimization is achieved, an object pool technology is adopted to manage scene entities of high-frequency operation, memory blocks are pre-allocated to reduce runtime allocation, and the design efficiency of the runtime editor is improved. And memory management is realized. According to the runtime editor design method based on the 3D scene engine, the engine operation logic is simplified, the learning cost of non-developers is greatly reduced through a visual interface and instant feedback, the editing process is simplified, the development process is accelerated, and then the team cooperation efficiency is improved.

Description

Technical Field

[0001] The present invention relates to the field of digital twin technology, and in particular to a runtime editor design method based on a 3D scene engine. Background Art

[0002] Modern commercial 3D engine editors are incredibly powerful, covering every aspect of game development and scene editing, providing developers with a comprehensive toolset. These editors offer a wide range of development capabilities, including comprehensive scene management and editing, advanced material and texture editing, animation systems, scripting and logic programming, physics and particle systems, sound and music management, user interface design, multiplayer collaboration and version control, and plugin and extension support.

[0003] As commercial game engines continue to mature, developers are able to build and optimize complex game content using powerful editors. However, with the increasing refinement of project development work, more and more non-developer professionals, such as artists and level designers (level editors), are required to actively participate in the entire development process. These professionals often possess excellent artistic and design skills, but are not necessarily proficient in complex engine operations. Therefore, the high complexity and technical barriers of traditional editors often become obstacles to their work.

[0004] At the same time, in actual digital twin project delivery, it is sometimes necessary to rapidly iterate scenarios based on user needs and allow users to partially adjust the scenarios. In these cases, native editors are overly complex and cumbersome, with a high learning curve, requiring continuous iterative optimization by developers. A simple runtime editor that allows users to modify packaged scenarios would simplify this problem.

[0005] Based on the above problems, the present invention proposes a runtime editor design method based on a 3D scene engine. Summary of the Invention

[0006] In order to overcome the defects of the prior art, the present invention provides a simple and efficient runtime editor design method based on a 3D scene engine.

[0007] The present invention is achieved through the following technical solutions:

[0008] A runtime editor design method based on a 3D scene engine includes the following steps:

[0009] Step S1: Build a dynamic scene building system

[0010] Through the matrix transformation from screen coordinates to world coordinates, precise positioning of drag instantiation is achieved;

[0011] Develop a quaternion-based composite transformation tool, implement a quaternion-based dual-coordinate system Gizmo, support local / global coordinate system switching, implement Gizmo instanced drawing, and complete all axial drawing with a single DrawCall;

[0012] Build a material parameter reflection system, declare adjustable parameter macros in Shader, and expose adjustable parameters through HLSL / CG shader macro definitions;

[0013] Step S2: Build scene data exchange module

[0014] Introducing the RapidJSON library through JSON serialization and using SIMD to accelerate parsing;

[0015] Compare the difference with the serialized saved content, use Myers'Diff algorithm to achieve O(ND) time complexity difference detection, and only export the modified parts;

[0016] Step S3: Build an extension tool system

[0017] By refactoring the parsing logic of the blueprint editing state, we built a blueprint runtime editor and developed a streamlined node system that supports event subscription, limited API, and automatic wiring.

[0018] Event subscription: bind events through the delegation mechanism to achieve multicast delegation;

[0019] Limited API: Design a sandbox execution environment, limit the set of available functions, and customize the encapsulation of no less than 50 commonly used function nodes (including movement, rotation, triggering animation, etc.);

[0020] Automatic wiring: Extends the A* state to the position vectors of all nodes, uses a priority queue to manage candidate layouts, and implements node layout based on a variant of the A* algorithm;

[0021] Step S4: Design key interaction logic

[0022] Use LRU cache strategy to manage local resource pool, and use memory mapped file to store historical records of more than 1000 steps; Step S5, performance optimization

[0023] Developed a dedicated LOD system for editing mode, which automatically reduces the rendering accuracy of non-focus objects when the Gizmo is activated to achieve rendering optimization;

[0024] Object pool technology is used to manage scene entities with high-frequency operations, pre-allocate memory blocks to reduce runtime allocation, and implement memory management.

[0025] In step S1, ray collision detection is used ( –Trumbore) algorithm for accurate triangle-level collision detection. By constructing the inverse transformation matrix from NDC to World, a kinematic constraint algorithm for continuous dragging in screen space is implemented, further implementing the matrix transformation from screen coordinates to world coordinates to achieve precise positioning of drag instantiation.

[0026] In step S1, during the instantiation drawing of the Gizmo, a plane projection algorithm is used to implement translation operation, the projection plane equation is constructed by combining the camera forward vector and the initial contact point, the rotation is optimized by spherical interpolation, and a Squad curve is used to achieve smooth rotation transition.

[0027] In step S1, GPU resource readback technology is used to implement PBO (Pixel Buffer Object) asynchronous readback and real-time parameter feedback.

[0028] In step S2, a scenario description specification is designed, a schema verification file is defined, the scenario and component content are serialized and stored according to the description specification, and assets are referenced using UUIDv4 identifiers.

[0029] In step S4, a priority loading queue is designed, and the loading order is dynamically adjusted based on frustum clipping to achieve streaming loading;

[0030] Construct a bidirectional operation linked list, record the reverse operation instructions for each operation, and implement the withdrawal system.

[0031] A runtime editor based on a 3D scene engine is designed based on the above method and uses a layered architecture to achieve logical decoupling, including an interaction layer, a logic layer, a rendering layer, and a data layer.

[0032] The interaction layer is responsible for building a dynamically scalable UI framework based on the Slate framework and receiving user input commands through the event bus.

[0033] The logic layer is responsible for designing the scene operation instruction stack and supporting operation rollback / redo. It uses the ECS architecture to manage scene entities, and entity attributes are exposed to the UI through the reflection system.

[0034] The rendering layer is responsible for integrating the OpenGL / DirectX rendering pipeline and isolating the editing and running rendering modes through FrameGraph. The Gizmo tool uses deferred rendering technology and is drawn independently of the main scene.

[0035] The data layer is responsible for building an incremental scene snapshot system, implementing binary incremental storage based on Protobuf, and supporting version merging and conflict resolution.

[0036] A runtime editor design device based on a 3D scene engine comprises a memory and a processor; the memory is used to store a computer program, and the processor is used to implement the above method steps when executing the computer program.

[0037] A readable storage medium stores a computer program, and when the computer program is executed by a processor, the above method steps are implemented.

[0038] The beneficial effects of the present invention are as follows: the runtime editor design method based on the 3D scene engine not only streamlines the engine operation logic, but also greatly reduces the learning cost of non-developers through an intuitive interface and instant feedback, and also simplifies the editing process, accelerates the development process, and thus improves the efficiency of team collaboration, ultimately bringing higher quality creative output and faster iteration speed to the project. BRIEF DESCRIPTION OF THE DRAWINGS

[0039] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0040] Attachment Figure 1 This is a schematic diagram of a runtime editor design method based on a 3D scene engine according to the present invention. DETAILED DESCRIPTION

[0041] In order to enable those skilled in the art to better understand the technical solutions of the present invention, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the embodiments of the present invention. Obviously, the embodiments described are only some embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work should fall within the scope of protection of the present invention.

[0042] The runtime editor design method based on the 3D scene engine includes the following steps:

[0043] Step S1: Build a dynamic scene building system

[0044] Through the matrix transformation from screen coordinates to world coordinates, precise positioning of drag instantiation is achieved;

[0045] Develop a quaternion-based composite transformation tool, implement a quaternion-based dual-coordinate system Gizmo, support local / global coordinate system switching, implement Gizmo instanced drawing, and complete all axial drawing with a single DrawCall;

[0046] Build a material parameter reflection system, declare adjustable parameter macros in Shader, and expose adjustable parameters through HLSL / CG shader macro definitions;

[0047] Step S2: Build scene data exchange module

[0048] Introducing the RapidJSON library through JSON serialization and using SIMD to accelerate parsing;

[0049] Compare the difference with the serialized saved content, use Myers'Diff algorithm to achieve O(ND) time complexity difference detection, and only export the modified parts;

[0050] Step S3: Build an extension tool system

[0051] By refactoring the parsing logic of the blueprint editing state, we built a blueprint runtime editor and developed a streamlined node system that supports event subscription, limited API, and automatic wiring.

[0052] Event subscription: bind events through the delegation mechanism to achieve multicast delegation;

[0053] Limited API: Design a sandbox execution environment, limit the set of available functions, and customize the encapsulation of no less than 50 commonly used function nodes (including movement, rotation, triggering animation, etc.);

[0054] Automatic wiring: Extends the A* state to the position vectors of all nodes, uses a priority queue to manage candidate layouts, and implements node layout based on a variant of the A* algorithm;

[0055] Step S4: Design key interaction logic

[0056] Use LRU cache strategy to manage local resource pool, and use memory mapped file to store historical records of more than 1000 steps; Step S5, performance optimization

[0057] Developed a dedicated LOD system for editing mode, which automatically reduces the rendering accuracy of non-focus objects when the Gizmo is activated to achieve rendering optimization;

[0058] Object pool technology is used to manage scene entities with high-frequency operations, pre-allocate memory blocks to reduce runtime allocation, and implement memory management.

[0059] In step S1, ray collision detection is used ( –Trumbore) algorithm for accurate triangle-level collision detection. By constructing the inverse transformation matrix from NDC to World, a kinematic constraint algorithm for continuous dragging in screen space is implemented, further implementing the matrix transformation from screen coordinates to world coordinates to achieve precise positioning of drag instantiation.

[0060] In step S1, during the instantiation drawing of the Gizmo, a plane projection algorithm is used to implement translation operation, the projection plane equation is constructed by combining the camera forward vector and the initial contact point, the rotation is optimized by spherical interpolation, and a Squad curve is used to achieve smooth rotation transition.

[0061] In step S1, GPU resource readback technology is used to implement PBO (Pixel Buffer Object) asynchronous readback and real-time parameter feedback.

[0062] In step S2, a scenario description specification is designed, a schema verification file is defined, the scenario and component content are serialized and stored according to the description specification, and assets are referenced using UUIDv4 identifiers.

[0063] In step S4, a priority loading queue is designed, and the loading order is dynamically adjusted based on frustum clipping to achieve streaming loading;

[0064] Construct a bidirectional operation linked list, record the reverse operation instructions for each operation, and implement the withdrawal system.

[0065] The runtime editor based on the 3D scene engine is designed based on the above method and adopts a layered architecture to achieve logical decoupling, including the interaction layer, logic layer, rendering layer and data layer;

[0066] The interaction layer is responsible for building a dynamically scalable UI framework based on the Slate framework and receiving user input commands through the event bus.

[0067] The logic layer is responsible for designing the scene operation instruction stack and supporting operation rollback / redo. It uses the ECS architecture to manage scene entities, and entity attributes are exposed to the UI through the reflection system.

[0068] The rendering layer is responsible for integrating the OpenGL / DirectX rendering pipeline and isolating the editing and running rendering modes through FrameGraph. The Gizmo tool uses deferred rendering technology and is drawn independently of the main scene.

[0069] The data layer is responsible for building an incremental scene snapshot system, implementing binary incremental storage based on Protobuf, and supporting version merging and conflict resolution.

[0070] The runtime editor based on the 3D scene engine is run as follows:

[0071] 1) Start the system

[0072] Start the application that contains the runtime editor. Ensure that the system is in running mode so that the user can view the current state of the application in real time.

[0073] 2) Access the runtime editor

[0074] Open the editor for real-time editing. You can edit scenes by dragging, resizing, adding, or removing objects from the scene. Users can manipulate objects directly within the application window. You can also edit properties: modifying object attributes (such as position, rotation, scale, material, and more). Use the Properties panel to adjust various settings for a selected object.

[0075] 3) After completing your edits, immediately see the changes in your app or game. The instant feedback module updates the display in real time, ensuring that your changes are reflected immediately. Use debugging tools to monitor your edits, identify any issues, and roll back changes at any time.

[0076] 4) Data persistence

[0077] Save edits. During the editing process, the system automatically saves your changes. If necessary, you can also manually save the current editing state. Save options: Select "Save" or "Save" in the editor to save the current edits to a persistent local file. If the application or game needs to be restarted, the system will load the user's previously saved edits from the data persistence module so that editing can continue.

[0078] 5) Complete editing

[0079] Save and exit to ensure all edits are saved, then close the runtime editor. If desired, you can choose to save the current session state for later editing. Verify the final results: After editing, verify that all changes are as expected to ensure that the application or game functions and behaves correctly.

[0080] The runtime editor based on the 3D scene engine will provide the following functions at runtime:

[0081] 1) Scene building function

[0082] ① Provide basic scene elements, such as static mesh objects, light sources, etc. Objects can be placed in the corresponding positions of the scene through simple drag and drop operations.

[0083] ② Provide a certain amount of model library and material library, which can be directly used in the scene.

[0084] ③ Users can quickly build scenes by dragging and dropping. The position, scale, material, and other parameters of objects in the scene are exposed and can be modified. A runtime Gizmo tool is also provided, allowing direct manipulation of Actor transformations, alignment, and scaling. These object position-related properties are dynamically modified in real time. Mouse dragging is linked to controlling objects; press, drag, and release to place.

[0085] ④ Provide Cesium terrain base, expose URL and other basic configuration parameters.

[0086] ⑤ Provides runtime functional windows similar to the original UE editor, including a world outline, actor details, and a content browser. These include a flexibly expandable menu bar, draggable toolbars, list components, a flexibly expandable sidebar, window title bars, viewport resizing, multi-window implementation, and more. The framework logic is based on a main widget, using a grid-nested name slot and grid panel for overall layout. This allows for toolbars, menu bars, sidebars, and menu nesting, and uses Docker tabs to switch between multiple menus at the top.

[0087] ⑥ Provides a simplified material editor window that can configure the parameters of material instances and directly assign materials to Actors in the scene by dragging and dropping.

[0088] 2) Scene save, export and import functions

[0089] Allows users to export scenes built in the Runtime Editor to a format recognizable by the native editor. The exported scene contains all necessary asset information and can be seamlessly imported into the normal editor for secondary development. The exported scene format is stored using JSON descriptions.

[0090] 3) Editor Tools / Features

[0091] ① Weather system, which supports manual configuration of basic weather effects in the scene.

[0092] ②Simple sequence recording tool.

[0093] ③Simplified blueprint editing function, providing blueprint editing functions for some key Actors.

[0094] ④ Editing and undoing function: any operation in the scene can be undone by pressing the shortcut key.

[0095] ⑤Model import function, you can import model files in basic formats (fbx, obj, etc.)

[0096] ⑥ Load the model from the model library, use the stream form to request data from the library, and cache it locally

[0097] The runtime editor design device based on the 3D scene engine includes a memory and a processor; the memory is used to store a computer program, and the processor is used to implement the above method steps when executing the computer program.

[0098] The readable storage medium stores a computer program, and the computer program implements the above method steps when executed by a processor.

[0099] Compared with the existing technology, this runtime editor design method based on the 3D scene engine has the following characteristics:

[0100] 1.) Instant feedback and rapid iteration

[0101] Any changes made by users during runtime (such as scene layout, material changes, script adjustments, etc.) are immediately reflected in the scene. This instant feedback reduces the waiting time in traditional development and improves development efficiency. Developers can quickly try out different design solutions and immediately test their effects in the real environment.

[0102] 2) Enhanced user experience

[0103] To reduce the learning curve for first-time users, runtime editors are typically designed to be more intuitive and easy to use, allowing non-developers such as artists and level designers to easily get started and work efficiently. This reduces reliance on technical skills, allowing creators to focus on creative expression. Furthermore, runtime editors often have simpler interfaces and more intuitive operations than traditional editors, making them suitable for users unfamiliar with complex engine editors.

[0104] 3) Real-time debugging and troubleshooting

[0105] Developers can debug and modify scripts or logic directly while the scene is running, without having to stop or restart the application. This debugging method is particularly helpful for dealing with issues involving complex states or interactions, allowing them to be quickly located and resolved. Without the need for frequent game restarts, developers can work continuously, reducing interruptions and improving debugging and development efficiency.

[0106] 4) Flexible development environment

[0107] The runtime editor can be customized to meet project needs, supporting specific development workflows or unique project requirements. This flexibility makes it suitable for a wide range of engineering projects. Developers can freely explore creative possibilities at runtime, unconstrained by traditional development workflows, and inspire more innovative design solutions.

[0108] 5) Improved final product quality

[0109] By enabling real-time testing and adjustments in real-world environments, developers can more accurately optimize the user experience and ensure the quality of the final product. Through rapid iteration and efficient collaboration, the runtime editor can significantly shorten development cycles and reduce development costs.

[0110] The embodiment described above is only one specific implementation of the present invention. Common changes and substitutions made by those skilled in the art within the scope of the technical solution of the present invention should be included in the protection scope of the present invention.

Claims

1. A runtime editor design method based on a 3D scene engine, characterized by: The following steps are involved: Step S1: Build a dynamic scene building system Through the matrix transformation from screen coordinates to world coordinates, precise positioning of drag instantiation is achieved; Develop a quaternion-based composite transformation tool, implement a quaternion-based dual-coordinate system Gizmo, support local / global coordinate system switching, implement Gizmo instanced drawing, and complete all axial drawing with a single DrawCall; Build a material parameter reflection system, declare parameter macros with adjustment permissions in Shader, and expose the parameters with adjustment permissions through HLSL / CG shader macro definitions; Step S2: Build scene data exchange module Introducing the RapidJSON library through JSON serialization and using SIMD to accelerate parsing; Compare the difference with the serialized saved content, use Myers'Diff algorithm to achieve O(ND) time complexity difference detection, and only export the modified parts; Step S3: Build an extension tool system By refactoring the parsing logic of the blueprint editing state, we built a blueprint runtime editor and developed a streamlined node system that supports event subscription, limited API, and automatic wiring. Event subscription: bind events through the delegation mechanism to achieve multicast delegation; Limited API: Design a sandbox execution environment, limit the set of functions with call permissions, and customize the encapsulation of no less than 50 commonly used function nodes; Automatic wiring: Extends the A* state to the position vectors of all nodes, uses a priority queue to manage candidate layouts, and implements node layout based on a variant of the A* algorithm; Step S4: Design key interaction logic Adopt LRU cache strategy to manage local resource pool and use memory mapped file to store historical records of more than 1000 steps; Step S5: Performance optimization Developed a dedicated LOD system for editing mode, which automatically reduces the rendering accuracy of non-focus objects when the Gizmo is activated to achieve rendering optimization; Object pool technology is used to manage scene entities with high-frequency operations, pre-allocate memory blocks to reduce runtime allocation, and implement memory management.

2. The runtime editor design method based on a 3D scene engine according to claim 1, characterized in that: In step S1, a ray collision detection algorithm is used to achieve accurate triangle-level collision detection. By constructing the inverse transformation matrix from NDC to World, a kinematic constraint algorithm for continuous dragging in screen space is implemented, and then a matrix transformation from screen coordinates to world coordinates is implemented to achieve precise positioning of drag instantiation.

3. The runtime editor design method based on a 3D scene engine according to claim 2, characterized in that: In step S1, during the instantiation drawing of the Gizmo, a plane projection algorithm is used to implement translation operation, the projection plane equation is constructed by combining the camera forward vector and the initial contact point, the rotation is optimized by spherical interpolation, and a Squad curve is used to achieve smooth rotation transition.

4. The runtime editor design method based on a 3D scene engine according to claim 1, characterized in that: In step S1, GPU resource readback technology is used to implement PBO asynchronous readback and real-time parameter feedback.

5. The runtime editor design method based on a 3D scene engine according to claim 1, characterized in that: In step S2, a scenario description specification is designed, a schema verification file is defined, the scenario and component content are serialized and stored according to the description specification, and assets are referenced using UUIDv4 identifiers.

6. The runtime editor design method based on a 3D scene engine according to claim 1, characterized in that: In step S4, a priority loading queue is designed, and the loading order is dynamically adjusted based on frustum clipping to achieve streaming loading; Construct a bidirectional operation linked list, record the reverse operation instructions for each operation, and implement the withdrawal system.

7. A runtime editor design system based on a 3D scene engine, characterized by: Designed based on the method described in any one of claims 1 to 6, using a layered architecture to achieve logical decoupling, including an interaction layer, a logic layer, a rendering layer, and a data layer; The interaction layer is responsible for building a dynamically scalable UI framework based on the Slate framework and receiving user input commands through the event bus. The logic layer is responsible for designing the scene operation instruction stack and supporting operation rollback / redo. It uses the ECS architecture to manage scene entities, and entity attributes are exposed to the UI through the reflection system. The rendering layer is responsible for integrating the OpenGL / DirectX rendering pipeline and isolating the editing and running rendering modes through FrameGraph. The Gizmo tool uses deferred rendering technology and is drawn independently of the main scene. The data layer is responsible for building an incremental scene snapshot system, implementing binary incremental storage based on Protobuf, and supporting version merging and conflict resolution.

8. A runtime editor design device based on a 3D scene engine, characterized by: The method comprises a memory and a processor; the memory is used to store a computer program, and the processor is used to implement the method steps according to any one of claims 1 to 6 when executing the computer program.

9. A readable storage medium, characterized in that: The readable storage medium stores a computer program, which, when executed by a processor, implements the method steps according to any one of claims 1 to 6.

Images