i_video.c

The source code of Doom legacy for windows

// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id: i_video.c,v 1.8 2001/04/28 14:25:03 metzgermeister Exp $
//
// Copyright (C) 1993-1996 by id Software, Inc.
// Portions Copyright (C) 1998-2000 by DooM Legacy Team.
//
// This program 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.
//
// This program 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.
//
//
// $Log: i_video.c,v $
// Revision 1.8  2001/04/28 14:25:03  metzgermeister
// fixed mouse and menu bug
//
// Revision 1.7  2001/04/27 13:32:14  bpereira
// no message
//
// Revision 1.6  2001/03/12 21:03:10  metzgermeister
//   * new symbols for rendererlib added in SDL
//   * console printout fixed for Linux&SDL
//   * Crash fixed in Linux SW renderer initialization
//
// Revision 1.5  2001/03/09 21:53:56  metzgermeister
// *** empty log message ***
//
// Revision 1.4  2001/02/24 13:35:23  bpereira
// no message
//
// Revision 1.3  2001/01/25 22:15:45  bpereira
// added heretic support
//
// Revision 1.2  2000/11/02 19:49:40  bpereira
// no message
//
// Revision 1.1  2000/09/10 10:56:00  metzgermeister
// clean up & made it work again
//
// Revision 1.1  2000/08/21 21:17:32  metzgermeister
// Initial import to CVS
//
//
//
// DESCRIPTION:
//      DOOM graphics stuff for SDL
//
//-----------------------------------------------------------------------------

#include <stdlib.h>

#include <SDL/SDL.h>

#include "doomdef.h"

#include "doomstat.h"
#include "i_system.h"
#include "v_video.h"
#include "m_argv.h"
#include "m_menu.h"
#include "d_main.h"
#include "s_sound.h"
#include "g_input.h"
#include "st_stuff.h"
#include "g_game.h"
#include "i_video.h"
#include "hardware/hw_main.h"
#include "hardware/hw_drv.h"
#include "console.h"
#include "command.h"
#include "hwsym_sdl.h" // For dynamic referencing of HW rendering functions
#include "ogl_sdl.h"

void VID_PrepareModeList(void);

// maximum number of windowed modes (see windowedModes[][])
#define MAXWINMODES (6) 
#define NUM_VOODOOMODES (3)

//Hudler: 16/10/99: added for OpenGL gamma correction
RGBA_t  gamma_correction = {0x7F7F7F7F};
extern consvar_t cv_grgammared;
extern consvar_t cv_grgammagreen;
extern consvar_t cv_grgammablue;

extern consvar_t cv_fullscreen; // for fullscreen support 

static int numVidModes= 0;

static char vidModeName[33][32]; // allow 33 different modes

rendermode_t    rendermode=render_soft;
boolean highcolor = false;

// synchronize page flipping with screen refresh
// unused and for compatibilityy reason 
consvar_t       cv_vidwait = {"vid_wait","1",CV_SAVE,CV_OnOff};

byte graphics_started = 0; // Is used in console.c and screen.c

// To disable fullscreen at startup; is set in VID_PrepareModeList
boolean allow_fullscreen = false;

event_t event;

// SDL vars
static       SDL_Surface *vidSurface=NULL;
static       SDL_Color    localPalette[256];
static       SDL_Rect   **modeList=NULL;
static       Uint8        BitsPerPixel;
const static Uint32       surfaceFlags = SDL_HWSURFACE|SDL_HWPALETTE|SDL_DOUBLEBUF;

// first entry in the modelist which is not bigger than 1024x768
static int firstEntry=0;

// windowed video modes from which to choose from.

static int windowedModes[MAXWINMODES][2] = {
    {MAXVIDWIDTH /*1024*/, MAXVIDHEIGHT/*768*/},
    {800, 600},
    {640, 480},
    {512, 384},
    {400, 300},
    {320, 200}};
//
//  Translates the SDL key into Doom key
//

static int xlatekey(SDLKey sym)
{
    int rc=0;

    switch(sym)
    {
    case SDLK_LEFT:  rc = KEY_LEFTARROW;     break;
    case SDLK_RIGHT: rc = KEY_RIGHTARROW;    break;
    case SDLK_DOWN:  rc = KEY_DOWNARROW;     break;
    case SDLK_UP:    rc = KEY_UPARROW;       break;

    case SDLK_ESCAPE:   rc = KEY_ESCAPE;        break;
    case SDLK_RETURN:   rc = KEY_ENTER;         break;
    case SDLK_TAB:      rc = KEY_TAB;           break;
    case SDLK_F1:       rc = KEY_F1;            break;
    case SDLK_F2:       rc = KEY_F2;            break;
    case SDLK_F3:       rc = KEY_F3;            break;
    case SDLK_F4:       rc = KEY_F4;            break;
    case SDLK_F5:       rc = KEY_F5;            break;
    case SDLK_F6:       rc = KEY_F6;            break;
    case SDLK_F7:       rc = KEY_F7;            break;
    case SDLK_F8:       rc = KEY_F8;            break;
    case SDLK_F9:       rc = KEY_F9;            break;
    case SDLK_F10:      rc = KEY_F10;           break;
    case SDLK_F11:      rc = KEY_F11;           break;
    case SDLK_F12:      rc = KEY_F12;           break;

    case SDLK_BACKSPACE: rc = KEY_BACKSPACE;    break;
    case SDLK_DELETE:    rc = KEY_DEL;          break;

    case SDLK_PAUSE:     rc = KEY_PAUSE;        break;

    case SDLK_EQUALS:
    case SDLK_PLUS:      rc = KEY_EQUALS;       break;

    case SDLK_MINUS:     rc = KEY_MINUS;        break;

    case SDLK_LSHIFT:
    case SDLK_RSHIFT:
        rc = KEY_SHIFT;
        break;
          
        //case SDLK_XK_Caps_Lock:
        //rc = KEY_CAPSLOCK;
        //break;

    case SDLK_LCTRL:
    case SDLK_RCTRL:
        rc = KEY_CTRL;
        break;
          
    case SDLK_LALT:
    case SDLK_RALT:
        rc = KEY_ALT;
        break;
        
    case SDLK_PAGEUP:   rc = KEY_PGUP; break;
    case SDLK_PAGEDOWN: rc = KEY_PGDN; break;
    case SDLK_END:      rc = KEY_END;  break;
    case SDLK_HOME:     rc = KEY_HOME; break;
    case SDLK_INSERT:   rc = KEY_INS;  break;
      
    case SDLK_KP0: rc = KEY_KEYPAD0;  break;
    case SDLK_KP1: rc = KEY_KEYPAD1;  break;
    case SDLK_KP2: rc = KEY_KEYPAD2;  break;
    case SDLK_KP3: rc = KEY_KEYPAD3;  break;
    case SDLK_KP4: rc = KEY_KEYPAD4;  break;
    case SDLK_KP5: rc = KEY_KEYPAD5;  break;
    case SDLK_KP6: rc = KEY_KEYPAD6;  break;
    case SDLK_KP7: rc = KEY_KEYPAD7;  break;
    case SDLK_KP8: rc = KEY_KEYPAD8;  break;
    case SDLK_KP9: rc = KEY_KEYPAD9;  break;

    case SDLK_KP_MINUS:  rc = KEY_KPADDEL;  break;
    case SDLK_KP_DIVIDE: rc = KEY_KPADSLASH; break;
    case SDLK_KP_ENTER:  rc = KEY_ENTER;    break;

    default:
        if (sym >= SDLK_SPACE && sym <= SDLK_DELETE)
            rc = sym - SDLK_SPACE + ' ';
        if (sym >= 'A' && sym <= 'Z')
            rc = sym - 'A' + 'a';
        break;
    }
    
    return rc;
}



//
// I_StartFrame
//
void I_StartFrame(void)
{
    if(render_soft == rendermode)
    {
        if(SDL_MUSTLOCK(vidSurface))
        {
            if(SDL_LockSurface(vidSurface) < 0)
                return;
        }
    }

    return;
}

static int      lastmousex = 0;
static int      lastmousey = 0;

#ifdef LJOYSTICK
extern void I_GetJoyEvent();
#endif
#ifdef LMOUSE2
extern void I_GetMouse2Event();
#endif


void I_GetEvent(void)
{
    SDL_Event inputEvent;
    
#ifdef LJOYSTICK
    I_GetJoyEvent();
#endif
#ifdef LMOUSE2
    I_GetMouse2Event();
#endif

    SDL_PumpEvents(); // FIXME: do we need this?
    
    while(SDL_PollEvent(&inputEvent))
    {
        switch(inputEvent.type)
        {
        case SDL_KEYDOWN:
            event.type = ev_keydown;
            event.data1 = xlatekey(inputEvent.key.keysym.sym);
            D_PostEvent(&event);
            break;
        case SDL_KEYUP:
            event.type = ev_keyup;
            event.data1 = xlatekey(inputEvent.key.keysym.sym);
            D_PostEvent(&event);
            break;
        case SDL_MOUSEMOTION:
            if(cv_usemouse.value)
            {
                // If the event is from warping the pointer back to middle
                // of the screen then ignore it.
                if ((inputEvent.motion.x == vid.width/2) &&
                    (inputEvent.motion.y == vid.height/2)) 
                {
                    lastmousex = inputEvent.motion.x;
                    lastmousey = inputEvent.motion.y;
                    break;
                } 
                else 
                {
                    event.data2 = (inputEvent.motion.x - lastmousex) << 2;
                    lastmousex = inputEvent.motion.x;
                    event.data3 = (lastmousey - inputEvent.motion.y) << 2;
                    lastmousey = inputEvent.motion.y;
                }
                event.type = ev_mouse;
                event.data1 = 0;
            
                D_PostEvent(&event);
            
                // Warp the pointer back to the middle of the window
                //  or we cannot move any further if it's at a border.
                if ((inputEvent.motion.x < (vid.width/2)-(vid.width/4)) || 
                    (inputEvent.motion.y < (vid.height/2)-(vid.height/4)) || 
                    (inputEvent.motion.x > (vid.width/2)+(vid.width/4)) || 
                    (inputEvent.motion.y > (vid.height/2)+(vid.height/4)))
                {
                    SDL_WarpMouse(vid.width/2, vid.height/2);
                }
            }
            break;
        case SDL_MOUSEBUTTONDOWN:
            if(cv_usemouse.value)
            {
                event.type = ev_keydown;
                event.data1 = KEY_MOUSE1 + inputEvent.button.button -1; // FIXME!
                D_PostEvent(&event);
            }
            break;
        case SDL_MOUSEBUTTONUP:
            if(cv_usemouse.value)
            {
                event.type = ev_keyup;
                event.data1 = KEY_MOUSE1 + inputEvent.button.button -1;
                D_PostEvent(&event);
            }
            break;
        
        case SDL_QUIT:
            M_QuitResponse('y');
            break;
        default:
            break;
        
        }
    }
    
}

static void doGrabMouse(void)
{
  if(SDL_GRAB_OFF == SDL_WM_GrabInput(SDL_GRAB_QUERY))
  {
    SDL_WM_GrabInput(SDL_GRAB_ON);
  }
}

static void doUngrabMouse(void)
{
  if(SDL_GRAB_ON == SDL_WM_GrabInput(SDL_GRAB_QUERY))
  {
    SDL_WM_GrabInput(SDL_GRAB_OFF);
  }
}

void I_StartupMouse(void)
{
    // warp to center 
    SDL_WarpMouse(vid.width/2, vid.height/2);

#ifdef HAS_SDL_BEEN_FIXED // FIXME
  if(cv_usemouse.value) 
    {
      doGrabMouse();
    }
  else
    {
      doUngrabMouse();
    }
#endif
    return;
}

//
// I_OsPolling
//
void I_OsPolling(void)
{
    if (!graphics_started)
        return;

    I_GetEvent();
    
    return;