Method for generating bindings between a C / C++ library and an interpreted language, and performing the method to convert a three-dimensional (3D) model

Abstract

The invention relates to a method for generating bindings between a C / C++ library (A) and one or more interpreted high-level languages ​​in order to expose the functionality of the C / C++ library to the high-level language(s), the method involving the steps of writing a definition of the binding (C) in the form of a high-level language, processing the definition to generate binding elements, grouping the binding elements around each of the high-level languages ​​in order to generate C++ binding code (D), and compiling the C++ code (D) and linking it to the C / C++ library (A). This can be used in particular for implementing a human-machine interface for mobile devices on land, in the air or at sea.

Description

Technical Field

[0001] The present invention relates to a method for generating bindings between a C / C++ library and an interpreted language.

[0002] The invention also relates to the implementation of said method for generating a binding in order to transform a three-dimensional (3D) model, in particular capable of being embedded in a human-machine interface of a mobile device.

[0003] The field of the invention is that of human-machine interfaces and more particularly that of human-machine interfaces embedded in land, air or sea mobile systems. Background Art

[0004] Binding generators are tools that can efficiently implement bindings between C / C++ libraries and interpreted languages. The problem of binding is to give access to the functionality / performance pairs of a low-level language (C++) from a high-level language (Python, Java, C#, Haskell, etc.).

[0005] In general, high-level languages ​​have lower performance than low-level languages. High-level languages ​​are slower and / or use more memory. In contrast, high-level languages ​​relieve the developer from performing many tasks, including memory management, specifically creating and destroying objects.

[0006] High-level languages ​​are much more accessible. They can achieve functional results faster, which gives them an ideal position in the rapid prototyping stage. However, performance issues exclude them from the industrialization stage. Therefore, it is necessary to have both the performance of C++ and the accessibility of high-level languages.

[0007] This problem is encountered in project management, especially in the design process of human-machine interfaces, which requires the joint contribution of hardware engineers using low-level languages ​​and business experts using high-level languages. The difficulty lies in organizing a method that is a synthesis of skills that change as skills conflict.

[0008] In particular, in the production of interactive applications with 3D content, one of the main problems is the "translation" (conversion) of 3D models originating from a CAO application into the proprietary format of the 3D engine that developed the application. This complex task is found at the intersection of the above-mentioned skills. Business experts have the knowledge of the functional and aesthetic goals to be achieved, but their technical parameters do not allow them to act in terms of industrialization. On the other hand, low-level engineers have the technical skills to process and display 3D data on industrial platforms, but do not have the knowledge required for the conversion / translation of 3D data that meets the goals of the business experts. Therefore, there is a gap between these skills, which hinders the realization of a human-machine interface that meets the functional and aesthetic goals and the technical specifications imposed by the industrial hardware.

[0009] Conversion / translation always brings about loss of information, and 3D CAO models do not contain the "material" properties required for 3D rendering.

[0010] The expedient to overcome the above gaps is to make adjustments once the translation has been performed. This is the approach chosen by solutions such as Unreal Engine and Unity 3D, which involves accumulating human means and labor, especially towards the end of the project. Even if it is admitted that this approach has a role in the entertainment industry, it is not suitable for the industrial sector.

[0011] Therefore, it should be noted that there is no solution for achieving binding between high-level languages ​​and low-level languages, and therefore, there is no solution for being able to integrate multi-disciplinary groups within an industrial HMI project.

[0012] Furthermore, the demands on ergonomic, efficient and highly dynamic human-machine interfaces (HMI) are currently high, expressed in particular by motor vehicle manufacturers.

[0013] In the prior art, SWIG is a program that can generate such "bindings". It is open source, free to access, and can link programs written in C / C++ to various "high-level" programming languages. Target languages ​​include conventional scripting languages, such as Javascript, Perl, PHP, Python, Tel, and Ruby. SWIG suffers from too much technical debt and unequal treatment of supported target languages. Therefore, it is often the case that only the desired functions are supported in some target languages, and sometimes the functions are not supported, which constitutes a significant obstacle to integrating expert scripts in the automated process for molding 3D models.

[0014] Furthermore, if overall automated binding generation is recommended, projects using SWIG have been found in practice to require explicit intervention by the developer in order to correct the automatically generated non-functional code. Thus, a paradox is achieved when the amount of code written to correct incorrectly generated code is much greater than what could reasonably be expected to achieve the intended level of functionality for the binding.

[0015] Furthermore, in the context of projects executed by multidisciplinary teams, the access of business experts to clear and comprehensive documentation is an absolute requirement for achieving the goals. Since version 2.0, SWIG no longer provides this functionality. If the generated bindings provide access to low-level functionality from a high-level language, business experts and the ability to generate high-level code have no documentation and reference support for the presented API.

[0016] Document US5083262A describes a language binding method for graphics functions, the purpose of which is to allow one application to be used in different processing environments.

[0017] Establishing a specific binding to the language between a high-level graphics application written in a specific programming language allows the graphics application to be transferred between different graphics processing systems and used in different graphics processing systems. Only one portable graphics application can be used with any graphics processor for which the application language binding has been established to produce graphics on an output peripheral.

[0018] Document CN101814024A discloses a design tool for multi-platform 3D interfaces, which is mainly used to develop large-screen interactive 3D human-machine interfaces. The tool includes a system kernel that can call system functions in a multi-platform manner, wherein the kernel processes the main functions of the current public platform and can perform self-tests to identify differences between system functions of different development systems.

[0019] The combination of SWIG's technical heritage and its patchy support for C++ features makes it extremely complex and expensive to ensure its development and maintenance. The few software alternatives to SWIG generally focus on a single target language and are much more limited than SWIG in terms of the C++ features it supports.

[0020] Furthermore, with the advent of the new C++ standard (C++11), new language constructs are not specifically or fully supported by SWIG, and multiple usage configurations of new C++ features are not properly supported by SWIG.

[0021] In the absence of a solution, in a large number of human-machine interface design and development centers, the code of the 3D model generated by the CAD tool is rewritten to be able to embed it into the mobile platform. Using a specific format inherited from the CAD environment to store 3D data suitable for the limitations of embedding brings up the problem of versatility and flexibility to overcome the limitations of the embedded environment.

[0022] DM Beazley in the document “Automated scientific software scripting with SWIW” in the review Future Generations Computer Systems 19 (2003) pages 599-609 discloses a method for generating bindings between a C / C++ library and one or more interpreted high-level languages ​​to present the functionality of the C / C++ library to the interpreted languages, the method comprising the steps of writing a definition of the binding in the form of a high-level language, processing the definition to generate binding elements, and compiling C++ code and linking it to the C / C++ library.

[0023] The document “AutoWIG: Automatic Generation of Python Bindings for C++ Libraries” XP080950591 by P. Fernique et al. discloses an automatic binding generation method for C++ libraries.

[0024] The purpose of the present invention is to propose a binding generation method that can combine the performance of 3D C++ libraries with the flexibility of high-level languages ​​on embedded materials. Summary of the invention

[0025] This object is achieved by a method for generating a binding between a C / C++ library (A) and a software environment of one or more high-level interpreted languages ​​to expose the functionality of the C / C++ library to the interpreted languages, the method comprising the following steps implemented by a computer:

[0026] - a step of processing a definition (C) of said binding, said definition having previously been written in a high-level language and comprising a list of functions, to generate binding elements,

[0027] - a step of generating a list of binding elements exposed to the high-level language to produce a C++ function group exposed to the high-level language,

[0028] - A step of compiling the C++ code (D) and linking it to the C / C++ library (A), characterized in that the step of generating bindings is also configured to enable the C / C++ library to call functions (callbacks) written in a high-level language to extend the functionality of the C / C++ library.

[0029] The definition of a binding may also include a list of functions, expected parameters and return values ​​for the functions.

[0030] In a particular variant of the invention, the step of defining the processing comprises allocating the processing between:

[0031] - the functionality of each of the high-level languages ​​[B],

[0032] -C++ language features, which are supported by the bindings in a transparent way and can be accessed from high-level languages.

[0033] The binding method according to the present invention may also advantageously include the step of processing the document attached to the C / C++ library (A) as a target high-level language (B2) and generating an XML file.

[0034] The method may further include: after the compilation step, obtaining a dynamic library (E) that integrates the C / C++ library (A) and an interface layer compiled from the C++ code (A) derived from the compilation step, and a static library (E) provided for directly embedding a high-level interpreted language into the C++ code derived from the compilation step.

[0035] According to another aspect of the present invention, a computing module is provided, the computing module implementing the binding method according to any one of the preceding claims, operating with a C / C++ library (A) and one or more high-level interpreted languages ​​to present the functionality of the C / C++ library to the interpreted languages, the module comprising:

[0036] - means for processing a definition of said binding to generate binding elements, said definition preferably being written in a high-level language and comprising a list of functions,

[0037] - means for assembling said binding elements towards each of said high-level languages ​​to generate C++ binding code (D),

[0038] - means for generating a list of binding elements exposed to the high-level language to produce a set of C++ functions exposed to the high-level language,

[0039] - means for compiling said C++ code (D) and linking to said C / C++ library (A).

[0040] According to the present invention, the means for generating bindings is further configured to enable the C / C++ library to call a function (callback) written in a high-level language to extend the functionality of the C / C++ library.

[0041] According to another aspect of the present invention, an implementation of the binding method according to the present invention in the following method is proposed, the method is used to convert a 3D module originating from a C / C++ library (A) so that it can be embedded in a project of a device for a "business" application written in a high-level language (B), import a dynamic library (E), and access the functions of the C / C++ library (A) via the dynamic library (E).

[0042] Said implementation of the binding method according to the invention may in particular involve converting a 3D model originating from a C / C++ library (A) into a 3D model capable of being embedded in a device within a mobile system.

[0043] In the binding method according to the invention, translation rules are implemented based on the requirements of each project so that once the 3D model is switched in the 3D engine, the translation should automatically give the best result. It is inconceivable that these rules must be implemented in C++ in order to make them accessible to those skilled in the art ("graphic designer / integrator").

[0044] The binding method according to the invention can in particular take into account the language Lua, which is a free scripting language well known to designers of 3D models, which makes it possible to write translation rules in Lua.

[0045] The binding generator according to the present invention is used to easily integrate the Lua language into all tools of the system for converting the three models.

[0046] Therefore, the binding method according to the present invention provides the developer with the possibility to describe the "high-level" interface he needs in a simple way, and is responsible for the automatic generation of C++ binding code and resource management mechanisms.

[0047] The generator method according to the invention provides the developer responsible for the binding with the possibility to implement the functionality of the target language language by language. The developer thus specifies what is presented explicitly, unlike SWIG which tries to present everything implicitly but fails.

[0048] In just one description, the binding generator according to the present invention automatically generates all bindings to supported languages. Therefore, increasing the support of the language is beneficial to all already linked projects.

[0049] The translation of a business application from one target language to another is quasi-direct and automatic, the API ("Application Programming Interface") generated by the binding generator is strictly identical.

[0050] The document is considered complete in the target language.

[0051] The binding generator according to the present invention handles the conversion of C++ types (STD and STL) and provides access to the latest C++ functions. This generator can present the types of library-specific objects in the debugger of the target language.

[0052] In high-level languages, all data is encapsulated with associated metadata. For the sake of random access memory usage efficiency, these languages ​​offer the possibility to store data directly in the metadata. The binding generator according to the invention makes this mechanism accessible. The direct benefits obtained thereby are improvements in performance, memory space and complexity (e.g.: integers, floating point numbers, vectors, etc.).

[0053] It is desirable to be able to call C++ functions from Python or Lua, but it is also desirable to be able to call Python or Lua functions from C++. The generator according to the invention implements this mechanism consistently in all supported languages. It provides the possibility for those skilled in the art to extend C++ functionality without having to know its implementation details.

[0054] By way of example, one can cite the implementation of optical effects on images, which requires the ability to be inserted directly at the heart of the image rendering pipeline, with callbacks to finalizer modules and callbacks from a real-time physics engine. The generated bindings can be used via dynamic libraries (DLL) or static libraries (integrated or binary).

[0055] This flexibility makes it possible, for example, to integrate the Lua language into a library for displaying and manipulating 3D models without any impact on performance or memory usage, and leads to the apparently paradoxical situation of being able to import Lua into Lua, which helps to bring multi-core capabilities to non-C++ developers. Likewise, Lua is accessible to all Python developers. BRIEF DESCRIPTION OF THE DRAWINGS

[0056] Other advantages and features of the invention will emerge from a reading of the detailed description of implementations and embodiments, which are by no means limiting, and of the accompanying drawings:

[0057] - Figure 1 is a schematic diagram of an embodiment of a binding generator according to the present invention;

[0058] - Figure 2 Schematically illustrates a terminator process for executing the binding method according to the present invention;

[0059] - Figure 3 Schematically shows a business application that executes the binding method according to the present invention;

[0060] - Figure 4 is a schematic diagram of the overall conversion process of performing the binding method according to the present invention;

[0061] - Figure 5 schematically illustrates an embedded graphics engine implementing the binding method according to the present invention; and

[0062] - Figure 6A specific implementation of the binding method according to the present invention in a multi-user configuration is shown. DETAILED DESCRIPTION

[0063] Since these embodiments are by no means limiting, variants of the invention can in particular be envisaged which consist only of a selection of the features described or shown hereinafter in isolation from the other features described or shown (even if this selection is isolated within a stage comprising said other features), if the selection of said features is sufficient to provide a technical advantage or to distinguish the invention from the prior art. This selection includes at least one feature, which is preferably functional without structural details and / or with some structural details, if this part is sufficient by itself to provide a technical advantage or to distinguish the invention from the prior art.

[0064] Now refer to Figure 1 An embodiment of a method for generating a binding according to the present invention is described.

[0065] Step 1: A user of the binding generator according to the present invention owns a third C or C++ library [A], whose functionality the user wishes to expose to a language such as Python, Lua or C# [B].

[0066] The user writes the definition of the bindings in the form of a Python program [C] using the binding generator's API (itself written in Python), which describes the API of the library [A] as it must be presented to developers of high-level languages ​​through a list of functions and their expected arguments and return values.

[0067] Step 2: Binding definitions that do not rely on any specificity of the high-level language are processed by the binding generator [C], which distributes the processing between:

[0068] - the functionality of each high-level language [B] (data management, its life cycle, data transfer between C++ and high-level languages, specific paradigms);

[0069] -C++ features, which are supported in a transparent way by the bindings and can be accessed from high-level languages ​​(STL / STD types).

[0070] In parallel, the document is processed in the target high-level language [B2] and an XML file is generated.

[0071] Step 3: The last step of the binding generator is to assemble the binding elements towards each high-level language to generate C++ binding code [D]. Step 4: The C++ code [D] generated at the output of the generator is designed to be compiled and linked to the third library, the functionality of which is presented.

[0072] In parallel, the list of bound symbols can be augmented by the documentation compiled in step 1, thus producing an understandable reference that is more accessible than Doxygen documentation, which is the state of the art for automatically generated C++ documentation.

[0073] Step 5: The compilation result of [D] is optionally:

[0074] - Dynamic library [E]. Library [E] integrates library [A] and the interface layer compiled from [D].

[0075] - Static libraries for embedding Python / Lua etc. directly into the final C++ program.

[0076] The final step is to use the binding. The user writes a "business" application in language [B], imports the dynamic library [E], and accesses the functionality of library [A] via the dynamic library.

[0077] The binding generator according to the invention provides the developer responsible for the binding with the possibility to implement the functionality of the target language language by language. The developer specifies what is presented explicitly, unlike SWIG which tries to present everything implicitly but fails.

[0078] In just one description, the binding generator according to the present invention automatically generates all bindings to supported languages. Therefore, increasing the support of the language is beneficial to all already linked projects.

[0079] The translation of business applications from one target language to another is virtually direct and automatic. The APIs generated by the binding generators are strictly identical, which further increases the portability of projects developed in C++. The target language chosen at the beginning of the project is no longer an impeding aspect.

[0080] Furthermore, the binding generator according to the invention handles the conversion of C++ types (STD and STL) and provides access to the latest C++ functionality. The generator can present the types of library-specific objects in the debugger of the target language.

[0081] The generated bindings can be used via dynamic libraries (DLL) or static libraries (integrated or binary). This flexibility allows, for example, integrating Lua into a library of 3D models without any impact on performance or memory usage.

[0082] Now refer to Figure 2 Describes how binding operations are performed in model transformation processing involving "Terminator" blocks.

[0083] 1. The translation of the 3D model originating from the C / C++ library automatically calls the terminator module. With the help of a callback system, the interpreter running in parallel with the translation calls a group of functions implemented by a person skilled in the art on a project-by-project basis and details the transformation to be performed so that the 3D model sent by the embedded device meets the designer's expectations.

[0084] 2. If the finalizer module has received an instruction to intervene in the transformation of the 3D model, it is possible to modify the morphology of the 3D model, its density, its orientation, etc. All these transformations must be aimed at making the 3D model compatible and optimized for embedded devices. This modification is carried out via a callback that causes a series of instructions to be executed by the interpreter.

[0085] 3. If the finalizer receives instructions that intervene in the transformation of materials, it has the possibility to completely redefine them, decomposing them, assigning them processing, light and material algorithms (or shaders) that transform image streams, with the goal of making the data compatible and optimized for embedded devices. This modification is performed via a callback that causes a series of instructions to be executed by the interpreter.

[0086] 4. The terminator module is called as many times as the 3D model or material is processed by the 3D development tool in a high-level language.

[0087] 5. When storing 3D models, the terminator module can choose the format that best suits the embedded device (binary, XML, Json, etc.).

[0088] Now refer to Figure 3 The manner in which the binding method according to the present invention is implemented in a conversion process of converting a 3D model from a development tool into a model embedded in a device provided with a human-machine interface is described.

[0089] 1. Consider the human-machine interface designed by the designer and processed by the 3D development tool so that it can be embedded,

[0090] 2. Business applications provide business functions to users of embedded devices.

[0091] 3. The interpreter of the interpreted language enables the business application to run and utilize the functions of the C++ library,

[0092] 4. C++ library presents 3D, video and audio functions via API,

[0093] 5. The 3D graphics driver presents the capabilities of the graphics processing unit (GPU) via the API (OpenGL) and converts the given instructions into GPU primitives.

[0094] 6. The 3D graphics processing unit GPU processes the graphics primitives and converts them into video signals, 7. The screen of the embedded device displays the video signal transmitted by the GPU, and thus displays the HMI (1).

[0095] Now refer to Figure 4 The method for generating a binding according to the invention is described in terms of its role in different stages of design, production and operation.

[0096] In the design phase, which is performed on a computer or an embedded device, a 3D model (A) originating directly from a CAD (or CAO) tool is manipulated.

[0097] In the production phase, which is also executed on a computer or embedded device, the 3D model is submitted at the input of the FXB converter, which includes a program written in C++ and integrates a terminator module, a Lua binding module and a Lua virtual machine. The terminator module executes the conversion rules. The result of the FXB converter is 3D production data, including models, algorithms of the "shader" type, images and videos. These results can be accessed via user scripts and plug-in modules. They are applied at the input of a visual 3D development tool, which includes a program written in C++ and includes a Lua binding module and a Lua virtual machine (VM). This C++ program is controlled by a Lua binding program. At the output of this C++ program, optimized 3D data can be obtained, which are suitable for optimized embedded 3D platforms.

[0098] Now refer to Figure 5 An example of the structure of an embedded engine that performs the binding method according to the present invention is described. The embedded engine receives a business application at an input. The embedded engine includes a Lua virtual machine, the deliverables of which are embedded in a virtual machine VM, the output of which is connected to the input of a Lua binding module, and the Lua binding module provides input for a dedicated C++ core. The C++ core generates a 3D rendering system, a physics system, and a scripting system.

[0099] The embedded module also includes a virtual machine group VM1-4, some of which are associated with user tasks. These virtual machines are also connected to the Lua binding module.

[0100] Reference Figure 6 , the binding method according to the present invention can be executed in a multi-platform and multi-purpose environment:

[0101] Embedded device or smartphone :

[0102] The binding method according to the invention can be embedded in a vehicle or a smartphone. In this case of use, the API C++ is used, and the business application is implemented in C++. However, due to the binding, the 3D development tool still integrates a Lua virtual machine, which can execute microscripts (or in fact more complex scripts) that are usually used to cause the movement of visual elements.

[0103] a. Smartphone

[0104] Applications that use 3D in an intensive way, either live or mixed with other elements, such as viewing 3D objects in augmented reality.

[0105] b. Motor vehicles

[0106] Applications that use 3D real-time in an intensive way to replace all or some physical items of a device (infotainment, cluster, etc.).

[0107] Computer or Internet Applications

[0108] The binding method according to the invention providing a direct gateway to Python allows rapid development of complex 3D applications without requiring expert knowledge of low-level real-time 3D APIs.

[0109] If all business applications are written in Python, using Lua in parallel is possible / recommended, depending on the nature of the tasks and the expected performance.

[0110] a. Desktop

[0111] Applications written in Python are advantageously portable across all reference platforms (Windows, OS X, Linux). This is the ideal format for developing business applications that execute directly on regular workstations.

[0112] b. Server

[0113] The modular and portable nature of the 3D C++ engine / Python business application pair provides the possibility of running it in "renderless" mode (i.e., by deactivating the image generator). The paradoxical situation of a real-time 3D image engine that calculates real-time 3D images but does not display them is obtained. This is a very common function in "online massive", where multiple client software instances are connected to the same server and must find the same simulation on the server. Here, Python is also fully suitable for developing "server-side" applications. This function can be obtained with C++ alone under the Unreal engine and with C# alone under Unity3D. The software environment that executes the binding method according to the present invention opens this function to C++ / Python / Lua / C#.

[0114] Computer or smartphone

[0115] The binding method according to the invention is particularly suitable for high-performance and compact applications on office computers or smartphones / embedded devices, while providing maximum accessibility to developers via bindings and Lua.

[0116] a. Office computer

[0117] Fast, compact business applications with moderate interoperability requirements.

[0118] b. Smartphone

[0119] There is a great need for fast and compact business applications with real-time 3D images.

[0120] Web Client

[0121] This involves the latest developments for "client-side" web applications (executed by a navigator or browser). Developing business applications 100% in C++ opens the first door to WebAssembly / WebGL targets. The extremely compact (12000 lines of C) virtual machine Lua provides the second channel.

[0122] Compiling C++ in WebAssembly is very new. This is an assembly language for a virtual target CPU. Consensus on the specification for a platform common to the major web browsers (Firefox, Apple, Google, Microsoft) was just validated in March 2017.

[0123] Due to the compactness and portability of its C++ source code, the binding method according to the present invention and its implementation for converting models are ideal technologies for running in WebAssembly. The main problem is the size of the binary files. To date, the WASM binaries of C / C++ libraries used with the binding method according to the present invention represent 5 megaoctets. By way of example, the WASM binary of the Unreal engine represents 35 megaoctets. In WebAssembly, Unity3D must be limited to subcomponents of the functions that exist in C#.

[0124] Of course, the present invention is not limited to the above-mentioned embodiments, and many modifications may be made to the embodiments without departing from the scope of the present invention. Of course, the various features, types, variants and embodiments of the present invention may be associated with each other according to various combinations, as long as they are not mutually incompatible or exclusive. In particular, all the above-mentioned variations and embodiments may be combined with each other.

Claims

1. A method for generating a binding between a C / C++ library and a software environment of one or more high-level interpreted languages ​​to present the functionality of the C / C++ library to the one or more high-level interpreted languages, the method comprising the following steps implemented by a computer: - processing a definition of said binding to generate a binding element, said definition having previously been written in a high-level language, said definition comprising a list of functions, - generating binding elements exposed to the one or more high-level interpreted languages ​​to produce a set of C++ functions exposed to the one or more high-level interpreted languages, wherein, The binding element is also configured to enable the C / C++ library to call functions written in the one or more high-level interpreted languages ​​to extend the functionality of the C / C++ library. - compile the C++ code and link the C++ code to the C / C++ library, - obtaining a dynamic library integrating the C / C++ library and the interface layer compiled from the C / C++ code; - converting a three-dimensional engine derived from said C / C++ library to be embedded in a project of a device in which software applications are written using said high-level language, -Import the dynamic library; - access the functions of the C / C++ library through the dynamic library; and - Converting the 3D model from the C / C++ library into a 3D model that can be embedded in a device with a human-machine interface in a mobile system, the human-machine interface being designed and processed using a 3D development tool, wherein the conversion of the 3D model comprises utilizing the functions of the C / C++ library through an interpreter, so that: - the C / C++ library presents 3D, video and audio functionality through an application programming interface, - a 3D graphics driver that exposes the capabilities of the 3D GPU through an API and converts given instructions into GPU primitives, and wherein the 3D GPU processes the GPU primitives and converts the GPU primitives into video signals to be displayed on a screen within the device, wherein processing the definition includes processing an allocation between: - high-level functionality of each of the one or more high-level interpreted languages; - C++ functions of the C++ language, which are supported in a transparent manner by the binding and can be accessed from the high-level language.

2. The method according to claim 1, wherein: The definition of the binding is written in the form of a program in a high-level language using an application programming interface, which describes the application programming interface of the C / C++ library as the application programming interface to be exposed to developers of the high-level language.

3. The method according to claim 1 or 2, wherein: The definition of the binding includes a list of functions, expected parameters for the functions, and return values.

4. The method according to claim 1 or 2, further comprising processing a document attached to the C / C++ library as a target high-level language and generating an XML file.

5. The method according to claim 4, characterized in that The method further comprises, after the compiling step, obtaining a static library intended to embed the high-level interpreted language directly into the C++ code derived from the compiled state.

6. A computing module, said computing module implementing the binding method according to any one of the preceding claims, operating with a C / C++ library and one or more high-level interpreted languages ​​to present the functionality of said C / C++ library to said interpreted languages, said computing module comprising: - means for processing a definition of said binding between a software environment of said one or more high-level interpreted languages ​​and said C / C++ library to present the functionalities of said C / C++ library to said one or more high-level interpreted languages ​​to generate binding elements, said definition being written in a high-level language and comprising a function list, Means for generating the binding element so that the C / C++ library can call functions written in the one or more high-level interpreted languages ​​to extend the functionality of the C / C++ library, the binding element being exposed to the one or more high-level interpreted languages ​​to generate a C++ function group exposed to the one or more high-level interpreted languages, and enabling the C / C++ library to call functions written in the one or more high-level interpreted languages ​​to extend the functionality of the C / C++ library; - means for compiling C++ code and linking said C++ code to said C / C++ library, - means for obtaining a dynamic library integrating said C / C++ library and an interface layer compiled from said C / C++ code; - means for converting a three-dimensional engine originating from said C / C++ library to be embedded in a project of a device in which software applications are written using said one or more high-level interpreted languages, - means for importing said dynamic library; - means for accessing the functions of said C / C++ library through said dynamic library; as well as - means for converting a three-dimensional model derived from the C / C++ library into a three-dimensional model configured to be embedded in a device provided with a human-machine interface in a mobile system, the human-machine interface being designed and processed using a three-dimensional development tool, wherein the conversion of the three-dimensional model comprises utilizing the functions of the C / C++ library through an interpreter, so that: - the C / C++ library presents 3D, video and audio functionality through an application programming interface, - a 3D graphics driver that exposes the capabilities of the 3D GPU through an API and converts given instructions into GPU primitives, and - The 3D GPU processes the GPU primitives and converts the GPU into video signals to be displayed on a screen within the device.

Images