diff -ruwN source/build-scripts/config.sub source-new/build-scripts/config.sub --- source/build-scripts/config.sub 2012-01-18 23:30:05.000000000 -0700 +++ source-new/build-scripts/config.sub 2019-08-10 20:55:13.662786449 -0600 @@ -1276,7 +1276,7 @@ -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ - | -kopensolaris* \ + | -kopensolaris* | -redox* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ diff -ruwN source/configure.in source-new/configure.in --- source/configure.in 2012-01-18 23:30:05.000000000 -0700 +++ source-new/configure.in 2019-08-10 20:55:13.662786449 -0600 @@ -685,6 +685,18 @@ fi } +dnl Set up the Redox Audio driver +CheckRedoxAudio() +{ + AC_ARG_ENABLE(redoxaudio, +AC_HELP_STRING([--enable-redoxaudio], [support the redox audio driver [[default=yes]]]), + , enable_redoxaudio=yes) + if test x$enable_audio = xyes -a x$enable_redoxaudio = xyes; then + AC_DEFINE(SDL_AUDIO_DRIVER_REDOX) + SOURCES="$SOURCES $srcdir/src/audio/redox/*.c" + fi +} + dnl See if we can use x86 assembly blitters # NASM is available from: http://nasm.sourceforge.net CheckNASM() @@ -1646,6 +1658,20 @@ fi } +dnl Set up the Orbital video driver. +CheckOrbitalVideo() +{ + AC_ARG_ENABLE(video-orbital, +AC_HELP_STRING([--enable-video-orbital], [use orbital video driver [[default=yes]]]), + , enable_video_orbital=yes) + if test x$enable_video_orbital = xyes; then + AC_DEFINE(SDL_VIDEO_DRIVER_ORBITAL) + SOURCES="$SOURCES $srcdir/src/video/orbital/*.c" + SDL_LIBS="$SDL_LIBS -lorbital" + have_video=yes + fi +} + dnl Check to see if OpenGL support is desired AC_ARG_ENABLE(video-opengl, AC_HELP_STRING([--enable-video-opengl], [include OpenGL context creation [[default=yes]]]), @@ -1859,6 +1885,10 @@ AC_HELP_STRING([--enable-pthread-sem], [use pthread semaphores [[default=yes]]]), , enable_pthread_sem=yes) case "$host" in + *-*-redox*) + pthread_cflags="-D_REENTRANT" + pthread_lib="-lpthread" + ;; *-*-linux*|*-*-uclinux*) pthread_cflags="-D_REENTRANT" pthread_lib="-lpthread" @@ -2325,10 +2355,11 @@ have_timers=yes fi ;; - *-*-linux*|*-*-uclinux*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-dragonfly*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-irix*|*-*-aix*|*-*-osf*) + *-*-linux*|*-*-uclinux*|*-*-redox*|*-*-gnu*|*-*-k*bsd*-gnu|*-*-bsdi*|*-*-freebsd*|*-*-dragonfly*|*-*-netbsd*|*-*-openbsd*|*-*-sysv5*|*-*-solaris*|*-*-hpux*|*-*-irix*|*-*-aix*|*-*-osf*) case "$host" in *-*-linux*) ARCH=linux ;; *-*-uclinux*) ARCH=linux ;; + *-*-redox*) ARCH=redox ;; *-*-kfreebsd*-gnu) ARCH=kfreebsd-gnu ;; *-*-knetbsd*-gnu) ARCH=knetbsd-gnu ;; *-*-kopenbsd*-gnu) ARCH=kopenbsd-gnu ;; @@ -2347,8 +2378,10 @@ esac CheckVisibilityHidden CheckDummyVideo + CheckOrbitalVideo CheckDiskAudio CheckDummyAudio + CheckRedoxAudio CheckDLOPEN CheckNASM CheckAltivec @@ -2445,6 +2478,11 @@ SOURCES="$SOURCES $srcdir/src/cdrom/osf/*.c" have_cdrom=yes ;; + redox) + AC_DEFINE(SDL_CDROM_DUMMY) + SOURCES="$SOURCES $srcdir/src/cdrom/dummy/*.c" + have_cdrom=yes + ;; esac fi # Set up files for the thread library diff -ruwN source/include/SDL_config.h.in source-new/include/SDL_config.h.in --- source/include/SDL_config.h.in 2012-01-18 23:30:05.000000000 -0700 +++ source-new/include/SDL_config.h.in 2019-08-10 20:55:13.662786449 -0600 @@ -182,6 +182,7 @@ #undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H #undef SDL_AUDIO_DRIVER_PAUD #undef SDL_AUDIO_DRIVER_QNXNTO +#undef SDL_AUDIO_DRIVER_REDOX #undef SDL_AUDIO_DRIVER_SNDMGR #undef SDL_AUDIO_DRIVER_SUNAUDIO #undef SDL_AUDIO_DRIVER_WAVEOUT @@ -268,6 +269,7 @@ #undef SDL_VIDEO_DRIVER_GGI #undef SDL_VIDEO_DRIVER_IPOD #undef SDL_VIDEO_DRIVER_NANOX +#undef SDL_VIDEO_DRIVER_ORBITAL #undef SDL_VIDEO_DRIVER_OS2FS #undef SDL_VIDEO_DRIVER_PHOTON #undef SDL_VIDEO_DRIVER_PICOGUI diff -ruwN source/src/audio/redox/SDL_redoxaudio.c source-new/src/audio/redox/SDL_redoxaudio.c --- source/src/audio/redox/SDL_redoxaudio.c 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/audio/redox/SDL_redoxaudio.c 2019-08-10 20:55:13.662786449 -0600 @@ -0,0 +1,169 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org + + This file written by Ryan C. Gordon (icculus@icculus.org) +*/ +#include "SDL_config.h" + +/* Output raw audio data to a file. */ + +#include +#include +#include + +#include "SDL_timer.h" +#include "SDL_audio.h" +#include "../SDL_audiomem.h" +#include "../SDL_audio_c.h" +#include "../SDL_audiodev_c.h" +#include "SDL_redoxaudio.h" + +/* The tag name used by REDOX audio */ +#define REDOXAUD_DRIVER_NAME "redox" + +/* Audio driver functions */ +static int REDOXAUD_OpenAudio(_THIS, SDL_AudioSpec *spec); +static void REDOXAUD_WaitAudio(_THIS); +static void REDOXAUD_PlayAudio(_THIS); +static Uint8 *REDOXAUD_GetAudioBuf(_THIS); +static void REDOXAUD_CloseAudio(_THIS); + +/* Audio driver bootstrap functions */ +static int REDOXAUD_Available(void) +{ + return(1); +} + +static void REDOXAUD_DeleteDevice(SDL_AudioDevice *device) +{ + SDL_free(device->hidden); + SDL_free(device); +} + +static SDL_AudioDevice *REDOXAUD_CreateDevice(int devindex) +{ + SDL_AudioDevice *this; + const char *envr; + + /* Initialize all variables that we clean on shutdown */ + this = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice)); + if ( this ) { + SDL_memset(this, 0, (sizeof *this)); + this->hidden = (struct SDL_PrivateAudioData *) + SDL_malloc((sizeof *this->hidden)); + } + if ( (this == NULL) || (this->hidden == NULL) ) { + SDL_OutOfMemory(); + if ( this ) { + SDL_free(this); + } + return(0); + } + SDL_memset(this->hidden, 0, (sizeof *this->hidden)); + + this->hidden->output = -1; + + /* Set the function pointers */ + this->OpenAudio = REDOXAUD_OpenAudio; + this->WaitAudio = REDOXAUD_WaitAudio; + this->PlayAudio = REDOXAUD_PlayAudio; + this->GetAudioBuf = REDOXAUD_GetAudioBuf; + this->CloseAudio = REDOXAUD_CloseAudio; + + this->free = REDOXAUD_DeleteDevice; + + return this; +} + +AudioBootStrap REDOXAUD_bootstrap = { + REDOXAUD_DRIVER_NAME, "Redox audio", + REDOXAUD_Available, REDOXAUD_CreateDevice +}; + +/* This function waits until it is possible to write a full sound buffer */ +static void REDOXAUD_WaitAudio(_THIS) +{} + +static void REDOXAUD_PlayAudio(_THIS) +{ + int written; + + /* Write the audio data */ + written = write(this->hidden->output, + this->hidden->mixbuf, + this->hidden->mixlen); + + /* If we couldn't write, assume fatal error for now */ + if ( (Uint32)written != this->hidden->mixlen ) { + this->enabled = 0; + } +#ifdef DEBUG_AUDIO + fprintf(stderr, "Wrote %d bytes of audio data\n", written); +#endif +} + +static Uint8 *REDOXAUD_GetAudioBuf(_THIS) +{ + return(this->hidden->mixbuf); +} + +static void REDOXAUD_CloseAudio(_THIS) +{ + if ( this->hidden->mixbuf != NULL ) { + SDL_FreeAudioMem(this->hidden->mixbuf); + this->hidden->mixbuf = NULL; + } + if ( this->hidden->output >= 0 ) { + close(this->hidden->output); + this->hidden->output = -1; + } +} + +static int REDOXAUD_OpenAudio(_THIS, SDL_AudioSpec *spec) +{ + fprintf(stderr, "WARNING: You are using the SDL redox audio driver!\n"); + + /* Open the audio device */ + this->hidden->output = open("audio:", O_WRONLY); + if ( this->hidden->output < 0 ) { + perror("failed to open audio:"); + return(-1); + } + + spec->freq = 44100; + spec->format = AUDIO_S16; + spec->channels = 2; + SDL_CalculateAudioSpec(spec); + + /* Allocate mixing buffer */ + this->hidden->mixlen = spec->size; + this->hidden->mixbuf = (Uint8 *) SDL_AllocAudioMem(this->hidden->mixlen); + if ( this->hidden->mixbuf == NULL ) { + perror("failed to allocate audio memory"); + return(-1); + } + SDL_memset(this->hidden->mixbuf, spec->silence, spec->size); + + fprintf(stderr, "openaudio success\n"); + + /* We're ready to rock and roll. :-) */ + return(0); +} diff -ruwN source/src/audio/redox/SDL_redoxaudio.h source-new/src/audio/redox/SDL_redoxaudio.h --- source/src/audio/redox/SDL_redoxaudio.h 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/audio/redox/SDL_redoxaudio.h 2019-08-10 20:55:13.662786449 -0600 @@ -0,0 +1,40 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#ifndef _SDL_redoxaudio_h +#define _SDL_redoxaudio_h + +#include "SDL_rwops.h" +#include "../SDL_sysaudio.h" + +/* Hidden "this" pointer for the video functions */ +#define _THIS SDL_AudioDevice *this + +struct SDL_PrivateAudioData { + /* The file descriptor for the audio device */ + int output; + Uint8 *mixbuf; + Uint32 mixlen; +}; + +#endif /* _SDL_redoxaudio_h */ diff -ruwN source/src/audio/SDL_audio.c source-new/src/audio/SDL_audio.c --- source/src/audio/SDL_audio.c 2012-01-18 23:30:06.000000000 -0700 +++ source-new/src/audio/SDL_audio.c 2019-08-10 20:55:13.662786449 -0600 @@ -36,6 +36,9 @@ /* Available audio drivers */ static AudioBootStrap *bootstrap[] = { +#if SDL_AUDIO_DRIVER_REDOX + &REDOXAUD_bootstrap, +#endif #if SDL_AUDIO_DRIVER_PULSE &PULSE_bootstrap, #endif diff -ruwN source/src/audio/SDL_sysaudio.h source-new/src/audio/SDL_sysaudio.h --- source/src/audio/SDL_sysaudio.h 2012-01-18 23:30:06.000000000 -0700 +++ source-new/src/audio/SDL_sysaudio.h 2019-08-10 20:55:13.666786472 -0600 @@ -102,6 +102,9 @@ SDL_AudioDevice *(*create)(int devindex); } AudioBootStrap; +#if SDL_AUDIO_DRIVER_REDOX +extern AudioBootStrap REDOXAUD_bootstrap; +#endif #if SDL_AUDIO_DRIVER_BSD extern AudioBootStrap BSD_AUDIO_bootstrap; #endif diff -ruwN source/src/thread/pthread/SDL_systhread.c source-new/src/thread/pthread/SDL_systhread.c --- source/src/thread/pthread/SDL_systhread.c 2012-01-18 23:30:06.000000000 -0700 +++ source-new/src/thread/pthread/SDL_systhread.c 2019-08-10 20:55:13.666786472 -0600 @@ -86,7 +86,11 @@ for ( i=0; sig_list[i]; ++i ) { sigaddset(&mask, sig_list[i]); } + #if defined(__redox__) + sigprocmask(SIG_BLOCK, &mask, 0); + #else pthread_sigmask(SIG_BLOCK, &mask, 0); + #endif #ifdef PTHREAD_CANCEL_ASYNCHRONOUS /* Allow ourselves to be asynchronously cancelled */ diff -ruwN source/src/video/orbital/SDL_orbitalevents.c source-new/src/video/orbital/SDL_orbitalevents.c --- source/src/video/orbital/SDL_orbitalevents.c 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/video/orbital/SDL_orbitalevents.c 2019-08-12 14:51:38.427129083 -0600 @@ -0,0 +1,240 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#include "SDL.h" +#include "../../events/SDL_sysevents.h" +#include "../../events/SDL_events_c.h" +#include "../SDL_cursor_c.h" + +#include +#include "SDL_orbitalvideo.h" +#include "SDL_orbitalevents_c.h" + +#include + +static SDLKey keymap[128]; + +/* Static variables so only changes are reported */ +static bool last_button_left = false; +static bool last_button_middle = false; +static bool last_button_right = false; +static int last_x = 0; +static int last_y = 0; + +void ORBITAL_CheckMouseMode(_THIS) +{ + /* If the mouse is hidden and input is grabbed, we use relative mode */ + bool mouse_relative = + !(SDL_cursorstate & CURSOR_VISIBLE) && + (this->input_grab != SDL_GRAB_OFF); + // printf("ORBITAL_CheckMouseMode = %d\n", mouse_relative); + if (mouse_relative != this->hidden->mouse_relative) { + this->hidden->mouse_relative = mouse_relative; + if (this->hidden->window) { + orb_window_set_mouse_relative(this->hidden->window, mouse_relative); + } + } +} + +SDL_GrabMode ORBITAL_GrabInput(_THIS, SDL_GrabMode mode) { + bool mouse_grab = mode != SDL_GRAB_OFF; + // printf("ORBITAL_GrabInput(%d) = %d\n", mode, mouse_grab); + if (mouse_grab != this->hidden->mouse_grab) { + this->hidden->mouse_grab = mouse_grab; + if (this->hidden->window) { + orb_window_set_mouse_grab(this->hidden->window, mouse_grab); + } + } + return (mode); +} + +void ORBITAL_PumpEvents(_THIS) +{ + SDL_keysym keysym; + + if (!this->hidden->window) { + return; + } + + void* event_iter = orb_window_events(this->hidden->window); + OrbEventOption oeo = orb_events_next(event_iter); + while (oeo.tag != OrbEventOption_None) { + switch (oeo.tag) { + case OrbEventOption_Key: + keysym.unicode = oeo.key.character; + keysym.scancode = oeo.key.scancode; + keysym.sym = keymap[oeo.key.scancode]; + keysym.mod = KMOD_NONE; + + SDL_PrivateKeyboard(oeo.key.pressed ? SDL_PRESSED : SDL_RELEASED, &keysym); + break; + case OrbEventOption_Mouse: + if (this->hidden->mouse_relative) { + SDL_PrivateMouseMotion(0, 1, oeo.mouse.x - last_x, oeo.mouse.y - last_y); + } else { + SDL_PrivateMouseMotion(0, 0, oeo.mouse.x, oeo.mouse.y); + } + + last_x = oeo.mouse.x; + last_y = oeo.mouse.y; + break; + case OrbEventOption_MouseRelative: + SDL_PrivateMouseMotion(0, 1, oeo.mouse_relative.dx, oeo.mouse_relative.dy); + break; + case OrbEventOption_Button: + if (oeo.button.left ^ last_button_left) + SDL_PrivateMouseButton(oeo.button.left ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0); + if (oeo.button.middle ^ last_button_middle) + SDL_PrivateMouseButton(oeo.button.middle ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0); + if (oeo.button.right ^ last_button_right) + SDL_PrivateMouseButton(oeo.button.right ? SDL_PRESSED : SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0); + + last_button_left = oeo.button.left; + last_button_middle = oeo.button.middle; + last_button_right = oeo.button.right; + break; + case OrbEventOption_Scroll: + if (oeo.scroll.y > 0) { + SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0); + SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0); + } else if (oeo.scroll.y < 0) { + SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0); + SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0); + } + break; + case OrbEventOption_Quit: + SDL_PrivateQuit(); + break; + case OrbEventOption_Focus: + SDL_PrivateAppActive(oeo.focus.focused, SDL_APPMOUSEFOCUS); + break; + case OrbEventOption_Move: + // oeo.move.x, oeo.move.y + break; + case OrbEventOption_Resize: + SDL_PrivateResize(oeo.resize.width, oeo.resize.height); + break; + case OrbEventOption_Screen: + // oeo.screen.width, oeo.screen.height + break; + case OrbEventOption_Unknown: + // oeo.unknown.code, oeo.unknown.a, oeo.unknown.b + break; + default: + break; + } + + oeo = orb_events_next(event_iter); + } + + orb_events_destroy(event_iter); +} + +void ORBITAL_InitOSKeymap(_THIS) +{ + int i; + for ( i = 0; i < SDL_arraysize(keymap); ++i ) + keymap[i] = SDLK_UNKNOWN; + + keymap[ORB_KEY_ESC] = SDLK_ESCAPE; + keymap[ORB_KEY_1] = SDLK_1; + keymap[ORB_KEY_2] = SDLK_2; + keymap[ORB_KEY_3] = SDLK_3; + keymap[ORB_KEY_4] = SDLK_4; + keymap[ORB_KEY_5] = SDLK_5; + keymap[ORB_KEY_6] = SDLK_6; + keymap[ORB_KEY_7] = SDLK_7; + keymap[ORB_KEY_8] = SDLK_8; + keymap[ORB_KEY_9] = SDLK_9; + keymap[ORB_KEY_0] = SDLK_0; + keymap[ORB_KEY_MINUS] = SDLK_MINUS; + keymap[ORB_KEY_EQUALS] = SDLK_EQUALS; + keymap[ORB_KEY_BKSP] = SDLK_BACKSPACE; + keymap[ORB_KEY_TAB] = SDLK_TAB; + keymap[ORB_KEY_Q] = SDLK_q; + keymap[ORB_KEY_W] = SDLK_w; + keymap[ORB_KEY_E] = SDLK_e; + keymap[ORB_KEY_R] = SDLK_r; + keymap[ORB_KEY_T] = SDLK_t; + keymap[ORB_KEY_Y] = SDLK_y; + keymap[ORB_KEY_U] = SDLK_u; + keymap[ORB_KEY_I] = SDLK_i; + keymap[ORB_KEY_O] = SDLK_o; + keymap[ORB_KEY_P] = SDLK_p; + keymap[ORB_KEY_BRACE_OPEN] = SDLK_LEFTBRACKET; + keymap[ORB_KEY_BRACE_CLOSE] = SDLK_RIGHTBRACKET; + keymap[ORB_KEY_ENTER] = SDLK_RETURN; + keymap[ORB_KEY_CTRL] = SDLK_LCTRL; + keymap[ORB_KEY_A] = SDLK_a; + keymap[ORB_KEY_S] = SDLK_s; + keymap[ORB_KEY_D] = SDLK_d; + keymap[ORB_KEY_F] = SDLK_f; + keymap[ORB_KEY_G] = SDLK_g; + keymap[ORB_KEY_H] = SDLK_h; + keymap[ORB_KEY_J] = SDLK_j; + keymap[ORB_KEY_K] = SDLK_k; + keymap[ORB_KEY_L] = SDLK_l; + keymap[ORB_KEY_SEMICOLON] = SDLK_SEMICOLON; + keymap[ORB_KEY_QUOTE] = SDLK_QUOTE; + keymap[ORB_KEY_TICK] = SDLK_BACKQUOTE; + keymap[ORB_KEY_LEFT_SHIFT] = SDLK_LSHIFT; + keymap[ORB_KEY_RIGHT_SHIFT] = SDLK_RSHIFT; + keymap[ORB_KEY_BACKSLASH] = SDLK_BACKSLASH; + keymap[ORB_KEY_Z] = SDLK_z; + keymap[ORB_KEY_X] = SDLK_x; + keymap[ORB_KEY_C] = SDLK_c; + keymap[ORB_KEY_V] = SDLK_v; + keymap[ORB_KEY_B] = SDLK_b; + keymap[ORB_KEY_N] = SDLK_n; + keymap[ORB_KEY_M] = SDLK_m; + keymap[ORB_KEY_COMMA] = SDLK_COMMA; + keymap[ORB_KEY_PERIOD] = SDLK_PERIOD; + keymap[ORB_KEY_SLASH] = SDLK_SLASH; + keymap[ORB_KEY_ALT] = SDLK_LALT; + keymap[ORB_KEY_SPACE] = SDLK_SPACE; + keymap[ORB_KEY_CAPS] = SDLK_CAPSLOCK; + keymap[ORB_KEY_F1] = SDLK_F1; + keymap[ORB_KEY_F2] = SDLK_F2; + keymap[ORB_KEY_F3] = SDLK_F3; + keymap[ORB_KEY_F4] = SDLK_F4; + keymap[ORB_KEY_F5] = SDLK_F5; + keymap[ORB_KEY_F6] = SDLK_F6; + keymap[ORB_KEY_F7] = SDLK_F7; + keymap[ORB_KEY_F8] = SDLK_F8; + keymap[ORB_KEY_F9] = SDLK_F9; + keymap[ORB_KEY_F10] = SDLK_F10; + keymap[ORB_KEY_F11] = SDLK_F11; + keymap[ORB_KEY_F12] = SDLK_F12; + keymap[ORB_KEY_HOME] = SDLK_HOME; + keymap[ORB_KEY_UP] = SDLK_UP; + keymap[ORB_KEY_PGUP] = SDLK_PAGEUP; + keymap[ORB_KEY_LEFT] = SDLK_LEFT; + keymap[ORB_KEY_RIGHT] = SDLK_RIGHT; + keymap[ORB_KEY_END] = SDLK_END; + keymap[ORB_KEY_DOWN] = SDLK_DOWN; + keymap[ORB_KEY_PGDN] = SDLK_PAGEDOWN; + keymap[ORB_KEY_INSERT] = SDLK_INSERT; + keymap[ORB_KEY_DEL] = SDLK_DELETE; +} + +/* end of SDL_orbitalevents.c ... */ diff -ruwN source/src/video/orbital/SDL_orbitalevents_c.h source-new/src/video/orbital/SDL_orbitalevents_c.h --- source/src/video/orbital/SDL_orbitalevents_c.h 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/video/orbital/SDL_orbitalevents_c.h 2019-08-12 13:21:41.975750603 -0600 @@ -0,0 +1,32 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#include "SDL_orbitalvideo.h" + +/* Variables and functions exported by SDL_sysevents.c to other parts + of the native video subsystem (SDL_sysvideo.c) +*/ +extern void ORBITAL_InitOSKeymap(_THIS); +extern void ORBITAL_PumpEvents(_THIS); + +/* end of SDL_orbitalevents_c.h ... */ diff -ruwN source/src/video/orbital/SDL_orbitalmouse.c source-new/src/video/orbital/SDL_orbitalmouse.c --- source/src/video/orbital/SDL_orbitalmouse.c 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/video/orbital/SDL_orbitalmouse.c 2019-08-12 14:51:48.555193061 -0600 @@ -0,0 +1,64 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#include "SDL_mouse.h" +#include "../../events/SDL_events_c.h" + +#include "SDL_orbitalmouse_c.h" + + +/* The implementation dependent data for the window manager cursor */ +struct WMcursor { + int unused; +}; + +WMcursor * ORBITAL_CreateWMCursor (_THIS, + Uint8 * data, Uint8 * mask, int w, int h, int hot_x, int hot_y) +{ + WMcursor * cursor ; + + cursor = (WMcursor *) SDL_malloc (sizeof (WMcursor)) ; + if (cursor == NULL) { + SDL_OutOfMemory () ; + return NULL ; + } + + return cursor ; +} + +void ORBITAL_FreeWMCursor (_THIS, WMcursor * cursor) +{ + SDL_free (cursor) ; +} + +int ORBITAL_ShowWMCursor (_THIS, WMcursor * cursor) +{ + bool mouse_cursor = cursor != NULL; + // printf("ORBITAL_ShowWMCursor(%p) = %d\n", cursor, mouse_cursor); + if (mouse_cursor != this->hidden->mouse_cursor) { + this->hidden->mouse_cursor = mouse_cursor; + if (this->hidden->window) { + orb_window_set_mouse_cursor(this->hidden->window, mouse_cursor); + } + } +} diff -ruwN source/src/video/orbital/SDL_orbitalmouse_c.h source-new/src/video/orbital/SDL_orbitalmouse_c.h --- source/src/video/orbital/SDL_orbitalmouse_c.h 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/video/orbital/SDL_orbitalmouse_c.h 2019-08-12 13:14:47.509444528 -0600 @@ -0,0 +1,28 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#include "SDL_orbitalvideo.h" + +extern WMcursor * ORBITAL_CreateWMCursor (_THIS, Uint8 * data, Uint8 * mask, int w, int h, int hot_x, int hot_y) ; +void ORBITAL_FreeWMCursor (_THIS, WMcursor * cursor) ; +extern int ORBITAL_ShowWMCursor (_THIS, WMcursor * cursor) ; diff -ruwN source/src/video/orbital/SDL_orbitalvideo.c source-new/src/video/orbital/SDL_orbitalvideo.c --- source/src/video/orbital/SDL_orbitalvideo.c 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/video/orbital/SDL_orbitalvideo.c 2019-08-12 13:52:49.188487962 -0600 @@ -0,0 +1,265 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +/* Orbital SDL video driver implementation + * + * Initial work by Ryan C. Gordon (icculus@icculus.org). A good portion + * of this was cut-and-pasted from Stephane Peter's work in the AAlib + * SDL video driver. Renamed to "DUMMY" by Sam Lantinga. + * Repurposed to ORBITAL by Jeremy Soller. + */ + +#include "SDL_video.h" +#include "SDL_mouse.h" +#include "../SDL_sysvideo.h" +#include "../SDL_pixels_c.h" +#include "../../events/SDL_events_c.h" + +#include +#include "SDL_orbitalvideo.h" +#include "SDL_orbitalevents_c.h" +#include "SDL_orbitalmouse_c.h" + +#include +#include +#include +#include + +#define ORBITALVID_DRIVER_NAME "orbital" + +/* Initialization/Query functions */ +static int ORBITAL_VideoInit(_THIS, SDL_PixelFormat *vformat); +static SDL_Rect **ORBITAL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); +static SDL_Surface *ORBITAL_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); +static int ORBITAL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors); +static void ORBITAL_VideoQuit(_THIS); +static void ORBITAL_SetCaption(_THIS, const char *title, const char *icon); + +/* Hardware surface functions */ +static int ORBITAL_AllocHWSurface(_THIS, SDL_Surface *surface); +static int ORBITAL_LockHWSurface(_THIS, SDL_Surface *surface); +static void ORBITAL_UnlockHWSurface(_THIS, SDL_Surface *surface); +static void ORBITAL_FreeHWSurface(_THIS, SDL_Surface *surface); + +/* Input handling */ +static void ORBITAL_CheckMouseMode(_THIS); +static SDL_GrabMode ORBITAL_GrabInput(_THIS, SDL_GrabMode mode); + +/* etc. */ +static void ORBITAL_UpdateRects(_THIS, int numrects, SDL_Rect *rects); + +/* ORBITAL driver bootstrap functions */ + +static int ORBITAL_Available(void) +{ + return(1); +} + +static void ORBITAL_DeleteDevice(SDL_VideoDevice *device) +{ + SDL_free(device->hidden); + SDL_free(device); +} + +static SDL_VideoDevice *ORBITAL_CreateDevice(int devindex) +{ + SDL_VideoDevice *device; + + /* Initialize all variables that we clean on shutdown */ + device = (SDL_VideoDevice *)SDL_malloc(sizeof(SDL_VideoDevice)); + if ( device ) { + SDL_memset(device, 0, (sizeof *device)); + device->hidden = (struct SDL_PrivateVideoData *) + SDL_malloc((sizeof *device->hidden)); + } + if ( (device == NULL) || (device->hidden == NULL) ) { + SDL_OutOfMemory(); + if ( device ) { + SDL_free(device); + } + return(0); + } + SDL_memset(device->hidden, 0, (sizeof *device->hidden)); + + /* Set the function pointers */ + device->VideoInit = ORBITAL_VideoInit; + device->ListModes = ORBITAL_ListModes; + device->SetVideoMode = ORBITAL_SetVideoMode; + device->CreateYUVOverlay = NULL; + device->SetColors = ORBITAL_SetColors; + device->UpdateRects = ORBITAL_UpdateRects; + device->VideoQuit = ORBITAL_VideoQuit; + device->AllocHWSurface = ORBITAL_AllocHWSurface; + device->CheckHWBlit = NULL; + device->FillHWRect = NULL; + device->SetHWColorKey = NULL; + device->SetHWAlpha = NULL; + device->LockHWSurface = ORBITAL_LockHWSurface; + device->UnlockHWSurface = ORBITAL_UnlockHWSurface; + device->FlipHWSurface = NULL; + device->FreeHWSurface = ORBITAL_FreeHWSurface; + device->SetCaption = ORBITAL_SetCaption; + device->SetIcon = NULL; + device->IconifyWindow = NULL; + device->FreeWMCursor = ORBITAL_FreeWMCursor; + device->CreateWMCursor = ORBITAL_CreateWMCursor; + device->ShowWMCursor = ORBITAL_ShowWMCursor; + device->CheckMouseMode = ORBITAL_CheckMouseMode; + device->GrabInput = ORBITAL_GrabInput; + device->GetWMInfo = NULL; + device->InitOSKeymap = ORBITAL_InitOSKeymap; + device->PumpEvents = ORBITAL_PumpEvents; + + device->free = ORBITAL_DeleteDevice; + + return device; +} + +VideoBootStrap ORBITAL_bootstrap = { + ORBITALVID_DRIVER_NAME, "SDL orbital video driver", + ORBITAL_Available, ORBITAL_CreateDevice +}; + + +int ORBITAL_VideoInit(_THIS, SDL_PixelFormat *vformat) +{ + fprintf(stderr, "WARNING: You are using the SDL orbital video driver!\n"); + + /* Determine the screen depth (use default 32-bit depth) */ + /* we change this during the SDL_SetVideoMode implementation... */ + vformat->BitsPerPixel = 32; + vformat->BytesPerPixel = 4; + + /* We're done! */ + return(0); +} + +SDL_Rect **ORBITAL_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) +{ + if (format->BitsPerPixel != 32) + return NULL; + + return (SDL_Rect **) -1; +} + +SDL_Surface *ORBITAL_SetVideoMode(_THIS, SDL_Surface *current, + int width, int height, int bpp, Uint32 flags) +{ + if ( bpp != 32 ) { + SDL_SetError("Unsupported color depth - must use 32-bits per pixel"); + return(NULL); + } + + if (this->hidden->window) { + orb_window_set_size(this->hidden->window, width, height); + } else { + uint32_t orb_flags = ORB_WINDOW_ASYNC; + if (flags & SDL_RESIZABLE) + orb_flags |= ORB_WINDOW_RESIZABLE; + + this->hidden->window = orb_window_new_flags(-1, -1, width, height, "SDL", orb_flags); + if (!this->hidden->window) { + SDL_SetError("Couldn't create window for requested mode"); + return(NULL); + } + + orb_window_set_mouse_cursor(this->hidden->window, this->hidden->mouse_cursor); + orb_window_set_mouse_grab(this->hidden->window, this->hidden->mouse_grab); + orb_window_set_mouse_relative(this->hidden->window, this->hidden->mouse_relative); + } + + fprintf(stderr, "Setting mode %dx%d@%d\n", width, height, bpp); + + /* Allocate the new pixel format for the screen */ + if ( ! SDL_ReallocFormat(current, bpp, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000) ) { + orb_window_destroy(this->hidden->window); + this->hidden->window = NULL; + + SDL_SetError("Couldn't allocate new pixel format for requested mode"); + return(NULL); + } + + /* Set up the new mode framebuffer */ + current->flags = flags & (~SDL_DOUBLEBUF); + current->w = width; + current->h = height; + current->pitch = width * (bpp / 8); + current->pixels = orb_window_data(this->hidden->window); + + /* We're done */ + return(current); +} + +static void ORBITAL_SetCaption(_THIS, const char *title, const char *icon) +{ + if (this->hidden->window) { + orb_window_set_title(this->hidden->window, title); + } +} + +/* We don't actually allow hardware surfaces other than the main one */ +static int ORBITAL_AllocHWSurface(_THIS, SDL_Surface *surface) +{ + return(-1); +} +static void ORBITAL_FreeHWSurface(_THIS, SDL_Surface *surface) +{ + return; +} + +/* We need to wait for vertical retrace on page flipped displays */ +static int ORBITAL_LockHWSurface(_THIS, SDL_Surface *surface) +{ + return(0); +} + +static void ORBITAL_UnlockHWSurface(_THIS, SDL_Surface *surface) +{ + return; +} + +static void ORBITAL_UpdateRects(_THIS, int numrects, SDL_Rect *rects) +{ + if (this->hidden->window) { + SDL_SetAlphaChannel(this->screen, SDL_ALPHA_OPAQUE); + orb_window_sync(this->hidden->window); + } +} + +int ORBITAL_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) +{ + /* do nothing of note. */ + return(1); +} + +/* Note: If we are terminated, this could be called in the middle of + another SDL video routine -- notably UpdateRects. +*/ +void ORBITAL_VideoQuit(_THIS) +{ + if (this->hidden->window) { + orb_window_destroy(this->hidden->window); + this->hidden->window = NULL; + this->screen->pixels = NULL; + } +} diff -ruwN source/src/video/orbital/SDL_orbitalvideo.h source-new/src/video/orbital/SDL_orbitalvideo.h --- source/src/video/orbital/SDL_orbitalvideo.h 1969-12-31 17:00:00.000000000 -0700 +++ source-new/src/video/orbital/SDL_orbitalvideo.h 2019-08-12 14:06:11.392352905 -0600 @@ -0,0 +1,43 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_config.h" + +#ifndef _SDL_orbitalvideo_h +#define _SDL_orbitalvideo_h + +#include +#include "../SDL_sysvideo.h" + +/* Hidden "this" pointer for the video functions */ +#define _THIS SDL_VideoDevice *this + + +/* Private display data */ + +struct SDL_PrivateVideoData { + void *window; + bool mouse_cursor; + bool mouse_grab; + bool mouse_relative; +}; + +#endif /* _SDL_orbitalvideo_h */ diff -ruwN source/src/video/SDL_gamma.c source-new/src/video/SDL_gamma.c --- source/src/video/SDL_gamma.c 2012-01-18 23:30:06.000000000 -0700 +++ source-new/src/video/SDL_gamma.c 2019-08-10 20:55:13.670786496 -0600 @@ -35,6 +35,9 @@ #define log(x) __ieee754_log(x) #endif +#include "e_log.h" +#define log(x) __ieee754_log(x) + #include "SDL_sysvideo.h" diff -ruwN source/src/video/SDL_sysvideo.h source-new/src/video/SDL_sysvideo.h --- source/src/video/SDL_sysvideo.h 2012-01-18 23:30:06.000000000 -0700 +++ source-new/src/video/SDL_sysvideo.h 2019-08-10 20:55:13.670786496 -0600 @@ -410,6 +410,9 @@ #if SDL_VIDEO_DRIVER_CACA extern VideoBootStrap CACA_bootstrap; #endif +#if SDL_VIDEO_DRIVER_ORBITAL +extern VideoBootStrap ORBITAL_bootstrap; +#endif #if SDL_VIDEO_DRIVER_DUMMY extern VideoBootStrap DUMMY_bootstrap; #endif diff -ruwN source/src/video/SDL_video.c source-new/src/video/SDL_video.c --- source/src/video/SDL_video.c 2012-01-18 23:30:06.000000000 -0700 +++ source-new/src/video/SDL_video.c 2019-08-10 20:55:13.670786496 -0600 @@ -126,6 +126,9 @@ #if SDL_VIDEO_DRIVER_CACA &CACA_bootstrap, #endif +#if SDL_VIDEO_DRIVER_ORBITAL + &ORBITAL_bootstrap, +#endif #if SDL_VIDEO_DRIVER_DUMMY &DUMMY_bootstrap, #endif @@ -726,7 +729,8 @@ video->offset_y = 0; mode->offset = 0; SDL_SetClipRect(mode, NULL); - SDL_ClearSurface(mode); + // Causes blinking under Orbital + //SDL_ClearSurface(mode); /* Now adjust the offsets to match the desired mode */ video->offset_x = (mode->w-width)/2;