A method for quickly generating naked-eye 3D Windows executable programs

Abstract

The present invention provides a method for rapidly generating a glasses-free 3D Windows executable program, belonging to the field of glasses-free 3D technology. The method comprises the following steps: obtaining user requirements, conducting technical research on glasses-free 3D technology, obtaining a requirements-function table, determining functions to be added according to the requirements-function table, and then rapidly developing a glasses-free 3D editor; grading the glasses-free 3D technology in detail levels based on key dimensions, obtaining detail level grades, and SDK packaging the corresponding grades; creating a new Unity project, first importing the Unity project according to the SDK packaging package, and determining a glasses-free 3D effect to be achieved according to the requirements-function table, performing a second import on the Unity project, and determining a glasses-free 3D template based on the results of the first and second imports; performing a comprehensive test on the glasses-free 3D template, and if qualified, saving the glasses-free 3D template as a prefabricated object, and packaging and publishing the prefabricated object, thereby realizing a systematic process from requirement acquisition to final publication, and improving the efficiency and quality of glasses-free 3D application development.

Description

Technical Field

[0001] The present invention relates to the field of naked-eye 3D technology, and in particular to a method for rapidly generating a naked-eye 3D Windows executable program. Background Art

[0002] Glasses-free 3D technology aims to provide viewers with a stereoscopic visual effect without the need for special glasses. This technology has demonstrated potential application value in a variety of fields, including entertainment, advertising, medical imaging, and education. However, existing glass-free 3D technology development lacks a clear user-focused approach, resulting in a disconnect between feature development and end-user needs. Furthermore, the lack of a standardized and modular development framework for glass-free 3D projects complicates implementation and makes maintenance difficult.

[0003] Therefore, the present invention provides a method for quickly generating a naked-eye 3D Windows executable program. Summary of the Invention

[0004] The present invention provides a method for rapidly generating a naked-eye 3D Windows executable program. The method obtains user needs and conducts technical research, clarifies functional requirements, performs subdivided technical grading and encapsulates the program into an SDK. The method then gradually imports and implements naked-eye 3D effects in a Unity project. Finally, the method undergoes comprehensive testing and is released as an executable program. This method implements a systematic process from demand acquisition to final release, improves the efficiency and quality of naked-eye 3D application development, and ensures the user-demand fit, standardization, modularity, and maintainability of the developed software.

[0005] The present invention provides a method for rapidly generating a naked-eye 3D Windows executable program, comprising:

[0006] Step 1: Obtain user needs and conduct technical research on naked-eye 3D technology to obtain a demand-function table. Based on the demand-function table, determine the functions to be added and quickly develop a naked-eye 3D editor based on the functions to be added.

[0007] Step 2: Classify the level of detail of the naked-eye 3D technology based on key dimensions, obtain the level of detail level, and encapsulate the corresponding level into SDK;

[0008] Step 3: Create a new Unity project, import the Unity project according to the SDK package, and specify the naked eye 3D effect to be achieved according to the requirements-function table. Import the Unity project again and determine the naked eye 3D template based on the results of the first and second imports.

[0009] Step 4: Perform comprehensive testing on the naked-eye 3D template. If qualified, save the naked-eye 3D template as a prefabricated body, package and publish the prefabricated body, and generate a corresponding Windows executable program.

[0010] The present invention provides a method for rapidly generating a glasses-free 3D Windows executable program. The method obtains user requirements, conducts technical research on glasses-free 3D technology, obtains a requirements-function table, determines functions to be added based on the requirements-function table, and rapidly develops a glasses-free 3D editor based on the functions to be added. The method includes:

[0011] Functionally classify the acquired user requirements and produce a requirements document;

[0012] Analyze the core technology of naked-eye 3D, study the advantages and disadvantages of different implementation schemes of the corresponding technology and their applicable scenarios, and produce a technical research report;

[0013] List the requirements-function table based on the requirements document and technical research report, and then determine the functions to be added;

[0014] The functions to be added are sorted according to priority, and corresponding core function modules are determined according to the sorting results, and a naked-eye 3D editor is developed based on the core function modules.

[0015] The present invention provides a method for rapidly generating a glasses-free 3D Windows executable program, which sorts the functions to be added according to their priorities, determines the corresponding core functional modules based on the sorting results, and develops a glasses-free 3D editor based on the core functional modules, including:

[0016] Assign the features to be added into the corresponding categories of must have, should have, could have, and won't have;

[0017] The core functional modules are determined according to the category allocation results, and a naked-eye 3D editor is developed based on the core functional modules, wherein the core modules include a parallax adjustment module, a depth rendering module, and a basic user interface control module.

[0018] The present invention provides a method for rapidly generating a naked-eye 3D Windows executable program, which performs detail level classification on naked-eye 3D technology based on key dimensions, obtains detail level grades, and performs SDK packaging on the corresponding grades, including:

[0019] Splitting the core functional module into multiple key dimensions, and refining the functions of the key dimensions to obtain a refined functional vector for each key dimension;

[0020] Determining a level of detail of a key dimension of each refined function vector from a function-level library, wherein the level of detail includes basic functions, intermediate functions, and advanced functions;

[0021] Establishing a corresponding level version of an LOD model according to the level of detail level, determining an observation distance range for switching between different level versions of the LOD model according to user requirements, and determining automatic switching parameters of the corresponding LOD model at different observation distances according to the observation distance range, performing a first configuration on the corresponding LOD model according to the automatic switching parameters, and obtaining a first configuration result of the LOD model;

[0022] Determine the depth parameters of the second configuration based on the characteristics of the naked-eye 3D display, perform the second configuration based on the first configuration result, obtain the second configuration result, use the naked-eye 3D editor to export the parameters of the second configuration result, and encapsulate the exported result into SDK to obtain the SDK encapsulation package corresponding to the naked-eye 3D.

[0023] The present invention provides a method for quickly generating a naked-eye 3D Windows executable program. The method comprises: creating a new Unity project, first importing the Unity project according to an SDK package, and specifying the naked-eye 3D effect to be achieved according to a requirement-function table. The method then performs a second import on the Unity project. The method further comprises:

[0024] Select a 3D project template related to naked-eye 3D technology based on the Unity project. At the same time, download the SDK package corresponding to the naked-eye 3D technology, select all resources in the SDK package for the first import, and perform the first import configuration of the 3D project template according to the first import result;

[0025] According to the requirements-function table, the naked-eye 3D effects to be achieved are listed, the required resource vectors and interactive display effects are determined based on the naked-eye 3D effects, a second import is performed based on the resource vectors and interactive display effects, and the second import configuration of the 3D project template is performed based on the second import result;

[0026] All the import configuration results of the first import configuration and the second import configuration are integrated to save the current 3D project template as a naked eye 3D template.

[0027] The present invention provides a method for rapidly generating a naked-eye 3D Windows executable program, which performs comprehensive detection on a naked-eye 3D template, including:

[0028] Simulate various user interactions item by item according to the requirements-function table, perform a first test on the response and event triggering, and obtain a first test result;

[0029] Recording average frame rates corresponding to the entire time period under different scene operations, calculating the instantaneous frame rate under the corresponding scene operation and the corresponding average instantaneous frame rate, comparing the average frame rate with the average instantaneous frame rate to obtain a first comparison result, comparing the average frame rate with the first preset range to obtain a second comparison result, determining a geometric multiple of the second preset range based on the complexity of the corresponding scene operation, and then multiplying the geometric multiple by the first preset range to obtain the second preset range, wherein the instantaneous frame rate and the corresponding average instantaneous frame rate are calculated based on a preset time window;

[0030] Comparing the instantaneous frame rate with a second preset range under the corresponding scene operation to obtain a third comparison result;

[0031] Determine a second detection result according to the first comparison result, the second comparison result, and the third comparison result;

[0032] Conduct user operation simulations, conduct a third test on the smoothness and correctness of the UI and interaction, and obtain the third test results;

[0033] The first, second and third test results are combined to determine whether the naked-eye 3D template is qualified.

[0034] The present invention provides a method for rapidly generating a naked-eye 3D Windows executable program, recording the average frame rate of the entire time period corresponding to different scene operations, and calculating the instantaneous frame rate under the corresponding scene operation and the corresponding average instantaneous frame rate, including:

[0035] Calculate the instantaneous frame rate:

[0036] ;in, Indicates the instantaneous frame rate at time t; A constant coefficient representing the scaling frame rate; Indicates the dynamic adjustment factor of the frame rate at time t; represents a small constant and ; represents the additional time-related adjustment factor at time t; Represents the time distance of the frame Varying rendering times; Represents the weight of the i-th frame; M represents a total of M frames in the current scene operation; i represents the i-th frame in the current scene operation;

[0037] Calculate the average real-time frame rate:

[0038] ;in, represents the average instantaneous frame rate at time t; Represents the historical frame rate adjustment factor between the i-th frame and time t; Represents the time distance of the frame The associated nonlinear weighting parameters; represents the nonlinear weighting factor; Represents the time distance of the frame exponential decay factor of the change; represents the exponential decay coefficient; represents the instantaneous frame rate of the i-th frame; n represents the size of the time window.

[0039] The present invention provides a method for quickly generating a glasses-free 3D Windows executable program. If qualified, the glasses-free 3D template is packaged and published to generate a corresponding Windows executable program, and the subsequent interaction between the glasses-free 3D editor and the glasses-free 3D environment software is tested, including:

[0040] Save the naked eye 3D template object as a prefab, use the naked eye 3D editor based on the Unity project to package the prefab, and obtain the corresponding executable 3D scene program;

[0041] The adaptability of the executable 3D scene program is tested in Windows systems with different configurations, and the executable 3D scene program is released according to the adaptability test results.

[0042] Compared with the existing technology, the beneficial effects of this application are as follows: by obtaining user needs and technical research, clarifying functional requirements, performing subdivided technical classification and packaging into an SDK, and then gradually importing and realizing naked-eye 3D effects in the Unity project, and finally comprehensively testing and publishing it as an executable program, a systematic process from demand acquisition to final release is realized, which improves the efficiency and quality of naked-eye 3D application development, and ensures the user demand fit, standardization, modularity and maintainability of the developed software.

[0043] Other features and advantages of the present invention will be described in the following description, and in part will become apparent from the description, or will be understood by practicing the present invention. The purpose and other advantages of the present invention can be realized and obtained by the structures particularly pointed out in the written description and the accompanying drawings.

[0044] The technical solution of the present invention is further described in detail below through the accompanying drawings and embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0045] The accompanying drawings are used to provide a further understanding of the present invention and constitute a part of the specification. Together with the embodiments of the present invention, they are used to explain the present invention and do not constitute a limitation of the present invention. In the accompanying drawings:

[0046] Figure 1 The present invention provides a flowchart of a method for rapidly generating a naked-eye 3D Windows executable program. DETAILED DESCRIPTION

[0047] The preferred embodiments of the present invention are described below with reference to the accompanying drawings. It should be understood that the preferred embodiments described herein are only used to illustrate and explain the present invention, and are not used to limit the present invention.

[0048] Example 1:

[0049] The embodiment of the present invention provides a method for quickly generating a naked-eye 3D Windows executable program, such as Figure 1 Shown, including:

[0050] Step 1: Obtain user needs and conduct technical research on naked-eye 3D technology to obtain a demand-function table. Based on the demand-function table, determine the functions to be added and quickly develop a naked-eye 3D editor based on the functions to be added.

[0051] Step 2: Classify the level of detail of the naked-eye 3D technology based on key dimensions, obtain the level of detail level, and encapsulate the corresponding level into SDK;

[0052] Step 3: Create a new Unity project, import the Unity project according to the SDK package, and specify the naked eye 3D effect to be achieved according to the requirements-function table. Import the Unity project again and determine the naked eye 3D template based on the results of the first and second imports.

[0053] Step 4: Perform comprehensive testing on the naked-eye 3D template. If qualified, save the naked-eye 3D template as a prefabricated body, package and publish the prefabricated body, and generate a corresponding Windows executable program.

[0054] In this embodiment, the requirement-function table lists the detailed functions that the product needs to implement based on the requirement document and technical research report. Each requirement corresponds to one or more functions, and the column names in the table format usually include requirement ID, function description, priority, etc.

[0055] In this embodiment, the functions to be added are extracted from the requirements-function table and are required to be implemented in the final product. After the list is classified and prioritized, the functions are marked as must-implement functions.

[0056] In this embodiment, key dimensions include display technology, depth perception, content format, rendering performance, etc.

[0057] In this embodiment, the process of developing a naked-eye 3D editor is to classify the functions to be added into must-have, should-have, can-have and will not-have, and determine the core functional modules based on the classification results, including parallax adjustment, depth rendering and basic user interface control, and develop a naked-eye 3D editor based on these core modules.

[0058] In this embodiment, the levels of detail are divided according to complexity and importance, including: basic functions: core minimum functions to ensure the normal operation of the system; intermediate functions: additional functions to improve the product function range and experience; advanced functions: functions for advanced user needs and specific application scenarios, which are usually more complex.

[0059] In this embodiment, the packaging process is to split the core functional modules into key dimensions and refine the functions, use the level of detail level to establish the LOD model, configure the parameters according to the observation distance and the characteristics of the naked eye 3D display, and finally export and package it into an SDK.

[0060] In this embodiment, the specific process of the first import includes: selecting a 3D project template, downloading the SDK package, importing SDK resources, and then performing the first configuration.

[0061] In this embodiment, the specific process of the second import is to list the requirements for naked-eye 3D effects and the specific naked-eye 3D effects that the project needs to achieve; list the required resources and interactive display effects according to the naked-eye 3D effects; import the required resource vectors into the project, and import the required resources (secondary import), such as high-definition textures, complex models, and interactive scripts; configure the imported resources to adapt to the project and naked-eye 3D effect requirements.

[0062] In this embodiment, the process of determining the naked-eye 3D template is by selecting the relevant 3D project template in the Unity project, importing the SDK resources and requirements of the naked-eye 3D technology in two steps - the resources and effects in the function table, configuring and integrating the import results, and finally saving them as the naked-eye 3D template.

[0063] In this embodiment, the comprehensive detection process is to simulate user interactions item by item, record frame rates, compare instant and average frame rates, set a preset range according to the complexity of the scene, detect the smoothness and correctness of the UI and interaction in stages, and make a qualified judgment based on the comprehensive results.

[0064] In this embodiment, the naked-eye 3D template is saved as a prefab, packaged into an executable program using the naked-eye 3D editor in the Unity project, and tested for compatibility under different Windows configurations, and released based on the test results.

[0065] The working principle and beneficial effects of the above technical solution are: by obtaining user needs and technical research, clarifying functional requirements, performing subdivided technical grading and packaging into an SDK, and then gradually importing and realizing naked-eye 3D effects in the Unity project, and finally comprehensively testing and publishing it as an executable program, a systematic process from demand acquisition to final release is realized, which improves the efficiency and quality of naked-eye 3D application development, and ensures the user demand fit, standardization, modularity and maintainability of the developed software.

[0066] Example 2:

[0067] An embodiment of the present invention provides a method for rapidly generating a glasses-free 3D Windows executable program. The method obtains user requirements, conducts technical research on glasses-free 3D technology, and obtains a requirements-function table. Functions to be added are determined based on the requirements-function table, and a glasses-free 3D editor is rapidly developed based on the functions to be added. The method includes:

[0068] Functionally classify the acquired user requirements and produce a requirements document;

[0069] Analyze the core technologies of naked-eye 3D, study the advantages and disadvantages of different implementation schemes of the corresponding technologies and their applicable scenarios, and produce a technical research report;

[0070] List the requirements-function table based on the requirements document and technical research report, and then determine the functions to be added;

[0071] The functions to be added are sorted according to priority, and corresponding core function modules are determined according to the sorting results, and a naked-eye 3D editor is developed based on the core function modules.

[0072] In this embodiment, the function classification process is to classify the functions according to importance and necessity based on the obtained user needs, including: must have: core required functions, without which the product will not be able to be used normally; should have: important but non-core functions that can significantly improve the user experience; can have: additional functions that can enhance the attractiveness of the product but are not necessary; will not have: functions that are not considered at the current stage and may be added in future versions.

[0073] In this embodiment, the requirements document is a document that records user requirements and related information in detail, including but not limited to: user-expected functions and features, application scenarios and usage scenarios, performance requirements and limitations, and other related non-functional requirements (such as security and maintainability).

[0074] In this embodiment, the technical research report is a document that analyzes and compares naked-eye 3D technology and its different implementation solutions, including: an overview and working principle of the core technology, an analysis of the advantages and disadvantages of various implementation solutions, the applicable scenarios and conditions of various solutions, and recommendations and conclusions on technology selection.

[0075] In this embodiment, the prioritization process is to prioritize the functions to be added, including the following steps: evaluating the importance of each function to the user experience and product value; classification sorting: first sorting by function category (must have, should have, can have), and then sorting by weight within each category; priority matrix: establishing a priority matrix, and finally sorting by priority from high to low.

[0076] In this embodiment, the core functional module refers to the most critical functional combination that is first implemented when developing a naked-eye 3D editor, including: a parallax adjustment module: processing parallax calculation and adjustment in naked-eye 3D effects; a depth rendering module: responsible for rendering depth information of 3D scenes; a basic user interface control module: implementing basic user interface controls and interactive operations.

[0077] In this embodiment, the naked-eye 3D editor is used to create, edit and optimize naked-eye 3D content. It integrates various core functional modules and provides a user-friendly interface, allowing developers to efficiently create applications or content with naked-eye 3D effects.

[0078] The working principle and beneficial effects of the above technical solution are: by classifying user needs, conducting core technology research, analyzing the advantages and disadvantages of different implementation solutions, listing a demand-function table, determining the core functional modules according to priority, and finally developing a naked-eye 3D editor, user-demand-oriented function development is achieved, ensuring the focus and sequence of development, improving development efficiency and product quality, and at the same time optimizing technical implementation through technical research, enhancing the applicability and maintainability of the project.

[0079] Example 3:

[0080] An embodiment of the present invention provides a method for rapidly generating a glasses-free 3D Windows executable program, which sorts the functions to be added according to priority, determines the corresponding core functional modules based on the sorting results, and develops a glasses-free 3D editor based on the core functional modules, including:

[0081] Assign the features to be added into the corresponding categories of must have, should have, could have, and won't have;

[0082] The core functional modules are determined according to the category allocation results, and a naked-eye 3D editor is developed based on the core functional modules, wherein the core modules include a parallax adjustment module, a depth rendering module, and a basic user interface control module.

[0083] In this embodiment, an example of assigning corresponding categories is to assume that we have the following functions to be added, and they need to be assigned to corresponding categories: parallax adjustment, depth rendering, basic user interface, high-precision color calibration, scene animation, touch interaction support, and virtual reality support. The result of the category assignment is: there must be a category containing parallax adjustment, depth rendering, and basic user interface; there should be categories: scene animation and touch interaction support; there can be categories: high-precision color calibration and virtual reality support; there will not be a category: complex data analysis function (assuming it is not needed in the current version).

[0084] In this embodiment, the step of determining the core functional modules is to screen out the most basic and critical functions from the "must have" function list; and define the screened out basic functions as the core functional modules.

[0085] In this embodiment, the process of developing a naked-eye 3D editor is to design the architecture and interface of the core modules to ensure collaboration and integration between modules, parallax adjustment module: responsible for parallax calculation and adjustment, depth rendering module: responsible for depth rendering of 3D scenes, user interface basic control module: provides basic UI controls; implement each core functional module according to the design document, parallax adjustment module: develop parallax calculation algorithm, provide adjustment interface, depth rendering module: integrate depth information rendering technology, user interface basic control module: develop UI controls and interaction logic; integrate each core module into a unified naked-eye 3D editor, so that it has the basic functions of creating and editing naked-eye 3D content.

[0086] The working principle and beneficial effects of the above technical solution are: by classifying the functions to be added into must-have, should-have, can-have and will not-have, and determining the core functional modules based on the classification results, including parallax adjustment, depth rendering and basic user interface control, a naked-eye 3D editor is developed based on these core modules, which improves development efficiency and product quality, and enhances the stability of the project and user experience.

[0087] Example 4:

[0088] An embodiment of the present invention provides a method for rapidly generating a glasses-free 3D Windows executable program, which performs detail level classification on glasses-free 3D technology based on key dimensions, obtains detail level grades, and performs SDK packaging on the corresponding grades, including:

[0089] Splitting the core functional module into multiple key dimensions, and refining the functions of the key dimensions to obtain a refined functional vector for each key dimension;

[0090] Determining a level of detail of a key dimension of each refined function vector from a function-level library, wherein the level of detail includes basic functions, intermediate functions, and advanced functions;

[0091] Establishing a corresponding level version of an LOD model according to the level of detail level, determining an observation distance range for switching between different level versions of the LOD model according to user requirements, and determining automatic switching parameters of the corresponding LOD model at different observation distances according to the observation distance range, performing a first configuration on the corresponding LOD model according to the automatic switching parameters, and obtaining a first configuration result of the LOD model;

[0092] Determine the depth parameters for the second configuration according to the characteristics of the autostereoscopic 3D display, perform the second configuration based on the first configuration result to obtain the second configuration result, use the autostereoscopic 3D editor to export the parameters of the second configuration result, and encapsulate the export result with the SDK to obtain the SDK package corresponding to the autostereoscopic 3D.

[0093] In this embodiment, the refined function vector is a list of function items obtained by specifically refining each key dimension. For example, for parallax calculation: [0.1] Support binocular parallax calculation, [0.2] Provide real-time parallax calculation function; for parallax adjustment: [1.1] Support manual adjustment of parallax, [1.2] Support automatic parallax adjustment function; for parallax preset: [2.1] Provide scene preset function, [2.2] Provide user-defined preset function.

[0094] In this embodiment, the function-hierarchy library is a structure that classifies and stores the refined function vectors according to the hierarchical levels, including: the basic function library contains the basic technologies for implementing basic functions (such as basic parallax calculation); the intermediate function library contains more complex functions (such as real-time parallax calculation); the advanced function library contains advanced technologies and features (such as user-defined parallax preset).

[0095] In this embodiment, the versions of the LOD model include: the basic version: implement basic functions to ensure the framework works and the core functions are available; the intermediate version: add intermediate functions (such as real-time calculation) on the basis of the basic version; the advanced version: add advanced functions (such as user-defined functions) on the basis of the intermediate version.

[0096] In this embodiment, the viewing distance range is determined according to the requirements of each level model and the requirements of the display effect. For example, for the basic version: long-distance display, with fewer details, but ensuring the main structure is clear, while for the advanced version: close-range display, with high-precision details, suitable for fine observation.

[0097] In this embodiment, the automatic switching parameters are determined according to the viewing distance and performance requirements. For example, regarding the distance threshold, when the distance is <X meters, the advanced version is used.

[0098] In this embodiment, the first configuration result is the LOD model configuration set according to the automatic switching parameters, ensuring that the model can automatically switch at different viewing distances.

[0099] In this embodiment, the depth parameters are specific parameters of the autostereoscopic 3D display, used to determine the depth stereoscopic effect of the 3D scene, such as: parallax distance, depth field information, etc.

[0100] In this embodiment, the second configuration result is based on the first configuration result and is adjusted according to the depth parameters to optimize the display effect of the autostereoscopic 3D.

[0101] In this embodiment, parameter export refers to exporting all configured parameters in a naked-eye 3D editor in a specific file format for SDK packaging: Export: Generate a configuration file (such as JSON, XML, etc.), Packaging: Package the generated configuration file together with the model into an SDK.

[0102] The working principle and beneficial effects of the above technical solution are: by splitting the core functional modules into key dimensions and refining the functions, using the level of detail level to establish the LOD model, configuring the parameters according to the observation distance and the characteristics of the naked-eye 3D display, and finally exporting and packaging it into an SDK, the balance between performance and visual effects is ensured, the user experience is improved through automatic switching of the LOD model and parameter optimization, and the modular SDK packaging improves development efficiency and maintainability to adapt to different application scenarios and needs.

[0103] Example 5:

[0104] An embodiment of the present invention provides a method for quickly generating a glasses-free 3D Windows executable program. The method includes creating a new Unity project, first importing the Unity project according to an SDK package, and specifying the glasses-free 3D effect to be achieved according to a requirements-function table. The method then performs a second import on the Unity project. The method then determines a glasses-free 3D template based on the results of the first and second imports, including:

[0105] Select a 3D project template related to naked-eye 3D technology based on the Unity project. At the same time, download the SDK package corresponding to the naked-eye 3D technology, select all resources in the SDK package for the first import, and perform the first import configuration of the 3D project template according to the first import result;

[0106] According to the requirements-function table, the naked-eye 3D effects to be achieved are listed, the required resource vectors and interactive display effects are determined based on the naked-eye 3D effects, a second import is performed based on the resource vectors and interactive display effects, and the second import configuration of the 3D project template is performed based on the second import result;

[0107] All the import configuration results of the first import configuration and the second import configuration are integrated to save the current 3D project template as a naked eye 3D template.

[0108] In this embodiment, the 3D project template is a basic project framework pre-set in the Unity project, which includes basic 3D settings, scenes, cameras, lights, etc., so that developers can quickly start a 3D project.

[0109] In this embodiment, the first import configuration is to initialize the configuration of the SDK resources and project templates imported for the first time to ensure the normal operation of the basic functions of the project, including: confirming that all SDK resources are imported correctly; setting basic parameters related to naked-eye 3D (such as parallax, depth, etc.); configuring basic scenes and cameras to adapt to naked-eye 3D display.

[0110] In this embodiment, the naked-eye 3D effect refers to the 3D visual effect achieved through specific display technology without wearing specific glasses or equipment. The specific effects include: parallax effect: presenting different images through different perspectives to form a 3D sense; depth effect: showing the front and back relationship of objects to generate a three-dimensional effect; multi-view switching: dynamically adjusting the perspective according to the viewer's position; interactive effect: dynamically updating 3D content according to user input.

[0111] In this embodiment, the resource vector is a collection of all resources required to achieve the naked eye 3D effect, including: 3D models (such as character models, scene models), materials and maps (high-definition texture maps, surface materials), scripts (control logic, perspective switching)

[0112] In this embodiment, the interactive display effect is the visual and operational feedback when the user interacts with the 3D content, including: user gestures or input devices controlling 3D objects, real-time perspective switching and updating, and dynamic responses (such as clicking, dragging, zooming in and out).

[0113] In this embodiment, the second import configuration is to perform specific functional and structural configuration on the resources imported for the second time, including: configuring the position, size and behavior of the 3D model, setting the display parameters of the material and texture, configuring complex interaction logic and dynamic switching of multiple perspectives, optimizing performance, and ensuring that all resources work normally in the naked-eye 3D display.

[0114] In this embodiment, the comprehensive import configuration result is a comprehensive result: integrating all configuration results of the first import and the second import to ensure that the project can run smoothly in the naked eye 3D environment; saving the template: saving the configured project as a naked eye 3D template to facilitate subsequent rapid creation and editing of naked eye 3D content.

[0115] The working principle and beneficial effects of the above technical solution are: by selecting the relevant 3D project template in the Unity project, importing the SDK resources and requirements of the naked-eye 3D technology in two steps - the resources and effects in the function table, configuring and integrating the import results, and finally saving them as a naked-eye 3D template, ensuring the accurate integration of resources and effects, improving the development efficiency of the naked-eye 3D template, and at the same time ensuring that the final template is fully functional and has optimized effects, providing a reliable foundation for subsequent applications.

[0116] Example 6:

[0117] An embodiment of the present invention provides a method for rapidly generating a naked-eye 3D Windows executable program, which performs comprehensive testing on a naked-eye 3D template, including:

[0118] Simulate various user interactions item by item according to the requirements-function table, perform a first test on the response and event triggering, and obtain a first test result;

[0119] Recording average frame rates corresponding to the entire time period under different scene operations, calculating the instantaneous frame rate under the corresponding scene operation and the corresponding average instantaneous frame rate, comparing the average frame rate with the average instantaneous frame rate to obtain a first comparison result, comparing the average frame rate with the first preset range to obtain a second comparison result, determining a geometric multiple of the second preset range based on the complexity of the corresponding scene operation, and then multiplying the geometric multiple by the first preset range to obtain the second preset range, wherein the instantaneous frame rate and the corresponding average instantaneous frame rate are calculated based on a preset time window;

[0120] Comparing the instantaneous frame rate with a second preset range under the corresponding scene operation to obtain a third comparison result;

[0121] Determine a second detection result according to the first comparison result, the second comparison result, and the third comparison result;

[0122] Conduct user operation simulations, conduct a third test on the smoothness and correctness of the UI and interaction, and obtain the third test results;

[0123] The first, second and third test results are combined to determine whether the naked-eye 3D template is qualified.

[0124] In this embodiment, the average frame rate refers to the ratio of the number of frames rendered by the program to the time over a longer period of time, which provides the overall performance of the program within the period of time. For example, if a program renders 1800 frames in 30 seconds, then the average frame rate = 1800 frames / 30 seconds = 60 FPS, which is used to measure the stability and performance of the program during long-term operation and is an important indicator for comprehensive performance evaluation.

[0125] In this embodiment, the instantaneous frame rate refers to the ratio of the program's frame rate to the time within a very short period of time (such as one or more frames), reflecting the program's performance at the current moment. The instantaneous frame rate is typically calculated at the end of each frame, calculating the interval between it and the previous frame. FPS = 1 / rendering time. For example, if the rendering time for a frame is 16 milliseconds, then the instantaneous frame rate = 1 / 0.016 seconds ≈ 62.5 FPS. This captures the program's performance at an instant and can be used to detect momentary freezes or performance fluctuations.

[0126] In this embodiment, the average instantaneous frame rate is the average frame rate calculated within a short time window, such as the last few seconds or dozens of frames. It lies between the instantaneous frame rate and the long-term average frame rate. Within a specific time window, the ratio of all frames and times within that window is calculated. For example, if 7200 frames were rendered within the last 2 seconds (120 frames), then the average instantaneous frame rate = 7200 frames / 120 seconds = 60 FPS. This captures performance over a short period of time and can reflect performance trends within a smaller range.

[0127] In this embodiment, the relationship between the three is hierarchical: the instantaneous frame rate is the finest-grained frame rate calculation, which is almost frame by frame; the average instantaneous frame rate is the average of the frame rates in a short time window, which slightly smoothes the fluctuations of the instantaneous frame rate; the average frame rate is the average of the frame rates over a long time range, which is a global performance indicator; in terms of time scale, the instantaneous frame rate considers the momentary performance between each frame and the previous frame; the average instantaneous frame rate considers the average performance over a short period of time; the average frame rate considers the global performance during the entire evaluation period; in terms of application scenarios, the instantaneous frame rate is often used to capture instantaneous performance problems, such as freezes; the average instantaneous frame rate is used to observe the stability of the program in a short period of time; and the average frame rate is used to evaluate the long-term stability and performance of the overall operation of the program.

[0128] In this embodiment, the first detection result is a preliminary detection result obtained by simulating the user interaction process item by item according to the demand-function table, observing the system response and event triggering, including whether the system performs the corresponding interaction and event triggering as expected, in order to verify whether the basic functions of the system meet the design specifications.

[0129] In this embodiment, the first comparison result is the result of comparing the average frame rate under different scene operations with the instantaneous frame rate and the average instantaneous frame rate, in order to determine whether the frame rate performance in different operation scenarios is consistent with expectations and whether there are large fluctuations or instability.

[0130] In this embodiment, the second comparison result is the result obtained by comparing the average frame rate (which may be the average frame rate in long-term operation) with the first detection result (functional response and event triggering), in order to combine the smoothness and stability of the system function to determine whether the system performance meets the standards.

[0131] In this embodiment, the third comparison result is the result of comparing the instantaneous frame rate with the second preset range under the corresponding scene operation, in order to ensure whether the instantaneous frame rate can be maintained within a reasonable range under different operation complexities and to ensure the smoothness of the system under various operation conditions.

[0132] In this embodiment, the second detection result is a result comprehensively judged based on the first comparison result, the second comparison result and the third comparison result, in order to provide a comprehensive performance evaluation, including the frame rate performance and stability of the system in different scenarios.

[0133] In this embodiment, the third detection result is obtained by further simulating user operations to detect the smoothness and correctness of the UI and interaction, in order to ensure that the actual operation experience and interaction logic of the user interface meet expectations.

[0134] In this embodiment, the qualification determination process is to determine the final quality of the naked-eye 3D template based on the results of the comprehensive evaluation, in order to finally confirm whether the naked-eye 3D template meets the predetermined quality standards and user experience requirements.

[0135] The working principle and beneficial effects of the above technical solution are: by simulating user interactions item by item, recording frame rates, comparing instant and average frame rates, and setting preset ranges according to the complexity of the scene, the smoothness and correctness of the UI and interaction are detected in stages, and the comprehensive results are used to make qualified judgments, thereby ensuring the high performance and high quality of the naked-eye 3D template, comprehensively improving the user experience, ensuring that the functions and performance meet the standards, and providing stable and reliable naked-eye 3D applications.

[0136] Example 7:

[0137] An embodiment of the present invention provides a method for rapidly generating a glasses-free 3D Windows executable program, recording the average frame rate corresponding to the entire time period under different scene operations, and calculating the instantaneous frame rate under the corresponding scene operation and the corresponding average instantaneous frame rate, including:

[0138] Calculate the instantaneous frame rate:

[0139] ;in, Indicates the instantaneous frame rate at time t; A constant coefficient representing the scaling frame rate; Indicates the dynamic adjustment factor of the frame rate at time t; represents a small constant and ; represents the additional time-related adjustment factor at time t; Represents the time distance of the frame Variable rendering times; Represents the weight of the i-th frame; M represents a total of M frames in the current scene operation; i represents the i-th frame in the current scene operation;

[0140] Calculate the average real-time frame rate:

[0141] ;in, represents the average instantaneous frame rate at time t; Represents the historical frame rate adjustment factor between the i-th frame and time t; Represents the time distance of the frame The associated nonlinear weighting parameters; represents the nonlinear weighting factor; Represents the time distance of the frame exponential decay factor of the change; represents the exponential decay coefficient; represents the instantaneous frame rate of the i-th frame; n represents the size of the time window.

[0142] The working principle and beneficial effects of the above technical solution are: by simulating user interactions item by item, recording frame rates, comparing instant and average frame rates, and setting preset ranges according to the complexity of the scene, the smoothness and correctness of the UI and interaction are detected in stages, and the comprehensive results are used to make qualified judgments, thereby ensuring the high performance and high quality of the naked-eye 3D template, comprehensively improving the user experience, ensuring that the functions and performance meet the standards, and providing stable and reliable naked-eye 3D applications.

[0143] Example 8:

[0144] The embodiment of the present invention provides a method for quickly generating a glasses-free 3D Windows executable program. If qualified, the glasses-free 3D template is packaged and published, a corresponding Windows executable program is generated, and subsequent interaction between the glasses-free 3D editor and the glasses-free 3D environment software is tested, including:

[0145] Save the naked eye 3D template object as a prefab, use the naked eye 3D editor based on the Unity project to package the prefab, and obtain the corresponding executable 3D scene program;

[0146] The adaptability of the executable 3D scene program is tested in Windows systems with different configurations, and the executable 3D scene program is released according to the adaptability test results.

[0147] In this embodiment, a prefab is a template that stores a game object and its components, properties, and sub-objects, allowing developers to create, configure, and store one or more game objects, and then repeatedly instantiate these objects in the game scene. For example, an enemy unit, tree, building, etc. can be set as a prefab so that they can be reused in multiple scenes and locations.

[0148] In this embodiment, adaptability refers to the condition of the executable 3D scene program running in Windows systems with different configurations. The purpose of the adaptability test is to ensure that the program can run normally in Windows environments with various hardware and software configurations.

[0149] In this embodiment, the corresponding steps for adaptability judgment are test plan formulation: determining the Windows configuration combination that needs to be tested, including different operating system versions and hardware configurations; environment construction: preparing multiple test machines, or using virtual machines / cloud services to simulate different hardware and software environments; executing tests: executing program tests according to the test plan, and recording performance data and problems in each test environment; problem fixing and retesting: fixing problems found in the test, and then retesting to verify whether the problems are solved; report generation: integrating all test results, generating an adaptability test report, and confirming whether the program meets the adaptability requirements in the target system configuration.

[0150] In this embodiment, the release process is to decide whether to release the executable 3D scene program based on the adaptability test result. Only after it is determined that the program can run normally under various system configurations can it be officially released.

[0151] The working principle and beneficial effects of the above technical solution are: by saving the naked-eye 3D template as a prefab, using the naked-eye 3D editor in the Unity project to package it into an executable program, and testing the adaptability under different Windows configurations, and publishing it according to the test results, the compatibility and stability of the naked-eye 3D application in different hardware configurations and operating system environments are ensured, the applicability and user experience of the product are improved, and the quality of the released program is ensured to be reliable.

[0152] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit it. Although the present invention has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A method for rapidly generating a naked-eye 3D Windows executable program, characterized in that: include: Step 1: Obtain user needs and conduct technical research on naked-eye 3D technology to obtain a demand-function table. Based on the demand-function table, determine the functions to be added and quickly develop a naked-eye 3D editor based on the functions to be added. Step 2: Classify the level of detail of the naked-eye 3D technology based on key dimensions, obtain the level of detail level, and encapsulate the corresponding level into SDK; Step 3: Create a new Unity project, import the Unity project according to the SDK package, and specify the naked eye 3D effect to be achieved according to the requirements-function table. Import the Unity project again and determine the naked eye 3D template based on the results of the first and second imports. Step 4: Perform comprehensive testing on the naked-eye 3D template. If qualified, save the naked-eye 3D template as a prefabricated body, package and publish the prefabricated body, and generate a corresponding Windows executable program.

2. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 1, wherein: Obtain user needs and conduct technical research on naked-eye 3D technology to obtain a demand-function table. Based on the demand-function table, determine the functions to be added. Based on the functions to be added, quickly develop a naked-eye 3D editor, including: Functionally classify the acquired user requirements and produce a requirements document; Analyze the core technologies of naked-eye 3D, study the advantages and disadvantages of different implementation schemes of the corresponding technologies and their applicable scenarios, and produce a technical research report; List the requirements-function table based on the requirements document and technical research report, and then determine the functions to be added; The functions to be added are sorted according to priority, and corresponding core function modules are determined according to the sorting results, and a naked-eye 3D editor is developed based on the core function modules.

3. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 2, wherein: Sort the functions to be added according to their priorities, determine the corresponding core functional modules based on the sorting results, and develop a naked-eye 3D editor based on the core functional modules, including: Assign the features to be added into the corresponding categories of must have, should have, could have, and won't have; The core functional modules are determined according to the category allocation results, and a naked-eye 3D editor is developed based on the core functional modules, wherein the core functional modules include a parallax adjustment module, a depth rendering module, and a basic user interface control module.

4. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 3, wherein: The naked eye 3D technology is graded based on key dimensions to obtain detail levels, and the corresponding levels are packaged into SDKs, including: Splitting the core functional module into multiple key dimensions, and refining the functions of the key dimensions to obtain a refined functional vector for each key dimension; Determining a level of detail of a key dimension of each refined function vector from a function-level library, wherein the level of detail includes basic functions, intermediate functions, and advanced functions; Establishing a level of detail (LOD) model of a corresponding level version according to the level of detail level, determining an observation distance range for switching between different levels of LOD models according to user requirements, determining automatic switching parameters of the corresponding LOD models at different observation distances according to the observation distance range, performing a first configuration on the corresponding LOD model according to the automatic switching parameters, and obtaining a first configuration result of the LOD model; Determine the depth parameters of the second configuration based on the characteristics of the naked-eye 3D display, perform the second configuration based on the first configuration result, obtain the second configuration result, use the naked-eye 3D editor to export the parameters of the second configuration result, and encapsulate the exported result into SDK to obtain the SDK encapsulation package corresponding to the naked-eye 3D.

5. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 1, wherein: Create a new Unity project, import the Unity project first according to the SDK package, and specify the naked eye 3D effect to be achieved according to the requirements-function table. Import the Unity project secondly, and determine the naked eye 3D template based on the results of the first and second imports, including: Select a 3D project template related to naked-eye 3D technology based on the Unity project. At the same time, download the SDK package corresponding to the naked-eye 3D technology, select all resources in the SDK package for the first import, and perform the first import configuration of the 3D project template according to the first import result; According to the requirements-function table, the naked-eye 3D effects to be achieved are listed, the required resource vectors and interactive display effects are determined based on the naked-eye 3D effects, a second import is performed based on the resource vectors and interactive display effects, and the second import configuration of the 3D project template is performed based on the second import result; All the import configuration results of the first import configuration and the second import configuration are integrated to save the current 3D project template as a naked eye 3D template.

6. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 1, characterized in that: Comprehensive testing of naked-eye 3D templates, including: Simulate various user interactions item by item according to the requirements-function table, perform a first test on the response and event triggering, and obtain a first test result; Recording average frame rates corresponding to the entire time period under different scene operations, calculating the instantaneous frame rate under the corresponding scene operation and the corresponding average instantaneous frame rate, comparing the average frame rate with the average instantaneous frame rate to obtain a first comparison result, comparing the average frame rate with the first preset range to obtain a second comparison result, determining a geometric multiple of the second preset range based on the complexity of the corresponding scene operation, and then multiplying the geometric multiple by the first preset range to obtain the second preset range, wherein the instantaneous frame rate and the corresponding average instantaneous frame rate are calculated based on a preset time window; Comparing the instantaneous frame rate with a second preset range under the corresponding scene operation to obtain a third comparison result; Determine a second detection result according to the first comparison result, the second comparison result, and the third comparison result; Conduct user operation simulations, conduct a third test on the smoothness and correctness of the UI and interaction, and obtain the third test results; The first, second and third test results are combined to determine whether the naked-eye 3D template is qualified.

7. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 6, characterized in that: Record the average frame rate of the entire time period under different scene operations, and calculate the real-time frame rate under the corresponding scene operation and the corresponding average real-time frame rate, including: Calculate the instantaneous frame rate: ;in, Indicates the instantaneous frame rate at time t; A constant coefficient representing the scaling frame rate; Indicates the dynamic adjustment factor of the frame rate at time t; represents a small constant and ; represents the additional time-related adjustment factor at time t; Represents the time distance of the frame Variable rendering times; Represents the weight of the i-th frame; M represents a total of M frames in the current scene operation; i represents the i-th frame in the current scene operation; Calculate the average real-time frame rate: ;in, represents the average instantaneous frame rate at time t; Represents the historical frame rate adjustment factor between the i-th frame and time t; Represents the time distance of the frame The associated nonlinear weighting parameters; represents the nonlinear weighting factor; Represents the time distance of the frame exponential decay factor of the change; represents the exponential decay coefficient; represents the instantaneous frame rate of the i-th frame; n represents the size of the time window.

8. The method for rapidly generating a naked-eye 3D Windows executable program according to claim 1, characterized in that: If qualified, the naked eye 3D template is saved as a prefab, the prefab is packaged and published, and a corresponding Windows executable program is generated, including: Save the naked eye 3D template object as a prefab, use the naked eye 3D editor based on the Unity project to package the prefab, and obtain the corresponding executable 3D scene program; The adaptability of the executable 3D scene program is tested in Windows systems with different configurations, and the executable 3D scene program is released according to the adaptability test results.

Images