Readded SDL target (currently only stubbed).

macsrc/Makefile

 CC = gcc
 #CC = g++
 
-CFLAGS = -Wall -O6 -fomit-frame-pointer -ffast-math -funroll-loops -mpentiumpro -mcpu=pentiumpro -march=pentiumpro 
+#CFLAGS = -Wall -O6 -fomit-frame-pointer -ffast-math -funroll-loops -mpentiumpro -mcpu=pentiumpro -march=pentiumpro 
 #CFLAGS = -g -Wall -O6 -fomit-frame-pointer -ffast-math -funroll-loops -mpentiumpro -mcpu=pentiumpro -march=pentiumpro 
 CFLAGS = -g -Wall -ansi -pedantic
 #CFLAGS = -Os -g
 
+CFLAGS += `sdl-config --cflags`
+
 OBJS 	 = Data.o Doors.o EnMove.o EnThink.o Intro.o Level.o \
 	   Missiles.o Sounds.o PlMove.o PlStuff.o PlThink.o PushWall.o \
 	   RefBsp.o Refresh.o Refresh2.o Sight.o Main.o StateDef.o \
@@ -14,10 +16,9 @@ SOFTOBJS = RefSprite.o SoftDraw.o SoftDraw2.o
 OGLOBJS	 = GLDraw.o
 SOBJS	 = $(OBJS) $(SOFTOBJS) vi_svga.o
 XOBJS	 = $(OBJS) $(SOFTOBJS) vi_xlib.o
-XMOBJS   = $(OBJS) $(SOFTOBJS) vi_xm.o
 GOBJS	 = $(OBJS) $(SOFTOBJS) vi_gtk.o
 GLOBJS	 = $(OBJS) $(OGLOBJS)  vi_glx.o
-GLXMOBJS = $(OBJS) $(OGLOBJS)  vi_glxm.o
+DOBJS	 = $(OBJS) $(SOFTOBJS) vi_sdl.o
 
 LFLAGS = -lm 
 #LFLAGS = -lm /home/relnev/ElectricFence-2.1/libefence.a
@@ -28,17 +29,19 @@ SLFLAGS		= $(LFLAGS) -lvga
 XLFLAGS		= $(LFLAGS) -L/usr/X11R6/lib -lX11
 GLFLAGS		= $(LFLAGS) `gtk-config --libs` # -L/usr/X11R6/lib -lX11 -lXi -lXext -lgdk -lgtk 
 GLLFLAGS	= $(LFLAGS) -L/usr/lib -L/usr/X11R6/lib -lX11 -lXext -lGL
+DLFLAGS		= $(LFLAGS) `sdl-config --libs`
 
 NASM = nasm
 
 .SUFFIXES: .asm
 
-all:	swolf3d xwolf3d glwolf3d 
+all:	swolf3d xwolf3d glwolf3d sdlwolf3d
 
 $(SOBJS):  Sounds.h  Sprites.h  States.h  Wolf.h  burger.h  wolfdef.h
 $(XOBJS):  Sounds.h  Sprites.h  States.h  Wolf.h  burger.h  wolfdef.h
 $(GOBJS):  Sounds.h  Sprites.h  States.h  Wolf.h  burger.h  wolfdef.h
 $(GLOBJS): Sounds.h  Sprites.h  States.h  Wolf.h  burger.h  wolfdef.h
+$(DOBJS):  Sounds.h  Sprites.h  States.h  Wolf.h  burger.h  wolfdef.h
 
 .asm.o:
 	$(NASM) -f elf -o $@ $<
@@ -58,8 +61,11 @@ gwolf3d: $(GOBJS)
 glwolf3d: $(GLOBJS)
 	gcc -o glwolf3d $(GLOBJS) $(GLLFLAGS)
 
+sdlwolf3d: $(DOBJS)
+	gcc -o sdlwolf3d $(DOBJS) $(DLFLAGS)
+
 clean:
-	rm -rf swolf3d xwolf3d gwolf3d glwolf3d  *.o
+	rm -rf swolf3d xwolf3d gwolf3d glwolf3d sdlwolf3d *.o
 
 distclean: clean
 	rm -rf core *~ DEADJOE

macsrc/vi_sdl.c

+/*
+Copyright (C) 1992-1994 Id Software, Inc.
+Copyright (C) 2000,2001 Steven Fuller <relnev@atdot.org>
+
+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.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include <SDL/SDL.h>
+
+#include "wolfdef.h"
+
+
+Byte *gfxbuf;
+
+int main(int argc, char *argv[])
+{
+	if (argc != 2) {
+		fprintf(stderr, "usage: %s <mac wolf3d resource fork>\n", argv[0]);
+		exit(EXIT_FAILURE);
+	}
+	
+	if (InitResources(argv[1])) {
+		fprintf(stderr, "could not load %s\n", argv[1]);
+		exit(EXIT_FAILURE);
+	}
+	
+	InitData();
+	
+	GameViewSize = 3;	
+	NewGameWindow(GameViewSize); 
+
+	ClearTheScreen(BLACK);
+	BlastScreen();
+	
+	return WolfMain(argc, argv);
+}
+
+void Quit(char *str)
+{	
+	FreeResources();
+	
+	if (str && *str) {
+		fprintf(stderr, "%s\n", str);
+		exit(EXIT_FAILURE);
+	}
+	
+	exit(EXIT_SUCCESS);
+}
+
+void SetPalette(Byte *pal)
+{
+	int i;
+	
+	for (i = 0; i < 256; i++) {
+	}
+}
+	
+void BlastScreen2(Rect *BlastRect)
+{
+	BlastScreen();
+}
+
+int VidWidth, VidHeight, ViewHeight;
+#define w VidWidth
+#define h VidHeight
+#define v ViewHeight
+
+void BlastScreen()
+{
+	/* XPutImage(dpy, win, gc, img, 0, 0, 0, 0, w, h); */
+}
+
+Word VidXs[] = {320,512,640,640};       /* Screen sizes to play with */
+Word VidYs[] = {200,384,400,480};
+Word VidVs[] = {160,320,320,400};
+Word VidPics[] = {rFaceShapes,rFace512,rFace640,rFace640};
+Word VidSize = -1;
+
+Word NewGameWindow(Word NewVidSize)
+{
+	LongWord *LongPtr;
+	Byte *DestPtr;
+	int i;
+	
+	printf("Called: %d\n", NewVidSize);
+	
+	if (NewVidSize == VidSize)
+		return VidSize;
+	
+	printf("Setting Size: %d (from %d)\n", NewVidSize, VidSize);
+		
+	if (NewVidSize < 4) {
+		w = VidXs[NewVidSize];
+		h = VidYs[NewVidSize];
+		v = VidVs[NewVidSize];
+	} else {
+		fprintf(stderr, "Invalid Vid size: %d\n", NewVidSize);
+		exit(EXIT_FAILURE);
+	}
+	
+	/* Free Image */
+	
+	/* Resize Window */
+	
+	gfxbuf = (Byte *)malloc(w * h);
+	
+	/* Create Image */
+	
+	VideoPointer = gfxbuf;
+	VideoWidth = w;
+	InitYTable();
+	SetAPalette(rBlackPal);
+	ClearTheScreen(BLACK);
+	BlastScreen();
+	
+	LongPtr = (LongWord *) LoadAResource(VidPics[NewVidSize]);
+
+	if (GameShapes)
+		FreeSomeMem(GameShapes);
+		
+	GameShapes = (Byte **)AllocSomeMem(lMSB(LongPtr[0]));
+	DLZSS((Byte *)GameShapes, (Byte *)&LongPtr[1], lMSB(LongPtr[0]));
+	ReleaseAResource(VidPics[NewVidSize]);
+	
+	LongPtr = (LongWord *)GameShapes;
+	DestPtr = (Byte *)GameShapes;
+	for (i = 0; i < ((NewVidSize == 1) ? 57 : 47); i++) 
+		GameShapes[i] = DestPtr + lMSB(LongPtr[i]);
+	
+	VidSize = NewVidSize;
+	
+	return VidSize;
+}
+
+/* Keyboard Hack */
+static int RSJ;
+
+static int keys[128];
+
+void FlushKeys()
+{
+	joystick1 = 0;
+	memset(keys, 0, sizeof(keys));
+}
+
+struct {
+	char code[13];
+} CheatCodes[] = {
+{ "XUSCNIELPPA" }, /* "XUSCNIELPPA" */
+{ "IDDQD" }, /* "IDDQD" */
+{ "BURGER" }, /* "BURGER" */
+{ "WOWZERS" }, /* "WOWZERS" */
+{ "LEDOUX" }, /* "LEDOUX" */
+{ "SEGER" }, /* "SEGER" */
+{ "MCCALL" }, /* "MCCALL" */
+{ "APPLEIIGS" } /* "APPLEIIGS" */
+};
+const int CheatCount = sizeof(CheatCodes) / sizeof(CheatCodes[0]);
+int CheatIndex;
+
+#define SC_CURSORUPLEFT 	1
+#define SC_CURSORUP	  	2
+#define SC_CURSORUPRIGHT	3
+#define SC_CURSORRIGHT		4
+#define SC_CURSORDOWNRIGHT	5
+#define SC_CURSORDOWN		6
+#define SC_CURSORDOWNLEFT	7
+#define SC_CURSORLEFT		8
+#define SC_CURSORBLOCKLEFT	9
+#define SC_CURSORBLOCKRIGHT	10
+#define SC_CURSORBLOCKUP	11
+#define SC_CURSORBLOCKDOWN	12
+#define SC_KEYPADENTER		13
+#define SC_ENTER		14
+#define SC_SPACE		15
+#define SC_LEFTALT		16
+#define SC_RIGHTALT		17
+#define SC_LEFTCONTROL		18
+#define SC_RIGHTCONTROL		19
+#define SC_LEFTSHIFT		20
+#define SC_RIGHTSHIFT		21
+#define SC_B			22
+
+void UpdateKeys(int key, int press)
+{
+#if 0
+	switch(key) {
+		case XK_KP_Home:
+			keys[SC_CURSORUPLEFT] = press;
+			break;
+		case XK_KP_Up:
+			keys[SC_CURSORUP] = press;
+			break;
+		case XK_KP_Page_Up:
+			keys[SC_CURSORUPRIGHT] = press;
+			break;
+		case XK_KP_Right:
+			keys[SC_CURSORRIGHT] = press;
+			break;
+		case XK_KP_Page_Down:
+			keys[SC_CURSORDOWNRIGHT] = press;
+			break;
+		case XK_KP_Down:
+			keys[SC_CURSORDOWN] = press;
+			break;
+		case XK_KP_End:
+			keys[SC_CURSORDOWNLEFT] = press;
+			break;
+		case XK_KP_Left:
+			keys[SC_CURSORLEFT] = press;
+			break;
+			
+		case XK_Up:
+			keys[SC_CURSORBLOCKUP] = press;
+			break;
+		case XK_Down:
+			keys[SC_CURSORBLOCKDOWN] = press;
+			break;
+		case XK_Left:
+			keys[SC_CURSORBLOCKLEFT] = press;
+			break;
+		case XK_Right:
+			keys[SC_CURSORBLOCKRIGHT] = press;
+			break;
+			
+		case XK_KP_Enter:
+			keys[SC_KEYPADENTER] = press;
+			break;
+		case XK_Return:
+			keys[SC_ENTER] = press;
+			break;
+		case XK_space:
+			keys[SC_SPACE] = press;
+			break;
+		
+		case XK_Alt_L:
+			keys[SC_LEFTALT] = press;
+			break;
+		case XK_Alt_R:
+			keys[SC_RIGHTALT] = press;
+			break;
+		
+		case XK_Control_L:
+			keys[SC_LEFTCONTROL] = press;
+			break;
+		case XK_Control_R:
+			keys[SC_RIGHTCONTROL] = press;
+			break;
+		
+		case XK_Shift_L:
+			keys[SC_LEFTSHIFT] = press;
+			break;
+		case XK_Shift_R:
+			keys[SC_RIGHTSHIFT] = press;
+			break;
+				
+		case XK_b:
+			keys[SC_B] = press;
+			break;
+	}
+#endif
+
+}
+
+void keyboard_handler(int keycode, int press)
+{
+	UpdateKeys(keycode, press);
+
+	if (RSJ) {
+#if 0	
+		if (press == 0) {
+			int i;
+			
+			for (i = 0; i < CheatCount; i++) {
+				char *key = XKeysymToString(keycode);
+				if (key == NULL)
+					break;
+				if (strlen(key) != 1)
+					break;
+				if (CheatCodes[i].code[CheatIndex] == toupper(key[0])) {
+					CheatIndex++;
+					if (CheatCodes[i].code[CheatIndex] == 0) {
+						PlaySound(SND_BONUS);
+						switch (i) {
+						case 0:
+						case 4:
+							GiveKey(0);
+							GiveKey(1);
+							gamestate.godmode = TRUE;
+							break;
+						case 1:
+							gamestate.godmode^=TRUE;
+							break;
+						case 2:
+							gamestate.machinegun = TRUE;
+							gamestate.chaingun = TRUE;
+							gamestate.flamethrower = TRUE;
+							gamestate.missile = TRUE;
+							GiveAmmo(gamestate.maxammo);
+							GiveGas(99);
+							GiveMissile(99);
+							break;
+						case 3:
+							gamestate.maxammo = 999;
+							GiveAmmo(999);
+							break;
+						case 5:
+							GiveKey(0);
+							GiveKey(1);
+							break;
+						case 6:
+							playstate=EX_WARPED;
+							nextmap = gamestate.mapon+1;
+							if (MapListPtr->MaxMap<=nextmap) 
+								nextmap = 0;
+							break;
+						case 7:
+							ShowPush ^= TRUE;
+							break;
+						}
+						CheatIndex = 0;
+					}
+					break;
+				} 
+			}	
+			if (i == CheatCount) 
+				CheatIndex = 0;
+		}
+#endif
+				
+		joystick1 = 0;
+
+#if 0		
+		if (press == 0) {
+			switch(keycode) {
+			case XK_1:
+				gamestate.pendingweapon = WP_KNIFE;
+				break;
+			case XK_2:
+				if (gamestate.ammo) {
+					gamestate.pendingweapon = WP_PISTOL;
+				}	
+				break;
+			case XK_3:
+				if (gamestate.ammo && gamestate.machinegun) {
+					gamestate.pendingweapon = WP_MACHINEGUN;
+				}
+				break;
+			case XK_4:
+				if (gamestate.ammo && gamestate.chaingun) {
+					gamestate.pendingweapon = WP_CHAINGUN;
+				}
+				break;
+			case XK_5:
+				if (gamestate.gas && gamestate.flamethrower) {
+					gamestate.pendingweapon = WP_FLAMETHROWER;
+				}
+				break;
+			case XK_6:
+				if (gamestate.missiles && gamestate.missile) {
+					gamestate.pendingweapon = WP_MISSILE;
+				}
+				break;
+			case XK_period:
+			case XK_slash:
+				joystick1 = JOYPAD_START;
+				break;
+			case XK_Escape:
+				Quit(NULL); /* fast way out */
+			}
+		}
+#endif		
+		if (keys[SC_CURSORUPLEFT])
+			joystick1 |= (JOYPAD_UP|JOYPAD_LFT);
+		if (keys[SC_CURSORUP])
+			joystick1 |= JOYPAD_UP;
+		if (keys[SC_CURSORUPRIGHT])
+			joystick1 |= (JOYPAD_UP|JOYPAD_RGT);
+		if (keys[SC_CURSORRIGHT])
+			joystick1 |= JOYPAD_RGT;
+		if (keys[SC_CURSORDOWNRIGHT])
+			joystick1 |= (JOYPAD_DN|JOYPAD_RGT);
+		if (keys[SC_CURSORDOWN])
+			joystick1 |= JOYPAD_DN;
+		if (keys[SC_CURSORDOWNLEFT])
+			joystick1 |= (JOYPAD_DN|JOYPAD_LFT);
+		if (keys[SC_CURSORLEFT])
+			joystick1 |= JOYPAD_LFT;	
+		
+		if (keys[SC_CURSORBLOCKLEFT]) 
+			joystick1 |= JOYPAD_LFT;
+		if (keys[SC_CURSORBLOCKRIGHT])
+			joystick1 |= JOYPAD_RGT;
+		if (keys[SC_CURSORBLOCKUP])
+			joystick1 |= JOYPAD_UP;
+		if (keys[SC_CURSORBLOCKDOWN])
+			joystick1 |= JOYPAD_DN;
+		
+		if (keys[SC_KEYPADENTER])
+			joystick1 |= JOYPAD_A;	
+		if (keys[SC_ENTER])
+			joystick1 |= JOYPAD_A;
+		if (keys[SC_SPACE])
+			joystick1 |= JOYPAD_A;
+		
+		if (keys[SC_LEFTALT]) 
+			joystick1 |= JOYPAD_TR;
+		if (keys[SC_RIGHTALT])
+			joystick1 |= JOYPAD_TR;
+			
+		if (keys[SC_LEFTCONTROL])
+			joystick1 |= JOYPAD_B;
+		if (keys[SC_RIGHTCONTROL])
+			joystick1 |= JOYPAD_B;
+		
+		if (keys[SC_LEFTSHIFT])
+			joystick1 |= (JOYPAD_X|JOYPAD_Y);
+		if (keys[SC_RIGHTSHIFT])
+			joystick1 |= (JOYPAD_X|JOYPAD_Y);
+	}
+	
+	if ((joystick1 & (JOYPAD_LFT|JOYPAD_RGT)) == (JOYPAD_LFT|JOYPAD_RGT))
+		joystick1 &= ~(JOYPAD_LFT|JOYPAD_RGT);
+	if ((joystick1 & (JOYPAD_UP|JOYPAD_DN)) == (JOYPAD_UP|JOYPAD_DN))
+		joystick1 &= ~(JOYPAD_UP|JOYPAD_DN);
+		
+	if (joystick1 & JOYPAD_TR) {
+		if (joystick1 & JOYPAD_LFT) {
+			joystick1 = (joystick1 & ~(JOYPAD_TR|JOYPAD_LFT)) | JOYPAD_TL;
+		} else if (joystick1 & JOYPAD_RGT) {
+			joystick1 = joystick1 & ~JOYPAD_RGT;
+		} else {
+			joystick1 &= ~JOYPAD_TR;
+		}
+	}
+							
+}
+
+int HandleEvents()
+{
+#if 0
+	XEvent event;
+	int ret = 0;
+	
+	if (XPending(dpy)) {
+		do {
+			XNextEvent(dpy, &event);
+			switch(event.type) {
+				case KeyPress:
+					keyboard_handler(XKeycodeToKeysym(dpy, event.xkey.keycode, 0), 1);
+					ret = 1;
+					break; 
+				case KeyRelease:
+					keyboard_handler(XKeycodeToKeysym(dpy, event.xkey.keycode, 0), 0);
+					ret = 0;
+					break;
+				case Expose:
+					BlastScreen();
+					break;
+				case ClientMessage:
+					if (event.xclient.data.l[0] == wmDeleteWindow)
+						Quit(NULL);
+					break;
+				default:
+					break;
+			}
+		} while (XPending(dpy));
+	}
+	return ret;
+#else
+	return 0;
+#endif
+}
+
+void ReadSystemJoystick()
+{
+	RSJ = 1;
+	HandleEvents();
+}
+
+int DoEvents()
+{
+	RSJ = 0;
+	if (HandleEvents()) {
+		if (keys[SC_B]) { /* Special */
+			return 'B';
+		}
+		return 1;
+	}
+	return 0;
+}
+
+Word ChooseGameDiff()
+{
+/* 0 = easy, 1 = normal, 2 = hard, 3 = death incarnate */
+	difficulty = 1;
+	SetAPalette(rGamePal);
+
+	return 1;
+}