thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Modularized GP2X backend. Renamed GP2XWIZSdlEventManager to GP2XSdlEventManager, and added GP2X code.

Browse source 
svn-id: r50542
This commit is contained in:
Alejandro Marzini 2010-07-01 06:07:24 +00:00
parent 1bc87e3bee
commit a35db656d3
15 changed files with 406 additions and 3170 deletions
Download patch file Download diff file Expand all files Collapse all files

71
backends/events/gp2xwizsdl/gp2xwizsdl-events.cpp → backends/events/gp2xsdl/gp2xsdl-events.cpp
View file

@ -23,11 +23,17 @@
* *
*/ */
#ifdef GP2XWIZ #if defined(GP2X) || defined(GP2XWIZ)
#include "backends/events/gp2xwizsdl/gp2xwizsdl-events.h" #include "backends/events/gp2xsdl/gp2xsdl-events.h"
#if defined(GP2X)
#include "backends/platform/gp2x/gp2x-hw.h"
#include "backends/graphics/gp2xsdl/gp2xsdl-graphics.h"
#else
#include "backends/platform/gp2xwiz/gp2xwiz-hw.h" #include "backends/platform/gp2xwiz/gp2xwiz-hw.h"
#include "backends/platform/gp2xwiz/gp2xwiz-sdl.h" #endif
#include "backends/platform/sdl/sdl.h"
// FIXME move joystick defines out and replace with confile file options // FIXME move joystick defines out and replace with confile file options
// we should really allow users to map any key to a joystick button using the keymapper. // we should really allow users to map any key to a joystick button using the keymapper.
@ -36,7 +42,7 @@
#define JOY_XAXIS 0 #define JOY_XAXIS 0
#define JOY_YAXIS 1 #define JOY_YAXIS 1
/* GP2X Wiz: Main Joystick Mappings */ /* GP2X: Main Joystick Mappings */
enum { enum {
GP2X_BUTTON_UP = 0, GP2X_BUTTON_UP = 0,
GP2X_BUTTON_UPLEFT = 1, GP2X_BUTTON_UPLEFT = 1,
@ -55,17 +61,18 @@ enum {
GP2X_BUTTON_X = 14, GP2X_BUTTON_X = 14,
GP2X_BUTTON_Y = 15, GP2X_BUTTON_Y = 15,
GP2X_BUTTON_VOLUP = 16, GP2X_BUTTON_VOLUP = 16,
GP2X_BUTTON_VOLDOWN = 17 GP2X_BUTTON_VOLDOWN = 17,
GP2X_BUTTON_CLICK = 18
}; };
GP2XWIZSdlEventManager::GP2XWIZSdlEventManager(Common::EventSource *boss) GP2XSdlEventManager::GP2XSdlEventManager(Common::EventSource *boss)
: :
_buttonStateL(false), _buttonStateL(false),
SdlEventManager(boss) { SdlEventManager(boss) {
} }
void GP2XWIZSdlEventManager::SDLModToOSystemKeyFlags(SDLMod mod, Common::Event &event) { void GP2XSdlEventManager::SDLModToOSystemKeyFlags(SDLMod mod, Common::Event &event) {
event.kbd.flags = 0; event.kbd.flags = 0;
if (mod & KMOD_SHIFT) if (mod & KMOD_SHIFT)
@ -76,7 +83,7 @@ void GP2XWIZSdlEventManager::SDLModToOSystemKeyFlags(SDLMod mod, Common::Event &
event.kbd.flags |= Common::KBD_CTRL; event.kbd.flags |= Common::KBD_CTRL;
} }
void GP2XWIZSdlEventManager::moveStick() { void GP2XSdlEventManager::moveStick() {
bool stickBtn[32]; bool stickBtn[32];
memcpy(stickBtn, _stickBtn, sizeof(stickBtn)); memcpy(stickBtn, _stickBtn, sizeof(stickBtn));
@ -119,7 +126,7 @@ void GP2XWIZSdlEventManager::moveStick() {
} }
} }
/* GP2X Wiz Input mappings. /* GP2X Input mappings.
Single Button Single Button
Movement: Movement:
@ -136,6 +143,7 @@ GP2X_BUTTON_DOWNRIGHT Cursor Down Right
Button Emulation: Button Emulation:
GP2X_BUTTON_CLICK Left Mouse Click (GP2X only)
GP2X_BUTTON_A . (Period) GP2X_BUTTON_A . (Period)
GP2X_BUTTON_B Left Mouse Click GP2X_BUTTON_B Left Mouse Click
GP2X_BUTTON_Y Space Bar GP2X_BUTTON_Y Space Bar
@ -153,9 +161,10 @@ GP2X_BUTTON_VOLUP & GP2X_BUTTON_VOLDOWN 0 (For Monkey 2 CP) or Virtual Keyboard
GP2X_BUTTON_L & GP2X_BUTTON_SELECT Common::EVENT_QUIT (Calls Sync() to make sure SD is flushed) GP2X_BUTTON_L & GP2X_BUTTON_SELECT Common::EVENT_QUIT (Calls Sync() to make sure SD is flushed)
GP2X_BUTTON_L & GP2X_BUTTON_MENU Common::EVENT_MAINMENU (ScummVM Global Main Menu) GP2X_BUTTON_L & GP2X_BUTTON_MENU Common::EVENT_MAINMENU (ScummVM Global Main Menu)
GP2X_BUTTON_L & GP2X_BUTTON_A Common::EVENT_PREDICTIVE_DIALOG for predictive text entry box (AGI games) GP2X_BUTTON_L & GP2X_BUTTON_A Common::EVENT_PREDICTIVE_DIALOG for predictive text entry box (AGI games)
GP2X_BUTTON_L & GP2X_BUTTON_Y Toggles setZoomOnMouse() for larger then 320*240 games to scale to the point + raduis. (GP2X only)
*/ */
bool GP2XWIZSdlEventManager::handleKeyDown(SDL_Event &ev, Common::Event &event) { bool GP2XSdlEventManager::handleKeyDown(SDL_Event &ev, Common::Event &event) {
SDLModToOSystemKeyFlags(SDL_GetModState(), event); SDLModToOSystemKeyFlags(SDL_GetModState(), event);
if (remapKey(ev, event)) if (remapKey(ev, event))
@ -168,7 +177,7 @@ bool GP2XWIZSdlEventManager::handleKeyDown(SDL_Event &ev, Common::Event &event)
return true; return true;
} }
bool GP2XWIZSdlEventManager::handleKeyUp(SDL_Event &ev, Common::Event &event) { bool GP2XSdlEventManager::handleKeyUp(SDL_Event &ev, Common::Event &event) {
if (remapKey(ev, event)) if (remapKey(ev, event))
return true; return true;
@ -186,11 +195,16 @@ bool GP2XWIZSdlEventManager::handleKeyUp(SDL_Event &ev, Common::Event &event) {
return true; return true;
} }
bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &event) { bool GP2XSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &event) {
_stickBtn[ev.jbutton.button] = 1; _stickBtn[ev.jbutton.button] = 1;
if (ev.jbutton.button == GP2X_BUTTON_B) { if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONDOWN; event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y); fillMouseEvent(event, _km.x, _km.y);
#ifdef GP2X
} else if (ev.jbutton.button == GP2X_BUTTON_CLICK) {
event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
#endif
} else if (ev.jbutton.button == GP2X_BUTTON_X) { } else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONDOWN; event.type = Common::EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y); fillMouseEvent(event, _km.x, _km.y);
@ -208,7 +222,7 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
_buttonStateL = true; _buttonStateL = true;
break; break;
case GP2X_BUTTON_R: case GP2X_BUTTON_R:
if (_buttonStateL == true) { if (_buttonStateL) {
#ifdef ENABLE_VKEYBD #ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7; event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0); event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
@ -222,7 +236,7 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
} }
break; break;
case GP2X_BUTTON_SELECT: case GP2X_BUTTON_SELECT:
if (_buttonStateL == true) { if (_buttonStateL) {
event.type = Common::EVENT_QUIT; event.type = Common::EVENT_QUIT;
} else { } else {
event.kbd.keycode = Common::KEYCODE_ESCAPE; event.kbd.keycode = Common::KEYCODE_ESCAPE;
@ -230,7 +244,7 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
} }
break; break;
case GP2X_BUTTON_A: case GP2X_BUTTON_A:
if (_buttonStateL == true) { if (_buttonStateL) {
event.type = Common::EVENT_PREDICTIVE_DIALOG; event.type = Common::EVENT_PREDICTIVE_DIALOG;
} else { } else {
event.kbd.keycode = Common::KEYCODE_PERIOD; event.kbd.keycode = Common::KEYCODE_PERIOD;
@ -238,11 +252,19 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
} }
break; break;
case GP2X_BUTTON_Y: case GP2X_BUTTON_Y:
#ifdef GP2X
if (_buttonStateL) {
((GP2XSdlGraphicsManager *)((OSystem_SDL *)g_system)->getGraphicsManager())->toggleZoomOnMouse();
} else {
#endif
event.kbd.keycode = Common::KEYCODE_SPACE; event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0); event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
#ifdef GP2X
}
#endif
break; break;
case GP2X_BUTTON_MENU: case GP2X_BUTTON_MENU:
if (_buttonStateL == true) { if (_buttonStateL) {
event.type = Common::EVENT_MAINMENU; event.type = Common::EVENT_MAINMENU;
} else { } else {
event.kbd.keycode = Common::KEYCODE_F5; event.kbd.keycode = Common::KEYCODE_F5;
@ -250,8 +272,13 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
} }
break; break;
case GP2X_BUTTON_VOLUP: case GP2X_BUTTON_VOLUP:
#ifdef GP2X
GP2X_HW::mixerMoveVolume(2);
if (GP2X_HW::volumeLevel == 100) {
#else
WIZ_HW::mixerMoveVolume(2); WIZ_HW::mixerMoveVolume(2);
if (WIZ_HW::volumeLevel == 100) { if (WIZ_HW::volumeLevel == 100) {
#endif
g_system->displayMessageOnOSD("Maximum Volume"); g_system->displayMessageOnOSD("Maximum Volume");
} else { } else {
g_system->displayMessageOnOSD("Increasing Volume"); g_system->displayMessageOnOSD("Increasing Volume");
@ -259,8 +286,13 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
break; break;
case GP2X_BUTTON_VOLDOWN: case GP2X_BUTTON_VOLDOWN:
#ifdef GP2X
GP2X_HW::mixerMoveVolume(1);
if (GP2X_HW::volumeLevel == 0) {
#else
WIZ_HW::mixerMoveVolume(1); WIZ_HW::mixerMoveVolume(1);
if (WIZ_HW::volumeLevel == 0) { if (WIZ_HW::volumeLevel == 0) {
#endif
g_system->displayMessageOnOSD("Minimal Volume"); g_system->displayMessageOnOSD("Minimal Volume");
} else { } else {
g_system->displayMessageOnOSD("Decreasing Volume"); g_system->displayMessageOnOSD("Decreasing Volume");
@ -271,11 +303,16 @@ bool GP2XWIZSdlEventManager::handleJoyButtonDown(SDL_Event &ev, Common::Event &e
return true; return true;
} }
bool GP2XWIZSdlEventManager::handleJoyButtonUp(SDL_Event &ev, Common::Event &event) { bool GP2XSdlEventManager::handleJoyButtonUp(SDL_Event &ev, Common::Event &event) {
_stickBtn[ev.jbutton.button] = 0; _stickBtn[ev.jbutton.button] = 0;
if (ev.jbutton.button == GP2X_BUTTON_B) { if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONUP; event.type = Common::EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y); fillMouseEvent(event, _km.x, _km.y);
#ifdef GP2X
} else if (ev.jbutton.button == GP2X_BUTTON_CLICK) {
event.type = Common::EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
#endif
} else if (ev.jbutton.button == GP2X_BUTTON_X) { } else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONUP; event.type = Common::EVENT_RBUTTONUP;
fillMouseEvent(event, _km.x, _km.y); fillMouseEvent(event, _km.x, _km.y);

8
backends/events/gp2xwizsdl/gp2xwizsdl-events.h → backends/events/gp2xsdl/gp2xsdl-events.h
View file

@ -23,14 +23,14 @@
* *
*/ */
#if !defined(BACKEND_EVENTS_SDL_GP2XWIZ_H) && !defined(DISABLE_DEFAULT_EVENTMANAGER) #if !defined(BACKEND_EVENTS_SDL_GP2X_H) && !defined(DISABLE_DEFAULT_EVENTMANAGER)
#define BACKEND_EVENTS_SDL_GP2XWIZ_H #define BACKEND_EVENTS_SDL_GP2X_H
#include "backends/events/sdl/sdl-events.h" #include "backends/events/sdl/sdl-events.h"
class GP2XWIZSdlEventManager : public SdlEventManager { class GP2XSdlEventManager : public SdlEventManager {
public: public:
GP2XWIZSdlEventManager(Common::EventSource *boss); GP2XSdlEventManager(Common::EventSource *boss);
protected: protected:
bool _stickBtn[32]; bool _stickBtn[32];

183
backends/graphics/gp2xsdl/gp2xsdl-graphics.cpp Normal file
View file

@ -0,0 +1,183 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#ifdef GP2X
#include "backends/graphics/gp2xsdl/gp2xsdl-graphics.h"
#include "graphics/scaler/aspect.h"
#include <SDL_gp2x.h>
static const OSystem::GraphicsMode s_supportedGraphicsModes[] = {
{"Fullscreen", "1x", GFX_NORMAL},
{0, 0, 0}
};
GP2XSdlGraphicsManager::GP2XSdlGraphicsManager()
:
_adjustZoomOnMouse(false) {
}
const OSystem::GraphicsMode *GP2XSdlGraphicsManager::getSupportedGraphicsModes() const {
return s_supportedGraphicsModes;
}
int GP2XSdlGraphicsManager::getDefaultGraphicsMode() const {
return GFX_NORMAL;
}
bool GP2XSdlGraphicsManager::hasFeature(OSystem::Feature f) {
if (f == OSystem::kFeatureIconifyWindow)
return false;
return SdlGraphicsManager::hasFeature(f);
}
void GP2XSdlGraphicsManager::setFeatureState(OSystem::Feature f, bool enable) {
if (f != OSystem::kFeatureIconifyWindow)
SdlGraphicsManager::setFeatureState(f, enable);
}
void GP2XSdlGraphicsManager::drawMouse() {
if (!_mouseVisible || !_mouseSurface) {
_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0;
return;
}
SDL_Rect zoomdst;
SDL_Rect dst;
int scale;
int hotX, hotY;
int tmpScreenWidth, tmpScreenHeight;
// Temp vars to ensure we zoom to the LCD resolution or greater.
tmpScreenWidth = _videoMode.screenWidth;
tmpScreenHeight = _videoMode.screenHeight;
if (_videoMode.screenHeight <= 240) {
tmpScreenHeight = 240;
}
if (_videoMode.screenWidth <= 320) {
tmpScreenWidth = 320;
}
dst.x = _mouseCurState.x;
dst.y = _mouseCurState.y;
if (!_overlayVisible) {
scale = _videoMode.scaleFactor;
dst.w = _mouseCurState.vW;
dst.h = _mouseCurState.vH;
hotX = _mouseCurState.vHotX;
hotY = _mouseCurState.vHotY;
} else {
scale = 1;
dst.w = _mouseCurState.rW;
dst.h = _mouseCurState.rH;
hotX = _mouseCurState.rHotX;
hotY = _mouseCurState.rHotY;
}
// The mouse is undrawn using virtual coordinates, i.e. they may be
// scaled and aspect-ratio corrected.
_mouseBackup.x = dst.x - hotX;
_mouseBackup.y = dst.y - hotY;
_mouseBackup.w = dst.w;
_mouseBackup.h = dst.h;
// We draw the pre-scaled cursor image, so now we need to adjust for
// scaling, shake position and aspect ratio correction manually.
if (!_overlayVisible) {
dst.y += _currentShakePos;
}
if (_videoMode.aspectRatioCorrection && !_overlayVisible)
dst.y = real2Aspect(dst.y);
dst.x = scale * dst.x - _mouseCurState.rHotX;
dst.y = scale * dst.y - _mouseCurState.rHotY;
dst.w = _mouseCurState.rW;
dst.h = _mouseCurState.rH;
// Hacking about with the zoom around mouse pointer stuff.
if (_adjustZoomOnMouse){
zoomdst.w = (tmpScreenWidth / 2);
zoomdst.h = (tmpScreenHeight / 2);
// Create a zoomed rect centered on the mouse pointer.
// Will pan 1/4 of the screen.
if (dst.x > ((tmpScreenWidth / 4) * 3)) {
zoomdst.x = (tmpScreenWidth / 2);
} else {
zoomdst.x = (dst.x - (tmpScreenWidth / 4));
if (zoomdst.x < 0) {
zoomdst.x = 0;
}
}
if (dst.y > ((tmpScreenHeight / 4) * 3)) {
zoomdst.y = (tmpScreenHeight / 2);
} else {
zoomdst.y = (dst.y - (tmpScreenHeight / 4));
if (zoomdst.y < 0) {
zoomdst.y = 0;
}
}
SDL_GP2X_Display(&zoomdst);
} else {
// Make sure we are looking at the whole screen otherwise.
zoomdst.x = 0;
zoomdst.y = 0;
zoomdst.w = (tmpScreenWidth);
zoomdst.h = (tmpScreenHeight);
SDL_GP2X_Display(&zoomdst);
};
// Note that SDL_BlitSurface() and addDirtyRect() will both perform any
// clipping necessary
if (SDL_BlitSurface(_mouseSurface, NULL, _hwscreen, &dst) != 0)
error("SDL_BlitSurface failed: %s", SDL_GetError());
// The screen will be updated using real surface coordinates, i.e.
// they will not be scaled or aspect-ratio corrected.
addDirtyRect(dst.x, dst.y, dst.w, dst.h, true);
}
void GP2XSdlGraphicsManager::toggleZoomOnMouse() {
_adjustZoomOnMouse = !_adjustZoomOnMouse;
}
#endif

50
backends/graphics/gp2xsdl/gp2xsdl-graphics.h Normal file
View file

@ -0,0 +1,50 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#ifndef BACKENDS_GRAPHICS_SDL_GP2X_H
#define BACKENDS_GRAPHICS_SDL_GP2X_H
#include "backends/graphics/sdl/sdl-graphics.h"
class GP2XSdlGraphicsManager : public SdlGraphicsManager {
public:
GP2XSdlGraphicsManager();
virtual ~GP2XSdlGraphicsManager() {}
virtual const OSystem::GraphicsMode *getSupportedGraphicsModes() const;
virtual int getDefaultGraphicsMode() const;
virtual void drawMouse();
virtual bool hasFeature(OSystem::Feature f);
virtual void setFeatureState(OSystem::Feature f, bool enable);
// Toggles zoom adjust on mouse
void toggleZoomOnMouse();
protected:
bool _adjustZoomOnMouse;
};
#endif

6
backends/graphics/gp2xwizsdl/gp2xwizsdl-graphics.cpp
View file

@ -23,10 +23,10 @@
* *
*/ */
#ifndef GP2XWIZ #ifdef GP2XWIZ
#include "backends/graphics/gp2xwizsdl/gp2xwizsdl-graphics.h" #include "backends/graphics/gp2xwizsdl/gp2xwizsdl-graphics.h"
#include "backends/events/gp2xwizsdl/gp2xwizsdl-events.h" #include "backends/events/gp2xsdl/gp2xsdl-events.h"
#include "common/mutex.h" #include "common/mutex.h"
#include "graphics/scaler/aspect.h" #include "graphics/scaler/aspect.h"
@ -121,7 +121,7 @@ void GP2XWIZSdlGraphicsManager::initSize(uint w, uint h) {
if (w > 320 || h > 240){ if (w > 320 || h > 240){
setGraphicsMode(GFX_HALF); setGraphicsMode(GFX_HALF);
setGraphicsModeIntern(); setGraphicsModeIntern();
((GP2XWIZSdlEventManager *)g_system->getEventManager())->toggleMouseGrab(); ((GP2XSdlEventManager *)g_system->getEventManager())->toggleMouseGrab();
} }
_transactionDetails.sizeChanged = true; _transactionDetails.sizeChanged = true;

2
backends/mixer/doublebuffersdl/doublebuffersdl-mixer.cpp
View file

@ -23,7 +23,7 @@
* *
*/ */
#if defined(MACOSX) #if defined(MACOSX) || defined(GP2X)
#include "backends/mixer/doublebuffersdl/doublebuffersdl-mixer.h" #include "backends/mixer/doublebuffersdl/doublebuffersdl-mixer.h"

5
backends/mixer/sdl/sdl-mixer.cpp
View file

@ -29,8 +29,11 @@
#include "common/system.h" #include "common/system.h"
#include "common/config-manager.h" #include "common/config-manager.h"
//#define SAMPLES_PER_SEC 11025 #ifdef GP2X
#define SAMPLES_PER_SEC 11025
#else
#define SAMPLES_PER_SEC 22050 #define SAMPLES_PER_SEC 22050
#endif
//#define SAMPLES_PER_SEC 44100 //#define SAMPLES_PER_SEC 44100
SdlMixerManager::SdlMixerManager() SdlMixerManager::SdlMixerManager()

3
backends/module.mk
View file

@ -6,7 +6,7 @@ MODULE_OBJS := \
audiocd/default/default-audiocd.o \ audiocd/default/default-audiocd.o \
audiocd/sdl/sdl-audiocd.o \ audiocd/sdl/sdl-audiocd.o \
events/default/default-events.o \ events/default/default-events.o \
events/gp2xwizsdl/gp2xwizsdl-events.o \ events/gp2xsdl/gp2xsdl-events.o \
events/linuxmotosdl/linuxmotosdl-events.o \ events/linuxmotosdl/linuxmotosdl-events.o \
events/samsungtvsdl/samsungtvsdl-events.o \ events/samsungtvsdl/samsungtvsdl-events.o \
events/sdl/sdl-events.o \ events/sdl/sdl-events.o \
@ -25,6 +25,7 @@ MODULE_OBJS := \
fs/wii/wii-fs-factory.o \ fs/wii/wii-fs-factory.o \
fs/n64/n64-fs-factory.o \ fs/n64/n64-fs-factory.o \
fs/n64/romfsstream.o \ fs/n64/romfsstream.o \
graphics/gp2xsdl/gp2xsdl-graphics.o \
graphics/gp2xwizsdl/gp2xwizsdl-graphics.o \ graphics/gp2xwizsdl/gp2xwizsdl-graphics.o \
graphics/linuxmotosdl/linuxmotosdl-graphics.o \ graphics/linuxmotosdl/linuxmotosdl-graphics.o \
graphics/sdl/sdl-graphics.o \ graphics/sdl/sdl-graphics.o \

638
backends/platform/gp2x/events.cpp
View file

@ -1,638 +0,0 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
/*
* GP2X: Common::Event Handling.
*
*/
#include "backends/platform/gp2x/gp2x-common.h"
#include "backends/platform/gp2x/gp2x-hw.h"
#include "backends/keymapper/keymapper.h"
#include "common/util.h"
#include "common/events.h"
#include "graphics/scaler/aspect.h" // for aspect2Real
// FIXME move joystick defines out and replace with confile file options
// we should really allow users to map any key to a joystick button using the keymapper.
#define JOY_DEADZONE 2200
#define JOY_XAXIS 0
#define JOY_YAXIS 1
/* GP2X Wiz: Main Joystick Mappings */
enum {
GP2X_BUTTON_UP = 0,
GP2X_BUTTON_UPLEFT = 1,
GP2X_BUTTON_LEFT = 2,
GP2X_BUTTON_DOWNLEFT = 3,
GP2X_BUTTON_DOWN = 4,
GP2X_BUTTON_DOWNRIGHT = 5,
GP2X_BUTTON_RIGHT = 6,
GP2X_BUTTON_UPRIGHT = 7,
GP2X_BUTTON_START = 8,
GP2X_BUTTON_SELECT = 9,
GP2X_BUTTON_L = 10,
GP2X_BUTTON_R = 11,
GP2X_BUTTON_A = 12,
GP2X_BUTTON_B = 13,
GP2X_BUTTON_X = 14,
GP2X_BUTTON_Y = 15,
GP2X_BUTTON_VOLUP = 16,
GP2X_BUTTON_VOLDOWN = 17,
GP2X_BUTTON_CLICK = 18
};
static int mapKey(SDLKey key, SDLMod mod, Uint16 unicode) {
if (key >= SDLK_F1 && key <= SDLK_F9) {
return key - SDLK_F1 + Common::ASCII_F1;
} else if (key >= SDLK_KP0 && key <= SDLK_KP9) {
return key - SDLK_KP0 + '0';
} else if (key >= SDLK_UP && key <= SDLK_PAGEDOWN) {
return key;
} else if (unicode) {
return unicode;
} else if (key >= 'a' && key <= 'z' && (mod & KMOD_SHIFT)) {
return key & ~0x20;
} else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO) {
return 0;
}
return key;
}
void OSystem_GP2X::fillMouseEvent(Common::Event &event, int x, int y) {
event.mouse.x = x;
event.mouse.y = y;
// Update the "keyboard mouse" coords
_km.x = x;
_km.y = y;
// Adjust for the screen scaling
if (!_overlayVisible) {
event.mouse.x /= _videoMode.scaleFactor;
event.mouse.y /= _videoMode.scaleFactor;
if (_videoMode.aspectRatioCorrection)
event.mouse.y = aspect2Real(event.mouse.y);
}
}
void OSystem_GP2X::handleKbdMouse() {
uint32 curTime = getMillis();
if (curTime >= _km.last_time + _km.delay_time) {
_km.last_time = curTime;
if (_km.x_down_count == 1) {
_km.x_down_time = curTime;
_km.x_down_count = 2;
}
if (_km.y_down_count == 1) {
_km.y_down_time = curTime;
_km.y_down_count = 2;
}
if (_km.x_vel || _km.y_vel) {
if (_km.x_down_count) {
if (curTime > _km.x_down_time + _km.delay_time * 12) {
if (_km.x_vel > 0)
_km.x_vel++;
else
_km.x_vel--;
} else if (curTime > _km.x_down_time + _km.delay_time * 8) {
if (_km.x_vel > 0)
_km.x_vel = 5;
else
_km.x_vel = -5;
}
}
if (_km.y_down_count) {
if (curTime > _km.y_down_time + _km.delay_time * 12) {
if (_km.y_vel > 0)
_km.y_vel++;
else
_km.y_vel--;
} else if (curTime > _km.y_down_time + _km.delay_time * 8) {
if (_km.y_vel > 0)
_km.y_vel = 5;
else
_km.y_vel = -5;
}
}
_km.x += _km.x_vel;
_km.y += _km.y_vel;
if (_km.x < 0) {
_km.x = 0;
_km.x_vel = -1;
_km.x_down_count = 1;
} else if (_km.x > _km.x_max) {
_km.x = _km.x_max;
_km.x_vel = 1;
_km.x_down_count = 1;
}
if (_km.y < 0) {
_km.y = 0;
_km.y_vel = -1;
_km.y_down_count = 1;
} else if (_km.y > _km.y_max) {
_km.y = _km.y_max;
_km.y_vel = 1;
_km.y_down_count = 1;
}
SDL_WarpMouse((Uint16)_km.x, (Uint16)_km.y);
}
}
}
static byte SDLModToOSystemKeyFlags(SDLMod mod) {
byte b = 0;
if (mod & KMOD_SHIFT)
b |= Common::KBD_SHIFT;
if (mod & KMOD_ALT)
b |= Common::KBD_ALT;
if (mod & KMOD_CTRL)
b |= Common::KBD_CTRL;
return b;
}
void OSystem_GP2X::moveStick() {
bool stickBtn[32];
memcpy(stickBtn, _stickBtn, sizeof(stickBtn));
if ((stickBtn[0])||(stickBtn[2])||(stickBtn[4])||(stickBtn[6]))
stickBtn[1] = stickBtn[3] = stickBtn[5] = stickBtn[7] = 0;
if ((stickBtn[1])||(stickBtn[2])||(stickBtn[3])){
if (_km.x_down_count!=2){
_km.x_vel = -1;
_km.x_down_count = 1;
}else
_km.x_vel = -4;
} else if ((stickBtn[5])||(stickBtn[6])||(stickBtn[7])){
if (_km.x_down_count!=2){
_km.x_vel = 1;
_km.x_down_count = 1;
} else
_km.x_vel = 4;
} else {
_km.x_vel = 0;
_km.x_down_count = 0;
}
if ((stickBtn[0])||(stickBtn[1])||(stickBtn[7])){
if (_km.y_down_count!=2){
_km.y_vel = -1;
_km.y_down_count = 1;
}else
_km.y_vel = -4;
} else if ((stickBtn[3])||(stickBtn[4])||(stickBtn[5])){
if (_km.y_down_count!=2){
_km.y_vel = 1;
_km.y_down_count = 1;
} else
_km.y_vel = 4;
} else {
_km.y_vel = 0;
_km.y_down_count = 0;
}
}
/* Quick default button states for modifiers. */
int GP2X_BUTTON_STATE_L = false;
bool OSystem_GP2X::pollEvent(Common::Event &event) {
SDL_Event ev;
int axis;
byte b = 0;
handleKbdMouse();
// If the screen mode changed, send an Common::EVENT_SCREEN_CHANGED
if (_modeChanged) {
_modeChanged = false;
event.type = Common::EVENT_SCREEN_CHANGED;
return true;
}
// GP2X Input mappings.
/*
Single Button
Movement:
GP2X_BUTTON_UP Cursor Up
GP2X_BUTTON_DOWN Cursor Down
GP2X_BUTTON_LEFT Cursor Left
GP2X_BUTTON_RIGHT Cursor Right
GP2X_BUTTON_UPLEFT Cursor Up Left
GP2X_BUTTON_UPRIGHT Cursor Up Right
GP2X_BUTTON_DOWNLEFT Cursor Down Left
GP2X_BUTTON_DOWNRIGHT Cursor Down Right
Button Emulation:
GP2X_BUTTON_CLICK Left Mouse Click
GP2X_BUTTON_A . (Period)
GP2X_BUTTON_B Left Mouse Click
GP2X_BUTTON_Y Space Bar
GP2X_BUTTON_X Right Mouse Click
GP2X_BUTTON_L Combo Modifier (Left Trigger)
GP2X_BUTTON_R Return (Right Trigger)
GP2X_BUTTON_START F5 (Game Menu)
GP2X_BUTTON_SELECT Escape
GP2X_BUTTON_VOLUP /dev/mixer Global Volume Up
GP2X_BUTTON_VOLDOWN /dev/mixer Global Volume Down
Combos:
GP2X_BUTTON_VOLUP & GP2X_BUTTON_VOLDOWN 0 (For Monkey 2 CP) or Virtual Keyboard if enabled
GP2X_BUTTON_L & GP2X_BUTTON_SELECT Common::EVENT_QUIT (Calls Sync() to make sure SD is flushed)
GP2X_BUTTON_L & GP2X_BUTTON_Y Toggles setZoomOnMouse() for larger then 320*240 games to scale to the point + raduis.
GP2X_BUTTON_L & GP2X_BUTTON_START Common::EVENT_MAINMENU (ScummVM Global Main Menu)
GP2X_BUTTON_L & GP2X_BUTTON_A Common::EVENT_PREDICTIVE_DIALOG for predictive text entry box (AGI games)
*/
while (SDL_PollEvent(&ev)) {
switch (ev.type) {
case SDL_KEYDOWN:{
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = Common::EVENT_KEYDOWN;
event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
return true;
}
case SDL_KEYUP:
{
const bool event_complete = remapKey(ev,event);
if (event_complete)
return true;
event.type = Common::EVENT_KEYUP;
event.kbd.keycode = (Common::KeyCode)ev.key.keysym.sym;
event.kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod, ev.key.keysym.unicode);
b = event.kbd.flags = SDLModToOSystemKeyFlags(SDL_GetModState());
// Ctrl-Alt-<key> will change the GFX mode
if ((b & (Common::KBD_CTRL|Common::KBD_ALT)) == (Common::KBD_CTRL|Common::KBD_ALT)) {
// Swallow these key up events
break;
}
return true;
}
case SDL_MOUSEMOTION:
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, ev.motion.x, ev.motion.y);
setMousePos(event.mouse.x, event.mouse.y);
return true;
case SDL_MOUSEBUTTONDOWN:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = Common::EVENT_LBUTTONDOWN;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = Common::EVENT_RBUTTONDOWN;
#if defined(SDL_BUTTON_WHEELUP) && defined(SDL_BUTTON_WHEELDOWN)
else if (ev.button.button == SDL_BUTTON_WHEELUP)
event.type = Common::EVENT_WHEELUP;
else if (ev.button.button == SDL_BUTTON_WHEELDOWN)
event.type = Common::EVENT_WHEELDOWN;
#endif
#if defined(SDL_BUTTON_MIDDLE)
else if (ev.button.button == SDL_BUTTON_MIDDLE)
event.type = Common::EVENT_MBUTTONDOWN;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
case SDL_MOUSEBUTTONUP:
if (ev.button.button == SDL_BUTTON_LEFT)
event.type = Common::EVENT_LBUTTONUP;
else if (ev.button.button == SDL_BUTTON_RIGHT)
event.type = Common::EVENT_RBUTTONUP;
#if defined(SDL_BUTTON_MIDDLE)
else if (ev.button.button == SDL_BUTTON_MIDDLE)
event.type = Common::EVENT_MBUTTONUP;
#endif
else
break;
fillMouseEvent(event, ev.button.x, ev.button.y);
return true;
// GP2X Button mapings. Main code
case SDL_JOYBUTTONDOWN:
_stickBtn[ev.jbutton.button] = 1;
if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_CLICK) {
event.type = Common::EVENT_LBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONDOWN;
fillMouseEvent(event, _km.x, _km.y);
} else if (_stickBtn[GP2X_BUTTON_L] && (ev.jbutton.button == GP2X_BUTTON_SELECT)) {
event.type = Common::EVENT_QUIT;
} else if (ev.jbutton.button < 8) {
moveStick();
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = Common::EVENT_KEYDOWN;
event.kbd.flags = 0;
switch (ev.jbutton.button) {
case GP2X_BUTTON_L:
GP2X_BUTTON_STATE_L = true;
break;
case GP2X_BUTTON_R:
if (GP2X_BUTTON_STATE_L == true) {
#ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
#else
event.kbd.keycode = Common::KEYCODE_0;
event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0);
#endif
} else {
event.kbd.keycode = Common::KEYCODE_RETURN;
event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_SELECT:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_QUIT;
} else {
event.kbd.keycode = Common::KEYCODE_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_A:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_PREDICTIVE_DIALOG;
} else {
event.kbd.keycode = Common::KEYCODE_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_Y:
if (GP2X_BUTTON_STATE_L == true) {
setZoomOnMouse();
} else {
event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_START:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_MAINMENU;
} else {
event.kbd.keycode = Common::KEYCODE_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_VOLUP:
GP2X_HW::mixerMoveVolume(2);
if (GP2X_HW::volumeLevel == 100) {
displayMessageOnOSD("Maximum Volume");
} else {
displayMessageOnOSD("Increasing Volume");
}
break;
case GP2X_BUTTON_VOLDOWN:
GP2X_HW::mixerMoveVolume(1);
if (GP2X_HW::volumeLevel == 0) {
displayMessageOnOSD("Minimal Volume");
} else {
displayMessageOnOSD("Decreasing Volume");
}
break;
}
}
return true;
case SDL_JOYBUTTONUP:
_stickBtn[ev.jbutton.button] = 0;
if (ev.jbutton.button == GP2X_BUTTON_B) {
event.type = Common::EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_CLICK) {
event.type = Common::EVENT_LBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button == GP2X_BUTTON_X) {
event.type = Common::EVENT_RBUTTONUP;
fillMouseEvent(event, _km.x, _km.y);
} else if (ev.jbutton.button < 8) {
moveStick();
event.type = Common::EVENT_MOUSEMOVE;
fillMouseEvent(event, _km.x, _km.y);
} else {
event.type = Common::EVENT_KEYUP;
event.kbd.flags = 0;
switch (ev.jbutton.button) {
case GP2X_BUTTON_SELECT:
event.kbd.keycode = Common::KEYCODE_ESCAPE;
event.kbd.ascii = mapKey(SDLK_ESCAPE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_A:
event.kbd.keycode = Common::KEYCODE_PERIOD;
event.kbd.ascii = mapKey(SDLK_PERIOD, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_Y:
event.kbd.keycode = Common::KEYCODE_SPACE;
event.kbd.ascii = mapKey(SDLK_SPACE, ev.key.keysym.mod, 0);
break;
case GP2X_BUTTON_START:
if (GP2X_BUTTON_STATE_L == true) {
event.type = Common::EVENT_MAINMENU;
} else {
event.kbd.keycode = Common::KEYCODE_F5;
event.kbd.ascii = mapKey(SDLK_F5, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_L:
GP2X_BUTTON_STATE_L = false;
break;
case GP2X_BUTTON_R:
if (GP2X_BUTTON_STATE_L == true) {
#ifdef ENABLE_VKEYBD
event.kbd.keycode = Common::KEYCODE_F7;
event.kbd.ascii = mapKey(SDLK_F7, ev.key.keysym.mod, 0);
#else
event.kbd.keycode = Common::KEYCODE_0;
event.kbd.ascii = mapKey(SDLK_0, ev.key.keysym.mod, 0);
#endif
} else {
event.kbd.keycode = Common::KEYCODE_RETURN;
event.kbd.ascii = mapKey(SDLK_RETURN, ev.key.keysym.mod, 0);
}
break;
case GP2X_BUTTON_VOLUP:
break;
case GP2X_BUTTON_VOLDOWN:
break;
}
}
return true;
case SDL_JOYAXISMOTION:
axis = ev.jaxis.value;
if ( axis > JOY_DEADZONE) {
axis -= JOY_DEADZONE;
event.type = Common::EVENT_MOUSEMOVE;
} else if ( axis < -JOY_DEADZONE ) {
axis += JOY_DEADZONE;
event.type = Common::EVENT_MOUSEMOVE;
} else
axis = 0;
if ( ev.jaxis.axis == JOY_XAXIS) {
if (axis != 0) {
_km.x_vel = (axis > 0) ? 1:-1;
_km.x_down_count = 1;
} else {
_km.x_vel = 0;
_km.x_down_count = 0;
}
} else if (ev.jaxis.axis == JOY_YAXIS) {
#ifndef JOY_INVERT_Y
axis = -axis;
#endif
#ifdef JOY_ANALOG
_km.y_vel = -axis / 2000;
_km.y_down_count = 0;
#else
if (axis != 0) {
_km.y_vel = (-axis > 0) ? 1: -1;
_km.y_down_count = 1;
} else {
_km.y_vel = 0;
_km.y_down_count = 0;
}
#endif
}
fillMouseEvent(event, _km.x, _km.y);
return true;
case SDL_VIDEOEXPOSE:
_forceFull = true;
break;
case SDL_QUIT:
event.type = Common::EVENT_QUIT;
return true;
}
}
return false;
}
bool OSystem_GP2X::remapKey(SDL_Event &ev,Common::Event &event) {
return false;
}
void OSystem_GP2X::setupKeymapper() {
#ifdef ENABLE_KEYMAPPER
using namespace Common;
Keymapper *mapper = getEventManager()->getKeymapper();
HardwareKeySet *keySet = new HardwareKeySet();
keySet->addHardwareKey(new HardwareKey( "a", KeyState(KEYCODE_a), "a", kActionKeyType ));
keySet->addHardwareKey(new HardwareKey( "s", KeyState(KEYCODE_s), "s", kActionKeyType ));
keySet->addHardwareKey(new HardwareKey( "d", KeyState(KEYCODE_d), "d", kActionKeyType ));
keySet->addHardwareKey(new HardwareKey( "f", KeyState(KEYCODE_f), "f", kActionKeyType ));
keySet->addHardwareKey(new HardwareKey( "n", KeyState(KEYCODE_n), "n (vk)", kTriggerLeftKeyType, kVirtualKeyboardActionType ));
keySet->addHardwareKey(new HardwareKey( "m", KeyState(KEYCODE_m), "m (remap)", kTriggerRightKeyType, kKeyRemapActionType ));
keySet->addHardwareKey(new HardwareKey( "[", KeyState(KEYCODE_LEFTBRACKET), "[ (select)", kSelectKeyType ));
keySet->addHardwareKey(new HardwareKey( "]", KeyState(KEYCODE_RIGHTBRACKET), "] (start)", kStartKeyType ));
mapper->registerHardwareKeySet(keySet);
Keymap *globalMap = new Keymap("global");
Keymap *guiMap = new Keymap("gui");
Action *act;
Event evt ;
act = new Action(globalMap, "MENU", "Menu", kGenericActionType, kSelectKeyType);
act->addKeyEvent(KeyState(KEYCODE_F5, ASCII_F5, 0));
act = new Action(globalMap, "SKCT", "Skip", kGenericActionType, kActionKeyType);
act->addKeyEvent(KeyState(KEYCODE_ESCAPE, ASCII_ESCAPE, 0));
act = new Action(globalMap, "PAUS", "Pause", kGenericActionType, kStartKeyType);
act->addKeyEvent(KeyState(KEYCODE_SPACE, ' ', 0));
act = new Action(globalMap, "SKLI", "Skip line", kGenericActionType, kActionKeyType);
act->addKeyEvent(KeyState(KEYCODE_PERIOD, '.', 0));
act = new Action(globalMap, "VIRT", "Display keyboard", kVirtualKeyboardActionType);
act->addKeyEvent(KeyState(KEYCODE_F6, ASCII_F6, 0));
act = new Action(globalMap, "REMP", "Remap keys", kKeyRemapActionType);
act->addKeyEvent(KeyState(KEYCODE_F7, ASCII_F7, 0));
mapper->addGlobalKeymap(globalMap);
act = new Action(guiMap, "CLOS", "Close", kGenericActionType, kStartKeyType);
act->addKeyEvent(KeyState(KEYCODE_ESCAPE, ASCII_ESCAPE, 0));
act = new Action(guiMap, "CLIK", "Mouse click");
act->addLeftClickEvent();
act = new Action(guiMap, "VIRT", "Display keyboard", kVirtualKeyboardActionType);
act->addKeyEvent(KeyState(KEYCODE_F6, ASCII_F6, 0));
act = new Action(guiMap, "REMP", "Remap keys", kKeyRemapActionType);
act->addKeyEvent(KeyState(KEYCODE_F7, ASCII_F7, 0));
mapper->addGlobalKeymap(guiMap);
mapper->pushKeymap("global");
#endif
}

363
backends/platform/gp2x/gp2x-common.h
View file

@ -23,361 +23,26 @@
* *
*/ */
#ifndef GP2X_COMMON_H #ifndef PLATFORM_SDL_GP2X_H
#define GP2X_COMMON_H #define PLATFORM_SDL_GP2X_H
#include <SDL.h> #include "backends/platform/sdl/posix/posix.h"
#include <SDL_gp2x.h>
#include "backends/base-backend.h" #ifndef PATH_MAX
#include "graphics/scaler.h" #define PATH_MAX 255
#define __GP2X__
#define USE_OSD
#define MIXER_DOUBLE_BUFFERING 1
namespace Audio {
class MixerImpl;
}
enum {
GFX_NORMAL = 0
};
class OSystem_GP2X : public BaseBackend {
public:
OSystem_GP2X();
virtual ~OSystem_GP2X();
virtual void initBackend();
void beginGFXTransaction(void);
TransactionError endGFXTransaction(void);
// Set the size of the video bitmap.
// Typically, 320x200
void initSize(uint w, uint h, const Graphics::PixelFormat *format);
int getScreenChangeID() const { return _screenChangeCount; }
// Set colors of the palette
void setPalette(const byte *colors, uint start, uint num);
// Get colors of the palette
void grabPalette(byte *colors, uint start, uint num);
// Draw a bitmap to screen.
// The screen will not be updated to reflect the new bitmap
void copyRectToScreen(const byte *src, int pitch, int x, int y, int w, int h);
virtual Graphics::Surface *lockScreen();
virtual void unlockScreen();
// Update the dirty areas of the screen
void updateScreen();
// Either show or hide the mouse cursor
bool showMouse(bool visible);
// Warp the mouse cursor. Where set_mouse_pos() only informs the
// backend of the mouse cursor's current position, this function
// actually moves the cursor to the specified position.
void warpMouse(int x, int y);
// Set the bitmap that's used when drawing the cursor.
void setMouseCursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format);
// Set colors of cursor palette
void setCursorPalette(const byte *colors, uint start, uint num);
// Disables or enables cursor palette
void disableCursorPalette(bool disable) {
_cursorPaletteDisabled = disable;
blitCursor();
}
// Shaking is used in SCUMM. Set current shake position.
void setShakePos(int shake_pos);
// Get the number of milliseconds since the program was started.
uint32 getMillis();
// Delay for a specified amount of milliseconds
void delayMillis(uint msecs);
// Get the next event.
// Returns true if an event was retrieved.
virtual bool pollEvent(Common::Event &event); // overloaded by CE backend
// Sets up the keymapper with the backends hardware key set
void setupKeymapper();
// Set function that generates samples
void setupMixer();
static void mixCallback(void *s, byte *samples, int len);
void closeMixer();
virtual Audio::Mixer *getMixer();
// Quit
void quit();
void getTimeAndDate(TimeDate &t) const;
virtual Common::TimerManager *getTimerManager();
// Mutex handling
MutexRef createMutex();
void lockMutex(MutexRef mutex);
void unlockMutex(MutexRef mutex);
void deleteMutex(MutexRef mutex);
// Overlay
Graphics::PixelFormat getOverlayFormat() const { return _overlayFormat; }
void showOverlay();
void hideOverlay();
void clearOverlay();
void grabOverlay(OverlayColor *buf, int pitch);
void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h);
int16 getHeight();
int16 getWidth();
int16 getOverlayHeight() { return _videoMode.overlayHeight; }
int16 getOverlayWidth() { return _videoMode.overlayWidth; }
const GraphicsMode *getSupportedGraphicsModes() const;
int getDefaultGraphicsMode() const;
bool setGraphicsMode(int mode);
int getGraphicsMode() const;
bool hasFeature(Feature f);
void setFeatureState(Feature f, bool enable);
bool getFeatureState(Feature f);
void displayMessageOnOSD(const char *msg);
virtual Common::SaveFileManager *getSavefileManager();
virtual FilesystemFactory *getFilesystemFactory();
virtual void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0);
virtual Common::SeekableReadStream *createConfigReadStream();
virtual Common::WriteStream *createConfigWriteStream();
protected:
bool _inited;
SDL_Surface *_osdSurface;
Uint8 _osdAlpha; // Transparency level of the OSD
uint32 _osdFadeStartTime; // When to start the fade out
enum {
kOSDFadeOutDelay = 2 * 1000, // Delay before the OSD is faded out (in milliseconds)
kOSDFadeOutDuration = 500, // Duration of the OSD fade out (in milliseconds)
kOSDColorKey = 1,
kOSDInitialAlpha = 80 // Initial alpha level, in percent
};
// hardware screen
SDL_Surface *_hwscreen;
// unseen game screen
SDL_Surface *_screen;
// temporary screen (for scalers)
SDL_Surface *_tmpscreen;
SDL_Surface *_tmpscreen2;
// overlay
SDL_Surface *_overlayscreen;
bool _overlayVisible;
Graphics::PixelFormat _overlayFormat;
enum {
kTransactionNone = 0,
kTransactionActive = 1,
kTransactionRollback = 2
};
struct TransactionDetails {
bool sizeChanged;
bool needHotswap;
bool needUpdatescreen;
bool normal1xScaler;
};
TransactionDetails _transactionDetails;
struct VideoState {
bool setup;
bool fullscreen;
bool aspectRatioCorrection;
int mode;
int scaleFactor;
int screenWidth, screenHeight;
int overlayWidth, overlayHeight;
};
VideoState _videoMode, _oldVideoMode;
virtual void setGraphicsModeIntern(); // overloaded by CE backend
/** Force full redraw on next updateScreen */
bool _forceFull;
ScalerProc *_scalerProc;
int _scalerType;
int _transactionMode;
bool _screenIsLocked;
Graphics::Surface _framebuffer;
/** Current video mode flags (see DF_* constants) */
bool _modeChanged;
int _screenChangeCount;
/* True if zoom on mouse is enabled. (only set by > 240 high games) */
bool _adjustZoomOnMouse;
enum {
NUM_DIRTY_RECT = 100,
MAX_MOUSE_W = 80,
MAX_MOUSE_H = 80,
MAX_SCALING = 3
};
// Dirty rect management
SDL_Rect _dirtyRectList[NUM_DIRTY_RECT];
int _numDirtyRects;
// Keyboard mouse emulation. Disabled by fingolfin 2004-12-18.
// I am keeping the rest of the code in for now, since the joystick
// code (or rather, "hack") uses it, too.
struct KbdMouse {
int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
uint32 last_time, delay_time, x_down_time, y_down_time;
};
struct MousePos {
// The mouse position, using either virtual (game) or real
// (overlay) coordinates.
int16 x, y;
// The size and hotspot of the original cursor image.
int16 w, h;
int16 hotX, hotY;
// The size and hotspot of the pre-scaled cursor image, in real
// coordinates.
int16 rW, rH;
int16 rHotX, rHotY;
// The size and hotspot of the pre-scaled cursor image, in game
// coordinates.
int16 vW, vH;
int16 vHotX, vHotY;
MousePos() : x(0), y(0), w(0), h(0), hotX(0), hotY(0),
rW(0), rH(0), rHotX(0), rHotY(0), vW(0), vH(0),
vHotX(0), vHotY(0)
{ }
};
// mouse
KbdMouse _km;
bool _mouseVisible;
bool _mouseNeedsRedraw;
byte *_mouseData;
SDL_Rect _mouseBackup;
MousePos _mouseCurState;
byte _mouseKeyColor;
int _cursorTargetScale;
bool _cursorPaletteDisabled;
SDL_Surface *_mouseOrigSurface;
SDL_Surface *_mouseSurface;
enum {
kMouseColorKey = 1
};
// joystick
SDL_Joystick *_joystick;
bool _stickBtn[32];
// Shake mode
int _currentShakePos;
int _newShakePos;
// Palette data
SDL_Color *_currentPalette;
uint _paletteDirtyStart, _paletteDirtyEnd;
// Cursor palette data
SDL_Color *_cursorPalette;
/**
* Mutex which prevents multiple threads from interfering with each other
* when accessing the screen.
*/
MutexRef _graphicsMutex;
#ifdef MIXER_DOUBLE_BUFFERING
SDL_mutex *_soundMutex;
SDL_cond *_soundCond;
SDL_Thread *_soundThread;
bool _soundThreadIsRunning;
bool _soundThreadShouldQuit;
byte _activeSoundBuf;
uint _soundBufSize;
byte *_soundBuffers[2];
void mixerProducerThread();
static int SDLCALL mixerProducerThreadEntry(void *arg);
void initThreadedMixer(Audio::MixerImpl *mixer, uint bufSize);
void deinitThreadedMixer();
#endif #endif
FilesystemFactory *_fsFactory; class OSystem_GP2X : public OSystem_POSIX {
Common::SaveFileManager *_savefile; public:
Audio::MixerImpl *_mixer; OSystem_GP2X() {}
virtual ~OSystem_GP2X() {}
SDL_TimerID _timerID; virtual void initBackend();
Common::TimerManager *_timer; virtual void quit();
virtual void addSysArchivesToSearchSet(Common::SearchSet &s, int priority = 0);
protected: protected:
virtual void addDirtyRect(int x, int y, int w, int h, bool realCoordinates = false); virtual void initSDL();
void drawMouse();
void undrawMouse();
void blitCursor();
/** Set the position of the virtual mouse cursor. */
void setMousePos(int x, int y);
void fillMouseEvent(Common::Event &event, int x, int y);
void toggleMouseGrab();
void internUpdateScreen();
bool loadGFXMode();
void unloadGFXMode();
bool hotswapGFXMode();
void setFullscreenMode(bool enable);
void setAspectRatioCorrection(bool enable);
void setZoomOnMouse(); // GP2X: On > 240 high games zooms on the mouse + radius.
bool saveScreenshot(const char *filename);
int effectiveScreenHeight() const;
void setupIcon();
void handleKbdMouse();
virtual bool remapKey(SDL_Event &ev, Common::Event &event);
void handleScalerHotkeys(const SDL_KeyboardEvent &key);
void moveStick();
int _gp2xInputType;
}; };
#endif // GP2X_COMMON_H #endif

50
backends/platform/gp2x/gp2x-main.cpp Normal file
View file

@ -0,0 +1,50 @@
/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $URL$
* $Id$
*
*/
#include "backends/platform/gp2x/gp2x-sdl.h"
#include "backends/plugins/posix/posix-provider.h"
#include "base/main.h"
int main(int argc, char *argv[]) {
// Create our OSystem instance
g_system = new OSystem_GP2X();
assert(g_system);
// Pre initialize the backend
((OSystem_GP2X *)g_system)->init();
#ifdef DYNAMIC_MODULES
PluginManager::instance().addPluginProvider(new POSIXPluginProvider());
#endif
// Invoke the actual ScummVM main entry point:
int res = scummvm_main(argc, argv);
// Free OSystem
delete (OSystem_GP2X *)g_system;
return res;
}

505
backends/platform/gp2x/gp2x.cpp
View file

@ -23,29 +23,19 @@
* *
*/ */
/*
* GP2X: Main backend.
*
*/
#include "backends/platform/gp2x/gp2x-common.h" #include "backends/platform/gp2x/gp2x-common.h"
#include "backends/platform/gp2x/gp2x-hw.h" #include "backends/platform/gp2x/gp2x-hw.h"
#include "backends/platform/gp2x/gp2x-mem.h" #include "backends/platform/gp2x/gp2x-mem.h"
#include "common/archive.h"
#include "common/config-manager.h"
#include "common/debug.h"
#include "common/EventRecorder.h"
#include "common/events.h"
#include "common/util.h"
#include "common/file.h"
#include "base/main.h"
#include "backends/graphics/gp2xsdl/gp2xsdl-graphics.h"
#include "backends/events/gp2xsdl/gp2xsdl-events.h"
#include "backends/saves/default/default-saves.h" #include "backends/saves/default/default-saves.h"
#include "backends/timer/default/default-timer.h" #include "common/config-manager.h"
#include "backends/plugins/posix/posix-provider.h" #include "common/debug.h"
#include "sound/mixer_intern.h"
// Disable for normal serial logging.
#define DUMP_STDOUT
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -53,66 +43,11 @@
#include <limits.h> #include <limits.h>
#include <errno.h> #include <errno.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <time.h> // for getTimeAndDate()
// Disable for normal serial logging.
#define DUMP_STDOUT
#define SAMPLES_PER_SEC 11025
//#define SAMPLES_PER_SEC 22050
//#define SAMPLES_PER_SEC 44100
#define DEFAULT_CONFIG_FILE ".scummvmrc"
#include "backends/fs/posix/posix-fs-factory.h"
static Uint32 timer_handler(Uint32 interval, void *param) {
((DefaultTimerManager *)param)->handler();
return interval;
}
int main(int argc, char *argv[]) {
g_system = new OSystem_GP2X();
assert(g_system);
#ifdef DYNAMIC_MODULES
PluginManager::instance().addPluginProvider(new POSIXPluginProvider());
#endif
// Invoke the actual ScummVM main entry point:
int res = scummvm_main(argc, argv);
g_system->quit();
return res;
}
OSystem *OSystem_GP2X_create() {
return new OSystem_GP2X();
}
void OSystem_GP2X::initBackend() { void OSystem_GP2X::initBackend() {
assert(!_inited);
ConfMan.setInt("joystick_num", 0);
int joystick_num = ConfMan.getInt("joystick_num");
uint32 sdlFlags = SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER | SDL_INIT_EVENTTHREAD;
if (ConfMan.hasKey("disable_sdl_parachute"))
sdlFlags |= SDL_INIT_NOPARACHUTE;
if (joystick_num > -1)
sdlFlags |= SDL_INIT_JOYSTICK;
if (SDL_Init(sdlFlags) == -1) {
error("Could not initialize SDL: %s", SDL_GetError());
}
// Setup default save path to be workingdir/saves // Setup default save path to be workingdir/saves
#ifndef PATH_MAX char savePath[PATH_MAX + 1];
#define PATH_MAX 255 char workDirName[PATH_MAX + 1];
#endif
char savePath[PATH_MAX+1];
char workDirName[PATH_MAX+1];
if (getcwd(workDirName, PATH_MAX) == NULL) { if (getcwd(workDirName, PATH_MAX) == NULL) {
error("Could not obtain current working directory."); error("Could not obtain current working directory.");
@ -134,8 +69,8 @@ void OSystem_GP2X::initBackend() {
#ifdef DUMP_STDOUT #ifdef DUMP_STDOUT
// The GP2X has a serial console but most users do not use this so we // The GP2X has a serial console but most users do not use this so we
// output all our STDOUT and STDERR to files for debug purposes. // output all our STDOUT and STDERR to files for debug purposes.
char STDOUT_FILE[PATH_MAX+1]; char STDOUT_FILE[PATH_MAX + 1];
char STDERR_FILE[PATH_MAX+1]; char STDERR_FILE[PATH_MAX + 1];
strcpy(STDOUT_FILE, workDirName); strcpy(STDOUT_FILE, workDirName);
strcpy(STDERR_FILE, workDirName); strcpy(STDERR_FILE, workDirName);
@ -175,12 +110,7 @@ void OSystem_GP2X::initBackend() {
printf("%s\n", "Debug: STDOUT and STDERR redirected to text files."); printf("%s\n", "Debug: STDOUT and STDERR redirected to text files.");
#endif /* DUMP_STDOUT */ #endif /* DUMP_STDOUT */
_graphicsMutex = createMutex();
SDL_ShowCursor(SDL_DISABLE);
// Setup other defaults. // Setup other defaults.
ConfMan.registerDefault("aspect_ratio", true); ConfMan.registerDefault("aspect_ratio", true);
/* Up default volume values as we use a seperate system level volume anyway. */ /* Up default volume values as we use a seperate system level volume anyway. */
@ -189,143 +119,47 @@ void OSystem_GP2X::initBackend() {
ConfMan.registerDefault("speech_volume", 192); ConfMan.registerDefault("speech_volume", 192);
ConfMan.registerDefault("autosave_period", 3 * 60); // Trigger autosave every 3 minutes - On low batts 4 mins is about your warning time. ConfMan.registerDefault("autosave_period", 3 * 60); // Trigger autosave every 3 minutes - On low batts 4 mins is about your warning time.
memset(&_oldVideoMode, 0, sizeof(_oldVideoMode));
memset(&_videoMode, 0, sizeof(_videoMode));
memset(&_transactionDetails, 0, sizeof(_transactionDetails));
_videoMode.mode = GFX_NORMAL;
_videoMode.scaleFactor = 1;
_scalerProc = Normal1x;
_videoMode.aspectRatioCorrection = ConfMan.getBool("aspect_ratio");
_scalerType = 0;
_adjustZoomOnMouse = false;
ConfMan.setBool("FM_low_quality", true); ConfMan.setBool("FM_low_quality", true);
// enable joystick
if (joystick_num > -1 && SDL_NumJoysticks() > 0) {
_joystick = SDL_JoystickOpen(joystick_num);
}
_savefile = new DefaultSaveFileManager();
// Create and hook up the mixer, if none exists yet (we check for this to
// allow subclasses to provide their own).
if (_mixer == 0) {
setupMixer();
}
// Create and hook up the timer manager, if none exists yet (we check for
// this to allow subclasses to provide their own).
if (_timer == 0) {
// Note: We could implement a custom SDLTimerManager by using
// SDL_AddTimer. That might yield better timer resolution, but it would
// also change the semantics of a timer: Right now, ScummVM timers
// *never* run in parallel, due to the way they are implemented. If we
// switched to SDL_AddTimer, each timer might run in a separate thread.
// However, not all our code is prepared for that, so we can't just
// switch. Still, it's a potential future change to keep in mind.
_timer = new DefaultTimerManager();
_timerID = SDL_AddTimer(10, &timer_handler, _timer);
}
/* Initialise any GP2X specific stuff we may want (Batt Status, scaler etc.) */ /* Initialise any GP2X specific stuff we may want (Batt Status, scaler etc.) */
GP2X_HW::deviceInit(); GP2X_HW::deviceInit();
/* Set Default hardware mixer volume to a preset level (VOLUME_INITIAL). This is done to 'reset' volume level if set by other apps. */ /* Set Default hardware mixer volume to a preset level (VOLUME_INITIAL). This is done to 'reset' volume level if set by other apps. */
GP2X_HW::mixerMoveVolume(0); GP2X_HW::mixerMoveVolume(0);
OSystem::initBackend(); // Create the events manager
if (_eventManager == 0)
_eventManager = new GP2XSdlEventManager(this);
_inited = true; // Create the graphics manager
if (_graphicsManager == 0)
_graphicsManager = new GP2XSdlGraphicsManager();
// Call parent implementation of this method
OSystem_POSIX::initBackend();
} }
OSystem_GP2X::OSystem_GP2X() void OSystem_GP2X::initSDL() {
: // Check if SDL has not been initialized
_osdSurface(0), _osdAlpha(SDL_ALPHA_TRANSPARENT), _osdFadeStartTime(0), if (!_initedSDL) {
_hwscreen(0), _screen(0), _tmpscreen(0), uint32 sdlFlags = SDL_INIT_EVENTTHREAD;
_overlayVisible(false), if (ConfMan.hasKey("disable_sdl_parachute"))
_overlayscreen(0), _tmpscreen2(0), sdlFlags |= SDL_INIT_NOPARACHUTE;
_scalerProc(0), _modeChanged(false), _screenChangeCount(0),
_mouseVisible(false), _mouseNeedsRedraw(false), _mouseData(0), _mouseSurface(0),
_mouseOrigSurface(0), _cursorTargetScale(1), _cursorPaletteDisabled(true),
_joystick(0),
_currentShakePos(0), _newShakePos(0),
_paletteDirtyStart(0), _paletteDirtyEnd(0),
#ifdef MIXER_DOUBLE_BUFFERING
_soundMutex(0), _soundCond(0), _soundThread(0),
_soundThreadIsRunning(false), _soundThreadShouldQuit(false),
#endif
_fsFactory(0),
_savefile(0),
_mixer(0),
_timer(0),
_screenIsLocked(false),
_graphicsMutex(0), _transactionMode(kTransactionNone) {
// allocate palette storage // Initialize SDL (SDL Subsystems are initiliazed in the corresponding sdl managers)
_currentPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256); if (SDL_Init(sdlFlags) == -1)
_cursorPalette = (SDL_Color *)calloc(sizeof(SDL_Color), 256); error("Could not initialize SDL: %s", SDL_GetError());
_mouseBackup.x = _mouseBackup.y = _mouseBackup.w = _mouseBackup.h = 0; // Enable unicode support if possible
SDL_EnableUNICODE(1);
// reset mouse state _initedSDL = true;
memset(&_km, 0, sizeof(_km)); }
memset(&_mouseCurState, 0, sizeof(_mouseCurState));
_inited = false;
_fsFactory = new POSIXFilesystemFactory();
}
OSystem_GP2X::~OSystem_GP2X() {
SDL_RemoveTimer(_timerID);
closeMixer();
free(_currentPalette);
free(_cursorPalette);
free(_mouseData);
delete _savefile;
delete _timer;
}
uint32 OSystem_GP2X::getMillis() {
uint32 millis = SDL_GetTicks();
g_eventRec.processMillis(millis);
return millis;
}
void OSystem_GP2X::delayMillis(uint msecs) {
SDL_Delay(msecs);
}
void OSystem_GP2X::getTimeAndDate(TimeDate &td) const {
time_t curTime = time(0);
struct tm t = *localtime(&curTime);
td.tm_sec = t.tm_sec;
td.tm_min = t.tm_min;
td.tm_hour = t.tm_hour;
td.tm_mday = t.tm_mday;
td.tm_mon = t.tm_mon;
td.tm_year = t.tm_year;
}
Common::TimerManager *OSystem_GP2X::getTimerManager() {
assert(_timer);
return _timer;
}
Common::SaveFileManager *OSystem_GP2X::getSavefileManager() {
assert(_savefile);
return _savefile;
}
FilesystemFactory *OSystem_GP2X::getFilesystemFactory() {
assert(_fsFactory);
return _fsFactory;
} }
void OSystem_GP2X::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) { void OSystem_GP2X::addSysArchivesToSearchSet(Common::SearchSet &s, int priority) {
/* Setup default extra data paths for engine data files and plugins */ /* Setup default extra data paths for engine data files and plugins */
char workDirName[PATH_MAX+1]; char workDirName[PATH_MAX + 1];
if (getcwd(workDirName, PATH_MAX) == NULL) { if (getcwd(workDirName, PATH_MAX) == NULL) {
error("Error: Could not obtain current working directory."); error("Error: Could not obtain current working directory.");
@ -357,283 +191,14 @@ void OSystem_GP2X::addSysArchivesToSearchSet(Common::SearchSet &s, int priority)
} }
} }
static Common::String getDefaultConfigFileName() {
char configFile[MAXPATHLEN];
strcpy(configFile, DEFAULT_CONFIG_FILE);
return configFile;
}
Common::SeekableReadStream *OSystem_GP2X::createConfigReadStream() {
Common::FSNode file(getDefaultConfigFileName());
return file.createReadStream();
}
Common::WriteStream *OSystem_GP2X::createConfigWriteStream() {
Common::FSNode file(getDefaultConfigFileName());
return file.createWriteStream();
}
bool OSystem_GP2X::hasFeature(Feature f) {
return
(f == kFeatureFullscreenMode) ||
(f == kFeatureAspectRatioCorrection) ||
(f == kFeatureCursorHasPalette);
}
void OSystem_GP2X::setFeatureState(Feature f, bool enable) {
switch (f) {
case kFeatureFullscreenMode:
return;
case kFeatureAspectRatioCorrection:
setAspectRatioCorrection(enable);
break;
case kFeatureDisableKeyFiltering:
// TODO: Extend as more support for this is added to engines.
return;
default:
break;
}
}
bool OSystem_GP2X::getFeatureState(Feature f) {
assert (_transactionMode == kTransactionNone);
switch (f) {
case kFeatureFullscreenMode:
return false;
case kFeatureAspectRatioCorrection:
return _videoMode.aspectRatioCorrection;
default:
return false;
}
}
void OSystem_GP2X::quit() { void OSystem_GP2X::quit() {
unloadGFXMode();
deleteMutex(_graphicsMutex);
if (_joystick)
SDL_JoystickClose(_joystick);
GP2X_HW::deviceDeinit(); GP2X_HW::deviceDeinit();
SDL_RemoveTimer(_timerID);
closeMixer();
free(_currentPalette);
free(_cursorPalette);
free(_mouseData);
delete _timer;
SDL_ShowCursor(SDL_ENABLE);
SDL_Quit();
delete getEventManager();
delete _savefile;
#ifdef DUMP_STDOUT #ifdef DUMP_STDOUT
printf("%s\n", "Debug: STDOUT and STDERR text files closed."); printf("%s\n", "Debug: STDOUT and STDERR text files closed.");
fclose(stdout); fclose(stdout);
fclose(stderr); fclose(stderr);
#endif /* DUMP_STDOUT */ #endif /* DUMP_STDOUT */
exit(0); OSystem_POSIX::quit();
}
OSystem::MutexRef OSystem_GP2X::createMutex(void) {
return (MutexRef) SDL_CreateMutex();
}
void OSystem_GP2X::lockMutex(MutexRef mutex) {
SDL_mutexP((SDL_mutex *) mutex);
}
void OSystem_GP2X::unlockMutex(MutexRef mutex) {
SDL_mutexV((SDL_mutex *) mutex);
}
void OSystem_GP2X::deleteMutex(MutexRef mutex) {
SDL_DestroyMutex((SDL_mutex *) mutex);
}
#pragma mark -
#pragma mark --- Audio ---
#pragma mark -
#ifdef MIXER_DOUBLE_BUFFERING
void OSystem_GP2X::mixerProducerThread() {
byte nextSoundBuffer;
SDL_LockMutex(_soundMutex);
while (true) {
// Wait till we are allowed to produce data
SDL_CondWait(_soundCond, _soundMutex);
if (_soundThreadShouldQuit)
break;
// Generate samples and put them into the next buffer
nextSoundBuffer = _activeSoundBuf ^ 1;
_mixer->mixCallback(_soundBuffers[nextSoundBuffer], _soundBufSize);
// Swap buffers
_activeSoundBuf = nextSoundBuffer;
}
SDL_UnlockMutex(_soundMutex);
}
int SDLCALL OSystem_GP2X::mixerProducerThreadEntry(void *arg) {
OSystem_GP2X *this_ = (OSystem_GP2X *)arg;
assert(this_);
this_->mixerProducerThread();
return 0;
}
void OSystem_GP2X::initThreadedMixer(Audio::MixerImpl *mixer, uint bufSize) {
_soundThreadIsRunning = false;
_soundThreadShouldQuit = false;
// Create mutex and condition variable
_soundMutex = SDL_CreateMutex();
_soundCond = SDL_CreateCond();
// Create two sound buffers
_activeSoundBuf = 0;
_soundBufSize = bufSize;
_soundBuffers[0] = (byte *)calloc(1, bufSize);
_soundBuffers[1] = (byte *)calloc(1, bufSize);
_soundThreadIsRunning = true;
// Finally start the thread
_soundThread = SDL_CreateThread(mixerProducerThreadEntry, this);
}
void OSystem_GP2X::deinitThreadedMixer() {
// Kill thread?? _soundThread
if (_soundThreadIsRunning) {
// Signal the producer thread to end, and wait for it to actually finish.
_soundThreadShouldQuit = true;
SDL_CondBroadcast(_soundCond);
SDL_WaitThread(_soundThread, NULL);
// Kill the mutex & cond variables.
// Attention: AT this point, the mixer callback must not be running
// anymore, else we will crash!
SDL_DestroyMutex(_soundMutex);
SDL_DestroyCond(_soundCond);
_soundThreadIsRunning = false;
free(_soundBuffers[0]);
free(_soundBuffers[1]);
}
}
void OSystem_GP2X::mixCallback(void *arg, byte *samples, int len) {
OSystem_GP2X *this_ = (OSystem_GP2X *)arg;
assert(this_);
assert(this_->_mixer);
assert((int)this_->_soundBufSize == len);
// Lock mutex, to ensure our data is not overwritten by the producer thread
SDL_LockMutex(this_->_soundMutex);
// Copy data from the current sound buffer
memcpy(samples, this_->_soundBuffers[this_->_activeSoundBuf], len);
// Unlock mutex and wake up the produced thread
SDL_UnlockMutex(this_->_soundMutex);
SDL_CondSignal(this_->_soundCond);
}
#else
void OSystem_GP2X::mixCallback(void *sys, byte *samples, int len) {
OSystem_GP2X *this_ = (OSystem_GP2X *)sys;
assert(this_);
assert(this_->_mixer);
this_->_mixer->mixCallback(samples, len);
}
#endif
void OSystem_GP2X::setupMixer() {
SDL_AudioSpec desired;
SDL_AudioSpec obtained;
// Determine the desired output sampling frequency.
uint32 samplesPerSec = 0;
if (ConfMan.hasKey("output_rate"))
samplesPerSec = ConfMan.getInt("output_rate");
if (samplesPerSec <= 0)
samplesPerSec = SAMPLES_PER_SEC;
// Determine the sample buffer size. We want it to store enough data for
// at least 1/16th of a second (though at most 8192 samples). Note
// that it must be a power of two. So e.g. at 22050 Hz, we request a
// sample buffer size of 2048.
uint32 samples = 8192;
while (samples * 16 > samplesPerSec * 2)
samples >>= 1;
memset(&desired, 0, sizeof(desired));
desired.freq = samplesPerSec;
desired.format = AUDIO_S16SYS;
desired.channels = 2;
//desired.samples = (uint16)samples;
desired.samples = 128; // Samples hack
desired.callback = mixCallback;
desired.userdata = this;
assert(!_mixer);
if (SDL_OpenAudio(&desired, &obtained) != 0) {
warning("Could not open audio device: %s", SDL_GetError());
_mixer = new Audio::MixerImpl(this, samplesPerSec);
assert(_mixer);
_mixer->setReady(false);
} else {
// Note: This should be the obtained output rate, but it seems that at
// least on some platforms SDL will lie and claim it did get the rate
// even if it didn't. Probably only happens for "weird" rates, though.
samplesPerSec = obtained.freq;
debug(1, "Output sample rate: %d Hz", samplesPerSec);
// Create the mixer instance and start the sound processing
_mixer = new Audio::MixerImpl(this, samplesPerSec);
assert(_mixer);
_mixer->setReady(true);
#ifdef MIXER_DOUBLE_BUFFERING
initThreadedMixer(_mixer, obtained.samples * 4);
#endif
// start the sound system
SDL_PauseAudio(0);
}
}
void OSystem_GP2X::closeMixer() {
if (_mixer)
_mixer->setReady(false);
SDL_CloseAudio();
delete _mixer;
_mixer = 0;
#ifdef MIXER_DOUBLE_BUFFERING
deinitThreadedMixer();
#endif
}
Audio::Mixer *OSystem_GP2X::getMixer() {
assert(_mixer);
return _mixer;
} }

1679
backends/platform/gp2x/graphics.cpp
View file

File diff suppressed because it is too large Load diff

5
backends/platform/gp2x/module.mk
View file

@ -2,10 +2,9 @@ MODULE := backends/platform/gp2x
MODULE_OBJS := \ MODULE_OBJS := \
gp2x-hw.o \ gp2x-hw.o \
gp2x-main.o \
gp2x-mem.o \ gp2x-mem.o \
events.o \ gp2x.o
graphics.o \
gp2x.o \
MODULE_DIRS += \ MODULE_DIRS += \
backends/platform/gp2x/ backends/platform/gp2x/

4
backends/platform/gp2xwiz/gp2xwiz-sdl.cpp
View file

@ -27,7 +27,7 @@
#include "backends/platform/gp2xwiz/gp2xwiz-hw.h" #include "backends/platform/gp2xwiz/gp2xwiz-hw.h"
#include "backends/graphics/gp2xwizsdl/gp2xwizsdl-graphics.h" #include "backends/graphics/gp2xwizsdl/gp2xwizsdl-graphics.h"
#include "backends/events/gp2xwizsdl/gp2xwizsdl-events.h" #include "backends/events/gp2xsdl/gp2xsdl-events.h"
#include "backends/saves/default/default-saves.h" #include "backends/saves/default/default-saves.h"
#include "common/config-manager.h" #include "common/config-manager.h"
@ -133,7 +133,7 @@ void OSystem_GP2XWIZ::initBackend() {
// Create the events manager // Create the events manager
if (_eventManager == 0) if (_eventManager == 0)
_eventManager = new GP2XWIZSdlEventManager(this); _eventManager = new GP2XSdlEventManager(this);
// Create the graphics manager // Create the graphics manager
if (_graphicsManager == 0) if (_graphicsManager == 0)