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 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #ifdef WIN32
  36 #  if defined(_MSC_VER) && defined(_M_X64)
  37 #    include <math.h> /* needed for _set_FMA3_enable */
  38 #  endif
  39 #  include <windows.h>
  40 #  include "utfconv.h"
  41 #endif
  42
  43 #include "MEM_guardedalloc.h"
  44
  45 #ifdef WIN32
  46 #  include "BLI_winstuff.h"
  47 #endif
  48
  49 #include "BLI_args.h"
  50 #include "BLI_threads.h"
  51 #include "BLI_utildefines.h"
  52 #include "BLI_callbacks.h"
  53 #include "BLI_string.h"
  54
  55 /* mostly init functions */
  56 #include "BKE_appdir.h"
  57 #include "BKE_blender.h"
  58 #include "BKE_brush.h"
  59 #include "BKE_context.h"
  60 #include "BKE_depsgraph.h" /* for DAG_init */
  61 #include "BKE_font.h"
  62 #include "BKE_global.h"
  63 #include "BKE_material.h"
  64 #include "BKE_modifier.h"
  65 #include "BKE_node.h"
  66 #include "BKE_sound.h"
  67 #include "BKE_image.h"
  68 #include "BKE_particle.h"
  69
  70
  71 #include "IMB_imbuf.h"  /* for IMB_init */
  72
  73 #include "RE_engine.h"
  74 #include "RE_render_ext.h"
  75
  76 #include "ED_datafiles.h"
  77
  78 #include "WM_api.h"
  79
  80 #include "RNA_define.h"
  81
  82 #ifdef WITH_FREESTYLE
  83 #  include "FRS_freestyle.h"
  84 #endif
  85
  86 /* for passing information between creator and gameengine */
  87 #ifdef WITH_GAMEENGINE
  88 #  include "BL_System.h"
  89 #else /* dummy */
  90 #  define SYS_SystemHandle int
  91 #endif
  92
  93 #include <signal.h>
  94
  95 #ifdef __FreeBSD__
  96 #  include <floatingpoint.h>
  97 #endif
  98
  99 #ifdef WITH_BINRELOC
 100 #  include "binreloc.h"
 101 #endif
 102
 103 #ifdef WITH_LIBMV
 104 #  include "libmv-capi.h"
 105 #endif
 106
 107 #ifdef WITH_CYCLES_LOGGING
 108 #  include "CCL_api.h"
 109 #endif
 110
 111 #ifdef WITH_SDL_DYNLOAD
 112 #  include "sdlew.h"
 113 #endif
 114
 115 #include "creator_intern.h"  /* own include */
 116
 117
 118 /*      Local Function prototypes */
 119 #ifdef WITH_PYTHON_MODULE
 120 int  main_python_enter(int argc, const char **argv);
 121 void main_python_exit(void);
 122 #endif
 123
 124 /* written to by 'creator_args.c' */
 125 struct ApplicationState app_state = {
 126         .signal = {
 127                 .use_crash_handler = true,
 128                 .use_abort_handler = true,
 129         },
 130         .exit_code_on_error = {
 131                 .python = 0,
 132         }
 133 };
 134
 135 /* -------------------------------------------------------------------- */
 136
 137 /** \name Application Level Callbacks
 138  *
 139  * Initialize callbacks for the modules that need them.
 140  *
 141  * \{ */
 142
 143 static void callback_mem_error(const char *errorStr)
 144 {
 145         fputs(errorStr, stderr);
 146         fflush(stderr);
 147 }
 148
 149 static void main_callback_setup(void)
 150 {
 151         /* Error output from the alloc routines: */
 152         MEM_set_error_callback(callback_mem_error);
 153 }
 154
 155 /** \} */
 156
 157
 158
 159 /* -------------------------------------------------------------------- */
 160
 161 /** \name Main Function
 162  * \{ */
 163
 164 #ifdef WITH_PYTHON_MODULE
 165 /* allow python module to call main */
 166 #  define main main_python_enter
 167 static void *evil_C = NULL;
 168
 169 #  ifdef __APPLE__
 170      /* environ is not available in mac shared libraries */
 171 #    include <crt_externs.h>
 172 char **environ = NULL;
 173 #  endif
 174 #endif
 175
 176 /**
 177  * Blender's main function responsibilities are:
 178  * - setup subsystems.
 179  * - handle arguments.
 180  * - run #WM_main() event loop,
 181  *   or exit immediately when running in background mode.
 182  */
 183 int main(
 184         int argc,
 185 #ifdef WIN32
 186         const char **UNUSED(argv_c)
 187 #else
 188         const char **argv
 189 #endif
 190         )
 191 {
 192         bContext *C;
 193         SYS_SystemHandle syshandle;
 194
 195 #ifndef WITH_PYTHON_MODULE
 196         bArgs *ba;
 197 #endif
 198
 199 #ifdef WIN32
 200         char **argv;
 201         int argv_num;
 202 #endif
 203
 204         /* --- end declarations --- */
 205
 206
 207 #ifdef WIN32
 208         /* FMA3 support in the 2013 CRT is broken on Vista and Windows 7 RTM (fixed in SP1). Just disable it. */
 209 #  if defined(_MSC_VER) && defined(_M_X64)
 210         _set_FMA3_enable(0);
 211 #  endif
 212
 213         /* Win32 Unicode Args */
 214         /* NOTE: cannot use guardedalloc malloc here, as it's not yet initialized
 215          *       (it depends on the args passed in, which is what we're getting here!)
 216          */
 217         {
 218                 wchar_t **argv_16 = CommandLineToArgvW(GetCommandLineW(), &argc);
 219                 argv = malloc(argc * sizeof(char *));
 220                 for (argv_num = 0; argv_num < argc; argv_num++) {
 221                         argv[argv_num] = alloc_utf_8_from_16(argv_16[argv_num], 0);
 222                 }
 223                 LocalFree(argv_16);
 224         }
 225 #endif  /* WIN32 */
 226
 227         /* NOTE: Special exception for guarded allocator type switch:
 228          *       we need to perform switch from lock-free to fully
 229          *       guarded allocator before any allocation happened.
 230          */
 231         {
 232                 int i;
 233                 for (i = 0; i < argc; i++) {
 234                         if (STREQ(argv[i], "--debug") || STREQ(argv[i], "-d") ||
 235                             STREQ(argv[i], "--debug-memory") || STREQ(argv[i], "--debug-all"))
 236                         {
 237                                 printf("Switching to fully guarded memory allocator.\n");
 238                                 MEM_use_guarded_allocator();
 239                                 break;
 240                         }
 241                         else if (STREQ(argv[i], "--")) {
 242                                 break;
 243                         }
 244                 }
 245         }
 246
 247 #ifdef BUILD_DATE
 248         {
 249                 time_t temp_time = build_commit_timestamp;
 250                 struct tm *tm = gmtime(&temp_time);
 251                 if (LIKELY(tm)) {
 252                         strftime(build_commit_date, sizeof(build_commit_date), "%Y-%m-%d", tm);
 253                         strftime(build_commit_time, sizeof(build_commit_time), "%H:%M", tm);
 254                 }
 255                 else {
 256                         const char *unknown = "date-unknown";
 257                         BLI_strncpy(build_commit_date, unknown, sizeof(build_commit_date));
 258                         BLI_strncpy(build_commit_time, unknown, sizeof(build_commit_time));
 259                 }
 260         }
 261 #endif
 262
 263 #ifdef WITH_SDL_DYNLOAD
 264         sdlewInit();
 265 #endif
 266
 267         C = CTX_create();
 268
 269 #ifdef WITH_PYTHON_MODULE
 270 #ifdef __APPLE__
 271         environ = *_NSGetEnviron();
 272 #endif
 273
 274 #undef main
 275         evil_C = C;
 276 #endif
 277
 278
 279
 280 #ifdef WITH_BINRELOC
 281         br_init(NULL);
 282 #endif
 283
 284 #ifdef WITH_LIBMV
 285         libmv_initLogging(argv[0]);
 286 #elif defined(WITH_CYCLES_LOGGING)
 287         CCL_init_logging(argv[0]);
 288 #endif
 289
 290         main_callback_setup();
 291
 292 #if defined(__APPLE__) && !defined(WITH_PYTHON_MODULE)
 293         /* patch to ignore argument finder gives us (pid?) */
 294         if (argc == 2 && STREQLEN(argv[1], "-psn_", 5)) {
 295                 extern int GHOST_HACK_getFirstFile(char buf[]);
 296                 static char firstfilebuf[512];
 297
 298                 argc = 1;
 299
 300                 if (GHOST_HACK_getFirstFile(firstfilebuf)) {
 301                         argc = 2;
 302                         argv[1] = firstfilebuf;
 303                 }
 304         }
 305 #endif
 306
 307 #ifdef __FreeBSD__
 308         fpsetmask(0);
 309 #endif
 310
 311         /* initialize path to executable */
 312         BKE_appdir_program_path_init(argv[0]);
 313
 314         BLI_threadapi_init();
 315
 316         initglobals();  /* blender.c */
 317
 318         IMB_init();
 319         BKE_images_init();
 320         BKE_modifier_init();
 321         DAG_init();
 322
 323         BKE_brush_system_init();
 324         RE_texture_rng_init();
 325
 326
 327         BLI_callback_global_init();
 328
 329 #ifdef WITH_GAMEENGINE
 330         syshandle = SYS_GetSystem();
 331 #else
 332         syshandle = 0;
 333 #endif
 334
 335         /* first test for background */
 336 #ifndef WITH_PYTHON_MODULE
 337         ba = BLI_argsInit(argc, (const char **)argv); /* skip binary path */
 338         main_args_setup(C, ba, &syshandle);
 339
 340         BLI_argsParse(ba, 1, NULL, NULL);
 341
 342         main_signal_setup();
 343
 344 #else
 345         G.factory_startup = true;  /* using preferences or user startup makes no sense for py-as-module */
 346         (void)syshandle;
 347 #endif
 348
 349 #ifdef WITH_FFMPEG
 350         IMB_ffmpeg_init();
 351 #endif
 352
 353         /* after level 1 args, this is so playanim skips RNA init */
 354         RNA_init();
 355
 356         RE_engines_init();
 357         init_nodesystem();
 358         psys_init_rng();
 359         /* end second init */
 360
 361
 362 #if defined(WITH_PYTHON_MODULE) || defined(WITH_HEADLESS)
 363         G.background = true; /* python module mode ALWAYS runs in background mode (for now) */
 364 #else
 365         if (G.background) {
 366                 main_signal_setup_background();
 367         }
 368 #endif
 369
 370         /* background render uses this font too */
 371         BKE_vfont_builtin_register(datatoc_bfont_pfb, datatoc_bfont_pfb_size);
 372
 373         /* Initialize ffmpeg if built in, also needed for bg mode if videos are
 374          * rendered via ffmpeg */
 375         BKE_sound_init_once();
 376
 377         init_def_material();
 378
 379         if (G.background == 0) {
 380 #ifndef WITH_PYTHON_MODULE
 381                 BLI_argsParse(ba, 2, NULL, NULL);
 382                 BLI_argsParse(ba, 3, NULL, NULL);
 383 #endif
 384                 WM_init(C, argc, (const char **)argv);
 385
 386                 /* this is properly initialized with user defs, but this is default */
 387                 /* call after loading the startup.blend so we can read U.tempdir */
 388                 BKE_tempdir_init(U.tempdir);
 389         }
 390         else {
 391 #ifndef WITH_PYTHON_MODULE
 392                 BLI_argsParse(ba, 3, NULL, NULL);
 393 #endif
 394
 395                 WM_init(C, argc, (const char **)argv);
 396
 397                 /* don't use user preferences temp dir */
 398                 BKE_tempdir_init(NULL);
 399         }
 400 #ifdef WITH_PYTHON
 401         /**
 402          * NOTE: the U.pythondir string is NULL until WM_init() is executed,
 403          * so we provide the BPY_ function below to append the user defined
 404          * python-dir to Python's sys.path at this point.  Simply putting
 405          * WM_init() before #BPY_python_start() crashes Blender at startup.
 406          */
 407
 408         /* TODO - U.pythondir */
 409 #else
 410         printf("\n* WARNING * - Blender compiled without Python!\nthis is not intended for typical usage\n\n");
 411 #endif
 412
 413         CTX_py_init_set(C, 1);
 414         WM_keymap_init(C);
 415
 416 #ifdef WITH_FREESTYLE
 417         /* initialize Freestyle */
 418         FRS_initialize();
 419         FRS_set_context(C);
 420 #endif
 421
 422         /* OK we are ready for it */
 423 #ifndef WITH_PYTHON_MODULE
 424         main_args_setup_post(C, ba);
 425
 426         if (G.background == 0) {
 427                 if (!G.file_loaded)
 428                         if (U.uiflag2 & USER_KEEP_SESSION)
 429                                 WM_recover_last_session(C, NULL);
 430         }
 431
 432 #endif
 433
 434 #ifndef WITH_PYTHON_MODULE
 435         BLI_argsFree(ba);
 436 #endif
 437
 438 #ifdef WIN32
 439         while (argv_num) {
 440                 free(argv[--argv_num]);
 441         }
 442         free(argv);
 443         argv = NULL;
 444 #endif
 445
 446 #ifdef WITH_PYTHON_MODULE
 447         return 0; /* keep blender in background mode running */
 448 #endif
 449
 450         if (G.background) {
 451                 /* Using window-manager API in background mode is a bit odd, but works fine. */
 452                 WM_exit(C);
 453         }
 454         else {
 455                 if (G.fileflags & G_FILE_AUTOPLAY) {
 456                         if (G.f & G_SCRIPT_AUTOEXEC) {
 457                                 if (WM_init_game(C)) {
 458                                         return 0;
 459                                 }
 460                         }
 461                         else {
 462                                 if (!(G.f & G_SCRIPT_AUTOEXEC_FAIL_QUIET)) {
 463                                         G.f |= G_SCRIPT_AUTOEXEC_FAIL;
 464                                         BLI_snprintf(G.autoexec_fail, sizeof(G.autoexec_fail), "Game AutoStart");
 465                                 }
 466                         }
 467                 }
 468
 469                 if (!G.file_loaded) {
 470                         WM_init_splash(C);
 471                 }
 472         }
 473
 474         WM_main(C);
 475
 476         return 0;
 477 } /* end of int main(argc, argv)        */
 478
 479 #ifdef WITH_PYTHON_MODULE
 480 void main_python_exit(void)
 481 {
 482         WM_exit_ext((bContext *)evil_C, true);
 483         evil_C = NULL;
 484 }
 485 #endif
 486
 487 /** \} */