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
}
int main(int argc, char** argv)
{
int i;
int argc_py_clamped= argc; /* use this so python args can be added after ' - ' */
bool error = false;
SYS_SystemHandle syshandle = SYS_GetSystem();
bool fullScreen = false;
bool fullScreenParFound = false;
bool windowParFound = false;
#ifdef WIN32
bool closeConsole = true;
#endif
RAS_IRasterizer::StereoMode stereomode = RAS_IRasterizer::RAS_STEREO_NOSTEREO;
bool stereoWindow = false;
bool stereoParFound = false;
int stereoFlag = STEREO_NOSTEREO;
int domeFov = -1;
int domeTilt = -200;
int domeMode = 0;
char* domeWarp = NULL;
Text *domeText = NULL;
int windowLeft = 100;
int windowTop = 100;
int windowWidth = 640;
int windowHeight = 480;
GHOST_TUns32 fullScreenWidth = 0;
GHOST_TUns32 fullScreenHeight= 0;
int fullScreenBpp = 32;
int fullScreenFrequency = 60;
GHOST_TEmbedderWindowID parentWindow = 0;
bool isBlenderPlayer = false; //true when lauching from blender or command line. false for bundled player
int validArguments=0;
bool samplesParFound = false;
GHOST_TUns16 aasamples = 0;
#ifdef __linux__
#ifdef __alpha__
signal (SIGFPE, SIG_IGN);
#endif /* __alpha__ */
#endif /* __linux__ */
#ifdef WITH_SDL_DYNLOAD
sdlewInit();
#endif
BKE_appdir_program_path_init(argv[0]);
BKE_tempdir_init(NULL);
// We don't use threads directly in the BGE, but we need to call this so things like
// freeing up GPU_Textures works correctly.
BLI_threadapi_init();
RNA_init();
init_nodesystem();
initglobals();
U.gameflags |= USER_DISABLE_VBO;
// We load our own G.main, so free the one that initglobals() gives us
BKE_main_free(G.main);
G.main = NULL;
MEM_CacheLimiter_set_disabled(true);
IMB_init();
BKE_images_init();
BKE_modifier_init();
DAG_init();
#ifdef WITH_FFMPEG
IMB_ffmpeg_init();
#endif
// Setup builtin font for BLF (mostly copied from creator.c, wm_init_exit.c and interface_style.c)
BLF_init(11, U.dpi);
BLF_lang_init();
BLF_lang_set("");
BLF_load_mem("default", (unsigned char*)datatoc_bfont_ttf, datatoc_bfont_ttf_size);
if (blf_mono_font == -1)
blf_mono_font = BLF_load_mem_unique("monospace", (unsigned char*)datatoc_bmonofont_ttf, datatoc_bmonofont_ttf_size);
// Parse command line options
#if defined(DEBUG)
printf("argv[0] = '%s'\n", argv[0]);
#endif
#ifdef WIN32
if (scr_saver_init(argc, argv))
{
switch (scr_saver_mode)
{
case SCREEN_SAVER_MODE_CONFIGURATION:
MessageBox(scr_saver_hwnd, "This screen saver has no options that you can set", "Screen Saver", MB_OK);
break;
case SCREEN_SAVER_MODE_PASSWORD:
/* This is W95 only, which we currently do not support.
* Fall-back to normal screen saver behavior in that case... */
case SCREEN_SAVER_MODE_SAVER:
fullScreen = true;
fullScreenParFound = true;
break;
case SCREEN_SAVER_MODE_PREVIEW:
/* This will actually be handled somewhere below... */
break;
}
}
#endif
// XXX add the ability to change this values to the command line parsing.
U.mixbufsize = 2048;
U.audiodevice = 2;
U.audiorate = 44100;
U.audioformat = 0x24;
U.audiochannels = 2;
// XXX this one too
U.anisotropic_filter = 2;
// enable fast mipmap generation
U.use_gpu_mipmap = 1;
sound_init_once();
set_free_windowmanager_cb(wm_free);
/* if running blenderplayer the last argument can't be parsed since it has to be the filename. else it is bundled */
isBlenderPlayer = !BLO_is_a_runtime(argv[0]);
if (isBlenderPlayer)
validArguments = argc - 1;
else
validArguments = argc;
/* Parsing command line arguments (can be set from WM_OT_blenderplayer_start) */
#if defined(DEBUG)
printf("Parsing command line arguments...\n");
printf("Num of arguments is: %i\n", validArguments-1); //-1 because i starts at 1
#endif
for (i = 1; (i < validArguments) && !error
#ifdef WIN32
&& scr_saver_mode == SCREEN_SAVER_MODE_NONE
#endif
;)
{
#if defined(DEBUG)
printf("argv[%d] = '%s'\n", i, argv[i]);
#endif
if (argv[i][0] == '-')
{
/* ignore all args after " - ", allow python to have own args */
if (argv[i][1]=='\0') {
argc_py_clamped= i;
break;
}
switch (argv[i][1])
{
case 'g': //game engine options (show_framerate, fixedtime, etc)
{
i++;
if (i <= validArguments)
{
char* paramname = argv[i];
// Check for single value versus assignment
if (i+1 <= validArguments && (*(argv[i+1]) == '='))
{
i++;
if (i + 1 <= validArguments)
{
i++;
// Assignment
SYS_WriteCommandLineInt(syshandle, paramname, atoi(argv[i]));
SYS_WriteCommandLineFloat(syshandle, paramname, atof(argv[i]));
SYS_WriteCommandLineString(syshandle, paramname, argv[i]);
#if defined(DEBUG)
printf("%s = '%s'\n", paramname, argv[i]);
#endif
i++;
}
else
{
error = true;
printf("error: argument assignment %s without value.\n", paramname);
}
}
else
{
// SYS_WriteCommandLineInt(syshandle, argv[i++], 1);
}
}
break;
}
case 'd': //debug on
{
i++;
G.debug |= G_DEBUG;
MEM_set_memory_debug();
#ifdef DEBUG
BLI_mempool_set_memory_debug();
#endif
break;
}
case 'f': //fullscreen mode
{
i++;
fullScreen = true;
fullScreenParFound = true;
if ((i + 2) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
fullScreenWidth = atoi(argv[i++]);
fullScreenHeight = atoi(argv[i++]);
if ((i + 1) <= validArguments && argv[i][0] != '-')
{
fullScreenBpp = atoi(argv[i++]);
if ((i + 1) <= validArguments && argv[i][0] != '-')
fullScreenFrequency = atoi(argv[i++]);
}
}
else if ((i + 1) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
error = true;
printf("error: to define fullscreen width or height, both options must be used.\n");
}
break;
}
case 'w': //display in a window
{
i++;
fullScreen = false;
windowParFound = true;
// Parse window position and size options
if ((i + 2) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
windowWidth = atoi(argv[i++]);
windowHeight = atoi(argv[i++]);
if ((i + 2) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
windowLeft = atoi(argv[i++]);
windowTop = atoi(argv[i++]);
}
else if ((i + 1) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
error = true;
printf("error: to define the window left or right coordinates, both options must be used.\n");
}
}
else if ((i + 1) <= validArguments && argv[i][0] != '-' && argv[i+1][0] != '-')
{
error = true;
printf("error: to define the window's width or height, both options must be used.\n");
}
break;
}
case 'h': //display help
{
usage(argv[0], isBlenderPlayer);
return 0;
break;
}
case 'i': //parent window ID
{
i++;
if ( (i + 1) <= validArguments )
parentWindow = atoi(argv[i++]);
else {
error = true;
printf("error: too few options for parent window argument.\n");
}
#if defined(DEBUG)
printf("XWindows ID = %d\n", parentWindow);
#endif // defined(DEBUG)
break;
}
case 'm': //maximum anti-aliasing (eg. 2,4,8,16)
{
i++;
samplesParFound = true;
if ((i+1) <= validArguments )
aasamples = atoi(argv[i++]);
else
{
error = true;
printf("error: No argument supplied for -m");
}
break;
}
case 'c': //keep console (windows only)
{
i++;
#ifdef WIN32
closeConsole = false;
#endif
break;
}
case 's': //stereo mode
{
i++;
if ((i + 1) <= validArguments)
{
stereoParFound = true;
stereoFlag = STEREO_ENABLED;
if (!strcmp(argv[i], "nostereo")) // may not be redundant if the file has different setting
{
stereomode = RAS_IRasterizer::RAS_STEREO_NOSTEREO;
stereoFlag = STEREO_NOSTEREO;
}
// only the hardware pageflip method needs a stereo window
else if (!strcmp(argv[i], "hwpageflip")) {
stereomode = RAS_IRasterizer::RAS_STEREO_QUADBUFFERED;
stereoWindow = true;
}
else if (!strcmp(argv[i], "syncdoubling"))
stereomode = RAS_IRasterizer::RAS_STEREO_ABOVEBELOW;
else if (!strcmp(argv[i], "3dtvtopbottom"))
stereomode = RAS_IRasterizer::RAS_STEREO_3DTVTOPBOTTOM;
else if (!strcmp(argv[i], "anaglyph"))
stereomode = RAS_IRasterizer::RAS_STEREO_ANAGLYPH;
else if (!strcmp(argv[i], "sidebyside"))
stereomode = RAS_IRasterizer::RAS_STEREO_SIDEBYSIDE;
else if (!strcmp(argv[i], "interlace"))
stereomode = RAS_IRasterizer::RAS_STEREO_INTERLACED;
else if (!strcmp(argv[i], "vinterlace"))
stereomode = RAS_IRasterizer::RAS_STEREO_VINTERLACE;
#if 0
// // future stuff
// else if (!strcmp(argv[i], "stencil")
// stereomode = RAS_STEREO_STENCIL;
#endif
else
{
error = true;
printf("error: stereomode '%s' unrecognized.\n", argv[i]);
}
i++;
}
else
{
error = true;
printf("error: too few options for stereo argument.\n");
}
break;
}
case 'D': //dome mode
{
stereoFlag = STEREO_DOME;
stereomode = RAS_IRasterizer::RAS_STEREO_DOME;
i++;
if ((i + 1) <= validArguments)
{
if (!strcmp(argv[i], "angle")) {
i++;
domeFov = atoi(argv[i++]);
}
if (!strcmp(argv[i], "tilt")) {
i++;
domeTilt = atoi(argv[i++]);
}
if (!strcmp(argv[i], "warpdata")) {
i++;
domeWarp = argv[i++];
}
if (!strcmp(argv[i], "mode")) {
i++;
if (!strcmp(argv[i], "fisheye"))
domeMode = DOME_FISHEYE;
else if (!strcmp(argv[i], "truncatedfront"))
domeMode = DOME_TRUNCATED_FRONT;
else if (!strcmp(argv[i], "truncatedrear"))
domeMode = DOME_TRUNCATED_REAR;
else if (!strcmp(argv[i], "cubemap"))
domeMode = DOME_ENVMAP;
else if (!strcmp(argv[i], "sphericalpanoramic"))
domeMode = DOME_PANORAM_SPH;
else
printf("error: %s is not a valid dome mode.\n", argv[i]);
}
i++;
}
break;
}
default: //not recognized
{
printf("Unknown argument: %s\n", argv[i++]);
break;
}
}
}
else
{
i++;
}
}
if ((windowWidth < kMinWindowWidth) || (windowHeight < kMinWindowHeight))
{
error = true;
printf("error: window size too small.\n");
}
if (error )
{
usage(argv[0], isBlenderPlayer);
return 0;
}
#ifdef WIN32
if (scr_saver_mode != SCREEN_SAVER_MODE_CONFIGURATION)
#endif
{
// Create the system
if (GHOST_ISystem::createSystem() == GHOST_kSuccess) {
GHOST_ISystem* system = GHOST_ISystem::getSystem();
assertd(system);
if (!fullScreenWidth || !fullScreenHeight)
system->getMainDisplayDimensions(fullScreenWidth, fullScreenHeight);
// process first batch of events. If the user
// drops a file on top off the blenderplayer icon, we
// receive an event with the filename
system->processEvents(0);
// this bracket is needed for app (see below) to get out
// of scope before GHOST_ISystem::disposeSystem() is called.
{
int exitcode = KX_EXIT_REQUEST_NO_REQUEST;
STR_String exitstring = "";
GPG_Application app(system);
bool firstTimeRunning = true;
char filename[FILE_MAX];
char pathname[FILE_MAX];
char *titlename;
get_filename(argc_py_clamped, argv, filename);
if (filename[0])
BLI_path_cwd(filename);
// fill the GlobalSettings with the first scene files
// those may change during the game and persist after using Game Actuator
GlobalSettings gs;
do {
// Read the Blender file
BlendFileData *bfd;
// if we got an exitcode 3 (KX_EXIT_REQUEST_START_OTHER_GAME) load a different file
if (exitcode == KX_EXIT_REQUEST_START_OTHER_GAME)
{
char basedpath[FILE_MAX];
// base the actuator filename relative to the last file
BLI_strncpy(basedpath, exitstring.Ptr(), sizeof(basedpath));
BLI_path_abs(basedpath, pathname);
bfd = load_game_data(basedpath);
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);
}
}
else {
bfd = load_game_data(BKE_appdir_program_path(), filename[0]? filename: NULL);
}
#if defined(DEBUG)
printf("Game data loaded from %s\n", filename);
#endif
if (!bfd) {
usage(argv[0], isBlenderPlayer);
error = true;
exitcode = KX_EXIT_REQUEST_QUIT_GAME;
}
else {
/* Setting options according to the blend file if not overriden in the command line */
#ifdef WIN32
#if !defined(DEBUG)
if (closeConsole) {
system->toggleConsole(0); // Close a console window
}
#endif // !defined(DEBUG)
#endif // WIN32
Main *maggie = bfd->main;
Scene *scene = bfd->curscene;
G.main = maggie;
if (firstTimeRunning) {
G.fileflags = bfd->fileflags;
gs.matmode= scene->gm.matmode;
gs.glslflag= scene->gm.flag;
}
//Seg Fault; icon.c gIcons == 0
BKE_icons_init(1);
titlename = maggie->name;
// Check whether the game should be displayed full-screen
if ((!fullScreenParFound) && (!windowParFound)) {
// Only use file settings when command line did not override
if ((scene->gm.playerflag & GAME_PLAYER_FULLSCREEN)) {
//printf("fullscreen option found in Blender file\n");
fullScreen = true;
fullScreenWidth= scene->gm.xplay;
fullScreenHeight= scene->gm.yplay;
fullScreenFrequency= scene->gm.freqplay;
fullScreenBpp = scene->gm.depth;
}
else
{
fullScreen = false;
windowWidth = scene->gm.xplay;
windowHeight = scene->gm.yplay;
}
}
// Check whether the game should be displayed in stereo (dome included)
if (!stereoParFound) {
// Only use file settings when command line did not override
if (scene->gm.stereoflag == STEREO_ENABLED) {
stereomode = (RAS_IRasterizer::StereoMode) scene->gm.stereomode;
if (stereomode == RAS_IRasterizer::RAS_STEREO_QUADBUFFERED)
stereoWindow = true;
}
}
else {
scene->gm.stereoflag = STEREO_ENABLED;
}
if (!samplesParFound)
aasamples = scene->gm.aasamples;
// Dome specific settings
if (stereoFlag == STEREO_DOME) {
stereomode = RAS_IRasterizer::RAS_STEREO_DOME;
scene->gm.stereoflag = STEREO_DOME;
if (domeFov > 89)
scene->gm.dome.angle = domeFov;
if (domeTilt > -180)
scene->gm.dome.tilt = domeTilt;
if (domeMode > 0)
scene->gm.dome.mode = domeMode;
if (domeWarp) {
//XXX to do: convert relative to absolute path
domeText= BKE_text_load(G.main, domeWarp, "");
if (!domeText)
printf("error: invalid warpdata text file - %s\n", domeWarp);
else
scene->gm.dome.warptext = domeText;
}
}
// GPG_Application app (system, maggie, startscenename);
app.SetGameEngineData(maggie, scene, &gs, argc, argv); /* this argc cant be argc_py_clamped, since python uses it */
BLI_strncpy(pathname, maggie->name, sizeof(pathname));
if (G.main != maggie) {
BLI_strncpy(G.main->name, maggie->name, sizeof(G.main->name));
}
#ifdef WITH_PYTHON
setGamePythonPath(G.main->name);
#endif
if (firstTimeRunning) {
firstTimeRunning = false;
if (fullScreen) {
#ifdef WIN32
if (scr_saver_mode == SCREEN_SAVER_MODE_SAVER)
{
app.startScreenSaverFullScreen(fullScreenWidth, fullScreenHeight, fullScreenBpp, fullScreenFrequency,
stereoWindow, stereomode, aasamples);
}
else
#endif
{
app.startFullScreen(fullScreenWidth, fullScreenHeight, fullScreenBpp, fullScreenFrequency,
stereoWindow, stereomode, aasamples, (scene->gm.playerflag & GAME_PLAYER_DESKTOP_RESOLUTION));
}
}
else
{
#ifdef __APPLE__
// on Mac's we'll show the executable name instead of the 'game.blend' name
char tempname[1024], *appstring;
::strcpy(tempname, titlename);
appstring = strstr(tempname, ".app/");
if (appstring) {
appstring[2] = 0;
titlename = &tempname[0];
}
#endif
// Strip the path so that we have the name of the game file
STR_String path = titlename;
#ifndef WIN32
vector<STR_String> parts = path.Explode('/');
#else // WIN32
vector<STR_String> parts = path.Explode('\\');
#endif // WIN32
STR_String title;
if (parts.size()) {
title = parts[parts.size()-1];
parts = title.Explode('.');
if (parts.size() > 1)
{
title = parts[0];
}
}
else {
title = "blenderplayer";
}
#ifdef WIN32
if (scr_saver_mode == SCREEN_SAVER_MODE_PREVIEW)
{
app.startScreenSaverPreview(scr_saver_hwnd, stereoWindow, stereomode, aasamples);
}
else
#endif
{
if (parentWindow != 0)
app.startEmbeddedWindow(title, parentWindow, stereoWindow, stereomode, aasamples);
else
app.startWindow(title, windowLeft, windowTop, windowWidth, windowHeight,
stereoWindow, stereomode, aasamples);
if (SYS_GetCommandLineInt(syshandle, "nomipmap", 0)) {
GPU_set_mipmap(0);
}
GPU_set_anisotropic(U.anisotropic_filter);
GPU_set_gpu_mipmapping(U.use_gpu_mipmap);
}
}
}
else {
app.StartGameEngine(stereomode);
exitcode = KX_EXIT_REQUEST_NO_REQUEST;
}
// Add the application as event consumer
system->addEventConsumer(&app);
// Enter main loop
bool run = true;
char *python_main = NULL;
pynextframestate.state = NULL;
pynextframestate.func = NULL;
#ifdef WITH_PYTHON
python_main = KX_GetPythonMain(scene);
#endif // WITH_PYTHON
if (python_main) {
char *python_code = KX_GetPythonCode(maggie, python_main);
if (python_code) {
#ifdef WITH_PYTHON
gpg_nextframestate.system = system;
gpg_nextframestate.app = &app;
gpg_nextframestate.gs = &gs;
pynextframestate.state = &gpg_nextframestate;
pynextframestate.func = &GPG_PyNextFrame;
printf("Yielding control to Python script '%s'...\n", python_main);
PyRun_SimpleString(python_code);
printf("Exit Python script '%s'\n", python_main);
#endif // WITH_PYTHON
MEM_freeN(python_code);
}
else {
fprintf(stderr, "ERROR: cannot yield control to Python: no Python text data block named '%s'\n", python_main);
}
}
else {
while (run) {
run = GPG_NextFrame(system, &app, exitcode, exitstring, &gs);
}
}
app.StopGameEngine();
/* 'app' is freed automatic when out of scope.
* removal is needed else the system will free an already freed value */
system->removeEventConsumer(&app);
BLO_blendfiledata_free(bfd);
/* G.main == bfd->main, it gets referenced in free_nodesystem so we can't have a dangling pointer */
G.main = NULL;
if (python_main) MEM_freeN(python_main);
}
} while (exitcode == KX_EXIT_REQUEST_RESTART_GAME || exitcode == KX_EXIT_REQUEST_START_OTHER_GAME);
}
// Seg Fault; icon.c gIcons == 0
BKE_icons_free();
// Dispose the system
GHOST_ISystem::disposeSystem();
}
else {
error = true;
printf("error: couldn't create a system.\n");
}
}
/* refer to WM_exit_ext() and free_blender(),
* these are not called in the player but we need to match some of there behavior here,
* if the order of function calls or blenders state isn't matching that of blender proper,
* we may get troubles later on */
free_nodesystem();
// Cleanup
RNA_exit();
BLF_exit();
#ifdef WITH_INTERNATIONAL
BLF_free_unifont();
BLF_free_unifont_mono();
BLF_lang_free();
#endif
IMB_exit();
BKE_images_exit();
DAG_exit();
IMB_moviecache_destruct();
SYS_DeleteSystem(syshandle);
int totblock= MEM_get_memory_blocks_in_use();
if (totblock!=0) {
printf("Error Totblock: %d\n",totblock);
MEM_set_error_callback(mem_error_cb);
MEM_printmemlist();
}
BKE_tempdir_session_purge();
return error ? -1 : 0;
}