---

o_omicron.cpp

Go to the documentation of this file.

// OMICRON ENGINE HEADER FILE
//
// --------------------------------------------------------------------------
// Copyright (C) 2001-2002 by Bjoern Paetzel <kolrabi@gmx.de>
//
// This file is part of the Omicron Engine.
//
// The Omicron Engine is free software; you can redistribute it and/or modify
// it under the terms of the  GNU General Public License  as published by the
// Free Software Foundation;  either version  2  of the License,  or (at your
// option) any later version.
//
// The Omicron Engine  is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or  FITNESS FOR A PARTICULAR PURPOSE.  See the  GNU General Public License
// for more details.
//
// You should have  received a copy of the  GNU General Public License  along
// with The Omicron Engine;  if not,  write to the  Free Software Foundation,
// Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
//
// --------------------------------------------------------------------------
// Last modified:       $Date: 2002/12/13 12:29:26 $
// By           :       $Author: kolrabi $
// $Id: o_omicron.cpp,v 1.4 2002/12/13 12:29:26 kolrabi Exp $ 

/*

  $Log: o_omicron.cpp,v $
  Revision 1.4  2002/12/13 12:29:26  kolrabi
  fixed some bugs

  Revision 1.3  2002/12/12 13:13:39  kolrabi
  made the fullscreen work under X11

  Revision 1.2  2002/12/11 16:35:43  kolrabi
  sound is now part of the engine

  Revision 1.1.1.1  2002/12/07 19:02:05  kolrabi
  initial release


*/

#include        <string>
#include        <signal.h>
 
#include        "omicron/internal.h" 
#include        "omicron/render.h"
#include        "omicron/texture.h"
#include        "omicron/gui.h" 
#include        "omicron/file.h"
#include        "omicron/net.h"
#include        "omicron/sound.h"
 
/**************************************************************************** 
 **************************************************************************** 
 * VARIABLES **************************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
gvar_t              gv;
ulong               assertions = 0;


/**************************************************************************** 
 **************************************************************************** 
 * MAIN ROUTINES ************************************************************ 
 **************************************************************************** 
 ****************************************************************************/ 
 
/**************************************************************************** 
 * _process_cmd_line                        processes command line switches * 
 ****************************************************************************/ 
static void _process_cmd_line 
( 
    ulong       argc, 
    char        *argv[] 
) 
{ 
    gv.init.argc = argc; 
    gv.init.argv = argv; 
 
    if (argc<2) 
      return; 
 
//    ulong       cmdlinelen  = argc; 
    char        *p          = NULL; 
    std::string      cmd;
    ulong       i; 

    _log_printf(MSG_DEBUG, "processing command line parameters:");

    for (i=1; i<argc; i++) 
        cmd += argv[i];

    _log_printf(MSG_DEBUG, "cmd: %s", cmd.c_str());
 
    if (NULL!=(p = strstr(cmd.c_str(), "-w")))
    {
        gv.init.fullscreen = false; 
        _log_printf(MSG_DEBUG, "  using windowed mode");
    }
 
    if (NULL!=(p = strstr(cmd.c_str(), "-s"))) 
    {
        gv.init.nosound = 1; 
        _log_printf(MSG_DEBUG, "  silent mode (no sound)");
    }
 
    if (NULL!=(p = strstr(cmd.c_str(), "-x"))) 
    { 
        gv.init.hres = atoi(p+2); 
        if (gv.init.hres<320) 
            gv.init.hres = 320; 

        _log_printf(MSG_DEBUG, "  resolution x = %u",gv.init.hres);
    } 
 
    if (NULL!=(p = strstr(cmd.c_str(), "-y")))
    { 
        gv.init.vres = atoi(p+2); 
        if (gv.init.vres<200) 
            gv.init.vres = 200; 

        _log_printf(MSG_DEBUG, "  resolution y = %u",gv.init.vres);
    } 
 
    if (NULL!=(p = strstr(cmd.c_str(), "-b")))
    {
        gv.init.bpp = atoi(p+2); 
        _log_printf(MSG_DEBUG, "  color depth : %u bits",gv.init.bpp);
    }
 
    if (NULL!=(p = strstr(cmd.c_str(), "-d")))
    { 
        gv.debuglevel = atoi(p+2); 
        _log_printf(MSG_DEBUG, "  debug level : %d", gv.debuglevel);
    } 

    _log_printf(MSG_DEBUG, "  debug level : %d", gv.debuglevel);
} 
 
 
 
/**************************************************************************** 
 * _init                                                     initialization * 
 ****************************************************************************/ 
static ulong _init() 
{
    new file_manager_c;
    new net_manager_c;
 
    init_vars(); 

    // say hello 
    _log_printf(MSG_NORMAL, "******************************** -"); 
    _log_printf(MSG_NORMAL, "*        OMICRON ENGINE        * -"); 
    _log_printf(MSG_NORMAL, "******************************** -\n\n"); 
 
    _log_printf(MSG_NORMAL, OMICRON_VERSION); 
 
//    _showmem(false); 
 
    _log_printf(MSG_NORMAL, "Omicron engine starting up.."); 
 
    _log_printf(MSG_DEBUG, "Global variables (gv) take %u bytes", sizeof(gv)); 

    _process_cmd_line(gv.init.argc, gv.init.argv); 
    
    if (!gv.init.wnd) 
    if (!_win_init(gv.init.hres, gv.init.vres,  
#if defined(WIN32) 
        gv.init.hInstance,  
#endif            /* end windows specific ***********************************/ 
        gv.init.fullscreen )) 
        return 0; 

    srand(_time_get()); 

#if defined(WIN32) 
 
    ShowWindow((HWND)gv.init.wnd, SW_SHOW); 
 
#else             /* end windows specific ***********************************/ 
 
    XMapWindow(gv.init.dpy, gv.init.wnd); 
 
#endif            /* end other's specific ***********************************/ 
 
    if (!gv.init.nogfx) 
    { 
        if (!_gfx_init( gv.init.hres, gv.init.vres, gv.init.fullscreen )) 
            return 0; 
 
        // create new renderer
        new renderer_c;

        if (!gv.renderer)
            return 0;

// let the user decide to use or not to use the gui
//        new gui_c;
    } 

    if (!gv.init.noinput) 
          _input_init(); 
 
    if (!gv.init.nosound) 
        new sound_manager_c; 
 
    gv.time   = 0;
    gv.dtime  = 0;
 
    if (gv.iface)
        gv.iface->init(); 

    gv.active = 1;
 
    return 1; 
} 
 
 
/**************************************************************************** 
 * _deinit                                                 deinitialization * 
 ****************************************************************************/ 
void _deinit() 
{ 
    _log_printf(MSG_DEBUG, "_deinit()");
    
    if (gv.iface)
        gv.iface->deinit(); 

    SafeDelete(gv.netman);
    SafeDelete(gv.soundman);
    SafeDelete(gv.iface);
    SafeDelete(gv.gui);               /* deinit gui             */ 
 
    _input_deinit();                  /* input                  */ 
    SafeDelete(gv.renderer);
 
    _gfx_deinit();                    /* graphics               */ 
 
    SafeDelete(gv.fileman);
 
    _win_deinit();                    /* destroy window         */ 

//    _showmem(true);                   /* show debug information */ 
//    _profile_show(); 
} 
 
#if defined(WIN32) 
static HINSTANCE hInst = NULL; 
#endif            /* end windows specific ***********************************/ 
 
/**************************************************************************** 
 * main                                                                     * 
 ****************************************************************************/ 
int main(int argc, char*argv[]) 
{ 
    memset(&gv, 0, sizeof(gv)); 

    _log_init(); 
 
    gv.init.fullscreen              = true; 
    gv.init.wndclassname            = "_OMICRON"; 
    gv.init.wndtitle                = "OMICRON TEST APPLICATION"; 
    gv.timescale                    = 1; 
 
    gv.init.hres                    = 640; 
    gv.init.vres                    = 480; 
    gv.init.bpp                     = 32; 
    gv.init.zbuffer                 = 24; 
    gv.init.stencil                 = 1; 

    gv.init.argc                    = argc;
    gv.init.argv                    = argv;

    gv.active                       = 0;
 
#if defined(WIN32) 
    gv.init.hInstance               = hInst; 
#endif            /* end windows specific ***********************************/ 
    gv.debuglevel                   = 0; 
 
    if (_init()) 
    {
        //signal(SIGQUIT, _signal_handler);
        _win_mainloop(); 
    }
 
    _log_printf(MSG_NORMAL, "Omicron engine shutting down.."); 
 
    _deinit(); 
 
    _log_printf(MSG_NORMAL, "Have a nice day.."); 
    _log_deinit(); 

    if (assertions)
    {
#if defined(WIN32) 

        MessageBeep(MB_ICONEXCLAMATION);
        MessageBox(NULL,    "One or more Assertions have failed. "
                            "Please see log file for more information",
                            "There were errors", MB_ICONERROR);
#endif
    }
 
    return 0; 
} 
 
#if defined(WIN32) 
/**************************************************************************** 
 * WinMain                                           the win 32 entry point * 
 ****************************************************************************/ 
int APIENTRY WinMain(HINSTANCE hInstance, 
                     HINSTANCE /* hPrevInstance */, 
                     LPSTR     /* lpCmdLine     */, 
                     int       /* nCmdShow      */ ) 
{ 
    hInst = hInstance; 
 
    return main(__argc, __argv); 
} 
#endif            /* end windows specific ***********************************/ 

---