Interaktion mit C++ Klassen in Emscripten

Question

Die Emscripten Tutorial eine gute Erklärung dafür, wie mit C-Funktionen zur Interaktion: https://github.com/kripken/emscripten/wiki/Interacting-with-code

Aber wie interagieren Sie mit C++ Klassen:

• Call a Konstruktor eine erstellen Objekt
• oBJ
• Prevent Beseitigung von totem Code der Klassen löschen und seine Methoden

Answer 1

Check: https://github.com/kripken/emscripten/wiki/embind

Beispiel:

C++ Code:

#include <emscripten/bind.h> 

using namespace emscripten; 

class MyClass { 
public: 
    MyClass(int x, std::string y) 
     : x(x) 
     , y(y) 
    {} 

    void incrementX() { 
     ++x; 
    } 

    int getX() const { return x; } 
    void setX(int x_) { x = x_; } 

    static std::string getStringFromInstance(const MyClass& instance) { 
     return instance.y; 
    } 

private: 
    int x; 
    std::string y; 
}; 

EMSCRIPTEN_BINDINGS(my_class_example) { 
    class_<MyClass>("MyClass") 
     .constructor<int, std::string>() 
     .function("incrementX", &MyClass::incrementX) 
     .property("x", &MyClass::getX, &MyClass::setX) 
     .class_function("getStringFromInstance", &MyClass::getStringFromInstance) 
     ; 
} 

JS-Code:

var instance = new Module.MyClass(10, "hello"); 
instance.incrementX(); 
instance.x; // 12 
instance.x = 20; // 20 
Module.MyClass.getStringFromInstance(instance); // "hello" 
instance.delete(); 

Answer 2

Die Art, wie ich dies tat war, um "Proxy" -Funktionen zu erstellen, die die notwendigen Operationen ausführen. Zum Beispiel:

class HelloWorld 
{ 
    int x; 
    public: 
    HelloWorld() { x = 0; } 
    ~HelloWorld() {} 
    void setX(int v) { x = v; } 
    int getX() { return x; } 
    // ... 
}; 


//compile using "C" linkage to avoid name obfuscation 
extern "C" { 
    //constructor, returns a pointer to the HelloWorld object 
    void *HW_constructor() { 
    return new HelloWorld(); 
    } 

    void HW_setX(HelloWorld *hw, int x) { 
    hw->setX(x); 
    } 

    int HW_getX(HelloWorld *hw) { 
    return hw->getX(); 
    } 

    void HW_destructor(HelloWorld *hw) { 
    delete hw; 
    } 
}; 

dann in JS, haben Sie einen Klon des Objekts zu erstellen, die die Proxy-Funktionen aufrufen (ärgerlich, ich weiß, aber ich weiß nicht, von einer besseren Lösung im Moment):

// get references to the exposed proxy functions 
var HW_constructor = Module.cwrap('HW_constructor', 'number', []); 
var HW_destructor = Module.cwrap('HW_destructor', null, ['number']); 
var HW_setX = Module.cwrap('HW_setX', null, ['number', 'number']); 
var HW_getX = Module.cwrap('HW_getX', 'number', ['number']); 

function HelloWorld() { 
    this.ptr = HW_constructor(); 
} 

HelloWorld.prototype.destroy = function() { 
    HW_destructor(this.ptr); 
}; 

HelloWorld.prototype.setX = function (x) { 
    HW_setX(this.ptr, x); 
}; 

HelloWorld.prototype.getX = function() { 
    return HW_getX(this.ptr); 
}; 

WICHTIG Denken Sie daran, für diese, um zu arbeiten, müssen Sie das folgende Flag zu Ihrem emcc Befehl hinzufügen, um es zu sagen, nicht die Proxy-Methoden als toter Code Streifen aus (Hinweis: das Unterstreichungs hier ist beabsichtigt und wichtig!):

emcc helloworld.cpp -o helloworld.js \ 
    -s EXPORTED_FUNCTIONS="['_HW_constructor','_HW_destructor','_HW_setX','_HW_getX']" 

EDIT: Ich habe eine gist für Leute erstellt, um den Code auszuprobieren. diese