---

o_wnd.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/14 20:02:33 $
// By           :       $Author: kolrabi $
// $Id: o_wnd.cpp,v 1.5 2002/12/14 20:02:33 kolrabi Exp $ 

/*

  $Log: o_wnd.cpp,v $
  Revision 1.5  2002/12/14 20:02:33  kolrabi
  fixed some memory leaks

  Revision 1.4  2002/12/13 15:59:47  kolrabi
  several bug fixes

  Revision 1.3  2002/12/08 20:08:15  kolrabi
  Now really runs under X11

  Revision 1.2  2002/12/08 11:04:10  kolrabi
  Setting Window title correctly

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


*/

#include            "omicron/internal.h" 
#include            "omicron/render.h"
#include            "omicron/gui.h" 
#include            "omicron/file.h"
#include            "omicron/net.h"
#include            "omicron/sound.h"

/**************************************************************************** 
 **************************************************************************** 
 * WINDOW VARIABKES ********************************************************* 
 **************************************************************************** 
 ****************************************************************************/ 
 
#if defined(WIN32) 
static WNDCLASS wcWindow;           // the window class 
#endif 
 
static ulong    end,        // timer values 
                start, 
                lastend; 
 
/**************************************************************************** 
 **************************************************************************** 
 * WINDOW ROUTINES ********************************************************** 
 **************************************************************************** 
 ****************************************************************************/ 
 
 
 
#if defined(WIN32) 
/**************************************************************************** 
 * _win_wndproc                                         window message proc * 
 ****************************************************************************/ 
LRESULT CALLBACK _win_wndproc 
( 
    HWND        hwnd, 
    UINT        uMsg, 
    WPARAM      wParam, 
    LPARAM      lParam 
) 
{ 
//    STARTPROFILE("wndproc");
    switch ( uMsg ) 
    { 
        case    WM_CLOSE: 
            PostQuitMessage(0); 
            gv.bExit = 1; 
//            ENDPROFILE("wndproc");
            return 1; 
 
        case    WM_SIZE: 
            { 
                RECT r; 
 
                GetClientRect((HWND)gv.init.wnd, &r); 
                _gfx_resize( (ushort)r.right, (ushort)r.bottom, 0 ); 
                gv.init.hres = (ushort)r.right;
                gv.init.vres = (ushort)r.bottom;
                //_r_render_scene(); 
            } 
            break; 
/*
        case WM_LBUTTONDOWN:
            gv.mouse_b |= 1;
            break;

        case WM_RBUTTONDOWN:
            gv.mouse_b |= 2;
            break;
 
        case WM_LBUTTONUP:
            gv.mouse_b &= ~1;
            break;

        case WM_RBUTTONUP:
            gv.mouse_b &= ~2;
            break;*/

        case WM_ACTIVATE:
            gv.active = !!LOWORD(wParam);
//            ENDPROFILE("wndproc");
            return 0; 
    } 
//    ENDPROFILE("wndproc");
    return DefWindowProc(hwnd, uMsg, wParam, lParam); 
} 
#else

void _win_process_event(XEvent &event)
{
    switch (event.type)
    {
        case ConfigureNotify:

        if ((event.xconfigure.width != gv.init.hres) || 
            (event.xconfigure.height != gv.init.vres))
          {
              gv.init.hres = event.xconfigure.width;
              gv.init.vres = event.xconfigure.height;
              _gfx_resize(event.xconfigure.width,
                          event.xconfigure.height, gv.init.fullscreen);
          }
        break;
    }
}

#endif 
 
 
/**************************************************************************** 
 * _win_init                                          windows initialization * 
 ****************************************************************************/ 
#if defined(WIN32) 
HWND            _win_init 
( 
    ulong       nWidth, 
    ulong       nHeight, 
    HINSTANCE   hInstance, 
    bool        bFullscreen ) 
#else 
ulong           _win_init 
( 
    ulong       nWidth, 
    ulong       nHeight, 
    bool        bFullscreen ) 
#endif 
{ 
    _log_printf(MSG_DEBUG, "- _win_init() - -"); 
 
#if defined(WIN32) 
    ZeroMemory(&wcWindow, sizeof(WNDCLASS)); 
 
    wcWindow.hInstance      = hInstance; 
    wcWindow.style          = CS_VREDRAW|CS_HREDRAW|CS_OWNDC; 
    wcWindow.lpfnWndProc    = _win_wndproc; 
    wcWindow.lpszClassName  = gv.init.wndclassname; 
    wcWindow.hbrBackground  = NULL; //CreateSolidBrush(RGB(0,0,0)); 
 
    if (!RegisterClass(&wcWindow)) 
        return 0; 
 
    if (!bFullscreen) 
    { 
        // windowed mode
        gv.init.wnd =  (ulong)CreateWindow( 
            gv.init.wndclassname, 
            gv.init.wndtitle, 
            WS_OVERLAPPEDWINDOW, 
            0,0, nWidth, nHeight, 
            NULL, NULL, 
            hInstance, NULL 
        );

        if (!gv.init.wnd)
        {
            UnregisterClass(gv.init.wndclassname, hInstance);
            return 0;
        }

        RECT r; 

        GetClientRect((HWND)gv.init.wnd, &r); 
        AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, false); 

        MoveWindow((HWND)gv.init.wnd, 0, 0, r.right-r.left, r.bottom-r.top, false); 
    } 
    else 
    { 
        // fullscreen mode
        gv.init.wnd =  (ulong)CreateWindow( 
            gv.init.wndclassname, 
            gv.init.wndtitle, 
            WS_POPUP, 
            0,0, nWidth, nHeight, 
            NULL, NULL, 
            hInstance, NULL 
        ); 

        if (!gv.init.wnd)
        {
            UnregisterClass(gv.init.wndclassname, hInstance);
            return 0;
        }

        // FIXME:
        // somehow gv.init.*res get changed here, i the heck dont know why

        gv.init.hres = (ushort)nWidth;
        gv.init.vres = (ushort)nHeight;
    } 

    ShowCursor(false); 

    return (HWND)gv.init.wnd; 
 
#else 
 
    gv.init.dpy = XOpenDisplay(NULL); 
    gv.init.vis = DefaultVisual(gv.init.dpy,0); 
 
    // XVisualInfo *vi; 
 
    if (!gv.init.nogfx) 
    { 
        int attribsdbl[] =  
        { 
            GLX_RGBA, GLX_DOUBLEBUFFER, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None 
        }; 
        int attribssgl[] =  
        { 
            GLX_RGBA, GLX_RED_SIZE, 1, GLX_GREEN_SIZE, 1, GLX_BLUE_SIZE, 1, None 
        }; 
 
        gv.init.vi = glXChooseVisual(gv.init.dpy, DefaultScreen(gv.init.dpy), attribsdbl); 
 
        if (!gv.init.vi) 
        { 
            gv.init.vi = glXChooseVisual(gv.init.dpy, DefaultScreen(gv.init.dpy), attribssgl); 
 
            if (!gv.init.vi) 
            return 0; 
 
        } 
        gv.init.vis = gv.init.vi->visual; 
    } 
 
    if (bFullscreen) 
    { 
    } 
 
    gv.init.wnd = XCreateSimpleWindow(gv.init.dpy, DefaultRootWindow(gv.init.dpy),
        0,0, nWidth, nHeight,
        1, 0, 0);

 
    if (!gv.init.nogfx) 
    { 
        gv.glxc = glXCreateContext(gv.init.dpy, gv.init.vi, 0, GL_TRUE); 
        glXMakeCurrent(gv.init.dpy, gv.init.wnd, gv.glxc); 
    } 
 
    XStoreName(gv.init.dpy, gv.init.wnd, gv.init.wndtitle); 

    return gv.init.wnd; 
#endif 
} 
 
 
 
/**************************************************************************** 
 * _win_deinit                                      windows deinitialization * 
 ****************************************************************************/ 
void            _win_deinit() 
{ 
    _log_printf(MSG_DEBUG, "- _win_deinit() ------------------------"); 
 
#if defined(WIN32) 
    _log_printf(MSG_DEBUG, "destroying window.."); 
    DestroyWindow((HWND)gv.init.wnd); 
 
    _log_printf(MSG_DEBUG, "unregistering window.."); 
    UnregisterClass(gv.init.wndclassname, gv.init.hInstance); 
#else

    // free vi
    XFree(gv.init.vi);

#endif 
 
    _log_printf(MSG_DEBUG, "----------------------------------------"); 
} 
 

/**************************************************************************** 
 * _win_mainloop                                          windows main loop * 
 ****************************************************************************/ 
ulong           _win_mainloop() 
{
#if defined(WIN32)

    MSG msg;

#else

    XEvent event;

    XSelectInput(gv.init.dpy, gv.init.wnd, StructureNotifyMask);

#endif

    lastend = end = start = _time_get(); 
   
    while (!gv.bExit) 
    { 
//        STARTPROFILE("frame");

        end = _time_get(); 
#if defined(WIN32)
        while(PeekMessage(&msg, (HWND)gv.init.wnd, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg); 
            DispatchMessage(&msg); 
        }
#else
        while (XPending(gv.init.dpy)>0)
        {
            XNextEvent(gv.init.dpy, &event);
            _win_process_event(event);
        }
#endif
 
        long dif = end-start; 
 
        gv.dtime    = (dif * 0.001f)*gv.timescale-gv.time; 
        gv.time     = dif * 0.001f * gv.timescale; 

        if (gv.fileman)
            gv.fileman->update(); 

        if (gv.init.noinput == false) 
            _input_update(); 

        if (gv.gui)
            gv.gui->update();

#if !defined(NOSOUND)
        if (gv.init.nosound == false) 
            gv.soundman->update(); 
#endif

        if (gv.netman)
            gv.netman->update();

        if (gv.iface)
            gv.iface->world_update();

        if (gv.renderer)
            gv.renderer->render(); 

        if (gv.iface)
            gv.iface->afterframe(); 
    } 

    return 0;
} 

---