2587 lines
62 KiB
C
2587 lines
62 KiB
C
|
|
#ifdef __LINUX__ // AH
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <sys/types.h>
|
|
#include "SDL.h"
|
|
#else // __WIN32__
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <ddraw.h>
|
|
#include <initguid.h>
|
|
#include <mmsystem.h>
|
|
#include <math.h>
|
|
#include <dsound.h>
|
|
#include <dinput.h>
|
|
#include <winuser.h>
|
|
#include "resource.h"
|
|
#endif // __LINUX__
|
|
|
|
#define BYTE unsigned char
|
|
#define WORD unsigned short
|
|
#define DWORD unsigned long
|
|
|
|
BYTE Tester[]={"WinTest1"};
|
|
|
|
DWORD WindowWidth = 256;
|
|
DWORD WindowHeight = 224;
|
|
DWORD FullScreen = 0;
|
|
BYTE TestID1[]={""};
|
|
DWORD Moving= 0;
|
|
DWORD SoundBufferSize=1024*18;
|
|
DWORD FirstSound=1;
|
|
int AllowDefault=0;
|
|
int SoundEnabled=1;
|
|
|
|
#ifdef __LINUX__ // AH
|
|
typedef enum {TRUE, FALSE} BOOL;
|
|
typedef void *HWND;
|
|
typedef void *MSG;
|
|
typedef void *HINSTANCE;
|
|
typedef void *LPVOID;
|
|
typedef void *DEVMODE;
|
|
typedef Uint32 UINT32;
|
|
typedef long long _int64;
|
|
typedef long long LARGE_INTEGER;
|
|
typedef int HRESULT;
|
|
#define STUB_FUNCTION fprintf(stderr,"STUB: %s at " __FILE__ ", line %d, thread %d\n",__FUNCTION__,__LINE__,getpid())
|
|
#define FAR
|
|
#define PASCAL
|
|
#endif // __LINUX__
|
|
|
|
HWND hMainWindow;
|
|
|
|
HINSTANCE hInst;
|
|
|
|
#ifndef __LINUX__ // AH
|
|
LPDIRECTSOUND lpDirectSound;
|
|
LPDIRECTSOUNDBUFFER SoundBuffer;
|
|
LPDIRECTSOUNDBUFFER lpPrimaryBuffer;
|
|
DSBUFFERDESC dsbd;
|
|
#else
|
|
SDL_Surface *surface;
|
|
int sdl_inited = 0;
|
|
#endif // __LINUX__
|
|
|
|
LPVOID lpvPtr1;
|
|
DWORD dwBytes1;
|
|
LPVOID lpvPtr2;
|
|
DWORD dwBytes2;
|
|
|
|
#ifndef __LINUX__ // AH
|
|
//LPDIRECTDRAW BasiclpDD = NULL;
|
|
|
|
LPDIRECTDRAW2 lpDD = NULL;
|
|
LPDIRECTDRAWSURFACE DD_Primary = NULL;
|
|
LPDIRECTDRAWSURFACE DD_CFB = NULL;
|
|
LPDIRECTDRAWCLIPPER lpDDClipper =NULL;
|
|
RECT rcWindow;
|
|
|
|
LPDIRECTINPUT DInput;
|
|
LPDIRECTINPUTDEVICE MouseInput;
|
|
LPDIRECTINPUTDEVICE KeyboardInput;
|
|
LPDIRECTINPUTDEVICE7 JoystickInput[4];
|
|
DIJOYSTATE js[4];
|
|
#endif // __LINUX__
|
|
|
|
DWORD X1Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD X2Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD Y1Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD Y2Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD Z1Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD Z2Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD RX1Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD RX2Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD RY1Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD RY2Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD RZ1Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD RZ2Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD S01Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD S02Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD S11Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
DWORD S12Disable[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
|
|
DWORD CurrentJoy=0;
|
|
|
|
DWORD BitDepth;
|
|
BYTE BackColor=0;
|
|
DEVMODE mode;
|
|
|
|
int DTimerCheck;
|
|
float MouseMinX=0;
|
|
float MouseMaxX=256;
|
|
float MouseMinY=0;
|
|
float MouseMaxY=223;
|
|
int MouseX;
|
|
int MouseY;
|
|
float MouseMoveX;
|
|
float MouseMoveY;
|
|
int MouseMove2X;
|
|
int MouseMove2Y;
|
|
|
|
DWORD SurfaceX=0;
|
|
DWORD SurfaceY=0;
|
|
|
|
Uint8 MouseButton;
|
|
|
|
|
|
#define UPDATE_TICKS_GAME 1000/60 // milliseconds per world update
|
|
#define UPDATE_TICKS_GAMEPAL 1000/50 // milliseconds per world update
|
|
#define UPDATE_TICKS_GUI 1000/36 // milliseconds per world update
|
|
#define UPDATE_TICKS_UDP 1000/60 // milliseconds per world update
|
|
|
|
_int64 start, end, freq, update_ticks_pc, start2, end2, update_ticks_pc2;
|
|
|
|
|
|
extern unsigned char pressed[];
|
|
|
|
void drawscreenwin(void);
|
|
void Init_2xSaI(UINT32 BitFormat);
|
|
DWORD LastUsedPos=0;
|
|
DWORD CurMode=-1;
|
|
|
|
DWORD InputEn=0;
|
|
BOOL InputAcquire(void)
|
|
{
|
|
#ifdef __LINUX__ // AH
|
|
STUB_FUNCTION;
|
|
#else // __WIN32__
|
|
if(JoystickInput[0]) JoystickInput[0]->Acquire();
|
|
if(JoystickInput[1]) JoystickInput[1]->Acquire();
|
|
if(JoystickInput[2]) JoystickInput[2]->Acquire();
|
|
if(JoystickInput[3]) JoystickInput[3]->Acquire();
|
|
|
|
if(MouseInput) MouseInput->Acquire();
|
|
if(KeyboardInput) KeyboardInput->Acquire();
|
|
InputEn=1;
|
|
return TRUE;
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
BOOL InputDeAcquire(void)
|
|
{
|
|
#ifdef __LINUX__ // AH
|
|
STUB_FUNCTION;
|
|
#else // __WIN32__
|
|
if(MouseInput) { MouseInput->Unacquire(); }
|
|
if(KeyboardInput) KeyboardInput->Unacquire();
|
|
if(JoystickInput[0]) JoystickInput[0]->Unacquire();
|
|
if(JoystickInput[1]) JoystickInput[1]->Unacquire();
|
|
if(JoystickInput[2]) JoystickInput[2]->Unacquire();
|
|
if(JoystickInput[3]) JoystickInput[3]->Unacquire();
|
|
#endif // __LINUX__
|
|
InputEn=0;
|
|
return TRUE;
|
|
}
|
|
|
|
unsigned char keyboardhit=0;
|
|
void initwinvideo();
|
|
extern BYTE StereoSound;
|
|
extern DWORD SoundQuality;
|
|
extern int CurKeyPos;
|
|
extern int CurKeyReadPos;
|
|
extern int KeyBuffer[16];
|
|
|
|
|
|
BYTE PrevStereoSound;
|
|
DWORD PrevSoundQuality;
|
|
|
|
void ExitFunction(void)
|
|
{
|
|
#ifdef __LINUX__
|
|
STUB_FUNCTION;
|
|
#else
|
|
ChangeDisplaySettings(NULL,0);
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
#ifdef __LINUX__ // AH
|
|
int shiftptr = 0;
|
|
void ProcessKeyBuf(int scancode);
|
|
|
|
int Main_Proc(void)
|
|
{
|
|
// TODO: Main event loop
|
|
SDL_Event event;
|
|
|
|
//STUB_FUNCTION;
|
|
while (SDL_PollEvent(&event)) {
|
|
switch(event.type)
|
|
{
|
|
case SDL_KEYDOWN:
|
|
if (event.key.keysym.sym == SDLK_LSHIFT ||
|
|
event.key.keysym.sym == SDLK_RSHIFT)
|
|
shiftptr = 1;
|
|
if (event.key.keysym.scancode-8 > 0) {
|
|
if (pressed[event.key.keysym.scancode-8]!=2)
|
|
pressed[event.key.keysym.scancode-8]=1;
|
|
ProcessKeyBuf(event.key.keysym.sym);
|
|
}
|
|
break;
|
|
case SDL_KEYUP:
|
|
if (event.key.keysym.sym == SDLK_LSHIFT ||
|
|
event.key.keysym.sym == SDLK_RSHIFT)
|
|
shiftptr = 0;
|
|
if (event.key.keysym.scancode-8 > 0)
|
|
pressed[event.key.keysym.scancode-8]=0;
|
|
break;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
#define true 1
|
|
|
|
void ProcessKeyBuf(int scancode)
|
|
{
|
|
int accept = 0;
|
|
int vkeyval;
|
|
|
|
if (((scancode>='A') && (scancode<='Z')) ||
|
|
((scancode>='a') && (scancode<='z')) || (scancode==27) ||
|
|
(scancode==32) || (scancode==8) || (scancode==13) || (scancode==9)) {
|
|
accept=true; vkeyval=scancode;
|
|
}
|
|
if ((scancode>='0') && (scancode<='9')) {
|
|
accept=1; vkeyval=scancode;
|
|
if (shiftptr) {
|
|
switch (scancode) {
|
|
case '1': vkeyval='!'; break;
|
|
case '2': vkeyval='@'; break;
|
|
case '3': vkeyval='#'; break;
|
|
case '4': vkeyval='$'; break;
|
|
case '5': vkeyval='%'; break;
|
|
case '6': vkeyval='^'; break;
|
|
case '7': vkeyval='&'; break;
|
|
case '8': vkeyval='*'; break;
|
|
case '9': vkeyval='('; break;
|
|
case '0': vkeyval=')'; break;
|
|
}
|
|
}
|
|
}
|
|
if ((scancode>=256) && (scancode<=265)) {
|
|
accept=true; vkeyval=scancode-256+'0';
|
|
}
|
|
if (!shiftptr){
|
|
switch (scancode) {
|
|
// Fix these for proper SDL usage - DDOI
|
|
case 189: vkeyval='-'; accept=true; break;
|
|
case 187: vkeyval='='; accept=true; break;
|
|
case 219: vkeyval='['; accept=true; break;
|
|
case 221: vkeyval=']'; accept=true; break;
|
|
case 186: vkeyval=';'; accept=true; break;
|
|
case 222: vkeyval=39; accept=true; break;
|
|
case 188: vkeyval=','; accept=true; break;
|
|
case 190: vkeyval='.'; accept=true; break;
|
|
case 191: vkeyval='/'; accept=true; break;
|
|
case 192: vkeyval='`'; accept=true; break;
|
|
case 220: vkeyval=92; accept=true; break;
|
|
}
|
|
} else {
|
|
switch (scancode) {
|
|
// Fix these for proper SDL usage - DDOI
|
|
case 189: vkeyval='_'; accept=true; break;
|
|
case 187: vkeyval='+'; accept=true; break;
|
|
case 219: vkeyval='{'; accept=true; break;
|
|
case 221: vkeyval='}'; accept=true; break;
|
|
case 186: vkeyval=':'; accept=true; break;
|
|
case 222: vkeyval='"'; accept=true; break;
|
|
case 188: vkeyval='<'; accept=true; break;
|
|
case 190: vkeyval='>'; accept=true; break;
|
|
case 191: vkeyval='?'; accept=true; break;
|
|
case 192: vkeyval='~'; accept=true; break;
|
|
case 220: vkeyval='|'; accept=true; break;
|
|
}
|
|
}
|
|
switch (scancode) {
|
|
// Fix these for proper SDL usage - DDOI
|
|
case 33: vkeyval=256+73; accept=true; break;
|
|
case 38: vkeyval=256+72; accept=true; break;
|
|
case 36: vkeyval=256+71; accept=true; break;
|
|
case 39: vkeyval=256+77; accept=true; break;
|
|
case 12: vkeyval=256+76; accept=true; break;
|
|
case 37: vkeyval=256+75; accept=true; break;
|
|
case 34: vkeyval=256+81; accept=true; break;
|
|
case 40: vkeyval=256+80; accept=true; break;
|
|
case 35: vkeyval=256+79; accept=true; break;
|
|
case 107: vkeyval='+'; accept=true; break;
|
|
case 109: vkeyval='-'; accept=true; break;
|
|
case 106: vkeyval='*'; accept=true; break;
|
|
case 111: vkeyval='/'; accept=true; break;
|
|
case 110: vkeyval='.'; accept=true; break;
|
|
}
|
|
if (accept){
|
|
KeyBuffer[CurKeyPos]=vkeyval;
|
|
CurKeyPos++;
|
|
if (CurKeyPos==16) CurKeyPos=0;
|
|
}
|
|
}
|
|
#else // __WIN32__
|
|
LRESULT CALLBACK Main_Proc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static bool shiftpr;
|
|
bool accept;
|
|
int vkeyval;
|
|
short zDelta;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_KEYDOWN: // sent when user presses a key
|
|
if (!((CurKeyPos+1==CurKeyReadPos) || ((CurKeyPos+1==16)
|
|
&& (CurKeyReadPos==0)))){
|
|
accept=false;
|
|
|
|
// char bla[256];
|
|
// sprintf(bla,"%d",wParam);
|
|
// MessageBox(NULL,bla,"Key",MB_SYSTEMMODAL|MB_OK);
|
|
|
|
if (wParam==16)
|
|
shiftpr=true;
|
|
if (((wParam>='A') && (wParam<='Z')) ||
|
|
((wParam>='a') && (wParam<='z')) || (wParam==27) ||
|
|
(wParam==32) || (wParam==8) || (wParam==13) || (wParam==9)) {
|
|
accept=true; vkeyval=wParam;
|
|
}
|
|
if ((wParam>='0') && (wParam<='9')) {
|
|
accept=true; vkeyval=wParam;
|
|
if (shiftpr) {
|
|
switch (wParam) {
|
|
case '1': vkeyval='!'; break;
|
|
case '2': vkeyval='@'; break;
|
|
case '3': vkeyval='#'; break;
|
|
case '4': vkeyval='$'; break;
|
|
case '5': vkeyval='%'; break;
|
|
case '6': vkeyval='^'; break;
|
|
case '7': vkeyval='&'; break;
|
|
case '8': vkeyval='*'; break;
|
|
case '9': vkeyval='('; break;
|
|
case '0': vkeyval=')'; break;
|
|
}
|
|
}
|
|
}
|
|
if ((wParam>=VK_NUMPAD0) && (wParam<=VK_NUMPAD9)) {
|
|
accept=true; vkeyval=wParam-VK_NUMPAD0+'0';
|
|
}
|
|
if (!shiftpr){
|
|
switch (wParam) {
|
|
case 189: vkeyval='-'; accept=true; break;
|
|
case 187: vkeyval='='; accept=true; break;
|
|
case 219: vkeyval='['; accept=true; break;
|
|
case 221: vkeyval=']'; accept=true; break;
|
|
case 186: vkeyval=';'; accept=true; break;
|
|
case 222: vkeyval=39; accept=true; break;
|
|
case 188: vkeyval=','; accept=true; break;
|
|
case 190: vkeyval='.'; accept=true; break;
|
|
case 191: vkeyval='/'; accept=true; break;
|
|
case 192: vkeyval='`'; accept=true; break;
|
|
case 220: vkeyval=92; accept=true; break;
|
|
}
|
|
} else {
|
|
switch (wParam) {
|
|
case 189: vkeyval='_'; accept=true; break;
|
|
case 187: vkeyval='+'; accept=true; break;
|
|
case 219: vkeyval='{'; accept=true; break;
|
|
case 221: vkeyval='}'; accept=true; break;
|
|
case 186: vkeyval=':'; accept=true; break;
|
|
case 222: vkeyval='"'; accept=true; break;
|
|
case 188: vkeyval='<'; accept=true; break;
|
|
case 190: vkeyval='>'; accept=true; break;
|
|
case 191: vkeyval='?'; accept=true; break;
|
|
case 192: vkeyval='~'; accept=true; break;
|
|
case 220: vkeyval='|'; accept=true; break;
|
|
}
|
|
}
|
|
switch (wParam) {
|
|
case 33: vkeyval=256+73; accept=true; break;
|
|
case 38: vkeyval=256+72; accept=true; break;
|
|
case 36: vkeyval=256+71; accept=true; break;
|
|
case 39: vkeyval=256+77; accept=true; break;
|
|
case 12: vkeyval=256+76; accept=true; break;
|
|
case 37: vkeyval=256+75; accept=true; break;
|
|
case 34: vkeyval=256+81; accept=true; break;
|
|
case 40: vkeyval=256+80; accept=true; break;
|
|
case 35: vkeyval=256+79; accept=true; break;
|
|
case 107: vkeyval='+'; accept=true; break;
|
|
case 109: vkeyval='-'; accept=true; break;
|
|
case 106: vkeyval='*'; accept=true; break;
|
|
case 111: vkeyval='/'; accept=true; break;
|
|
case 110: vkeyval='.'; accept=true; break;
|
|
}
|
|
if (accept){
|
|
KeyBuffer[CurKeyPos]=vkeyval;
|
|
CurKeyPos++;
|
|
if (CurKeyPos==16) CurKeyPos=0;
|
|
}
|
|
}
|
|
break;
|
|
case WM_KEYUP: // sent when user releases a key
|
|
if (wParam==16)
|
|
shiftpr=false;
|
|
break;
|
|
case WM_MOUSEMOVE:
|
|
if(MouseInput) MouseInput->Acquire();
|
|
break;
|
|
/* case 0x020A:
|
|
zDelta = (short) HIWORD(wParam);
|
|
zDelta=120;
|
|
while (zDelta>0){
|
|
zDelta-=120;
|
|
if (!((CurKeyPos+1==CurKeyReadPos) || ((CurKeyPos+1==16)
|
|
&& (CurKeyReadPos==0)))){
|
|
KeyBuffer[CurKeyPos]=72+256;
|
|
CurKeyPos++;
|
|
if (CurKeyPos==16) CurKeyPos=0;
|
|
}
|
|
}
|
|
while (zDelta<0){
|
|
zDelta+=120;
|
|
if (!((CurKeyPos+1==CurKeyReadPos) || ((CurKeyPos+1==16)
|
|
&& (CurKeyReadPos==0)))){
|
|
KeyBuffer[CurKeyPos]=72+256;
|
|
CurKeyPos++;
|
|
if (CurKeyPos==16) CurKeyPos=0;
|
|
}
|
|
}
|
|
break;*/
|
|
case WM_MOVE:
|
|
initwinvideo();
|
|
break;
|
|
case WM_PAINT:
|
|
ValidateRect(hWnd,NULL);
|
|
break;
|
|
case WM_ACTIVATE:
|
|
if(LOWORD(wParam)==WA_INACTIVE)
|
|
{
|
|
ChangeDisplaySettings(NULL,0);
|
|
}
|
|
else
|
|
{
|
|
if(FullScreen==1)
|
|
{
|
|
ChangeDisplaySettings(&mode,0);
|
|
}
|
|
initwinvideo();
|
|
}
|
|
InputAcquire();
|
|
break;
|
|
case WM_SETFOCUS:
|
|
if(FullScreen==1)
|
|
{
|
|
ChangeDisplaySettings(&mode,0);
|
|
}
|
|
ShowWindow(hMainWindow, SW_SHOWNORMAL);
|
|
InputAcquire();
|
|
break;
|
|
case WM_KILLFOCUS:
|
|
ChangeDisplaySettings(NULL,0);
|
|
InputDeAcquire();
|
|
break;
|
|
case WM_DESTROY:
|
|
ChangeDisplaySettings(NULL,0);
|
|
PostQuitMessage(0);
|
|
break;
|
|
case WM_SETTEXT:
|
|
case WM_SHOWWINDOW:
|
|
case WM_SETTINGCHANGE:
|
|
case WM_SETICON:
|
|
case WM_CREATE:
|
|
case WM_SETREDRAW:
|
|
return DefWindowProc(hWnd,uMsg,wParam,lParam);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
#endif // __LINUX__
|
|
|
|
#ifdef __LINUX__ // AH
|
|
int RegisterWinClass ( void )
|
|
{
|
|
// TODO: WM stuff goes here
|
|
STUB_FUNCTION;
|
|
return TRUE;
|
|
}
|
|
#else // __WIN32__
|
|
int RegisterWinClass ( void )
|
|
{
|
|
WNDCLASS wcl;
|
|
|
|
wcl.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW | CS_NOCLOSE ;
|
|
wcl.cbClsExtra = 0;
|
|
wcl.cbWndExtra = 0;
|
|
wcl.hIcon = LoadIcon(NULL,IDI_APPLICATION);
|
|
wcl.hCursor = NULL;
|
|
wcl.hInstance = hInst;
|
|
|
|
wcl.lpfnWndProc = (WNDPROC)Main_Proc;
|
|
wcl.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
wcl.lpszMenuName = NULL;
|
|
wcl.lpszClassName = "ZSNESWIN";
|
|
|
|
if (RegisterClass(&wcl) == 0) return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
#endif // __LINUX__
|
|
|
|
void ShutdownApplication()
|
|
{
|
|
|
|
}
|
|
|
|
#ifdef __LINUX__
|
|
|
|
void UpdateSound(void *userdata, Uint8 *stream, int len);
|
|
|
|
int InitSound (void)
|
|
{
|
|
SDL_AudioSpec wanted;
|
|
const int freqtab[7] = { 8000, 11025, 22050, 44100, 16000, 32000, 48000 };
|
|
const int samptab[7] = { 64, 64, 128, 256, 128, 256, 256 };
|
|
|
|
SDL_LockAudio(); /* wait for callback to finish */
|
|
|
|
SDL_CloseAudio();
|
|
|
|
if (!SoundEnabled) return FALSE;
|
|
|
|
PrevSoundQuality = SoundQuality;
|
|
PrevStereoSound = StereoSound;
|
|
|
|
if (SoundQuality > 6)
|
|
SoundQuality = 1;
|
|
wanted.freq = freqtab[SoundQuality];
|
|
|
|
if (StereoSound) {
|
|
wanted.channels = 2;
|
|
} else {
|
|
wanted.channels = 1;
|
|
}
|
|
|
|
//wanted.samples = (wanted.freq / 60) * 2 * wanted.channels;
|
|
wanted.samples = samptab[SoundQuality] * 2 * wanted.channels;
|
|
wanted.format = AUDIO_S16LSB;
|
|
wanted.userdata = NULL;
|
|
wanted.callback = UpdateSound;
|
|
|
|
if (SDL_OpenAudio(&wanted, NULL) < 0) {
|
|
fprintf(stderr, "Sound init failed!\n");
|
|
fprintf(stderr, "freq: %d, channels: %d, samples: %d\n", wanted.freq, wanted.channels, wanted.samples);
|
|
SoundEnabled = 0;
|
|
return FALSE;
|
|
}
|
|
SDL_PauseAudio(0);
|
|
|
|
SDL_UnlockAudio();
|
|
|
|
return TRUE;
|
|
}
|
|
#else // __WIN32__
|
|
InitSound()
|
|
{
|
|
HRESULT hr;
|
|
WAVEFORMATEX wfx;
|
|
|
|
if (!SoundEnabled) return FALSE;
|
|
|
|
PrevSoundQuality=SoundQuality;
|
|
PrevStereoSound=StereoSound;
|
|
|
|
if(DS_OK == DirectSoundCreate(NULL, &lpDirectSound,NULL))
|
|
{
|
|
hr = lpDirectSound->SetCooperativeLevel(hMainWindow, DSSCL_NORMAL );
|
|
if (hr != DS_OK) {SoundEnabled=0; return FALSE;}
|
|
}
|
|
else
|
|
{
|
|
SoundEnabled=0; return FALSE;
|
|
}
|
|
|
|
wfx.wFormatTag = WAVE_FORMAT_PCM;
|
|
switch(SoundQuality)
|
|
{
|
|
case 0:
|
|
wfx.nSamplesPerSec = 8000;
|
|
SoundBufferSize=1024*2;
|
|
break;
|
|
case 1:
|
|
wfx.nSamplesPerSec = 11025;
|
|
SoundBufferSize=1024*2;
|
|
break;
|
|
case 2:
|
|
wfx.nSamplesPerSec = 22050;
|
|
SoundBufferSize=1024*4;
|
|
break;
|
|
case 3:
|
|
wfx.nSamplesPerSec = 44100;
|
|
SoundBufferSize=1024*8;
|
|
break;
|
|
case 4:
|
|
wfx.nSamplesPerSec = 16000;
|
|
SoundBufferSize=1024*4;
|
|
break;
|
|
case 5:
|
|
wfx.nSamplesPerSec = 32000;
|
|
SoundBufferSize=1024*8;
|
|
break;
|
|
case 6:
|
|
wfx.nSamplesPerSec = 48000;
|
|
SoundBufferSize=1024*8;
|
|
break;
|
|
default:
|
|
wfx.nSamplesPerSec = 11025;
|
|
}
|
|
|
|
if(StereoSound==1)
|
|
{
|
|
wfx.nChannels = 2;
|
|
wfx.nBlockAlign = 4;
|
|
SoundBufferSize*=2;
|
|
}
|
|
else
|
|
{
|
|
wfx.nChannels = 1;
|
|
wfx.nBlockAlign = 2;
|
|
}
|
|
|
|
wfx.wBitsPerSample = 16;
|
|
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
|
|
wfx.cbSize=0;
|
|
|
|
memset(&dsbd, 0, sizeof(DSBUFFERDESC));
|
|
dsbd.dwSize = sizeof(DSBUFFERDESC);
|
|
dsbd.dwFlags = DSBCAPS_STICKYFOCUS; // | DSBCAPS_PRIMARYBUFFER;
|
|
dsbd.dwBufferBytes = SoundBufferSize;
|
|
dsbd.lpwfxFormat = &wfx;
|
|
|
|
hr = lpDirectSound->CreateSoundBuffer(&dsbd, &SoundBuffer, NULL);
|
|
|
|
if(DS_OK == hr)
|
|
{
|
|
if(DS_OK != SoundBuffer->Play(0,0,DSBPLAY_LOOPING ))
|
|
{
|
|
SoundEnabled=0; return FALSE;
|
|
}
|
|
FirstSound=0;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
SoundEnabled=0; return FALSE;
|
|
}
|
|
|
|
}
|
|
#endif // __LINUX__
|
|
|
|
#ifdef __LINUX__ // AH
|
|
int ReInitSound(void)
|
|
{
|
|
return InitSound();
|
|
}
|
|
#else // __WIN32__
|
|
ReInitSound()
|
|
{
|
|
HRESULT hr;
|
|
WAVEFORMATEX wfx;
|
|
|
|
if (!SoundEnabled) return FALSE;
|
|
|
|
SoundBuffer->Stop();
|
|
SoundBuffer->Release();
|
|
|
|
PrevSoundQuality=SoundQuality;
|
|
PrevStereoSound=StereoSound;
|
|
|
|
|
|
wfx.wFormatTag = WAVE_FORMAT_PCM;
|
|
switch(SoundQuality)
|
|
{
|
|
case 0:
|
|
wfx.nSamplesPerSec = 8000;
|
|
SoundBufferSize=1024*2;
|
|
break;
|
|
case 1:
|
|
wfx.nSamplesPerSec = 11025;
|
|
SoundBufferSize=1024*2;
|
|
break;
|
|
case 2:
|
|
wfx.nSamplesPerSec = 22050;
|
|
SoundBufferSize=1024*4;
|
|
break;
|
|
case 3:
|
|
wfx.nSamplesPerSec = 44100;
|
|
SoundBufferSize=1024*8;
|
|
break;
|
|
case 4:
|
|
wfx.nSamplesPerSec = 16000;
|
|
SoundBufferSize=1024*4;
|
|
break;
|
|
case 5:
|
|
wfx.nSamplesPerSec = 32000;
|
|
SoundBufferSize=1024*8;
|
|
break;
|
|
case 6:
|
|
wfx.nSamplesPerSec = 48000;
|
|
SoundBufferSize=1024*8;
|
|
break;
|
|
|
|
default:
|
|
wfx.nSamplesPerSec = 11025;
|
|
}
|
|
|
|
if(StereoSound==1)
|
|
{
|
|
wfx.nChannels = 2;
|
|
wfx.nBlockAlign = 4;
|
|
SoundBufferSize*=2;
|
|
}
|
|
else
|
|
{
|
|
wfx.nChannels = 1;
|
|
wfx.nBlockAlign = 2;
|
|
}
|
|
|
|
wfx.wBitsPerSample = 16;
|
|
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
|
|
wfx.cbSize=0;
|
|
|
|
memset(&dsbd, 0, sizeof(DSBUFFERDESC));
|
|
dsbd.dwSize = sizeof(DSBUFFERDESC);
|
|
dsbd.dwFlags = DSBCAPS_STICKYFOCUS;
|
|
dsbd.dwBufferBytes = SoundBufferSize;
|
|
dsbd.lpwfxFormat = &wfx;
|
|
|
|
hr = lpDirectSound->CreateSoundBuffer(&dsbd, &SoundBuffer, NULL);
|
|
|
|
if(DS_OK == hr)
|
|
{
|
|
if(DS_OK != SoundBuffer->Play(0,0,DSBPLAY_LOOPING ))
|
|
{
|
|
return FALSE;
|
|
}
|
|
LastUsedPos=0;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
#endif // __LINUX__
|
|
|
|
#ifdef __LINUX__ // AH
|
|
BOOL InitJoystickInput(void)
|
|
{
|
|
STUB_FUNCTION;
|
|
return TRUE;
|
|
}
|
|
#else // __WIN32__
|
|
BOOL FAR PASCAL InitJoystickInput(LPCDIDEVICEINSTANCE pdinst, LPVOID pvRef)
|
|
{
|
|
LPDIRECTINPUT7 pdi = (LPDIRECTINPUT7)pvRef;
|
|
// fprintf(tempf,"Cur :%d %X\n",CurrentJoy,pdinst->guidInstance);
|
|
GUID DeviceGuid = pdinst->guidInstance;
|
|
|
|
if(CurrentJoy>3)
|
|
return DIENUM_CONTINUE;
|
|
|
|
// Create the DirectInput joystick device.
|
|
if (pdi->CreateDeviceEx(DeviceGuid,IID_IDirectInputDevice7,
|
|
(void**)&JoystickInput[CurrentJoy], NULL) != DI_OK)
|
|
{
|
|
// fprintf(tempf,"IDirectInput7::CreateDeviceEx FAILED\n");
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
if (JoystickInput[CurrentJoy]->SetDataFormat(&c_dfDIJoystick) != DI_OK)
|
|
{
|
|
// fprintf(tempf,"IDirectInputDevice7::SetDataFormat FAILED\n");
|
|
JoystickInput[CurrentJoy]->Release();
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
if(JoystickInput[CurrentJoy]->SetCooperativeLevel(hMainWindow,
|
|
DISCL_NONEXCLUSIVE | DISCL_FOREGROUND) != DI_OK)
|
|
{
|
|
// fprintf(tempf,"IDirectInputDevice7::SetCooperativeLevel FAILED\n");
|
|
JoystickInput[CurrentJoy]->Release();
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
|
|
|
|
DIPROPRANGE diprg;
|
|
|
|
diprg.diph.dwSize = sizeof(diprg);
|
|
diprg.diph.dwHeaderSize = sizeof(diprg.diph);
|
|
diprg.diph.dwObj = DIJOFS_X;
|
|
diprg.diph.dwHow = DIPH_BYOFFSET;
|
|
diprg.lMin = -1000;
|
|
diprg.lMax = +1000;
|
|
|
|
if FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph))
|
|
{
|
|
// fprintf(tempf,"IDirectInputDevice7::SetProperty(DIPH_RANGE) FAILED\n");
|
|
// JoystickInput[CurrentJoy]->Release();
|
|
// return FALSE;
|
|
X1Disable[CurrentJoy]=1;
|
|
X2Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
diprg.diph.dwObj = DIJOFS_Y;
|
|
|
|
if FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph))
|
|
{
|
|
// fprintf(tempf,"IDirectInputDevice7::SetProperty(DIPH_RANGE) FAILED\n");
|
|
// JoystickInput[CurrentJoy]->Release();
|
|
// return FALSE;
|
|
Y1Disable[CurrentJoy]=1;
|
|
Y2Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
|
|
|
|
diprg.diph.dwObj = DIJOFS_Z;
|
|
if(FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph)))
|
|
{
|
|
Z1Disable[CurrentJoy]=1;
|
|
Z2Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
diprg.diph.dwObj = DIJOFS_RX;
|
|
if(FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph)))
|
|
{
|
|
RX1Disable[CurrentJoy]=1;
|
|
RX2Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
diprg.diph.dwObj = DIJOFS_RY;
|
|
if(FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph)))
|
|
{
|
|
RY1Disable[CurrentJoy]=1;
|
|
RY2Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
diprg.diph.dwObj = DIJOFS_RZ;
|
|
if(FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph)))
|
|
{
|
|
RZ1Disable[CurrentJoy]=1;
|
|
RZ2Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
diprg.diph.dwObj = DIJOFS_SLIDER(0);
|
|
if(FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph)))
|
|
{
|
|
S01Disable[CurrentJoy]=1;
|
|
S02Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
diprg.diph.dwObj = DIJOFS_SLIDER(1);
|
|
if(FAILED(JoystickInput[CurrentJoy]->SetProperty(DIPROP_RANGE, &diprg.diph)))
|
|
{
|
|
S11Disable[CurrentJoy]=1;
|
|
S12Disable[CurrentJoy]=1;
|
|
}
|
|
|
|
|
|
|
|
|
|
DIPROPDWORD dipdw;
|
|
|
|
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
|
|
dipdw.diph.dwHeaderSize = sizeof(dipdw.diph);
|
|
dipdw.diph.dwHow = DIPH_BYOFFSET;
|
|
dipdw.dwData = 2500;
|
|
dipdw.diph.dwObj = DIJOFS_X;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_Y;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_Z;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_RX;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_RY;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_RZ;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_SLIDER(0);
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
dipdw.diph.dwObj = DIJOFS_SLIDER(1);
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_DEADZONE, &dipdw.diph);
|
|
|
|
|
|
|
|
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
|
|
dipdw.diph.dwHeaderSize = sizeof(dipdw.diph);
|
|
dipdw.diph.dwHow = DIPH_DEVICE;
|
|
dipdw.dwData = DIPROPAXISMODE_ABS;
|
|
dipdw.diph.dwObj = 0;
|
|
JoystickInput[CurrentJoy]->SetProperty(DIPROP_AXISMODE, &dipdw.diph);
|
|
|
|
CurrentJoy+=1;
|
|
// fprintf(tempf,"joystick initialized!\n");
|
|
|
|
return DIENUM_CONTINUE;
|
|
}
|
|
#endif // __LINUX__
|
|
|
|
void endgame()
|
|
{
|
|
|
|
#ifdef __LINUX__ // AH
|
|
// TODO: Cleanup, dealloc buffers, etc.
|
|
STUB_FUNCTION;
|
|
SDL_Quit();
|
|
#else // __WIN32__
|
|
if(DD_CFB)
|
|
{
|
|
DD_CFB->Release();
|
|
DD_CFB=NULL;
|
|
}
|
|
|
|
|
|
if(lpDD)
|
|
{
|
|
lpDD->Release();
|
|
lpDD=NULL;
|
|
}
|
|
|
|
|
|
if(lpDDClipper)
|
|
{
|
|
lpDDClipper->Release();
|
|
lpDDClipper=NULL;
|
|
}
|
|
|
|
if(DD_Primary)
|
|
{
|
|
DD_Primary->Release();
|
|
DD_Primary=NULL;
|
|
}
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
#ifdef __WIN32__ // AH
|
|
void DInputError(){
|
|
char message1[256];
|
|
|
|
sprintf(message1,"Error initializing DirectInput\nYou may need to install
|
|
DirectX 7.0a or higher located at www.microsoft.com/directx \0");
|
|
MessageBox (NULL, message1, "Init Error" , MB_ICONERROR );
|
|
}
|
|
#endif // __WIN32__
|
|
|
|
BOOL InitInput()
|
|
{
|
|
char message1[256];
|
|
#ifdef __LINUX__ // AH
|
|
STUB_FUNCTION;
|
|
#else // __WIN32__
|
|
HRESULT hr;
|
|
|
|
if(FAILED(hr=DirectInputCreate(hInst,DIRECTINPUT_VERSION,&DInput,NULL)))
|
|
{
|
|
sprintf(message1,"Error initializing DirectInput\nYou may need to install
|
|
DirectX 7.0a or higher located at www.microsoft.com/directx \0");
|
|
MessageBox (NULL, message1, "Init Error" , MB_ICONERROR );
|
|
|
|
switch(hr)
|
|
{
|
|
case DIERR_BETADIRECTINPUTVERSION:
|
|
sprintf(message1,"Beta %X\n\0",hr);
|
|
MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
break;
|
|
case DIERR_INVALIDPARAM:
|
|
sprintf(message1,"Invalid %X\n\0",hr);
|
|
MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
break;
|
|
case DIERR_OLDDIRECTINPUTVERSION:
|
|
sprintf(message1,"OLDDIRECTINPUTVERSION %X\n\0",hr);
|
|
MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
break;
|
|
case DIERR_OUTOFMEMORY:
|
|
sprintf(message1,"OUTOFMEMORY %X\n\0",hr);
|
|
MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
break;
|
|
default:
|
|
sprintf(message1,"UNKNOWN %X\n\0",hr);
|
|
MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
hr=DInput->CreateDevice(GUID_SysKeyboard, &KeyboardInput,NULL);
|
|
if(FAILED(hr)) {DInputError();return FALSE;}
|
|
|
|
hr=KeyboardInput->SetDataFormat(&c_dfDIKeyboard);
|
|
if(FAILED(hr)) {DInputError();return FALSE;}
|
|
|
|
|
|
|
|
hr=KeyboardInput->SetCooperativeLevel(hMainWindow,DISCL_NONEXCLUSIVE |
|
|
DISCL_FOREGROUND );
|
|
|
|
hr=DInput->CreateDevice(GUID_SysMouse, &MouseInput,NULL);
|
|
if(FAILED(hr)) {DInputError();return FALSE;}
|
|
|
|
hr=MouseInput->SetDataFormat(&c_dfDIMouse);
|
|
if(FAILED(hr)) {DInputError();return FALSE;}
|
|
|
|
|
|
hr=MouseInput->SetCooperativeLevel(hMainWindow,DISCL_EXCLUSIVE|DISCL_FOREGROUND);
|
|
if(FAILED(hr)) {DInputError();return FALSE;}
|
|
|
|
|
|
JoystickInput[0]=NULL;JoystickInput[1]=NULL;JoystickInput[2]=NULL;JoystickInput[3]=NULL;
|
|
|
|
|
|
hr=DInput->EnumDevices(DIDEVTYPE_JOYSTICK, InitJoystickInput,
|
|
DInput, DIEDFL_ATTACHEDONLY);
|
|
if(FAILED(hr)) {DInputError();return FALSE;}
|
|
|
|
|
|
InputAcquire();
|
|
#endif // __LINUX__
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
void TestJoy()
|
|
{
|
|
#ifdef __LINUX__ // AH
|
|
STUB_FUNCTION;
|
|
#else // __WIN32__
|
|
int i;
|
|
|
|
for(i=0;i<4;i++)
|
|
{
|
|
if(JoystickInput[i])
|
|
{
|
|
JoystickInput[i]->Poll();
|
|
// memset(&js[i], 0, sizeof(DIJOYSTATE));
|
|
|
|
|
|
if(IDirectInputDevice7_GetDeviceState(JoystickInput[i],sizeof(DIJOYSTATE),
|
|
&js[i])==DIERR_INPUTLOST)
|
|
{
|
|
if(JoystickInput[i]) JoystickInput[i]->Acquire();
|
|
|
|
if(FAILED(IDirectInputDevice7_GetDeviceState(JoystickInput[i],sizeof(DIJOYSTATE),
|
|
&js[i]))) return;
|
|
}
|
|
|
|
|
|
if(!X1Disable[i])
|
|
{
|
|
if(js[i].lX>0) X1Disable[i]=1;
|
|
}
|
|
|
|
if(!X2Disable[i])
|
|
{
|
|
if(js[i].lX<0) X2Disable[i]=1;
|
|
}
|
|
|
|
if(!Y1Disable[i])
|
|
{
|
|
if(js[i].lY>0) Y1Disable[i]=1;
|
|
}
|
|
|
|
if(!Y2Disable[i])
|
|
{
|
|
if(js[i].lY<0) Y2Disable[i]=1;
|
|
}
|
|
|
|
if(!Z1Disable[i])
|
|
{
|
|
if(js[i].lZ>0) Z1Disable[i]=1;
|
|
}
|
|
|
|
if(!Z2Disable[i])
|
|
{
|
|
if(js[i].lZ<0) Z2Disable[i]=1;
|
|
}
|
|
|
|
if(!RY1Disable[i])
|
|
{
|
|
if(js[i].lRy>0) RY1Disable[i]=1;
|
|
}
|
|
if(!RY2Disable[i])
|
|
{
|
|
if(js[i].lRy<0) RY2Disable[i]=1;
|
|
}
|
|
if(!RZ1Disable[i])
|
|
{
|
|
if(js[i].lRz>0) RZ1Disable[i]=1;
|
|
}
|
|
if(!RZ2Disable[i])
|
|
{
|
|
if(js[i].lRz<0) RZ2Disable[i]=1;
|
|
}
|
|
if(!S01Disable[i])
|
|
{
|
|
if(js[i].rglSlider[0]>0) S01Disable[i]=1;
|
|
}
|
|
if(!S02Disable[i])
|
|
{
|
|
if(js[i].rglSlider[0]<0) S02Disable[i]=1;
|
|
}
|
|
|
|
if(!S11Disable[i])
|
|
{
|
|
if(js[i].rglSlider[1]>0) S11Disable[i]=1;
|
|
}
|
|
if(!S12Disable[i])
|
|
{
|
|
if(js[i].rglSlider[1]<0) S12Disable[i]=1;
|
|
}
|
|
|
|
}
|
|
}
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
DWORD converta;
|
|
unsigned int BitConv32Ptr;
|
|
|
|
#ifdef __LINUX__ // AH
|
|
int startgame(void)
|
|
{
|
|
unsigned int color32,ScreenPtr2;
|
|
int i;
|
|
Uint32 flags = SDL_SWSURFACE | SDL_HWPALETTE;
|
|
DWORD GBitMask;
|
|
|
|
//STUB_FUNCTION;
|
|
ScreenPtr2=BitConv32Ptr;
|
|
for(i=0;i<65536;i++)
|
|
{
|
|
color32=((i&0xF800)<<8)+
|
|
((i&0x07E0)<<5)+
|
|
((i&0x001F)<<3)+0x7F000000;
|
|
(*(unsigned int *)(ScreenPtr2))=color32;
|
|
ScreenPtr2+=4;
|
|
}
|
|
|
|
if (sdl_inited == 0) {
|
|
if (SDL_Init(SDL_INIT_TIMER|SDL_INIT_VIDEO) < 0) {
|
|
fprintf(stderr, "Could not initialize SDL!\n");
|
|
return FALSE;
|
|
} else {
|
|
sdl_inited = 1;
|
|
}
|
|
}
|
|
|
|
flags != ( FullScreen ? SDL_FULLSCREEN : 0);
|
|
|
|
surface = SDL_SetVideoMode(WindowWidth, WindowHeight, 0, flags);
|
|
if (surface == NULL) {
|
|
fprintf (stderr, "Could not set %dx%d video mode.\n",SurfaceX,
|
|
SurfaceY);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Need to handle situations where BPP is not what we can handle */
|
|
|
|
SDL_WM_SetCaption ("ZSNES Linux","ZSNES");
|
|
SDL_ShowCursor(0);
|
|
|
|
BitDepth = surface->format->BitsPerPixel;
|
|
// Check hardware for 565/555
|
|
GBitMask = surface->format->Gmask;
|
|
|
|
if(BitDepth==16 && GBitMask!=0x07E0)
|
|
{
|
|
converta=1;
|
|
Init_2xSaI(555);
|
|
}
|
|
else
|
|
{
|
|
converta=0;
|
|
}
|
|
return TRUE;
|
|
}
|
|
#else // __WIN32__
|
|
startgame()
|
|
{
|
|
DDSURFACEDESC ddsd;
|
|
DDPIXELFORMAT format;
|
|
HRESULT hr;
|
|
char message1[256];
|
|
unsigned int color32,ScreenPtr2;
|
|
int i;
|
|
|
|
ScreenPtr2=BitConv32Ptr;
|
|
for(i=0;i<65536;i++)
|
|
{
|
|
color32=((i&0xF800)<<8)+
|
|
((i&0x07E0)<<5)+
|
|
((i&0x001F)<<3)+0x7F000000;
|
|
(*(unsigned int *)(ScreenPtr2))=color32;
|
|
ScreenPtr2+=4;
|
|
}
|
|
|
|
GetClientRect(hMainWindow, &rcWindow );
|
|
ClientToScreen(hMainWindow, ( LPPOINT )&rcWindow );
|
|
ClientToScreen(hMainWindow, ( LPPOINT )&rcWindow + 1 );
|
|
|
|
if(FAILED(DirectDrawCreate(NULL,&BasiclpDD,NULL)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if(FAILED(BasiclpDD->SetCooperativeLevel(hMainWindow, DDSCL_NORMAL )))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if(FAILED(BasiclpDD->QueryInterface(IID_IDirectDraw2,(LPVOID *)&lpDD)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BasiclpDD->Release();
|
|
|
|
ddsd.dwSize = sizeof( ddsd );
|
|
ddsd.dwFlags = DDSD_CAPS;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
|
|
|
|
if (FAILED(lpDD->CreateSurface( &ddsd, &DD_Primary, NULL )))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if (FAILED(lpDD->CreateClipper(0,&lpDDClipper,NULL)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (FAILED(lpDDClipper->SetHWnd(0,hMainWindow)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (FAILED( DD_Primary->SetClipper(lpDDClipper)))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
format.dwSize = sizeof(DDPIXELFORMAT);
|
|
if (DD_Primary->GetPixelFormat(&format) != DD_OK)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BitDepth=format.dwRGBBitCount;
|
|
GBitMask=format.dwGBitMask; // 0x07E0 or not
|
|
|
|
if(BitDepth==16&& GBitMask!=0x07E0)
|
|
{
|
|
converta=1;
|
|
Init_2xSaI(555);
|
|
}
|
|
else
|
|
{
|
|
converta=0;
|
|
}
|
|
|
|
if(DD_CFB!=NULL) DD_CFB->Release();
|
|
|
|
DD_CFB=NULL;
|
|
|
|
ddsd.dwSize = sizeof( ddsd );
|
|
ddsd.dwFlags = DDSD_CAPS | DDSD_HEIGHT |DDSD_WIDTH;
|
|
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN ;
|
|
|
|
ddsd.dwWidth = SurfaceX;
|
|
ddsd.dwHeight = SurfaceY;
|
|
|
|
if ( lpDD->CreateSurface( &ddsd, &DD_CFB, NULL ) != DD_OK )
|
|
{
|
|
DD_CFB = NULL;
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
#endif // __LINUX__
|
|
|
|
BYTE* SurfBuf;
|
|
|
|
DWORD LockSurface(void)
|
|
{
|
|
// Lock SDL surface, return surface pitch
|
|
SDL_LockSurface(surface);
|
|
return(surface->pitch);
|
|
}
|
|
|
|
void UnlockSurface(void)
|
|
{
|
|
SDL_UnlockSurface(surface);
|
|
SurfBuf = surface->pixels;
|
|
}
|
|
|
|
void WinUpdateDevices();
|
|
|
|
int Running=0;
|
|
|
|
unsigned char Noise[]={
|
|
27,232,234,138,187,246,176,81,25,241,1,127,154,190,195,103,231,165,220,238,
|
|
232,189,57,201,123,75,63,143,145,159,13,236,191,142,56,164,222,80,88,13,
|
|
148,118,162,212,157,146,176,0,241,88,244,238,51,235,149,50,77,212,186,241,
|
|
88,32,23,206,1,24,48,244,248,210,253,77,19,100,83,222,108,68,11,58,
|
|
152,161,223,245,4,105,3,82,15,130,171,242,141,2,172,218,152,97,223,157,
|
|
93,75,83,238,104,238,131,70,22,252,180,82,110,123,106,133,183,209,48,230,
|
|
157,205,27,21,107,63,85,164};
|
|
|
|
|
|
int X, Y;
|
|
DWORD Temp1;
|
|
MSG msg;
|
|
DWORD SurfBufD;
|
|
int count, x,count2;
|
|
HRESULT hr;
|
|
int i;
|
|
short *Sound;
|
|
DWORD CurrentPos;
|
|
DWORD WritePos;
|
|
DWORD SoundBufD;
|
|
DWORD SoundBufD2;
|
|
|
|
|
|
|
|
DWORD T60HZEnabled=0;
|
|
DWORD T36HZEnabled=0;
|
|
|
|
extern unsigned char romispal;
|
|
|
|
void Start60HZ(void)
|
|
{
|
|
freq = 1000;
|
|
update_ticks_pc2 = UPDATE_TICKS_UDP * freq / 1000;
|
|
if(romispal==1)
|
|
{
|
|
update_ticks_pc = UPDATE_TICKS_GAMEPAL * freq / 1000;
|
|
}
|
|
else
|
|
{
|
|
update_ticks_pc = UPDATE_TICKS_GAME * freq / 1000;
|
|
}
|
|
|
|
start = SDL_GetTicks();
|
|
start2 = SDL_GetTicks();
|
|
// QueryPerformanceCounter((LARGE_INTEGER*)&start);
|
|
// QueryPerformanceCounter((LARGE_INTEGER*)&start2);
|
|
T36HZEnabled=0;
|
|
T60HZEnabled=1;
|
|
}
|
|
|
|
void Stop60HZ(void)
|
|
{
|
|
T60HZEnabled=0;
|
|
}
|
|
|
|
void Start36HZ(void)
|
|
{
|
|
freq = 1000;
|
|
update_ticks_pc2 = UPDATE_TICKS_UDP * freq / 1000;
|
|
update_ticks_pc = UPDATE_TICKS_GUI * freq / 1000;
|
|
// QueryPerformanceCounter((LARGE_INTEGER*)&start);
|
|
// QueryPerformanceCounter((LARGE_INTEGER*)&start2);
|
|
|
|
start = SDL_GetTicks();
|
|
start2 = SDL_GetTicks();
|
|
T60HZEnabled=0;
|
|
T36HZEnabled=1;
|
|
}
|
|
|
|
void Stop36HZ(void)
|
|
{
|
|
T36HZEnabled=0;
|
|
}
|
|
|
|
char WinMessage[256];
|
|
extern unsigned char cvidmode;
|
|
DWORD FirstVid=1;
|
|
DWORD FirstFull=1;
|
|
extern BYTE GUIWFVID[];
|
|
void clearwin();
|
|
|
|
char WinName[]={"ZSNESW\0"};
|
|
void initwinvideo(void)
|
|
{
|
|
#ifdef __LINUX__
|
|
//RECT zwindowrect;
|
|
// WINDOWPLACEMENT wndpl;
|
|
//RECT rc1, swrect;
|
|
DWORD newmode=0;
|
|
|
|
//STUB_FUNCTION;
|
|
|
|
if(CurMode!=cvidmode)
|
|
{
|
|
CurMode=cvidmode;
|
|
newmode=1;
|
|
SurfaceX=256;
|
|
SurfaceY=224;
|
|
X=0;
|
|
Y=0;
|
|
FullScreen=GUIWFVID[cvidmode];
|
|
|
|
switch(cvidmode)
|
|
{
|
|
case 0:
|
|
WindowWidth=64;
|
|
WindowHeight=56;
|
|
break;
|
|
case 1:
|
|
WindowWidth=128;
|
|
WindowHeight=112;
|
|
break;
|
|
case 2:
|
|
WindowWidth=256;
|
|
WindowHeight=224;
|
|
break;
|
|
case 3:
|
|
WindowWidth=640;
|
|
WindowHeight=480;
|
|
SurfaceX=320;
|
|
SurfaceY=240;
|
|
break;
|
|
case 4:
|
|
WindowWidth=512;
|
|
WindowHeight=448;
|
|
break;
|
|
case 5:
|
|
WindowWidth=512;
|
|
WindowHeight=448;
|
|
SurfaceX=512;
|
|
SurfaceY=448;
|
|
break;
|
|
case 6:
|
|
WindowWidth=640;
|
|
WindowHeight=480;
|
|
break;
|
|
case 7:
|
|
WindowWidth=640;
|
|
WindowHeight=480;
|
|
SurfaceX=640;
|
|
SurfaceY=480;
|
|
break;
|
|
case 8:
|
|
WindowWidth=640;
|
|
WindowHeight=480;
|
|
SurfaceX=512;
|
|
SurfaceY=448;
|
|
break;
|
|
case 9:
|
|
WindowWidth=640;
|
|
WindowHeight=480;
|
|
break;
|
|
case 10:
|
|
WindowWidth=800;
|
|
WindowHeight=600;
|
|
break;
|
|
case 11:
|
|
WindowWidth=800;
|
|
WindowHeight=600;
|
|
SurfaceX=512;
|
|
SurfaceY=448;
|
|
break;
|
|
case 12:
|
|
WindowWidth=800;
|
|
WindowHeight=600;
|
|
break;
|
|
case 13:
|
|
WindowWidth=800;
|
|
WindowHeight=600;
|
|
SurfaceX=512;
|
|
SurfaceY=448;
|
|
break;
|
|
case 14:
|
|
WindowWidth=1024;
|
|
WindowHeight=768;
|
|
break;
|
|
case 15:
|
|
WindowWidth=1024;
|
|
WindowHeight=768;
|
|
SurfaceX=512;
|
|
SurfaceY=448;
|
|
break;
|
|
case 16:
|
|
WindowWidth=1024;
|
|
WindowHeight=768;
|
|
break;
|
|
case 17:
|
|
WindowWidth=1024;
|
|
WindowHeight=768;
|
|
SurfaceX=512;
|
|
SurfaceY=448;
|
|
break;
|
|
default:
|
|
WindowWidth=256;
|
|
WindowHeight=224;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(startgame()!=TRUE) {return; }
|
|
if(newmode==1) clearwin();
|
|
|
|
if (FirstVid == 1) {
|
|
FirstVid = 0;
|
|
|
|
InitSound();
|
|
}
|
|
if(((PrevStereoSound!=StereoSound)||(PrevSoundQuality!=SoundQuality)))
|
|
ReInitSound();
|
|
#else
|
|
if(FirstVid!=1)
|
|
{
|
|
// sprintf(WinMessage,"FirstVid!=1 start\n\0");
|
|
// MessageBox (NULL, WinMessage, "Init", MB_ICONERROR );
|
|
|
|
if(X<0)X=0;
|
|
if(X>(GetSystemMetrics( SM_CXSCREEN )-WindowWidth)) X=(GetSystemMetrics(
|
|
SM_CXSCREEN )-WindowWidth);
|
|
if(Y<0)Y=0;
|
|
if(Y>(GetSystemMetrics( SM_CYSCREEN )-WindowHeight)) Y=(GetSystemMetrics(
|
|
SM_CYSCREEN )-WindowHeight);
|
|
if(FullScreen==1) {X=0; Y=0;}
|
|
|
|
MoveWindow( hMainWindow, X, Y,
|
|
WindowWidth, WindowHeight, TRUE );
|
|
|
|
wndpl.length = sizeof(wndpl);
|
|
GetWindowPlacement( hMainWindow, &wndpl);
|
|
SetRect( &rc1, 0, 0, WindowWidth, WindowHeight );
|
|
|
|
AdjustWindowRectEx( &rc1,GetWindowLong( hMainWindow, GWL_STYLE ),
|
|
GetMenu( hMainWindow ) != NULL, GetWindowLong( hMainWindow, GWL_EXSTYLE )
|
|
);
|
|
// X=(GetSystemMetrics( SM_CXSCREEN ) - WindowWidth) / 2;
|
|
// Y=(GetSystemMetrics( SM_CYSCREEN ) - WindowHeight) / 2;
|
|
|
|
GetClientRect( hMainWindow, &rc1 );
|
|
ClientToScreen( hMainWindow, ( LPPOINT )&rc1 );
|
|
ClientToScreen( hMainWindow, ( LPPOINT )&rc1 + 1 );
|
|
// return;
|
|
// sprintf(WinMessage,"FirstVid!=1 end\n\0");
|
|
// MessageBox (NULL, WinMessage, "Init", MB_ICONERROR );
|
|
|
|
// MoveScreen(wndpl.rcNormalPosition.left, wndpl.rcNormalPosition.top);
|
|
}
|
|
else
|
|
{
|
|
FirstVid=0;
|
|
if (!QueryPerformanceFrequency((LARGE_INTEGER*)&freq)) return;
|
|
// hInst=GetModuleHandle(0);
|
|
if ( !RegisterWinClass() ); // { return; }
|
|
X=(GetSystemMetrics( SM_CXSCREEN ) - WindowWidth) / 2;
|
|
Y=(GetSystemMetrics( SM_CYSCREEN ) - WindowHeight) / 2;
|
|
if(FullScreen==1) {X=0; Y=0;}
|
|
if(hMainWindow) CloseWindow(hMainWindow);
|
|
|
|
hMainWindow = CreateWindow( "ZSNESWIN", WinName, WS_VISIBLE|WS_POPUP,X,Y,
|
|
//WS_OVERLAPPED "ZSNESWIN"
|
|
WindowWidth,WindowHeight,NULL,NULL,hInst,NULL);
|
|
|
|
if(!hMainWindow) { return; }
|
|
|
|
ShowWindow(hMainWindow, SW_SHOWNORMAL);
|
|
SetWindowText(hMainWindow,"ZSNESWIN");
|
|
InitInput();
|
|
InitSound();
|
|
TestJoy();
|
|
}
|
|
|
|
|
|
if(Moving==1) return;
|
|
if(FullScreen==1)
|
|
{
|
|
if(FirstFull==1)
|
|
{
|
|
atexit(ExitFunction);
|
|
}
|
|
mode.dmSize=sizeof(DEVMODE);
|
|
mode.dmBitsPerPel=16;
|
|
mode.dmPelsWidth=WindowWidth;
|
|
mode.dmPelsHeight=WindowHeight;
|
|
mode.dmDisplayFlags=0;
|
|
mode.dmDisplayFrequency=0;
|
|
mode.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
|
|
ChangeDisplaySettings(&mode,0);
|
|
}
|
|
else
|
|
{
|
|
ChangeDisplaySettings(NULL,0);
|
|
}
|
|
//endgame();
|
|
|
|
if(startgame()!=TRUE) {return; }
|
|
if(newmode==1) clearwin();
|
|
// MessageBox (NULL, "Done", "Init", MB_ICONERROR );
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
extern unsigned int vidbuffer;
|
|
extern void SoundProcess();
|
|
extern int DSPBuffer[];
|
|
DWORD ScreenPtr;
|
|
DWORD ScreenPtr2;
|
|
extern int GUI36hzcall(void);
|
|
extern int Game60hzcall(void);
|
|
extern int packettimeleft[256];
|
|
extern int PacketCounter;
|
|
extern int CounterA;
|
|
extern int CounterB;
|
|
|
|
|
|
void CheckTimers(void)
|
|
{
|
|
int i;
|
|
//QueryPerformanceCounter((LARGE_INTEGER*)&end2);
|
|
end2 = SDL_GetTicks();
|
|
while ((end2 - start2) >= update_ticks_pc2)
|
|
{
|
|
if (CounterA>0) CounterA--;
|
|
if (CounterB>0) CounterB--;
|
|
if (PacketCounter){
|
|
for (i=0;i<256;i++){
|
|
if (packettimeleft[i]>0)
|
|
packettimeleft[i]--;
|
|
}
|
|
}
|
|
start2 += update_ticks_pc2;
|
|
}
|
|
|
|
if(T60HZEnabled)
|
|
{
|
|
//QueryPerformanceCounter((LARGE_INTEGER*)&end);
|
|
end = SDL_GetTicks();
|
|
|
|
while ((end - start) >= update_ticks_pc)
|
|
{
|
|
// _asm{
|
|
// pushad
|
|
// call Game60hzcall
|
|
// popad
|
|
// }
|
|
DTimerCheck = 1;
|
|
Game60hzcall();
|
|
start += update_ticks_pc;
|
|
}
|
|
}
|
|
|
|
if(T36HZEnabled)
|
|
{
|
|
//QueryPerformanceCounter((LARGE_INTEGER*)&end);
|
|
end = SDL_GetTicks();
|
|
|
|
while ((end - start) >= update_ticks_pc)
|
|
{
|
|
// _asm{
|
|
// pushad
|
|
// call GUI36hzcall
|
|
// popad
|
|
// }
|
|
GUI36hzcall();
|
|
DTimerCheck = 1;
|
|
start += update_ticks_pc;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* should we clear these on sound reset? */
|
|
DWORD BufferLeftOver=0;
|
|
short Buffer[1800*2];
|
|
|
|
#ifdef __LINUX__
|
|
void UpdateSound(void *userdata, Uint8 *stream, int len)
|
|
{
|
|
const int SPCSize = 256;
|
|
int DataNeeded;
|
|
int i;
|
|
Uint8 *ptr;
|
|
|
|
len /= 2; /* only 16bit here */
|
|
|
|
ptr = stream;
|
|
DataNeeded = len;
|
|
|
|
/* take care of the things we left behind last time */
|
|
if (BufferLeftOver) {
|
|
DataNeeded -= BufferLeftOver;
|
|
|
|
memcpy(ptr, &Buffer[BufferLeftOver], (SPCSize-BufferLeftOver)*2);
|
|
|
|
ptr += (SPCSize-BufferLeftOver)*2;
|
|
BufferLeftOver = 0;
|
|
}
|
|
|
|
if (len & 255) { /* we'll save the rest first */
|
|
DataNeeded -= 256;
|
|
}
|
|
|
|
while (DataNeeded > 0) {
|
|
SoundProcess();
|
|
|
|
for (i = 0; i < SPCSize; i++) {
|
|
if (T36HZEnabled) {
|
|
Buffer[i]=0;
|
|
} else {
|
|
if(DSPBuffer[i]>32767)Buffer[i]=32767;
|
|
else if(DSPBuffer[i]<-32767)Buffer[i]=-32767;
|
|
else Buffer[i]=DSPBuffer[i];
|
|
}
|
|
}
|
|
|
|
memcpy(ptr, &Buffer[0], SPCSize*2);
|
|
ptr += SPCSize*2;
|
|
|
|
DataNeeded -= SPCSize;
|
|
}
|
|
|
|
if (DataNeeded) {
|
|
DataNeeded += 256;
|
|
BufferLeftOver = DataNeeded;
|
|
|
|
SoundProcess();
|
|
|
|
for (i = 0; i < SPCSize; i++) {
|
|
if (T36HZEnabled) {
|
|
Buffer[i] = 0;
|
|
} else {
|
|
if(DSPBuffer[i]>32767)Buffer[i]=32767;
|
|
else if(DSPBuffer[i]<-32767)Buffer[i]=-32767;
|
|
else Buffer[i]=DSPBuffer[i];
|
|
}
|
|
}
|
|
|
|
memcpy(ptr, &Buffer[0], DataNeeded*2);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void UpdateVFrame(void)
|
|
{
|
|
#ifdef __LINUX__
|
|
//STUB_FUNCTION;
|
|
Main_Proc();
|
|
|
|
WinUpdateDevices();
|
|
CheckTimers();
|
|
|
|
if (DTimerCheck == 1)
|
|
{
|
|
SDL_UpdateRect(surface,0,0,0,0);
|
|
DTimerCheck = 0;
|
|
}
|
|
#else
|
|
int DataNeeded;
|
|
int SPCSize=256;
|
|
|
|
if(StereoSound==1)SPCSize=256;
|
|
|
|
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
WinUpdateDevices();
|
|
CheckTimers();
|
|
|
|
if (!SoundEnabled) return;
|
|
|
|
SoundBuffer->GetCurrentPosition(&CurrentPos,&WritePos);
|
|
|
|
if(LastUsedPos <= CurrentPos)
|
|
{
|
|
DataNeeded=CurrentPos-LastUsedPos;
|
|
}
|
|
else
|
|
{
|
|
DataNeeded=SoundBufferSize- LastUsedPos + CurrentPos;
|
|
}
|
|
|
|
DataNeeded/=(SPCSize*2);
|
|
DataNeeded*=(SPCSize*2);
|
|
|
|
while(DataNeeded>0)
|
|
{
|
|
_asm
|
|
{
|
|
pushad
|
|
call SoundProcess
|
|
popad
|
|
}
|
|
|
|
DSPBuffer1=(int *)&DSPBuffer;
|
|
|
|
for(i=0;i<SPCSize;i++)
|
|
{
|
|
Buffer[i]=DSPBuffer1[i];
|
|
if(DSPBuffer1[i]>32767)Buffer[i]=32767;
|
|
if(DSPBuffer1[i]<-32767)Buffer[i]=-32767;
|
|
if(T36HZEnabled)Buffer[i]=0;
|
|
}
|
|
|
|
if(DS_OK!=SoundBuffer->Lock(LastUsedPos,
|
|
SPCSize*2, &lpvPtr1,
|
|
&dwBytes1, &lpvPtr2,
|
|
&dwBytes2, 0))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Sound=(short *)lpvPtr1;
|
|
|
|
CopyMemory(lpvPtr1, &Buffer[0], dwBytes1);
|
|
|
|
if(NULL != lpvPtr2)
|
|
{
|
|
CopyMemory(lpvPtr2, &Buffer[0]+dwBytes1, dwBytes2);
|
|
}
|
|
|
|
if(DS_OK != SoundBuffer->Unlock(lpvPtr1, dwBytes1, lpvPtr2, dwBytes2))
|
|
{
|
|
return;
|
|
}
|
|
|
|
LastUsedPos+=SPCSize*2;
|
|
if(LastUsedPos==SoundBufferSize) LastUsedPos=0;
|
|
DataNeeded-=(SPCSize*2);
|
|
}
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
extern unsigned char curblank;
|
|
extern DWORD AddEndBytes;
|
|
extern DWORD NumBytesPerLine;
|
|
extern unsigned char * WinVidMemStart;
|
|
extern void copy640x480x16bwin(void);
|
|
extern unsigned char FPUCopy;
|
|
extern unsigned char NGNoTransp;
|
|
extern unsigned char newengen;
|
|
|
|
void clearwin()
|
|
{
|
|
DWORD i,j,color32;
|
|
DWORD *SURFDW;
|
|
|
|
Temp1=LockSurface();
|
|
if(Temp1==0) { return; }
|
|
|
|
SurfBufD=(DWORD) &SurfBuf[0];
|
|
SURFDW=(DWORD *) &SurfBuf[0];
|
|
switch(BitDepth)
|
|
{
|
|
case 16:
|
|
// Still crashes - DDOI
|
|
STUB_FUNCTION;
|
|
/*
|
|
__asm__ __volatile__ ("
|
|
pushw %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xorl %%eax, %%eax
|
|
movl SurfBufD, %%edi
|
|
xorl %%ebx, %%ebx
|
|
Blank2:
|
|
movl SurfaceX, %%ecx
|
|
rep
|
|
stosw
|
|
addl Temp1, %%edi
|
|
subl SurfaceX, %%edi
|
|
subl SurfaceX, %%edi
|
|
addl $1, %%ebx
|
|
cmpl SurfaceY, %%ebx
|
|
jne Blank2
|
|
popw %%es
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx", "edi");
|
|
break;
|
|
case 32:
|
|
__asm__ __volatile__ ("
|
|
pushw %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xorl %%eax, %%eax
|
|
movl SurfBufD, %%edi
|
|
xorl %%ebx, %%ebx
|
|
Blank3:
|
|
movl SurfaceX, %%ecx
|
|
rep
|
|
stosl
|
|
addl Temp1, %%edi
|
|
subl SurfaceX, %%edi
|
|
subl SurfaceX, %%edi
|
|
subl SurfaceX, %%edi
|
|
subl SurfaceX, %%edi
|
|
addl $1, %%ebx
|
|
cmpl SurfaceY, %%ebx
|
|
jne Blank3
|
|
popw %%es
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx","edi");
|
|
*/
|
|
break;
|
|
}
|
|
UnlockSurface();
|
|
}
|
|
|
|
void drawscreenwin(void)
|
|
{
|
|
DWORD i,j,color32;
|
|
DWORD *SURFDW;
|
|
|
|
NGNoTransp = 0; // Set this value to 1 within the appropriate
|
|
// video mode if you want to add a custom
|
|
// transparency routine or hardware
|
|
// transparency. This only works if
|
|
// the value of newengen is equal to 1.
|
|
// (see ProcessTransparencies in newgfx16.asm
|
|
// for ZSNES' current transparency code)
|
|
UpdateVFrame();
|
|
if(curblank!=0) return;
|
|
|
|
Temp1=LockSurface();
|
|
if(Temp1==0) { return; }
|
|
|
|
ScreenPtr=vidbuffer;
|
|
ScreenPtr+=16*2+32*2+256*2;
|
|
SurfBufD=(DWORD) &SurfBuf[0];
|
|
SURFDW=(DWORD *) &SurfBuf[0];
|
|
|
|
if (SurfBufD == 0) {
|
|
UnlockSurface();
|
|
return;
|
|
}
|
|
|
|
if(SurfaceX==256&&SurfaceY==224)
|
|
{
|
|
switch(BitDepth)
|
|
{
|
|
case 16:
|
|
if (FPUCopy){
|
|
__asm__ __volatile__ ("
|
|
pushw %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xorl %%eax, %%eax
|
|
movl ScreenPtr, %%esi
|
|
movl SurfBufD, %%edi
|
|
Copying3:
|
|
movl $32, %%ecx
|
|
CopyLoop:
|
|
movq (%%esi), %%mm0
|
|
movq 8(%%esi), %%mm1
|
|
movq %%mm0, (%%edi)
|
|
movq %%mm1, 8(%%edi)
|
|
addl $16, %%esi
|
|
addl $16, %%edi
|
|
decl %%ecx
|
|
jnz CopyLoop
|
|
incl %%eax
|
|
addl Temp1, %%edi
|
|
subl $512, %%edi
|
|
subl $512, %%esi
|
|
addl $576, %%esi
|
|
cmpl $223, %%eax
|
|
jne Copying3
|
|
|
|
xorl %%eax, %%eax
|
|
movl $128, %%ecx
|
|
rep
|
|
stosl
|
|
popw %%es
|
|
emms
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx","edi", "esi");
|
|
} else {
|
|
// Doesn't seem to work - DDOI
|
|
__asm__ __volatile__ ("
|
|
pushw %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xorl %%eax, %%eax
|
|
movl ScreenPtr, %%esi
|
|
movl SurfBufD, %%edi
|
|
Copying:
|
|
movl $128, %%ecx
|
|
rep
|
|
movsl
|
|
incl %%eax
|
|
addl Temp1, %%edi
|
|
subl $512, %%edi
|
|
subl $512, %%esi
|
|
addl $576, %%esi
|
|
cmpl $223, %%eax
|
|
jne Copying
|
|
xorl %%eax, %%eax
|
|
movl $128, %%ecx
|
|
rep
|
|
stosl
|
|
popw %%es
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx","edi", "esi");
|
|
}
|
|
break;
|
|
case 32:
|
|
// Untested - DDOI
|
|
__asm__ __volatile__ ("
|
|
pushw %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xorl %%eax, %%eax
|
|
movl BitConv32Ptr, %%ebx
|
|
movl ScreenPtr, %%esi
|
|
movl SurfBufD, %%edi
|
|
Copying32b:
|
|
movl $256, %%ecx
|
|
pushl %%eax
|
|
xorl %%eax, %%eax
|
|
CopyLoop32b:
|
|
movw (%%esi), %%ax
|
|
addl $2, %%esi
|
|
movl (%%ebx, %%eax, 4), %%edx
|
|
movl %%edx, (%%edi)
|
|
addl $4, %%edi
|
|
loop CopyLoop32b
|
|
popl %%eax
|
|
incl %%eax
|
|
addl Temp1, %%edi
|
|
subl $1024, %%edi
|
|
subl $512, %%esi
|
|
addl $576, %%esi
|
|
cmpl $223, %%eax
|
|
jne Copying32b
|
|
popw %%es
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx","edi", "esi");
|
|
SURFDW=(DWORD *) &SurfBuf[222*Temp1];
|
|
color32=0x7F000000;
|
|
|
|
for(i=0;i<256;i++)
|
|
{
|
|
SURFDW[i]=color32;
|
|
}
|
|
|
|
SURFDW=(DWORD *) &SurfBuf[223*Temp1];
|
|
color32=0x7F000000;
|
|
|
|
for(i=0;i<256;i++)
|
|
{
|
|
SURFDW[i]=color32;
|
|
}
|
|
break;
|
|
case 24:
|
|
fprintf (stderr, "Sorry, ZSNES does not work in windowed 24 bit color modes.\nSwitching to fullscreen mode\n");
|
|
cvidmode=3;
|
|
initwinvideo();
|
|
sleep(1);
|
|
drawscreenwin();
|
|
break;
|
|
default:
|
|
UnlockSurface();
|
|
fprintf(stderr, "Mode only available in 16 and 32 bit color.\n");
|
|
cvidmode=2;
|
|
initwinvideo();
|
|
sleep(1);
|
|
drawscreenwin();
|
|
break;
|
|
} // switch (BitDepth)
|
|
} // if(SurfaceX==256&&SurfaceY==224)
|
|
|
|
else if(SurfaceX==320&&SurfaceY==240)
|
|
{
|
|
switch(BitDepth)
|
|
{
|
|
case 16:
|
|
if (FPUCopy) {
|
|
__asm__ __volatile__ ("
|
|
pushw %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xor %%eax, %%eax
|
|
xor %%ebx, %%ebx
|
|
movl ScreenPtr, %%esi
|
|
movl SurfBufD, %%edi
|
|
Blank1MMX:
|
|
mov $160, %%ecx
|
|
rep
|
|
stosl
|
|
subl $160, %%edi
|
|
addl Temp1, %%edi
|
|
addl $1, %%ebx
|
|
cmpl $8, %%ebx
|
|
jne Blank1MMX
|
|
xor %%ebx, %%ebx
|
|
pxor %%mm0, %%mm0
|
|
Copying2MMX:
|
|
mov $4, %%ecx
|
|
MMXLoopA:
|
|
movq %%mm0, 0(%%edi)
|
|
movq %%mm0, 8(%%edi)
|
|
addl $16, %%edi
|
|
dec %%ecx
|
|
jnz MMXLoopA
|
|
mov $32, %%ecx
|
|
MMXLoopB:
|
|
movq 0(%%esi), %%mm1
|
|
movq 8(%%esi), %%mm2
|
|
movq %%mm1, 0(%%edi)
|
|
movq %%mm2, 8(%%edi)
|
|
addl $16, %%esi
|
|
addl $16, %%edi
|
|
decl %%ecx
|
|
jnz MMXLoopB
|
|
mov $4, %%ecx
|
|
MMXLoopC:
|
|
movq %%mm0, 0(%%edi)
|
|
movq %%mm0, 8(%%edi)
|
|
addl $16, %%edi
|
|
decl %%ecx
|
|
jnz MMXLoopC
|
|
incl %%ebx
|
|
addl Temp1, %%edi
|
|
subl $640, %%edi
|
|
subl $512, %%esi
|
|
addl $576, %%esi
|
|
cmpl $223, %%ebx
|
|
jne Copying2MMX
|
|
|
|
movl $128, %%ecx
|
|
rep
|
|
stosl
|
|
pop %%es
|
|
emms
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx","edi", "esi");
|
|
|
|
} else {
|
|
__asm__ __volatile__ ("
|
|
push %%es
|
|
movw %%ds, %%ax
|
|
movw %%ax, %%es
|
|
xorl %%eax, %%eax
|
|
xorl %%ebx, %%ebx
|
|
movl ScreenPtr, %%esi
|
|
movl SurfBufD, %%edi
|
|
Blank1:
|
|
movl $160, %%ecx
|
|
rep
|
|
stosl
|
|
subl $640, %%edi
|
|
addl Temp1, %%edi
|
|
addl $1, %%ebx
|
|
cmpl $8, %%ebx
|
|
jne Blank1
|
|
xor %%ebx, %%ebx
|
|
Copying2:
|
|
movl $16, %%ecx
|
|
rep
|
|
stosl
|
|
movl $128, %%ecx
|
|
rep
|
|
movsl
|
|
movl $16, %%ecx
|
|
rep
|
|
stosl
|
|
incl %%ebx
|
|
addl Temp1, %%edi
|
|
subl $640, %%edi
|
|
subl $512, %%esi
|
|
addl $576, %%esi
|
|
cmpl $223, %%ebx
|
|
jne Copying2
|
|
|
|
movl $128, %%ecx
|
|
rep
|
|
stosl
|
|
pop %%es
|
|
" : : : "cc", "memory", "eax", "ebx", "ecx","edi", "esi");
|
|
|
|
}
|
|
break;
|
|
case 32:
|
|
for(j=0;j<8;j++)
|
|
{
|
|
SURFDW=(DWORD *) &SurfBuf[j*Temp1];
|
|
color32=0x7F000000;
|
|
|
|
for(i=0;i<320;i++)
|
|
{
|
|
SURFDW[i]=color32;
|
|
}
|
|
}
|
|
|
|
for(j=8;j<223+8;j++)
|
|
{
|
|
color32=0x7F000000;
|
|
for(i=0;i<32;i++)
|
|
{
|
|
SURFDW[i]=color32;
|
|
}
|
|
|
|
for(i=32;i<(256+32);i++)
|
|
{
|
|
color32=(((*(WORD *)(ScreenPtr))&0xF800)<<8)+
|
|
(((*(WORD *)(ScreenPtr))&0x07E0)<<5)+
|
|
(((*(WORD *)(ScreenPtr))&0x001F)<<3)+0x7F000000;
|
|
SURFDW[i]=color32;
|
|
ScreenPtr+=2;
|
|
}
|
|
|
|
color32=0x7F000000;
|
|
for(i=(256+32);i<320;i++)
|
|
{
|
|
SURFDW[i]=color32;
|
|
}
|
|
|
|
ScreenPtr=ScreenPtr+576-512;
|
|
SURFDW=(DWORD *) &SurfBuf[(j)*Temp1];
|
|
}
|
|
|
|
for(j=(223+8);j<240;j++)
|
|
{
|
|
SURFDW=(DWORD *) &SurfBuf[j*Temp1];
|
|
|
|
color32=0x7F000000;
|
|
for(i=0;i<320;i++)
|
|
{
|
|
SURFDW[i]=color32;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
UnlockSurface();
|
|
fprintf(stderr, "Mode only available in 16 and 32 bit color.\n");
|
|
cvidmode=2;
|
|
initwinvideo();
|
|
sleep(1);
|
|
drawscreenwin();
|
|
break;
|
|
} // switch
|
|
} // if
|
|
|
|
else if(SurfaceX==512&&SurfaceY==448)
|
|
{
|
|
switch(BitDepth)
|
|
{
|
|
case 16:
|
|
AddEndBytes=Temp1-1024;
|
|
NumBytesPerLine=Temp1;
|
|
WinVidMemStart=&SurfBuf[0];
|
|
copy640x480x16bwin();
|
|
break;
|
|
default:
|
|
UnlockSurface();
|
|
fprintf(stderr, "Mode only available in 16 and 32 bit color.\n");
|
|
cvidmode=2;
|
|
initwinvideo();
|
|
sleep(1);
|
|
drawscreenwin();
|
|
break;
|
|
} // switch
|
|
} // if
|
|
else if (SurfaceX==640 && SurfaceY==480)
|
|
{
|
|
switch(BitDepth)
|
|
{
|
|
case 16:
|
|
AddEndBytes=Temp1-1024;
|
|
NumBytesPerLine=Temp1;
|
|
WinVidMemStart=&SurfBuf[16*640*2+64*2];
|
|
copy640x480x16bwin();
|
|
break;
|
|
default:
|
|
UnlockSurface();
|
|
fprintf(stderr, "Mode only available in 16 bit color.\n");
|
|
cvidmode=2;
|
|
initwinvideo();
|
|
sleep(1);
|
|
drawscreenwin();
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnlockSurface();
|
|
}
|
|
|
|
void LinuxExit (void)
|
|
{
|
|
SDL_Quit();
|
|
exit(0);
|
|
}
|
|
|
|
extern char fulladdtab[65536*2];
|
|
extern WORD vesa2_usbit;
|
|
extern WORD vesa2_clbit;
|
|
extern WORD vesa2_rpos;
|
|
extern WORD vesa2_rfull;
|
|
extern WORD vesa2_rtrcl;
|
|
extern WORD vesa2_rtrcla;
|
|
extern WORD vesa2_gpos;
|
|
extern WORD vesa2_gfull;
|
|
extern WORD vesa2_gtrcl;
|
|
extern WORD vesa2_gtrcla;
|
|
extern WORD vesa2_bpos;
|
|
extern WORD vesa2_bfull;
|
|
extern WORD vesa2_btrcl;
|
|
extern WORD vesa2_btrcla;
|
|
extern WORD nojoystickpoll;
|
|
|
|
extern void SwitchFullScreen(void);
|
|
|
|
void WinUpdateDevices()
|
|
{
|
|
int i,j;
|
|
unsigned char * keys;
|
|
unsigned char keys2[256];
|
|
HRESULT hRes;
|
|
|
|
#ifdef __LINUX__
|
|
//STUB_FUNCTION;
|
|
MouseButton = SDL_GetMouseState( &MouseX, &MouseY);
|
|
#else
|
|
for (i=0;i<256;i++)
|
|
keys2[i]=0;
|
|
keys=(unsigned char *)&pressed;
|
|
|
|
if(KeyboardInput&&InputEn==1)
|
|
{
|
|
KeyboardInput->GetDeviceState(256, keys2);
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
if(keys2[0x38]!=0&&keys2[0x3E]!=0) exit(0);
|
|
if(keys2[0x38]!=0&&keys2[0x1c]!=0)
|
|
{
|
|
_asm{
|
|
pushad
|
|
call SwitchFullScreen
|
|
popad
|
|
}
|
|
return;
|
|
}
|
|
for(i=0;i<256;i++)
|
|
{
|
|
if(keys2[i]==0) keys[i]=0;
|
|
if(keys2[i]!=0&&keys[i]==0) keys[i]=1;
|
|
}
|
|
// keys[1]=keys[16];
|
|
keys[0]=0;
|
|
|
|
// if (nojoystickpoll) return;
|
|
|
|
for(i=0;i<4;i++)
|
|
{
|
|
if(JoystickInput[i])
|
|
{
|
|
for(j=0;j<32;j++)
|
|
{
|
|
keys[0x100+i*32+j]=0;
|
|
}
|
|
|
|
// memset(&js[i], 0, sizeof(DIJOYSTATE));
|
|
JoystickInput[i]->Poll();
|
|
|
|
if(IDirectInputDevice7_GetDeviceState(JoystickInput[i],sizeof(DIJOYSTATE),
|
|
&js[i])==DIERR_INPUTLOST)
|
|
{
|
|
if(JoystickInput[i]) JoystickInput[i]->Acquire();
|
|
|
|
if(FAILED(IDirectInputDevice7_GetDeviceState(JoystickInput[i],sizeof(DIJOYSTATE),
|
|
&js[i]))) return;
|
|
}
|
|
|
|
if(!X1Disable[i])
|
|
{
|
|
if(js[i].lX>0) keys[0x100+i*32+0]=1;
|
|
}
|
|
|
|
if(!X2Disable[i])
|
|
{
|
|
if(js[i].lX<0) keys[0x100+i*32+1]=1;
|
|
}
|
|
|
|
|
|
if(!Y1Disable[i])
|
|
{
|
|
if(js[i].lY>0) keys[0x100+i*32+2]=1;
|
|
}
|
|
|
|
if(!Y2Disable[i])
|
|
{
|
|
if(js[i].lY<0) keys[0x100+i*32+3]=1;
|
|
}
|
|
|
|
if(!Z1Disable[i])
|
|
{
|
|
if(js[i].lZ>0) keys[0x100+i*32+4]=1;
|
|
}
|
|
|
|
if(!Z2Disable[i])
|
|
{
|
|
if(js[i].lZ<0) keys[0x100+i*32+5]=1;
|
|
}
|
|
if(!RY1Disable[i])
|
|
{
|
|
if(js[i].lRy>0) keys[0x100+i*32+6]=1;
|
|
}
|
|
if(!RY2Disable[i])
|
|
{
|
|
if(js[i].lRy<0) keys[0x100+i*32+7]=1;
|
|
}
|
|
|
|
if(!RZ1Disable[i])
|
|
{
|
|
if(js[i].lRz>0) keys[0x100+i*32+8]=1;
|
|
}
|
|
if(!RZ2Disable[i])
|
|
{
|
|
if(js[i].lRz<0) keys[0x100+i*32+9]=1;
|
|
}
|
|
if(!S01Disable[i])
|
|
{
|
|
if(js[i].rglSlider[0]>0) keys[0x100+i*32+10]=1;
|
|
}
|
|
if(!S02Disable[i])
|
|
{
|
|
if(js[i].rglSlider[0]<0) keys[0x100+i*32+11]=1;
|
|
}
|
|
if(!S11Disable[i])
|
|
{
|
|
if(js[i].rglSlider[1]>0) keys[0x100+i*32+12]=1;
|
|
}
|
|
if(!S12Disable[i])
|
|
{
|
|
if(js[i].rglSlider[1]<0) keys[0x100+i*32+13]=1;
|
|
}
|
|
if(js[i].rgbButtons[0]) keys[0x100+i*32+16]=1;
|
|
if(js[i].rgbButtons[1]) keys[0x100+i*32+17]=1;
|
|
if(js[i].rgbButtons[2]) keys[0x100+i*32+18]=1;
|
|
if(js[i].rgbButtons[3]) keys[0x100+i*32+19]=1;
|
|
if(js[i].rgbButtons[4]) keys[0x100+i*32+20]=1;
|
|
if(js[i].rgbButtons[5]) keys[0x100+i*32+21]=1;
|
|
if(js[i].rgbButtons[6]) keys[0x100+i*32+22]=1;
|
|
if(js[i].rgbButtons[7]) keys[0x100+i*32+23]=1;
|
|
if(js[i].rgbButtons[8]) keys[0x100+i*32+24]=1;
|
|
if(js[i].rgbButtons[9]) keys[0x100+i*32+25]=1;
|
|
if(js[i].rgbButtons[10]) keys[0x100+i*32+26]=1;
|
|
if(js[i].rgbButtons[11]) keys[0x100+i*32+27]=1;
|
|
if(js[i].rgbButtons[12]) keys[0x100+i*32+28]=1;
|
|
if(js[i].rgbButtons[13]) keys[0x100+i*32+29]=1;
|
|
if(js[i].rgbButtons[14]) keys[0x100+i*32+30]=1;
|
|
if(js[i].rgbButtons[15]) keys[0x100+i*32+31]=1;
|
|
}
|
|
else
|
|
{
|
|
for(j=0;j<32;j++)
|
|
{
|
|
keys[0x100+i*32+j]=0;
|
|
}
|
|
}
|
|
}
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
|
|
int GetMouseX(void)
|
|
{
|
|
return((int)MouseX);
|
|
}
|
|
|
|
int GetMouseY(void)
|
|
{
|
|
return((int)MouseY);
|
|
}
|
|
|
|
int GetMouseMoveX(void)
|
|
{
|
|
// InputRead();
|
|
MouseMove2X=MouseMoveX;
|
|
return(MouseMove2X);
|
|
}
|
|
|
|
int GetMouseMoveY(void)
|
|
{
|
|
MouseMove2Y=MouseMoveY;
|
|
return(MouseMove2Y);
|
|
}
|
|
|
|
int GetMouseButton(void)
|
|
{
|
|
//STUB_FUNCTION;
|
|
return((int)MouseButton);
|
|
}
|
|
|
|
void SetMouseMinX(int MinX)
|
|
{
|
|
// MinX&=0xFFF;
|
|
// char message1[256];
|
|
// sprintf(message1,"MinX %d",MinX);
|
|
// MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
// MouseMinX=MinX;
|
|
}
|
|
|
|
void SetMouseMaxX(int MaxX)
|
|
{
|
|
// MaxX&=0xFFF;
|
|
// char message1[256];
|
|
// sprintf(message1,"MaxX %d",MaxX);
|
|
// MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
// MouseMaxX=MaxX;
|
|
}
|
|
|
|
void SetMouseMinY(int MinY)
|
|
{
|
|
// MinY&=0xFFF;
|
|
// char message1[256];
|
|
// sprintf(message1,"MinY %d",MinY);
|
|
// MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
// MouseMinY=MinY;
|
|
}
|
|
|
|
void SetMouseMaxY(int MaxY)
|
|
{
|
|
// MaxY&=0xFFF;
|
|
// char message1[256];
|
|
// sprintf(message1,"MaxY %d",MaxY);
|
|
// MessageBox (NULL, message1, "Init", MB_ICONERROR );
|
|
// MouseMaxY=MaxY;
|
|
}
|
|
|
|
void SetMouseX(int X)
|
|
{
|
|
// MouseX=X;
|
|
}
|
|
|
|
void SetMouseY(int Y)
|
|
{
|
|
// MouseY=Y;
|
|
}
|
|
|
|
void ZsnesPage()
|
|
{
|
|
#ifdef __LINUX__
|
|
STUB_FUNCTION;
|
|
#else
|
|
ShellExecute(NULL, NULL, "http://www.zsnes.com", NULL, NULL, 0);
|
|
#endif // __LINUX__
|
|
}
|
|
|
|
#ifdef __LINUX__
|
|
void GetLocalTime(void *pointer)
|
|
{
|
|
STUB_FUNCTION;
|
|
}
|
|
#endif
|