bind.h (in Arbeit)¶

Die C++-APIs in bind.h definieren

Eine Leitdokumentation für diese API finden Sie unter Embind.

Inhaltsverzeichnis

Wie man diese API verwendet
Richtlinien (Policies)
select_overload und select_const
Funktionen
Value Tuples
Value Structs
Smart Pointer
Klassen
Vektoren
Maps
Enums
Konstanten

Wie man diese API verwendet ¶

Definiert¶

EMSCRIPTEN_BINDINGS(name)¶

Diese Definition wird verwendet, um C++-Klassen, -Funktionen und andere Konstrukte an JavaScript zu binden. Sie wird je nach dem zugeordneten Konstrukt unterschiedlich verwendet – siehe das Embind-Handbuch für Beispiele.

Parameter: name – Dies ist ein Etikett, um eine Gruppe verwandter Bindungen zu kennzeichnen (zum Beispiel EMSCRIPTEN_BINDINGS(physics), EMSCRIPTEN_BINDINGS(components), usw.)

type sharing_policy¶

type sharing_policy::NONE¶

type sharing_policy::INTRUSIVE¶

type sharing_policy::BY_EMVAL¶

Richtlinien ¶

Derzeit wird nur die Richtlinie allow_raw_pointers unterstützt. Eventuell hoffen wir, Boost.Python-ähnliche Rohzeiger-Richtlinien zur Verwaltung der Objekt-Eigentümerschaft zu implementieren.

type arg¶

static int index¶

// Prototype
static constexpr int index

type ret_val¶

static int index¶

// Prototype
static constexpr int index

type allow_raw_pointers¶

Diese Richtlinie wird verwendet, um Rohzeiger zuzulassen.

type Transform::type¶

type allow_raw_pointer¶

select_overload und select_const ¶

typename std::add_pointer<Signature>::type select_overload(typename std::add_pointer<Signature>::type fn)¶

// Prototype
template<typename Signature>
typename std::add_pointer<Signature>::type select_overload(typename std::add_pointer<Signature>::type fn)

Parameter: typename std::add_pointer<Signature>::type fn –

typename internal::MemberFunctionType<ClassType, Signature>::type select_overload()¶

// Prototype
template<typename Signature, typename ClassType>
typename internal::MemberFunctionType<ClassType, Signature>::type select_overload(Signature (ClassType::*fn))

Parameter: Signature (ClassType::*fn) –

auto select_const()¶

// Prototype
template<typename ClassType, typename ReturnType, typename... Args>
auto select_const(ReturnType (ClassType::*method)(Args...) const)

Parameter: ReturnType (ClassType::*method)(Args...) const –

typename internal::CalculateLambdaSignature<LambdaType>::type optional_override(const LambdaType &fp)¶

// Prototype
template<typename LambdaType>
typename internal::CalculateLambdaSignature<LambdaType>::type optional_override(const LambdaType& fp)

Parameter: const LambdaType& fp –

Funktionen ¶

void function()¶

//prototype
template<typename ReturnType, typename... Args, typename... Policies>
void function(const char* name, ReturnType (*fn)(Args...), Policies...)

Registriert eine Funktion zum Export nach JavaScript. Dies wird innerhalb eines EMSCRIPTEN_BINDINGS()-Blocks aufgerufen.

Zum Beispiel zum Exportieren der Funktion lerp()

// quick_example.cpp
#include <emscripten/bind.h>

using namespace emscripten;

float lerp(float a, float b, float t) {
   return (1 - t) * a + t * b;
}

EMSCRIPTEN_BINDINGS(my_module) {
   function("lerp", &lerp);
}

Parameter

const char* name – Der Name der zu exportierenden Funktion (z.B. "lerp").
ReturnType (*fn)(Args...) – Funktionszeigeradresse für die exportierte Funktion (z.B. &lerp).
Policies... – Richtlinie zur Verwaltung der Eigentümerschaft von Rohzeigerobjekten. Muss derzeit allow_raw_pointers sein.

Werte-Tupel ¶

class value_array : public internal::noncopyable¶

type class_type¶: Ein Typedef von ClassType, dem Typnamen des getypten Typs für die Klasse.

value_array(const char *name)¶

Konstruktor.

Parameter: const char* name –

~value_array()¶: Destruktor.

value_array &element(ElementType InstanceType::*field)¶

Parameter: ElementType InstanceType::*field – Beachten Sie, dass ElementType und InstanceType Typnamen (getypte Typen) sind.

value_array &element(Getter getter, Setter setter)¶

Parameter

Getter getter – Beachten Sie, dass Getter ein Typname (getypter Typ) ist.
Setter setter – Beachten Sie, dass Setter ein Typname (getypter Typ) ist.

value_array &element(index<Index>)¶

Parameter: index<Index> – Beachten Sie, dass Index ein ganzzahliger Vorlagenparameter ist.

Werte-Strukturen ¶

class value_object : public internal::noncopyable¶

type class_type¶: Ein Typedef von ClassType, dem Typnamen des getypten Typs für die Klasse.

value_object(const char *name)¶

Konstruktor.

Parameter: const char* name –

~value_object()¶: Destruktor.

value_object &field(const char *fieldName, FieldType InstanceType::*field)¶

Parameter

const char* fieldName –
FieldType InstanceType::*field –

value_object &field(const char *fieldName, Getter getter, Setter setter)¶

Parameter

const char* fieldName –
Getter getter – Beachten Sie, dass Getter ein Typname (getypter Typ) ist.
Setter setter – Beachten Sie, dass Setter ein Typname (getypter Typ) ist.

value_object &field(const char *fieldName, index<Index>)¶

Parameter

const char* fieldName –
index<Index> – Beachten Sie, dass Index ein ganzzahliger Vorlagenparameter ist.

Smart Pointers ¶

type default_smart_ptr_trait¶

//prototype
template<typename PointerType>
struct default_smart_ptr_trait

static sharing_policy get_sharing_policy()¶

static void *share(void *v)¶

Parameter: void* v –

static PointerType *construct_null()¶

Gibt zurück: Beachten Sie, dass der zurückgegebene PointerType ein Typname (getypter Typ) ist.

type smart_ptr_trait¶

//prototype
template<typename PointerType>
struct smart_ptr_trait : public default_smart_ptr_trait<PointerType>

typedef PointerType::element_type element_type¶

//prototype
typedef typename PointerType::element_type element_type;

Ein Typedef für PointerType::element_type, wobei PointerType ein Typname (getypter Typ) ist.

static element_type *get(const PointerType &ptr)¶

Parameter: const PointerType& ptr – Beachten Sie, dass PointerType ein Typname (getypter Typ) ist.

template<typename PointeeType> using smart_ptr_trait<std::shared_ptr<PointeeType>>¶

//prototype
template<typename PointeeType>
struct smart_ptr_trait<std::shared_ptr<PointeeType>>

type PointerType¶: Ein Typedef zu std::shared_ptr<PointeeType>, wobei PointeeType ein Typname (getypter Typ) ist.

type element_type¶: Ein Typedef für den PointerType::element_type.

static element_type *get(const PointerType &ptr)¶

Parameter: const PointerType& ptr –

static sharing_policy get_sharing_policy()¶

static std::shared_ptr<PointeeType> *share(PointeeType *p, EM_VAL v)¶

Parameter

PointeeType* p – Beachten Sie, dass PointeeType ein Typname (getypter Typ) ist.
EM_VAL v –

static PointerType *construct_null()¶

Klassen ¶

class wrapper : public T, public internal::WrapperBase¶

//prototype
template<typename T>
class wrapper : public T, public internal::WrapperBase

type class_type¶: Ein Typedef von T, dem Typnamen des getypten Typs für die Klasse.

wrapper(val &&wrapped, Args&&... args)¶

//prototype
template<typename... Args>
explicit wrapper(val&& wrapped, Args&&... args)
  : T(std::forward<Args>(args)...)
  , wrapped(std::forward<val>(wrapped))

Konstruktor.

Parameter

val&& wrapped –
Args&&... args – Beachten Sie, dass Args ein Typname (getypter Typ) ist.

~wrapper()¶: Destruktor.

ReturnType call(const char *name, Args&&... args) const¶

Konstruktor.

Parameter

const char* name –
Args&&... args – Beachten Sie, dass Args ein Typname (getypter Typ) ist.

Gibt zurück

Beachten Sie, dass ReturnType ein Typname (getypter Typ) ist.

EMSCRIPTEN_WRAPPER(T)¶

Parameter: T –

type base¶

type class_type¶: Ein Typedef von BaseClass, dem Typnamen des getypten Typs für die Klasse.

static void verify()¶: Hinweis: ist eine Vorlagenfunktion, die den Typnamen ClassType akzeptiert.

static internal::TYPEID get()¶

template<typename ClassType>
using Upcaster = BaseClass* (*)(ClassType*);

template<typename ClassType>
using Downcaster = ClassType* (*)(BaseClass*);

static Upcaster<ClassType> getUpcaster()¶

//prototype
template<typename ClassType>
static Upcaster<ClassType> getUpcaster()

static Downcaster<ClassType> getDowncaster()¶

//prototype
template<typename ClassType>
static Downcaster<ClassType> getDowncaster()

static To *convertPointer(From *ptr)¶

//prototype
template<typename From, typename To>
static To* convertPointer(From* ptr)

Parameter: From* ptr –

type pure_virtual¶

type Transform¶

Beachten Sie, dass dies eine Vorlagenstruktur ist, die den Typnamenparameter InputType und die Ganzzahl Index akzeptiert.

type type¶: Dies ist ein Typedef für den Typnamenparameter der Elternstruktur InputType.

type constructor¶: Beachten Sie, dass dies eine Vorlagenstruktur ist, die den Typnamen ... ConstructorArgs akzeptiert.

class class_¶

Beachten Sie, dass dies eine Vorlagenklasse mit den Typnamenparametern ClassType und BaseSpecifier ist.

type class_type¶: Ein Typedef von ClassType (ein Typname für die Klasse).

type base_specifier¶: Ein Typedef von BaseSpecifier (ein Typname für die Klasse).

type HELPNEEDEDHERE¶

class_() = delete;

explicit class_(const char *name)¶

//prototype
EMSCRIPTEN_ALWAYS_INLINE explicit class_(const char* name)

Konstruktor.

Parameter: const char* name –

const class_ &smart_ptr(const char *name) const¶

//prototype
template<typename PointerType>
EMSCRIPTEN_ALWAYS_INLINE const class_& smart_ptr(const char* name) const

Parameter: const char* name –
Gibt zurück: Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &constructor() const¶

//prototype
template<typename... ConstructorArgs, typename... Policies>
EMSCRIPTEN_ALWAYS_INLINE const class_& constructor(Policies... policies) const

Argumentlose Form des Klassenkonstruktors. Dies ruft den natürlichen Konstruktor mit den in der Vorlage angegebenen Argumenten auf. Weitere Informationen finden Sie unter Externe Konstruktoren.

Parameter: Policies... policies – Richtlinie zur Verwaltung der Eigentümerschaft von Rohzeigerobjekten. Muss derzeit allow_raw_pointers sein.
Gibt zurück: Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &constructor(Callable callable, Policies...) const¶

//prototype
template<typename Signature = internal::DeduceArgumentsTag, typename Callable, typename... Policies>
EMSCRIPTEN_ALWAYS_INLINE const class_& constructor(Callable callable, Policies...) const

Klassenkonstruktor für Objekte, die eine Fabrikfunktion zur Erstellung des Objekts verwenden. Diese Methode akzeptiert entweder einen Funktionszeiger, ein std::function-Objekt oder ein Funktionsobjekt, das ein neu konstruiertes Objekt zurückgibt. Wenn das Callable ein Funktionsobjekt ist, muss die Funktionssignatur explizit im Vorlagenparameter Signature im Format ReturnType (Args...) angegeben werden. Für Callable-Typen, die keine Funktionsobjekte sind, wird die Methodensignatur abgeleitet.

Die folgenden sind alle gültige Aufrufe von constructor

using namespace std::placeholders;
myClass1.constructor(&my_factory);
myClass2.constructor(std::function<ClassType2(float, float)>(&class2_factory));
myClass3.constructor<ClassType3(const val&)>(std::bind(Class3Functor(), _1));

Weitere Informationen finden Sie unter Externe Konstruktoren.

Parameter

Callable callable – Beachten Sie, dass Callable entweder ein Member-Funktionszeiger, ein Funktionszeiger, ein std::function oder ein Funktionsobjekt sein kann.
Policies... policies – Richtlinie zur Verwaltung der Eigentümerschaft von Rohzeigerobjekten. Muss derzeit allow_raw_pointers sein.

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &smart_ptr_constructor() const¶

//prototype
template<typename SmartPtr, typename... Args, typename... Policies>
EMSCRIPTEN_ALWAYS_INLINE const class_& smart_ptr_constructor(const char* smartPtrName, SmartPtr (*factory)(Args...), Policies...) const

Parameter

const char* smartPtrName –
SmartPtr (*factory)(Args...) –
Policies... policies – Richtlinie zur Verwaltung der Eigentümerschaft von Rohzeigerobjekten. Muss derzeit allow_raw_pointers sein.

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &allow_subclass() const¶

//prototype
 template<typename WrapperType, typename PointerType, typename... ConstructorArgs>
EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
  const char* wrapperClassName,
  const char* pointerName,
  ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>()
) const

Parameter

const char* wrapperClassName –
const char* pointerName –
emscripten::constructor<ConstructorArgs...> constructor) –

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &allow_subclass(const char *wrapperClassName, emscripten::constructor<ConstructorArgs...> constructor) const¶

//prototype
template<typename WrapperType, typename... ConstructorArgs>
EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
  const char* wrapperClassName,
  ::emscripten::constructor<ConstructorArgs...> constructor = ::emscripten::constructor<>()
) const

Parameter

const char* wrapperClassName –
::emscripten::constructor<ConstructorArgs...> constructor) –

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &function() const¶

//prototype
template<typename Signature = internal::DeduceArgumentsTag, typename Callable, typename... Policies>
EMSCRIPTEN_ALWAYS_INLINE const class_& function(const char* methodName, Callable callable, Policies...) const

Diese Methode dient zur Deklaration einer Methode, die zu einer Klasse gehört.

Auf der JavaScript-Seite ist dies eine Funktion, die als Eigenschaft des Prototyps gebunden wird. Zum Beispiel würde .function("myClassMember", &MyClass::myClassMember) myClassMember an MyClass.prototype.myClassMember in JavaScript binden. Diese Methode akzeptiert entweder einen Zeiger auf eine Member-Funktion, einen Funktionszeiger, ein std::function-Objekt oder ein Funktionsobjekt. Wenn das Callable kein Zeiger auf eine Member-Funktion ist, muss es den ClassType als ersten (this)-Parameter akzeptieren. Wenn das Callable ein Funktionsobjekt ist, muss die Funktionssignatur explizit im Vorlagenparameter Signature im Format ReturnType (Args...) angegeben werden. Für Callable-Typen, die keine Funktionsobjekte sind, wird die Methodensignatur abgeleitet.

Ein Methodenname, der im menschenlesbaren bekannten Symbolformat angegeben ist (z.B. @@iterator), wird unter Verwendung des benannten Symbol für JavaScript gebunden (z.B. Symbol.iterator).

Die folgenden sind alle gültige Aufrufe von function

using namespace std::placeholders;
myClass.function("myClassMember", &MyClass::myClassMember)
    .function("myFreeFunction", &my_free_function)
    .function("myStdFunction", std::function<float(ClassType&, float, float)>(&my_function))
    .function<val(const MyClass&)>("myFunctor", std::bind(&my_functor_taking_this, _1));

Parameter

const char* methodName –
Callable callable – Beachten Sie, dass Callable entweder ein Member-Funktionszeiger, ein Funktionszeiger, ein std::function oder ein Funktionsobjekt sein kann.
typename... Policies – Richtlinie zur Verwaltung der Eigentümerschaft von Rohzeigerobjekten. Muss derzeit allow_raw_pointers sein.

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &property() const¶

//prototype
template<typename FieldType, typename = typename std::enable_if<!std::is_function<FieldType>::value>::type>
EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, const FieldType ClassType::*field) const

Parameter

const char* fieldName –
const FieldType ClassType::*field –

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &property(const char *fieldName, FieldType ClassType::*field) const¶

//prototype
template<typename FieldType, typename = typename std::enable_if<!std::is_function<FieldType>::value>::type>
EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, FieldType ClassType::*field) const

Parameter

const char* fieldName –
FieldType ClassType::*field –

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &property(const char *fieldName, Getter getter) const¶

//prototype
template<typename PropertyType = internal::DeduceArgumentsTag, typename Getter>
EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, Getter getter) const;

Deklariert eine schreibgeschützte Eigenschaft mit dem angegebenen fieldName in der Klasse unter Verwendung des angegebenen getter, um den Eigenschaftswert abzurufen. Getter kann entweder eine Klassenmethode, eine Funktion, eine std::function oder ein Funktionsobjekt sein. Wenn Getter kein Zeiger auf eine Member-Funktion ist, muss es eine Instanz des ClassType als this-Argument akzeptieren. Wenn Getter ein Funktionsobjekt ist, muss der Eigenschaftstyp als Vorlagenparameter angegeben werden, da er nicht abgeleitet werden kann, z.B.: myClass.property<int>("myIntProperty", MyIntGetterFunctor());

Parameter

const char* fieldName –
Getter getter – Beachten Sie, dass Getter ein Typname für eine Funktion ist.

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &property(const char *fieldName, Getter getter, Setter setter) const¶

//prototype
template<typename PropertyType = internal::DeduceArgumentsTag, typename Getter, typename Setter>
EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, Getter getter, Setter setter) const

Dies ist eine Funktionenvorlage, die Typnamen Setter und Getter annimmt: template<typename Getter, typename Setter>, die eine Lese-Schreib-Eigenschaft mit dem angegebenen fieldName in der Klasse deklariert. Getter und Setter können entweder eine Klassenmethode, eine Funktion, ein std::function oder ein Funktionsobjekt sein. Wenn Getter oder Setter kein Zeiger auf eine Member-Funktion ist, muss es eine Instanz des ClassType als this-Argument akzeptieren. Wenn Getter oder Setter ein Funktionsobjekt ist, muss der Eigenschaftstyp als Vorlagenparameter angegeben werden, da er nicht abgeleitet werden kann, z.B.: myClass.property<int>("myIntProperty", MyIntGetterFunctor(), MyIntSetterFunctor());

Parameter

const char* fieldName –
Getter getter – Beachten Sie, dass Getter ein Typname für eine Funktion ist.
Setter setter – Beachten Sie, dass Setter ein Typname für eine Funktion ist.

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &class_function() const¶

//prototype
template<typename ReturnType, typename... Args, typename... Policies>
EMSCRIPTEN_ALWAYS_INLINE const class_& class_function(const char* methodName, ReturnType (*classMethod)(Args...), Policies...) const

Diese Methode dient zur Deklaration einer statischen Funktion, die zu einer Klasse gehört.

Auf der JavaScript-Seite ist dies eine Funktion, die als Eigenschaft des Konstruktors gebunden wird. Zum Beispiel bindet .class_function("myStaticFunction", &MyClass::myStaticFunction) myStaticFunction an MyClass.myStaticFunction.

Ein Methodenname, der im menschenlesbaren bekannten Symbolformat angegeben ist (z.B. @@species), wird unter Verwendung des benannten Symbol für JavaScript gebunden (z.B. Symbol.species).

Parameter

const char* methodName –
ReturnType (*classMethod)(Args...) –
Policies... – Richtlinie zur Verwaltung der Eigentümerschaft von Rohzeigerobjekten. Muss derzeit allow_raw_pointers sein.

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

const class_ &class_property(const char *fieldName, FieldType *field) const¶

//prototype
template<typename FieldType>
EMSCRIPTEN_ALWAYS_INLINE const class_& property(const char* fieldName, FieldType *field) const

Parameter

const char* fieldName –
FieldType ClassType::*field –

Gibt zurück

Eine const-Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung der class_-Funktionen, die die Bindung im EMSCRIPTEN_BINDINGS()-Block definieren.

Vektoren ¶

class_<std::vector<T>> register_vector(const char *name)¶

//prototype
template<typename T>
class_<std::vector<T>> register_vector(const char* name)

Eine Funktion zum Registrieren eines std::vector<T>.

Parameter: const char* name –

Karten ¶

class_<std::map<K, V>> register_map(const char *name)¶

//prototype
template<typename K, typename V>
class_<std::map<K, V>> register_map(const char* name)

Eine Funktion zum Registrieren einer std::map<K, V>.

Parameter: const char* name –

Enums ¶

class enum_¶

//prototype
template<typename EnumType>
class enum_

Registriert ein Enum zum Export nach JavaScript. Dies wird innerhalb eines EMSCRIPTEN_BINDINGS()-Blocks aufgerufen und funktioniert sowohl mit C++98-Enums als auch mit C++11 „enum classes“. Weitere Informationen finden Sie unter Enums.

type enum_type¶: Ein Typedef von EnumType (ein Typname für die Klasse).

enum_(const char *name)¶

Konstruktor.

Parameter: const char* name –

enum_ &value(const char *name, EnumType value)¶

Registriert einen Enum-Wert.

Parameter

const char* name – Der Name des aufgezählten Werts.
EnumType value – Der Typ des aufgezählten Werts.

Gibt zurück

Eine Referenz auf das aktuelle Objekt. Dies ermöglicht die Verkettung mehrerer Enum-Werte im EMSCRIPTEN_BINDINGS()-Block.

Konstanten ¶

void constant(const char *name, const ConstantType &v)¶

//prototype
template<typename ConstantType>
void constant(const char* name, const ConstantType& v)

Registriert eine Konstante zum Export nach JavaScript. Dies wird innerhalb eines EMSCRIPTEN_BINDINGS()-Blocks aufgerufen.

EMSCRIPTEN_BINDINGS(my_constant_example) {
  constant("SOME_CONSTANT", SOME_CONSTANT);
}

Parameter

const char* name – Der Name der Konstante.
const ConstantType& v – Der Konstantentyp. Dies kann jeder von embind bekannte Typ sein.