CN116243890A - Serialization persistence release method for Unity scene - Google Patents
Serialization persistence release method for Unity scene Download PDFInfo
- Publication number
- CN116243890A CN116243890A CN202211721111.2A CN202211721111A CN116243890A CN 116243890 A CN116243890 A CN 116243890A CN 202211721111 A CN202211721111 A CN 202211721111A CN 116243890 A CN116243890 A CN 116243890A
- Authority
- CN
- China
- Prior art keywords
- serialization
- picture
- scene
- component
- file
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Human Computer Interaction (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a serialization persistence release method for a Unity scene, which comprises the following steps: acquiring a Unity scene; according to the Unity scene, carrying out page layout description document structure definition to obtain a serialization assembly; carrying out serialization processing according to the serialization assembly to obtain a serialization file; performing persistence processing according to the serialized file to obtain a persistence storage database; and carrying out inverse sequence instantiation of the serialization assembly according to the persistent storage database to realize inverse serialization rendering display release of the Unity scene. The method and the device realize serialization processing, persistence processing and inverse serialization rendering display release of the Unity scene, bypass the complex packaging flow of the Unity scene, greatly improve the project release speed and the project release size, and improve the project release efficiency.
Description
Technical Field
The invention relates to a serialization persistence release method for a Unity scene, and belongs to the technical field of three-dimensional visualization.
Background
The conventional Unity Scene release needs to edit, compile and package the Scene, and when the Scene is packaged, the Unity can fully throw all Resources in the Resources folder into the inclusion, so that the released engineering file is large, and when the Scene content is changed, the Scene, the script and the resource file need to be fully compiled, packaged and released each time, although the Unity provides an assembly base packaging mode for the situation, the resource directory structure needs to be pre-set, and the unpacking assembly base package needs to be removed when the resource is changed, so that the Scene with frequent requirement change is very low-efficiency, and a simple and quick mode for quickly releasing the serialized and deserialized Scene is needed.
The information disclosed in this background section is only for enhancement of understanding of the general background of the invention and should not be taken as an acknowledgement or any form of suggestion that this information forms the prior art already known to a person of ordinary skill in the art.
Disclosure of Invention
The invention aims to overcome the defects in the prior art, and provides a serialization persistence release method for a Unity scene, which realizes serialization processing, persistence processing and inverse serialization rendering display release of the Unity scene, bypasses the complex packaging flow of the Unity scene, greatly improves the project release speed and the project release size, and improves the project release efficiency.
In order to achieve the above purpose, the invention is realized by adopting the following technical scheme:
the invention discloses a serialization persistence release method for a Unity scene, which comprises the following steps:
acquiring a Unity scene;
according to the Unity scene, carrying out page layout description document structure definition to obtain a serialization assembly;
carrying out serialization processing according to the serialization assembly to obtain a serialization file;
performing persistence processing according to the serialized file to obtain a persistence storage database;
and according to the persistent storage database, performing inverse sequence instantiation of the serialization assembly to realize inverse serialization rendering display release of the Unity scene.
Further, the serialization component comprises a conventional attribute component, a custom component, a built-in component and a resource type component;
the conventional properties component includes string, int, float, char, bool;
the custom components comprise a data set SQL data set VSDataSQL, excel data set VSDataShellet and a data source VSHttp component;
the built-in components comprise a camera component Camera, canvas, canvasGroup, canvasScaler, graphicRaycaster, a color Color, colorsGroup, rectTransform, transform, unityEvent, two-dimensional data Vector2, three-dimensional data Vector3, image, mask and Text;
the resource type components comprise GameObject, material, effect, font fonts, sprite pictures and three-dimensional models.
Further, the serialization process includes:
marking the serialization assembly by using the JSOnObject, namely creating a JSON object JObject of the serialization assembly, wherein the complete path of the assembly is taken as an attribute name, and the serialization JSON character string is taken as an attribute value;
aiming at the marked conventional attribute components, using JSOnProperty characteristics to mark fields needing serialization, and then using JSOnConverter to carry out serialization to obtain corresponding serialization files;
and aiming at the marked custom component, built-in component or resource type component, a corresponding custom serialization converter is used to obtain a corresponding serialization file.
Further, for the marked custom component, a serialization converter based on custom types:
obtaining an instance object JObject of a serialization converter of a custom type;
executing a corresponding serialization method of the component, and assigning the result to a customJson attribute of the JObject;
serializing the residual marked as JSOnProperty attribute through JSOnConvertet, and assigning the result to the selfJson attribute of the Jobject;
and finally, serializing the JObject to form a key value pair json object by using the custom component class name and the serialized character string, thereby obtaining a corresponding serialized file.
Further, for the marked built-in components, a serialization converter based on the built-in components,
obtaining an instance object JObject of a serialization converter of a built-in component;
and executing a corresponding serialization method of the component, and forming a json object by using the built-in component class name and the serialized character string to obtain a corresponding serialized file.
Further, for the marked resource type component, based on a serialization converter of the resource type component, a resource path is obtained as a serialization attribute value, and a key value pair json object is formed by the resource type component class name and the serialized character string, so that a corresponding serialized file is obtained.
Further, the persistent storage database comprises a template type data table, a picture grouping directory data table, a picture template data table and a picture file data table;
the template type data table is used for storing the attributes such as the length and the width of a single screen, the number of rows and the number of columns of a definition rendering display container;
the picture grouping directory data table is used for storing grouping directory information defining a scene;
the picture template data table is used for storing attribute information of a design page, including information such as picture names, template types, grouping directory information, deletion states, sub-picture IDs and the like;
the picture file data table is used for storing a scene content serialization file, and the file data stream is stored in a table field of a BLOG type.
Further, the persistence process includes:
respectively constructing a template type data table, a picture grouping directory data table, a picture template data table and a picture file data table;
configuring and obtaining a template type, a picture grouping directory and a picture template according to the serialization file;
generating a template type object according to the template type, and persisting the template type object into a template type data table based on the Hibernate;
generating a picture grouping directory object according to the picture grouping directory, and persisting the picture grouping directory object into a picture grouping directory data table based on the Hibernate;
generating a picture template object according to the picture template, and persisting the picture template object into a picture template data table based on the Hibernate;
and generating a picture file entity object from the json file in the serialization file in a byte array form, and persisting the picture file entity object to a picture file data table based on the Hibernate.
Further, the inverse serialization rendering of the Unity scene shows the release, including:
obtaining a serialized file of the picture scene according to the persistence storage database;
performing anti-serialization processing on the serialized files of the picture scenes, traversing all components in the scenes, and performing anti-sequence instantiation one by one to realize instantiation of the picture scenes;
the switching of the picture scenes can be realized through a preset scene control management component.
Compared with the prior art, the invention has the beneficial effects that:
on one hand, the invention realizes serialization and persistence by dividing the Unity scene into serialization components; on the other hand, through the anti-serialization instantiation processing of the serialization assembly, the anti-serialization rendering display release of the Unity scene is realized, the problems of complicated compiling, packing and deploying processes and low efficiency of the conventional Unity scene are solved, the complicated packing process of the Unity scene is bypassed, the project release speed and the project release size are greatly improved, and the project release efficiency is improved.
Drawings
FIG. 1 is a flow chart of a method of serialized persistent publishing for a Unity-oriented scenario;
FIG. 2 is a flow chart of a serialization process;
FIG. 3 is a flow chart of a persistence process;
FIG. 4 is a serialized rendering presentation flow diagram;
FIG. 5 is a cascade relationship of data tables.
Detailed Description
The invention is further described below with reference to the accompanying drawings. The following examples are only for more clearly illustrating the technical aspects of the present invention, and are not intended to limit the scope of the present invention.
The invention discloses a serialization persistence release method facing a Unity scene, which is shown in fig. 1 and comprises the following steps:
acquiring a Unity scene;
according to the Unity scene, carrying out page layout description document structure definition to obtain a serialization assembly;
carrying out serialization processing according to the serialization assembly to obtain a serialization file;
performing persistence processing according to the serialized file to obtain a persistence storage database;
and carrying out inverse sequence instantiation of the serialization assembly according to the persistent storage database to realize inverse serialization rendering display release of the Unity scene.
The technical conception of the invention is as follows: on one hand, the Unity scene is divided into serialization components, so that serialization processing and persistence processing are realized; on the other hand, through the anti-serialization instantiation processing of the serialization assembly, the anti-serialization rendering display release of the Unity scene is realized, the problems of complicated compiling, packing and deploying processes and low efficiency of the conventional Unity scene are solved, the complicated packing process of the Unity scene is bypassed, the project release speed and the project release size are greatly improved, and the project release efficiency is improved.
The method comprises the following specific steps:
step one: and serializing the components.
Firstly, defining a directory structure of Unity scene editing and a document structure of a serialized page layout description file, wherein the scene serialized file is described in a key value pair mode and comprises contents such as whether a scene, a scene name, a template scene, a scene component structure and the like are loaded, the scene content is all component information of a scene, and elements in the scene are mainly divided into a conventional attribute component, a custom component, a built-in component and a resource type component; the elements in the scene mainly comprise node elements such as the scene, camera components, custom controls, built-in controls, data sets, events, operators, animations, three-dimensional models and the like, and the specific attribute list can be increased or decreased according to actual requirements.
Specifically, conventional attribute components, including string, int, float, char, bool;
custom components, including a dataset SQL dataset VSDataSQL, excel dataset VSDataSheaet, a data source VSHttp component;
built-in components including camera component Camera, canvas, canvasGroup, canvasScaler, graphicRaycaster, color Color, colorsGroup, rectTransform, transform, unityEvent, two-dimensional data Vector2, three-dimensional data Vector3, image, mask, and Text;
resource type components including GameObject, material, effect, font fonts, sprite pictures, three-dimensional models.
The specific scene page layout description document template has the following structure:
scene (one):
(II) conventional Property Components:
and (III) a custom component:
(IV) built-in components:
and (V) a resource component:
and (six) a scene control management component:
step two: the file is serialized.
When the Unity scene content is serialized, firstly, a serialization component class is marked by [ JSOnObject (membrane serialization. OptIn) ], for the conventional type attribute, fields needing to be serialized are marked by [ JSOnProperty ] characteristics, for the complex type attribute, including a custom component, a built-in component and a resource component, corresponding serialization converters are required to be customized, attribute field association is carried out by [ JSOnConverter (typeof (XXJsonConverter)) ], and when the whole component class serialization method is executed, the corresponding serialization converters are called to realize serialization.
Specifically, as shown in fig. 2:
marking the serialization assembly by using [ JSOnObject (memberseriation. OptIn) ] to create JSON object JObject of the serialization assembly, wherein the complete path of the assembly is taken as an attribute name, and the serialization JSON character string is taken as an attribute value;
aiming at marked conventional attribute components, such as string, int, float, char, bool, fields needing to be serialized are marked by using JsonProperty characteristics, default without marking is not serialized, and then serialization is carried out by using JsonConverter, so that a corresponding serialized file is obtained;
and aiming at the marked custom component, built-in component or resource type component, using a corresponding custom serialization converter, and carrying out attribute field association by using [ JsonConverter (typeof (XXJsonConverter)) ] to obtain a corresponding serialization file.
Further, for the marked custom component, a serialization converter based on custom types:
creating a JSON object JObject of the custom component, and acquiring an instance object JObject of a serialization converter of a custom type;
executing a corresponding serialization method of the component, and assigning the result to a customJson attribute of the JObject;
serializing the residual marked as JSOnProperty attribute through JSOnConvertet, and assigning the result to the selfJson attribute of the Jobject;
and finally, serializing the JObject to form a key value pair json object by using the custom component class name and the serialized character string, thereby obtaining a corresponding serialized file.
Further, for the marked built-in components, a serialization converter based on the built-in components,
obtaining an instance object JObject of a serialization converter of a built-in component;
and executing a component corresponding serialization method ComponentToJson (), and forming a key value pair json object by using the built-in component class name and the serialized character string to obtain a corresponding serialization file.
Further, for the marked resource type component, based on a serialization converter of the resource type component, a resource path is obtained as a serialization attribute value, and a key value pair json object is formed by the resource type component class name and the serialized character string, so that a corresponding serialized file is obtained.
It should be noted that, the custom component, the built-in component and the resource component cannot be directly serialized, and respective Json converters xxjson converters are required, and the converters inherit the icomponentconnentconvertinterface interface, so that only required component data is manually spliced into Json object attributes and attribute values during component serialization, and then serialization processing is performed, and data is assigned to the component objects during deserialization to realize data conversion.
The user-defined assembly comprises a scene control management assembly, the scene control management assembly is serialized, after each scene is designed, the scene is switched by adopting a keyboard key, a unified switching management interface is needed for the association mapping of the keyboard key value and the scene, and when the scene is serialized, only the keyboard key Key code and the scene name SceneName are required to be associated together.
Step three: the database is persisted.
After the serialization of the scene, storing the file into a persistence storage database, wherein the persistence storage database comprises a template type data table, a picture grouping directory data table, a picture template data table and a picture file data table, and realizing the persistence and management functions of the scene serialization file through the data tables. The cascade of data tables is shown in fig. 5.
The specific steps are shown in fig. 3:
(1) Respectively constructing a template type data table, a picture grouping directory data table, a picture template data table and a picture file data table;
(2) Configuring and obtaining a template type, a picture grouping directory and a picture template according to the serialization file;
(3) Generating a template type object according to the template type configured by the foreground, and persisting the template type object into a template type data table based on the Hibernate;
(4) Generating a picture grouping directory object according to a picture grouping directory configured by a foreground, and persisting the picture grouping directory object into a picture grouping directory data table based on the Hibernate;
(5) Generating a picture template object according to a picture template configured by a foreground, and persisting the picture template object into a picture template data table based on a Hibernate;
(6) Generating a picture file entity object from a json file in the serialized file in a byte array form, and persisting the picture file entity object to a picture file data table based on the Hibernate;
(7) And finishing the persistence and management of the template types, the grouping, the templates and the picture files.
The template type data table visu_save_ TEMPLATETYPE is used for defining the length, width, number of rows and columns of a single screen of the rendering display container.
A picture packet directory data table VISU _ save _ temp _ directory for defining packet directory information of a scene; the data table implements a recursive pattern of directory structure data through the partntid.
The picture TEMPLATE data table visu_save_template is used for designing the attribute information stored in the page, including the information of picture name, TEMPLATE type, grouping directory information, deleting state, sub-picture ID, etc.
The picture FILE data table VISU _ save _ TEMPLATE _ FILE is used for storing the scene content serialization FILEs, and the FILE data stream is stored in a table field of the BLOG type. .
The detailed description of each table field is shown in the following table
Step four: the deserialized rendering shows the release.
When project engineering is started, as shown in fig. 4, firstly, a scene control management file is loaded, a keyboard key event is created, then, a corresponding scene serialization file is loaded through a configured scene name, data contents of multiple scene pictures are combined to remove repeated contents, then, the repeated contents are serialized in one scene file, components in the scene are instantiated one by one, finally, the instantiation of the scene is realized, and display hiding operation of sub-scenes is executed in the keyboard event through the scene control component, so that the switching of the scene is realized.
The method comprises the following specific steps:
(1) And E, loading the scene control management component in the step I, traversing the keyboard key code and the sub-picture scene associated data list, and generating a dictionary list.
(2) Creating a keyboard key event and monitoring user key input.
(3) Based on the persistence storage database in the third step, loading the serialized files of each sub-picture scene, and merging each serialized file into one picture scene serialized file.
(4) And performing deserialization processing on the combined picture scene files, traversing all components in the scene, and performing deserialization instantiation one by one to complete the instantiation of the picture scene.
(5) After the key event of the keyboard is triggered, searching the sub-picture scene corresponding to the key through the dictionary list, executing the display operation of the sub-picture scene, and executing the hiding operation of the sub-picture scene switched last time, thereby realizing the switching function of the picture scene.
In summary, the method and the device separate scene contents into a page layout description file and an object library aiming at the complexity of the Unity publishing process, wherein the page layout description file is used for describing configuration information such as layout, control, dynamic effect, event and the like of the scene, the object library is entity class objects such as control, dynamic effect, event and the like, and when serialization is carried out, only the original scene is needed to be analyzed into json files of layout description, and the files are persisted into database service.
When a scene is released, the units in the scene are instantiated one by analyzing page layout description files of each scene, so that the instantiation rendering display of the scene is finally realized, and the problems of complex compiling, packing and deploying processes and low efficiency of the conventional Unity scene are solved.
The foregoing is only a preferred embodiment of the invention, it being noted that: it will be apparent to those skilled in the art that various modifications and adaptations can be made without departing from the principles of the present invention, and such modifications and adaptations are intended to be comprehended within the scope of the invention.
Claims (9)
1. A serialization persistence release method facing to a Unity scene is characterized by comprising the following steps:
acquiring a Unity scene;
according to the Unity scene, carrying out page layout description document structure definition to obtain a serialization assembly;
carrying out serialization processing according to the serialization assembly to obtain a serialization file;
performing persistence processing according to the serialized file to obtain a persistence storage database;
and according to the persistent storage database, performing inverse sequence instantiation of the serialization assembly to realize inverse serialization rendering display release of the Unity scene.
2. The Unity-scene-oriented serialization persistence publishing method of claim 1, wherein the serialization component comprises a conventional attribute component, a custom component, a built-in component and a resource type component;
the conventional properties component includes string, int, float, char, bool;
the custom components comprise a data set SQL data set VSDataSQL, excel data set VSDataShellet and a data source VSHttp component;
the built-in components comprise a camera component Camera, canvas, canvasGroup, canvasScaler, graphicRaycaster, a color Color, colorsGroup, rectTransform, transform, unityEvent, two-dimensional data Vector2, three-dimensional data Vector3, image, mask and Text;
the resource type components comprise GameObject, material, effect, font fonts, sprite pictures and three-dimensional models.
3. The Unity-scene-oriented serialization persistence distribution method of claim 2, wherein the serialization process comprises:
marking the serialization assembly by using the JSOnObject, namely creating a JSON object JObject of the serialization assembly, wherein the complete path of the assembly is taken as an attribute name, and the serialization JSON character string is taken as an attribute value;
aiming at the marked conventional attribute components, using JSOnProperty characteristics to mark fields needing serialization, and then using JSOnConverter to carry out serialization to obtain corresponding serialization files;
and aiming at the marked custom component, built-in component or resource type component, a corresponding custom serialization converter is used to obtain a corresponding serialization file.
4. The method for the serialized persistent publishing of the Unity-oriented scene of claim 3, wherein for the marked custom component, based on a custom type serialization converter:
obtaining an instance object JObject of a serialization converter of a custom type;
executing a corresponding serialization method of the component, and assigning the result to a customJson attribute of the JObject;
serializing the residual marked as JSOnProperty attribute through JSOnConvertet, and assigning the result to the selfJson attribute of the Jobject;
and finally, serializing the JObject to form a key value pair json object by using the custom component class name and the serialized character string, thereby obtaining a corresponding serialized file.
5. The method for the serialized persistent distribution of the Unity-oriented scene of claim 3, wherein for the marked built-in components, based on the serialization converter of the built-in components,
obtaining an instance object JObject of a serialization converter of a built-in component;
and executing a corresponding serialization method of the component, and forming a json object by using the built-in component class name and the serialized character string to obtain a corresponding serialized file.
6. The method for the serialized persistent publishing of the Unity-oriented scene of claim 3, wherein for the marked resource type component, based on a serialization converter of the resource type component, a resource path is obtained as a serialized attribute value, and a json object is formed by a resource type component class name and a serialized character string to obtain a corresponding serialized file.
7. The method for the serialized persistent distribution of the Unity-oriented scene of claim 1, wherein the persistent storage database comprises a template type data table, a picture grouping directory data table, a picture template data table and a picture file data table;
the template type data table is used for storing the attributes such as the length and the width of a single screen, the number of rows and the number of columns of a definition rendering display container;
the picture grouping directory data table is used for storing grouping directory information defining a scene;
the picture template data table is used for storing attribute information of a design page, including information such as picture names, template types, grouping directory information, deletion states, sub-picture IDs and the like;
the picture file data table is used for storing a scene content serialization file, and the file data stream is stored in a table field of a BLOG type.
8. The method for managing a visibility scene oriented serialization persistence release of claim 7, wherein the persistence process comprises:
respectively constructing a template type data table, a picture grouping directory data table, a picture template data table and a picture file data table;
configuring and obtaining a template type, a picture grouping directory and a picture template according to the serialization file;
generating a template type object according to the template type, and persisting the template type object into a template type data table based on the Hibernate;
generating a picture grouping directory object according to the picture grouping directory, and persisting the picture grouping directory object into a picture grouping directory data table based on the Hibernate;
generating a picture template object according to the picture template, and persisting the picture template object into a picture template data table based on the Hibernate;
and generating a picture file entity object from the json file in the serialization file in a byte array form, and persisting the picture file entity object to a picture file data table based on the Hibernate.
9. The method for the serialized persistent publishing of the Unity scene according to claim 1, wherein the inverse serialized rendering exhibition publishing of the Unity scene comprises:
obtaining a serialized file of the picture scene according to the persistence storage database;
performing anti-serialization processing on the serialized files of the picture scenes, traversing all components in the scenes, and performing anti-sequence instantiation one by one to realize instantiation of the picture scenes;
the switching of the picture scenes can be realized through a preset scene control management component.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211721111.2A CN116243890A (en) | 2022-12-30 | 2022-12-30 | Serialization persistence release method for Unity scene |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211721111.2A CN116243890A (en) | 2022-12-30 | 2022-12-30 | Serialization persistence release method for Unity scene |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116243890A true CN116243890A (en) | 2023-06-09 |
Family
ID=86630533
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211721111.2A Pending CN116243890A (en) | 2022-12-30 | 2022-12-30 | Serialization persistence release method for Unity scene |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116243890A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117931755A (en) * | 2024-03-22 | 2024-04-26 | 上海合见工业软件集团有限公司 | Method, device, equipment and medium for batch import of package library |
-
2022
- 2022-12-30 CN CN202211721111.2A patent/CN116243890A/en active Pending
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117931755A (en) * | 2024-03-22 | 2024-04-26 | 上海合见工业软件集团有限公司 | Method, device, equipment and medium for batch import of package library |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| TWI808393B (en) | Page processing method, device, apparatus and storage medium | |
| US8561015B2 (en) | Source code semantic zoom and spatial layout | |
| Heer et al. | Software design patterns for information visualization | |
| US8352443B1 (en) | Representing scene description in databases | |
| Xia et al. | Leveraging single-user applications for multi-user collaboration: the coword approach | |
| DE69400436T2 (en) | RUN-TIME LOADER | |
| CN114035773B (en) | Configuration-based low-code form development method, system and device | |
| US20010045961A1 (en) | System and theme file format for creating visual styles | |
| US20050188349A1 (en) | Data association | |
| JP2004005568A (en) | Updating of high-speed gui style of legacy application | |
| US20140317563A1 (en) | Generate field mapping | |
| CN103679800A (en) | System for generating virtual scenes of video images and method for constructing frame of system | |
| US7409642B2 (en) | Method and system for applying user interface elements to data | |
| CN116243890A (en) | Serialization persistence release method for Unity scene | |
| CN108255471B (en) | System configuration item configuration device, method and equipment based on configuration suite | |
| JP2000029674A (en) | Application software constitution method | |
| US20110302558A1 (en) | System and Method for Constructing an Application Using Distributed Functionalities | |
| US20050010894A1 (en) | System and method of design modelling | |
| CN109814864A (en) | A kind of data visualization method, visualization system, Web browsing system and equipment | |
| CN116069330A (en) | Middle and background template construction method, device and storage medium | |
| CN112889026A (en) | User interface resource file optimization | |
| CN113485686B (en) | Information system program generation method and device, electronic equipment and storage medium | |
| CN112417345B (en) | Rendering method, rendering device, electronic equipment and storage medium | |
| CN113342399A (en) | Application structure configuration method and device and readable storage medium | |
| CN102841918A (en) | Method and device for processing binary system long-object fluidized data |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |