static void
rendermode_overlay_draw(void *data, RenderState *state, PyObject *src, PyObject *mask, PyObject *mask_light) {
RenderModeOverlay *self = (RenderModeOverlay *)data;
unsigned char r, g, b, a;
PyObject *top_block_py, *block_py;
// exactly analogous to edge-line code for these special blocks
int increment=0;
if (state->block == 44) // half-step
increment=6;
else if (state->block == 78) // snow
increment=9;
/* clear the draw space -- set alpha to 0 within mask */
tint_with_mask(state->img, 255, 255, 255, 0, mask, state->imgx, state->imgy, 0, 0);
/* skip rendering the overlay if we can't see it */
if (state->z != 127) {
unsigned char top_block = getArrayByte3D(state->blocks, state->x, state->y, state->z+1);
if (!is_transparent(top_block)) {
return;
}
/* check to be sure this block is solid/fluid */
top_block_py = PyInt_FromLong(top_block);
if (PySequence_Contains(self->solid_blocks, top_block_py) ||
PySequence_Contains(self->fluid_blocks, top_block_py)) {
/* top block is fluid or solid, skip drawing */
Py_DECREF(top_block_py);
return;
}
Py_DECREF(top_block_py);
}
/* check to be sure this block is solid/fluid */
block_py = PyInt_FromLong(state->block);
if (!PySequence_Contains(self->solid_blocks, block_py) &&
!PySequence_Contains(self->fluid_blocks, block_py)) {
/* not fluid or solid, skip drawing the overlay */
Py_DECREF(block_py);
return;
}
Py_DECREF(block_py);
/* get our color info */
self->get_color(data, state, &r, &g, &b, &a);
/* do the overlay */
if (a > 0) {
alpha_over(state->img, self->white_color, self->facemask_top, state->imgx, state->imgy + increment, 0, 0);
tint_with_mask(state->img, r, g, b, a, self->facemask_top, state->imgx, state->imgy + increment, 0, 0);
}
}
/** 'in' as 'has'.
* @throw type_err
*/
bool has(const obj& x)const
{
int r = PySequence_Contains(_p, x.p());
if(r != -1)
return r;
throw type_err("has failed");
}
//----------------------------------------------------------------------------
// Return set(dict.keys()).issubset(set([vkeys, ...])
// keys of dict must be string or unicode in Py2 and string in Py3!
// Parameters:
// dict - the Python dictionary object to be checked
// vkeys - a null-terminated list of keys (char *)
//----------------------------------------------------------------------------
int checkDictKeys(PyObject *dict, const char *vkeys, ...)
{
int i, j, rc;
PyObject *dkeys = PyDict_Keys(dict); // = dict.keys()
if (!dkeys) return 0; // no valid dictionary
j = PySequence_Size(dkeys); // len(dict.keys())
PyObject *validkeys = PyList_New(0); // make list of valid keys
va_list ap; // def var arg list
va_start(ap, vkeys); // start of args
while (vkeys != 0) // reached end yet?
{ // build list of valid keys to check against
#if PY_MAJOR_VERSION < 3
PyList_Append(validkeys, PyBytes_FromString(vkeys)); // Python 2
#else
PyList_Append(validkeys, PyUnicode_FromString(vkeys)); // python 3
#endif
vkeys = va_arg(ap, const char *); // get next char string
}
va_end(ap); // end the var args loop
rc = 1; // prepare for success
for (i = 0; i < j; i++)
{ // loop through dictionary keys
if (!PySequence_Contains(validkeys, PySequence_GetItem(dkeys, i)))
{
rc = 0;
break;
}
}
Py_DECREF(validkeys);
Py_DECREF(dkeys);
return rc;
}
int isInstance(PyObject *arg, classid id, PyTypeObject *type)
{
if (PyObject_TypeCheck(arg, &UObjectType_))
{
#if U_ICU_VERSION_HEX < 0x04060000
classid oid = ((t_uobject *) arg)->object->getDynamicClassID();
if (id == oid)
return 1;
PyObject *bn = PyInt_FromLong((Py_intptr_t) id);
PyObject *n = PyInt_FromLong((Py_intptr_t) oid);
#else
classid oid = typeid(*(((t_uobject *) arg)->object)).name();
if (!strcmp(id, oid))
return 1;
PyObject *bn = PyString_FromString(id);
PyObject *n = PyString_FromString(oid);
#endif
PyObject *list = PyDict_GetItem(types, bn);
int b = PySequence_Contains(list, n);
Py_DECREF(bn);
Py_DECREF(n);
return b ? b : PyObject_TypeCheck(arg, type);
}
return 0;
}
static int
proxy_contains(PyWeakReference *proxy, PyObject *value)
{
if (!proxy_checkref(proxy))
return -1;
return PySequence_Contains(PyWeakref_GET_OBJECT(proxy), value);
}
static int
Checker_check_int(Checker *self, PyObject *object, PyObject *name)
{
PyObject *permission=NULL;
int operator;
/* permission = self._permission_func(name) */
if (self->getperms)
permission = PyDict_GetItem(self->getperms, name);
/* if permission is not None: */
if (permission != NULL)
{
/* if permission is CheckerPublic: */
/* return # Public */
if (permission == CheckerPublic)
return 0;
if (checkPermission(permission, object, name) < 0)
return -1;
return 0;
}
operator = (PyString_Check(name)
&& PyString_AS_STRING(name)[0] == '_'
&& PyString_AS_STRING(name)[1] == '_');
if (operator)
{
/* elif name in _available_by_default: */
/* return */
int ic = PySequence_Contains(_available_by_default, name);
if (ic < 0)
return -1;
if (ic)
return 0;
/* if name != '__iter__' or hasattr(object, name): */
/* __traceback_supplement__ = (TracebackSupplement, object) */
/* raise ForbiddenAttribute, (name, object) */
if (strcmp("__iter__", PyString_AS_STRING(name)) == 0
&& ! PyObject_HasAttr(object, name))
/* We want an attr error if we're asked for __iter__ and we don't
have it. We'll get one by allowing the access. */
return 0;
}
{
PyObject *args;
args = Py_BuildValue("OO", name, object);
if (args != NULL)
{
PyErr_SetObject(ForbiddenAttribute, args);
Py_DECREF(args);
}
return -1;
}
}
//-----------------------------------------------------------------------------
// ApiType_RichCompare()
// Comparison routine. This routine allows the variable type objects
// registered with the API type to match as equal as mandated by the DB API.
//-----------------------------------------------------------------------------
static PyObject *ApiType_RichCompare(
udt_ApiType *self, // API type to compare
PyObject *other, // other object to compare
int comparisonType) // comparison type being made
{
PyObject *result;
int contains;
// only handle EQ and NE
if (comparisonType != Py_EQ && comparisonType != Py_NE) {
PyErr_SetString(g_InterfaceErrorException,
"API types only support comparing equal and not equal");
return NULL;
}
// for all other cases check to see if the object is in the list of types
contains = PySequence_Contains(self->types, other);
if (contains < 0)
return NULL;
if (comparisonType == Py_EQ && contains)
result = Py_True;
else if (comparisonType == Py_NE && !contains)
result = Py_True;
else result = Py_False;
Py_INCREF(result);
return result;
}
static int Proxy_contains(ProxyObject *self,
PyObject *value)
{
Proxy__ENSURE_WRAPPED_OR_RETURN_MINUS1(self);
return PySequence_Contains(self->wrapped, value);
}
int
is_transparent(unsigned char b) {
PyObject *block = PyInt_FromLong(b);
int ret = PySequence_Contains(transparent_blocks, block);
Py_DECREF(block);
return ret;
}
/*
* Implements PyObject_Dir(PyObject*) for pyjobjects. This is required for
* Python 3.3+ for dir(pyjobject) to work correctly.
*/
static PyObject* pyjobject_dir(PyObject *o, PyObject* ignore)
{
PyObject* attrs;
PyJObject *self = (PyJObject*) o;
Py_ssize_t size, i, contains;
attrs = PyList_New(0);
size = PySequence_Size(self->methods);
for (i = 0; i < size; i++) {
PyObject *item = PySequence_GetItem(self->methods, i);
contains = PySequence_Contains(attrs, item);
if (contains < 0) {
Py_DECREF(attrs);
return NULL;
} else if (contains == 0) {
if (PyList_Append(attrs, item) < 0) {
Py_DECREF(attrs);
return NULL;
}
}
}
// TODO copy/paste is bad, turn it into a method
size = PySequence_Size(self->fields);
for (i = 0; i < size; i++) {
PyObject *item = PySequence_GetItem(self->fields, i);
contains = PySequence_Contains(attrs, item);
if (contains < 0) {
Py_DECREF(attrs);
return NULL;
} else if (contains == 0) {
if (PyList_Append(attrs, item) < 0) {
Py_DECREF(attrs);
return NULL;
}
}
}
if (PyList_Sort(attrs) < 0) {
Py_DECREF(attrs);
return NULL;
}
return attrs;
}
static int t_sequence_seq_contains(t_sequence *self, PyObject *value)
{
int result;
if (self->itemvalue.flags & V_PURE)
result = PySequence_Contains(self->sequence, value);
else
{
value = _useValue(self, value);
if (!value)
return -1;
result = PySequence_Contains(self->sequence, value);
Py_DECREF(value);
}
return result;
}
static gboolean
eom_python_module_load (GTypeModule *gmodule)
{
EomPythonModulePrivate *priv = EOM_PYTHON_MODULE_GET_PRIVATE (gmodule);
PyObject *main_module, *main_locals, *locals, *key, *value;
PyObject *module, *fromlist;
Py_ssize_t pos = 0;
g_return_val_if_fail (Py_IsInitialized (), FALSE);
main_module = PyImport_AddModule ("__main__");
if (main_module == NULL) {
g_warning ("Could not get __main__.");
return FALSE;
}
/* If we have a special path, we register it */
if (priv->path != NULL) {
PyObject *sys_path = PySys_GetObject ("path");
PyObject *path = PyString_FromString (priv->path);
if (PySequence_Contains(sys_path, path) == 0)
PyList_Insert (sys_path, 0, path);
Py_DECREF(path);
}
main_locals = PyModule_GetDict (main_module);
/* We need a fromlist to be able to import modules with
* a '.' in the name. */
fromlist = PyTuple_New(0);
module = PyImport_ImportModuleEx (priv->module, main_locals, main_locals, fromlist);
Py_DECREF(fromlist);
if (!module) {
PyErr_Print ();
return FALSE;
}
locals = PyModule_GetDict (module);
while (PyDict_Next (locals, &pos, &key, &value)) {
if (!PyType_Check(value))
continue;
if (PyObject_IsSubclass (value, (PyObject*) PyEomPlugin_Type)) {
priv->type = eom_python_plugin_get_type (gmodule, value);
return TRUE;
}
}
return FALSE;
}
static PyObject*
validate_enum( Member* member, PyObject* owner, PyObject* oldvalue, PyObject* newvalue )
{
int res = PySequence_Contains( member->validate_context, newvalue );
if( res < 0 )
return 0;
if( res == 1 )
return newref( newvalue );
return py_value_fail( "invalid enum value" );
}
void add_if_not_present(PyObject *list, const char* path){
if(path){
PyObject *pymod_path = PyString_FromString(path);
if (!PySequence_Contains(list, pymod_path)){
PyList_Append(list, pymod_path);
}else{
Py_DECREF(pymod_path);
}
}
}
static int
structseq_contains(PyStructSequence *obj, PyObject *o)
{
PyObject *tup;
int result;
tup = make_tuple(obj);
result = PySequence_Contains(tup, o);
Py_DECREF(tup);
return result;
}
PyObject *ObjectRow_PyObject__has_key(ObjectRow_PyObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *key, *keys;
int has_key;
if (!PyArg_ParseTuple(args, "O", &key))
return NULL;
keys = ObjectRow_PyObject__keys(self, NULL, NULL);
has_key = PySequence_Contains(keys, key);
Py_DECREF(keys);
return PyBool_FromLong(has_key);
}
static int
append_new(PyObject *result, PyObject *v)
{
int contains;
if (v == OBJECT(&BaseType) || v == OBJECT(&PyBaseObject_Type))
return 0; /* Don't add these until end */
contains = PySequence_Contains(result, v);
if (contains != 0)
return contains;
return PyList_Append(result, v);
}
PyObject *ObjectRow_PyObject__keys(ObjectRow_PyObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *key, *value, *parent_type, *parent_id;
Py_ssize_t pos = 0;
if (!self->query_info && !self->keys)
// No query_info means we work just from pickle dict.
self->keys = PyMapping_Keys(self->pickle);
if (self->keys) {
Py_INCREF(self->keys);
return self->keys;
}
self->keys = PyList_New(0);
key = PyString_FromString("type");
PyList_Append(self->keys, key);
Py_DECREF(key);
while (PyDict_Next(self->query_info->idxmap, &pos, &key, &value)) {
ObjectAttribute *attr = (ObjectAttribute *)PyCObject_AsVoidPtr(value);
if (attr->index >= 0 || (attr->pickled && self->query_info->pickle_idx >= 0)) {
if (PyStr_Compare(key, "pickle") != 0)
PyList_Append(self->keys, key);
}
}
parent_type = PyString_FromString("parent_type");
parent_id = PyString_FromString("parent_id");
if (PySequence_Contains(self->keys, parent_type) && PySequence_Contains(self->keys, parent_id)) {
key = PyString_FromString("parent");
PyList_Append(self->keys, key);
Py_DECREF(key);
}
Py_DECREF(parent_type);
Py_DECREF(parent_id);
Py_INCREF(self->keys);
return self->keys;
}
void pybase::AddToPath(const char *dir)
{
if(dir && *dir) {
PyObject *pobj = PySys_GetObject(const_cast<char *>("path"));
if(pobj && PyList_Check(pobj)) {
PyObject *ps = PyString_FromString(dir);
if(!PySequence_Contains(pobj,ps))
PyList_Append(pobj,ps); // makes new reference
Py_DECREF(ps);
}
PySys_SetObject(const_cast<char *>("path"),pobj); // steals reference to pobj
}
}
/*
* Remove the function module from sys.modules
*
* >>> del sys.modules[func.oidstr]
*
* -1 on error.
*/
int
PyPgFunction_RemoveModule(PyObj func)
{
int rv;
PyObj modules;
modules = PyImport_GetModuleDict();
rv = PySequence_Contains(modules, PyPgFunction_GetPyUnicodeOid(func));
if (rv == 1)
rv = PyObject_DelItem(modules, PyPgFunction_GetPyUnicodeOid(func));
return(rv);
}
/*
Register a python function to execute when idle
*/
PyObject *py_defer(PyObject *self, PyObject *args)
{
PyObject *pyfct, *pycombined, *pyfctargs;
int startidle=0;
int toadd=1;
int listsize=0;
if (!PyArg_ParseTuple(args, "OOO", &pyfct, &pyfctargs, &pycombined))
return NULL;
//if queue is empty, trigger a start of idle
if (!pydeferqueue)
{
pydeferqueue=PyList_New(0);
}
listsize=PyList_Size(pydeferqueue);
if (listsize==0)
{
//it has been stopped by the idle_cb
startidle=1;
}
//add fct cb into the defer queue
PyObject *pyelem=PyList_New(0);
PyList_Append(pyelem, pyfct);
PyList_Append(pyelem, pyfctargs);
if (pycombined==Py_True)
{
//check if the fucntion is already in the queue
if (PySequence_Contains(pydeferqueue, pyelem))
{
toadd=0;
}
}
if (toadd==1)
{
PyList_Append(pydeferqueue, pyelem);
//start the idle
if (startidle==1)
{
//we create a new idle watcher and we start it
if (debug) printf("trigger idle_start \n");
ev_idle_start(loop, idle_watcher);
}
}
Py_DECREF(pyelem);
return Py_None;
}
/*
* Get an offset from a number or a string.
*
* If a string, translate it using the name map.
* If a number, return it as a Py_ssize_t
*/
Py_ssize_t
Offset_FromPyPgTupleDescAndPyObject(PyObj tdo, PyObj ob)
{
if (PyUnicode_Check(ob))
{
int contains;
PyObj namemap = PyPgTupleDesc_GetNameMap(tdo); /* borrowed */
contains = PySequence_Contains(namemap, ob);
if (contains == 1)
{
ob = PyDict_GetItem(namemap, ob); /* borrowed */
return(PyNumber_AsSsize_t(ob, NULL));
}
return(-2);
}
return(-1);
}
static PyObject *
py_ipt_entry_add_match (PyObject *obj, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"match", NULL};
PyIPTEntryObject *self = (PyIPTEntryObject *) obj;
PyObject *match = NULL;
if (!PyArg_ParseTupleAndKeywords (args, kwds, "O!", kwlist,
&PyIPTMatchType, &match))
return NULL;
if (PySequence_Contains (self->matches, match)) {
PyErr_SetString (PyIPTException, "match already added");
return NULL;
}
PyList_Append (self->matches, match);
Py_INCREF (Py_None);
return Py_None;
}
static void extendPath(PyObject *list,
const char *base,
const char *archdir)
{
PyObject *mod, *ret;
mod = PyImport_ImportModule("os.path");
if(!mod)
return;
ret = PyObject_CallMethod(mod, "join", "sss", base, PYDIR, archdir);
if(ret && !PySequence_Contains(list, ret)) {
PyList_Insert(list, 0, ret);
}
Py_XDECREF(ret);
Py_DECREF(mod);
if(PyErr_Occurred()) {
PyErr_Print();
PyErr_Clear();
}
}
extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *cam_frame, int always_use_expand_framing)
{
/* context values */
struct wmWindow *win= CTX_wm_window(C);
struct Scene *startscene= CTX_data_scene(C);
struct Main* maggie1= CTX_data_main(C);
RAS_Rect area_rect;
area_rect.SetLeft(cam_frame->xmin);
area_rect.SetBottom(cam_frame->ymin);
area_rect.SetRight(cam_frame->xmax);
area_rect.SetTop(cam_frame->ymax);
int exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
Main* blenderdata = maggie1;
char* startscenename = startscene->id.name+2;
char pathname[FILE_MAXDIR+FILE_MAXFILE], oldsce[FILE_MAXDIR+FILE_MAXFILE];
STR_String exitstring = "";
BlendFileData *bfd= NULL;
BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));
BLI_strncpy(oldsce, G.main->name, sizeof(oldsce));
#ifdef WITH_PYTHON
resetGamePythonPath(); // need this so running a second time wont use an old blendfiles path
setGamePythonPath(G.main->name);
// Acquire Python's GIL (global interpreter lock)
// so we can safely run Python code and API calls
PyGILState_STATE gilstate = PyGILState_Ensure();
PyObject *pyGlobalDict = PyDict_New(); /* python utility storage, spans blend file loading */
#endif
bgl::InitExtensions(true);
// VBO code for derived mesh is not compatible with BGE (couldn't find why), so disable
int disableVBO = (U.gameflags & USER_DISABLE_VBO);
U.gameflags |= USER_DISABLE_VBO;
// Globals to be carried on over blender files
GlobalSettings gs;
gs.matmode= startscene->gm.matmode;
gs.glslflag= startscene->gm.flag;
do
{
View3D *v3d= CTX_wm_view3d(C);
RegionView3D *rv3d= CTX_wm_region_view3d(C);
// get some preferences
SYS_SystemHandle syshandle = SYS_GetSystem();
bool properties = (SYS_GetCommandLineInt(syshandle, "show_properties", 0) != 0);
bool usefixed = (SYS_GetCommandLineInt(syshandle, "fixedtime", 0) != 0);
bool profile = (SYS_GetCommandLineInt(syshandle, "show_profile", 0) != 0);
bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);
bool animation_record = (SYS_GetCommandLineInt(syshandle, "animation_record", 0) != 0);
bool displaylists = (SYS_GetCommandLineInt(syshandle, "displaylists", 0) != 0);
#ifdef WITH_PYTHON
bool nodepwarnings = (SYS_GetCommandLineInt(syshandle, "ignore_deprecation_warnings", 0) != 0);
#endif
bool novertexarrays = (SYS_GetCommandLineInt(syshandle, "novertexarrays", 0) != 0);
bool mouse_state = startscene->gm.flag & GAME_SHOW_MOUSE;
bool restrictAnimFPS = startscene->gm.flag & GAME_RESTRICT_ANIM_UPDATES;
if(animation_record) usefixed= true; /* override since you's always want fixed time for sim recording */
// create the canvas, rasterizer and rendertools
RAS_ICanvas* canvas = new KX_BlenderCanvas(win, area_rect, ar);
// default mouse state set on render panel
if (mouse_state)
canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
else
canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
RAS_IRenderTools* rendertools = new KX_BlenderRenderTools();
RAS_IRasterizer* rasterizer = NULL;
if(displaylists) {
if (GLEW_VERSION_1_1 && !novertexarrays)
rasterizer = new RAS_ListRasterizer(canvas, true, true);
else
rasterizer = new RAS_ListRasterizer(canvas);
}
else if (GLEW_VERSION_1_1 && !novertexarrays)
rasterizer = new RAS_VAOpenGLRasterizer(canvas, false);
else
rasterizer = new RAS_OpenGLRasterizer(canvas);
// create the inputdevices
KX_BlenderKeyboardDevice* keyboarddevice = new KX_BlenderKeyboardDevice();
KX_BlenderMouseDevice* mousedevice = new KX_BlenderMouseDevice();
// create a networkdevice
NG_NetworkDeviceInterface* networkdevice = new
NG_LoopBackNetworkDeviceInterface();
//
// create a ketsji/blendersystem (only needed for timing and stuff)
KX_BlenderSystem* kxsystem = new KX_BlenderSystem();
// create the ketsjiengine
KX_KetsjiEngine* ketsjiengine = new KX_KetsjiEngine(kxsystem);
// set the devices
ketsjiengine->SetKeyboardDevice(keyboarddevice);
ketsjiengine->SetMouseDevice(mousedevice);
ketsjiengine->SetNetworkDevice(networkdevice);
ketsjiengine->SetCanvas(canvas);
ketsjiengine->SetRenderTools(rendertools);
ketsjiengine->SetRasterizer(rasterizer);
ketsjiengine->SetUseFixedTime(usefixed);
ketsjiengine->SetTimingDisplay(frameRate, profile, properties);
ketsjiengine->SetRestrictAnimationFPS(restrictAnimFPS);
KX_KetsjiEngine::SetExitKey(ConvertKeyCode(startscene->gm.exitkey));
//set the global settings (carried over if restart/load new files)
ketsjiengine->SetGlobalSettings(&gs);
#ifdef WITH_PYTHON
CValue::SetDeprecationWarnings(nodepwarnings);
#endif
//lock frame and camera enabled - storing global values
int tmp_lay= startscene->lay;
Object *tmp_camera = startscene->camera;
if (v3d->scenelock==0){
startscene->lay= v3d->lay;
startscene->camera= v3d->camera;
}
// some blender stuff
float camzoom;
int draw_letterbox = 0;
if(rv3d->persp==RV3D_CAMOB) {
if(startscene->gm.framing.type == SCE_GAMEFRAMING_BARS) { /* Letterbox */
camzoom = 1.0f;
draw_letterbox = 1;
}
else {
camzoom = 1.0 / BKE_screen_view3d_zoom_to_fac(rv3d->camzoom);
}
}
else {
camzoom = 2.0;
}
ketsjiengine->SetDrawType(v3d->drawtype);
ketsjiengine->SetCameraZoom(camzoom);
// if we got an exitcode 3 (KX_EXIT_REQUEST_START_OTHER_GAME) load a different file
if (exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME || exitrequested == KX_EXIT_REQUEST_RESTART_GAME)
{
exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
if (bfd) BLO_blendfiledata_free(bfd);
char basedpath[FILE_MAX];
// base the actuator filename with respect
// to the original file working directory
if (exitstring != "")
strcpy(basedpath, exitstring.Ptr());
// load relative to the last loaded file, this used to be relative
// to the first file but that makes no sense, relative paths in
// blend files should be relative to that file, not some other file
// that happened to be loaded first
BLI_path_abs(basedpath, pathname);
bfd = load_game_data(basedpath);
// if it wasn't loaded, try it forced relative
if (!bfd)
{
// just add "//" in front of it
char temppath[242];
strcpy(temppath, "//");
strcat(temppath, basedpath);
BLI_path_abs(temppath, pathname);
bfd = load_game_data(temppath);
}
// if we got a loaded blendfile, proceed
if (bfd)
{
blenderdata = bfd->main;
startscenename = bfd->curscene->id.name + 2;
if(blenderdata) {
BLI_strncpy(G.main->name, blenderdata->name, sizeof(G.main->name));
BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));
#ifdef WITH_PYTHON
setGamePythonPath(G.main->name);
#endif
}
}
// else forget it, we can't find it
else
{
exitrequested = KX_EXIT_REQUEST_QUIT_GAME;
}
}
Scene *scene= bfd ? bfd->curscene : (Scene *)BLI_findstring(&blenderdata->scene, startscenename, offsetof(ID, name) + 2);
if (scene)
{
int startFrame = scene->r.cfra;
ketsjiengine->SetAnimRecordMode(animation_record, startFrame);
// Quad buffered needs a special window.
if(scene->gm.stereoflag == STEREO_ENABLED){
if (scene->gm.stereomode != RAS_IRasterizer::RAS_STEREO_QUADBUFFERED)
rasterizer->SetStereoMode((RAS_IRasterizer::StereoMode) scene->gm.stereomode);
rasterizer->SetEyeSeparation(scene->gm.eyeseparation);
}
rasterizer->SetBackColor(scene->gm.framing.col[0], scene->gm.framing.col[1], scene->gm.framing.col[2], 0.0f);
}
if (exitrequested != KX_EXIT_REQUEST_QUIT_GAME)
{
if (rv3d->persp != RV3D_CAMOB)
{
ketsjiengine->EnableCameraOverride(startscenename);
ketsjiengine->SetCameraOverrideUseOrtho((rv3d->persp == RV3D_ORTHO));
ketsjiengine->SetCameraOverrideProjectionMatrix(MT_CmMatrix4x4(rv3d->winmat));
ketsjiengine->SetCameraOverrideViewMatrix(MT_CmMatrix4x4(rv3d->viewmat));
if(rv3d->persp == RV3D_ORTHO)
{
ketsjiengine->SetCameraOverrideClipping(-v3d->far, v3d->far);
}
else
{
ketsjiengine->SetCameraOverrideClipping(v3d->near, v3d->far);
}
ketsjiengine->SetCameraOverrideLens(v3d->lens);
}
// create a scene converter, create and convert the startingscene
KX_ISceneConverter* sceneconverter = new KX_BlenderSceneConverter(blenderdata, ketsjiengine);
ketsjiengine->SetSceneConverter(sceneconverter);
sceneconverter->addInitFromFrame=false;
if (always_use_expand_framing)
sceneconverter->SetAlwaysUseExpandFraming(true);
bool usemat = false, useglslmat = false;
if(GLEW_ARB_multitexture && GLEW_VERSION_1_1)
usemat = true;
if(GPU_glsl_support())
useglslmat = true;
else if(gs.matmode == GAME_MAT_GLSL)
usemat = false;
if(usemat && (gs.matmode != GAME_MAT_TEXFACE))
sceneconverter->SetMaterials(true);
if(useglslmat && (gs.matmode == GAME_MAT_GLSL))
sceneconverter->SetGLSLMaterials(true);
KX_Scene* startscene = new KX_Scene(keyboarddevice,
mousedevice,
networkdevice,
startscenename,
scene,
canvas);
#ifdef WITH_PYTHON
// some python things
PyObject *gameLogic, *gameLogic_keys;
setupGamePython(ketsjiengine, startscene, blenderdata, pyGlobalDict, &gameLogic, &gameLogic_keys, 0, NULL);
#endif // WITH_PYTHON
//initialize Dome Settings
if(scene->gm.stereoflag == STEREO_DOME)
ketsjiengine->InitDome(scene->gm.dome.res, scene->gm.dome.mode, scene->gm.dome.angle, scene->gm.dome.resbuf, scene->gm.dome.tilt, scene->gm.dome.warptext);
// initialize 3D Audio Settings
AUD_I3DDevice* dev = AUD_get3DDevice();
if(dev)
{
dev->setSpeedOfSound(scene->audio.speed_of_sound);
dev->setDopplerFactor(scene->audio.doppler_factor);
dev->setDistanceModel(AUD_DistanceModel(scene->audio.distance_model));
}
// from see blender.c:
// FIXME: this version patching should really be part of the file-reading code,
// but we still get too many unrelated data-corruption crashes otherwise...
if (blenderdata->versionfile < 250)
do_versions_ipos_to_animato(blenderdata);
if (sceneconverter)
{
// convert and add scene
sceneconverter->ConvertScene(
startscene,
rendertools,
canvas);
ketsjiengine->AddScene(startscene);
// init the rasterizer
rasterizer->Init();
// start the engine
ketsjiengine->StartEngine(true);
// Set the animation playback rate for ipo's and actions
// the framerate below should patch with FPS macro defined in blendef.h
// Could be in StartEngine set the framerate, we need the scene to do this
ketsjiengine->SetAnimFrameRate(FPS);
// the mainloop
printf("\nBlender Game Engine Started\n");
while (!exitrequested)
{
// first check if we want to exit
exitrequested = ketsjiengine->GetExitCode();
// kick the engine
bool render = ketsjiengine->NextFrame();
if (render)
{
if(draw_letterbox) {
// Clear screen to border color
// We do this here since we set the canvas to be within the frames. This means the engine
// itself is unaware of the extra space, so we clear the whole region for it.
glClearColor(scene->gm.framing.col[0], scene->gm.framing.col[1], scene->gm.framing.col[2], 1.0f);
glViewport(ar->winrct.xmin, ar->winrct.ymin,
ar->winrct.xmax - ar->winrct.xmin, ar->winrct.ymax - ar->winrct.ymin);
glClear(GL_COLOR_BUFFER_BIT);
}
// render the frame
ketsjiengine->Render();
}
wm_window_process_events_nosleep();
// test for the ESC key
//XXX while (qtest())
while(wmEvent *event= (wmEvent *)win->queue.first)
{
short val = 0;
//unsigned short event = 0; //XXX extern_qread(&val);
if (keyboarddevice->ConvertBlenderEvent(event->type,event->val))
exitrequested = KX_EXIT_REQUEST_BLENDER_ESC;
/* Coordinate conversion... where
* should this really be?
*/
if (event->type==MOUSEMOVE) {
/* Note, not nice! XXX 2.5 event hack */
val = event->x - ar->winrct.xmin;
mousedevice->ConvertBlenderEvent(MOUSEX, val);
val = ar->winy - (event->y - ar->winrct.ymin) - 1;
mousedevice->ConvertBlenderEvent(MOUSEY, val);
}
else {
mousedevice->ConvertBlenderEvent(event->type,event->val);
}
BLI_remlink(&win->queue, event);
wm_event_free(event);
}
if(win != CTX_wm_window(C)) {
exitrequested= KX_EXIT_REQUEST_OUTSIDE; /* window closed while bge runs */
}
}
printf("Blender Game Engine Finished\n");
exitstring = ketsjiengine->GetExitString();
gs = *(ketsjiengine->GetGlobalSettings());
// when exiting the mainloop
#ifdef WITH_PYTHON
// Clears the dictionary by hand:
// This prevents, extra references to global variables
// inside the GameLogic dictionary when the python interpreter is finalized.
// which allows the scene to safely delete them :)
// see: (space.c)->start_game
//PyDict_Clear(PyModule_GetDict(gameLogic));
// Keep original items, means python plugins will autocomplete members
PyObject *gameLogic_keys_new = PyDict_Keys(PyModule_GetDict(gameLogic));
const Py_ssize_t numitems= PyList_GET_SIZE(gameLogic_keys_new);
Py_ssize_t listIndex;
for (listIndex=0; listIndex < numitems; listIndex++) {
PyObject* item = PyList_GET_ITEM(gameLogic_keys_new, listIndex);
if (!PySequence_Contains(gameLogic_keys, item)) {
PyDict_DelItem( PyModule_GetDict(gameLogic), item);
}
}
Py_DECREF(gameLogic_keys_new);
gameLogic_keys_new = NULL;
#endif
ketsjiengine->StopEngine();
#ifdef WITH_PYTHON
exitGamePythonScripting();
#endif
networkdevice->Disconnect();
}
if (sceneconverter)
{
delete sceneconverter;
sceneconverter = NULL;
}
#ifdef WITH_PYTHON
Py_DECREF(gameLogic_keys);
gameLogic_keys = NULL;
#endif
}
//lock frame and camera enabled - restoring global values
if (v3d->scenelock==0){
startscene->lay= tmp_lay;
startscene->camera= tmp_camera;
}
if(exitrequested != KX_EXIT_REQUEST_OUTSIDE)
{
// set the cursor back to normal
canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
}
// clean up some stuff
if (ketsjiengine)
{
delete ketsjiengine;
ketsjiengine = NULL;
}
if (kxsystem)
{
delete kxsystem;
kxsystem = NULL;
}
if (networkdevice)
{
delete networkdevice;
networkdevice = NULL;
}
if (keyboarddevice)
{
delete keyboarddevice;
keyboarddevice = NULL;
}
if (mousedevice)
{
delete mousedevice;
mousedevice = NULL;
}
if (rasterizer)
{
delete rasterizer;
rasterizer = NULL;
}
if (rendertools)
{
delete rendertools;
rendertools = NULL;
}
if (canvas)
{
delete canvas;
canvas = NULL;
}
// stop all remaining playing sounds
AUD_getDevice()->stopAll();
} while (exitrequested == KX_EXIT_REQUEST_RESTART_GAME || exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME);
if (!disableVBO)
U.gameflags &= ~USER_DISABLE_VBO;
if (bfd) BLO_blendfiledata_free(bfd);
BLI_strncpy(G.main->name, oldsce, sizeof(G.main->name));
#ifdef WITH_PYTHON
Py_DECREF(pyGlobalDict);
// Release Python's GIL
PyGILState_Release(gilstate);
#endif
}
extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *cam_frame, int always_use_expand_framing)
{
/* context values */
struct wmWindowManager *wm= CTX_wm_manager(C);
struct wmWindow *win= CTX_wm_window(C);
struct Scene *startscene= CTX_data_scene(C);
struct Main* maggie1= CTX_data_main(C);
RAS_Rect area_rect;
area_rect.SetLeft(cam_frame->xmin);
area_rect.SetBottom(cam_frame->ymin);
area_rect.SetRight(cam_frame->xmax);
area_rect.SetTop(cam_frame->ymax);
int exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
Main* blenderdata = maggie1;
char* startscenename = startscene->id.name+2;
char pathname[FILE_MAXDIR+FILE_MAXFILE], oldsce[FILE_MAXDIR+FILE_MAXFILE];
STR_String exitstring = "";
BlendFileData *bfd= NULL;
BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));
BLI_strncpy(oldsce, G.main->name, sizeof(oldsce));
#ifdef WITH_PYTHON
resetGamePythonPath(); // need this so running a second time wont use an old blendfiles path
setGamePythonPath(G.main->name);
// Acquire Python's GIL (global interpreter lock)
// so we can safely run Python code and API calls
PyGILState_STATE gilstate = PyGILState_Ensure();
PyObject *pyGlobalDict = PyDict_New(); /* python utility storage, spans blend file loading */
#endif
bgl::InitExtensions(true);
// VBO code for derived mesh is not compatible with BGE (couldn't find why), so disable
int disableVBO = (U.gameflags & USER_DISABLE_VBO);
U.gameflags |= USER_DISABLE_VBO;
// Globals to be carried on over blender files
GlobalSettings gs;
gs.matmode= startscene->gm.matmode;
gs.glslflag= startscene->gm.flag;
do
{
View3D *v3d= CTX_wm_view3d(C);
RegionView3D *rv3d= CTX_wm_region_view3d(C);
// get some preferences
SYS_SystemHandle syshandle = SYS_GetSystem();
bool properties = (SYS_GetCommandLineInt(syshandle, "show_properties", 0) != 0);
bool usefixed = (SYS_GetCommandLineInt(syshandle, "fixedtime", 0) != 0);
bool profile = (SYS_GetCommandLineInt(syshandle, "show_profile", 0) != 0);
bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);
bool animation_record = (SYS_GetCommandLineInt(syshandle, "animation_record", 0) != 0);
bool displaylists = (SYS_GetCommandLineInt(syshandle, "displaylists", 0) != 0) && GPU_display_list_support();
#ifdef WITH_PYTHON
bool nodepwarnings = (SYS_GetCommandLineInt(syshandle, "ignore_deprecation_warnings", 0) != 0);
#endif
// bool novertexarrays = (SYS_GetCommandLineInt(syshandle, "novertexarrays", 0) != 0);
bool mouse_state = (startscene->gm.flag & GAME_SHOW_MOUSE) != 0;
bool restrictAnimFPS = (startscene->gm.flag & GAME_RESTRICT_ANIM_UPDATES) != 0;
short drawtype = v3d->drawtype;
/* we do not support material mode in game engine, force change to texture mode */
if (drawtype == OB_MATERIAL) drawtype = OB_TEXTURE;
if (animation_record) usefixed= false; /* override since you don't want to run full-speed for sim recording */
// create the canvas and rasterizer
RAS_ICanvas* canvas = new KX_BlenderCanvas(wm, win, area_rect, ar);
// default mouse state set on render panel
if (mouse_state)
canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
else
canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);
// Setup vsync
int previous_vsync = 0;
canvas->GetSwapInterval(previous_vsync);
if (startscene->gm.vsync == VSYNC_ADAPTIVE)
canvas->SetSwapInterval(-1);
else
canvas->SetSwapInterval((startscene->gm.vsync == VSYNC_ON) ? 1 : 0);
RAS_IRasterizer* rasterizer = NULL;
//Don't use displaylists with VBOs
//If auto starts using VBOs, make sure to check for that here
if (displaylists && startscene->gm.raster_storage != RAS_STORE_VBO)
rasterizer = new RAS_ListRasterizer(canvas, true, startscene->gm.raster_storage);
else
rasterizer = new RAS_OpenGLRasterizer(canvas, startscene->gm.raster_storage);
RAS_IRasterizer::MipmapOption mipmapval = rasterizer->GetMipmapping();
// create the inputdevices
KX_BlenderKeyboardDevice* keyboarddevice = new KX_BlenderKeyboardDevice();
KX_BlenderMouseDevice* mousedevice = new KX_BlenderMouseDevice();
// create a networkdevice
NG_NetworkDeviceInterface* networkdevice = new
NG_LoopBackNetworkDeviceInterface();
//
// create a ketsji/blendersystem (only needed for timing and stuff)
KX_BlenderSystem* kxsystem = new KX_BlenderSystem();
// create the ketsjiengine
KX_KetsjiEngine* ketsjiengine = new KX_KetsjiEngine(kxsystem);
// set the devices
ketsjiengine->SetKeyboardDevice(keyboarddevice);
ketsjiengine->SetMouseDevice(mousedevice);
ketsjiengine->SetNetworkDevice(networkdevice);
ketsjiengine->SetCanvas(canvas);
ketsjiengine->SetRasterizer(rasterizer);
ketsjiengine->SetUseFixedTime(usefixed);
ketsjiengine->SetTimingDisplay(frameRate, profile, properties);
ketsjiengine->SetRestrictAnimationFPS(restrictAnimFPS);
KX_KetsjiEngine::SetExitKey(ConvertKeyCode(startscene->gm.exitkey));
//set the global settings (carried over if restart/load new files)
ketsjiengine->SetGlobalSettings(&gs);
#ifdef WITH_PYTHON
CValue::SetDeprecationWarnings(nodepwarnings);
#endif
//lock frame and camera enabled - storing global values
int tmp_lay= startscene->lay;
Object *tmp_camera = startscene->camera;
if (v3d->scenelock==0) {
startscene->lay= v3d->lay;
startscene->camera= v3d->camera;
}
// some blender stuff
float camzoom;
int draw_letterbox = 0;
if (rv3d->persp==RV3D_CAMOB) {
if (startscene->gm.framing.type == SCE_GAMEFRAMING_BARS) { /* Letterbox */
camzoom = 1.0f;
draw_letterbox = 1;
}
else {
camzoom = 1.0f / BKE_screen_view3d_zoom_to_fac(rv3d->camzoom);
}
}
else {
camzoom = 2.0;
}
rasterizer->SetDrawingMode(drawtype);
ketsjiengine->SetCameraZoom(camzoom);
// if we got an exitcode 3 (KX_EXIT_REQUEST_START_OTHER_GAME) load a different file
if (exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME || exitrequested == KX_EXIT_REQUEST_RESTART_GAME)
{
exitrequested = KX_EXIT_REQUEST_NO_REQUEST;
if (bfd) BLO_blendfiledata_free(bfd);
char basedpath[FILE_MAX];
// base the actuator filename with respect
// to the original file working directory
if (exitstring != "")
BLI_strncpy(basedpath, exitstring.ReadPtr(), sizeof(basedpath));
// load relative to the last loaded file, this used to be relative
// to the first file but that makes no sense, relative paths in
// blend files should be relative to that file, not some other file
// that happened to be loaded first
BLI_path_abs(basedpath, pathname);
bfd = load_game_data(basedpath);
// if it wasn't loaded, try it forced relative
if (!bfd)
{
// just add "//" in front of it
char temppath[FILE_MAX] = "//";
BLI_strncpy(temppath + 2, basedpath, FILE_MAX - 2);
BLI_path_abs(temppath, pathname);
bfd = load_game_data(temppath);
}
// if we got a loaded blendfile, proceed
if (bfd)
{
blenderdata = bfd->main;
startscenename = bfd->curscene->id.name + 2;
if (blenderdata) {
BLI_strncpy(G.main->name, blenderdata->name, sizeof(G.main->name));
BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));
#ifdef WITH_PYTHON
setGamePythonPath(G.main->name);
#endif
}
}
// else forget it, we can't find it
else
{
exitrequested = KX_EXIT_REQUEST_QUIT_GAME;
}
}
Scene *scene= bfd ? bfd->curscene : (Scene *)BLI_findstring(&blenderdata->scene, startscenename, offsetof(ID, name) + 2);
if (scene)
{
int startFrame = scene->r.cfra;
ketsjiengine->SetAnimRecordMode(animation_record, startFrame);
// Quad buffered needs a special window.
if (scene->gm.stereoflag == STEREO_ENABLED) {
if (scene->gm.stereomode != RAS_IRasterizer::RAS_STEREO_QUADBUFFERED)
rasterizer->SetStereoMode((RAS_IRasterizer::StereoMode) scene->gm.stereomode);
rasterizer->SetEyeSeparation(scene->gm.eyeseparation);
}
rasterizer->SetBackColor(scene->gm.framing.col);
}
if (exitrequested != KX_EXIT_REQUEST_QUIT_GAME)
{
if (rv3d->persp != RV3D_CAMOB)
{
ketsjiengine->EnableCameraOverride(startscenename);
ketsjiengine->SetCameraOverrideUseOrtho((rv3d->persp == RV3D_ORTHO));
ketsjiengine->SetCameraOverrideProjectionMatrix(MT_CmMatrix4x4(rv3d->winmat));
ketsjiengine->SetCameraOverrideViewMatrix(MT_CmMatrix4x4(rv3d->viewmat));
ketsjiengine->SetCameraOverrideClipping(v3d->near, v3d->far);
ketsjiengine->SetCameraOverrideLens(v3d->lens);
}
// create a scene converter, create and convert the startingscene
KX_ISceneConverter* sceneconverter = new KX_BlenderSceneConverter(blenderdata, ketsjiengine);
ketsjiengine->SetSceneConverter(sceneconverter);
if (always_use_expand_framing)
sceneconverter->SetAlwaysUseExpandFraming(true);
bool usemat = false, useglslmat = false;
if (GLEW_ARB_multitexture && GLEW_VERSION_1_1)
usemat = true;
if (GPU_glsl_support())
useglslmat = true;
else if (gs.matmode == GAME_MAT_GLSL)
usemat = false;
if (usemat)
sceneconverter->SetMaterials(true);
if (useglslmat && (gs.matmode == GAME_MAT_GLSL))
sceneconverter->SetGLSLMaterials(true);
if (scene->gm.flag & GAME_NO_MATERIAL_CACHING)
sceneconverter->SetCacheMaterials(false);
KX_Scene* startscene = new KX_Scene(keyboarddevice,
mousedevice,
networkdevice,
startscenename,
scene,
canvas);
#ifdef WITH_PYTHON
// some python things
PyObject *gameLogic, *gameLogic_keys;
setupGamePython(ketsjiengine, startscene, blenderdata, pyGlobalDict, &gameLogic, &gameLogic_keys, 0, NULL);
#endif // WITH_PYTHON
//initialize Dome Settings
if (scene->gm.stereoflag == STEREO_DOME)
ketsjiengine->InitDome(scene->gm.dome.res, scene->gm.dome.mode, scene->gm.dome.angle, scene->gm.dome.resbuf, scene->gm.dome.tilt, scene->gm.dome.warptext);
// initialize 3D Audio Settings
AUD_I3DDevice* dev = AUD_get3DDevice();
if (dev)
{
dev->setSpeedOfSound(scene->audio.speed_of_sound);
dev->setDopplerFactor(scene->audio.doppler_factor);
dev->setDistanceModel(AUD_DistanceModel(scene->audio.distance_model));
}
// from see blender.c:
// FIXME: this version patching should really be part of the file-reading code,
// but we still get too many unrelated data-corruption crashes otherwise...
if (blenderdata->versionfile < 250)
do_versions_ipos_to_animato(blenderdata);
if (sceneconverter)
{
// convert and add scene
sceneconverter->ConvertScene(
startscene,
rasterizer,
canvas);
ketsjiengine->AddScene(startscene);
// init the rasterizer
rasterizer->Init();
// start the engine
ketsjiengine->StartEngine(true);
// Set the animation playback rate for ipo's and actions
// the framerate below should patch with FPS macro defined in blendef.h
// Could be in StartEngine set the framerate, we need the scene to do this
ketsjiengine->SetAnimFrameRate(FPS);
#ifdef WITH_PYTHON
char *python_main = NULL;
pynextframestate.state = NULL;
pynextframestate.func = NULL;
python_main = KX_GetPythonMain(scene);
// the mainloop
printf("\nBlender Game Engine Started\n");
if (python_main) {
char *python_code = KX_GetPythonCode(blenderdata, python_main);
if (python_code) {
ketsjinextframestate.ketsjiengine = ketsjiengine;
ketsjinextframestate.C = C;
ketsjinextframestate.win = win;
ketsjinextframestate.scene = scene;
ketsjinextframestate.ar = ar;
ketsjinextframestate.keyboarddevice = keyboarddevice;
ketsjinextframestate.mousedevice = mousedevice;
ketsjinextframestate.draw_letterbox = draw_letterbox;
pynextframestate.state = &ketsjinextframestate;
pynextframestate.func = &BL_KetsjiPyNextFrame;
printf("Yielding control to Python script '%s'...\n", python_main);
PyRun_SimpleString(python_code);
printf("Exit Python script '%s'\n", python_main);
MEM_freeN(python_code);
}
}
else
#endif /* WITH_PYTHON */
{
while (!exitrequested)
{
exitrequested = BL_KetsjiNextFrame(ketsjiengine, C, win, scene, ar, keyboarddevice, mousedevice, draw_letterbox);
}
}
printf("Blender Game Engine Finished\n");
exitstring = ketsjiengine->GetExitString();
#ifdef WITH_PYTHON
if (python_main) MEM_freeN(python_main);
#endif /* WITH_PYTHON */
gs = *(ketsjiengine->GetGlobalSettings());
// when exiting the mainloop
#ifdef WITH_PYTHON
// Clears the dictionary by hand:
// This prevents, extra references to global variables
// inside the GameLogic dictionary when the python interpreter is finalized.
// which allows the scene to safely delete them :)
// see: (space.c)->start_game
//PyDict_Clear(PyModule_GetDict(gameLogic));
// Keep original items, means python plugins will autocomplete members
PyObject *gameLogic_keys_new = PyDict_Keys(PyModule_GetDict(gameLogic));
const Py_ssize_t numitems= PyList_GET_SIZE(gameLogic_keys_new);
Py_ssize_t listIndex;
for (listIndex=0; listIndex < numitems; listIndex++) {
PyObject *item = PyList_GET_ITEM(gameLogic_keys_new, listIndex);
if (!PySequence_Contains(gameLogic_keys, item)) {
PyDict_DelItem( PyModule_GetDict(gameLogic), item);
}
}
Py_DECREF(gameLogic_keys_new);
gameLogic_keys_new = NULL;
#endif
ketsjiengine->StopEngine();
#ifdef WITH_PYTHON
exitGamePythonScripting();
#endif
networkdevice->Disconnect();
}
if (sceneconverter)
{
delete sceneconverter;
sceneconverter = NULL;
}
#ifdef WITH_PYTHON
Py_DECREF(gameLogic_keys);
gameLogic_keys = NULL;
#endif
}
//lock frame and camera enabled - restoring global values
if (v3d->scenelock==0) {
startscene->lay= tmp_lay;
startscene->camera= tmp_camera;
}
if (exitrequested != KX_EXIT_REQUEST_OUTSIDE)
{
// set the cursor back to normal
canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);
// set mipmap setting back to its original value
rasterizer->SetMipmapping(mipmapval);
}
// clean up some stuff
if (ketsjiengine)
{
delete ketsjiengine;
ketsjiengine = NULL;
}
if (kxsystem)
{
delete kxsystem;
kxsystem = NULL;
}
if (networkdevice)
{
delete networkdevice;
networkdevice = NULL;
}
if (keyboarddevice)
{
delete keyboarddevice;
keyboarddevice = NULL;
}
if (mousedevice)
{
delete mousedevice;
mousedevice = NULL;
}
if (rasterizer)
{
delete rasterizer;
rasterizer = NULL;
}
if (canvas)
{
canvas->SetSwapInterval(previous_vsync); // Set the swap interval back
delete canvas;
canvas = NULL;
}
// stop all remaining playing sounds
AUD_getDevice()->stopAll();
} while (exitrequested == KX_EXIT_REQUEST_RESTART_GAME || exitrequested == KX_EXIT_REQUEST_START_OTHER_GAME);
if (!disableVBO)
U.gameflags &= ~USER_DISABLE_VBO;
if (bfd) BLO_blendfiledata_free(bfd);
BLI_strncpy(G.main->name, oldsce, sizeof(G.main->name));
#ifdef WITH_PYTHON
Py_DECREF(pyGlobalDict);
// Release Python's GIL
PyGILState_Release(gilstate);
#endif
}
/* inspect a message, update the seen set
* return 1 if we should pass this message on to the caller
* return 0 if we should drop it
* return -1 on internal error (exception has been raised)
*/
static int filter_message(modesreader *self, PyObject *o)
{
modesmessage *message = (modesmessage *)o;
if (message->df == DF_MODEAC) {
return self->want_modeac_messages; /* no address in mode a/c, no further filtering possible */
}
if (!message->valid) {
return self->want_invalid_messages; /* don't process further, contents are dubious */
}
if (self->seen != NULL && self->seen != Py_None) {
if (message->df == 11 || message->df == 17 || message->df == 18) {
/* note that we saw this aircraft, even if the message is filtered.
* only do this for CRC-checked messages as we get a lot of noise
* otherwise.
*/
if (PySet_Add(self->seen, message->address) < 0) {
return -1;
}
}
}
if (message->timestamp == 0 && !self->want_zero_timestamps) {
return 0;
}
if (message->timestamp == MAGIC_MLAT_TIMESTAMP && !self->want_mlat_messages) {
return 0;
}
if ((self->default_filter == NULL || self->default_filter == Py_None) &&
(self->specific_filter == NULL || self->specific_filter == Py_None)) {
/* no filters installed, match everything */
return 1;
}
/* check per-type filters */
if (self->default_filter != NULL && self->default_filter != Py_None) {
int rv;
PyObject *entry = PySequence_GetItem(self->default_filter, message->df);
if (entry == NULL)
return -1;
rv = PyObject_IsTrue(entry);
Py_DECREF(entry);
if (rv != 0)
return rv;
}
if (self->specific_filter != NULL && self->specific_filter != Py_None) {
int rv;
PyObject *entry = PySequence_GetItem(self->specific_filter, message->df);
if (entry == NULL)
return -1;
if (entry == Py_None) {
rv = 0;
} else {
rv = PySequence_Contains(entry, message->address);
}
Py_DECREF(entry);
if (rv != 0)
return rv;
}
return 0;
}
bool List::contains(const Object &obj)
{
bool toReturn = PySequence_Contains(mPtr, obj.borrowReference()) == 1;
PW_PyExcept_Check("List::contains");;
return toReturn;
}
static CeditPlugin *
cedit_plugin_loader_iface_load (CeditPluginLoader *loader,
CeditPluginInfo *info,
const gchar *path)
{
CeditPluginLoaderPython *pyloader = CEDIT_PLUGIN_LOADER_PYTHON (loader);
PyObject *main_module, *main_locals, *pytype;
PyObject *pymodule, *fromlist;
gchar *module_name;
CeditPlugin *result;
if (pyloader->priv->init_failed)
{
g_warning ("Cannot load python plugin Python '%s' since cedit was"
"not able to initialize the Python interpreter.",
cedit_plugin_info_get_name (info));
return NULL;
}
/* see if py definition for the plugin is already loaded */
result = new_plugin_from_info (pyloader, info);
if (result != NULL)
return result;
main_module = PyImport_AddModule ("cedit.plugins");
if (main_module == NULL)
{
g_warning ("Could not get cedit.plugins.");
return NULL;
}
/* If we have a special path, we register it */
if (path != NULL)
{
PyObject *sys_path = PySys_GetObject ("path");
PyObject *pypath = PyString_FromString (path);
if (PySequence_Contains (sys_path, pypath) == 0)
PyList_Insert (sys_path, 0, pypath);
Py_DECREF (pypath);
}
main_locals = PyModule_GetDict (main_module);
/* we need a fromlist to be able to import modules with a '.' in the
name. */
fromlist = PyTuple_New(0);
module_name = g_strdup (cedit_plugin_info_get_module_name (info));
pymodule = PyImport_ImportModuleEx (module_name,
main_locals,
main_locals,
fromlist);
Py_DECREF(fromlist);
if (!pymodule)
{
g_free (module_name);
PyErr_Print ();
return NULL;
}
PyDict_SetItemString (main_locals, module_name, pymodule);
g_free (module_name);
pytype = find_python_plugin_type (info, pymodule);
if (pytype)
return add_python_info (pyloader, info, pymodule, path, pytype);
return NULL;
}
PyObject *init_chunk_render(void) {
PyObject *tmp = NULL;
unsigned int i;
/* this function only needs to be called once, anything more should be
* ignored */
if (textures) {
Py_RETURN_NONE;
}
textures = PyImport_ImportModule("overviewer_core.textures");
/* ensure none of these pointers are NULL */
if ((!textures)) {
return NULL;
}
tmp = PyObject_GetAttrString(textures, "max_blockid");
if (!tmp)
return NULL;
max_blockid = PyInt_AsLong(tmp);
Py_DECREF(tmp);
tmp = PyObject_GetAttrString(textures, "max_data");
if (!tmp)
return NULL;
max_data = PyInt_AsLong(tmp);
Py_DECREF(tmp);
/* assemble the property table */
known_blocks = PyObject_GetAttrString(textures, "known_blocks");
if (!known_blocks)
return NULL;
transparent_blocks = PyObject_GetAttrString(textures, "transparent_blocks");
if (!transparent_blocks)
return NULL;
solid_blocks = PyObject_GetAttrString(textures, "solid_blocks");
if (!solid_blocks)
return NULL;
fluid_blocks = PyObject_GetAttrString(textures, "fluid_blocks");
if (!fluid_blocks)
return NULL;
nospawn_blocks = PyObject_GetAttrString(textures, "nospawn_blocks");
if (!nospawn_blocks)
return NULL;
nodata_blocks = PyObject_GetAttrString(textures, "nodata_blocks");
if (!nodata_blocks)
return NULL;
block_properties = calloc(max_blockid, sizeof(unsigned char));
for (i = 0; i < max_blockid; i++) {
PyObject *block = PyInt_FromLong(i);
if (PySequence_Contains(known_blocks, block))
block_properties[i] |= 1 << KNOWN;
if (PySequence_Contains(transparent_blocks, block))
block_properties[i] |= 1 << TRANSPARENT;
if (PySequence_Contains(solid_blocks, block))
block_properties[i] |= 1 << SOLID;
if (PySequence_Contains(fluid_blocks, block))
block_properties[i] |= 1 << FLUID;
if (PySequence_Contains(nospawn_blocks, block))
block_properties[i] |= 1 << NOSPAWN;
if (PySequence_Contains(nodata_blocks, block))
block_properties[i] |= 1 << NODATA;
Py_DECREF(block);
}
Py_RETURN_NONE;
}
