spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#include <map>
#include <list>
#include <vector>

#include "boost/python.hpp"
#include "boost/python/suite/indexing/map_indexing_suite.hpp"

using boost::ref;
using boost::shared_ptr;
using boost::noncopyable;
using namespace boost::python;

//---------------------------------------------------------------------
//einige Helfer
//---------------------------------------------------------------------
struct GIL // Nur für Threading notwendig. Benötigt ein PyEval_InitThreads() Aufruf direkt nach Py_Initialize() falls man es aus einer main raus nutzen will
{
    GIL()   { gstate = PyGILState_Ensure(); }
    ~GIL()  { PyGILState_Release(gstate); }

private:
    PyGILState_STATE gstate;
};

struct Except : public std::exception
{
    std::string str;
    Except(const char* what) : str(what)        {}
    Except(const std::string &what) : str(what) {}
    ~Except() throw()                           {}
    const char* what() const throw()            { return str.c_str(); }
};

class Self
{
protected:
    PyObject* self;

    Self(void) : self(0)        { }
    Self(PyObject* s) : self(s) { Py_INCREF(self); }
    ~Self()                     { Py_DECREF(self); }
    
    void assoziate(PyObject* s)
    {
        if(self)
            throw Except("c++ instance has already a 'self'");
        self = s;
        Py_INCREF(self);
    }
};

//---------------------------------------------------------------------
//ab hier beginnt der Spass
//---------------------------------------------------------------------

int simple_func(int x,int y)
{
    return x + y;
}

struct dont_create_me_in_python
{
    dont_create_me_in_python(int x) {}
};

struct simple_POD_example
{
    int readonly_val;
    int readwrite_val;
};

struct complex_POD_example
{
    int readonly_val;
    int readwrite_val;

    complex_POD_example(void) : readonly_val(0), readwrite_val(0) {}
    complex_POD_example(int val1) : readonly_val(val1), readwrite_val(0) {}
    complex_POD_example(int val1,int val2) : readonly_val(val1), readwrite_val(val2) {}

    void set1(int val1)                     { readonly_val = val1; }
    void set2(int val1=0)                   { readonly_val = val1; }
    void set3(int val1,int val2=0)          { readonly_val = val1; readwrite_val = val2; }
};

BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(Overload_set2, set2, 0, 1)
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(Overload_set3, set3, 1, 2)

struct stl_container
{
    std::vector<int>                    vector;
    std::list<simple_POD_example>       list;
    std::map<int,complex_POD_example>   map;

    stl_container(int count)
    {
        vector.insert(vector.begin(),count,10);
        list.insert(list.begin(),count,simple_POD_example());
        for(int counter = 0; counter < count; counter++)
            map.insert(std::make_pair(counter,complex_POD_example(counter)));
    }
};

template <class T> PyObject* get_data(typename std::vector<T>* ptr)
{
    return PyBuffer_FromMemory (&ptr->front(), ptr->size() * sizeof(T));
}

template <class T> T get_item(typename std::vector<T>* ptr, size_t pos)
{
    return (*ptr)[pos];
}

template <class T> void set_item(typename std::vector<T>* ptr, size_t pos, const T& val)
{
    (*ptr)[pos] = val;
}

struct Interface
{
    float val;

    Interface(float x) : val(x) {}

    virtual float pure(const simple_POD_example &e) = 0;
    virtual float overwriteable(float x, float y)           { return x + y; }
    float call_pure(const simple_POD_example &e)            { return pure(e) + val; }
    float call_overwriteable(float x,float y)               { return overwriteable(x,y) + val; }
};

class Interface_callback : public Interface, public Self
{
public:
    Interface_callback(PyObject* s,float x) : Self(s), Interface(x)     {}

    float pure(const simple_POD_example &e)                                 { return call_method<float>(self, "pure", ref(e)); }
    float overwriteable(float x, float y)                                   { return call_method<float>(self, "overwriteable", x, y); }
    static float s_overwriteable(Interface_callback &e,float x, float y)    { return e.Interface::overwriteable(x,y); }

    //Anmerkung: call_method stürzt ab, wenn ein GIL Lock a la
    //http://wiki.python.org/moin/boost.python/HowTo#MultithreadingSupportformyfunction davor geöffnet wird
};

//---------------------------------------------------------------------
//Eigentliches "exposing". Wenn man ein Modul erstellen will, welches von Python aus geladen werden kann,
//muss das Modul als DLL erstellt werden und in diesem Fall den Namen "test.pyd" haben (siehe Linkeroptionen).
//---------------------------------------------------------------------
BOOST_PYTHON_MODULE(test)
{
    //kann wegen des "no_init" nicht von python aus erstellt werden
    class_<dont_create_me_in_python>("dont_create_me_in_python",no_init)
    ;
    
    class_<simple_POD_example>("simple_POD_example")
        .def_readonly("readonly_val", &simple_POD_example::readonly_val)
        .def_readwrite("readwrite_val", &simple_POD_example::readwrite_val)
    ;
    
    class_<complex_POD_example>("complex_POD_example",init<int>())
        .def(init<int,int>())
        .def_readonly("readonly_val", &complex_POD_example::readonly_val)
        .def_readwrite("readwrite_val", &complex_POD_example::readwrite_val)
        .def("set1",&complex_POD_example::set1)
        .def("set2",&complex_POD_example::set2,Overload_set2())
        .def("set3",&complex_POD_example::set3,Overload_set3())
    ;

    class_<stl_container>("stl_container",init<int>())
        .def_readwrite("map", &stl_container::map)
        .def_readwrite("list", &stl_container::list)
        .def_readwrite("vector", &stl_container::vector)
    ;

    class_<std::vector<int> >("testvector")
        .add_property("data", &get_data<int>)
        .def("__iter__", iterator<std::vector<int> >())
        .def("__getitem__", &get_item<int>)
        .def("__setitem__", &set_item<int>)
    ;

    class_<std::list<simple_POD_example> >("testlist")
        .def("__iter__", iterator<std::list<simple_POD_example> >())
    ;

    class_<std::map<int, complex_POD_example> >("testmap")
        .def(map_indexing_suite<std::map<int, complex_POD_example> >())
    ;
    
    
    //Es ist auch "class_<Interface,Interface_callback>" möglich (wenn keine rein virtuellen
    //Methoden existieren), aber dann erstellt Python interne Kopien soweit ich weiß.
    class_<Interface,noncopyable,shared_ptr<Interface_callback> >("Interface",init<float>())
        .def("call_pure",&Interface::call_pure)
        .def("call_overwriteable",&Interface::call_overwriteable)
        .def("overwriteable",&Interface_callback::s_overwriteable)
    ;
}


//---------------------------------------------------------------------
//nur notwendig zum Test bzw fürs "embedding".
//Wenn man nur ein Modul erstellen will, kann man diesen Block auslassen.
//---------------------------------------------------------------------
int main( int argc, char ** argv )
{
    PyImport_AppendInittab( "test", &inittest );

    Py_Initialize();
    object main_module((handle<>(borrowed(PyImport_AddModule("__main__")))));

    
    PyObject* PyFileObject = PyFile_FromString("bindings/test2.py", "r");
    PyRun_SimpleFile(PyFile_AsFile(PyFileObject), "test2.py");

    std::cin.get();
    return 0;
}

Quellcode

import test
print "hi"

#Test von no_init
try:
    test.dont_create_me_in_python()
except RuntimeError as e:
    print e

#Test von readonly und readwrite
obj = test.simple_POD_example()
obj.readwrite_val = 10

try:
    obj.readonly_val = 10
except AttributeError as e:
    print e

print "Werte von simple_POD_example: ",obj.readonly_val, obj.readwrite_val


#Test von den (ueberladenen) Methoden und den verschiedenen inits
try:
    test.complex_POD_example()
except:
    print "Hierfuer gibt es keinen (python bekannter) ctor"
    
obj1 = test.complex_POD_example(1)
obj2 = test.complex_POD_example(1,1)

print "Werte von complex_POD_example(1): ",obj1.readonly_val, obj1.readwrite_val
print "Werte von complex_POD_example(2): ",obj2.readonly_val, obj2.readwrite_val

obj1.set1(10)
obj2.set2()
obj2.set2(20)
obj1.set3(30)
obj1.set3(50)

print "Werte von complex_POD_example(1): ",obj1.readonly_val, obj1.readwrite_val
print "Werte von complex_POD_example(2): ",obj2.readonly_val, obj2.readwrite_val

#Test der stl container
obj = test.stl_container(10)
print "Vectorbuffer: ", obj.vector.data
print "Vectorinhalt: ", [x for x in obj.vector]
print "Listinhalt: ", [x for x in obj.list]
print "Mapinhalt: ", [x for x in obj.map]
obj.vector[2] = 0
print obj.vector[2]

#Test von Interface/virtual/pure-virtual
class myClass1(test.Interface):
    def __init__(self,val):
        test.Interface.__init__(self,val)
        
class myClass2(test.Interface):
    def __init__(self,val):
        test.Interface.__init__(self,val)
        
    def pure(self,POD):
        return float(POD.readonly_val+POD.readwrite_val)
    
    def overwriteable(self,x,y):
        return (x+y)*2
obj1 = myClass1(100)
obj2 = myClass2(100)
data = test.simple_POD_example()
data.readwrite_val = 10
print "hi2"

print obj1.call_overwriteable(1,1)
print obj2.call_overwriteable(1,1)
print obj2.call_pure(data)

try:
    obj1.call_pure(data)
except RuntimeError as e:
    print "obj1 has no call_pure"

C-/C++-Quelltext

template<class T> void intrusive_ptr_add_ref(T* ptr)
{
    ptr->grab();
}

template<class T> void intrusive_ptr_release(T* ptr)
{
    ptr->drop();
}
//Nutzung
class_<MemExServerClient,noncopyable,intrusive_ptr<ServerClient_callback> >(.....

C-/C++-Quelltext

template<class T> T Read(NetworkBuffer &e)
{
    T ret;
    e.Read(ret);
    return ret;
}
//Nutzung
    class_<NetworkBuffer,noncopyable>("NetworkBuffer")
        .def<void(NetworkBuffer::*)(const int&)>("WriteInt", &NetworkBuffer::Write)
        .def<void(NetworkBuffer::*)(const bool&)>("WriteBool", &NetworkBuffer::Write)
        .def<void(NetworkBuffer::*)(const float&)>("WriteFloat", &NetworkBuffer::Write)
        .def<void(NetworkBuffer::*)(char*)>("WriteString", &NetworkBuffer::Write)
        .def<int(*)(NetworkBuffer&)>("ReadInt", &Read)
        .def<float(*)(NetworkBuffer&)>("ReadFloat", &Read)
        .def<std::string(*)(NetworkBuffer&)>("ReadString", &Read)
        ;