/*
* Gets the currently available types from the active clipboard.
*/
static PyObject*
_scrap_get_types (PyObject *self, PyObject *args)
{
int i = 0;
char **types;
PyObject *list;
PyObject *tmp;
PYGAME_SCRAP_INIT_CHECK ();
if (!pygame_scrap_lost ())
{
switch (_currentmode)
{
case SCRAP_SELECTION:
return PyDict_Keys (_selectiondata);
case SCRAP_CLIPBOARD:
default:
return PyDict_Keys (_clipdata);
}
}
list = PyList_New (0);
types = pygame_scrap_get_types ();
if (!types)
return list;
while (types[i] != NULL)
{
tmp = PyString_FromString (types[i]);
PyList_Append (list, tmp);
Py_DECREF (tmp);
i++;
}
return list;
}
configParserStruct::pythonParser::containerForVariables configParserStruct::pythonParser::listOfVariables( void *Object )
{
containerForVariables Result;
if ( Object == NULL )
return Result;
PyObject *Dict = castToPyObject(Object);
if ( ! PyDict_Check( Dict ) )
return Result;
PyObject *KeysList = PyDict_Keys( Dict );
Py_ssize_t KeysListSize = PyList_Size( KeysList );
for ( ptrdiff_t Index = 0; Index < static_cast<ptrdiff_t>(KeysListSize); Index++ )
{
PyObject *Key = PyList_GetItem( KeysList, Index );
PyObject *KeyRepr = PyObject_Repr( Key );
std::string KeyString = dequoteString( PyString_AsString( KeyRepr ), "'" );
PyObject *Item = PyDict_GetItem( Dict, Key );
if ( PyDict_Check(Item) )
{
containerForVariables ListOfItemsinSubDict = listOfVariables( Item );
for ( containerForVariables::const_iterator i = ListOfItemsinSubDict.begin(); i != ListOfItemsinSubDict.end(); ++i )
Result.insert( KeyString + structSeparator() + *i );
} else {
Result.insert( KeyString );
}
}
return Result;
}
//----------------------------------------------------------------------------
// 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;
}
/**
* parse the return PyObject and store the result into task_ret_pool
*/
static void
dump_ret_msg(PyObject *pRet)
{
if ( pRet == NULL) {
throw std::runtime_error("pycall failed");
}
char *ret_err_msg;
int rsize = PyDict_Size(pRet);
int taskid;
download_ret_t dr_ret; // down return mesg structure
PyObject *pret_keys_list = PyDict_Keys(pRet);
pthread_mutex_lock(&retmtx);
for (int i = 0; i < rsize; i++) {
PyObject *pkey_item = PyList_GetItem(pret_keys_list, i);
PyObject *pvalue_tuple = PyDict_GetItem(pRet, pkey_item);
PyObject *pret_flag = PyTuple_GetItem(pvalue_tuple, 0);
PyObject *perr_msg = PyTuple_GetItem(pvalue_tuple, 1);
taskid = PyInt_AsLong(pkey_item);
dr_ret.ret_flag = PyInt_AsLong(pret_flag);
ret_err_msg = PyString_AsString(perr_msg);
strncpy(dr_ret.err_msg, ret_err_msg, NAME_LEN);
task_ret_pool[taskid] = dr_ret;
}
pthread_mutex_unlock(&retmtx);
}
std::map<std::string, std::string> PythonTools::dtom( PyObject* d )
{
std::map<std::string, std::string> results;
if ( d != NULL && PyDict_Check( d ) )
{
PyObject* keyList = PyDict_Keys( d );
PyObject* curKey;
PyObject* curVal;
for ( int i = 0; i < PyList_Size( keyList ); i++ )
{
curKey = PyList_GetItem( keyList, i );
curVal = PyDict_GetItem( d, curKey );
char* valstr = PyString_AsString( curVal );
if ( valstr == NULL )
gravUtil::logWarning( "PythonTools::dtom(): "
"value not a string\n" );
char* keystr = PyString_AsString( curKey );
if ( keystr == NULL )
gravUtil::logWarning( "PythonTools::dtom(): "
"key not a string\n" );
if ( keystr != NULL && valstr != NULL )
results[ keystr ] = valstr;
}
}
return results;
}
/**
* Extends __dir__ with the extra attributes accessible through
* resulttuple_getattro()
*/
static PyObject *
resulttuple_dir(PyObject *self)
{
PyObject *mapping_attr;
PyObject *items = NULL;
PyObject *mapping = NULL;
PyObject *mapping_values = NULL;
PyObject *result = NULL;
mapping_attr = PYGLIB_PyUnicode_FromString (tuple_indices_key);
mapping = PyTuple_Type.tp_getattro (self, mapping_attr);
Py_DECREF (mapping_attr);
if (mapping == NULL)
goto error;
items = PyObject_Dir ((PyObject*)self->ob_type);
if (items == NULL)
goto error;
mapping_values = PyDict_Keys (mapping);
if (mapping_values == NULL)
goto error;
result = PySequence_InPlaceConcat (items, mapping_values);
error:
Py_XDECREF (items);
Py_XDECREF (mapping);
Py_XDECREF (mapping_values);
return result;
}
int
dictkeys(const int handle)
{
PyObject *v;
PyObject *obj = getObjectFromHandle(handle);
v = PyDict_Keys(obj);
return newHandle(v);
}
static char *build_headers_string(PyObject *dict)
{
Py_ssize_t i, dict_len, buf_pos, buf_size, req_space, free_space;
PyObject *keys, *key_ob;
char *key, *value, *header_s;
const char *header_format = "%s: %s\r\n";
buf_size = 512;
buf_pos = 0;
if ((header_s = (char *) malloc(buf_size * sizeof(char))) == NULL) {
PyErr_NoMemory();
return NULL;
}
if (dict == NULL || dict == Py_None) {
sprintf(header_s, "%s", "");
return header_s;
}
if (!PyDict_Check(dict)) {
PyErr_SetString(PyExc_TypeError, "Headers must be a dict");
return NULL;
}
memset(header_s, '\0', (size_t) buf_size);
if ((keys = PyDict_Keys(dict)) == NULL) {
PyErr_SetString(PyExc_TypeError, "Key must not be null.");
free(header_s);
return NULL;
}
dict_len = PyList_Size(keys);
for (i = 0; i < dict_len; ++i) {
key_ob = PyList_GetItem(keys, i);
if ((key = PyString_AsString(key_ob)) == NULL) {
free(header_s);
return NULL;
}
if ((value = PyString_AsString(PyDict_GetItem(dict, key_ob))) == NULL) {
free(header_s);
return NULL;
}
//Make sure header_s has enough space
req_space = strlen(key) + strlen(value) + strlen(header_format);
free_space = buf_size - buf_pos;
while ((req_space + 1) > free_space) { // +1 to be sure final '\0' fits
if ((header_s = (char *) realloc(header_s, buf_size * 2)) == NULL) {
PyErr_NoMemory();
free(header_s);
return NULL;
}
buf_size *= 2;
free_space = buf_size - buf_pos;
}
sprintf(header_s + buf_pos, header_format, key, value);
buf_pos += req_space;
}
header_s[buf_pos + 1] = '\0';
return header_s;
}
static void print_dict(PyObject *dict) {
PyObject *keys = PyDict_Keys(dict);
for (Py_ssize_t i = 0; i < PyList_Size(keys); ++i) {
PyObject *key = PyList_GetItem(keys, i);
debug("\t%s", PyUnicode_AsUTF8(key));
Py_DECREF(key);
}
Py_DECREF(keys);
}
static std::map<K,V> py2c(PyObject * ob) {
pyref keys = PyDict_Keys(ob);
pyref values = PyDict_Values(ob);
std::map<K,V> res;
int len = PyDict_Size(ob);
for (int i = 0; i < len; i++)
res.emplace(py_converter<K>::py2c(PyList_GET_ITEM((PyObject*)keys, i)), //borrowed ref
py_converter<V>::py2c(PyList_GET_ITEM((PyObject*)values, i))); //borrowed ref
return res;
}
void printDict(PyObject* obj) {
if (!PyDict_Check(obj))
return;
PyObject *k, *keys;
keys = PyDict_Keys(obj);
for (int i = 0; i < PyList_GET_SIZE(keys); i++) {
k = PyList_GET_ITEM(keys, i);
char* c_name = PyString_AsString(k);
printf("%s\n", c_name);
}
}
void printDict(PyObject* obj) {
if (!PyDict_Check(obj))
return;
PyObject *k, *keys;
keys = PyDict_Keys(obj);// get keys of the dictionary,list output
for (int i = 0; i < PyList_GET_SIZE(keys); i++) {
k = PyList_GET_ITEM(keys, i);
char* c_name = PyString_AsString(k);
printf("%s/n", c_name);
}
}
list dict_base::keys() const
{
if (check_exact(this))
{
return list(detail::new_reference(
PyDict_Keys(this->ptr())));
}
else
{
return assume_list(this->attr("keys")());
}
}
static PyObject* py_set_colormap(PyObject *self, PyObject *args,
PyObject *kwargs) {
const char *kwnames[] = {"name", "pairs", NULL};
PyObject *newdict, *keys, *vals;
PyObject *result = NULL;
VMDApp *app;
char *name;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO!:color.set_colormap",
(char**) kwnames, &name, &PyDict_Type,
&newdict))
return NULL;
if (!(app = get_vmdapp()))
return NULL;
keys = PyDict_Keys(newdict);
vals = PyDict_Values(newdict);
for (int i=0; i<PyList_Size(keys); i++) {
char *keyname = as_charptr(PyList_GetItem(keys, i));
char *valname = as_charptr(PyList_GetItem(vals, i));
if (!keyname || !valname || PyErr_Occurred()) {
PyErr_SetString(PyExc_ValueError, "set_colormap dictionary invalid");
goto cleanup;
}
if (!app->color_change_name(name, keyname, valname)) {
PyErr_SetString(PyExc_ValueError,
"Invalid color category or item specified");
goto cleanup;
}
}
result = Py_None;
// Getting the keys and values from the dictionary makes a new reference.
// We tell Python we're done with it so as to not leak memory.
// This needs to happen even if there was a problem setting color, which is
// why we don't return NULL from the error checking statements above.
cleanup:
Py_DECREF(keys);
Py_DECREF(vals);
Py_XINCREF(result);
return result;
}
//=============================================================================
// METHOD: SPELLconfigDict::reset()
//=============================================================================
void SPELLconfigDict::reset( PyObject* dict )
{
m_values.clear();
if (dict)
{
SPELLsafePythonOperations ops ("SPELLconfigDict::reset()");
SPELLpyHandle keys = PyDict_Keys(dict);
unsigned int numKeys = PyList_Size(keys.get());
for( unsigned int idx = 0; idx < numKeys; idx++ )
{
PyObject* key = PyList_GetItem( keys.get(), idx );
PyObject* value = PyDict_GetItem( dict, key );
m_values.insert( std::make_pair( PYSSTR(key), SPELLpyValue(value) ));
}
}
}
/*static PyObject * c2py(std::map<K,V> &m) {
PyObject * d = PyDict_New();
for (auto & x : m) {
pyref k = py_converter<K>::c2py(x.first);
pyref v = py_converter<V>::c2py(x.second);
if (PyDict_SetItem(d,k,v) == -1) { Py_DECREF(d); return NULL;} // error
}
return d;
}*/
static bool is_convertible(PyObject *ob, bool raise_exception) {
if (!PyDict_Check(ob)) goto _false;
{
pyref keys = PyDict_Keys(ob);
pyref values = PyDict_Values(ob);
int len = PyDict_Size(ob);
for (int i = 0; i < len; i++) {
if (!py_converter<K>::is_convertible(PyList_GET_ITEM((PyObject*)keys, i),raise_exception)) goto _false; //borrowed ref
if (!py_converter<V>::is_convertible(PyList_GET_ITEM((PyObject*)values, i),raise_exception)) goto _false; //borrowed ref
}
return true;
}
_false:
if (raise_exception) { PyErr_SetString(PyExc_TypeError, "Cannot convert to std::map");}
return false;
}
// ----------------------------------------------------------------
static PyObject *
FormatsRepr(PyFormatsObject *cFormats)
{
char sBuf[ 1000 ];
int i;
PyObject* cTmp= PyDict_Keys( FormatsType.tp_dict );
sBuf[ 0 ]= '\0';
for( i= 0; i< PyObject_Length( cTmp ); i++ )
{
char *s= PyString_AsString( PyList_GetItem( cTmp, i ));
if( strlen( s )> 2 && ( s[ 0 ]== s[ 1 ] ) && ( s[ 1 ]== '_' ) )
continue;
if( i )
strcat( sBuf, ",");
strcat( sBuf, s);
}
return PyString_FromString( sBuf );
}
/* Convert the set of state numbers into a sorted tuple for use as a
* dictionary key.
*/
static PyObject *make_key(PyObject *state_set)
{
PyObject *states, *key;
states = PyDict_Keys(state_set);
if (states == NULL) {
return NULL;
}
if (PyList_Sort(states) < 0) {
Py_DECREF(states);
return NULL;
}
key = PySequence_Tuple(states);
Py_DECREF(states);
if (key == NULL) {
return NULL;
}
return key;
}
static PyObject *set_colors(PyObject *self, PyObject *args) {
PyObject *newdict;
if (!PyArg_ParseTuple(args, (char *)"O!", &PyDict_Type, &newdict))
return NULL;
VMDApp *app = get_vmdapp();
PyObject *keys = PyDict_Keys(newdict);
PyObject *vals = PyDict_Values(newdict);
int error = 0;
for (int i=0; i<PyList_Size(keys); i++) {
char *keyname = PyString_AsString(PyList_GET_ITEM(keys, i));
if (PyErr_Occurred()) {
error = 1;
break;
}
if (app->color_index(keyname) < 0) {
PyErr_SetString(PyExc_ValueError, (char *)"Unknown color");
error = 1;
break;
}
PyObject *newtuple = PyList_GET_ITEM(vals, i);
if (!PyTuple_Check(newtuple) || PyTuple_Size(newtuple) != 3) {
PyErr_SetString(PyExc_ValueError, (char *)"color definition must be 3-tuple of floats");
error = 1;
break;
}
float rgb[3];
for (int j=0; j<3; j++)
rgb[j] = (float)PyFloat_AsDouble(PyTuple_GET_ITEM(newtuple, j));
if (PyErr_Occurred()) {
error = 1;
break;
}
app->color_changevalue(keyname, rgb[0], rgb[1], rgb[2]);
}
Py_DECREF(keys);
Py_DECREF(vals);
if (error)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
void print_dict(PyObject *d)
{
PyObject *k;
Py_ssize_t size, i =0;
k = PyDict_Keys(d);
size = PyList_Size(k);
printf("Size : %d\n", size);
for (i = 0; i < size; i++) {
PyObject *item = PyList_GET_ITEM(k, i);
#ifndef IS_PY3K
printf("-- %s -- \n", PyString_AsString(item));
#else
printf("-- %s -- \n", PyUnicode_AsUTF8String(item));
#endif
}
}
static PyObject *
module_dir(PyObject *self, PyObject *args)
{
_Py_IDENTIFIER(__dict__);
PyObject *result = NULL;
PyObject *dict = _PyObject_GetAttrId(self, &PyId___dict__);
if (dict != NULL) {
if (PyDict_Check(dict))
result = PyDict_Keys(dict);
else {
const char *name = PyModule_GetName(self);
if (name)
PyErr_Format(PyExc_TypeError,
"%.200s.__dict__ is not a dictionary",
name);
}
}
Py_XDECREF(dict);
return result;
}
//-----------------------------------------------------------------------------
// ExtGetDependentFiles()
// Return a list of files that this file depends on.
//-----------------------------------------------------------------------------
static PyObject *ExtGetDependentFiles(
PyObject *self, // passthrough argument
PyObject *args) // arguments
{
PyObject *results;
char *imageName;
if (!PyArg_ParseTuple(args, "s", &imageName))
return NULL;
g_ImageNames = PyDict_New();
if (!g_ImageNames)
return NULL;
if (!BindImageEx(BIND_NO_BOUND_IMPORTS | BIND_NO_UPDATE | BIND_ALL_IMAGES,
imageName, NULL, NULL, BindStatusRoutine)) {
Py_DECREF(g_ImageNames);
PyErr_SetExcFromWindowsErrWithFilename(g_BindErrorException,
GetLastError(), imageName);
return NULL;
}
results = PyDict_Keys(g_ImageNames);
Py_DECREF(g_ImageNames);
return results;
}
/* Searches amongs lower-cased keystrings to find a match with the key.
Sets the `found` parameter's value to 1 if key found in the list, 0 otherwise. */
PyObject *
searchLowerCaseKeyMatch(LDAPEntry *self, PyObject *key, int* found) {
PyObject *keys = PyDict_Keys((PyObject *)self);
PyObject *iter = PyObject_GetIter(keys);
PyObject *item;
if (iter == NULL) {
Py_DECREF(keys);
return NULL;
}
/* Searching for same lowercase key amongs the other keys. */
for (item = PyIter_Next(iter); item != NULL; item = PyIter_Next(iter)) {
if (lowerCaseMatch(item, key) == 1) {
key = item;
*found = 1;
break;
}
*found = 0;
Py_DECREF(item);
}
Py_DECREF(iter);
Py_DECREF(keys);
return key;
}
static PyObject *set_colormap(PyObject *self, PyObject *args) {
char *name;
PyObject *newdict;
if (!PyArg_ParseTuple(args, (char *)"sO!", &name, &PyDict_Type, &newdict))
return NULL;
VMDApp *app = get_vmdapp();
PyObject *keys = PyDict_Keys(newdict);
PyObject *vals = PyDict_Values(newdict);
int error = 0;
for (int i=0; i<PyList_Size(keys); i++) {
char *keyname = PyString_AsString(PyList_GET_ITEM(keys, i));
if (PyErr_Occurred()) {
error = 1;
break;
}
char *valname = PyString_AsString(PyList_GET_ITEM(vals, i));
if (PyErr_Occurred()) {
error = 1;
break;
}
if (!app->color_changename(name, keyname, valname)) {
PyErr_SetString(PyExc_ValueError,
(char *)"Invalid color category or item specified");
return NULL;
}
}
Py_DECREF(keys);
Py_DECREF(vals);
if (error)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
namespace_repr(PyObject *ns)
{
int i, loop_error = 0;
PyObject *pairs = NULL, *d = NULL, *keys = NULL, *keys_iter = NULL;
PyObject *key;
PyObject *separator, *pairsrepr, *repr = NULL;
const char * name;
name = (Py_TYPE(ns) == &_PyNamespace_Type) ? "namespace"
: ns->ob_type->tp_name;
i = Py_ReprEnter(ns);
if (i != 0) {
return i > 0 ? PyUnicode_FromFormat("%s(...)", name) : NULL;
}
pairs = PyList_New(0);
if (pairs == NULL)
goto error;
d = ((_PyNamespaceObject *)ns)->ns_dict;
assert(d != NULL);
Py_INCREF(d);
keys = PyDict_Keys(d);
if (keys == NULL)
goto error;
if (PyList_Sort(keys) != 0)
goto error;
keys_iter = PyObject_GetIter(keys);
if (keys_iter == NULL)
goto error;
while ((key = PyIter_Next(keys_iter)) != NULL) {
if (PyUnicode_Check(key) && PyUnicode_GET_LENGTH(key) > 0) {
PyObject *value, *item;
value = PyDict_GetItem(d, key);
assert(value != NULL);
item = PyUnicode_FromFormat("%S=%R", key, value);
if (item == NULL) {
loop_error = 1;
}
else {
loop_error = PyList_Append(pairs, item);
Py_DECREF(item);
}
}
Py_DECREF(key);
if (loop_error)
goto error;
}
separator = PyUnicode_FromString(", ");
if (separator == NULL)
goto error;
pairsrepr = PyUnicode_Join(separator, pairs);
Py_DECREF(separator);
if (pairsrepr == NULL)
goto error;
repr = PyUnicode_FromFormat("%s(%S)", name, pairsrepr);
Py_DECREF(pairsrepr);
error:
Py_XDECREF(pairs);
Py_XDECREF(d);
Py_XDECREF(keys);
Py_XDECREF(keys_iter);
Py_ReprLeave(ns);
return repr;
}
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
}
static CYTHON_INLINE PyObject* __Pyx_PyDict_Keys(PyObject* d) {
if (PY_MAJOR_VERSION >= 3)
return __Pyx_PyObject_CallMethod1((PyObject*)&PyDict_Type, PYIDENT("keys"), d);
else
return PyDict_Keys(d);
}
/*
* DIALECT REGISTRY
*/
static PyObject *
csv_list_dialects(PyObject *module, PyObject *args)
{
return PyDict_Keys(dialects);
}
QList<PythonVariable> PythonEngine::variableList()
{
QStringList filter_name;
filter_name << "__builtins__" << "StdoutCatcher" << "python_engine_stdout" << "chdir"
<< "python_engine_get_completion_file" << "python_engine_get_completion_string"
<< "python_engine_get_completion_string_dot" << "PythonLabRopeProject"
<< "pythonlab_rope_project"
<< "python_engine_pyflakes_check";
QStringList filter_type;
filter_type << "builtin_function_or_method";
QList<PythonVariable> list;
PyObject *keys = PyDict_Keys(m_dict);
for (int i = 0; i < PyList_Size(keys); ++i)
{
PyObject *key = PyList_GetItem(keys, i);
PyObject *value = PyDict_GetItem(m_dict, key);
// variable
PythonVariable var;
// variable name
var.name = PyString_AsString(key);
// variable type
var.type = value->ob_type->tp_name;
// variable value
if (var.type == "bool")
{
var.value = PyInt_AsLong(value) ? "True" : "False";
}
else if (var.type == "int")
{
var.value = (int) PyInt_AsLong(value);
}
else if (var.type == "float")
{
var.value = PyFloat_AsDouble(value);
}
else if (var.type == "str")
{
var.value = PyString_AsString(value);
}
else if (var.type == "list")
{
var.value = QString("%1 items").arg(PyList_Size(value));
}
else if (var.type == "tuple")
{
var.value = QString("%1 items").arg(PyTuple_Size(value));
}
else if (var.type == "dict")
{
var.value = QString("%1 items").arg(PyDict_Size(value));
}
else if (var.type == "numpy.ndarray")
{
var.value = ""; //TODO count
}
else if (var.type == "module")
{
var.value = PyString_AsString(PyObject_GetAttrString(value, "__name__"));
}
else if (var.type == "function"
|| var.type == "instance"
|| var.type == "classobj")
{
// qDebug() << value->ob_type->tp_name;
}
// append
if (!filter_name.contains(var.name) && !filter_type.contains(var.type))
{
list.append(var);
}
}
Py_DECREF(keys);
return list;
}
