---

o_gfx.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/18 14:12:16 $
// By           :       $Author: kolrabi $
// $Id: o_gfx.cpp,v 1.6 2002/12/18 14:12:16 kolrabi Exp $ 

/*

  $Log: o_gfx.cpp,v $
  Revision 1.6  2002/12/18 14:12:16  kolrabi
  *** empty log message ***

  Revision 1.5  2002/12/13 12:29:26  kolrabi
  fixed some bugs

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

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

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

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


*/

#include            "omicron/internal.h"
#include            <string.h>


#if !defined(WIN32)

#include            <X11/extensions/xf86vmode.h>

static XF86VidModeModeInfo oldmode;

#endif

/**************************************************************************** 
 **************************************************************************** 
 * GFX ROUTINES ************************************************************* 
 **************************************************************************** 
 ****************************************************************************/ 

/****************************************************************************
 * _gfx_setmode                                           set graphics mode *
 ****************************************************************************/
int _gfx_setmode() 
{ 
#if defined(WIN32) 
    int bpp = gv.init.bpp;

    _log_printf(MSG_NORMAL, "setting full screen"); 
    DEVMODE devmode; 
 
    ZeroMemory(&devmode, sizeof(DEVMODE)); 
 
    devmode.dmSize      =   sizeof(DEVMODE); 
    devmode.dmPelsWidth =   gv.init.hres;   // Selected Screen Width 
    devmode.dmPelsHeight=   gv.init.vres;         // Selected Screen Height 
    devmode.dmBitsPerPel=   bpp;            // Selected Bits Per Pixel 
    devmode.dmFields    =   DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; 

    // try this for color depth 32/24/16/8 bits 
    while((signed)bpp>0) 
    { 
        _log_printf(MSG_DEBUG, "trying %u bpp",bpp); 
        devmode.dmBitsPerPel= bpp; 
        if ( ChangeDisplaySettings(&devmode, CDS_FULLSCREEN) == 
            DISP_CHANGE_SUCCESSFUL ) 
            break; 
 
        bpp -= 8; 
    } 
 
    // could not set display mode
    if (!bpp) 
    { 
        ChangeDisplaySettings(NULL, 0); 
        _log_printf(MSG_ERROR, 
        "failed to set full screen. try command line option -w."); 
        return 0; 
    } 
#else  // not WIN32

    XF86VidModeModeInfo **modes;
    int modeNum;
    int bestMode;
    Atom wmDelete;
    Window winDummy;
    unsigned int borderDummy;

    XF86VidModeGetAllModeLines(gv.init.dpy, 0, &modeNum, &modes);
    /* save desktop-resolution before switching modes */
//    XF86VidModeModeLine curmode;
//    XF86VidModeGetModeLine(gv.init.dpy, 0, NULL, &curmode);
    oldmode = *modes[modeNum-1];
    /* look for mode with requested resolution */
    for (int i = 0; i < modeNum; i++)
    {
        if ((modes[i]->hdisplay == gv.init.hres) && 
            (modes[i]->vdisplay == gv.init.vres))
        {
            bestMode = i;
        }
/*
        if ((modes[i]->hdisplay == curmode.hdisplay) &&
            (modes[i]->vdisplay == curmode.vdisplay))
        {
            oldmode = *modes[i];
        }*/
    }

    XF86VidModeSwitchToMode(gv.init.dpy, 0, modes[bestMode]);
    XF86VidModeSetViewPort(gv.init.dpy, 0, 0, 0);
    gv.init.hres = modes[bestMode]->hdisplay;
    gv.init.vres = modes[bestMode]->vdisplay;
    XFree(modes);
    
    XWarpPointer(gv.init.dpy, None, gv.init.wnd, 0, 0, 0, 0, 0, 0);
    XWarpPointer(gv.init.dpy, None, gv.init.wnd, 0, 0, 0, 0, gv.init.hres, gv.init.vres);
    XWarpPointer(gv.init.dpy, None, gv.init.wnd, 0, 0, 0, 0, gv.init.hres/2, gv.init.vres/2);


    /* vars to make blank cursor */
    Pixmap blank;
    XColor dummy;
    char data[1] = {0};
    Cursor cursor;
    
    /* make a blank cursor */
    blank = XCreateBitmapFromData (gv.init.dpy, gv.init.wnd, data, 1, 1);
    cursor = XCreatePixmapCursor(gv.init.dpy, blank, blank, &dummy, &dummy, 0, 0);
    XFreePixmap (gv.init.dpy, blank);
    
    XGrabPointer(gv.init.dpy, gv.init.wnd, True, ButtonPressMask, GrabModeAsync, GrabModeAsync, gv.init.wnd, cursor, CurrentTime);
    XMapRaised(gv.init.dpy, gv.init.wnd);
        
#endif // not WIN32
    return 1; 
} 
 
 
/**************************************************************************** 
 * _gfx_init                                           initializes graphics * 
 ****************************************************************************/ 
ulong _gfx_init                       // returns a nonzero value if successful 
( 
    ushort          /* nWidth  */,      // desired width 
    ushort          /* nHeight */,      // and height of screen 
    ulong           bFullscreen         // set to 1 for fullscreen 
) 
{ 
    _log_printf(MSG_DEBUG, "- _gfx_init() --------------------------"); 
 
#if defined(WIN32)

    int                     pixel_format;
    PIXELFORMATDESCRIPTOR   pfd=                // pfd Tells Windows How We Want Things To Be
    {
        sizeof(PIXELFORMATDESCRIPTOR),              // Size Of This Pixel Format Descriptor
        1,                                          // Version Number
        PFD_DRAW_TO_WINDOW |                        // Format Must Support Window
        PFD_SUPPORT_OPENGL |                        // Format Must Support OpenGL
        PFD_DOUBLEBUFFER,                           // Must Support Double Buffering
        PFD_TYPE_RGBA,                              // Request An RGBA Format
        gv.init.bpp,                                // Select Our Color Depth
        0, 0, 0, 0, 0, 0,                           // Color Bits Ignored
        0,                                          // No Alpha Buffer
        0,                                          // Shift Bit Ignored
        0,                                          // No Accumulation Buffer
        0, 0, 0, 0,                                 // Accumulation Bits Ignored
        gv.init.zbuffer,                            // Z-Buffer (Depth Buffer)  
        0,                                          // No Stencil Buffer
        0,                                          // No Auxiliary Buffer
        PFD_MAIN_PLANE,                             // Main Drawing Layer
        0,                                          // Reserved
        0, 0, 0                                     // Layer Masks Ignored
    };

    _log_printf(MSG_DEBUG, "getting device context for window"); 
    gv.hdc = GetDC((HWND)gv.init.wnd); 
    if (!gv.hdc)
    {
        if (bFullscreen) 
            ChangeDisplaySettings(NULL, 0); 
 
        _log_printf(MSG_ERROR,  
        "could not get device context for window.."); 
        return 0; 
    }

    pixel_format = ChoosePixelFormat(gv.hdc, &pfd);
 
    if (!pixel_format) 
    { 
        if (bFullscreen) 
            ChangeDisplaySettings(NULL, 0); 
 
        _log_printf(MSG_ERROR,  
        "could not find valid, accellerated pixel format.."); 
        ReleaseDC((HWND)gv.init.wnd, gv.hdc); 
        return 0; 
    } 

    _log_printf(MSG_DEBUG, "setting pixel format %u", pixel_format); 
    if(!SetPixelFormat(gv.hdc, pixel_format, &pfd)) 
    { 
        if (bFullscreen) 
            ChangeDisplaySettings(NULL, 0); 
 
        _log_printf(MSG_ERROR, "could not set pixel format..");
        ReleaseDC((HWND)gv.init.wnd, gv.hdc); 
        return 0; 
    } 
 
    _log_printf(MSG_DEBUG, "creating rendering context..."); 
    
    if (!(gv.hrc = wglCreateContext(gv.hdc))) 
    { 
        _log_printf(MSG_ERROR, "couldn't create rendering context...");
        ReleaseDC((HWND)gv.init.wnd, gv.hdc);
        return 0; 
    } 
 
    _log_printf(MSG_DEBUG, "making rendering context current..."); 
 
    if (!wglMakeCurrent(gv.hdc, gv.hrc)) 
    { 
        if (bFullscreen) 
            ChangeDisplaySettings(NULL, 0); 
 
        wglDeleteContext(gv.hrc); 
        ReleaseDC((HWND)gv.init.wnd, gv.hdc); 
        _log_printf(MSG_ERROR, "could not make rendering context current.."); 
        return 0; 
    } 
#endif  
 
    _log_printf(MSG_NORMAL, "OpenGL version     : %s",  
                           glGetString(GL_VERSION)); 
    _log_printf(MSG_NORMAL, "OpenGL vendor      : %s",  
                           glGetString(GL_VENDOR)); 
    _log_printf(MSG_NORMAL, "OpenGL renderer    : %s",  
                           glGetString(GL_RENDERER)); 

    _log_printf(MSG_DEBUG, "OpenGL extensions  : %s",  
                           glGetString(GL_EXTENSIONS));
 
    // initialize extensions 

#if defined(WIN32)

    extgl_Initialize();
    
    RECT r; 

    // bring window to top 
    GetClientRect((HWND)gv.init.wnd, &r); 
 
    SetForegroundWindow((HWND)gv.init.wnd); 
    SetFocus((HWND)gv.init.wnd); 
    
#else
#endif 
 
    // set fullscreen 
    if (gv.init.fullscreen = bFullscreen) 
        _gfx_setmode(); 
 
    gv.init.nogfx = 0;
 
#if defined(WIN32) 
    _gfx_resize((ushort)r.right, (ushort)r.bottom, bFullscreen);
#else
    _gfx_resize(gv.init.hres,gv.init.vres, bFullscreen);
#endif
 
    _log_printf(MSG_DEBUG, "----------------------------------------"); 
 
    return 1; 
} // _gfx_init 
 
/**************************************************************************** 
 * _gfx_resize                                called when window is resized * 
 ****************************************************************************/ 
ulong           _gfx_resize 
( 
    ushort          width,              // new width 
    ushort          height,             // and height of window 
    ulong           fullscreen          // useless 
) 
{ 
    // only if gfx is already initialized 
    if (gv.init.nogfx) 
        return 0; 
 
    gv.init.hres = width; 
    gv.init.vres = height; 
 
    // recalculate aspect ratio 
    gv.aspect = 1.0f*width / (height?height*1.0f:1.0f); 

    if (!fullscreen) 
        if (gv.aspect<1) gv.aspect = 1; 
 
    glViewport(0, 0, width, height); 

    return 1; 
} // _gfx_resize 
 
 
 
/**************************************************************************** 
 * _gfx_deinit                                       deinitializes graphics * 
 ****************************************************************************/ 
ulong             _gfx_deinit() 
{ 
    _log_printf(MSG_DEBUG, "- _gfx_deinit() ------------------------"); 
    _log_printf(MSG_DEBUG, "deinitializing opengl.."); 
    
#if defined(WIN32) 
    if (gv.init.fullscreen) 
    { 
        _log_printf(MSG_DEBUG, "resetting display mode.."); 
        ChangeDisplaySettings(NULL, 0); 
    } 
 
    wglMakeCurrent(gv.hdc,0); 
    wglDeleteContext(gv.hrc); 
    ReleaseDC((HWND)gv.init.wnd, gv.hdc); 
#else

    glXMakeCurrent(gv.init.dpy, 0, 0);
    glXDestroyContext(gv.init.dpy, gv.glxc);

    XF86VidModeSwitchToMode(gv.init.dpy, 0, &oldmode);
    XF86VidModeSetViewPort(gv.init.dpy, 0, 0, 0);

    XUngrabPointer(gv.init.dpy, CurrentTime);
    
#endif 
 
    _log_printf(MSG_DEBUG, "----------------------------------------"); 
    return 1; 
} // _gfx_deinit 

---