source/creator/creator.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * The Original Code is: all of this file.
  22  *
  23  * Contributor(s): none yet.
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file creator/creator.c
  29  *  \ingroup creator
  30  */
  31
  32
  33 #if defined(__linux__) && defined(__GNUC__)
  34 #  define _GNU_SOURCE
  35 #  include <fenv.h>
  36 #endif
  37
  38 #if (defined(__APPLE__) && (defined(__i386__) || defined(__x86_64__)))
  39 #  define OSX_SSE_FPE
  40 #  include <xmmintrin.h>
  41 #endif
  42
  43 #ifdef WIN32
  44 #  include <Windows.h>
  45 #  include "utfconv.h"
  46 #endif
  47
  48 #include <stdlib.h>
  49 #include <stddef.h>
  50 #include <string.h>
  51
  52 /* This little block needed for linking to Blender... */
  53
  54 #include "MEM_guardedalloc.h"
  55
  56 #ifdef WIN32
  57 #  include "BLI_winstuff.h"
  58 #endif
  59
  60 #include "BLI_args.h"
  61 #include "BLI_threads.h"
  62 #include "BLI_utildefines.h"
  63 #include "BLI_callbacks.h"
  64
  65 #include "DNA_ID.h"
  66 #include "DNA_scene_types.h"
  67 #include "DNA_userdef_types.h"
  68
  69 #include "BLI_blenlib.h"
  70
  71 #include "BKE_utildefines.h"
  72 #include "BKE_blender.h"
  73 #include "BKE_context.h"
  74 #include "BKE_depsgraph.h" /* for DAG_on_visible_update */
  75 #include "BKE_font.h"
  76 #include "BKE_global.h"
  77 #include "BKE_main.h"
  78 #include "BKE_material.h"
  79 #include "BKE_packedFile.h"
  80 #include "BKE_scene.h"
  81 #include "BKE_node.h"
  82 #include "BKE_report.h"
  83 #include "BKE_sound.h"
  84 #include "BKE_image.h"
  85
  86 #include "IMB_imbuf.h"  /* for IMB_init */
  87
  88 #ifdef WITH_PYTHON
  89 #include "BPY_extern.h"
  90 #endif
  91
  92 #include "RE_engine.h"
  93 #include "RE_pipeline.h"
  94
  95 //XXX #include "playanim_ext.h"
  96 #include "ED_datafiles.h"
  97
  98 #include "WM_api.h"
  99
 100 #include "RNA_define.h"
 101
 102 #include "GPU_draw.h"
 103 #include "GPU_extensions.h"
 104
 105 #include "BLI_scanfill.h" /* for BLI_setErrorCallBack, TODO, move elsewhere */
 106
 107 #ifdef WITH_BUILDINFO_HEADER
 108 #  define BUILD_DATE
 109 #endif
 110
 111 /* for passing information between creator and gameengine */
 112 #ifdef WITH_GAMEENGINE
 113 #  include "BL_System.h"
 114 #else /* dummy */
 115 #  define SYS_SystemHandle int
 116 #endif
 117
 118 #include <signal.h>
 119
 120 #ifdef __FreeBSD__
 121 #  include <sys/types.h>
 122 #  include <floatingpoint.h>
 123 #  include <sys/rtprio.h>
 124 #endif
 125
 126 #ifdef WITH_BINRELOC
 127 #  include "binreloc.h"
 128 #endif
 129
 130 #ifdef WITH_LIBMV
 131 #  include "libmv-capi.h"
 132 #endif
 133
 134 /* from buildinfo.c */
 135 #ifdef BUILD_DATE
 136 extern char build_date[];
 137 extern char build_time[];
 138 extern char build_rev[];
 139 extern char build_platform[];
 140 extern char build_type[];
 141 extern char build_cflags[];
 142 extern char build_cxxflags[];
 143 extern char build_linkflags[];
 144 extern char build_system[];
 145 #endif
 146
 147 /*      Local Function prototypes */
 148 #ifndef WITH_PYTHON_MODULE
 149 static int print_help(int argc, const char **argv, void *data);
 150 static int print_version(int argc, const char **argv, void *data);
 151 #endif
 152
 153 /* for the callbacks: */
 154
 155 #define BLEND_VERSION_STRING_FMT                                              \
 156     "Blender %d.%02d (sub %d)\n",                                             \
 157     BLENDER_VERSION / 100, BLENDER_VERSION % 100, BLENDER_SUBVERSION          \
 158
 159 /* Initialize callbacks for the modules that need them */
 160 static void setCallbacks(void);
 161
 162 #ifndef WITH_PYTHON_MODULE
 163
 164 /* set breakpoints here when running in debug mode, useful to catch floating point errors */
 165 #if defined(__linux__) || defined(_WIN32) || defined(OSX_SSE_FPE)
 166 static void fpe_handler(int UNUSED(sig))
 167 {
 168         // printf("SIGFPE trapped\n");
 169 }
 170 #endif
 171
 172 /* handling ctrl-c event in console */
 173 static void blender_esc(int sig)
 174 {
 175         static int count = 0;
 176
 177         G.afbreek = 1;  /* forces render loop to read queue, not sure if its needed */
 178
 179         if (sig == 2) {
 180                 if (count) {
 181                         printf("\nBlender killed\n");
 182                         exit(2);
 183                 }
 184                 printf("\nSent an internal break event. Press ^C again to kill Blender\n");
 185                 count++;
 186         }
 187 }
 188
 189 static int print_version(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 190 {
 191         printf(BLEND_VERSION_STRING_FMT);
 192 #ifdef BUILD_DATE
 193         printf("\tbuild date: %s\n", build_date);
 194         printf("\tbuild time: %s\n", build_time);
 195         printf("\tbuild revision: %s\n", build_rev);
 196         printf("\tbuild platform: %s\n", build_platform);
 197         printf("\tbuild type: %s\n", build_type);
 198         printf("\tbuild c flags: %s\n", build_cflags);
 199         printf("\tbuild c++ flags: %s\n", build_cxxflags);
 200         printf("\tbuild link flags: %s\n", build_linkflags);
 201         printf("\tbuild system: %s\n", build_system);
 202 #endif
 203         exit(0);
 204
 205         return 0;
 206 }
 207
 208 static int print_help(int UNUSED(argc), const char **UNUSED(argv), void *data)
 209 {
 210         bArgs *ba = (bArgs *)data;
 211
 212         printf(BLEND_VERSION_STRING_FMT);
 213         printf("Usage: blender [args ...] [file] [args ...]\n\n");
 214
 215         printf("Render Options:\n");
 216         BLI_argsPrintArgDoc(ba, "--background");
 217         BLI_argsPrintArgDoc(ba, "--render-anim");
 218         BLI_argsPrintArgDoc(ba, "--scene");
 219         BLI_argsPrintArgDoc(ba, "--render-frame");
 220         BLI_argsPrintArgDoc(ba, "--frame-start");
 221         BLI_argsPrintArgDoc(ba, "--frame-end");
 222         BLI_argsPrintArgDoc(ba, "--frame-jump");
 223         BLI_argsPrintArgDoc(ba, "--render-output");
 224         BLI_argsPrintArgDoc(ba, "--engine");
 225
 226         printf("\n");
 227         printf("Format Options:\n");
 228         BLI_argsPrintArgDoc(ba, "--render-format");
 229         BLI_argsPrintArgDoc(ba, "--use-extension");
 230         BLI_argsPrintArgDoc(ba, "--threads");
 231
 232         printf("\n");
 233         printf("Animation Playback Options:\n");
 234         BLI_argsPrintArgDoc(ba, "-a");
 235
 236         printf("\n");
 237         printf("Window Options:\n");
 238         BLI_argsPrintArgDoc(ba, "--window-border");
 239         BLI_argsPrintArgDoc(ba, "--window-borderless");
 240         BLI_argsPrintArgDoc(ba, "--window-geometry");
 241         BLI_argsPrintArgDoc(ba, "--start-console");
 242
 243         printf("\n");
 244         printf("Game Engine Specific Options:\n");
 245         BLI_argsPrintArgDoc(ba, "-g");
 246
 247         printf("\n");
 248         printf("Misc Options:\n");
 249         BLI_argsPrintArgDoc(ba, "--debug");
 250         BLI_argsPrintArgDoc(ba, "--debug-fpe");
 251
 252 #ifdef WITH_FFMPEG
 253         BLI_argsPrintArgDoc(ba, "--debug-ffmpeg");
 254 #endif
 255
 256 #ifdef WITH_LIBMV
 257         BLI_argsPrintArgDoc(ba, "--debug-libmv");
 258 #endif
 259
 260         printf("\n");
 261         BLI_argsPrintArgDoc(ba, "--factory-startup");
 262         printf("\n");
 263         BLI_argsPrintArgDoc(ba, "--env-system-config");
 264         BLI_argsPrintArgDoc(ba, "--env-system-datafiles");
 265         BLI_argsPrintArgDoc(ba, "--env-system-scripts");
 266         BLI_argsPrintArgDoc(ba, "--env-system-python");
 267         printf("\n");
 268         BLI_argsPrintArgDoc(ba, "-nojoystick");
 269         BLI_argsPrintArgDoc(ba, "-noglsl");
 270         BLI_argsPrintArgDoc(ba, "-noaudio");
 271         BLI_argsPrintArgDoc(ba, "-setaudio");
 272
 273         printf("\n");
 274
 275         BLI_argsPrintArgDoc(ba, "--help");
 276
 277         printf("\n");
 278
 279         BLI_argsPrintArgDoc(ba, "--enable-autoexec");
 280         BLI_argsPrintArgDoc(ba, "--disable-autoexec");
 281
 282         printf("\n");
 283
 284         BLI_argsPrintArgDoc(ba, "--python");
 285         BLI_argsPrintArgDoc(ba, "--python-console");
 286         BLI_argsPrintArgDoc(ba, "--addons");
 287
 288 #ifdef WIN32
 289         BLI_argsPrintArgDoc(ba, "-R");
 290         BLI_argsPrintArgDoc(ba, "-r");
 291 #endif
 292         BLI_argsPrintArgDoc(ba, "--version");
 293
 294         BLI_argsPrintArgDoc(ba, "--");
 295
 296         printf("Other Options:\n");
 297         BLI_argsPrintOtherDoc(ba);
 298
 299         printf("Argument Parsing:\n");
 300         printf("\targuments must be separated by white space. eg\n");
 301         printf("\t\t\"blender -ba test.blend\"\n");
 302         printf("\t...will ignore the 'a'\n");
 303         printf("\t\t\"blender -b test.blend -f8\"\n");
 304         printf("\t...will ignore 8 because there is no space between the -f and the frame value\n\n");
 305
 306         printf("Argument Order:\n");
 307         printf("Arguments are executed in the order they are given. eg\n");
 308         printf("\t\t\"blender --background test.blend --render-frame 1 --render-output /tmp\"\n");
 309         printf("\t...will not render to /tmp because '--render-frame 1' renders before the output path is set\n");
 310         printf("\t\t\"blender --background --render-output /tmp test.blend --render-frame 1\"\n");
 311         printf("\t...will not render to /tmp because loading the blend file overwrites the render output that was set\n");
 312         printf("\t\t\"blender --background test.blend --render-output /tmp --render-frame 1\" works as expected.\n\n");
 313
 314         printf("\nEnvironment Variables:\n");
 315         printf("  $BLENDER_USER_CONFIG      Directory for user configuration files.\n");
 316         printf("  $BLENDER_USER_SCRIPTS     Directory for user scripts.\n");
 317         printf("  $BLENDER_SYSTEM_SCRIPTS   Directory for system wide scripts.\n");
 318         printf("  $Directory for user data files (icons, translations, ..).\n");
 319         printf("  $BLENDER_SYSTEM_DATAFILES Directory for system wide data files.\n");
 320         printf("  $BLENDER_SYSTEM_PYTHON    Directory for system python libraries.\n");
 321 #ifdef WIN32
 322         printf("  $TEMP                     Store temporary files here.\n");
 323 #else
 324         printf("  $TMP or $TMPDIR           Store temporary files here.\n");
 325 #endif
 326 #ifdef WITH_SDL
 327         printf("  $SDL_AUDIODRIVER          LibSDL audio driver - alsa, esd, dma.\n");
 328 #endif
 329         printf("  $PYTHONHOME               Path to the python directory, eg. /usr/lib/python.\n\n");
 330
 331         exit(0);
 332
 333         return 0;
 334 }
 335
 336 static int end_arguments(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 337 {
 338         return -1;
 339 }
 340
 341 static int enable_python(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 342 {
 343         G.f |= G_SCRIPT_AUTOEXEC;
 344         G.f |= G_SCRIPT_OVERRIDE_PREF;
 345         return 0;
 346 }
 347
 348 static int disable_python(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 349 {
 350         G.f &= ~G_SCRIPT_AUTOEXEC;
 351         G.f |= G_SCRIPT_OVERRIDE_PREF;
 352         return 0;
 353 }
 354
 355 static int background_mode(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 356 {
 357         G.background = 1;
 358         return 0;
 359 }
 360
 361 static int debug_mode(int UNUSED(argc), const char **UNUSED(argv), void *data)
 362 {
 363         G.debug |= G_DEBUG;  /* std output printf's */
 364         printf(BLEND_VERSION_STRING_FMT);
 365         MEM_set_memory_debug();
 366
 367 #ifdef WITH_BUILDINFO
 368         printf("Build: %s %s %s %s\n", build_date, build_time, build_platform, build_type);
 369 #endif // WITH_BUILDINFO
 370
 371         BLI_argsPrint(data);
 372         return 0;
 373 }
 374
 375 static int debug_mode_generic(int UNUSED(argc), const char **UNUSED(argv), void *data)
 376 {
 377         G.debug |= GET_INT_FROM_POINTER(data);
 378         return 0;
 379 }
 380
 381 #ifdef WITH_LIBMV
 382 static int debug_mode_libmv(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 383 {
 384         libmv_startDebugLogging();
 385
 386         return 0;
 387 }
 388 #endif
 389
 390 static int set_debug_value(int argc, const char **argv, void *UNUSED(data))
 391 {
 392         if (argc > 1) {
 393                 G.rt = atoi(argv[1]);
 394
 395                 return 1;
 396         }
 397         else {
 398                 printf("\nError: you must specify debug value to set.\n");
 399                 return 0;
 400         }
 401 }
 402
 403 static int set_fpe(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 404 {
 405 #if defined(__linux__) || defined(_WIN32) || defined(OSX_SSE_FPE)
 406         /* zealous but makes float issues a heck of a lot easier to find!
 407          * set breakpoints on fpe_handler */
 408         signal(SIGFPE, fpe_handler);
 409
 410 # if defined(__linux__) && defined(__GNUC__)
 411         feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
 412 # endif /* defined(__linux__) && defined(__GNUC__) */
 413 # if defined(OSX_SSE_FPE)
 414         /* OSX uses SSE for floating point by default, so here
 415          * use SSE instructions to throw floating point exceptions */
 416         _MM_SET_EXCEPTION_MASK(_MM_MASK_MASK & ~
 417                                (_MM_MASK_OVERFLOW | _MM_MASK_INVALID | _MM_MASK_DIV_ZERO));
 418 # endif /* OSX_SSE_FPE */
 419 # if defined(_WIN32) && defined(_MSC_VER)
 420         _controlfp_s(NULL, 0, _MCW_EM); /* enables all fp exceptions */
 421         _controlfp_s(NULL, _EM_DENORMAL | _EM_UNDERFLOW | _EM_INEXACT, _MCW_EM); /* hide the ones we don't care about */
 422 # endif /* _WIN32 && _MSC_VER */
 423 #endif
 424
 425         return 0;
 426 }
 427
 428 static int set_factory_startup(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 429 {
 430         G.factory_startup = 1;
 431         return 0;
 432 }
 433
 434 static int set_env(int argc, const char **argv, void *UNUSED(data))
 435 {
 436         /* "--env-system-scripts" --> "BLENDER_SYSTEM_SCRIPTS" */
 437
 438         char env[64] = "BLENDER";
 439         char *ch_dst = env + 7; /* skip BLENDER */
 440         const char *ch_src = argv[0] + 5; /* skip --env */
 441
 442         if (argc < 2) {
 443                 printf("%s requires one argument\n", argv[0]);
 444                 exit(1);
 445         }
 446
 447         for (; *ch_src; ch_src++, ch_dst++) {
 448                 *ch_dst = (*ch_src == '-') ? '_' : (*ch_src) - 32; /* toupper() */
 449         }
 450
 451         *ch_dst = '\0';
 452         BLI_setenv(env, argv[1]);
 453         return 1;
 454 }
 455
 456 static int playback_mode(int argc, const char **argv, void *UNUSED(data))
 457 {
 458         extern void playanim(int argc, const char **argv);
 459
 460         /* not if -b was given first */
 461         if (G.background == 0) {
 462                 playanim(argc, argv); /* not the same argc and argv as before */
 463         }
 464
 465         return -2;
 466 }
 467
 468 static int prefsize(int argc, const char **argv, void *UNUSED(data))
 469 {
 470         int stax, stay, sizx, sizy;
 471
 472         if (argc < 5) {
 473                 fprintf(stderr, "-p requires four arguments\n");
 474                 exit(1);
 475         }
 476
 477         stax = atoi(argv[1]);
 478         stay = atoi(argv[2]);
 479         sizx = atoi(argv[3]);
 480         sizy = atoi(argv[4]);
 481
 482         WM_setprefsize(stax, stay, sizx, sizy);
 483
 484         return 4;
 485 }
 486
 487 static int with_borders(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 488 {
 489         WM_setinitialstate_normal();
 490         return 0;
 491 }
 492
 493 static int without_borders(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 494 {
 495         WM_setinitialstate_fullscreen();
 496         return 0;
 497 }
 498
 499 extern int wm_start_with_console; /* wm_init_exit.c */
 500 static int start_with_console(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 501 {
 502         wm_start_with_console = 1;
 503         return 0;
 504 }
 505
 506 static int register_extension(int UNUSED(argc), const char **UNUSED(argv), void *data)
 507 {
 508 #ifdef WIN32
 509         if (data)
 510                 G.background = 1;
 511         RegisterBlendExtension();
 512 #else
 513         (void)data; /* unused */
 514 #endif
 515         return 0;
 516 }
 517
 518 static int no_joystick(int UNUSED(argc), const char **UNUSED(argv), void *data)
 519 {
 520 #ifndef WITH_GAMEENGINE
 521         (void)data;
 522 #else
 523         SYS_SystemHandle *syshandle = data;
 524
 525         /**
 526          * don't initialize joysticks if user doesn't want to use joysticks
 527          * failed joystick initialization delays over 5 seconds, before game engine start
 528          */
 529         SYS_WriteCommandLineInt(*syshandle, "nojoystick", 1);
 530         if (G.debug & G_DEBUG) printf("disabling nojoystick\n");
 531 #endif
 532
 533         return 0;
 534 }
 535
 536 static int no_glsl(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 537 {
 538         GPU_extensions_disable();
 539         return 0;
 540 }
 541
 542 static int no_audio(int UNUSED(argc), const char **UNUSED(argv), void *UNUSED(data))
 543 {
 544         sound_force_device(0);
 545         return 0;
 546 }
 547
 548 static int set_audio(int argc, const char **argv, void *UNUSED(data))
 549 {
 550         if (argc < 1) {
 551                 fprintf(stderr, "-setaudio require one argument\n");
 552                 exit(1);
 553         }
 554
 555         sound_force_device(sound_define_from_str(argv[1]));
 556         return 1;
 557 }
 558
 559 static int set_output(int argc, const char **argv, void *data)
 560 {
 561         bContext *C = data;
 562         if (argc >= 1) {
 563                 Scene *scene = CTX_data_scene(C);
 564                 if (scene) {
 565                         BLI_strncpy(scene->r.pic, argv[1], sizeof(scene->r.pic));
 566                 }
 567                 else {
 568                         printf("\nError: no blend loaded. cannot use '-o / --render-output'.\n");
 569                 }
 570                 return 1;
 571         }
 572         else {
 573                 printf("\nError: you must specify a path after '-o  / --render-output'.\n");
 574                 return 0;
 575         }
 576 }
 577
 578 static int set_engine(int argc, const char **argv, void *data)
 579 {
 580         bContext *C = data;
 581         if (argc >= 2) {
 582                 if (!strcmp(argv[1], "help")) {
 583                         RenderEngineType *type = NULL;
 584                         printf("Blender Engine Listing:\n");
 585                         for (type = R_engines.first; type; type = type->next) {
 586                                 printf("\t%s\n", type->idname);
 587                         }
 588                         exit(0);
 589                 }
 590                 else {
 591                         Scene *scene = CTX_data_scene(C);
 592                         if (scene) {
 593                                 RenderData *rd = &scene->r;
 594
 595                                 if (BLI_findstring(&R_engines, argv[1], offsetof(RenderEngineType, idname))) {
 596                                         BLI_strncpy_utf8(rd->engine, argv[1], sizeof(rd->engine));
 597                                 }
 598                         }
 599                         else {
 600                                 printf("\nError: no blend loaded. order the arguments so '-E  / --engine ' is after a blend is loaded.\n");
 601                         }
 602                 }
 603
 604                 return 1;
 605         }
 606         else {
 607                 printf("\nEngine not specified, give 'help' for a list of available engines.\n");
 608                 return 0;
 609         }
 610 }
 611
 612 static int set_image_type(int argc, const char **argv, void *data)
 613 {
 614         bContext *C = data;
 615         if (argc > 1) {
 616                 const char *imtype = argv[1];
 617                 Scene *scene = CTX_data_scene(C);
 618                 if (scene) {
 619                         const char imtype_new = BKE_imtype_from_arg(imtype);
 620
 621                         if (imtype_new == R_IMF_IMTYPE_INVALID) {
 622                                 printf("\nError: Format from '-F / --render-format' not known or not compiled in this release.\n");
 623                         }
 624                         else {
 625                                 scene->r.im_format.imtype = imtype_new;
 626                         }
 627                 }
 628                 else {
 629                         printf("\nError: no blend loaded. order the arguments so '-F  / --render-format' is after the blend is loaded.\n");
 630                 }
 631                 return 1;
 632         }
 633         else {
 634                 printf("\nError: you must specify a format after '-F  / --render-foramt'.\n");
 635                 return 0;
 636         }
 637 }
 638
 639 static int set_threads(int argc, const char **argv, void *UNUSED(data))
 640 {
 641         if (argc > 1) {
 642                 if (G.background) {
 643                         RE_set_max_threads(atoi(argv[1]));
 644                 }
 645                 else {
 646                         printf("Warning: threads can only be set in background mode\n");
 647                 }
 648                 return 1;
 649         }
 650         else {
 651                 printf("\nError: you must specify a number of threads between 0 and 8 '-t  / --threads'.\n");
 652                 return 0;
 653         }
 654 }
 655
 656 static int set_verbosity(int argc, const char **argv, void *UNUSED(data))
 657 {
 658         if (argc > 1) {
 659                 int level = atoi(argv[1]);
 660
 661 #ifdef WITH_LIBMV
 662                 libmv_setLoggingVerbosity(level);
 663 #else
 664                 (void)level;
 665 #endif
 666
 667                 return 1;
 668         }
 669         else {
 670                 printf("\nError: you must specify a verbosity level.\n");
 671                 return 0;
 672         }
 673 }
 674
 675 static int set_extension(int argc, const char **argv, void *data)
 676 {
 677         bContext *C = data;
 678         if (argc >= 1) {
 679                 Scene *scene = CTX_data_scene(C);
 680                 if (scene) {
 681                         if (argv[1][0] == '0') {
 682                                 scene->r.scemode &= ~R_EXTENSION;
 683                         }
 684                         else if (argv[1][0] == '1') {
 685                                 scene->r.scemode |= R_EXTENSION;
 686                         }
 687                         else {
 688                                 printf("\nError: Use '-x 1 / -x 0' To set the extension option or '--use-extension'\n");
 689                         }
 690                 }
 691                 else {
 692                         printf("\nError: no blend loaded. order the arguments so '-o ' is after '-x '.\n");
 693                 }
 694                 return 1;
 695         }
 696         else {
 697                 printf("\nError: you must specify a path after '- '.\n");
 698                 return 0;
 699         }
 700 }
 701
 702 static int set_ge_parameters(int argc, const char **argv, void *data)
 703 {
 704         int a = 0;
 705 #ifdef WITH_GAMEENGINE
 706         SYS_SystemHandle syshandle = *(SYS_SystemHandle *)data;
 707 #else
 708         (void)data;
 709 #endif
 710
 711         /**
 712          * gameengine parameters are automatically put into system
 713          * -g [paramname = value]
 714          * -g [boolparamname]
 715          * example:
 716          * -g novertexarrays
 717          * -g maxvertexarraysize = 512
 718          */
 719
 720         if (argc >= 1) {
 721                 const char *paramname = argv[a];
 722                 /* check for single value versus assignment */
 723                 if (a + 1 < argc && (*(argv[a + 1]) == '=')) {
 724                         a++;
 725                         if (a + 1 < argc) {
 726                                 a++;
 727                                 /* assignment */
 728 #ifdef WITH_GAMEENGINE
 729                                 SYS_WriteCommandLineString(syshandle, paramname, argv[a]);
 730 #endif
 731                         }
 732                         else {
 733                                 printf("error: argument assignment (%s) without value.\n", paramname);
 734                                 return 0;
 735                         }
 736                         /* name arg eaten */
 737
 738                 }
 739                 else {
 740 #ifdef WITH_GAMEENGINE
 741                         SYS_WriteCommandLineInt(syshandle, argv[a], 1);
 742 #endif
 743                         /* doMipMap */
 744                         if (!strcmp(argv[a], "nomipmap")) {
 745                                 GPU_set_mipmap(0); //doMipMap = 0;
 746                         }
 747                         /* linearMipMap */
 748                         if (!strcmp(argv[a], "linearmipmap")) {
 749                                 GPU_set_linear_mipmap(1); //linearMipMap = 1;
 750                         }
 751
 752
 753                 } /* if (*(argv[a+1]) == '=') */
 754         }
 755
 756         return a;
 757 }
 758
 759 static int render_frame(int argc, const char **argv, void *data)
 760 {
 761         bContext *C = data;
 762         Scene *scene = CTX_data_scene(C);
 763         if (scene) {
 764                 Main *bmain = CTX_data_main(C);
 765
 766                 if (argc > 1) {
 767                         Render *re = RE_NewRender(scene->id.name);
 768                         int frame;
 769                         ReportList reports;
 770
 771                         switch (*argv[1]) {
 772                                 case '+':
 773                                         frame = scene->r.sfra + atoi(argv[1] + 1);
 774                                         break;
 775                                 case '-':
 776                                         frame = (scene->r.efra - atoi(argv[1] + 1)) + 1;
 777                                         break;
 778                                 default:
 779                                         frame = atoi(argv[1]);
 780                                         break;
 781                         }
 782
 783                         BKE_reports_init(&reports, RPT_PRINT);
 784
 785                         frame = CLAMPIS(frame, MINAFRAME, MAXFRAME);
 786
 787                         RE_SetReports(re, &reports);
 788                         RE_BlenderAnim(re, bmain, scene, NULL, scene->lay, frame, frame, scene->r.frame_step);
 789                         RE_SetReports(re, NULL);
 790                         return 1;
 791                 }
 792                 else {
 793                         printf("\nError: frame number must follow '-f / --render-frame'.\n");
 794                         return 0;
 795                 }
 796         }
 797         else {
 798                 printf("\nError: no blend loaded. cannot use '-f / --render-frame'.\n");
 799                 return 0;
 800         }
 801 }
 802
 803 static int render_animation(int UNUSED(argc), const char **UNUSED(argv), void *data)
 804 {
 805         bContext *C = data;
 806         Scene *scene = CTX_data_scene(C);
 807         if (scene) {
 808                 Main *bmain = CTX_data_main(C);
 809                 Render *re = RE_NewRender(scene->id.name);
 810                 ReportList reports;
 811                 BKE_reports_init(&reports, RPT_PRINT);
 812                 RE_SetReports(re, &reports);
 813                 RE_BlenderAnim(re, bmain, scene, NULL, scene->lay, scene->r.sfra, scene->r.efra, scene->r.frame_step);
 814                 RE_SetReports(re, NULL);
 815         }
 816         else {
 817                 printf("\nError: no blend loaded. cannot use '-a'.\n");
 818         }
 819         return 0;
 820 }
 821
 822 static int set_scene(int argc, const char **argv, void *data)
 823 {
 824         if (argc > 1) {
 825                 bContext *C = data;
 826                 Scene *scene = BKE_scene_set_name(CTX_data_main(C), argv[1]);
 827                 if (scene) {
 828                         CTX_data_scene_set(C, scene);
 829                 }
 830                 return 1;
 831         }
 832         else {
 833                 printf("\nError: Scene name must follow '-S / --scene'.\n");
 834                 return 0;
 835         }
 836 }
 837
 838 static int set_start_frame(int argc, const char **argv, void *data)
 839 {
 840         bContext *C = data;
 841         Scene *scene = CTX_data_scene(C);
 842         if (scene) {
 843                 if (argc > 1) {
 844                         int frame = atoi(argv[1]);
 845                         (scene->r.sfra) = CLAMPIS(frame, MINFRAME, MAXFRAME);
 846                         return 1;
 847                 }
 848                 else {
 849                         printf("\nError: frame number must follow '-s / --frame-start'.\n");
 850                         return 0;
 851                 }
 852         }
 853         else {
 854                 printf("\nError: no blend loaded. cannot use '-s / --frame-start'.\n");
 855                 return 0;
 856         }
 857 }
 858
 859 static int set_end_frame(int argc, const char **argv, void *data)
 860 {
 861         bContext *C = data;
 862         Scene *scene = CTX_data_scene(C);
 863         if (scene) {
 864                 if (argc > 1) {
 865                         int frame = atoi(argv[1]);
 866                         (scene->r.efra) = CLAMPIS(frame, MINFRAME, MAXFRAME);
 867                         return 1;
 868                 }
 869                 else {
 870                         printf("\nError: frame number must follow '-e / --frame-end'.\n");
 871                         return 0;
 872                 }
 873         }
 874         else {
 875                 printf("\nError: no blend loaded. cannot use '-e / --frame-end'.\n");
 876                 return 0;
 877         }
 878 }
 879
 880 static int set_skip_frame(int argc, const char **argv, void *data)
 881 {
 882         bContext *C = data;
 883         Scene *scene = CTX_data_scene(C);
 884         if (scene) {
 885                 if (argc > 1) {
 886                         int frame = atoi(argv[1]);
 887                         (scene->r.frame_step) = CLAMPIS(frame, 1, MAXFRAME);
 888                         return 1;
 889                 }
 890                 else {
 891                         printf("\nError: number of frames to step must follow '-j / --frame-jump'.\n");
 892                         return 0;
 893                 }
 894         }
 895         else {
 896                 printf("\nError: no blend loaded. cannot use '-j / --frame-jump'.\n");
 897                 return 0;
 898         }
 899 }
 900
 901 /* macro for ugly context setup/reset */
 902 #ifdef WITH_PYTHON
 903 #define BPY_CTX_SETUP(_cmd)                                                   \
 904         {                                                                         \
 905                 wmWindowManager *wm = CTX_wm_manager(C);                              \
 906                 wmWindow *prevwin = CTX_wm_window(C);                                 \
 907                 Scene *prevscene = CTX_data_scene(C);                                 \
 908                 if (wm->windows.first) {                                              \
 909                         CTX_wm_window_set(C, wm->windows.first);                          \
 910                         _cmd;                                                             \
 911                         CTX_wm_window_set(C, prevwin);                                    \
 912                 }                                                                     \
 913                 else {                                                                \
 914                         fprintf(stderr, "Python script \"%s\" "                           \
 915                                 "running with missing context data.\n", argv[1]);         \
 916                         _cmd;                                                             \
 917                 }                                                                     \
 918                 CTX_data_scene_set(C, prevscene);                                     \
 919         }                                                                         \
 920
 921 #endif /* WITH_PYTHON */
 922
 923 static int run_python(int argc, const char **argv, void *data)
 924 {
 925 #ifdef WITH_PYTHON
 926         bContext *C = data;
 927
 928         /* workaround for scripts not getting a bpy.context.scene, causes internal errors elsewhere */
 929         if (argc > 1) {
 930                 /* Make the path absolute because its needed for relative linked blends to be found */
 931                 char filename[FILE_MAX];
 932                 BLI_strncpy(filename, argv[1], sizeof(filename));
 933                 BLI_path_cwd(filename);
 934
 935                 BPY_CTX_SETUP(BPY_filepath_exec(C, filename, NULL))
 936
 937                 return 1;
 938         }
 939         else {
 940                 printf("\nError: you must specify a Python script after '-P / --python'.\n");
 941                 return 0;
 942         }
 943 #else
 944         (void)argc; (void)argv; (void)data; /* unused */
 945         printf("This blender was built without python support\n");
 946         return 0;
 947 #endif /* WITH_PYTHON */
 948 }
 949
 950 static int run_python_console(int UNUSED(argc), const char **argv, void *data)
 951 {
 952 #ifdef WITH_PYTHON
 953         bContext *C = data;
 954
 955         BPY_CTX_SETUP(BPY_string_exec(C, "__import__('code').interact()"))
 956
 957         return 0;
 958 #else
 959         (void)argv; (void)data; /* unused */
 960         printf("This blender was built without python support\n");
 961         return 0;
 962 #endif /* WITH_PYTHON */
 963 }
 964
 965 static int set_addons(int argc, const char **argv, void *data)
 966 {
 967         /* workaround for scripts not getting a bpy.context.scene, causes internal errors elsewhere */
 968         if (argc > 1) {
 969 #ifdef WITH_PYTHON
 970                 const int slen = strlen(argv[1]) + 128;
 971                 char *str = malloc(slen);
 972                 bContext *C = data;
 973                 BLI_snprintf(str, slen, "[__import__('addon_utils').enable(i, default_set=False) for i in '%s'.split(',')]", argv[1]);
 974                 BPY_CTX_SETUP(BPY_string_exec(C, str));
 975                 free(str);
 976 #else
 977                 (void)argv; (void)data; /* unused */
 978 #endif /* WITH_PYTHON */
 979                 return 1;
 980         }
 981         else {
 982                 printf("\nError: you must specify a comma separated list after '--addons'.\n");
 983                 return 0;
 984         }
 985 }
 986
 987 static int load_file(int UNUSED(argc), const char **argv, void *data)
 988 {
 989         bContext *C = data;
 990
 991         /* Make the path absolute because its needed for relative linked blends to be found */
 992         char filename[FILE_MAX];
 993
 994         /* note, we could skip these, but so far we always tried to load these files */
 995         if (argv[0][0] == '-') {
 996                 fprintf(stderr, "unknown argument, loading as file: %s\n", argv[0]);
 997         }
 998
 999         BLI_strncpy(filename, argv[0], sizeof(filename));
1000         BLI_path_cwd(filename);
1001
1002         if (G.background) {
1003                 int retval = BKE_read_file(C, filename, NULL);
1004
1005                 /* we successfully loaded a blend file, get sure that
1006                  * pointcache works */
1007                 if (retval != BKE_READ_FILE_FAIL) {
1008                         wmWindowManager *wm = CTX_wm_manager(C);
1009
1010                         /* special case, 2.4x files */
1011                         if (wm == NULL && CTX_data_main(C)->wm.first == NULL) {
1012                                 extern void wm_add_default(bContext *C);
1013
1014                                 /* wm_add_default() needs the screen to be set. */
1015                                 CTX_wm_screen_set(C, CTX_data_main(C)->screen.first);
1016                                 wm_add_default(C);
1017                         }
1018
1019                         CTX_wm_manager_set(C, NULL); /* remove wm to force check */
1020                         WM_check(C);
1021                         G.relbase_valid = 1;
1022                         if (CTX_wm_manager(C) == NULL) CTX_wm_manager_set(C, wm);  /* reset wm */
1023
1024                         DAG_on_visible_update(CTX_data_main(C), TRUE);
1025                 }
1026                 else {
1027                         /* failed to load file, stop processing arguments */
1028                         return -1;
1029                 }
1030
1031                 /* WM_read_file() runs normally but since we're in background mode do here */
1032 #ifdef WITH_PYTHON
1033                 /* run any texts that were loaded in and flagged as modules */
1034                 BPY_driver_reset();
1035                 BPY_app_handlers_reset(FALSE);
1036                 BPY_modules_load_user(C);
1037 #endif
1038
1039                 /* happens for the UI on file reading too (huh? (ton))*/
1040                 // XXX          BKE_reset_undo();
1041                 //                      BKE_write_undo("original");     /* save current state */
1042         }
1043         else {
1044                 /* we are not running in background mode here, but start blender in UI mode with
1045                  * a file - this should do everything a 'load file' does */
1046                 ReportList reports;
1047                 BKE_reports_init(&reports, RPT_PRINT);
1048                 WM_read_file(C, filename, &reports);
1049                 BKE_reports_clear(&reports);
1050         }
1051
1052         G.file_loaded = 1;
1053
1054         return 0;
1055 }
1056
1057 static void setupArguments(bContext *C, bArgs *ba, SYS_SystemHandle *syshandle)
1058 {
1059         static char output_doc[] = "<path>"
1060                 "\n\tSet the render path and file name."
1061                 "\n\tUse // at the start of the path to"
1062                 "\n\t\trender relative to the blend file."
1063                 "\n\tThe # characters are replaced by the frame number, and used to define zero padding."
1064                 "\n\t\tani_##_test.png becomes ani_01_test.png"
1065                 "\n\t\ttest-######.png becomes test-000001.png"
1066                 "\n\t\tWhen the filename does not contain #, The suffix #### is added to the filename"
1067                 "\n\tThe frame number will be added at the end of the filename."
1068                 "\n\t\teg: blender -b foobar.blend -o //render_ -F PNG -x 1 -a"
1069                 "\n\t\t//render_ becomes //render_####, writing frames as //render_0001.png//";
1070
1071         static char format_doc[] = "<format>"
1072                 "\n\tSet the render format, Valid options are..."
1073                 "\n\t\tTGA IRIS JPEG MOVIE IRIZ RAWTGA"
1074                 "\n\t\tAVIRAW AVIJPEG PNG BMP FRAMESERVER"
1075                 "\n\t(formats that can be compiled into blender, not available on all systems)"
1076                 "\n\t\tHDR TIFF EXR MULTILAYER MPEG AVICODEC QUICKTIME CINEON DPX DDS";
1077
1078         static char playback_doc[] = "<options> <file(s)>"
1079                 "\n\tPlayback <file(s)>, only operates this way when not running in background."
1080                 "\n\t\t-p <sx> <sy>\tOpen with lower left corner at <sx>, <sy>"
1081                 "\n\t\t-m\t\tRead from disk (Don't buffer)"
1082                 "\n\t\t-f <fps> <fps-base>\t\tSpecify FPS to start with"
1083                 "\n\t\t-j <frame>\tSet frame step to <frame>";
1084
1085         static char game_doc[] = "Game Engine specific options"
1086                 "\n\t-g fixedtime\t\tRun on 50 hertz without dropping frames"
1087                 "\n\t-g vertexarrays\t\tUse Vertex Arrays for rendering (usually faster)"
1088                 "\n\t-g nomipmap\t\tNo Texture Mipmapping"
1089                 "\n\t-g linearmipmap\t\tLinear Texture Mipmapping instead of Nearest (default)";
1090
1091         static char debug_doc[] = "\n\tTurn debugging on\n"
1092                 "\n\t* Prints every operator call and their arguments"
1093                 "\n\t* Disables mouse grab (to interact with a debugger in some cases)"
1094                 "\n\t* Keeps python sys.stdin rather than setting it to None";
1095
1096         //BLI_argsAdd(ba, pass, short_arg, long_arg, doc, cb, C);
1097
1098         /* end argument processing after -- */
1099         BLI_argsAdd(ba, -1, "--", NULL, "\n\tEnds option processing, following arguments passed unchanged. Access via python's sys.argv", end_arguments, NULL);
1100
1101         /* first pass: background mode, disable python and commands that exit after usage */
1102         BLI_argsAdd(ba, 1, "-h", "--help", "\n\tPrint this help text and exit", print_help, ba);
1103         /* Windows only */
1104         BLI_argsAdd(ba, 1, "/?", NULL, "\n\tPrint this help text and exit (windows only)", print_help, ba);
1105
1106         BLI_argsAdd(ba, 1, "-v", "--version", "\n\tPrint Blender version and exit", print_version, NULL);
1107
1108         /* only to give help message */
1109 #ifndef WITH_PYTHON_SECURITY /* default */
1110 #  define   PY_ENABLE_AUTO ", (default)"
1111 #  define   PY_DISABLE_AUTO ""
1112 #else
1113 #  define   PY_ENABLE_AUTO ""
1114 #  define   PY_DISABLE_AUTO ", (compiled as non-standard default)"
1115 #endif
1116
1117         BLI_argsAdd(ba, 1, "-y", "--enable-autoexec", "\n\tEnable automatic python script execution" PY_ENABLE_AUTO, enable_python, NULL);
1118         BLI_argsAdd(ba, 1, "-Y", "--disable-autoexec", "\n\tDisable automatic python script execution (pydrivers & startup scripts)" PY_DISABLE_AUTO, disable_python, NULL);
1119
1120 #undef PY_ENABLE_AUTO
1121 #undef PY_DISABLE_AUTO
1122
1123         BLI_argsAdd(ba, 1, "-b", "--background", "<file>\n\tLoad <file> in background (often used for UI-less rendering)", background_mode, NULL);
1124
1125         BLI_argsAdd(ba, 1, "-a", NULL, playback_doc, playback_mode, NULL);
1126
1127         BLI_argsAdd(ba, 1, "-d", "--debug", debug_doc, debug_mode, ba);
1128
1129 #ifdef WITH_FFMPEG
1130         BLI_argsAdd(ba, 1, NULL, "--debug-ffmpeg", "\n\tEnable debug messages from FFmpeg library", debug_mode_generic, (void *)G_DEBUG_FFMPEG);
1131 #endif
1132         BLI_argsAdd(ba, 1, NULL, "--debug-python", "\n\tEnable debug messages for python", debug_mode_generic, (void *)G_DEBUG_PYTHON);
1133         BLI_argsAdd(ba, 1, NULL, "--debug-events", "\n\tEnable debug messages for the event system", debug_mode_generic, (void *)G_DEBUG_EVENTS);
1134         BLI_argsAdd(ba, 1, NULL, "--debug-wm",     "\n\tEnable debug messages for the window manager", debug_mode_generic, (void *)G_DEBUG_WM);
1135         BLI_argsAdd(ba, 1, NULL, "--debug-all",    "\n\tEnable all debug messages (excludes libmv)", debug_mode_generic, (void *)G_DEBUG_ALL);
1136
1137         BLI_argsAdd(ba, 1, NULL, "--debug-fpe", "\n\tEnable floating point exceptions", set_fpe, NULL);
1138
1139 #ifdef WITH_LIBMV
1140         BLI_argsAdd(ba, 1, NULL, "--debug-libmv", "\n\tEnable debug messages from libmv library", debug_mode_libmv, NULL);
1141 #endif
1142
1143         BLI_argsAdd(ba, 1, NULL, "--debug-value", "<value>\n\tSet debug value of <value> on startup\n", set_debug_value, NULL);
1144         BLI_argsAdd(ba, 1, NULL, "--debug-jobs",  "\n\tEnable time profiling for background jobs.", debug_mode_generic, (void *)G_DEBUG_JOBS);
1145
1146         BLI_argsAdd(ba, 1, NULL, "--verbose", "<verbose>\n\tSet logging verbosity level.", set_verbosity, NULL);
1147
1148         BLI_argsAdd(ba, 1, NULL, "--factory-startup", "\n\tSkip reading the "STRINGIFY (BLENDER_STARTUP_FILE)" in the users home directory", set_factory_startup, NULL);
1149
1150         /* TODO, add user env vars? */
1151         BLI_argsAdd(ba, 1, NULL, "--env-system-datafiles",  "\n\tSet the "STRINGIFY_ARG (BLENDER_SYSTEM_DATAFILES)" environment variable", set_env, NULL);
1152         BLI_argsAdd(ba, 1, NULL, "--env-system-scripts",    "\n\tSet the "STRINGIFY_ARG (BLENDER_SYSTEM_SCRIPTS)" environment variable", set_env, NULL);
1153         BLI_argsAdd(ba, 1, NULL, "--env-system-python",     "\n\tSet the "STRINGIFY_ARG (BLENDER_SYSTEM_PYTHON)" environment variable", set_env, NULL);
1154
1155         /* second pass: custom window stuff */
1156         BLI_argsAdd(ba, 2, "-p", "--window-geometry", "<sx> <sy> <w> <h>\n\tOpen with lower left corner at <sx>, <sy> and width and height as <w>, <h>", prefsize, NULL);
1157         BLI_argsAdd(ba, 2, "-w", "--window-border", "\n\tForce opening with borders (default)", with_borders, NULL);
1158         BLI_argsAdd(ba, 2, "-W", "--window-borderless", "\n\tForce opening without borders", without_borders, NULL);
1159         BLI_argsAdd(ba, 2, "-con", "--start-console", "\n\tStart with the console window open (ignored if -b is set)", start_with_console, NULL);
1160         BLI_argsAdd(ba, 2, "-R", NULL, "\n\tRegister .blend extension, then exit (Windows only)", register_extension, NULL);
1161         BLI_argsAdd(ba, 2, "-r", NULL, "\n\tSilently register .blend extension, then exit (Windows only)", register_extension, ba);
1162
1163         /* third pass: disabling things and forcing settings */
1164         BLI_argsAddCase(ba, 3, "-nojoystick", 1, NULL, 0, "\n\tDisable joystick support", no_joystick, syshandle);
1165         BLI_argsAddCase(ba, 3, "-noglsl", 1, NULL, 0, "\n\tDisable GLSL shading", no_glsl, NULL);
1166         BLI_argsAddCase(ba, 3, "-noaudio", 1, NULL, 0, "\n\tForce sound system to None", no_audio, NULL);
1167         BLI_argsAddCase(ba, 3, "-setaudio", 1, NULL, 0, "\n\tForce sound system to a specific device\n\tNULL SDL OPENAL JACK", set_audio, NULL);
1168
1169         /* fourth pass: processing arguments */
1170         BLI_argsAdd(ba, 4, "-g", NULL, game_doc, set_ge_parameters, syshandle);
1171         BLI_argsAdd(ba, 4, "-f", "--render-frame", "<frame>\n\tRender frame <frame> and save it.\n\t+<frame> start frame relative, -<frame> end frame relative.", render_frame, C);
1172         BLI_argsAdd(ba, 4, "-a", "--render-anim", "\n\tRender frames from start to end (inclusive)", render_animation, C);
1173         BLI_argsAdd(ba, 4, "-S", "--scene", "<name>\n\tSet the active scene <name> for rendering", set_scene, C);
1174         BLI_argsAdd(ba, 4, "-s", "--frame-start", "<frame>\n\tSet start to frame <frame> (use before the -a argument)", set_start_frame, C);
1175         BLI_argsAdd(ba, 4, "-e", "--frame-end", "<frame>\n\tSet end to frame <frame> (use before the -a argument)", set_end_frame, C);
1176         BLI_argsAdd(ba, 4, "-j", "--frame-jump", "<frames>\n\tSet number of frames to step forward after each rendered frame", set_skip_frame, C);
1177         BLI_argsAdd(ba, 4, "-P", "--python", "<filename>\n\tRun the given Python script (filename or Blender Text)", run_python, C);
1178         BLI_argsAdd(ba, 4, NULL, "--python-console", "\n\tRun blender with an interactive console", run_python_console, C);
1179         BLI_argsAdd(ba, 4, NULL, "--addons", "\n\tComma separated list of addons (no spaces)", set_addons, C);
1180
1181         BLI_argsAdd(ba, 4, "-o", "--render-output", output_doc, set_output, C);
1182         BLI_argsAdd(ba, 4, "-E", "--engine", "<engine>\n\tSpecify the render engine\n\tuse -E help to list available engines", set_engine, C);
1183
1184         BLI_argsAdd(ba, 4, "-F", "--render-format", format_doc, set_image_type, C);
1185         BLI_argsAdd(ba, 4, "-t", "--threads", "<threads>\n\tUse amount of <threads> for rendering in background\n\t[1-" STRINGIFY(BLENDER_MAX_THREADS) "], 0 for systems processor count.", set_threads, NULL);
1186         BLI_argsAdd(ba, 4, "-x", "--use-extension", "<bool>\n\tSet option to add the file extension to the end of the file", set_extension, C);
1187
1188 }
1189 #endif /* WITH_PYTHON_MODULE */
1190
1191 #ifdef WITH_PYTHON_MODULE
1192 /* allow python module to call main */
1193 #  define main main_python_enter
1194 static void *evil_C = NULL;
1195
1196 #  ifdef __APPLE__
1197      /* environ is not available in mac shared libraries */
1198 #    include <crt_externs.h>
1199 char **environ = NULL;
1200 #  endif
1201 #endif
1202
1203
1204 #ifdef WIN32
1205 int main(int argc, const char **UNUSED(argv_c)) /* Do not mess with const */
1206 #else
1207 int main(int argc, const char **argv)
1208 #endif
1209 {
1210         bContext *C = CTX_create();
1211         SYS_SystemHandle syshandle;
1212
1213 #ifndef WITH_PYTHON_MODULE
1214         bArgs *ba;
1215 #endif
1216
1217 #ifdef WIN32
1218         wchar_t **argv_16 = CommandLineToArgvW(GetCommandLineW(), &argc);
1219         int argci = 0;
1220         char **argv = MEM_mallocN(argc * sizeof(char *), "argv array");
1221         for (argci = 0; argci < argc; argci++) {
1222                 argv[argci] = alloc_utf_8_from_16(argv_16[argci], 0);
1223         }
1224         LocalFree(argv_16);
1225 #endif
1226
1227 #ifdef WITH_PYTHON_MODULE
1228 #ifdef __APPLE__
1229         environ = *_NSGetEnviron();
1230 #endif
1231
1232 #undef main
1233         evil_C = C;
1234 #endif
1235
1236
1237
1238 #ifdef WITH_BINRELOC
1239         br_init(NULL);
1240 #endif
1241
1242 #ifdef WITH_LIBMV
1243         libmv_initLogging(argv[0]);
1244 #endif
1245
1246         setCallbacks();
1247 #if defined(__APPLE__) && !defined(WITH_PYTHON_MODULE)
1248         /* patch to ignore argument finder gives us (pid?) */
1249         if (argc == 2 && strncmp(argv[1], "-psn_", 5) == 0) {
1250                 extern int GHOST_HACK_getFirstFile(char buf[]);
1251                 static char firstfilebuf[512];
1252
1253                 argc = 1;
1254
1255                 if (GHOST_HACK_getFirstFile(firstfilebuf)) {
1256                         argc = 2;
1257                         argv[1] = firstfilebuf;
1258                 }
1259         }
1260
1261 #endif
1262
1263 #ifdef __FreeBSD__
1264         fpsetmask(0);
1265 #endif
1266
1267         /* initialize path to executable */
1268         BLI_init_program_path(argv[0]);
1269
1270         BLI_threadapi_init();
1271
1272         RNA_init();
1273         RE_engines_init();
1274
1275         init_nodesystem();
1276
1277         initglobals();  /* blender.c */
1278
1279         IMB_init();
1280
1281         BLI_callback_global_init();
1282
1283 #ifdef WITH_GAMEENGINE
1284         syshandle = SYS_GetSystem();
1285 #else
1286         syshandle = 0;
1287 #endif
1288
1289         /* first test for background */
1290 #ifndef WITH_PYTHON_MODULE
1291         ba = BLI_argsInit(argc, (const char **)argv); /* skip binary path */
1292         setupArguments(C, ba, &syshandle);
1293
1294         BLI_argsParse(ba, 1, NULL, NULL);
1295 #endif
1296
1297 #if defined(WITH_PYTHON_MODULE) || defined(WITH_HEADLESS)
1298         G.background = 1; /* python module mode ALWAYS runs in background mode (for now) */
1299 #else
1300         /* for all platforms, even windos has it! */
1301         if (G.background) signal(SIGINT, blender_esc);  /* ctrl c out bg render */
1302 #endif
1303
1304         /* background render uses this font too */
1305         BKE_vfont_builtin_register(datatoc_Bfont, datatoc_Bfont_size);
1306
1307         /* Initialize ffmpeg if built in, also needed for bg mode if videos are
1308          * rendered via ffmpeg */
1309         sound_init_once();
1310
1311         init_def_material();
1312
1313         if (G.background == 0) {
1314 #ifndef WITH_PYTHON_MODULE
1315                 BLI_argsParse(ba, 2, NULL, NULL);
1316                 BLI_argsParse(ba, 3, NULL, NULL);
1317 #endif
1318                 WM_init(C, argc, (const char **)argv);
1319
1320                 /* this is properly initialized with user defs, but this is default */
1321                 /* call after loading the startup.blend so we can read U.tempdir */
1322                 BLI_init_temporary_dir(U.tempdir);
1323
1324 #ifdef WITH_SDL
1325                 BLI_setenv("SDL_VIDEODRIVER", "dummy");
1326 #endif
1327         }
1328         else {
1329 #ifndef WITH_PYTHON_MODULE
1330                 BLI_argsParse(ba, 3, NULL, NULL);
1331 #endif
1332
1333                 WM_init(C, argc, (const char **)argv);
1334
1335                 /* don't use user preferences temp dir */
1336                 BLI_init_temporary_dir(NULL);
1337         }
1338 #ifdef WITH_PYTHON
1339         /**
1340          * NOTE: the U.pythondir string is NULL until WM_init() is executed,
1341          * so we provide the BPY_ function below to append the user defined
1342          * python-dir to Python's sys.path at this point.  Simply putting
1343          * WM_init() before #BPY_python_start() crashes Blender at startup.
1344          */
1345
1346         // TODO - U.pythondir
1347 #else
1348         printf("\n* WARNING * - Blender compiled without Python!\nthis is not intended for typical usage\n\n");
1349 #endif
1350
1351         CTX_py_init_set(C, 1);
1352         WM_keymap_init(C);
1353
1354         /* OK we are ready for it */
1355 #ifndef WITH_PYTHON_MODULE
1356         BLI_argsParse(ba, 4, load_file, C);
1357 #endif
1358
1359 #ifndef WITH_PYTHON_MODULE
1360         BLI_argsFree(ba);
1361 #endif
1362
1363 #ifdef WIN32
1364         while (argci) {
1365                 free(argv[--argci]);
1366         }
1367         MEM_freeN(argv);
1368         argv = NULL;
1369 #endif
1370
1371 #ifdef WITH_PYTHON_MODULE
1372         return 0; /* keep blender in background mode running */
1373 #endif
1374
1375         if (G.background) {
1376                 /* actually incorrect, but works for now (ton) */
1377                 WM_exit(C);
1378         }
1379         else {
1380                 if ((G.fileflags & G_FILE_AUTOPLAY) && (G.f & G_SCRIPT_AUTOEXEC)) {
1381                         if (WM_init_game(C))
1382                                 return 0;
1383                 }
1384                 else if (!G.file_loaded) {
1385                         WM_init_splash(C);
1386                 }
1387         }
1388
1389         WM_main(C);
1390
1391         return 0;
1392 } /* end of int main(argc,argv) */
1393
1394 #ifdef WITH_PYTHON_MODULE
1395 void main_python_exit(void)
1396 {
1397         WM_exit((bContext *)evil_C);
1398         evil_C = NULL;
1399 }
1400 #endif
1401
1402 static void error_cb(const char *err)
1403 {
1404
1405         printf("%s\n", err);    /* XXX do this in WM too */
1406 }
1407
1408 static void mem_error_cb(const char *errorStr)
1409 {
1410         fputs(errorStr, stderr);
1411         fflush(stderr);
1412 }
1413
1414 static void setCallbacks(void)
1415 {
1416         /* Error output from the alloc routines: */
1417         MEM_set_error_callback(mem_error_cb);
1418
1419
1420         /* BLI_blenlib: */
1421
1422         BLI_setErrorCallBack(error_cb); /* */
1423 // XXX  BLI_setInterruptCallBack(blender_test_break);
1424
1425 }