forked from KolibriOS/kolibrios
866 lines
21 KiB
C
866 lines
21 KiB
C
// Emacs style mode select -*- C++ -*-
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Id:$
|
|
//
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
//
|
|
// This source is available for distribution and/or modification
|
|
// only under the terms of the DOOM Source Code License as
|
|
// published by id Software. All rights reserved.
|
|
//
|
|
// The source is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
|
// for more details.
|
|
//
|
|
// $Log:$
|
|
//
|
|
// DESCRIPTION:
|
|
// DOOM graphics stuff for SDL library
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static const char
|
|
rcsid[] = "$Id: i_x.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";
|
|
|
|
#include <stdlib.h>
|
|
|
|
//#include "SDL.h"
|
|
|
|
//#include "m_swap.h"
|
|
#include "doomstat.h"
|
|
#include "i_system.h"
|
|
#include "v_video.h"
|
|
#include "m_argv.h"
|
|
#include "d_main.h"
|
|
|
|
#include "doomdef.h"
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <windows.h>
|
|
|
|
typedef struct SURFACE
|
|
{
|
|
int w, h;
|
|
int pitch;
|
|
unsigned char *pixels;
|
|
int offset;
|
|
} SURFACE;
|
|
|
|
SURFACE screen;
|
|
|
|
// Fake mouse handling.
|
|
boolean grabMouse;
|
|
|
|
// Blocky mode,
|
|
// replace each 320x200 pixel with multiply*multiply pixels.
|
|
// According to Dave Taylor, it still is a bonehead thing
|
|
// to use ....
|
|
static int multiply=2;
|
|
|
|
void WinError(char *msg);
|
|
|
|
|
|
int BPP;
|
|
byte *hicolortable;
|
|
short hicolortransmask1,hicolortransmask2;
|
|
int X_width;
|
|
int X_height;
|
|
static int disableVerticalMouse = 0;
|
|
static int closed=0;
|
|
static int windowActive = 0;
|
|
|
|
HWND win;
|
|
static HINSTANCE inst;
|
|
static HDC dibDC;
|
|
static LOGPALETTE *palette;
|
|
static HPALETTE dibPal;
|
|
BITMAPINFO *bminfo;
|
|
static unsigned char *dibData;
|
|
static int bits8;
|
|
int palette_color[256];
|
|
|
|
|
|
static int lastmousex = 0;
|
|
static int lastmousey = 0;
|
|
boolean mousemoved = false;
|
|
boolean shmFinished;
|
|
|
|
|
|
|
|
//
|
|
// Translates the key
|
|
//
|
|
|
|
/*******
|
|
int xlatekey(SDL_keysym *key)
|
|
{
|
|
|
|
int rc;
|
|
|
|
switch(key->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:
|
|
case SDLK_DELETE: rc = KEY_BACKSPACE; break;
|
|
|
|
case SDLK_PAUSE: rc = KEY_PAUSE; break;
|
|
|
|
case SDLK_EQUALS: rc = KEY_EQUALS; break;
|
|
|
|
case SDLK_KP_MINUS:
|
|
case SDLK_MINUS: rc = KEY_MINUS; break;
|
|
|
|
case SDLK_LSHIFT:
|
|
case SDLK_RSHIFT:
|
|
rc = KEY_RSHIFT;
|
|
break;
|
|
|
|
case 'z':
|
|
case SDLK_LCTRL:
|
|
case SDLK_RCTRL:
|
|
rc = KEY_RCTRL;
|
|
break;
|
|
|
|
case SDLK_LALT:
|
|
case SDLK_LMETA:
|
|
case SDLK_RALT:
|
|
case SDLK_RMETA:
|
|
rc = KEY_RALT;
|
|
break;
|
|
|
|
default:
|
|
rc = key->sym;
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
**********/
|
|
|
|
void I_ShutdownGraphics(void)
|
|
{
|
|
// SDL_Quit();
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// I_StartFrame
|
|
//
|
|
void I_StartFrame (void)
|
|
{
|
|
// er?
|
|
|
|
}
|
|
|
|
/* This processes SDL events */
|
|
/*****
|
|
void I_GetEvent(SDL_Event *Event)
|
|
{
|
|
Uint8 buttonstate;
|
|
event_t event;
|
|
|
|
switch (Event->type)
|
|
{
|
|
case SDL_KEYDOWN:
|
|
event.type = ev_keydown;
|
|
event.data1 = xlatekey(&Event->key.keysym);
|
|
D_PostEvent(&event);
|
|
break;
|
|
case SDL_KEYUP:
|
|
event.type = ev_keyup;
|
|
event.data1 = xlatekey(&Event->key.keysym);
|
|
D_PostEvent(&event);
|
|
break;
|
|
case SDL_QUIT:
|
|
I_Quit();
|
|
break;
|
|
}
|
|
}
|
|
|
|
*******/
|
|
|
|
|
|
|
|
|
|
void I_GetEvent(void)
|
|
{
|
|
MSG msg;
|
|
POINT point;
|
|
static LONG prevX, prevY;
|
|
static int hadMouse = 0;
|
|
event_t event;
|
|
RECT rect;
|
|
int lb, rb;
|
|
static int prevlb = 0, prevrb = 0;
|
|
|
|
/* Dispatch all messages: */
|
|
while ( PeekMessage(&msg, NULL, 0, 0xFFFFFFFF, PM_REMOVE) )
|
|
{
|
|
TranslateMessage (&msg) ;
|
|
DispatchMessage (&msg) ;
|
|
}
|
|
|
|
/* Check mouse and generate events if necessary: */
|
|
if ( !GetCursorPos(&point) )
|
|
WinError("GetCursorPos() failed");
|
|
if ( hadMouse && windowActive)
|
|
{
|
|
lb = (GetAsyncKeyState(VK_LBUTTON) < 0);
|
|
rb = (GetAsyncKeyState(VK_RBUTTON) < 0);
|
|
|
|
if ( (prevX != point.x) || (prevY != point.y) ||
|
|
(prevlb != lb) || (prevrb != rb) )
|
|
{
|
|
event.type = ev_mouse;
|
|
event.data1 = lb | (rb << 1);
|
|
event.data2 = (point.x - prevX)*9;
|
|
if ( disableVerticalMouse )
|
|
event.data3 = 0;
|
|
else
|
|
event.data3 = (prevY - point.y)*9;
|
|
prevX = point.x;
|
|
prevY = point.y;
|
|
prevlb = lb;
|
|
prevrb = rb;
|
|
D_PostEvent(&event);
|
|
}
|
|
|
|
if ( grabMouse )
|
|
{
|
|
GetWindowRect(win, &rect);
|
|
if ( !SetCursorPos((rect.left + rect.right) / 2,
|
|
(rect.top + rect.bottom) / 2) )
|
|
WinError("SetCursorPos() failed");
|
|
prevX = (rect.left + rect.right) / 2;
|
|
prevY = (rect.top + rect.bottom) / 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
prevX = point.x;
|
|
prevY = point.y;
|
|
hadMouse = 1;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// I_StartTic
|
|
//
|
|
void I_StartTic (void)
|
|
{
|
|
// SDL_Event Event;
|
|
|
|
// while ( SDL_PollEvent(&Event) )
|
|
// I_GetEvent(&Event);
|
|
I_GetEvent();
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// I_UpdateNoBlit
|
|
//
|
|
void I_UpdateNoBlit (void)
|
|
{
|
|
// what is this?
|
|
}
|
|
|
|
//
|
|
// I_ReadScreen
|
|
//
|
|
void I_ReadScreen (byte* scr)
|
|
{
|
|
memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
|
|
}
|
|
|
|
|
|
//
|
|
// I_SetPalette
|
|
//
|
|
|
|
typedef struct SDL_Color
|
|
{
|
|
byte r;
|
|
byte g;
|
|
byte b;
|
|
byte unused;
|
|
} SDL_Color;
|
|
|
|
SDL_Color colors[256];
|
|
|
|
void I_SetPalette (byte* palette)
|
|
{
|
|
int i;
|
|
RGBQUAD *rgb;
|
|
|
|
//
|
|
// for ( i=0; i<256; ++i ) {
|
|
// colors[i].r = gammatable[usegamma][*palette++];
|
|
// colors[i].g = gammatable[usegamma][*palette++];
|
|
// colors[i].b = gammatable[usegamma][*palette++];
|
|
// colors[i].unused = 0;
|
|
// }
|
|
// SDL_SetColors(screen, colors, 0, 256);
|
|
|
|
rgb = bminfo->bmiColors;
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
rgb->rgbRed = gammatable[usegamma][*palette++];
|
|
rgb->rgbGreen = gammatable[usegamma][*palette++];
|
|
rgb->rgbBlue = gammatable[usegamma][*palette++];
|
|
rgb->rgbReserved = 0;
|
|
rgb++;
|
|
};
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int makecol(int r, int g, int b)
|
|
{
|
|
// assert(BPP==2);
|
|
return (b >> 3) | ((g >> 3) << 5) | ((r >> 3) << 10);
|
|
}
|
|
|
|
int TranslateKey(unsigned k)
|
|
{
|
|
/*wtf? if ( (k >= VK_0) && (k <= VK_9) )*/
|
|
if ( (k >= 0x30) && (k <= 0x39) )
|
|
return (k - 0x30 + '0');
|
|
if ( (k >= 0x41) && (k <= 0x5a) )
|
|
return (k - 0x41 + 'a');
|
|
|
|
#define K(a,b) case a: return b;
|
|
switch ( k )
|
|
{
|
|
K(VK_LEFT, KEY_LEFTARROW);
|
|
K(VK_RIGHT, KEY_RIGHTARROW);
|
|
K(VK_UP, KEY_UPARROW);
|
|
K(VK_DOWN, KEY_DOWNARROW);
|
|
K(VK_BACK, KEY_BACKSPACE);
|
|
K(VK_TAB, KEY_TAB);
|
|
K(VK_RETURN, KEY_ENTER);
|
|
K(VK_SHIFT, KEY_RSHIFT);
|
|
K(VK_CONTROL, KEY_RCTRL);
|
|
K(VK_MENU, KEY_RALT);
|
|
K(VK_PAUSE, KEY_PAUSE);
|
|
K(VK_ESCAPE, KEY_ESCAPE);
|
|
K(VK_SPACE, ' ');
|
|
K(VK_DELETE, KEY_BACKSPACE);
|
|
K(VK_ADD, '+');
|
|
K(VK_SUBTRACT, KEY_MINUS);
|
|
K(0xBC, ',');
|
|
K(0xBE, '.');
|
|
K(VK_F1, KEY_F1);
|
|
K(VK_F2, KEY_F2);
|
|
K(VK_F3, KEY_F3);
|
|
K(VK_F4, KEY_F4);
|
|
K(VK_F5, KEY_F5);
|
|
K(VK_F6, KEY_F6);
|
|
K(VK_F7, KEY_F7);
|
|
K(VK_F8, KEY_F8);
|
|
K(VK_F9, KEY_F9);
|
|
K(VK_F10, KEY_F10);
|
|
K(VK_F11, KEY_F11);
|
|
K(VK_F12, KEY_F12);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void WinError(char *msg)
|
|
{
|
|
printf("Windows Error: %s, GetLastError(): %u\n", msg, GetLastError());
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
|
|
WPARAM wparam, LPARAM lparam);
|
|
|
|
void BlitDIB(void)
|
|
{
|
|
RECT rect;
|
|
|
|
GetClientRect(win, &rect);
|
|
if ( StretchDIBits(dibDC, rect.left, rect.top, rect.right-rect.left,
|
|
rect.bottom-rect.top, 0, 0, SCREENWIDTH*2,
|
|
SCREENHEIGHT*2, dibData, bminfo, DIB_RGB_COLORS,
|
|
SRCCOPY)
|
|
== GDI_ERROR )
|
|
WinError("StrecthDIBits failed");
|
|
|
|
GdiFlush();
|
|
}
|
|
|
|
|
|
void I_InitGraphics(void)
|
|
{
|
|
static int firsttime=1;
|
|
|
|
WNDCLASS wc;
|
|
unsigned i, x, y, j;
|
|
WORD *d;
|
|
unsigned char *b;
|
|
int bits;
|
|
int frameX, frameY, capY;
|
|
RECT rect;
|
|
int width, height;
|
|
RGBQUAD *rgb;
|
|
int retval;
|
|
|
|
if (!firsttime)
|
|
return;
|
|
firsttime = 0;
|
|
|
|
if (M_CheckParm("-2"))
|
|
multiply = 2;
|
|
|
|
if (M_CheckParm("-3"))
|
|
multiply = 3;
|
|
|
|
if (M_CheckParm("-4"))
|
|
multiply = 4;
|
|
|
|
X_width = SCREENWIDTH * multiply;
|
|
X_height = SCREENHEIGHT * multiply;
|
|
|
|
// check if the user wants to grab the mouse (quite unnice)
|
|
grabMouse = !!M_CheckParm("-grabmouse");
|
|
|
|
/* [Petteri] New: Option to disable mouse vertical movement - useful
|
|
for players used to Quake: */
|
|
disableVerticalMouse = !!M_CheckParm("-novertmouse");
|
|
|
|
/* Build and initialize the window: */
|
|
|
|
inst = (HINSTANCE) GetModuleHandle(NULL);
|
|
|
|
frameX = GetSystemMetrics(SM_CXFRAME);
|
|
frameY = GetSystemMetrics(SM_CYFRAME);
|
|
capY = GetSystemMetrics(SM_CYCAPTION);
|
|
|
|
wc.style = CS_HREDRAW | CS_VREDRAW;
|
|
wc.lpfnWndProc = WndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = inst;
|
|
wc.hIcon = NULL;
|
|
if ( grabMouse )
|
|
wc.hCursor = LoadCursor( 0, IDC_ARROW );
|
|
else
|
|
wc.hCursor = LoadCursor( 0, IDC_ARROW );
|
|
/*wc.hbrBackground = GetStockObject( WHITE_BRUSH );*/
|
|
wc.hbrBackground = NULL;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = "DoomWindowClass";
|
|
|
|
retval= RegisterClass(&wc);
|
|
|
|
width = X_width + 2*frameX;
|
|
height = X_height + 2*frameY + capY;
|
|
|
|
win = CreateWindow("DoomWindowClass", "NTDOOM",
|
|
WS_OVERLAPPEDWINDOW | WS_VISIBLE, 200, 200, width, height,
|
|
NULL, NULL, inst, NULL);
|
|
|
|
/* Display the window: */
|
|
ShowWindow(win, SW_SHOW);
|
|
UpdateWindow(win);
|
|
|
|
GetClientRect(win, &rect);
|
|
fprintf(stderr, "I_InitGraphics: Client area: %ux%u\n",
|
|
rect.right-rect.left, rect.bottom-rect.top);
|
|
|
|
if ( (rect.right-rect.left) != X_width )
|
|
{
|
|
fprintf(stderr, "I_InitGraphics: Fixing width\n");
|
|
width += X_width - (rect.right-rect.left);
|
|
MoveWindow(win, 0, 0, width, height, TRUE);
|
|
}
|
|
if ( (rect.bottom-rect.top) != X_height )
|
|
{
|
|
fprintf(stderr, "I_InitGraphics: Fixing height\n");
|
|
height += X_height - (rect.bottom-rect.top);
|
|
MoveWindow(win, 0, 0, width, height, TRUE);
|
|
}
|
|
|
|
GetClientRect(win, &rect);
|
|
fprintf(stderr, "I_InitGraphics: Client area: %ux%u\n",
|
|
rect.right-rect.left, rect.bottom-rect.top);
|
|
|
|
dibDC = GetDC(win);
|
|
BPP=1;
|
|
bits = 8; //GetDeviceCaps(dibDC, BITSPIXEL);
|
|
fprintf(stderr, "I_InitGraphics: %i bpp screen\n", bits);
|
|
|
|
if ( BPP == 1 )
|
|
bminfo = malloc(sizeof(BITMAPINFOHEADER) + 4*256);
|
|
else
|
|
bminfo = malloc(sizeof(BITMAPINFOHEADER));
|
|
|
|
|
|
if ( BPP == 1 )
|
|
{
|
|
rgb = bminfo->bmiColors;
|
|
for ( i = 0; i < 256; i++ )
|
|
{
|
|
rgb->rgbRed = i;
|
|
rgb->rgbGreen = i;
|
|
rgb->rgbBlue = i;
|
|
rgb->rgbReserved = 0;
|
|
rgb++;
|
|
}
|
|
}
|
|
|
|
bminfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
|
|
bminfo->bmiHeader.biWidth = 640; X_width;
|
|
bminfo->bmiHeader.biHeight = -400 ;X_height;
|
|
bminfo->bmiHeader.biPlanes = 1;
|
|
if ( BPP == 1 )
|
|
bminfo->bmiHeader.biBitCount = 8;
|
|
else
|
|
bminfo->bmiHeader.biBitCount = 16;
|
|
bminfo->bmiHeader.biCompression = BI_RGB;
|
|
bminfo->bmiHeader.biSizeImage = 0;
|
|
bminfo->bmiHeader.biXPelsPerMeter = 0;
|
|
bminfo->bmiHeader.biYPelsPerMeter = 0;
|
|
bminfo->bmiHeader.biClrUsed = 0;
|
|
bminfo->bmiHeader.biClrImportant = 0;
|
|
|
|
dibData = malloc(640*400*BPP);
|
|
|
|
// BlitDIB();
|
|
|
|
screen.pixels=(unsigned char *) (dibData);
|
|
screen.h=400;
|
|
screen.w=640;
|
|
screen.pitch=640;
|
|
|
|
// screens[0] = malloc(320*200);
|
|
|
|
/* Build magic highcolor table: */
|
|
if (BPP==2)
|
|
{
|
|
byte *tempptr, *tempptr2;
|
|
|
|
tempptr=hicolortable=(byte *)malloc(256*32*9);
|
|
|
|
for (i=0;i<32;i++)
|
|
{
|
|
for (j=0;j<256;j++)
|
|
{
|
|
*tempptr=j*gammatable[3][i*(256/32)]/256;
|
|
tempptr++;
|
|
}
|
|
}
|
|
for (i=1;i<=8;i++)
|
|
{
|
|
tempptr2=hicolortable;
|
|
for (j=0;j<(256*32);j++)
|
|
{
|
|
*tempptr=(byte)(((int)(*tempptr2))*(8-i)/8);
|
|
tempptr++; tempptr2++;
|
|
}
|
|
}
|
|
hicolortransmask1=makecol(127,127,127);
|
|
hicolortransmask2=makecol(63,63,63);
|
|
}
|
|
}
|
|
|
|
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
|
|
WPARAM wparam, LPARAM lparam)
|
|
{
|
|
event_t event;
|
|
RECT rect;
|
|
|
|
switch ( message )
|
|
{
|
|
case WM_DESTROY:
|
|
if ( grabMouse )
|
|
{
|
|
ClipCursor(NULL);
|
|
ShowCursor(TRUE);
|
|
}
|
|
fprintf(stderr, "WM_DESTROY\n");
|
|
PostQuitMessage(0);
|
|
closed = 1;
|
|
break;
|
|
|
|
case WM_MOVE:
|
|
GetWindowRect(win, &rect);
|
|
fprintf(stderr, "%u,%u - %u, %u\n",
|
|
rect.left,rect.top,rect.right,rect.bottom);
|
|
ClipCursor(&rect);
|
|
break;
|
|
|
|
case WM_ACTIVATE:
|
|
fprintf(stderr, "WM_ACTIVATE %u\n", (unsigned) LOWORD(wparam));
|
|
if ( LOWORD(wparam) )
|
|
{
|
|
if ( !windowActive )
|
|
{
|
|
if ( grabMouse )
|
|
{
|
|
ClipCursor(NULL); /* helps with Win95? */
|
|
GetWindowRect(win, &rect);
|
|
fprintf(stderr, "%u,%u - %u, %u\n",
|
|
rect.left,rect.top,rect.right,rect.bottom);
|
|
ClipCursor(&rect);
|
|
ShowCursor(FALSE);
|
|
}
|
|
}
|
|
windowActive = 1;
|
|
if ( bits8 )
|
|
{
|
|
if ( SetPaletteEntries(dibPal, 0, 256, palette->palPalEntry) != 256 )
|
|
WinError("SetPaletteEntries failed");
|
|
if ( !UnrealizeObject(dibPal) )
|
|
WinError("UnrealizeObject failed");
|
|
if ( SelectPalette(dibDC, dibPal, FALSE) == NULL )
|
|
WinError("SelectPalette failed");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( grabMouse )
|
|
{
|
|
ClipCursor(NULL);
|
|
ShowCursor(TRUE);
|
|
}
|
|
windowActive = 0;
|
|
}
|
|
return DefWindowProc(hwnd, message, wparam, lparam);
|
|
|
|
case WM_KEYDOWN:
|
|
event.type = ev_keydown;
|
|
event.data1 = TranslateKey(wparam);
|
|
if ( event.data1 != 0 )
|
|
D_PostEvent(&event);
|
|
break;
|
|
|
|
case WM_KEYUP:
|
|
event.type = ev_keyup;
|
|
event.data1 = TranslateKey(wparam);
|
|
if ( event.data1 != 0 )
|
|
D_PostEvent(&event);
|
|
break;
|
|
|
|
default:
|
|
return(DefWindowProc(hwnd, message, wparam, lparam));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// I_FinishUpdate
|
|
//
|
|
void I_FinishUpdate (void)
|
|
{
|
|
|
|
static int lasttic;
|
|
int tics;
|
|
int i;
|
|
|
|
// draws little dots on the bottom of the screen
|
|
if (devparm)
|
|
{ i = I_GetTime();
|
|
|
|
tics = i - lasttic;
|
|
lasttic = i;
|
|
if (tics > 20)
|
|
tics = 20;
|
|
|
|
for (i=0 ; i<tics*2 ; i+=2)
|
|
screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
|
|
for ( ; i<20*2 ; i+=2)
|
|
screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
|
|
}
|
|
|
|
// scales the screen size before blitting it
|
|
if (multiply == 1)
|
|
{
|
|
unsigned char *olineptr;
|
|
unsigned char *ilineptr;
|
|
int y;
|
|
|
|
ilineptr = (unsigned char *) screens[0];
|
|
olineptr = (unsigned char *) screen.pixels;
|
|
|
|
y = SCREENHEIGHT;
|
|
while (y--)
|
|
{
|
|
memcpy(olineptr, ilineptr, screen.w);
|
|
ilineptr += SCREENWIDTH;
|
|
olineptr += screen.pitch;
|
|
}
|
|
}
|
|
else if (multiply == 2)
|
|
{
|
|
unsigned int *olineptrs[2];
|
|
unsigned int *ilineptr;
|
|
int x, y, i;
|
|
unsigned int twoopixels;
|
|
unsigned int twomoreopixels;
|
|
unsigned int fouripixels;
|
|
|
|
ilineptr = (unsigned int *) (screens[0]);
|
|
for (i=0 ; i<2 ; i++) {
|
|
olineptrs[i] =
|
|
(unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
|
|
}
|
|
|
|
y = SCREENHEIGHT;
|
|
while (y--)
|
|
{
|
|
x = SCREENWIDTH;
|
|
do
|
|
{
|
|
fouripixels = *ilineptr++;
|
|
twoopixels = (fouripixels & 0xff000000)
|
|
| ((fouripixels>>8) & 0xffff00)
|
|
| ((fouripixels>>16) & 0xff);
|
|
twomoreopixels = ((fouripixels<<16) & 0xff000000)
|
|
| ((fouripixels<<8) & 0xffff00)
|
|
| (fouripixels & 0xff);
|
|
*olineptrs[0]++ = twomoreopixels;
|
|
*olineptrs[1]++ = twomoreopixels;
|
|
*olineptrs[0]++ = twoopixels;
|
|
*olineptrs[1]++ = twoopixels;
|
|
} while (x-=4);
|
|
olineptrs[0] += screen.pitch/4;
|
|
olineptrs[1] += screen.pitch/4;
|
|
}
|
|
|
|
}
|
|
else if (multiply == 3)
|
|
{
|
|
unsigned int *olineptrs[3];
|
|
unsigned int *ilineptr;
|
|
int x, y, i;
|
|
unsigned int fouropixels[3];
|
|
unsigned int fouripixels;
|
|
|
|
ilineptr = (unsigned int *) (screens[0]);
|
|
for (i=0 ; i<3 ; i++) {
|
|
olineptrs[i] =
|
|
(unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
|
|
}
|
|
|
|
y = SCREENHEIGHT;
|
|
while (y--)
|
|
{
|
|
x = SCREENWIDTH;
|
|
do
|
|
{
|
|
fouripixels = *ilineptr++;
|
|
fouropixels[0] = (fouripixels & 0xff000000)
|
|
| ((fouripixels>>8) & 0xff0000)
|
|
| ((fouripixels>>16) & 0xffff);
|
|
fouropixels[1] = ((fouripixels<<8) & 0xff000000)
|
|
| (fouripixels & 0xffff00)
|
|
| ((fouripixels>>8) & 0xff);
|
|
fouropixels[2] = ((fouripixels<<16) & 0xffff0000)
|
|
| ((fouripixels<<8) & 0xff00)
|
|
| (fouripixels & 0xff);
|
|
*olineptrs[0]++ = fouropixels[2];
|
|
*olineptrs[1]++ = fouropixels[2];
|
|
*olineptrs[2]++ = fouropixels[2];
|
|
*olineptrs[0]++ = fouropixels[1];
|
|
*olineptrs[1]++ = fouropixels[1];
|
|
*olineptrs[2]++ = fouropixels[1];
|
|
*olineptrs[0]++ = fouropixels[0];
|
|
*olineptrs[1]++ = fouropixels[0];
|
|
*olineptrs[2]++ = fouropixels[0];
|
|
} while (x-=4);
|
|
olineptrs[0] += 2*screen.pitch/4;
|
|
olineptrs[1] += 2*screen.pitch/4;
|
|
olineptrs[2] += 2*screen.pitch/4;
|
|
}
|
|
|
|
}
|
|
BlitDIB();
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
void I_InitGraphics(void)
|
|
{
|
|
|
|
static int firsttime=1;
|
|
int video_w, video_h, w, h;
|
|
byte video_bpp;
|
|
unsigned int video_flags;
|
|
|
|
if (!firsttime)
|
|
return;
|
|
firsttime = 0;
|
|
|
|
video_flags = (SDL_SWSURFACE|SDL_HWPALETTE);
|
|
if (!!M_CheckParm("-fullscreen"))
|
|
video_flags |= SDL_FULLSCREEN;
|
|
|
|
if (M_CheckParm("-2"))
|
|
multiply = 2;
|
|
|
|
if (M_CheckParm("-3"))
|
|
multiply = 3;
|
|
|
|
// check if the user wants to grab the mouse (quite unnice)
|
|
grabMouse = !!M_CheckParm("-grabmouse");
|
|
|
|
video_w = w = SCREENWIDTH * multiply;
|
|
video_h = h = SCREENHEIGHT * multiply;
|
|
video_bpp = 8;
|
|
|
|
|
|
if ( multiply > 3 ) {
|
|
I_Error("Smallest available mode (%dx%d) is too large!",
|
|
video_w, video_h);
|
|
}
|
|
screen = SDL_SetVideoMode(video_w, video_h, 8, video_flags);
|
|
if ( screen == NULL ) {
|
|
I_Error("Could not set %dx%d video mode: %s", video_w, video_h,
|
|
SDL_GetError());
|
|
}
|
|
SDL_ShowCursor(0);
|
|
SDL_WM_SetCaption("MenuetOS-DOOM", "doom");
|
|
|
|
w = SCREENWIDTH * multiply;
|
|
h = SCREENHEIGHT * multiply;
|
|
if (multiply == 1 && !SDL_MUSTLOCK(screen) ) {
|
|
screens[0] = (unsigned char *) screen->pixels;
|
|
} else {
|
|
screens[0] = (unsigned char *) malloc (SCREENWIDTH * SCREENHEIGHT);
|
|
if ( screens[0] == NULL )
|
|
I_Error("Couldn't allocate screen memory");
|
|
}
|
|
}
|
|
*****/ |