A Highly Dynamic 3D Service Runtime Reconstruction System and Method Based on Scene Patch Transactions

By using a scenario-patch transaction-based high-dynamic 3D service runtime reconstruction system, the problems of target consistency and recoverability of reconstruction requests in high-dynamic edge-cloud edge-device systems are solved, the verifiability and auditability of 3D services are realized, and the overhead of redundant planning is reduced.

CN123067894APending Publication Date: 2026-11-10HARBIN INST OF TECH
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611205009.5
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-10
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Existing 3D service reconstruction technologies are insufficient to meet the requirements of highly dynamic edge-cloud-edge-device systems for target consistency, operational verifiability, service continuity, and failure recoverability. Furthermore, direct calls to the 3D engine interface by intelligent agents can lead to problems such as unstable temporary runtime identifiers and inapplicable operation plans due to state changes.

Method used

A highly dynamic 3D service runtime refactoring system based on scenario patch transactions is adopted. Through highly dynamic context-aware components, runtime control link components, scenario guardian orchestration components, service memory reuse components, business unit memory components, scenario patch planning components, and attribute binding components, a scenario patch transaction runtime component is formed to realize the transformation of refactoring requests into scenario patch transactions with scope, pre-state, invariants, and rollback plans.

Benefits of technology

It achieves verifiability, recoverability, and auditability of runtime changes in 3D services, reduces the overhead of redundant planning, improves the consistency and reusability of target binding, and avoids the problem of uncontrollable state.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123067894A_ABST
    Figure CN123067894A_ABST
Patent Text Reader

Abstract

This invention provides a highly dynamic 3D service runtime reconstruction system and method based on scene patch transactions, belonging to the technical field of highly dynamic edge-cloud-edge-device 3D service runtime scene reconstruction. In this system, a scene guardian orchestration component receives reconstruction requests; a highly dynamic context-aware component forms a context snapshot; a service memory reuse component recalls and sorts reusable scene patch templates; a business unit memory component parses stable business units into a current runtime object set; a scene patch planning component generates scene patches or attribute change task contracts; an attribute binding component completes secure runtime attribute binding; and a scene patch transaction execution component performs patch standardization, target expansion, state drift checks, verification, execution, validation, rollback, and auditing. A runtime control link component is used to establish control links between the cloud, edge nodes, and terminals. This invention improves the reusability, verifiability, recoverability, and auditability of reconstruction.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to a highly dynamic 3D service runtime reconstruction system and method based on scene patch transactions, belonging to the field of highly dynamic edge cloud edge-end 3D service runtime scene reconstruction technology. Background Technology

[0002] With the development of metaverse, digital twins, extended reality collaboration, virtual teaching, industrial simulation, and immersive interactive applications, 3D services are gradually shifting from static content display to continuously running, interacting, and evolving service models. In such 3D services, scene objects, region structures, object relationships, user viewpoints, interaction states, and service semantics collectively constitute the runtime service state. The system needs to make online adjustments to the running 3D scene based on user requests, business events, and system scheduling objectives.

[0003] Highly dynamic edge-cloud-edge-device 3D services are typically supported collaboratively by the cloud, edge nodes, and terminals. The cloud is used for complex inference, historical knowledge management, and cross-scene policy generation; edge nodes provide low-latency access, state synchronization, security control, and local verification; and terminals provide immersive display, interactive data acquisition, local rendering, and object manipulation within the 3D engine. In this architecture, network latency, bandwidth status, edge node load, terminal computing power, terminal frame rate, user session state, scene state version, and object state version are all dynamically changing.

[0004] Existing 3D scene adjustment technologies typically employ manual script editing, standalone editor operations, or remote tool invocation to perform runtime modifications. These methods struggle to meet the requirements of highly dynamic edge-cloud 3D services for target consistency, operational verifiability, service continuity, and failure recoverability. While runtime refactoring requests ultimately manifest as low-level operations such as object movement, rotation, scaling, attribute updates, cloning, hiding, or relationship updates, their actual execution process requires simultaneously handling issues such as determining the target object set, binding business units, regional semantic constraints, collision constraints, boundary constraints, reachability constraints, viewpoint visibility constraints, state version drift, and failure rollback.

[0005] With the development of large-scale models and intelligent agent technology, it has become possible to use intelligent agents to understand and reconstruct targets and generate 3D scene operation plans. However, relying solely on intelligent agents to directly call the 3D engine interface still has significant drawbacks: the planning, verification, execution, and supervision phases may work based on different sets of targets; temporary runtime identifiers in the 3D engine lack cross-session stability; natural language or event targets lack directly verifiable pre-states, post-states, and invariant constraints; if failed operations, temporary object identifiers, and error states are written to long-term memory, it will cause subsequent target binding errors; and when the state changes in the cloud, edge nodes, and terminals, the generated operation plan may no longer meet the current execution conditions.

[0006] Therefore, a runtime refactoring method for highly dynamic edge-cloud-edge-device 3D services is needed. This method transforms refactoring requests into scenario patch transactions with scope, pre-state, invariants, expected post-state, execution actions, rollback plans, and audit logs. Through highly dynamic context awareness, runtime control links, service memory, business unit memory, scenario patch planning, attribute binding, and transactional operation mechanisms, reusable, verifiable, rollbackable, and auditable runtime scenario refactoring can be achieved. Summary of the Invention

[0007] The purpose of this invention is to solve the problems existing in the prior art, and to provide a highly dynamic 3D service runtime reconstruction system and method based on scene patch transactions.

[0008] The objective of this invention is achieved through the following technical solution:

[0009] A highly dynamic 3D service runtime refactoring system and method based on scene patch transactions includes: a highly dynamic context-aware component, a runtime control link component, a scene guardian orchestration component, a service memory reuse component, a business unit memory component, a scene patch planning component, an attribute binding component, and a scene patch transaction execution component;

[0010] The status output of the runtime control link component is connected to the status input of the highly dynamic context-aware component; the context snapshot output of the highly dynamic context-aware component is connected to the context input of the scene guardian orchestration component; the scheduling output of the scene guardian orchestration component is connected to the scheduling input of the runtime control link component, the service memory reuse component, the business unit memory component, and the scene patch planning component; the candidate template output of the service memory reuse component is connected to the candidate template input of the scene patch planning component; the parsing result output of the business unit memory component is connected to the parsing result input of the service memory reuse component, the scene patch planning component, and the scene patch transaction execution component; the data input / output of the scene patch planning component is connected to the data input / output of the attribute binding component and the scene patch transaction execution component; the attribute read / write end of the attribute binding component is connected to the runtime control link component; the bound attribute patch output of the attribute binding component is connected to the patch input of the scene patch transaction execution component; the scene operation end of the scene patch transaction execution component has a bidirectional data connection with the data input / output of the runtime control link component.

[0011] Preferably, the highly dynamic context-aware component is used to collect network status, edge node status, terminal status and user session status, and read scene status and object status through runtime control link components to form a context snapshot corresponding to the current reconstruction request;

[0012] The runtime control link component is used to establish a control link between the cloud, edge nodes and terminals, and access the 3D engine runtime instance through the 3D engine tray or extended adaptation layer deployed on the terminal side. It provides unified encapsulation for object query, scene reading, relationship reading, object operation, attribute operation, collision checking, boundary checking and state readback.

[0013] The scene guardian orchestration component is used to receive reconstruction requests, perform type determination, ambiguity checking, task routing and limited pre-inspection on the requests, form a current task summary, and schedule the runtime control link component, service memory reuse component, business unit memory component and scene patch planning component according to the current task summary.

[0014] The service memory reuse component is used to recall verified reusable scenario patch templates based on the current task summary, sort the candidate patch templates by reusability, and output the candidate patch template set, sorting results and reuse conditions to the scenario patch planning component.

[0015] The business unit memory component is used to record the stable scene path, object path, member reference, grouping contract, relative layout relationship and business semantic constraints of the business unit. Before the scene patch planning, the record is parsed into the business unit parsing result, and before the transaction is executed, the current runtime object set, version information and business unit binding summary in the business unit parsing result are refreshed according to the current scene state.

[0016] The scenario patch planning component is used to generate ordinary scenario patches, attribute change task contracts, repair patches, or rejection evidence based on the refactoring request, current task summary, context snapshot, candidate patch template sorting results, business unit parsing results, and current scenario evidence read by the runtime control link component and scheduled by the scenario guardian orchestration component.

[0017] The attribute binding component receives the attribute change task contract generated by the scene patch planning component, reads the component type, current attribute value and writable attribute of the target object through the runtime control link component, binds the attribute change intent as a safe writable attribute, generates a single object attribute update patch or a batch attribute update patch and submits it to the scene patch transaction execution component. If the binding fails, it performs a limited number of rereading and rebinding. If it still fails, it returns the reason for the binding failure to the scene patch planning component.

[0018] The scenario patch transaction execution component is used to normalize and target reference deterministic expansion of scenario patches. It performs state drift checks and pre-execution verification before the transaction is written, executes the scenario patch transaction after the verification is passed, and performs post-execution verification, failure repair, failure rollback, compensation, and audit logging.

[0019] Preferably, the service memory reuse component includes a service memory library and a candidate patch sorter. The candidate patch template output of the service memory library is connected to the candidate input of the candidate patch sorter. The sorting result output of the candidate patch sorter serves as the candidate template output of the service memory reuse component and is connected to the candidate template input of the scene patch planning component.

[0020] The service memory is used to store reusable scene patch templates that have been successfully executed and verified, and to recall a set of candidate patch templates based on the current task summary generated by the scene guardian orchestration component, and output the set of candidate patch templates to the candidate patch sorter.

[0021] The candidate patch sorter is used to receive the set of candidate patch templates output by the service memory and the current task summary generated by the scenario guardian orchestration component. It combines the current context snapshot formed by the high dynamic context awareness component and the business unit parsing result formed by the business unit memory component, extracts the scenario state version from the current context snapshot, and sorts the candidate patch templates according to semantic similarity, target scope consistency, parameter substitutability, verification strategy matching degree, and state freshness.

[0022] Preferably, the service memory reuse component only converts scene patches that have been successfully executed, verified, have a stable scope and do not contain temporary runtime identifiers, historical absolute coordinates and expired versions into reusable scene patch templates and writes them into long-term memory.

[0023] Preferably, the business unit memory component outputs the business unit parsing result as the current runtime object set, object role, membership relationship, relative transformation, constraint condition, version information and business unit binding summary, and outputs them to the scene patch planning component and the scene patch transaction execution component respectively.

[0024] Preferably, the attribute binding component binds the attribute change intent to at least one runtime attribute among enabled state, display state, material state, interactive state, rendering state, collision state, or business state, within the scope defined by the list of secure writable attributes, based on the set of available attribute operations provided by the runtime control link component and the set of currently writable attributes of the target object.

[0025] Preferably, after completing the scenario patch normalization and target reference deterministic expansion, and before the transaction is written, the scenario patch transaction execution component compares the current scenario state version and target object version with the base version of the scenario patch record. When the versions are inconsistent, it determines that a state drift has occurred and triggers target rebinding, reverification, replanning, or rejection of execution. When the state drift occurs during the transaction writing process or the verification stage after execution and a consistent state cannot be restored, a rollback or compensation is triggered.

[0026] Preferably, when the scenario patch transaction execution component fails to perform pre-execution verification, it returns at least one of the following to the scenario patch planning component: blocking object, blocking reason, boundary evidence, collision evidence, invariant evidence, pre-execution state, expected post-execution state, and original tool evidence.

[0027] Preferably, when the scenario patch transaction execution component fails to verify after execution, it returns the failure evidence to the scenario patch planning component, which then performs patch generation, evidence completion, or verification objection handling. If the patch cannot be repaired, the scenario patch transaction execution component performs at least one of the following: rejection execution, rollback compensation, or audit record.

[0028] The reconstruction method for a highly dynamic 3D service runtime reconstruction system based on scenario patching transactions includes the following steps:

[0029] Step 1: The Scene Guardian Orchestration Component receives the refactoring request; the High Dynamic Context Awareness Component collects network status, edge node status, terminal status, and user session status, and reads the scene status and object status through the runtime control link component to form a current context snapshot including the scene status version and the target object version;

[0030] Step 2: The scene guardian orchestration component performs type determination, ambiguity checking, and limited pre-checking on the reconstruction request to form a summary of the current task; when the reconstruction request needs to be written into the 3D scene, the service memory reuse component, business unit memory component, and scene patch planning component are triggered.

[0031] Step 3: The service memory library in the service memory reuse component recalls verified reusable scenario patch templates based on the current task summary. The candidate patch sorter sorts the candidate patch templates based on the current context snapshot and the business unit parsing results, and outputs the sorted candidate patch template set, sorting results and reuse conditions to the scenario patch planning component.

[0032] Step 4: The business unit memory component parses the business unit into a collection of currently running objects based on the stable scene path, object path, member reference, grouping contract, relative layout relationship, and business semantic constraints. This generates a business unit parsing result that includes object roles, member relationships, constraints, version information, and binding summary. The business unit parsing result is then output to the scene patch planning component and the scene patch transaction execution component, respectively.

[0033] Step 5: The scenario patch planning component, based on the refactoring request, current task summary, current context snapshot, candidate patch template sorting results, business unit parsing results, and current scenario evidence provided by the runtime control link component, selects direct reuse, parameterized reuse, partial editing, or replanning to generate ordinary scenario patches, attribute change task contracts, repair patches, or evidence to refuse execution; if the evidence is insufficient, the scenario guardian orchestration component schedules the runtime control link component to supplement the required scenario evidence.

[0034] Step Six: When the scenario patch planning component generates an attribute change task contract, the attribute binding component reads the target object's component type, current attribute value, and writable attributes through the runtime control link component. It then matches the writable attributes with the list of secure writable attributes, generates a single-object attribute update patch or a batch attribute update patch, and submits it to the scenario patch transaction execution component. If binding fails, it rereads and rebinds within a limited number of attempts. If it still fails, it returns the reason for the binding failure to the scenario patch planning component.

[0035] Step 7: The scenario patch transaction execution component normalizes ordinary scenario patches or attribute update patches, and deterministically expands the stable target reference into a set of current runtime objects based on the business unit parsing results. It also reads the current scenario state version and target object version through the runtime control link component. When the current version is inconsistent with the base version recorded in the scenario patch, it determines that a state drift has occurred and triggers target rebinding, reverification, replanning, or rejection of execution.

[0036] Step 8: When no state drift occurs, the scenario patch transaction execution component performs checks on the existence of the target object, the consistency of business unit binding, the attribute binding result, collisions, boundaries, and invariants through the runtime control link component. If the pre-execution verification fails, the blocked object, the reason for blocking, the pre-execution state, the expected post-execution state, and the original tool evidence are returned to the scenario patch planning component. The scenario patch planning component then generates a repair patch, requests supplementary evidence, forms verification objection evidence, or refuses to execute, and re-enters the pre-execution verification within a limited number of times.

[0037] Step Nine: After the pre-execution verification is passed, the scenario patch transaction execution component executes the scenario patch transaction according to the same target expansion result through the runtime control link component and records the write action. After the execution is completed, the object status is read back and the post-execution verification is performed according to the expected post-state, invariants and verification plan. If the verification fails, repair, rollback or compensation is performed. If the verification is passed, the transaction result and audit record are formed, and the reusable scenario patch template and business unit binding evidence that meet the long-term memory writing conditions are allowed to be backfilled to the service memory reuse component and business unit memory component respectively.

[0038] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0039] This invention transforms runtime refactoring requests into scene patch transactions, giving runtime changes to 3D services clear scope, preceding state, expected subsequent state, invariants, and rollback plans, thus avoiding the uncontrollable state problem caused by direct tool calls.

[0040] This invention enables the refactoring process to perceive changes in the network, edge nodes, terminals, user sessions, scene versions, and object versions through highly dynamic context awareness, and triggers re-verification, re-planning, refusal to execute, or rollback when the state drifts.

[0041] This invention enables successfully executed and verified scenario patches to be converted into reusable scenario patch templates that do not contain temporary runtime identifiers, historical absolute coordinates, or expired versions through a service memory reuse component. These templates are then recalled and sorted when the current reuse conditions are met, reducing the overhead of repetitive planning.

[0042] This invention enables a collection of objects in a 3D scene to be parsed before planning based on stable paths, member contracts, and business semantics through a business unit memory component, and refreshes object binding and version information before transaction execution, thereby improving the consistency and reusability of target binding.

[0043] This invention uses an attribute binding component to bind the intent to change attributes with the safe writable attributes in the current running instance of the 3D engine, thereby reducing the fixed dependence of scene patches on specific attribute names and operation interfaces.

[0044] This invention improves the verifiability, recoverability, and auditability of the reconstruction results by using the same patch expansion result and the same set of target objects in the planning, verification, execution, and supervision phases through the scenario patch transaction execution component. Attached Figure Description

[0045] Figure 1 This is a schematic diagram of the structure of a highly dynamic 3D service runtime reconstruction system based on scene patch transactions according to the present invention.

[0046] Figure 2 This is a schematic diagram of the runtime control link between the cloud, edge nodes, terminals, and 3D services of the present invention.

[0047] Figure 3 This is a schematic diagram of the overall process of scene protection orchestration, service memory reuse, business unit parsing, scene patch planning, and scene patch transaction execution of the present invention.

[0048] Figure 4 This is a schematic diagram of the service memory candidate recall, candidate ranking, and reuse decision-making process of the present invention.

[0049] Figure 5 This is a schematic diagram of the business unit memory recording and runtime parsing process of the present invention.

[0050] Figure 6 This is a schematic diagram of the runtime attribute binding process of the attribute change task contract of the present invention.

[0051] Figure 7 This is a schematic diagram illustrating the process of scenario patch standardization, target reference deterministic expansion, state drift check, pre-execution verification, transaction execution, post-execution verification, repair, and rollback for the present invention.

[0052] In the attached diagram, A1 is the highly dynamic context-aware component, A2 is the runtime control link component, A3 is the scene guardian orchestration component, A4 is the service memory reuse component, A5 is the business unit memory component, A6 is the scene patch planning component, A7 is the attribute binding component, and A8 is the scene patch transaction execution component. Detailed Implementation

[0053] The present invention will be further described in detail below with reference to the accompanying drawings: This embodiment is implemented under the premise of the technical solution of the present invention, and detailed implementation methods are given, but the protection scope of the present invention is not limited to the following embodiments. Specific Implementation Method 1

[0055] like Figure 1 As shown Figure 7 As shown in the figure, this embodiment involves a highly dynamic 3D service runtime refactoring system based on scene patch transactions, including a highly dynamic context-aware component A1, a runtime control link component A2, a scene guardian orchestration component A3, a service memory reuse component A4, a business unit memory component A5, a scene patch planning component A6, an attribute binding component A7, and a scene patch transaction execution component A8. The runtime control link component A2 provides scene and object states to the highly dynamic context-aware component A1, and the highly dynamic context-aware component A1 provides context snapshots to the scene guardian orchestration component A3; the scene guardian orchestration component A3 issues scheduling instructions to the runtime control link component A2, the service memory reuse component A4, the business unit memory component A5, and the scene patch planning component A6; the service memory reuse component A4 and the business unit memory component A5 provide reuse basis and target binding basis to the scene patch planning component A6; the attribute binding component A7 converts attribute change task contracts into bound attribute patches; the scene patch transaction execution component A8 completes verification, execution, validation, and rollback through the runtime control link component A2, and generates transaction results and audit records.

[0056] The scenario patch is a transactional specification used to describe the runtime state transitions of a 3D service. Its processing objects include: object states, attribute states, spatial relationships, business unit relationships, and execution result evidence in the 3D scene. The scenario patch is used to constrain object operations, attribute operations, relationship operations, verification operations, and rollback operations during the runtime of the 3D service.

[0057] The highly dynamic context-aware component A1 is used to generate a context snapshot of the current reconstruction request. The context snapshot includes at least one or more of the following: request identifier, scene identifier, scene state version, target object version, user session state, network latency, edge node load, terminal frame rate, and terminal computing power state. The scene state, object state, and corresponding version are read by the runtime control link component A2 from the terminal-side 3D engine runtime instance; the network, edge node, terminal, and session states are obtained from the corresponding state acquisition interfaces.

[0058] like Figure 2As shown, the runtime control link component A2 is used to establish a control link between the cloud, edge nodes, and terminals. A 3D engine tray or extended adapter layer is deployed on the terminal side. This tray or extended adapter layer connects to the 3D engine runtime instance, providing a unified call entry point for object querying, object inspection, scene tree reading, relationship reading, object movement, attribute updating, collision checking, boundary checking, and state readback. The cloud is used for service memory management and complex planning, edge nodes are used for cross-terminal scheduling, evidence forwarding, and verification access control, and the terminal-side 3D engine runtime instance is used for local state acquisition and scene operation.

[0059] The scenario guardian orchestration component A3 receives natural language requests, system events, or service scheduling targets, performs type determination, ambiguity checking, task routing, and limited pre-checking, and generates a current task summary including request type, target scope, existing evidence, missing evidence, and freshness requirements. Based on this current task summary, the scenario guardian orchestration component A3 schedules the runtime control link component A2, service memory reuse component A4, business unit memory component A5, and scenario patch planning component A6. Specific Implementation Method Two

[0061] Combination Figure 4 In this specific embodiment, the service memory reuse component A4 includes: a service memory library and a candidate patch sorter.

[0062] The service memory is used to store reusable scenario patch templates that have been successfully executed and verified. Each reusable scenario patch template includes at least the service intent, operation type, parameter mode, target business unit reference, verification strategy, rollback requirements, success summary, and source scenario information. The reusable scenario patch templates are reused based on business unit references, parameter modes, and verification strategies; they do not store temporary object identifiers, historical absolute coordinates, historical target surface boundaries, or expired versions from a single run. Scenario patches that fail, have been rolled back, or have not completed post-execution verification are not converted into reusable scenario patch templates.

[0063] The candidate patch sorter receives candidate patch templates recalled by the service memory based on the current task summary, the current task summary generated by the scene guardian orchestration component A3, the current context snapshot formed by the high-dynamic context-aware component A1, and the business unit parsing result formed by the business unit memory component A5. It then extracts the scene state version from the current context snapshot and sorts the candidate patch templates based on semantic similarity, target scope consistency, parameter substitutability, verification strategy matching degree, and state freshness. The sorting result includes the candidate patch template identifier, reusability level, parameters to be edited, targets to be rebound, and rejection reason. The sorted set of candidate patch templates, the sorting result, and the reusability conditions are submitted to the scene patch planning component A6. Candidate patch templates that are inconsistent with the current scene state version, target object version, or business unit parsing result have their reusability level reduced or are marked with a rejection reason. Specific Implementation Method 3

[0065] Combination Figure 5 In this specific embodiment, the service unit memory component A5 is used to record stable service units in a three-dimensional scene.

[0066] The business unit includes one or more of the following: an object group with a common parent node, an object group without a common parent node but forming a whole in terms of spatial location, orientation or functional role, a region, a channel, a screen visible area or a light group.

[0067] The business unit memory component A5 is used to record the scene path, object path, member objects, member roles, anchor objects, relative layout, and evidence source of the business unit. Before scene patch planning, the business unit memory component A5 parses the object identifier in the current scene based on the scene path, object path, member roles, anchor objects, and relative layout, forming a business unit parsing result that includes the current runtime object set, object roles, member relationships, relative transformations, constraints, version information, and binding summary. Before the scene patch transaction execution component A8 performs verification, the business unit memory component A5 refreshes the object binding and version information according to the current scene state.

[0068] The business unit memory component A5 also generates a business unit binding summary based on member objects, member roles, anchor objects, relative layouts, and evidence sources. This business unit binding summary characterizes the consistency between the current runtime object set and stable business unit records, and is output along with resolved members, missing members, conflicting members, and confidence levels.

[0069] When an object is added, deleted, moved, or its state changes in the current scenario, the business unit memory component A5 outputs the parsed members, missing members, conflicting members, confidence level, version information, and business unit binding summary. These outputs are then fed into the scenario patch planning component A6 and the scenario patch transaction execution component A8, respectively. The scenario patch planning component A6 decides whether to reuse the data directly, edit it partially, rebind it, replan it, or refuse execution. The scenario patch transaction execution component A8 performs target deterministic expansion, binding consistency checks, and state freshness checks. Specific Implementation Method Four

[0071] Combination Figure 3 , Figure 4 and Figure 5 In this specific implementation, the scenario patch planning component A6 generates a scenario patch or attribute change task contract based on the current task summary, the candidate patch template sorting result, the business unit parsing result, the current context snapshot, and the current scenario evidence.

[0072] The scenario patch includes at least a patch identifier, a request identifier, a base scenario version, a target object version, a target scope, a set of target objects, a business unit binding summary, an operation set, invariants, a verification plan, an expected post-state, a rollback plan, attribute binding results, and evidence references.

[0073] If a candidate patch template matches the current request, target business unit, business unit binding summary, and scene state, the scene patch planning component A6 generates a reusable patch based on the current parameters and the current target binding. If the operation method of the candidate patch template is available but the parameters are different, the scene patch planning component A6 generates a parameterized patch or a partial editing patch. If the candidate patch template is not suitable for the current target, the scene patch planning component A6 generates a new patch based on the business unit parsing result and the current scene evidence. The current scene evidence is read from the current 3D engine running instance by the runtime control link component A2, including object, relationship, attribute, boundary, collision, and state readback evidence. The scene state version and target object version are encapsulated in the current context snapshot by the high-dynamic context-aware component A1 and provided to the scene patch planning component A6 by the scene guardian orchestration component A3 along with the current task summary. When the evidence is insufficient, the scene patch planning component A6 schedules the runtime control link component A2 through the scene guardian orchestration component A3 to supplement the reading. When the evidence is missing or the conflict cannot be eliminated, evidence to refuse execution is generated.

[0074] The ordinary scene patch generated by the scene patch planning component A6 does not directly perform write operations, but is submitted to the scene patch transaction execution component A8 for normalization, verification and execution; the attribute class request is generated by the scene patch planning component A6 to generate an attribute change task contract, which is submitted to the attribute binding component A7 to complete the safe runtime attribute binding, and then the attribute binding component A7 submits the bound scene patch to the scene patch transaction execution component A8. Detailed Implementation Method Five

[0076] Combination Figure 6 In this specific implementation, the attribute binding component A7 is used to handle attribute class reconstruction requests.

[0077] The attribute binding component A7 receives the attribute change task contract generated by the scenario patch planning component A6. The attribute change task contract includes at least the target business unit reference, target state, attribute change intent, constraints, and verification conditions. The attribute binding component A7 expands the target business unit reference into a current runtime object set through the runtime control link component A2, and reads the component type, current attribute value, and writable attributes of the target objects in batches.

[0078] The list of secure writable attributes is set in the attribute operation security policy of runtime control link component A2. Runtime control link component A2 provides attribute binding component A7 with the currently supported set of attribute operations and the set of currently writable attributes of the target object. Attribute binding component A7 takes the intersection of the set and the list of secure writable attributes and selects the corresponding runtime attribute. The list of secure writable attributes includes at least one of the following: renderer enabled attributes, light enabled attributes, collider enabled attributes, and object activation status.

[0079] The attribute binding component A7 generates a single-object attribute update patch or a batch attribute update patch based on the selection result, and submits the bound scene patch to the scene patch transaction execution component A8. If the attribute does not match the target state after execution, the attribute binding component A7 rereads the target object's component type, current attribute value, and writable attributes, and performs forced rebinding within a limited number of attempts. If the rebinding attempt limit is reached and a mismatch still occurs, the attribute binding component A7 returns a binding failure report to the scene patch planning component A6, including the target object, candidate attributes, failure reason, and reading evidence. The scene patch planning component A6 then replans, rejects execution, or generates verification objection evidence. Specific Implementation Method Six

[0081] Combination Figure 7 In this specific implementation, the scenario patch transaction execution component A8 is used to standardize, verify before execution, execute transactions, verify after execution, repair, refute, roll back, and audit scenario patches.

[0082] After receiving a regular scenario patch or a bound scenario patch, the scenario patch transaction execution component A8 normalizes the target scope, business unit reference, operation set, invariants, verification plan, expected post-state, rollback plan, attribute binding result, and evidence reference in the patch. Based on the business unit parsing result provided by the business unit memory component A5, it deterministically expands the stable target reference into the current runtime object set and the current executable operation sequence, so that pre-execution verification, transaction execution, and post-execution verification use the same target expansion result.

[0083] After normalization and deterministic expansion of target references are completed, but before transaction writing, the scenario patch transaction execution component A8 reads the current scenario state version and target object version through the runtime control link component A2, and compares them with the base scenario version and target object version recorded in the scenario patch. If the versions are inconsistent, a state drift is determined, writing is stopped, and target rebinding, revalidation, replanning, or execution rejection is triggered. If the versions are consistent, the scenario patch transaction execution component A8 continues to read the target object state, collision check results, boundary check results, business unit binding summary, and necessary evidence, and performs one or more blocking-level checks according to the verification plan, including target object existence, business unit binding consistency, attribute binding results, collision, boundary, and invariants. If any blocking-level check fails, the scenario patch transaction execution component A8 rejects execution and returns the blocked object, blocking reason, relevant boundaries, pre-execution state, expected post-execution state, and original tool evidence to the scenario patch planning component A6.

[0084] After successful verification, the scene patch transaction execution component A8 generates an execution license record and executes object movement, rotation, scaling, attribute update, cloning, hiding, or batch layout operations according to the expanded operation sequence. Each write action records the target object, its state before execution, its state after execution, the execution time, and the tool's return result.

[0085] If any action fails during the transaction write process, or if an unrecoverable version mismatch is detected during the write process, the scenario patch transaction execution component A8 will restore the already executed actions according to the rollback plan, or generate compensation actions, and form a blocking evidence record. The blocking evidence record includes one or more of the following: failed action, failure reason, pre-execution state, executed actions, version comparison result, rollback result, and related original evidence.

[0086] After execution, the scenario patch transaction execution component A8 rereads the target object state, scenario state version, target object version, collision results, boundary results, business unit binding summary, and necessary visual evidence, and compares them with the expected post-state, invariants, and verification plan. If post-execution verification passes, the scenario patch transaction execution component A8 records the transaction result and allows memory backfilling; if post-execution verification fails, the scenario patch transaction execution component A8 returns the failure evidence to the scenario patch planning component A6, which then selects to generate a repair patch, form verification objection evidence, request supplementary evidence, or trigger rollback compensation. Only when the transaction executes successfully, post-execution verification passes, the scope is stable and does not contain temporary runtime identifiers, historical absolute coordinates, or expired state versions, is the scenario patch converted into a reusable scenario patch template and written to the service memory reuse component A4; stable business unit binding evidence is written to the business unit memory component A5. Detailed Implementation Method Seven

[0088] like Figure 3 As shown, the reconstruction method of the highly dynamic 3D service runtime reconstruction system based on scene patch transactions includes the following steps:

[0089] Step 1: Scene Guardian Orchestration Component A3 receives the reconstruction request; High Dynamic Context Awareness Component A1 collects network status, edge node status, terminal status and user session status, and reads scene status and object status through runtime control link component A2 to form a current context snapshot including scene status version and target object version;

[0090] Step 2: Scene Guardian Orchestration Component A3 performs type determination, ambiguity checking, and limited pre-checking on the reconstruction request to form a summary of the current task; when the reconstruction request needs to be written into the 3D scene, it triggers Service Memory Reuse Component A4, Business Unit Memory Component A5, and Scene Patch Planning Component A6.

[0091] Step 3: The service memory library in the service memory reuse component A4 recalls the verified reusable scenario patch templates based on the current task summary. The candidate patch sorter sorts the candidate patch templates based on the current context snapshot and the business unit parsing results, and outputs the sorted candidate patch template set, sorting results and reuse conditions to the scenario patch planning component A6.

[0092] Step 4: The business unit memory component A5 parses the business unit into a collection of currently running objects based on the stable scene path, object path, member reference, grouping contract, relative layout relationship and business semantic constraints, forming a business unit parsing result including object role, member relationship, constraint condition, version information and binding summary, and outputs the business unit parsing result to the scene patch planning component A6 and the scene patch transaction execution component A8 respectively;

[0093] Step 5: The scenario patch planning component A6, based on the refactoring request, current task summary, current context snapshot, candidate patch template sorting results, business unit parsing results, and current scenario evidence provided by the runtime control link component A2, selects direct reuse, parameterized reuse, partial editing, or replanning to generate ordinary scenario patches, attribute change task contracts, repair patches, or evidence to refuse execution; if the evidence is insufficient, the scenario guardian orchestration component A3 schedules the runtime control link component A2 to supplement the required scenario evidence.

[0094] Step Six: When the scene patch planning component A6 generates an attribute change task contract, the attribute binding component A7 reads the component type, current attribute value, and writable attributes of the target object through the runtime control link component A2, matches the writable attributes with the list of secure writable attributes, generates a single-object attribute update patch or a batch attribute update patch, and submits it to the scene patch transaction execution component A8; if binding fails, it rereads and rebinds within a limited number of attempts, and if it still fails, it returns the reason for binding failure to the scene patch planning component A6;

[0095] Step 7: The scenario patch transaction execution component A8 normalizes ordinary scenario patches or attribute update patches. Based on the business unit parsing results, it deterministically expands the stable target reference into a set of current runtime objects and reads the current scenario state version and target object version through the runtime control link component A2. When the current version is inconsistent with the base version recorded in the scenario patch, it determines that a state drift has occurred and triggers target rebinding, reverification, replanning, or rejection of execution.

[0096] Step 8: When no state drift occurs, the scenario patch transaction execution component A8 performs checks on the existence of the target object, the consistency of business unit binding, the attribute binding result, collisions, boundaries, and invariants through the runtime control link component A2. If the pre-execution verification fails, the blocked object, the reason for the block, the pre-execution state, the expected post-execution state, and the original tool evidence are returned to the scenario patch planning component A6. The scenario patch planning component A6 generates a repair patch, requests supplementary evidence, forms verification objection evidence, or refuses to execute, and re-enters the pre-execution verification within a limited number of times.

[0097] Step Nine: After the pre-execution verification is passed, the scenario patch transaction execution component A8 executes the scenario patch transaction according to the same target expansion result through the runtime control link component A2 and records the write action. After the execution is completed, the object status is read back and the post-execution verification is performed according to the expected post-state, invariants and verification plan. If the verification fails, repair, rollback or compensation is performed. If the verification is passed, the transaction result and audit record are formed, and the reusable scenario patch template and business unit binding evidence that meet the long-term memory writing conditions are allowed to be backfilled to the service memory reuse component A4 and the business unit memory component A5 respectively.

[0098] The above description is merely a preferred embodiment of the present invention. These specific embodiments are different implementations based on the overall concept of the present invention, and the scope of protection of the present invention is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in the present invention should be included within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A highly dynamic 3D service runtime refactoring system based on scene patch transactions, characterized in that, include: The components include: High Dynamic Context Aware Component (A1), Runtime Control Link Component (A2), Scene Guardian Orchestration Component (A3), Service Memory Reuse Component (A4), Business Unit Memory Component (A5), Scene Patch Planning Component (A6), Attribute Binding Component (A7), and Scene Patch Transaction Execution Component (A8). The status output of the runtime control link component (A2) is connected to the status input of the high dynamic context awareness component (A1), and the context snapshot output of the high dynamic context awareness component (A1) is connected to the context input of the scene guardian orchestration component (A3). The scheduling output of the scene guardian orchestration component (A3) is connected to the scheduling inputs of the runtime control link component (A2), the service memory reuse component (A4), the business unit memory component (A5), and the scene patch planning component (A6), respectively. The candidate template output of the service memory reuse component (A4) is connected to the candidate template input of the scene patch planning component (A6). The parsing result output of the business unit memory component (A5) is connected to the parsing result inputs of the service memory reuse component (A4), the scene patch planning component (A6), and the scene patch transaction execution component (A8), respectively. The data input and output of the scene patch planning component (A6) are connected to the data input and output of the attribute binding component (A7) and the scene patch transaction execution component (A8), respectively. The attribute reading and writing end of the attribute binding component (A7) is connected to the runtime control link component (A2), and the bound attribute patch output end of the attribute binding component (A7) is connected to the patch input end of the scene patch transaction execution component (A8); the scene operation end of the scene patch transaction execution component (A8) is bidirectionally connected to the data input and output end of the runtime control link component (A2).

2. The highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 1, characterized in that, The highly dynamic context-aware component (A1) is used to collect dynamic information related to network status, edge node status, terminal status, user session status, scene status, and object status, and form a context snapshot corresponding to the current reconstruction request. The runtime control link component (A2) is used to establish a control link between the cloud, edge nodes and terminals, and access the 3D engine runtime instance through the 3D engine tray or extended adapter layer deployed on the terminal side. It provides unified encapsulation for object query, scene reading, relationship reading, object operation, attribute operation, collision checking, boundary checking and state readback. The Scene Guardian Orchestration Component (A3) is used to receive reconstruction requests, perform type determination, ambiguity checking, task routing and limited pre-inspection on the requests, form a current task summary, and schedule the runtime control link component (A2), service memory reuse component (A4), business unit memory component (A5) and scene patch planning component (A6) according to the current task summary. The service memory reuse component (A4) is used to recall verified reusable scenario patch templates based on the current task summary, sort the candidate patch templates by reusability, and output the candidate patch template set, sorting results and reuse conditions to the scenario patch planning component (A6). The business unit memory component (A5) is used to record the stable scene path, object path, member reference, grouping contract, relative layout relationship and business semantic constraints of the business unit. Before the scene patch planning, the record is parsed into the business unit parsing result, and before the transaction is executed, the current runtime object set, version information and business unit binding summary in the business unit parsing result are refreshed according to the current scene state. The Scene Patch Planning Component (A6) is used to generate ordinary scene patches, attribute change task contracts, repair patches, or rejection evidence based on the refactoring request, current task summary, context snapshot, candidate patch template sorting results, business unit parsing results, and current scene evidence read by the Runtime Control Link Component (A2) and scheduled by the Scene Guardian Orchestration Component (A3). The attribute binding component (A7) receives the attribute change task contract generated by the scene patch planning component (A6), reads the component type, current attribute value and writable attribute of the target object through the runtime control link component (A2), binds the attribute change intent as a safe writable attribute, generates a single object attribute update patch or a batch attribute update patch and submits it to the scene patch transaction execution component (A8). If the binding fails, it performs a limited number of rereading and rebinding. If it still fails, it returns the reason for the binding failure to the scene patch planning component (A6). The scenario patch transaction execution component (A8) is used to normalize and target reference deterministic expansion of scenario patches. It performs state drift checks and pre-execution verification before transaction writing, executes scenario patch transactions after verification, and performs post-execution verification, failure repair, failure rollback, compensation, and audit logging.

3. The highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 2, characterized in that, The service memory reuse component (A4) includes a service memory bank and a candidate patch sorter. The candidate patch template output of the service memory bank is connected to the candidate input of the candidate patch sorter. The sorting result output of the candidate patch sorter serves as the candidate template output of the service memory reuse component (A4) and is connected to the candidate template input of the scene patch planning component (A6). The service memory is used to store reusable scene patch templates that have been successfully executed and verified, and to recall a set of candidate patch templates based on the current task summary generated by the scene guardian orchestration component (A3), and output the set of candidate patch templates to the candidate patch sorter. The candidate patch sorter receives the set of candidate patch templates output by the service memory and the current task summary generated by the scenario guardian orchestration component (A3). It combines the current context snapshot formed by the high dynamic context awareness component (A1) and the business unit parsing result formed by the business unit memory component (A5). It extracts the scenario state version from the current context snapshot and sorts the candidate patch templates according to semantic similarity, target scope consistency, parameter substitutability, verification strategy matching degree and state freshness. It then outputs the sorted set of candidate patch templates, the sorting result and reuse conditions to the scenario patch planning component (A6).

4. The highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 3, characterized in that, The service memory reuse component (A4) only converts scene patches that have been successfully executed, verified, have a stable scope and do not contain temporary runtime identifiers, historical absolute coordinates and expired versions into reusable scene patch templates and writes them into long-term memory.

5. A highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 3, characterized in that, The business unit memory component (A5) outputs the business unit parsing results as the current runtime object set, object roles, membership relationships, relative transformations, constraints, version information, and business unit binding summary, and outputs them to the scenario patch planning component (A6) and the scenario patch transaction execution component (A8), respectively.

6. A highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 3, characterized in that, The attribute binding component (A7) binds the attribute change intent to at least one runtime attribute among enabled state, display state, material state, interactive state, rendering state, collision state, or business state, within the scope defined by the list of safe writable attributes, based on the set of available attribute operations provided by the runtime control link component (A2) and the set of currently writable attributes of the target object.

7. A highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 3, characterized in that, After completing the scenario patch normalization and target reference deterministic expansion, and before the transaction is written, the scenario patch transaction execution component (A8) compares the current scenario state version and target object version with the base version of the scenario patch record. When the versions are inconsistent, it determines that a state drift has occurred and triggers target rebinding, reverification, replanning, or rejection of execution. When the state drift occurs during the transaction writing process or the verification stage after execution and a consistent state cannot be restored, it triggers rollback or compensation.

8. A highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 3, characterized in that, When the scenario patch transaction execution component (A8) fails to perform pre-execution verification, it returns at least one of the following to the scenario patch planning component (A6): blocking object, blocking reason, boundary evidence, collision evidence, invariant evidence, pre-execution state, expected post-execution state, and original tool evidence.

9. A highly dynamic 3D service runtime refactoring system based on scene patch transactions according to claim 3, characterized in that, When the scenario patch transaction execution component (A8) fails to verify after execution, it returns the failure evidence to the scenario patch planning component (A6), which then performs patch generation, evidence completion, or verification objection processing. If the patch cannot be repaired, the scenario patch transaction execution component (A8) performs at least one of the following: rejection execution, rollback compensation, or audit record.

10. A reconstruction method for a highly dynamic 3D service runtime reconstruction system based on scene patch transactions, as described in any one of claims 3-9, characterized in that, Includes the following steps: Step 1: The Scene Guardian Orchestration Component (A3) receives the reconstruction request; the High Dynamic Context Aware Component (A1) collects the network status, edge node status, terminal status and user session status, and reads the scene status and object status through the Runtime Control Link Component (A2) to form a current context snapshot including the scene status version and the target object version; Step 2: The Scene Guardian Orchestration Component (A3) performs type determination, ambiguity checking, and limited pre-checking on the reconstruction request to form a summary of the current task; when the reconstruction request needs to be written into the 3D scene, the Service Memory Reuse Component (A4), Business Unit Memory Component (A5), and Scene Patch Planning Component (A6) are triggered. Step 3: The service memory library in the service memory reuse component (A4) recalls the verified reusable scenario patch templates based on the current task summary. The candidate patch sorter sorts the candidate patch templates based on the current context snapshot and the business unit parsing results, and outputs the sorted candidate patch template set, sorting results and reuse conditions to the scenario patch planning component (A6). Step 4: The business unit memory component (A5) resolves the business unit into a collection of currently running objects based on the stable scene path, object path, member reference, group contract, relative layout relationship and business semantic constraints, forming a business unit resolution result including object role, member relationship, constraint condition, version information and binding summary, and outputs the business unit resolution result to the scene patch planning component (A6) and the scene patch transaction execution component (A8) respectively. Step 5: The scenario patch planning component (A6) selects direct reuse, parameterized reuse, partial editing, or replanning based on the refactoring request, current task summary, current context snapshot, candidate patch template sorting results, business unit parsing results, and current scenario evidence provided by the runtime control link component (A2), generating ordinary scenario patches, attribute change task contracts, repair patches, or evidence to refuse execution; if the evidence is insufficient, the scenario guardian orchestration component (A3) schedules the runtime control link component (A2) to supplement the required scenario evidence. Step Six: When the Scene Patch Planning Component (A6) generates an attribute change task contract, the Attribute Binding Component (A7) reads the component type, current attribute value, and writable attribute of the target object through the runtime control link component (A2), matches the writable attribute with the list of secure writable attributes, generates a single-object attribute update patch or a batch attribute update patch, and submits it to the Scene Patch Transaction Run Component (A8). If binding fails, it rereads and rebinds within a limited number of attempts. If it still fails, it returns the reason for binding failure to the Scene Patch Planning Component (A6). Step 7: The scenario patch transaction execution component (A8) normalizes ordinary scenario patches or attribute update patches, and deterministically expands the stable target reference into a set of current runtime objects based on the business unit parsing results. It then reads the current scenario state version and target object version through the runtime control link component (A2). When the current version is inconsistent with the base version recorded in the scenario patch, it determines that a state drift has occurred and triggers target rebinding, reverification, replanning, or rejection of execution. Step 8: When no state drift occurs, the scenario patch transaction execution component (A8) performs checks on the existence of the target object, the consistency of business unit binding, the attribute binding result, collisions, boundaries, and invariants through the runtime control link component (A2). If the pre-execution verification fails, the blocked object, the reason for the block, the pre-execution state, the expected post-execution state, and the original tool evidence are returned to the scenario patch planning component (A6). The scenario patch planning component (A6) generates a repair patch, requests supplementary evidence, forms verification objection evidence, or refuses to execute, and re-enters the pre-execution verification within a limited number of times. Step 9: After the pre-execution verification is passed, the scenario patch transaction execution component (A8) executes the scenario patch transaction according to the same target expansion result through the runtime control link component (A2) and records the write action. After the execution is completed, the object state is read back and the post-execution verification is performed according to the expected post-state, invariants and verification plan. When verification fails, repair, rollback or compensation is performed. When verification passes, transaction results and audit records are generated, and reusable scenario patch templates and business unit binding evidence that meet the conditions for long-term memory writing are allowed to be backfilled to the service memory reuse component (A4) and the business unit memory component (A5) respectively.