CN116382681B - Method, device, equipment and storage medium for developing virtual engine layout - Google Patents
Method, device, equipment and storage medium for developing virtual engine layout Download PDFInfo
- Publication number
- CN116382681B CN116382681B CN202310124599.9A CN202310124599A CN116382681B CN 116382681 B CN116382681 B CN 116382681B CN 202310124599 A CN202310124599 A CN 202310124599A CN 116382681 B CN116382681 B CN 116382681B
- Authority
- CN
- China
- Prior art keywords
- packaging
- module
- uscripttabmanager
- layout
- class
- 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.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 27
- 238000004806 packaging method and process Methods 0.000 claims abstract description 39
- 230000006870 function Effects 0.000 claims description 42
- 238000005538 encapsulation Methods 0.000 claims description 10
- 238000010276 construction Methods 0.000 claims description 4
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
Classifications
-
- 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
-
- 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/40—Transformation of program code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
- G06F9/45529—Embedded in an application, e.g. JavaScript in a Web browser
-
- 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
Abstract
The invention discloses a method, a device, equipment and a storage medium for developing a virtual engine layout, and belongs to the technical field of computers. The method comprises the following steps: performing Uobject type packaging on a preset function class and a parameter class; creating a global usertTabManager single instance class; each function in the usartTabManager returns a corresponding object to form chained programming; generating a corresponding declaration file according to a reflection mechanism of the illusion engine so as to write interface layout in the lua or ts script, thereby obtaining interface layout results written by the script; converting the interface layout result into TSharedPtr < SWidget >; TSharedPtr < SWidget > is embedded in SWindow's Content on the ghost engine C++ side. The invention greatly improves the development efficiency and convenience.
Description
Technical Field
The invention belongs to the technical field of computers, and particularly relates to a method, a device, equipment and a storage medium for developing a fantasy engine layout.
Background
The traditional interface layout mode is written, only a slave code of C++, the grammar of the C++ is complex, after the C++ is encapsulated again in a fantasy way, talents with years of development experience are required to be driven, the slave code format is required to be manually adjusted, reading is inconvenient, once a project is released, the layout cannot be modified again unless the C++ code is modified again, and then the release is compiled again; and different projects need different layouts, so that the C++ code needs to be rewritten and cannot be well multiplexed.
Disclosure of Invention
The invention aims to overcome the defects of the prior art and provides a method, a device, equipment and a storage medium for developing a fantasy engine layout.
The aim of the invention is realized by the following technical scheme:
according to a first aspect of the present invention, a method for developing a layout of a illusion engine is applied to a development system based on the illusion engine, and the method includes:
s100, performing Uobject type packaging on preset function classes and parameter classes;
s200, creating a global UScriptTabManager single instance class;
s300, returning each function in the UScriptTabManager to a corresponding object according to all classes packaged in the S100 to form chained programming;
s400, deriving classes and functions encapsulated by the S100 by utilizing UnLua or Puerts plug-ins, and generating corresponding declaration files according to a reflection mechanism of the illusion engine so as to write interface layout in lua or ts script and obtain interface layout results written by the script;
s500, deriving a UMyGameEngine from the UGAMEEngine, implementing the overwriting of the window content creation flow in the initialization function, and starting the script virtual machine;
s600, calling a layout function created by a script, transmitting the result obtained in the S400 into a UScriptTabManager, and converting the interface layout result obtained in the S400 into TSharedPtr < SWidget > through an internal MyTabManagerPtr to obtain TSharedPtr < SWidget > of the whole interface layout;
s700, registering tag page contents to a UScriptTabManager through an identification ID, and storing an identification ID and tag page content key value pair in the UScriptTabManager through a Map;
s800, when the layout is presented in the window, acquiring tag page content registered in the corresponding S700 from the Map of the UScriptTabManager according to the identification ID of the tag page;
s900, embedding TSharedPtr < SWidget > generated in S600 into SWindow Content on the side of the illusion engine C++.
Further, performing Uobject type encapsulation on the preset function class and parameter class, including:
packaging the FTabManager into a UScriptTabManager;
packaging FLayout into UScriptLayout;
packaging FLayoutnode into UScriptLayoutNode;
packaging FStack into UScriptStack;
packaging FSplitter into UScriptSplitter;
packaging FArea into a UScriptArea;
FSpa WN TabArgs is packaged as UScriptDockTabArgs.
Further, the global usetttabmanager single instance class adopts a TStrongObjectPtr < usetttabmanager > strong reference manner.
Further, the global usetttabmanager singleton class contains a shared pointer TSharedPtr < FGlobalTabmanager > mytabmanager ptr to forward various events and parameters.
Further, the function returns an instance object where the corresponding objects are all themselves in S300.
According to a second aspect of the present invention, an apparatus for development of a fantasy engine layout, applied to a fantasy engine-based development system, comprises:
the packaging module is used for performing Uobject type packaging on the preset function class and parameter class;
the single instance class creation module is used for creating a single instance class of the global UScriptTabManager;
the chain programming construction module is used for returning corresponding objects according to all the packaged functions in the UScriptTabManager to form chain programming;
the declaration file export module is used for exporting classes and functions packaged by the packaging module by utilizing the UnLua or Puerts plugins, and generating a corresponding declaration file according to a reflection mechanism of the illusion engine so as to write interface layout in the lua or ts script and obtain interface layout results written by the script;
the process overwriting module is used for deriving a UMyGameEngine from the UGAMEEngine, implementing the overwriting of the window content creating process in the initializing function, and starting the script virtual machine;
the interface layout module is used for calling a layout function created by a script, transmitting the result obtained by the declaration file export module into a UScriptTabManager, and converting the interface layout result obtained by the declaration file export module into TSharedPtr < SWidget > through the internal MyTabManagerPtr to obtain TSharedPtr < SWidget > of the whole interface layout;
the key value pair storage module is used for registering tag page contents to the UScriptabManager through the identification ID, and storing the identification ID and tag page contents key value pair through the Map in the UScrittabManager;
the tag page content acquisition module is used for acquiring tag page content registered by the corresponding key value pair storage module from the Map of the UScriptTabManager according to the identification ID of the tag page when the layout is presented in the window;
and the embedding module is used for embedding TSharedPtr < SWidget > generated by the interface layout module into the Content of SWindow at the C++ side of the illusion engine.
Further, performing Uobject type encapsulation on the preset function class and parameter class, including:
packaging the FTabManager into a UScriptTabManager;
packaging FLayout into UScriptLayout;
packaging FLayoutnode into UScriptLayoutNode;
packaging FStack into UScriptStack;
packaging FSplitter into UScriptSplitter;
packaging FArea into a UScriptArea;
FSpa WN TabArgs is packaged as UScriptDockTabArgs.
Further, the global usetttabmanager single instance class adopts a TStrongObjectPtr < usetttabmanager > strong reference manner, and the global usetttabmanager single instance class contains a shared pointer TSharedPtr < FGlobalTabmanager > mytabmanager ptr to forward various events and parameters.
According to a third aspect of the present invention, an apparatus comprising a processor and a memory having stored therein at least one instruction, at least one program, code set or instruction set, the at least one instruction, the at least one program, code set or instruction set being loaded and executed by the processor to implement a method according to the first aspect of the present invention.
According to a fourth aspect of the present invention, a storage medium has stored therein at least one instruction, at least one program, a set of codes or a set of instructions, which are loaded and executed by a processor to implement the method according to the first aspect of the present invention.
The beneficial effects of the invention are as follows: the invention develops a mode of writing interface layout by using a script based on the diversity of layout and the randomness of tag page contents, is convenient for quick adjustment, has low development and maintenance cost, can designate the content of a Tab tag page as a blueprint object of UMG, greatly improves development efficiency and convenience, ensures complete consistency with C++ development functions and effects, and can only need to adjust the layout and then designate the content for different projects.
Drawings
FIG. 1 is a flow chart of one embodiment of a method for developing an interface layout based on a script in the present invention.
Detailed Description
The technical solutions of the present invention will be clearly and completely described below with reference to the embodiments, and it is apparent that the described embodiments are only some embodiments of the present invention, but not all embodiments. All other embodiments, which can be made by a person skilled in the art without any inventive effort, are intended to be within the scope of the present invention, based on the embodiments of the present invention.
Referring to fig. 1, the present embodiment provides a method, apparatus, device and storage medium for developing a fantasy engine layout:
the first aspect of the invention provides a method for developing a layout of a illusion engine, which is applied to a development system based on the illusion engine. As shown in fig. 1, the method includes S100 to S900, which are described in detail below.
S100, performing Uobject type packaging on the preset function class and parameter class.
Specifically, performing Uobject type encapsulation on a preset function class and parameter class includes: uobject type encapsulation is performed on the FTabManager related function classes and parameter classes. For example, FTabManager is packaged as a usarttabmanager, FLayout is packaged as a usartLayout, FLayoutnode is packaged as a usartLayoutNode, FStack is packaged as a usartStack, FSplitter is packaged as a usartsplit, FArea is packaged as a usartArea, and FSpa TabArgs is packaged as a usartDockTabArgs.
S200, creating a global UScriptTabManager single instance class.
Specifically, the global usarttabmanager single instance class adopts a TStrongObjectPtr < usarttabmanager > strong reference mode to ensure that the single instance class is not recycled by the engine GC mechanism garbage.
The global userttabmanager singleton class contains a shared pointer, TSharedPtr < FGlobalTabmanager > mytabmanager ptr, to forward various events and parameters.
S300, returning each function in the UScriptTabManager to a corresponding object according to all classes packaged in the S100 to form chained programming.
For example, each function returns an instance object whose result is itself, such as: usartlayout NewLayout (const FName LayoutName), thereby forming a chain programming like a phantom engine slave.
S400, deriving classes and functions encapsulated by the S100 by utilizing UnLua or Puerts plug-ins, and generating corresponding declaration files according to a reflection mechanism of the illusion engine so as to write interface layout in lua or ts script and obtain interface layout results written by the script.
S500, deriving a UMyGameEngine from the UGAMEEngine, implementing the overwriting of the window content creation flow in the initialization function, and starting the script virtual machine.
S600, calling a layout function created by a script, transmitting the interface layout result obtained in the S400 into a UScriptTabManager, and converting the interface layout result obtained in the S400 into TSharedPtr < SWidget > through an internal MyTabManagerPtr to obtain TSharedPtr < SWidget > of the whole interface layout.
S700, registering tag page contents to the UScriptTabManager through the identification ID, and storing the identification ID and tag page content key value pair in the UScriptTabManager through the Map.
S800, when the layout is presented in the window, acquiring tag page content registered in the corresponding S700 from the Map of the UScriptTabManager according to the identification ID of the tag page.
S900, embedding TSharedPtr < SWidget > generated in S600 into SWindow Content on the side of the illusion engine C++.
A second aspect of the present invention provides an apparatus for development of a fantasy engine layout, for use in a fantasy engine-based development system. The device comprises a packaging module, a single instance class creation module, a chained programming construction module, a declaration file export module, a flow overwriting module, an interface layout module, a key value pair storage module, a tag page content acquisition module and an embedding module.
The packaging module is used for performing Uobject type packaging on the preset function class and parameter class. For example, uobject type packaging is performed on the function class and the parameter class related to the FTabManager, FTabManager is packaged into UScriptabManager, FLayout is packaged into UScriptayLayout, FLayoutNode is packaged into UScriptayLayOutNode, FStack is packaged into UScriptStack, FSplitter is packaged into UScriptSplitter, FArea is packaged into UScriptakAres, and FSpa TabArgs is packaged into UScriptDockTabArgs.
The single instance class creation module is used for creating a global usertTabManager single instance class. The global UScriptTabManager single instance class adopts a TStrongObjectPtr < UScriptTabManager > strong reference mode to ensure that garbage is not recovered by an engine GC mechanism. The global userttabmanager singleton class contains a shared pointer, TSharedPtr < FGlobalTabmanager > mytabmanager ptr, to forward various events and parameters.
The chained programming construction module is used for returning corresponding objects according to all the packaged functions in the UScriptTabManager to form chained programming. For example, each function returns an instance object whose result is itself, such as: usartlayout NewLayout (const FName LayoutName), thereby forming a chain programming like a phantom engine slave.
The declaration file export module is used for exporting classes and functions encapsulated by the encapsulation module by utilizing the UnLua or Puerts plugins, and generating corresponding declaration files according to the reflection mechanism of the illusion engine so as to write interface layout in the lua or ts script and obtain interface layout results written by the script.
The process overwriting module is used for deriving a UMyGameEngine from the UGAMEEngine, implementing the overwriting of the window content creating process in the initializing function, and starting the script virtual machine.
The interface layout module is used for calling a layout function created by a script, transmitting the result obtained by the declaration file export module into a UScriptabManager, and converting the interface layout result obtained by the declaration file export module into TSharedPtr < SWidget > through the internal MyTabManagerPtr to obtain the TSharedPtr < SWidget > of the whole interface layout.
The key value pair storage module is used for registering tag page contents to the UScriptabManager through the identification ID, and storing the identification ID and tag page contents key value pair through the Map in the UScriptabManager.
And the tag page content acquisition module is used for acquiring tag page content registered by the corresponding key value pair storage module from the Map of the UScriptTabManager according to the identification ID of the tag page when the layout is presented in the window.
The embedding module is used for embedding TSharedPtr < SWidget > generated by the interface layout module into the Content of SWindow at the C++ side of the illusion engine.
A third aspect of the invention provides an apparatus comprising a processor and a memory having stored therein at least one instruction, at least one program, code set or instruction set, the at least one instruction, the at least one program, code set or instruction set being loaded and executed by the processor to implement a method according to the first aspect of the invention.
A fourth aspect of the invention provides a storage medium having stored therein at least one instruction, at least one program, code set or instruction set loaded and executed by a processor to implement a method according to the first aspect of the invention.
The foregoing is merely a preferred embodiment of the invention, and it is to be understood that the invention is not limited to the form disclosed herein but is not to be construed as excluding other embodiments, but is capable of numerous other combinations, modifications and environments and is capable of modifications within the scope of the inventive concept, either as taught or as a matter of routine skill or knowledge in the relevant art. And that modifications and variations which do not depart from the spirit and scope of the invention are intended to be within the scope of the appended claims.
Claims (5)
1. A method for developing a layout of a fantasy engine, which is applied to a development system based on the fantasy engine, and is characterized in that the method comprises the following steps:
s100, performing Uobject type packaging on preset function classes and parameter classes;
uobject type encapsulation is carried out on a preset function class and a parameter class, and the Uobject type encapsulation comprises the following steps:
packaging the FTabManager into a UScriptTabManager;
packaging FLayout into UScriptLayout;
packaging FLayoutnode into UScriptLayoutNode;
packaging FStack into UScriptStack;
packaging FSplitter into UScriptSplitter;
packaging FArea into a UScriptArea;
packaging FSpa WN TabArgs into UScriptDockTabArgs
S200, creating a global UScriptTabManager single instance class; the global userttabmanager single instance class contains a shared pointer TSharedPtr < FGlobalTabmanager > MyTabManagerPtr to forward events and parameters;
s300, returning each function in the UScriptTabManager to a corresponding object according to all classes packaged in the S100 to form chained programming; s300, returning the corresponding objects to be the instance objects of the function in S300;
s400, deriving classes and functions encapsulated by the S100 by utilizing UnLua or Puerts plug-ins, and generating corresponding statement files according to a reflection mechanism of the illusion engine so as to write interface layout in lua or ts script and obtain interface layout results written by the script;
s500, deriving a UMyGameEngine from the UGAMEEngine, implementing the overwriting of the window content creation flow in the initialization function, and starting the script virtual machine;
s600, calling a layout function created by a script, transmitting the result obtained in the S400 into a UScriptTabManager, and converting the interface layout result obtained in the S400 into TSharedPtr < SWidget > through an internal MyTabManagerPtr to obtain TSharedPtr < SWidget > of the whole interface layout;
s700, registering tag page contents to a UScriptTabManager through an identification ID, and storing an identification ID and tag page content key value pair in the UScriptTabManager through a Map;
s800, when the layout is presented in the window, acquiring tag page content registered in the corresponding S700 from the Map of the UScriptTabManager according to the identification ID of the tag page;
s900, embedding TSharedPtr < SWidget > generated in S600 into SWindow Content on the side of the illusion engine C++.
2. The method of claim 1, wherein the global usarttabmanager single instance class uses TStrongObjectPtr < usarttabmanager > as a strong reference.
3. An apparatus for development of a fantasy engine layout for use in a fantasy engine-based development system, the apparatus comprising:
the packaging module is used for performing Uobject type packaging on the preset function class and parameter class;
uobject type encapsulation is carried out on a preset function class and a parameter class, and the Uobject type encapsulation comprises the following steps:
packaging the FTabManager into a UScriptTabManager;
packaging FLayout into UScriptLayout;
packaging FLayoutnode into UScriptLayoutNode;
packaging FStack into UScriptStack;
packaging FSplitter into UScriptSplitter;
packaging FArea into a UScriptArea;
packaging FSpa WN TabArgs into UScriptDockTabArgs;
the single instance class creation module is used for creating a single instance class of the global UScriptTabManager;
the global UScriptabManager single instance class adopts a TStrongObjectPtr < UScriptabManager > strong reference mode, and contains a shared pointer TSharedPtr < FGlobalTabManagerPtr > MyTabManagerPtr for forwarding events and parameters;
the chain programming construction module is used for returning corresponding objects according to all the packaged functions in the UScriptTabManager to form chain programming;
the declaration file export module is used for exporting classes and functions encapsulated by the encapsulation module by utilizing a UnLua or Puerts plug-in, and generating a corresponding declaration file according to a reflection mechanism of the illusion engine so as to write interface layout in the lua or ts script and obtain interface layout results written by the script;
the process overwriting module is used for deriving a UMyGameEngine from the UGAMEEngine, implementing the overwriting of the window content creating process in the initializing function, and starting the script virtual machine;
the interface layout module is used for calling a layout function created by a script, transmitting the result obtained by the declaration file export module into a UScriptTabManager, and converting the interface layout result obtained by the declaration file export module into TSharedPtr < SWidget > through the internal MyTabManagerPtr to obtain TSharedPtr < SWidget > of the whole interface layout;
the key value pair storage module is used for registering tag page contents to the UScriptabManager through the identification ID, and storing the identification ID and tag page contents key value pair through the Map in the UScrittabManager;
the tag page content acquisition module is used for acquiring tag page content registered by the corresponding key value pair storage module from the Map of the UScriptTabManager according to the identification ID of the tag page when the layout is presented in the window;
and the embedding module is used for embedding TSharedPtr < SWidget > generated by the interface layout module into the Content of SWindow at the C++ side of the illusion engine.
4. An electronic device comprising a processor and a memory having stored therein at least one instruction, at least one program, code set or instruction set that is loaded and executed by the processor to implement the method of any one of claims 1 to 2.
5. A storage medium having stored therein at least one instruction, at least one program, code set, or instruction set, the at least one instruction, the at least one program, the code set, or instruction set being loaded and executed by a processor to implement the method of any one of claims 1-2.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310124599.9A CN116382681B (en) | 2023-02-16 | 2023-02-16 | Method, device, equipment and storage medium for developing virtual engine layout |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310124599.9A CN116382681B (en) | 2023-02-16 | 2023-02-16 | Method, device, equipment and storage medium for developing virtual engine layout |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN116382681A CN116382681A (en) | 2023-07-04 |
| CN116382681B true CN116382681B (en) | 2023-11-10 |
Family
ID=86970144
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310124599.9A Active CN116382681B (en) | 2023-02-16 | 2023-02-16 | Method, device, equipment and storage medium for developing virtual engine layout |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116382681B (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113282357A (en) * | 2021-06-24 | 2021-08-20 | 北京优锘科技有限公司 | Method, equipment and medium for realizing running of three-dimensional engine in combination with script engine |
| CN114816623A (en) * | 2022-04-02 | 2022-07-29 | 杭州易知微科技有限公司 | Embedded interface rendering and communication system based on CEF kernel and UnrealEngine end |
| CN115080016A (en) * | 2022-06-21 | 2022-09-20 | 苏州沁游网络科技有限公司 | Extended function implementation method, device, equipment and medium based on UE editor |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8881101B2 (en) * | 2011-05-24 | 2014-11-04 | Microsoft Corporation | Binding between a layout engine and a scripting engine |
-
2023
- 2023-02-16 CN CN202310124599.9A patent/CN116382681B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113282357A (en) * | 2021-06-24 | 2021-08-20 | 北京优锘科技有限公司 | Method, equipment and medium for realizing running of three-dimensional engine in combination with script engine |
| CN114816623A (en) * | 2022-04-02 | 2022-07-29 | 杭州易知微科技有限公司 | Embedded interface rendering and communication system based on CEF kernel and UnrealEngine end |
| CN115080016A (en) * | 2022-06-21 | 2022-09-20 | 苏州沁游网络科技有限公司 | Extended function implementation method, device, equipment and medium based on UE editor |
Non-Patent Citations (1)
| Title |
|---|
| 基于三维图形引擎的动画创作探究;常姣姣;张国龙;;中国传媒科技(第04期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN116382681A (en) | 2023-07-04 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9426259B2 (en) | Client server interaction for graphical/audio applications | |
| CN108932406B (en) | Virtualization software protection method and device | |
| US7174533B2 (en) | Method, system, and program for translating a class schema in a source language to a target language | |
| KR20140067018A (en) | Describing native application programming interfaces of an operating system with metadata | |
| CN110709816A (en) | Integrating learning models into software development systems | |
| CN110603520A (en) | Integrating learning models into software development systems | |
| CN111179086B (en) | Intelligent contract virtual machine based on WebAsssemly | |
| Fuchssteiner | MuPAD User’s Manual: Multi-Processing Algebra Data Tool, MuPAD Version 1.2. 2 | |
| TW201310341A (en) | Projecting native application programming interfaces of an operating system into other programming languages | |
| CN110083342B (en) | Program generation method and device and computer readable storage medium | |
| WO2020242809A1 (en) | Integration of learning models into a software development system | |
| WO2021109688A1 (en) | Illumination probe generation method, apparatus, storage medium, and computer device | |
| CN101030241A (en) | Method and system based on Keil C51 software protecting development | |
| Kiselyov | Delimited control in OCaml, abstractly and concretely: System description | |
| CN112835975A (en) | Method for deploying, updating and calling intelligent contracts in block chain | |
| US20090077121A1 (en) | System and method for interoperating with foreign objects from a host computing environment | |
| CN110362334B (en) | Method, device and medium for managing C + + object life cycle of secondary development language | |
| CN116382681B (en) | Method, device, equipment and storage medium for developing virtual engine layout | |
| US20140046984A1 (en) | Compact type layouts | |
| Järvi et al. | Library composition and adaptation using C++ concepts | |
| CN110673890B (en) | Plug-in calling method, system, medium and device | |
| Pettineo | Using bindless resources with DirectX raytracing | |
| Jiang et al. | Pavilion: Bridging Photo-Realism and Robotics | |
| Clair | Learning Objective-C 2.0: A hands-on guide to Objective-C for Mac and iOS developers | |
| Krebs et al. | Implementing the universal virtual computer |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |