Application development method, application development device, and XR device

Abstract

The application discloses an application development method, an application development device and an XR device, relates to the technical field of extended reality, and the method comprises the following steps: receiving, through a visual editor, that a user drags a preset XR scene component to an XR scene template; in response to a user request, calling an AIGC model to generate XR content materials, and inserting the XR content materials into a specified position of a current XR scene; receiving a user configuration of interaction logic, and converting the current XR scene and the interaction logic into an executable format of a target XR glasses through an adaptation layer, and outputting an application package adapted to the target XR glasses. By combining visual development and AIGC automatic content generation, the threshold of XR content creation is reduced, the development efficiency is improved, and diversified application scenarios are supported.

Description

Technical Field

[0001] This application relates to the field of extended reality technology, and in particular to application development methods, application development apparatus and XR devices. Background Technology

[0002] In recent years, Extended Reality (XR) technology has been increasingly widely used in education and training, industrial guidance, cultural tourism and entertainment, but the development of XR glasses applications still faces many technical bottlenecks. Traditional development methods heavily rely on professional programming skills and 3D art design capabilities. Developers need to manually write interactive logic using engines such as Unity and Unreal, and create or purchase 3D models, animations, and other materials themselves, resulting in long development cycles and high costs. Although some visualization tools attempt to lower the development threshold, their functions are limited to creating simple AR effects and cannot meet the development needs of complete XR applications, especially in terms of cross-device adaptation and complex interaction implementation.

[0003] Another major drawback of the existing XR development workflow lies in the efficiency bottleneck of content creation. High-quality 3D models, scene environments, and animation effects typically require time-consuming creation by professional designers, making it difficult for ordinary developers to quickly obtain customized materials. Although Artificial Intelligence Generated Content (AIGC) technology can generate 3D content based on text or images, its integration with XR development tools is insufficient. The generated models often require manual optimization of topology and adjustment of material parameters, making them unsuitable for direct integration into the development process. Furthermore, the writing of interaction logic still relies on traditional coding, lacking efficient means to automatically convert natural language intent into executable scripts, making it difficult for non-technical personnel to participate in development.

[0004] Regarding cross-platform adaptation, the hardware characteristics and operating environments of different XR glasses vary significantly, requiring developers to optimize rendering pipelines, interaction logic, and performance parameters for each type of device. Existing solutions typically require developers to manually adjust code or switch development engines, which not only increases workload but also easily introduces compatibility issues. Especially for scenarios where WebXR and native applications are deployed in a hybrid manner, the lack of a unified automated adaptation mechanism makes it difficult to achieve "develop once, deploy across multiple platforms." Summary of the Invention

[0005] This application provides an application development method, an application development apparatus, and an XR device to solve the above-mentioned technical problems.

[0006] On the one hand, embodiments of this application provide an application development method, including:

[0007] The system receives user-drag-and-drop pre-defined XR scene components into the XR scene template via a visual editor; the XR scene components include virtual objects, interaction logic, and UI components.

[0008] In response to a user request, the AIGC model is invoked to generate XR content materials, and the XR content materials are inserted into a specified position in the current XR scene; the XR content materials include at least one of 3D models, animation sequences, or interactive scripts;

[0009] The system receives user configurations for interaction logic and converts the current XR scene and interaction logic into an executable format for the target XR glasses through an adaptation layer, outputting an application package adapted to the target XR glasses; the configuration includes drag triggers or interaction rules described in natural language.

[0010] In one implementation of this application, in response to a user request, an AIGC model is invoked to generate XR content materials, and the XR content materials are inserted into a specified position in the current XR scene, specifically including:

[0011] If the user's required object is not found in the preset basic object library, the user request will be received.

[0012] If the XR content material to be generated is a 3D model, the user request is parsed to extract the key feature parameters corresponding to the 3D model; the user request includes natural language description, images or videos;

[0013] In response to the user request, the AIGC model is invoked based on the key feature parameters to generate a 3D model file that matches the natural language description;

[0014] The 3D model file is inserted into the current XR scene, and the 3D model is rendered in real time at a specified location in the current XR scene.

[0015] It receives user adjustment instructions for the rendering results, and adjusts the initial position and scaling of the rendered 3D model.

[0016] In one implementation of this application, it further includes:

[0017] When the XR content material to be generated is an interactive script, the natural language statements describing the user's behavioral logic are parsed, and the spatial relationships and event triggering conditions in the natural language statements are determined.

[0018] The corresponding executable code segment is generated by the large language model, and the executable code segment is bound to the interactive event node of the specified virtual object in the visual editor to generate an interactive script; the executable code segment includes Unity C# script or WebXR JavaScript script.

[0019] In one implementation of this application, receiving user configuration of interaction logic specifically includes:

[0020] The visual editor receives user connections to event nodes and action nodes to form an interactive logic chain.

[0021] When users describe the interaction rules in natural language, the AI ​​model generates the corresponding script code or visual logic nodes.

[0022] In one implementation of this application, an adaptation layer converts the current XR scene and interaction logic into an executable format for the target XR glasses, and outputs an application package adapted to the target XR glasses, specifically including:

[0023] The operating environment supported by the target XR glasses is detected; the operating environment includes WebXR and native applications;

[0024] If the target XR glasses support WebXR, the current XR scene is converted into code based on the WebXR standard, and the corresponding code is packaged into an offline application package; the content based on the WebXR standard includes HTML5 code or WebGL code;

[0025] If the target XR glasses require native applications, the SDK provided by the Unity engine is called to generate the corresponding project resources and application package.

[0026] In one implementation of this application, it further includes:

[0027] During the editing process, a real-time preview mode is activated, and when the user is detected to be connected to the target XR glasses, the current XR scene is pushed to the target XR glasses;

[0028] Based on a local lightweight rendering engine, the field of view parameters of the target XR glasses are simulated to render the current XR scene;

[0029] Receive the user's interactive test operation, and dynamically update the spatial coordinate mapping relationship when the user adjusts the component position;

[0030] If the user's instruction to modify the XR content material generated by the AIGC model is detected, the modified material feature description is recorded, and the AIGC model is re-triggered to generate optimized XR content material.

[0031] Based on the optimized XR content assets, the preview screen is dynamically updated, and the interaction delay parameters are fed back.

[0032] In one implementation of this application, activating a real-time preview mode during the editing process specifically includes:

[0033] Connect to the actual target XR glasses device and synchronize head posture data;

[0034] The current XR scene is rendered in real time on the device screen of the target XR glasses, and the user's interaction error log during the test is recorded, with abnormal nodes highlighted.

[0035] In one implementation of this application, before converting the current XR scene and interaction logic into the executable format of the target XR glasses through an adaptation layer, the method further includes:

[0036] Identify unused model vertex data in the current XR scene and compress the unused model vertex data to simplify the mesh of the 3D model;

[0037] The sampling rate of high-resolution textures in the current XR scene is reduced according to a preset strategy to match the computing power of the target XR glasses.

[0038] On the other hand, embodiments of this application also provide an XR device, the device comprising:

[0039] At least one processor;

[0040] And, a memory communicatively connected to the at least one processor;

[0041] The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform an application development method as described above.

[0042] On the other hand, embodiments of this application also provide an application development apparatus, characterized in that the apparatus includes:

[0043] The visualization module is used to receive user-drag-and-drop pre-defined XR scene components into the XR scene template through a visual editor; XR scene components include virtual objects, interaction logic, and UI components;

[0044] The model invocation module is used to respond to user requests, invoke the AIGC model to generate XR content materials, and insert the XR content materials into the specified position of the current XR scene; the XR content materials include at least one of 3D models, animation sequences, or interactive scripts;

[0045] The scene conversion module receives the user's configuration of the interaction logic and converts the current XR scene and interaction logic into an executable format for the target XR glasses through the adaptation layer, outputting an application package adapted to the target XR glasses; the configuration includes drag triggers or interaction rules described in natural language.

[0046] This application provides an application development method, an application development apparatus, and an XR device, which have at least the following beneficial effects:

[0047] By using visual drag-and-drop components and natural language interaction, users without professional programming skills can quickly build XR scenes and interaction logic, effectively solving the problem of traditional XR development's reliance on 3D graphics programming and art design skills. Utilizing AIGC models to automatically generate XR content materials such as 3D models, animation sequences, and interaction scripts reduces manual modeling and coding work that originally took days or even weeks to minutes, greatly accelerating the transformation process from idea to prototype. By parsing natural language descriptions to automatically generate matching 3D models and interaction logic, developers can express their creative needs in a more intuitive way. Simultaneously, AI-generated materials can be directly embedded into scenes and adjusted in real time, avoiding the tedious steps of repeated modifications and format conversions in traditional processes. Through an adaptation layer, scene content is automatically converted into the executable format of the target XR glasses, solving the problem of ecosystem fragmentation between different XR devices. Attached Figure Description

[0048] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings:

[0049] Figure 1 This is a schematic diagram illustrating an application scenario for an application development method provided in an embodiment of this application.

[0050] Figure 2 A flowchart illustrating an application development method provided in an embodiment of this application;

[0051] Figure 3 A flowchart illustrating a method for generating XR content materials by calling an AIGC model, provided in an embodiment of this application;

[0052] Figure 4 A flowchart illustrating an application package output method adapted to target XR glasses, provided in an embodiment of this application;

[0053] Figure 5 This is a schematic diagram of the internal structure of an XR device provided in an embodiment of this application;

[0054] Figure 6This is a schematic diagram of the internal structure of an application development device provided in an embodiment of this application. Detailed Implementation

[0055] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0056] The application development method provided in this application embodiment can be applied to, for example, Figure 1 The application environment shown. For example... Figure 1 As shown, the application environment may include: development terminal 101, AIGC cloud service platform 102, XR runtime engine 103, target XR glasses 104, and resource management database 105.

[0057] The development terminal 101 serves as the primary development tool, used to run a visual editor, providing a drag-and-drop XR scene building interface and natural language interaction functions, and enabling real-time preview through a local lightweight rendering engine.

[0058] The AIGC cloud service platform 102 connects to the development terminal 101 and integrates various generative AI models, including a 3D model generator, an animation sequence generator, and a code script generator, to automatically generate XR content materials according to the requests of the development terminal.

[0059] As a core component of the adaptation layer, XR runtime engine 103 is responsible for converting the edited XR scene into an executable format for the target device, supporting the conversion of SDK interfaces of WebXR standards and mainstream XR engines.

[0060] The target XR glasses 104 are connected to the development terminal 101 via wired or wireless means to receive the deployed application package and run the XR scene, while feeding back the device parameters and interaction data to the development terminal.

[0061] The resource management database 105 stores and manages XR scene template libraries, pre-made component libraries, AI-generated content, and user project data, supporting version control and collaborative team development. All components are interconnected via a high-speed network, forming a complete closed loop for XR application development, generation, adaptation, and deployment.

[0062] The technical solutions provided by the various embodiments of this application are described in detail below with reference to the accompanying drawings.

[0063] Figure 2 This is a flowchart illustrating an application development method provided in an embodiment of this application.

[0064] The analysis method involved in the embodiments of this application can be implemented by a terminal device or a server, and this application does not impose any special limitations on it. For ease of understanding and description, the following embodiments are all described in detail using a server as an example.

[0065] It should be noted that the server can be a single device or a system composed of multiple devices, i.e., a distributed server. This application does not make any specific limitations on this.

[0066] like Figure 2 As shown in the embodiment of this application, an application development method includes:

[0067] Step 201: Receive user-drag-and-drop pre-defined XR scene components into the XR scene template via the visual editor.

[0068] It should be noted that the XR scene components in the embodiments of this application include virtual objects, interaction logic, and UI components.

[0069] XR refers to all immersive reality technologies, including Virtual Reality (VR), Augmented Reality (AR), and Mixed Reality (MR). XR emphasizes the integration and interaction between virtual digital content and the real environment.

[0070] VR refers to a technology that uses computers to generate an immersive, fully virtual digital environment, allowing users to be completely isolated from the real world and immersed in a virtual scene. AR refers to a technology that overlays digital virtual content onto the real world, allowing users to simultaneously perceive the real environment and the virtual information superimposed on it. MR refers to a fusion of AR and VR, where virtual content can be overlaid on reality and interact with real objects in real time, resulting in a closer integration of the virtual and real worlds.

[0071] AIGC refers to content automatically generated using artificial intelligence (especially generative models), such as images, 3D models, animations, and text scripts. AIGC technology can automatically create the required materials or code from user-provided input, such as text descriptions or sketches, using an AI model.

[0072] This application discloses an XR glasses application development platform based on AIGC. The platform adopts a C / S architecture, including a user front-end and a cloud service, and also has local running capabilities. The user front-end runs on the developer's computer or tablet, and its main function is to provide users with a visual editing interface and local preview function based on a visual editor. The cloud service provides computing power support for AI content generation and complex scene rendering, as well as cloud storage and collaboration of project resources.

[0073] In this embodiment, a graphical development interface is provided through the development terminal, including a WYSIWYG scene editing view and a component drag-and-drop panel. Users can build applications by dragging and dropping pre-made XR interactive components into the scene, eliminating the need for hand-written code, such as UI interface controls, virtual objects, and interaction triggers. Simultaneously, users are allowed to describe their needs in natural language, and the system then parses the intent and recommends corresponding components or settings, achieving a user-friendly interaction design process.

[0074] It's important to note that the visual editor is a GUI application for direct developer interaction, featuring built-in sub-interfaces such as a scene editing window, component panel, property setting panel, and event flow editor. After launching the visual editor, developers first select the target XR glasses device type and then choose the desired XR scene template within the editor. Next, using the mouse, keyboard, or gesture controls, developers drag and drop virtual objects, UI controls, and interaction logic into the selected XR scene template within the scene window. They can then adjust the position and properties of the dragged virtual objects or UI controls, and draw simple paths or area triggers. The visual editor can capture user actions in real time and provide feedback on the display effects, such as displaying added 3D models and simulating simple interactive triggers.

[0075] In this embodiment, the project is first created and the scene is initialized. The user launches the visual editor, selects "New XR Project," enters the project name, and specifies the target device type, such as a certain model of AR glasses. The editor loads the corresponding device presets (such as field of view and resolution parameters) and the default empty scene accordingly. The user can select a suitable scene template from the built-in template library, such as "Indoor Display Scene" or "Outdoor Street Scene." The platform loads the pre-established basic scene environment into the editor for the user to modify.

[0076] Next, add objects and UI components. Users can drag and drop the required XR objects into the scene using the component panel. For example, in an AR educational application, a user might drag in a "machinery" object as the main teaching element; or in a game, they might drag in several "3D character" objects as interactive elements. The platform provides a library of basic objects (basic geometry, light sources, cameras, UI panels, etc.) to choose from.

[0077] Step 202: In response to the user request, call the AIGC model to generate XR content materials and insert the XR content materials into the specified position in the current XR scene.

[0078] It should be noted that the XR content materials in the embodiments of this application include at least one of three-dimensional models, animation sequences, or interactive scripts.

[0079] Figure 3This is a flowchart illustrating a method for generating XR content materials by calling an AIGC model, as provided in an embodiment of this application. Figure 3 As shown in the figure, the XR content material generation method that calls the AIGC model provided in this application embodiment specifically includes the following steps:

[0080] Step 301: If the object required by the user does not exist in the preset basic object library, receive the user request;

[0081] Step 302: If the XR content material to be generated is a 3D model, parse the user request to extract the key feature parameters corresponding to the 3D model; the user request includes natural language description, images or videos;

[0082] Step 303: In response to the user request, the AIGC model is invoked based on key feature parameters to generate a 3D model file that matches the natural language description;

[0083] Step 304: Insert the 3D model file into the current XR scene and render the 3D model in real time at the specified location in the current XR scene;

[0084] Step 305: Receive user adjustment instructions for the rendering results to adjust the initial position and scaling ratio of the rendered 3D model.

[0085] In this embodiment, the AIGC content generation system employs an intelligent multimodal request processing mechanism. It is understood that when a user searches the basic object library in the visual editor, the system monitors the matching degree between the search keywords and resources within the library in real time. It should be noted that the basic object library is stored using a graph database structure, and the relevance between user input and existing resources is calculated using a semantic similarity algorithm. Specifically, when a user searches for "retro telephone booth model," the system first searches for an exact match in the ontology library. If no results are found, the search is expanded to synonyms, such as "old-fashioned telephone booth." Finally, after confirming that there is no match in the basic object library, the AIGC generation process is activated. For example, this is triggered when the system detects that the user has searched three times consecutively without matching results or when the user actively clicks the AI ​​generation button. It is understood that the request parsing module adopts a multimodal input processing architecture, specifically including a text semantic parser, an image feature extractor, and a video keyframe analyzer.

[0086] For example, when developing AR guide applications in the field of cultural tourism interaction, when a user needs to generate a "3D model of the Paris Metro entrance with Art Nouveau style", firstly, the natural language parsing module will deconstruct the descriptive statement and identify "Art Nouveau style" as an art movement feature and "Paris Metro entrance" as the main object; secondly, if the user uploads historical photos for reference, the image analysis submodule will extract visual features such as wrought iron curves and stained glass; the final set of feature parameters includes main structural parameters, decorative feature parameters, and historical style parameters. Main structural parameters include the size of the arch and the layout of the steps, decorative feature parameters include the density of vine patterns and the reflectivity of the material, and historical style parameters include typical color schemes of the 1900s.

[0087] It's important to note that the AIGC model employs a hierarchical generation strategy. Specifically, the system first converts abstract features into control parameters for the generative model, uses a latent diffusion model to generate the basic geometry, refines surface details through neural radiation fields, and finally optimizes material representation using a physical renderer. Understandably, the generation process maintains real-time interactivity, allowing users to adjust parameter weights at any time. For example, in an industrial training scenario, when generating a model of the internal structure of a CNC machine tool, the proportion of transparent components can be dynamically adjusted to better showcase the internal mechanical structure.

[0088] In this embodiment, the model insertion and adjustment process employs scene-aware technology. For example, when developing anatomy AR applications in the education and training field, the generated "cardiovascular system" model automatically adapts to the proportions of the current anatomical table and inherits the scene's preset physical interaction parameters, such as peelable layer settings. Specifically, the system determines the optimal placement position through spatial semantic analysis, identifies the "teaching demonstration area" spatial markers in the scene, calculates the topological relationship between the model and surrounding anatomical models, and automatically adjusts the initial orientation for easier teaching observation. It is understood that users can make secondary adjustments to the model via gesture control or a parameter panel, and the system will provide real-time feedback on collision detection results to ensure that the adjusted model does not clip through existing objects in the scene.

[0089] In this embodiment, the intelligent generation of interactive scripts employs a semantic-code bidirectional mapping mechanism. It should be noted that this mechanism comprises three core components: an intent understanding module, a spatial relationship parser, and a code generator. Essentially, when a user describes "displaying the operation menu when the controller is near the control panel," the intent understanding module determines it as a touch-triggered information display interaction mode. The spatial relationship parser calculates the proximity threshold distance, and finally, the code generator outputs a complete script containing collision detection and UI control logic, achieving platform-adaptive script output.

[0090] The code generation process employs a context-aware constraint generation strategy. Specifically, when generating a script for an industrial field guidance application that plays a repair animation after a technician observes the equipment malfunction point for 3 seconds, if the target platform is Unity, the generated C# script will inherit from the project's base interaction class; if the target platform is WebXR, it will adopt a performance-optimized asynchronous loading mode. For example, the generated code will include detailed comments explaining the original natural language descriptions corresponding to each logical block.

[0091] Understandably, the code binding mechanism employs a hybrid programming model combining visual nodes and scripts. When developing AR guided tour applications in the marketing and cultural tourism interaction fields, when a user describes "automatically playing historical stories when visitors walk in front of exhibits," the system first locates the virtual object of the "exhibit" in the scene graph, then creates a new event listener node on the interactive component, and finally establishes a connection between the generated script logic and the node. It should be noted that this binding process maintains bidirectional synchronization; when the user adjusts the node connections in the visual editor, the underlying script will also update accordingly, and conversely, modifying the script will automatically refresh the node relationships.

[0092] For example, in the development of a personal creative game, when a developer describes "a hidden level is unlocked when the player collects three gems simultaneously," the system intelligently recognizes this as a complex conditional event and automatically generates a complete script architecture including a state manager. Specifically, the generated code not only includes basic conditional detection logic but also adds auxiliary code segments to enhance immersion, such as particle effect triggering and sound effect playback, based on the project style. Understandably, this context-based code completion capability significantly reduces the implementation burden on developers.

[0093] In this embodiment, the AIGC cloud service platform is deployed on a cloud server cluster, integrating multiple AIGC models and interacting with the front-end editor through a unified interface. The AIGC cloud service platform includes image / texture generation submodules, 3D model generation submodules, animation generation submodules, and code / script generation submodules. Specifically, the image / texture generation submodule generates scene textures or skybox images based on a diffusion model; the 3D model generation submodule uses a trained 3D generation model to generate simple 3D models based on text or reference images, outputting common file formats such as GLB / OBJ; the animation generation submodule generates character skeletal animations or object motion curves; and the code / script generation submodule, based on a large language model, generates corresponding script code segments based on user-defined language descriptions, such as Unity C# scripts or WebXR JS code segments.

[0094] When a user submits a content generation request in the visual editor, such as the text description "Generate a model of a tall oak tree," the front-end sends the request to a cloud-based AI service. The AI ​​service then invokes the corresponding model to generate the content and returns the result data, such as model files, images, or script text, to the front-end editor. Upon receiving the result data, the visual editor presents the generated content in the current XR scene for the user to preview and confirm. If the user is not satisfied with the result, they can adjust the description and regenerate, or manually edit details. The entire AI generation process is transparent to the user, requiring no understanding of the complexity of the underlying AI model. This allows the generated content to be directly applied to the scene in the visual editor, significantly reducing the workload of manually creating materials.

[0095] In this embodiment, when the desired object does not exist in the library, the user can describe the desired object in natural language, and the AI ​​content generation module will create it. For example, if the user inputs, "Generate a red industrial water pump model with pipe interfaces," the AI ​​model will generate a 3D model of the water pump based on the description, and the editor will then place the model in the scene. For interface interaction elements, the user can also drag and drop UI components such as buttons, progress bars, and text prompts into the field of view for overlay display on the XR glasses.

[0096] Step 203: Receive the user's configuration of the interaction logic, and convert the current XR scene and interaction logic into an executable format for the target XR glasses through the adaptation layer, and output the application package adapted to the target XR glasses.

[0097] It should be noted that the configuration in the embodiments of this application includes drag-and-drop triggers or interaction rules described in natural language.

[0098] In this embodiment, the interaction logic configuration system adopts a dual-modal input fusion architecture. This architecture uses a unified semantic understanding middleware layer to convert different input methods into standardized interaction logic descriptions. It should be noted that the event nodes in the visual editor use a color-coded classification system; for example, blue represents input events, green represents processing logic, and red represents output actions. This design significantly improves configuration efficiency for users in complex scenarios.

[0099] Specifically, in industrial training application development scenarios, when a user drags and drops a "gesture recognition" event node to establish a connection with a "device disassembly animation" action node, the system will automatically analyze the parameter compatibility between the nodes and intelligently insert necessary conversion logic nodes, such as adding a mapping relationship between gesture strength and animation playback speed.

[0100] For example, in specialized fields such as precision instrument repair training, the system will automatically supplement safety operation verification logic based on the domain knowledge base, such as detecting whether the user has performed a power-off operation before starting the disassembly steps. It is understandable that this intelligent node connection assistance mechanism retains configuration flexibility while ensuring operational safety in specialized scenarios.

[0101] The conversion from natural language to logical nodes employs a progressive parsing strategy. It's important to note that when a developer in the medical training field inputs "Vibrate to alert and record the number of errors when a trainee misoperates surgical instruments," the system first breaks down the complex statement into discrete interactive elements, such as the trigger condition "misoperation," the feedback action "vibration alert," and the data recording "number of errors." Then, through multiple rounds of dialogue, the system clarifies ambiguous expressions, such as confirming the intensity level of the "vibration alert." Specifically, the generated logical nodes retain the semantic labels of the original description, supporting subsequent modification and adjustment using natural language.

[0102] For example, in the development of cultural tourism interactive applications, users can first describe the basic rules using natural language, such as "displaying a description when a visitor looks at the exhibit," and then add details using a visual editor, dragging the "gaze duration" parameter to the "fade-in speed" control node on the description panel. Understandably, this hybrid editing mode fully leverages the advantages of both input methods: natural language quickly builds the framework, while visual editing precisely adjusts the details. It should be noted that the system maintains consistency between the two representations in real time; any modification to one will immediately be synchronized to the other.

[0103] In this embodiment, the user selects a virtual object in the current XR scene and adjusts its various attributes in the properties panel, such as position coordinates, scaling, and texture mapping. Furthermore, the user can utilize AI to set complex attributes, such as having AI generate and automatically apply texture maps to the wall based on a brief description like "this wall needs some industrial-style graffiti posters." Regarding behavior configuration, the platform supports adding interactive components to objects, such as preset behaviors like "collision bodies," "grabable objects," and "timed rotation." Users can assign corresponding interactive characteristics to objects simply by checking boxes or setting parameters, without needing to write code manually.

[0104] For more complex or customizable behavioral logic, users can use the script generation submodule to automatically generate it based on natural language descriptions. For example, in a VR puzzle game, if the goal is for a door to open when an item is placed in the correct position, the user could describe the logic in natural language as "When item A is placed at position B, trigger the door-opening animation of object C." The AI ​​will then generate the corresponding script code or a visual script node configuration and attach it to the events of the relevant virtual objects. Users can then view or fine-tune the generated logic. In this way, even users unfamiliar with programming can leverage AI to create complex interactive behaviors.

[0105] Figure 4 This is a flowchart illustrating an application package output method adapted to target XR glasses, provided in an embodiment of this application. Figure 4 As shown in the figure, the application package output method for adapting to target XR glasses provided in this application embodiment specifically includes the following steps:

[0106] Step 401: Detect the operating environment supported by the target XR glasses; the operating environment includes WebXR and native applications;

[0107] Step 402: If the target XR glasses support WebXR, convert the current XR scene into code based on the WebXR standard, and package the corresponding code into an offline application package; the content based on the WebXR standard includes HTML5 code or WebGL code;

[0108] Step 403: If the target XR glasses require native applications, call the SDK provided by the Unity engine to generate the corresponding project resources and application package.

[0109] In this embodiment, the cross-platform adaptation system adopts an intelligent environment detection and adaptive conversion architecture. This architecture dynamically determines the optimal packaging strategy by combining a device feature library with real-time performance analysis. It should be noted that the environment detection module collects multi-dimensional device parameters, such as the GPU model, memory capacity, sensor configuration, and supported API features of the XR glasses. This data is standardized using device fingerprinting technology.

[0110] Specifically, when outputting to a WebXR environment, the system first converts scene resources to the glTF2.0 standard format to ensure cross-browser compatibility. Secondly, it automatically injects device-specific performance tuning parameters, such as optimizing the WebGL shader for the Magic Leap browser. Finally, the generated service worker script enables complete offline operation. For example, in a cultural tourism guide application, the system intelligently identifies panoramic video resources and automatically converts them into a 360-degree video player component suitable for WebXR, while maintaining consistency in interaction with other 3D objects in the scene.

[0111] The native application packaging process employs a modular SDK integration solution. It's worth noting that different SDK plugin packages are dynamically loaded based on the characteristics of the target device. For Windows MR devices like HoloLens 2, the Mixed RealityToolkit core module is automatically integrated; while for Android-based AR glasses, the ARCore extension functionality is prioritized. Specifically, the conversion process maintains bidirectional traceability; developers can revert to the visual editor at any time to adjust the original scene, and all modifications are automatically synchronized to the native project files.

[0112] For example, in the development of industrial remote assistance applications, when the target device is detected as a Vuzix M400, the system automatically activates the device's waveguide display calibration parameters, adjusts the contrast settings of UI elements to adapt to industrial lighting conditions, and maps key interactive commands to physical buttons on the side of the device. Understandably, this deep device adaptation capability allows the generated application to fully utilize the hardware characteristics of various XR glasses, without developers needing to manually handle complex platform differences.

[0113] In this embodiment, during the editing process, the user can click the "Preview" button at any time to simulate the current scene. The editor will switch to preview mode, render the scene using the XR engine, and simulate the perspective and interaction of XR glasses. If an XR glasses device is connected, the preview can also be performed directly on the device. The user can test interactions in the preview, such as clicking buttons, moving the viewpoint to view the overlay effect, etc. For problems found in the preview, such as inappropriate object positions or unresponsive interaction triggers, the user can exit the preview, directly adjust the scene content or parameter configuration, and immediately preview again for verification. This rapid WYSIWYG loop allows developers to efficiently iterate and optimize the details of the experience.

[0114] In this embodiment, once the developer is satisfied with the preview, they can deploy the application to actual XR glasses for testing or release via the project management module. The platform provides a "one-click release" function; after the user selects the target device or distribution channel, the system automatically completes the remaining process. For example, for WebXR deployment, the platform will generate the application's URL link in the cloud, which the user can access and run through a browser while wearing XR glasses; for deployments requiring an installation package, the platform will generate an installation file adapted to the device's system and push it to the glasses or provide a download option. During deployment, the system also optimizes resources, such as compressing textures and cropping unused model parts, to ensure smooth operation on the limited computing power of XR glasses. Simultaneously, the platform records this build version for future updates and iterations. Thus, a complete XR glasses application development process is completed, producing a usable XR application.

[0115] In this embodiment, real-time preview achieves frame synchronization state sharing between the development environment and XR glasses by establishing a bidirectional data channel. It should be noted that when a target XR glasses connection is detected, the system automatically loads the device-specific display configuration file, such as field-of-view distortion parameters, interpupillary distance adaptive range, and screen color gamut characteristics. These parameters are applied in real-time to the shader program of the local lightweight rendering engine.

[0116] Specifically, an inverse projection matrix algorithm is used to accurately reproduce the optical distortion effects of XR glasses on the development side. For example, when developing medical AR applications, the system specifically simulates the unique optical path of microscope-style XR glasses to ensure that the preview seen by the developer is completely consistent with what the doctor actually sees. Understandably, this precise simulation avoids content positioning deviations caused by optical differences, which is particularly crucial for surgical navigation applications requiring millimeter-level positioning accuracy.

[0117] It's important to note that when a user adjusts the position of a virtual object during preview, the system establishes a spatial anchor point relationship. This maintains the object's original coordinates within the scene logic while also recording its offset relative to the user's current viewpoint. Specifically, this dual-coordinate system allows the same set of interaction logic to adapt to different XR devices without requiring developers to manually adjust position parameters. For example, in industrial maintenance guidance applications, the tooltip panel automatically adjusts its hover distance based on the field of view of different XR glasses, always maintaining the most comfortable reading position.

[0118] Understandably, when users adjust the AI-generated 3D model, the system records the modification vectors, such as changes in scaling or material parameter adjustments, and uses this feedback data as conditional input to re-trigger the generation process. It's worth noting that this reinforcement learning mechanism based on human feedback allows the AI ​​model to continuously adapt to the artistic style and technical requirements of the current project. Specifically, in educational application development, when a teacher adjusts the transparency of organs in an anatomical model, the system automatically learns this preference and presets the same transparency parameters in other subsequently generated anatomical models.

[0119] For example, a heatmap is used to display the rendering load distribution, and a time-series graph shows the changes in interaction latency. Understandably, this intuitive feedback mechanism helps developers quickly pinpoint performance bottlenecks, especially important when developing industrial operation guidance applications that require strictly real-time responses. Specifically, when gesture recognition latency exceeds the limit, the system intelligently suggests reducing the number of bones in the hand model or optimizing the collision detection algorithm to maintain overall interaction smoothness.

[0120] In this embodiment, the device-level real-time preview system adopts a low-latency data synchronization architecture. High-speed USB or Wi-Fi 6 connections are used to transmit head posture data, and millimeter-wave wireless projection technology is used to ensure real-time display. It should be noted that the posture data synchronization uses a predictive compensation algorithm. In scenarios with extremely high accuracy requirements, such as medical training, the system dynamically calculates the end-to-end latency from sensor sampling to image update and compensates for it using spatiotemporal interpolation technology.

[0121] Specifically, in the development of industrial equipment maintenance guidance applications, when engineers wear XR glasses to test disassembly and assembly processes, the system compares virtual guidance markers with key reference points on the actual equipment in real time, automatically calibrating the spatial mapping relationship. For example, in large machinery maintenance scenarios, the system intelligently identifies equipment feature points and establishes a precise correspondence between the world coordinate system and the glasses' SLAM system. Understandably, this spatial calibration mechanism based on actual equipment effectively solves the problem of misalignment between virtual content and real objects.

[0122] It should be noted that the system will record three key types of data in a structured manner: user behavior sequences (such as head movement trajectories and gesture operations), system response events (such as rendering frame rate and script execution status), and environmental parameters (such as lighting changes and spatial anchor point stability). Specifically, when an anomaly is detected, the system will construct a causal relationship graph. In cultural tourism guide applications, if a user attempts to trigger an explanation multiple times in front of a painting without success, the system will mark possible issues with the interactive hotspot settings and automatically suggest expanding the trigger range or adding visual cues.

[0123] Understandably, in testing educational and training applications, when a student makes a mistake, a semi-transparent warning box and a 3D arrow will be overlaid on the XR glasses screen, while the development side simultaneously displays the call stack of the error node. Specifically, this two-way feedback mechanism allows developers to quickly understand the context in which the problem occurred, rather than just seeing the final error state. It should be noted that the system intelligently distinguishes between occasional errors and systemic defects, automatically generating optimization suggestions for frequently occurring interaction problems, such as adjusting the size of the collider or adding haptic feedback.

[0124] In this embodiment, before converting the current XR scene and interaction logic into the executable format of the target XR glasses through the adaptation layer, a dependency graph of the 3D scene is established to accurately identify optimizable resource objects. It should be noted that a strategy combining frustum culling and occlusion detection is employed, which not only analyzes visible faces in static scenes but also predicts visible areas that may appear during dynamic interactions.

[0125] Specifically, in the development of industrial equipment training applications, when dealing with complex mechanical assembly models, the system identifies geometric structures within embedded parts that are completely obscured by the outer shell and automatically removes the vertex data of these unseen parts. Simultaneously, for visible but distant components, a progressive simplification algorithm preserves their outline features. For example, for standard parts such as screws and washers, the system calls preset optimization templates, significantly reducing model complexity while ensuring functional demonstration. Understandably, this semantic-based optimization approach maintains greater accuracy in instructional guidance compared to simple geometric simplification.

[0126] It's important to note that the system analyzes the content features of the texture image, maintaining high-precision sampling for areas containing important details (such as device nameplates and dashboard markings), while using block compression for large areas of solid color or gradients. Specifically, in the development of medical anatomy applications, organ textures are dynamically adjusted according to the viewing distance. Medium-precision textures are used at normal viewing distances, while high-resolution detail textures are automatically loaded when the user focuses on the image. For example, this adaptive hierarchical loading mechanism ensures visual quality while significantly reducing memory usage.

[0127] When the target device is replaced with higher-performance XR glasses, the system can restore the original high-precision resources with a single click, avoiding repeated imports and settings. It's important to note that all optimization operations are recorded in the version control system, allowing developers to compare the differences before and after optimization at any time, ensuring that key visual elements remain unaffected. Specifically, in cultural tourism guide applications, the system establishes a "protective optimization" whitelist for models of important cultural relics, ensuring that these core exhibits always maintain the best visual effect.

[0128] In one embodiment of this application, in the field of education and training, a vocational training institution aims to create a practical teaching application that runs on AR glasses to train students in repairing complex equipment. Through this platform, instructors do not need to program; they only need to select an "Industrial Equipment Training" scenario template, adjust the position of the equipment model, and use the AIGC module to generate 3D part models and fault animations for specific models. Then, they can configure step-by-step instructions and gesture prompts by dragging and dropping interactive components. Finally, the generated AR teaching application can be deployed on the XR glasses worn by students, enabling teaching with digital guidance overlaid on real equipment, thus improving training efficiency and safety.

[0129] In one embodiment of this application, in an industrial field guidance scenario, a company provides XR glasses to field engineers for equipment inspection and maintenance guidance. This platform helps the company quickly generate customized inspection applications. Engineers import CAD models of the factory workshop into a visual editor or directly generate a 3D workshop environment from AI descriptions, add inspection point markers, and have AI write inspection item descriptions based on existing documents. Interactions such as displaying maintenance steps when the engineer's gaze is focused on a component are set by dragging and dropping logic components. A field guidance AR application can be generated with almost no manual coding, helping novice engineers independently complete complex equipment inspections.

[0130] In one embodiment of this application, in a marketing and cultural tourism interaction scenario, a scenic spot plans an AR treasure hunt game to enhance the visitor interactive experience. The planners use this platform to select a game rule template, utilize AIGC to generate virtual treasure models and character animations related to the scenic spot's culture, and place these digital elements at corresponding locations on the scenic spot map. Through platform settings, when visitors wear AR glasses provided by the scenic spot at specific locations, virtual treasures will appear and puzzles will be triggered. The entire game's content and logic design can be completed in a short time, without the need for a professional programming development team, enabling marketing ideas to be quickly implemented.

[0131] In one embodiment of this application, targeting a personal creative game development scenario, an independent creator wishes to develop an immersive puzzle game that runs on VR glasses. Using this platform, a VR indoor scene template is first selected. Then, AI generates a castle-style indoor environment and mechanism model, allowing users to drag and drop components to set object interactions (such as picking up keys to unlock mechanisms), and the AI ​​is also asked to generate some dialogue scripts. The creator completes the game prototype within a few days and directly exports an application adapted for a specific VR glasses for testing, significantly reducing the difficulty of developing VR games for individuals.

[0132] The above are embodiments of the method proposed in this application. Based on the same inventive concept, embodiments of this application also provide an XR device, the structure of which is as follows: Figure 5 As shown.

[0133] Figure 5 This is a schematic diagram of the internal structure of an XR device provided in an embodiment of this application. Figure 5 As shown, the device includes:

[0134] At least one processor;

[0135] And, a memory that is communicatively connected to at least one processor;

[0136] The memory stores instructions that can be executed by at least one processor, and the instructions, when executed by at least one processor, enable at least one processor to:

[0137] The visual editor receives user-drag-and-drop pre-defined XR scene components into the XR scene template; XR scene components include virtual objects, interaction logic, and UI components.

[0138] In response to a user request, the AIGC model is invoked to generate XR content assets, which are then inserted into a specified location in the current XR scene. The XR content assets include at least one of the following: 3D models, animation sequences, or interactive scripts.

[0139] It receives the user's configuration of the interaction logic, and converts the current XR scene and interaction logic into an executable format for the target XR glasses through the adaptation layer, and outputs an application package adapted to the target XR glasses; the configuration includes drag triggers or interaction rules described in natural language.

[0140] like Figure 6 As shown in the embodiments of this specification, an application development apparatus is also provided. Figure 6 As can be seen, in one or more embodiments of this specification, an application development apparatus, apparatus 600 includes:

[0141] The visualization module 601 is used to receive user-drag-and-drop pre-defined XR scene components into the XR scene template through a visual editor; the XR scene components include virtual objects, interaction logic, and UI components;

[0142] The model invocation module 602 is used to respond to user requests, invoke the AIGC model to generate XR content materials, and insert the XR content materials into a specified position in the current XR scene; the XR content materials include at least one of 3D models, animation sequences, or interactive scripts;

[0143] The scene conversion module 603 is used to receive the user's configuration of the interaction logic, and convert the current XR scene and interaction logic into an executable format of the target XR glasses through the adaptation layer, and output an application package adapted to the target XR glasses; the configuration includes drag triggers or interaction rules described in natural language.

[0144] In some embodiments, in response to a user request, the AIGC model is invoked to generate XR content assets, and the XR content assets are inserted into a specified location in the current XR scene, specifically including:

[0145] If the user's required object is not found in the preset basic object library, the user request will be received.

[0146] When the XR content material to be generated is a 3D model, the user request is parsed to extract the key feature parameters corresponding to the 3D model; the user request includes natural language description, images or videos;

[0147] In response to user requests, the AIGC model is invoked based on key feature parameters to generate a 3D model file that matches the natural language description.

[0148] Insert the 3D model file into the current XR scene and render the 3D model in real time at a specified location in the current XR scene;

[0149] It receives user adjustment instructions for the rendering results, and adjusts the initial position and scaling of the rendered 3D model.

[0150] In some embodiments, it also includes:

[0151] When the XR content material to be generated is an interactive script, the natural language statements describing the user's behavioral logic are parsed, and the spatial relationships and event triggering conditions in the natural language statements are determined.

[0152] The large language model generates corresponding executable code segments, which are then bound to the interactive event nodes of a specified virtual object in the visual editor to generate interactive scripts. The executable code segments include Unity C# scripts or WebXR JavaScript scripts.

[0153] In some embodiments, receiving user configuration of interaction logic specifically includes:

[0154] The visual editor receives user connections to event nodes and action nodes to form an interactive logic chain.

[0155] When users describe the interaction rules in natural language, the AI ​​model generates the corresponding script code or visual logic nodes.

[0156] In some embodiments, an adaptation layer converts the current XR scene and interaction logic into an executable format for the target XR glasses, outputting an application package adapted to the target XR glasses, specifically including:

[0157] Detect the operating environment supported by the target XR glasses; the operating environment includes WebXR and native applications;

[0158] If the target XR glasses support WebXR, the current XR scene is converted into code based on the WebXR standard, and the corresponding code is packaged into an offline application package; the content based on the WebXR standard includes HTML5 code or WebGL code;

[0159] If the target XR glasses require native applications, the SDK provided by the Unity engine is called to generate the corresponding project resources and application package.

[0160] In some embodiments, it also includes:

[0161] During the editing process, a real-time preview mode is activated, and when the user is detected to be connected to the target XR glasses, the current XR scene is pushed to the target XR glasses;

[0162] Based on a local lightweight rendering engine, the field of view parameters of the target XR glasses are simulated to render the current XR scene;

[0163] Receive user interaction test operations and dynamically update the spatial coordinate mapping relationship when the user adjusts the component position;

[0164] If a user's instruction to modify the XR content material generated by the AIGC model is detected, the modified material feature description is recorded, and the AIGC model is re-triggered to generate optimized XR content material.

[0165] Based on the optimized XR content assets, the preview screen is dynamically updated, and the interaction delay parameters are fed back.

[0166] In some embodiments, activating a live preview mode during the editing process specifically includes:

[0167] Connect to the actual target XR glasses device and synchronize head posture data;

[0168] The current XR scene is projected onto the device screen of the target XR glasses in real time, and the user's interaction error logs during the test are recorded, with abnormal nodes highlighted.

[0169] In some embodiments, before converting the current XR scene and interaction logic into an executable format for the target XR glasses via an adaptation layer, the method further includes:

[0170] Identify unused model vertex data in the current XR scene and compress the unused model vertex data to simplify the mesh of the 3D model;

[0171] The sampling rate of high-resolution textures in the current XR scene is reduced according to a preset strategy to match the computing power of the target XR glasses.

[0172] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the device and medium embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the description of the method embodiments.

[0173] The devices and media provided in this application are one-to-one with the methods. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0174] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0175] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0176] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0177] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0178] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0179] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0180] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0181] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.

[0182] The above are merely embodiments of this application and are not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. An application development method, characterized in that, The method includes: The system receives user-drag-and-drop pre-defined XR scene components into the XR scene template via a visual editor; the XR scene components include virtual objects, interaction logic, and UI components. In response to a user request, the AIGC model is invoked to generate XR content materials, and the XR content materials are inserted into a specified position in the current XR scene; the XR content materials include at least one of 3D models, animation sequences, or interactive scripts; The system receives user configurations for interaction logic and converts the current XR scene and interaction logic into an executable format for the target XR glasses through an adaptation layer, outputting an application package adapted to the target XR glasses; the configuration includes drag triggers or interaction rules described in natural language. In response to a user request, the AIGC model is invoked to generate XR content assets, and these XR content assets are inserted into a specified location in the current XR scene. Specifically, this includes: If the user's required object is not found in the preset basic object library, the user request will be received. If the XR content material to be generated is a 3D model, the user request is parsed to extract the key feature parameters corresponding to the 3D model; the user request includes natural language description, images or videos; In response to the user request, the AIGC model is invoked based on the key feature parameters to generate a 3D model file that matches the natural language description; The 3D model file is inserted into the current XR scene, and the 3D model is rendered in real time at a specified location in the current XR scene. Receive user adjustment instructions for the rendering results to adjust the initial position and scaling of the rendered 3D model; The method further includes: During the editing process, a real-time preview mode is activated, and when the user is detected to be connected to the target XR glasses, the current XR scene is pushed to the target XR glasses; Based on a local lightweight rendering engine, the field of view parameters of the target XR glasses are simulated to render the current XR scene; Receive the user's interactive test operation, and dynamically update the spatial coordinate mapping relationship when the user adjusts the component position; If the user's instruction to modify the XR content material generated by the AIGC model is detected, the modified material feature description is recorded, and the AIGC model is re-triggered to generate optimized XR content material. Based on the optimized XR content assets, the preview screen is dynamically updated, and the interaction delay parameters are fed back.

2. The application development method according to claim 1, characterized in that, The method further includes: When the XR content material to be generated is an interactive script, the natural language statements describing the user's behavioral logic are parsed, and the spatial relationships and event triggering conditions in the natural language statements are determined. The corresponding executable code segment is generated by the large language model, and the executable code segment is bound to the interactive event node of the specified virtual object in the visual editor to generate an interactive script; the executable code segment includes Unity C# script or WebXR JavaScript script.

3. The application development method according to claim 1, characterized in that, Receive user configurations for the interaction logic, specifically including: The visual editor receives user connections to event nodes and action nodes to form an interactive logic chain. When users describe the interaction rules in natural language, the AI ​​model generates the corresponding script code or visual logic nodes.

4. The application development method according to claim 1, characterized in that, The adaptation layer converts the current XR scene and interaction logic into an executable format for the target XR glasses, outputting an application package adapted to the target XR glasses, specifically including: The operating environment supported by the target XR glasses is detected; the operating environment includes WebXR and native applications; If the target XR glasses support WebXR, the current XR scene is converted into code based on the WebXR standard, and the corresponding code is packaged into an offline application package; the content based on the WebXR standard includes HTML5 code or WebGL code; If the target XR glasses require native applications, the SDK provided by the Unity engine is called to generate the corresponding project resources and application package.

5. The application development method according to claim 1, characterized in that, To enable real-time preview mode during editing, specifically: Connect to the actual target XR glasses device and synchronize head posture data; The current XR scene is rendered in real time on the device screen of the target XR glasses, and the user's interaction error log during the test is recorded, with abnormal nodes highlighted.

6. The application development method according to claim 1, characterized in that, Before converting the current XR scene and interaction logic into the executable format of the target XR glasses through the adaptation layer, the method further includes: Identify unused model vertex data in the current XR scene and compress the unused model vertex data to simplify the mesh of the 3D model; The sampling rate of high-resolution textures in the current XR scene is reduced according to a preset strategy to match the computing power of the target XR glasses.

7. An XR device, characterized in that, The device includes: At least one processor; And, a memory communicatively connected to the at least one processor; The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform an application development method as described in any one of claims 1-6.

8. An application development apparatus, characterized in that, The device includes: The visualization module is used to receive user-drag-and-drop pre-defined XR scene components into the XR scene template through a visual editor; XR scene components include virtual objects, interaction logic, and UI components; The model invocation module is used to respond to user requests, invoke the AIGC model to generate XR content materials, and insert the XR content materials into the specified position of the current XR scene; the XR content materials include at least one of 3D models, animation sequences, or interactive scripts; If the user's required object is not found in the preset basic object library, the user request will be received. If the XR content material to be generated is a 3D model, the user request is parsed to extract the key feature parameters corresponding to the 3D model; the user request includes natural language description, images or videos; In response to the user request, the AIGC model is invoked based on the key feature parameters to generate a 3D model file that matches the natural language description; The 3D model file is inserted into the current XR scene, and the 3D model is rendered in real time at a specified location in the current XR scene. Receive user adjustment instructions for the rendering results to adjust the initial position and scaling of the rendered 3D model; The scene conversion module receives the user's configuration of the interaction logic and converts the current XR scene and interaction logic into an executable format for the target XR glasses through the adaptation layer, outputting an application package adapted to the target XR glasses; the configuration includes drag triggers or interaction rules described in natural language; Also includes: During the editing process, a real-time preview mode is activated, and when the user is detected to be connected to the target XR glasses, the current XR scene is pushed to the target XR glasses; Based on a local lightweight rendering engine, the field of view parameters of the target XR glasses are simulated to render the current XR scene; Receive the user's interactive test operation, and dynamically update the spatial coordinate mapping relationship when the user adjusts the component position; If the user's instruction to modify the XR content material generated by the AIGC model is detected, the modified material feature description is recorded, and the AIGC model is re-triggered to generate optimized XR content material. Based on the optimized XR content assets, the preview screen is dynamically updated, and the interaction delay parameters are fed back.

Images