diff options
Diffstat (limited to 'backends/platform/psp')
27 files changed, 4315 insertions, 1520 deletions
diff --git a/backends/platform/psp/Makefile b/backends/platform/psp/Makefile index f5d6a16c7e..cf1eb1611e 100644 --- a/backends/platform/psp/Makefile +++ b/backends/platform/psp/Makefile @@ -66,7 +66,7 @@ endif #CC = psp-gcc CXX = psp-g++ CXXFLAGS = -O3 -Wall -Wno-multichar -fno-exceptions -fno-rtti -DEFINES = -D__PSP__ -DNONSTANDARD_PORT -DDISABLE_TEXT_CONSOLE -DDISABLE_COMMAND_LINE -DUSE_ZLIB -DDISABLE_DOSBOX_OPL +DEFINES = -D__PSP__ -DNONSTANDARD_PORT -DDISABLE_TEXT_CONSOLE -DDISABLE_COMMAND_LINE -DUSE_ZLIB -DDISABLE_DOSBOX_OPL -DUSE_RGB_COLOR LDFLAGS := INCDIR := $(srcdir) . $(srcdir)/engines/ $(PSPSDK)/include INCLUDES := $(addprefix -I, $(INCDIR)) @@ -133,6 +133,13 @@ LIBS += -lpng -lSDL -lz $(findstring -lGL,$(SDLLIBS)) -lstdc++ -lc -lm $(fil OBJS := powerman.o \ psp_main.o \ osys_psp.o \ + psppixelformat.o \ + memory.o \ + display_manager.o \ + display_client.o \ + default_display_client.o \ + input.o \ + cursor.o \ trace.o \ psploader.o \ pspkeyboard.o diff --git a/backends/platform/psp/README.PSP.in b/backends/platform/psp/README.PSP.in index bd1ce88fb6..d9f75974f1 100644 --- a/backends/platform/psp/README.PSP.in +++ b/backends/platform/psp/README.PSP.in @@ -16,12 +16,13 @@ Left trigger - ESC Right trigger - Modifier key (see below for uses) Analog - Mouse movement Right trigger + Analog - Fine control mouse -Directionals - Mouse movement +Directions - Arrow keys +Directions + Right Trigger - Diagonal arrow keys Triangle - Enter Cross - Mouse button 1 Circle - Mouse button 2 Square - '.' (skip dialogue in some games) -Start - F5 +Start - F5 (Main Menu) Right trigger + Start - Return-To-Launcher menu Virtual Keyboard diff --git a/backends/platform/psp/cursor.cpp b/backends/platform/psp/cursor.cpp new file mode 100644 index 0000000000..b6b9a70458 --- /dev/null +++ b/backends/platform/psp/cursor.cpp @@ -0,0 +1,365 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.h $ + * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $ + * + */ + +#include "common/scummsys.h" +#include "backends/platform/psp/display_client.h" +#include "backends/platform/psp/default_display_client.h" +#include "backends/platform/psp/cursor.h" + +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ + +#include "backends/platform/psp/trace.h" + +void Cursor::init() { + DEBUG_ENTER_FUNC(); + + _renderer.setBuffer(&_buffer); // We do this explicitly + _renderer.setPalette(&_screenPalette); // because we want to choose screenpalette by default + _renderer.setUseGlobalScaler(true); + setRendererModePalettized(true); // Assume we start in 8bit mode + + // Default modes + _palette.setPixelFormats(PSPPixelFormat::Type_5551, PSPPixelFormat::Type_Palette_8bit); // default + _screenPalette.setPixelFormats(PSPPixelFormat::Type_5551, PSPPixelFormat::Type_Palette_8bit); + _buffer.setPixelFormat(PSPPixelFormat::Type_5551); + + DEBUG_EXIT_FUNC(); +} + +void Cursor::deallocate() { + DEBUG_ENTER_FUNC(); + + _buffer.deallocate(); + _palette.deallocate(); + _screenPalette.deallocate(); + + DEBUG_EXIT_FUNC(); +} + +void Cursor::setCursorPalette(const byte *colors, uint start, uint num) { + DEBUG_ENTER_FUNC(); + + if (!_palette.isAllocated()) { + _palette.allocate(); + } + + // Workaround: This is wrong, but we seem to not be getting setScreenPalette + if (!_screenPalette.isAllocated()) { + _screenPalette.allocate(); + } + + _palette.setPartial(colors, start, num); + setDirty(); + + DEBUG_EXIT_FUNC(); +} + +void Cursor::setScreenPalette(const byte *colors, uint start, uint num) { + DEBUG_ENTER_FUNC(); + + if (!_screenPalette.isAllocated()) { + _screenPalette.allocate(); + } + + _screenPalette.setPartial(colors, start, num); + setDirty(); + + DEBUG_EXIT_FUNC(); +} + +void Cursor::setKeyColor(uint32 color) { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("new color[%u], old color[%u]\n", color, _keyColor); + + // If it's a different color, undo the last keycolor + if (_buffer.hasPalette() && color != _keyColor) { + if (_screenPalette.isAllocated()) + _screenPalette.setColorPositionAlpha(_keyColor, true); + if (_palette.isAllocated()) + _palette.setColorPositionAlpha(_keyColor, true); + } + // Don't need anything special for 16-bit + _keyColor = color; + + DEBUG_EXIT_FUNC(); +} + +void Cursor::clearKeyColor() { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("keyColor[%d]\n", _keyColor); + + // We need 2 mechanisms: one for palettized and one for 16 bit + if (_buffer.hasPalette()) { + if (_screenPalette.isAllocated()) + _screenPalette.setColorPositionAlpha(_keyColor, false); // set keycolor to 0 + if (_palette.isAllocated()) + _palette.setColorPositionAlpha(_keyColor, false); + } else { // 16bit + _renderer.setKeyColor(_keyColor); + } + setDirty(); + + DEBUG_EXIT_FUNC(); +} + +void Cursor::enableCursorPalette(bool enable) { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("enable[%s]\n", enable ? "true" : "false"); + + _useCursorPalette = enable; + if (enable) + _renderer.setPalette(&_palette); // very important that we do this switch + else + _renderer.setPalette(&_screenPalette); + + setDirty(); + DEBUG_EXIT_FUNC(); +} + +inline void Cursor::setSize(uint32 width, uint32 height) { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("width[%u], height[%u]\n", width, height); + + _buffer.setSize(width, height, Buffer::kSizeByTextureSize); // we'll use texture size for mouse + _renderer.setDrawWholeBuffer(); // We need to let the renderer know how much to draw + + DEBUG_EXIT_FUNC(); +} + +void Cursor::copyFromArray(const byte *array) { + DEBUG_ENTER_FUNC(); + + if (!_buffer.isAllocated()) { + _buffer.allocate(); + } + + _buffer.copyFromArray(array, _buffer.getSourceWidthInBytes()); // pitch is source width + setDirty(); + + // debug + //PSP_DEBUG_DO(_buffer.print(0xF)); + + DEBUG_EXIT_FUNC(); + +} + +void Cursor::setHotspot(int32 x, int32 y) { + DEBUG_ENTER_FUNC(); + + _hotspotX = x; + _hotspotY = y; + updateRendererOffset(); // Important + + PSP_DEBUG_PRINT("hotspotX[%d], hotspotY[%d]\n", x, y); + DEBUG_EXIT_FUNC(); +} + +// Returns true if change in x or y +bool Cursor::increaseXY(int32 incX, int32 incY) { + DEBUG_ENTER_FUNC(); + + int32 oldX = _x, oldY = _y; + + // adjust for differences in X and Y + adjustXYForScreenSize(incX, incY); + + _x += incX; + _y += incY; + + // Clamp mouse + if (_x < 0) + _x = 0; + if (_y < 0) + _y = 0; + if (_x >= (int)_mouseLimitWidth) + _x = (int)_mouseLimitWidth - 1; + if (_y >= (int)_mouseLimitHeight) + _y = (int)_mouseLimitHeight - 1; + + PSP_DEBUG_PRINT("X[%d], Y[%d]\n", _x, _y); + + if (oldX != _x || oldY != _y) { + updateRendererOffset(); + setDirty(); + DEBUG_EXIT_FUNC(); + return true; + } + + DEBUG_EXIT_FUNC(); + return false; +} + +// Set limits on the movement of the cursor ie. screen size +void Cursor::setLimits(uint32 width, uint32 height) { + #define PSP_SCREEN_WIDTH 480 + #define PSP_SCREEN_HEIGHT 272 + DEBUG_ENTER_FUNC(); + + PSP_DEBUG_PRINT("width[%u], height[%u]\n", width, height); + _mouseLimitWidth = width; + _mouseLimitHeight = height; + + DEBUG_EXIT_FUNC(); +} + +// Adjust X,Y movement for the screen size to keep it consistent +inline void Cursor::adjustXYForScreenSize(int32 &x, int32 &y) { + DEBUG_ENTER_FUNC(); + // We have our speed calibrated for the y axis at 480x272. The idea is to adjust this for other + // resolutions and for x, which is wider. + int32 newX = x, newY = y; + + // adjust width movement to match height (usually around 1.5) + if (_mouseLimitWidth >= _mouseLimitHeight + (_mouseLimitHeight >> 1)) + newX = newX + (newX >> 1); + + if (_mouseLimitWidth >= 600) { // multiply by 2 + newX <<= 1; + newY <<= 1; + } else if (_mouseLimitWidth >= 480) { // multiply by 1.5 + newX = newX + (newX >> 1); + newY = newY + (newY >> 1); + } + + // Divide all movements by 8 + newX >>= 3; + newY >>= 3; + + // Make sure we didn't destroy minimum movement + if (!((x && !newX) || (y && !newY))) { + x = newX; + y = newY; + } + + DEBUG_EXIT_FUNC(); +} + +// This is only called when we have a new screen +void Cursor::setScreenPaletteScummvmPixelFormat(const Graphics::PixelFormat *format) { + DEBUG_ENTER_FUNC(); + + uint32 oldPaletteSize = 0; + if (_screenPalette.isAllocated()) + oldPaletteSize = _screenPalette.getSizeInBytes(); + + PSPPixelFormat::Type bufferType = PSPPixelFormat::Type_Unknown; + PSPPixelFormat::Type paletteType = PSPPixelFormat::Type_Unknown; + bool swapRedBlue = false; + + // Convert Scummvm Pixel Format to PSPPixelFormat + PSPPixelFormat::convertFromScummvmPixelFormat(format, bufferType, paletteType, swapRedBlue); + + if (paletteType == PSPPixelFormat::Type_None) { + //_screenPalette.deallocate(); // leave palette for default CLUT8 + setRendererModePalettized(false); // use 16-bit mechanism + } else { // We have a palette + _screenPalette.setPixelFormats(paletteType, bufferType); + _palette.setPixelFormats(paletteType, bufferType); + setRendererModePalettized(true); // use palettized mechanism + } + + DEBUG_EXIT_FUNC(); +} + +// This is called many many times +void Cursor::setSizeAndScummvmPixelFormat(uint32 width, uint32 height, const Graphics::PixelFormat *format) { + DEBUG_ENTER_FUNC(); + + PSP_DEBUG_PRINT("useCursorPalette[%s]\n", _useCursorPalette ? "true" : "false"); + + uint32 oldBufferSize = 0, oldPaletteSize = 0; + + if (_buffer.isAllocated()) + oldBufferSize = _buffer.getSizeInBytes(); + + if (_palette.isAllocated()) + oldPaletteSize = _palette.getSizeInBytes(); + + setSize(width, height); + + PSPPixelFormat::Type bufferType = PSPPixelFormat::Type_Unknown; + PSPPixelFormat::Type paletteType = PSPPixelFormat::Type_Unknown; + bool swapRedBlue = false; + + PSPPixelFormat::convertFromScummvmPixelFormat(format, bufferType, paletteType, swapRedBlue); + PSP_DEBUG_PRINT("bufferType[%u], paletteType[%u]\n", bufferType, paletteType); + + // Check if we need to set new pixel format + if (_buffer.getPixelFormat() != bufferType) { + PSP_DEBUG_PRINT("new buffer pixel format[%u] is different from [%u]. Setting it.\n", bufferType, _buffer.getPixelFormat()); + _buffer.setPixelFormat(bufferType); + } + + // Check if we need to reallocate + if (_buffer.getSizeInBytes() != oldBufferSize) { + _buffer.allocate(); + PSP_DEBUG_PRINT("reallocating buffer. new size: width[%u], height[%u]\n", width, height); + } + + PSP_DEBUG_PRINT("palette pixel format[%u]\n", paletteType); + + if (paletteType == PSPPixelFormat::Type_None) { + setRendererModePalettized(false); // use palettized mechanism + } else { // We have a palette + _palette.setPixelFormats(paletteType, bufferType); + setRendererModePalettized(true); // use palettized mechanism + } + + // debug + // PSP_DEBUG_DO(_palette.print(10)); + // PSP_DEBUG_DO(_screenPalette.print(10)); + + DEBUG_EXIT_FUNC(); +} + +void Cursor::setXY(int x, int y) { + DEBUG_ENTER_FUNC(); + + _x = x; + _y = y; + updateRendererOffset(); // Very important to let renderer know things changed + setDirty(); + + DEBUG_EXIT_FUNC(); +} + +inline void Cursor::updateRendererOffset() { + DEBUG_ENTER_FUNC(); + _renderer.setOffsetOnScreen(_x - _hotspotX, _y - _hotspotY); + DEBUG_EXIT_FUNC(); +} + +inline void Cursor::setRendererModePalettized(bool palettized) { + if (palettized) { // We have a palette. Use blending + _renderer.setAlphaBlending(true); + _renderer.setAlphaReverse(false); + _renderer.setColorTest(false); + } else { // 16 bits, no palette + _renderer.setAlphaBlending(true); + _renderer.setAlphaReverse(true); // We can't change all alpha values, so just reverse + _renderer.setColorTest(true); // Color test to make our key color transparent + } +} diff --git a/backends/platform/psp/cursor.h b/backends/platform/psp/cursor.h new file mode 100644 index 0000000000..49f58cd3f9 --- /dev/null +++ b/backends/platform/psp/cursor.h @@ -0,0 +1,81 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.h $ + * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $ + * + */ + +#ifndef MOUSE_H +#define MOUSE_H + +class Cursor : public DefaultDisplayClient { +private: + int _hotspotX, _hotspotY; + uint32 _keyColor; + int _cursorTargetScale; + bool _useCursorPalette; + bool _hasCursorPalette; + uint32 _mouseLimitWidth; + uint32 _mouseLimitHeight; + int32 _x, _y; + Palette _screenPalette; // separate palette for screen. default 'palette' is cursor palette. + + void updateRendererOffset(); + +public: + Cursor() : _hotspotX(0), _hotspotY(0), _keyColor(0), _cursorTargetScale(0), + _useCursorPalette(false), _hasCursorPalette(false), _mouseLimitWidth(0), + _mouseLimitHeight(0), _x(0), _y(0) { } + virtual ~Cursor() { deallocate(); } + + void setKeyColor(uint32 color); + void setCursorTargetScale(int scale) { _cursorTargetScale = scale; } + void setScreenPalette(const byte *colors, uint start, uint num); + void copyFromArray(const byte *array); + Palette &palette() { return _palette; } + Buffer &buffer() { return _buffer; } + void setCursorPalette(const byte *colors, uint start, uint num); + void enableCursorPalette(bool enable); + void setLimits(uint32 width, uint32 height); + void setXY(int x, int y); + int32 getX() { return _x; } + int32 getY() { return _y; } + bool increaseXY(int32 incX, int32 incY); // returns true if there's a change in x or y + void adjustXYForScreenSize(int32 &x, int32 &y); + void init(); + void setHotspot(int32 x, int32 y); + void setScreenPaletteScummvmPixelFormat(const Graphics::PixelFormat *format); + void setSizeAndScummvmPixelFormat(uint32 widht, uint32 height, const Graphics::PixelFormat *format); + void clearKeyColor(); + void useGlobalScaler(bool val) { _renderer.setUseGlobalScaler(val); } + bool allocate(); + void deallocate(); + +private: + void setSize(uint32 width, uint32 height); + void getPixelFormatsFromScummvmPixelFormat(const Graphics::PixelFormat *format, + PSPPixelFormat::Type &bufferFormat, + PSPPixelFormat::Type &paletteFormat, + uint32 &numOfEntries); + void setRendererModePalettized(bool palettized); +}; + +#endif /* MOUSE_H */ diff --git a/backends/platform/psp/default_display_client.cpp b/backends/platform/psp/default_display_client.cpp new file mode 100644 index 0000000000..eb20980315 --- /dev/null +++ b/backends/platform/psp/default_display_client.cpp @@ -0,0 +1,238 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.h $ + * $Id: osys_psp.h 46120 2009-11-24 10:33:30Z Bluddy $ + * + */ + +#include "common/scummsys.h" +#include "backends/platform/psp/display_client.h" +#include "backends/platform/psp/default_display_client.h" + +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ + +#include "backends/platform/psp/trace.h" + +// Class DefaultDisplayClient --------------------------------------------- + +bool DefaultDisplayClient::allocate(bool bufferInVram /* = false */, bool paletteInVram /* = false */) { + DEBUG_ENTER_FUNC(); + + if (!_buffer.allocate(bufferInVram)) { + PSP_ERROR("Couldn't allocate buffer.\n"); + DEBUG_EXIT_FUNC(); + return false; + } + + if (_buffer.hasPalette()) + { + PSP_DEBUG_PRINT("_palette[%p]\n", &_palette); + + if (!_palette.allocate()) { + PSP_ERROR("Couldn't allocate pallette.\n"); + DEBUG_EXIT_FUNC(); + return false; + } + } + + DEBUG_EXIT_FUNC(); + return true; +} + +void DefaultDisplayClient::deallocate() { + _buffer.deallocate(); + if (_buffer.hasPalette()) + _palette.deallocate(); +} + + +void DefaultDisplayClient::clearBuffer() { + DEBUG_ENTER_FUNC(); + _buffer.clear(); + setDirty(); + DEBUG_EXIT_FUNC(); +} + +inline void DefaultDisplayClient::clearPalette() { + DEBUG_ENTER_FUNC(); + _palette.clear(); + setDirty(); + DEBUG_EXIT_FUNC(); +} + +void DefaultDisplayClient::init() { + DEBUG_ENTER_FUNC(); + _renderer.setBuffer(&_buffer); + _renderer.setPalette(&_palette); + DEBUG_EXIT_FUNC(); +} + +void DefaultDisplayClient::copyFromRect(const byte *buf, int pitch, int destX, int destY, int recWidth, int recHeight) { + DEBUG_ENTER_FUNC(); + _buffer.copyFromRect(buf, pitch, destX, destY, recWidth, recHeight); + setDirty(); + DEBUG_EXIT_FUNC(); +} + +void DefaultDisplayClient::copyToArray(byte *dst, int pitch) { + DEBUG_ENTER_FUNC(); + _buffer.copyToArray(dst, pitch); + DEBUG_EXIT_FUNC(); +} + +// Class Overlay ------------------------------------------------------- + +void Overlay::init() { + DEBUG_ENTER_FUNC(); + + DefaultDisplayClient::init(); + _renderer.setAlphaBlending(true); + _renderer.setColorTest(false); + _renderer.setUseGlobalScaler(false); + _renderer.setFullScreen(true); // speeds up render slightly + + DEBUG_EXIT_FUNC(); +} + +void Overlay::setBytesPerPixel(uint32 size) { + DEBUG_ENTER_FUNC(); + + switch (size) { + case 1: + _buffer.setPixelFormat(PSPPixelFormat::Type_Palette_8bit); + _palette.setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_8bit); + break; + case 2: + _buffer.setPixelFormat(PSPPixelFormat::Type_4444); + break; + case 4: + _buffer.setPixelFormat(PSPPixelFormat::Type_8888); + break; + } + + DEBUG_EXIT_FUNC(); +} + +void Overlay::setSize(uint32 width, uint32 height) { + DEBUG_ENTER_FUNC(); + _buffer.setSize(width, height, Buffer::kSizeBySourceSize); + _renderer.setDrawWholeBuffer(); // We need to let the renderer know how much to draw + DEBUG_EXIT_FUNC(); +} + +void Overlay::copyToArray(OverlayColor *buf, int pitch) { + DEBUG_ENTER_FUNC(); + _buffer.copyToArray((byte *)buf, pitch * sizeof(OverlayColor)); // Change to bytes + DEBUG_EXIT_FUNC(); +} + +void Overlay::copyFromRect(const OverlayColor *buf, int pitch, int x, int y, int w, int h) { + DEBUG_ENTER_FUNC(); + + _buffer.copyFromRect((byte *)buf, pitch * sizeof(OverlayColor), x, y, w, h); // Change to bytes + // debug + //_buffer.print(0xFF); + setDirty(); + DEBUG_EXIT_FUNC(); +} + +bool Overlay::allocate() { + DEBUG_ENTER_FUNC(); + + bool ret = DefaultDisplayClient::allocate(true, false); // buffer in VRAM + + DEBUG_EXIT_FUNC(); + return ret; +} + +// Class Screen ----------------------------------------------------------- + +void Screen::init() { + DEBUG_ENTER_FUNC(); + + DefaultDisplayClient::init(); + _renderer.setAlphaBlending(false); + _renderer.setColorTest(false); + _renderer.setUseGlobalScaler(true); + _renderer.setFullScreen(true); + + DEBUG_EXIT_FUNC(); +} + +void Screen::setShakePos(int pos) { + _shakePos = pos; + _renderer.setOffsetOnScreen(0, pos); + setDirty(); +} + +void Screen::setSize(uint32 width, uint32 height) { + DEBUG_ENTER_FUNC(); + + _buffer.setSize(width, height, Buffer::kSizeBySourceSize); + _renderer.setDrawWholeBuffer(); // We need to let the renderer know how much to draw + + DEBUG_EXIT_FUNC(); +} + +void Screen::setScummvmPixelFormat(const Graphics::PixelFormat *format) { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("format[%p], _buffer[%p], _palette[%p]\n", format, &_buffer, &_palette); + + if (!format) { + bzero(&_pixelFormat, sizeof(_pixelFormat)); + _pixelFormat.bytesPerPixel = 1; // default + } else { + _pixelFormat = *format; + } + + PSPPixelFormat::Type bufferFormat, paletteFormat; + bool swapRedBlue = false; + + PSPPixelFormat::convertFromScummvmPixelFormat(format, bufferFormat, paletteFormat, swapRedBlue); + _buffer.setPixelFormat(bufferFormat, swapRedBlue); + _palette.setPixelFormats(paletteFormat, bufferFormat, swapRedBlue); + + DEBUG_EXIT_FUNC(); +} + +Graphics::Surface *Screen::lockAndGetForEditing() { + DEBUG_ENTER_FUNC(); + + _frameBuffer.pixels = _buffer.getPixels(); + _frameBuffer.w = _buffer.getSourceWidth(); + _frameBuffer.h = _buffer.getSourceHeight(); + _frameBuffer.pitch = _buffer.getBytesPerPixel() * _buffer.getWidth(); + _frameBuffer.bytesPerPixel = _buffer.getBytesPerPixel(); + // We'll set to dirty once we unlock the screen + + DEBUG_EXIT_FUNC(); + + return &_frameBuffer; +} + +bool Screen::allocate() { + DEBUG_ENTER_FUNC(); + + return DefaultDisplayClient::allocate(true, false); // buffer in VRAM + + DEBUG_EXIT_FUNC(); +} diff --git a/backends/platform/psp/default_display_client.h b/backends/platform/psp/default_display_client.h new file mode 100644 index 0000000000..e83b0bf04d --- /dev/null +++ b/backends/platform/psp/default_display_client.h @@ -0,0 +1,108 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/trace.h $ + * $Id: trace.h 44276 2009-09-23 16:11:23Z joostp $ + * + */ + +#ifndef PSP_DEF_DISPLAY_CLIENT_H +#define PSP_DEF_DISPLAY_CLIENT_H + +/** + * Default display client that is useful for most purposes. + */ +class DefaultDisplayClient : public DisplayClient { +public: + DefaultDisplayClient() : _visible(false), _dirty(true) {} + + bool isVisible() { return _visible; } + void setVisible(bool v) { _visible = v; setDirty(); } + Buffer &buffer() { return _buffer; } + Palette &palette() { return _palette; } + void init(); + bool allocate(bool bufferInVram = false, bool paletteInVram = false); + void deallocate(); + void clearBuffer(); + void clearPalette(); + void render() { _renderer.render(); } + uint32 getWidth() { return _buffer.getSourceWidth(); } + uint32 getHeight() { return _buffer.getSourceHeight(); } + void setPartialPalette(const byte *colors, uint start, uint num) { setDirty(); return _palette.setPartial(colors, start, num); } + void getPartialPalette(byte *colors, uint start, uint num) { + return _palette.getPartial(colors, start, num); + } + void copyFromRect(const byte *buf, int pitch, int destX, int destY, int recWidth, int recHeight); + void copyToArray(byte *dst, int pitch); + void setDirty() { _dirty = true; } + void setClean() { _dirty = false; } + bool isDirty() { return _dirty; } + +protected: + Buffer _buffer; + Palette _palette; + GuRenderer _renderer; + bool _visible; + bool _dirty; +}; + +/** + * Screen overlay class. + */ +class Overlay : public DefaultDisplayClient { +public: + Overlay() {} + ~Overlay() { } + + void init(); + bool allocate(); + void setBytesPerPixel(uint32 size); + void setSize(uint32 width, uint32 height); + void copyToArray(OverlayColor *buf, int pitch); + void copyFromRect(const OverlayColor *buf, int pitch, int x, int y, int w, int h); +}; + +/** + * Screen class. + */ +class Screen : public DefaultDisplayClient { +public: + Screen() : _shakePos(0) { + memset(&_pixelFormat, 0, sizeof(_pixelFormat)); + memset(&_frameBuffer, 0, sizeof(_frameBuffer)); + } + ~Screen() {} + + void init(); + bool allocate(); + void setShakePos(int pos); + void setScummvmPixelFormat(const Graphics::PixelFormat *format); + const Graphics::PixelFormat &getScummvmPixelFormat() const { return _pixelFormat; } + Graphics::Surface *lockAndGetForEditing(); + void unlock() { setDirty(); } // set dirty here because of changes + void setSize(uint32 width, uint32 height); + +private: + uint32 _shakePos; + Graphics::PixelFormat _pixelFormat; + Graphics::Surface _frameBuffer; +}; + +#endif /* PSP_DEF_DISPLAY_CLIENT_H */ diff --git a/backends/platform/psp/display_client.cpp b/backends/platform/psp/display_client.cpp new file mode 100644 index 0000000000..73a3fefe5b --- /dev/null +++ b/backends/platform/psp/display_client.cpp @@ -0,0 +1,805 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $ + * + */ + +#include <pspgu.h> +#include <pspdisplay.h> +#include <psputils.h> + +#include "common/scummsys.h" +#include "backends/platform/psp/display_client.h" +#include "backends/platform/psp/display_manager.h" +#include "backends/platform/psp/memory.h" + +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ +#include "backends/platform/psp/trace.h" + +#define PSP_BUFFER_WIDTH (512) +#define PSP_SCREEN_WIDTH 480 +#define PSP_SCREEN_HEIGHT 272 +#define PSP_FRAME_SIZE (PSP_BUFFER_WIDTH * PSP_SCREEN_HEIGHT) + +DisplayManager *GuRenderer::_displayManager = 0; + + +// class Palette ------------------------------------------------------------ +// +void Palette::clear() { + DEBUG_ENTER_FUNC(); + + if (_values && _numOfEntries) + memset(_values, 0, getSizeInBytes()); + + PSP_DEBUG_PRINT("_values[%p]\n", _values); + + DEBUG_EXIT_FUNC(); +} + +// Used to clear the specific keycolor +// +void Palette::setColorPositionAlpha(uint32 position, bool alpha) { + DEBUG_ENTER_FUNC(); + + assert(_values); + assert(position < _numOfEntries); + + PSP_DEBUG_PRINT("position[%d], numofEntries[%u], bpp[%u], values[%p]\n", position, _numOfEntries, + _pixelFormat.bitsPerPixel, _values); + + if (_numOfEntries <= 16) + position &= 0xF; + else if (_numOfEntries <= 256) + position &= 0xFF; + + switch (_pixelFormat.bitsPerPixel) { + case 16: { + uint16 *shortVal = (uint16 *)&_values[_pixelFormat.pixelsToBytes(position)]; + *shortVal = _pixelFormat.setColorAlpha((uint32)*shortVal, alpha ? 255 : 0); + } + break; + case 32: { + uint32 *wordVal = (uint32 *)&_values[_pixelFormat.pixelsToBytes(position)]; + *wordVal = _pixelFormat.setColorAlpha((uint32)*wordVal, alpha ? 255 : 0); + } + break; + default: + PSP_ERROR("Incorrect bits per pixel value[%u]\n", _pixelFormat.bitsPerPixel); + } + + DEBUG_EXIT_FUNC(); +} + +// Set some of the palette to color values in array +// By default, ScummVm doesn't support alpha values in palettes +void Palette::setPartial(const byte *colors, uint32 start, uint32 num, bool supportsAlpha /* = false */) { + DEBUG_ENTER_FUNC(); + + assert(_values); + assert(_numOfEntries); + + const byte *src = colors; + + if (start + num > _numOfEntries) // Check boundary + num = _numOfEntries - start; + + if (_pixelFormat.bitsPerPixel == 16) { + uint16 *palette = (uint16 *)_values; + palette += start; + + for (uint32 i = 0; i < num; ++i) { + byte alphaVal = supportsAlpha ? src[3] : 0xFF; + *palette = (uint16)_pixelFormat.rgbaToColor(src[0], src[1], src[2], alphaVal); + src += 4; + palette++; + } + } + else if (_pixelFormat.bitsPerPixel == 32) { + uint32 *palette = (uint32 *)_values; + palette += start; + + for (uint32 i = 0; i < num; ++i) { + byte alphaVal = supportsAlpha ? src[3] : 0xFF; + *palette = _pixelFormat.rgbaToColor(src[0], src[1], src[2], alphaVal); + src += 4; + palette++; + } + } + + DEBUG_EXIT_FUNC(); +} + +// Sets pixel format and number of entries by the buffer's pixel format */ +void Palette::setPixelFormats(PSPPixelFormat::Type paletteType, PSPPixelFormat::Type bufferType, bool swapRedBlue /* = false */) { + DEBUG_ENTER_FUNC(); + + if (paletteType == PSPPixelFormat::Type_Unknown) + PSP_ERROR("Unknown paletteType[%u]\n", paletteType); + + switch (bufferType) { + case PSPPixelFormat::Type_Palette_8bit: + _numOfEntries = 256; + break; + case PSPPixelFormat::Type_Palette_4bit: + _numOfEntries = 16; + break; + case PSPPixelFormat::Type_Unknown: + case PSPPixelFormat::Type_None: + PSP_ERROR("Unhandled bufferType[%u]\n", bufferType); + break; + default: // No palette + _numOfEntries = 0; + break; + } + + _pixelFormat.set(paletteType, swapRedBlue); + + DEBUG_EXIT_FUNC(); +} + +bool Palette::allocate() { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("_numOfEntries[%u]\n", _numOfEntries); + PSP_DEBUG_PRINT("_pixelFormat: format[%u], bpp[%u]\n", _pixelFormat.format, _pixelFormat.bitsPerPixel); + + if (_values) { + free (CACHED(_values)); + _values = 0; + } + + // We allocate on 64bytes to get a cache line, and round up to 64bytes to get the full line + uint32 amountInBytes = getSizeInBytes(); + if (amountInBytes < 64) + amountInBytes = 64; + _values = (byte *)memalign(64, amountInBytes); + + // Use uncached memory + GuRenderer::cacheInvalidate(_values, amountInBytes); + _values = UNCACHED(_values); + + if (!_values) { + PSP_ERROR("Couldn't allocate palette.\n"); + DEBUG_EXIT_FUNC(); + return false; + } + + PSP_DEBUG_PRINT("_values[%p]\n", _values); + clear(); + + DEBUG_EXIT_FUNC(); + return true; +} + +void Palette::deallocate() { + DEBUG_ENTER_FUNC(); + + free (CACHED(_values)); + _values = 0; + _numOfEntries = 0; + + DEBUG_EXIT_FUNC(); +} + +// Copy some of the palette to an array of colors +// +void Palette::getPartial(byte *colors, uint start, uint num) { + DEBUG_ENTER_FUNC(); + + assert(_values); + assert(_numOfEntries); + + uint32 r, g, b, a; + + if (start + num > _numOfEntries) // Check boundary + num = _numOfEntries - start; + + if (_pixelFormat.bitsPerPixel == 16) { + uint16 *palette = (uint16 *)_values; + palette += start; + + for (uint32 i = start; i < start + num; i++) { + _pixelFormat.colorToRgba(*palette, r, g, b, a); + + *colors++ = (byte)r; + *colors++ = (byte)g; + *colors++ = (byte)b; + *colors++ = (byte)a; + palette++; + } + } else if (_pixelFormat.bitsPerPixel == 32) { + uint32 *palette = (uint32 *)_values; + palette += start; + + for (uint32 i = start; i < start + num; i++) { + _pixelFormat.colorToRgba(*palette, r, g, b, a); + + *colors++ = (byte)r; + *colors++ = (byte)g; + *colors++ = (byte)b; + *colors++ = (byte)a; + palette++; + } + } + + DEBUG_EXIT_FUNC(); +} + +void Palette::setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a) { + // DEBUG_ENTER_FUNC(); + uint16 *shortValues; + uint32 *wordValues; + + assert (_values); + assert (num < _numOfEntries); + + switch (_pixelFormat.bitsPerPixel) { + case 16: + shortValues = (uint16 *)_values; + shortValues[num] = _pixelFormat.rgbaToColor(r, g, b, a); + break; + case 32: + wordValues = (uint32 *)_values; + wordValues[num] = _pixelFormat.rgbaToColor(r, g, b, a); + break; + default: + PSP_ERROR("Incorrect bitsPerPixel[%d]\n", _pixelFormat.bitsPerPixel); + break; + } + // DEBUG_EXIT_FUNC(); +} + +// Print to screen +void Palette::print(uint32 numToPrint /* = 0 */) { + if (_numOfEntries > 0) { + assert (_values); + + if (numToPrint > _numOfEntries || numToPrint == 0) + numToPrint = _numOfEntries; + + PSP_INFO_PRINT("cursor palette:\n"); + + for (unsigned int i=0; i<numToPrint; i++) { + byte *pcolor = &_values[_pixelFormat.pixelsToBytes(i)]; + uint32 color = _pixelFormat.getColorValueAt(pcolor); + + PSP_INFO_PRINT("[%u=%x] ", i, color); + } + + PSP_INFO_PRINT("\n"); + } +} + +uint32 Palette::getRawColorAt(uint32 position) { + byte *pcolor = &_values[_pixelFormat.pixelsToBytes(position)]; + uint32 color = _pixelFormat.getColorValueAt(pcolor); + return color; +} + +uint32 Palette::getRGBAColorAt(uint32 position) { + uint32 color = getRawColorAt(position); + uint32 r, g, b, a; + _pixelFormat.colorToRgba(color, r, g, b, a); + return (a << 24 | b << 16 | g << 8 | r); +} + +// class Buffer --------------------------------------------------- + +void Buffer::setPixelFormat(PSPPixelFormat::Type type, bool swapRedBlue) { + if (type == PSPPixelFormat::Type_None || + type == PSPPixelFormat::Type_Unknown) + PSP_ERROR("Unhandled buffer format[%u]\n", type); + + _pixelFormat.set(type, swapRedBlue); +} + +bool Buffer::hasPalette() { + if (_pixelFormat.format == PSPPixelFormat::Type_Palette_8bit || + _pixelFormat.format == PSPPixelFormat::Type_Palette_4bit) + return true; + + return false; +} + +/* pitch is in bytes */ +void Buffer::copyFromArray(const byte *buffer, int pitch) { + DEBUG_ENTER_FUNC(); + + // We use sourceSize because outside, they won't know what the true size is + copyFromRect(buffer, pitch, 0, 0, _sourceSize.width, _sourceSize.height); + + DEBUG_EXIT_FUNC(); +} + +/* pitch is in bytes */ +void Buffer::copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, uint32 recWidth, uint32 recHeight) { + // Removed silly clipping code + DEBUG_ENTER_FUNC(); + assert (_pixels); + + if (recWidth > _sourceSize.width - destX) { + recWidth = _sourceSize.width - destX; + } + + if (recHeight > _sourceSize.height - destY) { + recHeight = _sourceSize.height - destY; + } + + if (recWidth <= 0 || recHeight <= 0) { + DEBUG_EXIT_FUNC(); + return; + } + + byte *dst = _pixels + _pixelFormat.pixelsToBytes((destY * _width) + destX); + + uint32 recWidthInBytes = _pixelFormat.pixelsToBytes(recWidth); + uint32 realWidthInBytes = _pixelFormat.pixelsToBytes(_width); + + if (pitch == realWidthInBytes && pitch == recWidthInBytes) { + //memcpy(dst, buf, _pixelFormat.pixelsToBytes(recHeight * recWidth)); + Copier::copy(dst, buf, _pixelFormat.pixelsToBytes(recHeight * recWidth), &_pixelFormat); + } else { + do { + //memcpy(dst, buf, recWidthInBytes); + Copier::copy(dst, buf, recWidthInBytes, &_pixelFormat); + buf += pitch; + dst += realWidthInBytes; + } while (--recHeight); + } + + DEBUG_EXIT_FUNC(); +} + +/* pitch is in bytes */ +void Buffer::copyToArray(byte *dst, int pitch) { + DEBUG_ENTER_FUNC(); + assert (_pixels); + + uint32 h = _height; + byte *src = _pixels; + uint32 sourceWidthInBytes = _pixelFormat.pixelsToBytes(_sourceSize.width); + uint32 realWidthInBytes = _pixelFormat.pixelsToBytes(_width); + + do { + //memcpy(dst, src, sourceWidthInBytes); + Copier::copy(dst, src, sourceWidthInBytes, &_pixelFormat); + src += realWidthInBytes; + dst += pitch; + } while (--h); + + DEBUG_EXIT_FUNC(); +} + +/* We can size the buffer either by texture size (multiple of 2^n) or source size. The GU can + really handle both, but is supposed to get only 2^n size buffers */ +void Buffer::setSize(uint32 width, uint32 height, HowToSize textureOrSource/*=kSizeByTextureSize*/) { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("w[%u], h[%u], %s\n", width, height, textureOrSource ? "size by source" : "size by texture"); + + _sourceSize.width = width; + _sourceSize.height = height; + + _textureSize.width = scaleUpToPowerOfTwo(width); + _textureSize.height = scaleUpToPowerOfTwo(height); + + if (textureOrSource == kSizeByTextureSize) { + _width = _textureSize.width; + _height = _textureSize.height; + } + else { /* kSizeBySourceSize */ + _width = _sourceSize.width; + _height = _sourceSize.height; + } + + DEBUG_EXIT_FUNC(); +} + +/* Scale a dimension (width/height) up to power of 2 for the texture */ +uint32 Buffer::scaleUpToPowerOfTwo(uint32 size) { + + uint32 textureDimension = 0; + if (size <= 16) + textureDimension = 16; + else if (size <= 32) + textureDimension = 32; + else if (size <= 64) + textureDimension = 64; + else if (size <= 128) + textureDimension = 128; + else if (size <= 256) + textureDimension = 256; + else + textureDimension = 512; + + PSP_DEBUG_PRINT("power of 2 = %u\n", textureDimension); + + return textureDimension; +} + +bool Buffer::allocate(bool inVram/*=false*/) { + DEBUG_ENTER_FUNC(); + + PSP_DEBUG_PRINT("_width[%u], _height[%u]\n", _width, _height); + PSP_DEBUG_PRINT("_pixelFormat: format[%u], bpp[%u]\n", _pixelFormat.format, _pixelFormat.bitsPerPixel); + + if (_pixels) { + if (VramAllocator::isAddressInVram(_pixels)) // Check if in VRAM + VramAllocator::instance().deallocate(_pixels); + else // not in VRAM + free (CACHED(_pixels)); + + _pixels = 0; + } + + uint32 size = getSizeInBytes(); + + if (inVram) { + _pixels = (byte *)VramAllocator::instance().allocate(size); + } + + if (!_pixels) { // Either we are not in vram or we didn't manage to allocate in vram + // Align to 64 bytes. All normal buffer sizes are multiples of 64 anyway + _pixels = (byte *)memalign(64, size); + } + + if (!_pixels) { + PSP_ERROR("couldn't allocate buffer.\n"); + DEBUG_EXIT_FUNC(); + return false; + } + + // Use uncached memory + GuRenderer::cacheInvalidate(_pixels, size); + _pixels = UNCACHED(_pixels); + + clear(); + DEBUG_EXIT_FUNC(); + return true; +} + +void Buffer::deallocate() { + DEBUG_ENTER_FUNC(); + + if (!_pixels) + return; + + if (VramAllocator::isAddressInVram(_pixels)) // Check if in VRAM + VramAllocator::instance().deallocate(_pixels); + else + free(CACHED(_pixels)); + + _pixels = 0; + + DEBUG_EXIT_FUNC(); +} + +void Buffer::clear() { + DEBUG_ENTER_FUNC(); + + if (_pixels) + memset(_pixels, 0, getSizeInBytes()); + + DEBUG_EXIT_FUNC(); +} + +/* Convert 4 bit images to match weird PSP format */ +void Buffer::flipNibbles() { + DEBUG_ENTER_FUNC(); + + if (_pixelFormat.bitsPerPixel != 4) + return; + + assert(_pixels); + + uint32 *dest = (uint32 *)_pixels; + + for (uint32 i = 0; i < getSourceHeight(); i++) { + for (uint32 j = 0; j < (getWidth() >> 3); j++) { // /8 because we do it in 32bit chunks + uint32 val = *dest; + *dest++ = ((val >> 4) & 0x0F0F0F0F) | ((val << 4) & 0xF0F0F0F0); + } + } + + DEBUG_EXIT_FUNC(); +} + +// Print buffer contents to screen (only source size is printed out) +void Buffer::print(uint32 mask, uint32 numToPrint /*=0*/) { + assert(_pixels); + + if (numToPrint > _sourceSize.width * _sourceSize.height || numToPrint == 0) + numToPrint = _sourceSize.width * _sourceSize.height; + + PSP_INFO_PRINT("buffer: \n"); + PSP_INFO_PRINT("width[%u], height[%u]\n\n", _sourceSize.width, _sourceSize.height); + + for (unsigned int i=0; i < _sourceSize.height; i++) { + for (unsigned int j=0; j < _sourceSize.width; j++) { + if (numToPrint <= 0) // check if done + break; + + byte *pcolor = &_pixels[_pixelFormat.pixelsToBytes((i * _width) + j)]; + uint32 color = _pixelFormat.getColorValueAt(pcolor); + + //if (color != 0) PSP_INFO_PRINT("[%x] ", color); + PSP_INFO_PRINT("[%x] ", mask & color); + + numToPrint--; + } + PSP_INFO_PRINT("\n"); + } + PSP_INFO_PRINT("\n"); +} + +// class GuRenderer ------------------------------------------------- +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ + +#include "backends/platform/psp/trace.h" + + +void GuRenderer::render() { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("Buffer[%p] Palette[%p]\n", _buffer->getPixels(), _palette->getRawValues()); + + setMaxTextureOffsetByIndex(0, 0); + + guProgramDrawBehavior(); + + if (_buffer->hasPalette()) + guLoadPalette(); + + guProgramTextureFormat(); + guLoadTexture(); + + Vertex *vertices = guGetVertices(); + fillVertices(vertices); + + guDrawVertices(vertices); + + if (_buffer->getSourceWidth() > 512) { + setMaxTextureOffsetByIndex(1, 0); + + guLoadTexture(); + + vertices = guGetVertices(); + fillVertices(vertices); + + guDrawVertices(vertices); + } + + DEBUG_EXIT_FUNC(); +} + +inline void GuRenderer::setMaxTextureOffsetByIndex(uint32 x, uint32 y) { + DEBUG_ENTER_FUNC(); + const uint32 maxTextureSizeShift = 9; /* corresponds to 512 = max texture size*/ + + _maxTextureOffset.x = x << maxTextureSizeShift; /* x times 512 */ + _maxTextureOffset.y = y << maxTextureSizeShift; /* y times 512 */ + DEBUG_EXIT_FUNC(); +} + +inline void GuRenderer::guProgramDrawBehavior() { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("blending[%s] colorTest[%s] reverseAlpha[%s] keyColor[%u]\n", _blending ? "on" : "off", _colorTest ? "on" : "off", _alphaReverse ? "on" : "off", _keyColor); + + if (_blending) { + sceGuEnable(GU_BLEND); + + if (_alphaReverse) // Reverse the alpha value (0 is 1) + sceGuBlendFunc(GU_ADD, GU_ONE_MINUS_SRC_ALPHA, GU_SRC_ALPHA, 0, 0); + else // Normal alpha values + sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); + + } else + sceGuDisable(GU_BLEND); + + if (_colorTest) { + sceGuEnable(GU_COLOR_TEST); + sceGuColorFunc(GU_NOTEQUAL, _keyColor, 0x00ffffff); + } else + sceGuDisable(GU_COLOR_TEST); + + DEBUG_EXIT_FUNC(); +} + +inline void GuRenderer::guLoadPalette() { + DEBUG_ENTER_FUNC(); + + uint32 mask; + + if (_buffer->getBitsPerPixel() == 4) + mask = 0x0F; + else if (_buffer->getBitsPerPixel() == 8) + mask = 0xFF; + else + assert(0); /* error */ + + PSP_DEBUG_PRINT("numOfEntries[%d]\n", _palette->getNumOfEntries()); + PSP_DEBUG_PRINT("bpp[%d], pixelformat[%d], mask[%x]\n", _buffer->getBitsPerPixel(), _palette->getPixelFormat(), mask); + + sceGuClutMode(convertToGuPixelFormat(_palette->getPixelFormat()), 0, mask, 0); + sceGuClutLoad(_palette->getNumOfEntries() >> 3, _palette->getRawValues()); + + DEBUG_EXIT_FUNC(); +} + +inline void GuRenderer::guProgramTextureFormat() { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("pixelFormat[%d]\n", _buffer->getPixelFormat()); + + sceGuTexMode(convertToGuPixelFormat(_buffer->getPixelFormat()), 0, 0, 0); + DEBUG_EXIT_FUNC(); +} + +inline uint32 GuRenderer::convertToGuPixelFormat(PSPPixelFormat::Type format) { + DEBUG_ENTER_FUNC(); + + uint32 guFormat = 0; + + switch (format) { + case PSPPixelFormat::Type_4444: + guFormat = GU_PSM_4444; + break; + case PSPPixelFormat::Type_5551: + guFormat = GU_PSM_5551; + break; + case PSPPixelFormat::Type_5650: + guFormat = GU_PSM_5650; + break; + case PSPPixelFormat::Type_8888: + guFormat = GU_PSM_8888; + break; + case PSPPixelFormat::Type_Palette_8bit: + guFormat = GU_PSM_T8; + break; + case PSPPixelFormat::Type_Palette_4bit: + guFormat = GU_PSM_T4; + break; + default: + break; + } + + PSP_DEBUG_PRINT("Pixelformat[%d], guFormat[%d]\n", format, guFormat); + + DEBUG_EXIT_FUNC(); + return guFormat; + +} + +inline void GuRenderer::guLoadTexture() { + DEBUG_ENTER_FUNC(); + + sceGuTexImage(0, _buffer->getTextureWidth(), _buffer->getTextureHeight(), _buffer->getWidth(), _buffer->getPixels() + _buffer->_pixelFormat.pixelsToBytes(_maxTextureOffset.x)); + + DEBUG_EXIT_FUNC(); +} + +inline Vertex *GuRenderer::guGetVertices() { + DEBUG_ENTER_FUNC(); + + Vertex *ret = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex)); + + DEBUG_EXIT_FUNC(); + return ret; +} + +// Fills the vertices. Most of the logic is here. +void GuRenderer::fillVertices(Vertex *vertices) { + DEBUG_ENTER_FUNC(); + + uint32 outputWidth = _displayManager->getOutputWidth(); + uint32 outputHeight = _displayManager->getOutputHeight(); + + float textureStartX, textureStartY, textureEndX, textureEndY; + + // Texture adjustments for eliminating half-pixel artifacts from scaling + // Not necessary if we don't scale + float textureAdjustment = 0.0f; + if (_useGlobalScaler && + (_displayManager->getScaleX() != 1.0f || _displayManager->getScaleX() != 1.0f)) + textureAdjustment = 0.5f; + + textureStartX = textureAdjustment + _offsetInBuffer.x; //debug + textureStartY = textureAdjustment + _offsetInBuffer.y; + // We subtract maxTextureOffset because our shifted texture starts at 512 and will go to 640 + textureEndX = _offsetInBuffer.x + _drawSize.width - textureAdjustment - _maxTextureOffset.x; + textureEndY = _offsetInBuffer.y + _drawSize.height - textureAdjustment; + + // For scaling to the final image size, calculate the gaps on both sides + uint32 gapX = _useGlobalScaler ? (PSP_SCREEN_WIDTH - outputWidth) >> 1 : 0; + uint32 gapY = _useGlobalScaler ? (PSP_SCREEN_HEIGHT - outputHeight) >> 1 : 0; + + float imageStartX, imageStartY, imageEndX, imageEndY; + + imageStartX = gapX + ( scaleSourceToOutputX(_maxTextureOffset.x) ); + imageStartY = gapY; + + imageStartX += scaleSourceToOutputX(_offsetOnScreen.x); + imageStartY += scaleSourceToOutputY(_offsetOnScreen.y); + + if (_fullScreen) { // shortcut + imageEndX = PSP_SCREEN_WIDTH - gapX; + imageEndY = PSP_SCREEN_HEIGHT - gapY; + } else { /* !fullScreen */ + imageEndX = imageStartX + scaleSourceToOutputX(_drawSize.width); + imageEndY = imageStartY + scaleSourceToOutputY(_drawSize.height); + } + + vertices[0].u = textureStartX; + vertices[0].v = textureStartY; + vertices[1].u = textureEndX; + vertices[1].v = textureEndY; + + vertices[0].x = imageStartX; + vertices[0].y = imageStartY; + vertices[0].z = 0; + vertices[1].x = imageEndX; + vertices[1].y = imageEndY; + vertices[1].z = 0; + + PSP_DEBUG_PRINT("TextureStart: X[%f] Y[%f] TextureEnd: X[%.1f] Y[%.1f]\n", textureStartX, textureStartY, textureEndX, textureEndY); + PSP_DEBUG_PRINT("ImageStart: X[%f] Y[%f] ImageEnd: X[%.1f] Y[%.1f]\n", imageStartX, imageStartY, imageEndX, imageEndY); + + DEBUG_EXIT_FUNC(); +} + +/* Scale the input X offset to appear in proper position on the screen */ +inline float GuRenderer::scaleSourceToOutputX(float offset) { + float result; + + if (!_useGlobalScaler) + result = offset; + else if (!offset) + result = 0.0f; + else + result = offset * _displayManager->getScaleX(); + + return result; +} + +/* Scale the input Y offset to appear in proper position on the screen */ +inline float GuRenderer::scaleSourceToOutputY(float offset) { + float result; + + if (!_useGlobalScaler) + result = offset; + else if (!offset) + result = 0.0f; + else + result = offset * _displayManager->getScaleY(); + + return result; +} + +inline void GuRenderer::guDrawVertices(Vertex *vertices) { + DEBUG_ENTER_FUNC(); + + sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertices); + DEBUG_EXIT_FUNC(); +} + +void GuRenderer::cacheInvalidate(void *pointer, uint32 size) { + sceKernelDcacheWritebackInvalidateRange(pointer, size); +} diff --git a/backends/platform/psp/display_client.h b/backends/platform/psp/display_client.h new file mode 100644 index 0000000000..d96504ad04 --- /dev/null +++ b/backends/platform/psp/display_client.h @@ -0,0 +1,238 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $ + * + */ + +#ifndef PSP_GRAPHICS_H +#define PSP_GRAPHICS_H + +#include "common/singleton.h" +#include "graphics/surface.h" +#include "common/system.h" +#include "backends/platform/psp/psppixelformat.h" +#include "backends/platform/psp/memory.h" + +#define MAX_TEXTURE_SIZE 512 + +class DisplayManager; +class GuRenderer; + +/** + * Interface to inherit for all display clients + * We deliberately avoid virtual functions for speed. + */ +class DisplayClient { // Abstract class +public: + DisplayClient() {} + bool isVisible() { return true; } + bool isDirty() { return true; } + void setClean() {} + void render() {} + virtual ~DisplayClient() {} +}; + +/** + * Vertex used for GU rendering + */ +struct Vertex { + float u,v; + float x,y,z; +}; + +struct Point { + int x; + int y; + Point() : x(0), y(0) {} +}; + +/** + * Dimensions struct for simplification + */ +struct Dimensions { + uint32 width; + uint32 height; + Dimensions() : width(0), height(0) {} +}; + +/** + * Universal PSP Palette class + * Use this in any class that wishes to draw to the PSP screen. + * Use together with GuRenderer + */ +class Palette { +public: + Palette() : _values(0), _numOfEntries(0) {} + virtual ~Palette() { deallocate(); } + bool allocate(); + void deallocate(); + void clear(); + void setPixelFormats(PSPPixelFormat::Type paletteType, PSPPixelFormat::Type bufferType, bool swapRedBlue = false); + void setNumOfEntries(uint32 num) { _numOfEntries = num; } + uint32 getNumOfEntries() { return _numOfEntries; } + uint32 getSizeInBytes() { return _pixelFormat.pixelsToBytes(_numOfEntries); } + void set(byte *values) { setPartial(values, 0, _numOfEntries); } + void setPartial(const byte *colors, uint start, uint num, bool supportsAlpha = false); + void getPartial(byte *colors, uint start, uint num); + uint32 getRawColorAt(uint32 position); + uint32 getRGBAColorAt(uint32 position); + void setSingleColorRGBA(uint32 num, byte r, byte g, byte b, byte a); + void setColorPositionAlpha(uint32 position, bool alpha); + byte *getRawValues() { return _values; } + bool isAllocated() { return (_values != 0); } + PSPPixelFormat::Type getPixelFormat() { return _pixelFormat.format; } + void print(uint32 numToPrint = 0); // print to screen + +protected: + byte *_values; ///< array of palette data + uint32 _numOfEntries; ///< number of palette entries + PSPPixelFormat _pixelFormat; ///< pixel format of the palette data +}; + +/** + * Universal PSP buffer/texture object + * Use this in any class that wishes to draw to the PSP screen. + * Use together with GuRenderer + */ +class Buffer { +public: + enum HowToSize { + kSizeByTextureSize, // buffer size is determined by power of 2 roundup for texture + kSizeBySourceSize // buffer size is determined by source size + }; + + Buffer() : _pixels(0), _width(0), _height(0) {} + virtual ~Buffer() { deallocate(); } + + // setters + void setSize(uint32 width, uint32 height, HowToSize textureOrSource=kSizeByTextureSize); + void setBitsPerPixel(uint32 bits) { _pixelFormat.bitsPerPixel = bits; } + void setBytesPerPixel(uint32 bytes) { setBitsPerPixel(bytes << 3); } + void setPixelFormat(PSPPixelFormat::Type type, bool swapRedBlue = false); + + // getters + uint32 getWidth() { return _width; } + uint32 getWidthInBytes() { return _pixelFormat.pixelsToBytes(getWidth()); } + uint32 getHeight() { return _height; } + uint32 getSourceWidth() { return _sourceSize.width; } + uint32 getSourceWidthInBytes() { return _pixelFormat.pixelsToBytes(_sourceSize.width); } + uint32 getSourceHeight() { return _sourceSize.height; } + uint32 getTextureWidth() { return _textureSize.width; } + uint32 getTextureHeight() { return _textureSize.height; } + PSPPixelFormat::Type getPixelFormat() { return _pixelFormat.format; } + uint32 getBitsPerPixel() { return _pixelFormat.bitsPerPixel; } + uint32 getBytesPerPixel() { return getBitsPerPixel() >> 3; } /* won't work for 4-bit */ + byte *getPixels() { return _pixels; } + uint32 getSizeInBytes() { return _pixelFormat.pixelsToBytes(_width * _height); } + + bool hasPalette(); + void copyFromArray(const byte *buffer, int pitch); + void copyFromRect(const byte *buf, uint32 pitch, int destX, int destY, uint32 recWidth, uint32 recHeight); + void copyToArray(byte *dst, int pitch); + bool allocate(bool inVram = false); + void deallocate(); + bool isAllocated() { return (_pixels != 0) ; } + void clear(); + void flipNibbles(); // To handle peculiarities of PSP's 4 bit textures + static uint32 scaleUpToPowerOfTwo(uint32 size); + void print(uint32 mask, uint32 numToPrint = 0); + +protected: + friend class GuRenderer; + byte *_pixels; + uint32 _width; ///< True allocated width + uint32 _height; ///< True allocated height + Dimensions _textureSize; ///< Size rounded up to power of 2. Used for drawing + Dimensions _sourceSize; ///< Original size of the buffer + PSPPixelFormat _pixelFormat; ///< Format of the buffer +}; + +/** + * Universal rendering class for PSP + * Use this if you want to draw to the screen. + * Needs to be supplied with a Buffer and a Palette + */ +class GuRenderer { +public: + // Constructors + GuRenderer() : _useGlobalScaler(false), _buffer(0), _palette(0), _blending(false), _alphaReverse(false), _colorTest(false), _keyColor(0), _fullScreen(false) {} + GuRenderer(Buffer *buffer, Palette *palette) : _useGlobalScaler(false), _buffer(buffer), _palette(palette), _blending(false), _alphaReverse(false), _colorTest(false), _keyColor(0), _fullScreen(false) {} + static void setDisplayManager(DisplayManager *dm) { _displayManager = dm; } // Called by the Display Manager + + // Setters + void setDrawSize(uint32 width, uint32 height) { // How big of an area to draw + _drawSize.width = width; + _drawSize.height = height; + } + void setDrawWholeBuffer() { // Draw the full size of the current buffer + assert(_buffer); + _drawSize.width = _buffer->getSourceWidth(); + _drawSize.height = _buffer->getSourceHeight(); + } + void setBuffer(Buffer *buffer) { _buffer = buffer; } + void setPalette(Palette *palette) { _palette = palette; } + void setMaxTextureOffsetByIndex(uint32 x, uint32 y); // For drawing multiple textures + void setOffsetOnScreen(uint32 x, uint32 y) { _offsetOnScreen.x = x; _offsetOnScreen.y = y; } + void setOffsetInBuffer(uint32 x, uint32 y) { _offsetInBuffer.x = x; _offsetInBuffer.y = y; } + void setColorTest(bool value) { _colorTest = value; } + void setKeyColor(uint32 value) { _keyColor = _buffer->_pixelFormat.convertTo32BitColor(value); } + void setAlphaBlending(bool value) { _blending = value; } + void setAlphaReverse(bool value) { _alphaReverse = value; } + void setFullScreen(bool value) { _fullScreen = value; } // Shortcut for rendering + void setUseGlobalScaler(bool value) { _useGlobalScaler = value; } // Scale to screen + + static void cacheInvalidate(void *pointer, uint32 size); + + void render(); // Default rendering function. This should be good enough for most purposes + +protected: + // Gu functions + void fillVertices(Vertex *vertices); // Fill in vertices with coordinates + void guProgramDrawBehavior(); + Vertex *guGetVertices(); + void guLoadTexture(); + void guLoadPalette(); + void guProgramTextureFormat(); + void guProgramTextureBitDepth(); + void guDrawVertices(Vertex *vertices); + + uint32 convertToGuPixelFormat(PSPPixelFormat::Type format); + float scaleSourceToOutputX(float offset); + float scaleSourceToOutputY(float offset); + + friend class MasterGuRenderer; + Point _maxTextureOffset; ///> For rendering textures > 512 pixels + Point _offsetOnScreen; ///> Where on screen to draw + Point _offsetInBuffer; ///> Where in the texture to draw + bool _useGlobalScaler; ///> Scale to the output size on screen + Buffer *_buffer; + Palette *_palette; + static DisplayManager *_displayManager; + Dimensions _drawSize; ///> Actual size to draw out of the Buffer + bool _blending; + bool _alphaReverse; ///> 0 counts as full alpha + bool _colorTest; + uint32 _keyColor; ///> Color to test against for color test. in 32 bits. + bool _fullScreen; ///> Speeds up for fullscreen rendering +}; + +#endif /* PSP_SCREEN_H */ diff --git a/backends/platform/psp/display_manager.cpp b/backends/platform/psp/display_manager.cpp new file mode 100644 index 0000000000..a556a6e65f --- /dev/null +++ b/backends/platform/psp/display_manager.cpp @@ -0,0 +1,336 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 47541 2010-01-25 01:39:44Z lordhoto $ + * + */ + +//#define __PSP_DEBUG_FUNCS__ /* For debugging function calls */ +//#define __PSP_DEBUG_PRINT__ /* For debug printouts */ + +//#define ENABLE_RENDER_MEASURE + +#include "backends/platform/psp/trace.h" + +#include <pspgu.h> +#include <pspdisplay.h> + +#include "common/scummsys.h" +#include "backends/base-backend.h" +#include "backends/platform/psp/display_client.h" +#include "backends/platform/psp/default_display_client.h" +#include "backends/platform/psp/cursor.h" +#include "backends/platform/psp/pspkeyboard.h" +#include "backends/platform/psp/display_manager.h" + +#define PSP_BUFFER_WIDTH (512) +#define PSP_SCREEN_WIDTH 480 +#define PSP_SCREEN_HEIGHT 272 +#define PSP_FRAME_SIZE (PSP_BUFFER_WIDTH * PSP_SCREEN_HEIGHT) + +uint32 __attribute__((aligned(16))) MasterGuRenderer::_displayList[2048]; + + const OSystem::GraphicsMode DisplayManager::_supportedModes[] = { + { "320x200 (centered)", "320x200 16-bit centered", CENTERED_320X200 }, + { "435x272 (best-fit, centered)", "435x272 16-bit centered", CENTERED_435X272 }, + { "480x272 (full screen)", "480x272 16-bit stretched", STRETCHED_480X272 }, + { "362x272 (4:3, centered)", "362x272 16-bit centered", CENTERED_362X272 }, + {0, 0, 0} +}; + + +// Class MasterGuRenderer ---------------------------------------------- + +void MasterGuRenderer::guInit() { + DEBUG_ENTER_FUNC(); + + sceGuInit(); + sceGuStart(0, _displayList); + + guProgramDisplayBufferSizes(); + + sceGuOffset(2048 - (PSP_SCREEN_WIDTH/2), 2048 - (PSP_SCREEN_HEIGHT/2)); + sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); + sceGuDepthRange(0xC350, 0x2710); + sceGuDisable(GU_DEPTH_TEST); // We'll use depth buffer area + sceGuDepthMask(GU_TRUE); // Prevent writes to depth buffer + sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); + sceGuEnable(GU_SCISSOR_TEST); + sceGuFrontFace(GU_CW); + sceGuEnable(GU_TEXTURE_2D); + + sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); + sceGuFinish(); + sceGuSync(0,0); + + sceDisplayWaitVblankStart(); + sceGuDisplay(1); + + DEBUG_EXIT_FUNC(); +} + +void MasterGuRenderer::guProgramDisplayBufferSizes() { + DEBUG_ENTER_FUNC(); + + PSP_DEBUG_PRINT("Outputbits[%u]\n", GuRenderer::_displayManager->getOutputBitsPerPixel()); + + switch (GuRenderer::_displayManager->getOutputBitsPerPixel()) { + case 16: + sceGuDrawBuffer(GU_PSM_4444, (void *)0, PSP_BUFFER_WIDTH); + sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, (void*)(PSP_FRAME_SIZE * sizeof(uint16)), PSP_BUFFER_WIDTH); + sceGuDepthBuffer((void*)(PSP_FRAME_SIZE * sizeof(uint16) * 2), PSP_BUFFER_WIDTH); + VramAllocator::instance().allocate(PSP_FRAME_SIZE * sizeof(uint16) * 2); + break; + case 32: + sceGuDrawBuffer(GU_PSM_8888, (void *)0, PSP_BUFFER_WIDTH); + sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, (void*)(PSP_FRAME_SIZE * sizeof(uint32)), PSP_BUFFER_WIDTH); + sceGuDepthBuffer((void*)(PSP_FRAME_SIZE * sizeof(uint32) * 2), PSP_BUFFER_WIDTH); + VramAllocator::instance().allocate(PSP_FRAME_SIZE * sizeof(uint32) * 2); + break; + } + + DEBUG_EXIT_FUNC(); +} + +// These are GU commands that should always stay the same +inline void MasterGuRenderer::guPreRender() { + DEBUG_ENTER_FUNC(); + +#ifdef ENABLE_RENDER_MEASURE + _lastRenderTime = g_system->getMillis(); +#endif /* ENABLE_RENDER_MEASURE */ + + sceGuStart(0, _displayList); + + sceGuClearColor(0xFF000000); + sceGuClear(GU_COLOR_BUFFER_BIT); + + sceGuAmbientColor(0xFFFFFFFF); + sceGuColor(0xFFFFFFFF); + sceGuTexOffset(0,0); + sceGuTexFilter(GU_LINEAR, GU_LINEAR); + + sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA); // Also good enough for all purposes + sceGuAlphaFunc(GU_GREATER, 0, 0xFF); // Also good enough for all purposes + + DEBUG_EXIT_FUNC(); +} + +inline void MasterGuRenderer::guPostRender() { + DEBUG_ENTER_FUNC(); + + sceGuFinish(); + sceGuSync(0,0); + +#ifdef ENABLE_RENDER_MEASURE + uint32 now = g_system->getMillis(); + PSP_INFO_PRINT("Render took %d milliseconds\n", now - _lastRenderTime); +#endif /* ENABLE_RENDER_MEASURE */ + + sceDisplayWaitVblankStart(); + sceGuSwapBuffers(); + + DEBUG_EXIT_FUNC(); +} + +void MasterGuRenderer::guShutDown() { + sceGuTerm(); +} + + +// Class DisplayManager ----------------------------------------------------- + +DisplayManager::~DisplayManager() { + _masterGuRenderer.guShutDown(); +} + +void DisplayManager::init() { + DEBUG_ENTER_FUNC(); + + _displayParams.outputBitsPerPixel = 32; // can be changed to produce 16-bit output + + GuRenderer::setDisplayManager(this); + _screen->init(); + _overlay->init(); + _cursor->init(); + + _masterGuRenderer.guInit(); // start up the renderer + + DEBUG_EXIT_FUNC(); +} + +void DisplayManager::setSizeAndPixelFormat(uint width, uint height, const Graphics::PixelFormat *format) { + + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("w[%u], h[%u], pformat[%p]\n", width, height, format); + + _overlay->deallocate(); + _screen->deallocate(); + + _screen->setScummvmPixelFormat(format); + _screen->setSize(width, height); + _screen->allocate(); + + _cursor->setScreenPaletteScummvmPixelFormat(format); + + _overlay->setBytesPerPixel(sizeof(OverlayColor)); + _overlay->setSize(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); + _overlay->allocate(); + + _displayParams.screenSource.width = width; + _displayParams.screenSource.height = height; + calculateScaleParams(); + + DEBUG_EXIT_FUNC(); +} + +bool DisplayManager::setGraphicsMode(const char *name) { + DEBUG_ENTER_FUNC(); + + int i = 0; + + while (_supportedModes[i].name) { + if (!strcmpi(_supportedModes[i].name, name)) { + setGraphicsMode(_supportedModes[i].id); + DEBUG_EXIT_FUNC(); + return true; + } + i++; + } + + DEBUG_EXIT_FUNC(); + return false; +} + +bool DisplayManager::setGraphicsMode(int mode) { + DEBUG_ENTER_FUNC(); + + _graphicsMode = mode; + + switch (_graphicsMode) { + case CENTERED_320X200: + _displayParams.screenOutput.width = 320; + _displayParams.screenOutput.height = 200; + break; + case CENTERED_435X272: + _displayParams.screenOutput.width = 435; + _displayParams.screenOutput.height = 272; + break; + case STRETCHED_480X272: + _displayParams.screenOutput.width = 480; + _displayParams.screenOutput.height = 272; + break; + case CENTERED_362X272: + _displayParams.screenOutput.width = 362; + _displayParams.screenOutput.height = 272; + break; + default: + PSP_ERROR("Unsupported graphics mode[%d].\n", _graphicsMode); + } + + calculateScaleParams(); + + DEBUG_EXIT_FUNC(); + return true; +} + +void DisplayManager::calculateScaleParams() { + if (_displayParams.screenOutput.width && _displayParams.screenSource.width && + _displayParams.screenOutput.height && _displayParams.screenSource.height) { + _displayParams.scaleX = ((float)_displayParams.screenOutput.width) / _displayParams.screenSource.width; + _displayParams.scaleY = ((float)_displayParams.screenOutput.height) / _displayParams.screenSource.height; + } +} + +void DisplayManager::renderAll() { + DEBUG_ENTER_FUNC(); + + if (!isTimeToUpdate()) { + DEBUG_EXIT_FUNC(); + return; + } + + if (!_screen->isDirty() && + (!_overlay->isDirty()) && + (!_cursor->isDirty()) && + (!_keyboard->isDirty())) { + PSP_DEBUG_PRINT("Nothing dirty\n"); + DEBUG_EXIT_FUNC(); + return; + } + + PSP_DEBUG_PRINT("screen[%s], overlay[%s], cursor[%s], keyboard[%s]\n", + _screen->isDirty() ? "true" : "false", + _overlay->isDirty() ? "true" : "false", + _cursor->isDirty() ? "true" : "false", + _keyboard->isDirty() ? "true" : "false" + ); + + _masterGuRenderer.guPreRender(); // Set up rendering + + _screen->render(); + + _screen->setClean(); // clean out dirty bit + + if (_overlay->isVisible()) + _overlay->render(); + + _overlay->setClean(); + + if (_cursor->isVisible()) + _cursor->render(); + + _cursor->setClean(); + + if (_keyboard->isVisible()) + _keyboard->render(); + + _keyboard->setClean(); + + _masterGuRenderer.guPostRender(); + + DEBUG_EXIT_FUNC(); +} + +inline bool DisplayManager::isTimeToUpdate() { + +#define MAX_FPS 30 + + uint32 now = g_system->getMillis(); + if (now - _lastUpdateTime < (1000 / MAX_FPS)) + return false; + + _lastUpdateTime = now; + return true; +} + +Common::List<Graphics::PixelFormat> DisplayManager::getSupportedPixelFormats() { + Common::List<Graphics::PixelFormat> list; + + // In order of preference + list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_5650)); + list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_5551)); + list.push_back(PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type_4444)); + list.push_back(Graphics::PixelFormat::createFormatCLUT8()); + + return list; +} + diff --git a/backends/platform/psp/display_manager.h b/backends/platform/psp/display_manager.h new file mode 100644 index 0000000000..de5fcf94c8 --- /dev/null +++ b/backends/platform/psp/display_manager.h @@ -0,0 +1,114 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 47541 2010-01-25 01:39:44Z lordhoto $ + * + */ + +#ifndef PSP_DISPLAY_MAN_H +#define PSP_DISPLAY_MAN_H + +/** + * Class used only by DisplayManager to start/stop GU rendering + */ +class MasterGuRenderer { +public: + MasterGuRenderer() : _lastRenderTime(0) {} + void guInit(); + void guPreRender(); + void guPostRender(); + void guShutDown(); +private: + static uint32 _displayList[]; + uint32 _lastRenderTime; // For measuring rendering + void guProgramDisplayBufferSizes(); +}; + +class Screen; +class Overlay; +class Cursor; +class PSPKeyboard; + +/** + * Class that manages all display clients + */ +class DisplayManager { +public: + enum GraphicsModeID { ///> Possible output formats onscreen + CENTERED_320X200, + CENTERED_435X272, + STRETCHED_480X272, + CENTERED_362X272 + }; + DisplayManager() : _screen(0), _cursor(0), _overlay(0), _keyboard(0), _lastUpdateTime(0), _graphicsMode(0) {} + ~DisplayManager(); + + void init(); + void renderAll(); + bool setGraphicsMode(int mode); + bool setGraphicsMode(const char *name); + int getGraphicsMode() const { return _graphicsMode; } + uint32 getDefaultGraphicsMode() const { return STRETCHED_480X272; } + const OSystem::GraphicsMode* getSupportedGraphicsModes() const { return _supportedModes; } + + // Setters + void setScreen(Screen *screen) { _screen = screen; } + void setCursor(Cursor *cursor) { _cursor = cursor; } + void setOverlay(Overlay *overlay) { _overlay = overlay; } + void setKeyboard(PSPKeyboard *keyboard) { _keyboard = keyboard; } + void setSizeAndPixelFormat(uint width, uint height, const Graphics::PixelFormat *format); + + // Getters + float getScaleX() { return _displayParams.scaleX; } + float getScaleY() { return _displayParams.scaleY; } + uint32 getOutputWidth() { return _displayParams.screenOutput.width; } + uint32 getOutputHeight() { return _displayParams.screenOutput.height; } + uint32 getOutputBitsPerPixel() { return _displayParams.outputBitsPerPixel; } + Common::List<Graphics::PixelFormat> getSupportedPixelFormats(); + +private: + struct GlobalDisplayParams { + Dimensions screenOutput; + Dimensions screenSource; + float scaleX; + float scaleY; + uint32 outputBitsPerPixel; // How many bits end up on-screen + GlobalDisplayParams() : scaleX(0.0f), scaleY(0.0f), outputBitsPerPixel(0) {} + }; + + // Pointers to DisplayClients + Screen *_screen; + Cursor *_cursor; + Overlay *_overlay; + PSPKeyboard *_keyboard; + + MasterGuRenderer _masterGuRenderer; + uint32 _lastUpdateTime; // For limiting FPS + int _graphicsMode; + GlobalDisplayParams _displayParams; + static const OSystem::GraphicsMode _supportedModes[]; + + void calculateScaleParams(); // calculates scaling factor + bool isTimeToUpdate(); // should we update the screen now +}; + + +#endif /* PSP_DISPLAY_MAN_H */ diff --git a/backends/platform/psp/input.cpp b/backends/platform/psp/input.cpp new file mode 100644 index 0000000000..bd33175f03 --- /dev/null +++ b/backends/platform/psp/input.cpp @@ -0,0 +1,317 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 43618 2009-08-21 22:44:49Z joostp $ + * + */ + +// Todo: handle events that should fire because of shift going off +// Solution: handle shift on a button-by-button basis, only allowing it when the button is up. Also a inputmap-wide button. At buttonup, shiftstate is inspected per button. + +//#define __PSP_DEBUG_FUNCS__ /* Uncomment for debugging the stack */ +//#define __PSP_DEBUG_PRINT__ /* Uncomment for debug prints */ + +#include "backends/platform/psp/trace.h" + +#include "backends/platform/psp/input.h" + +// Defines for working with PSP buttons +#define CHANGED(x) (_buttonsChanged & (x)) +#define PRESSED(x) ((_buttonsChanged & (x)) && (pad.Buttons & (x))) +#define UNPRESSED(x) ((_buttonsChanged & (x)) && !(pad.Buttons & (x))) +#define DOWN(x) (pad.Buttons & (x)) +#define UP(x) (!(pad.Buttons & (x))) +#define PSP_DPAD (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT) +#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE) +#define PSP_TRIGGERS (PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER) + +#define PAD_CHECK_TIME 53 + +void InputHandler::init() { + sceCtrlSetSamplingCycle(0); // set sampling to vsync. n = n usecs + sceCtrlSetSamplingMode(1); // analog +} + +bool InputHandler::getAllInputs(Common::Event &event) { + DEBUG_ENTER_FUNC(); + + uint32 time = g_system->getMillis(); // may not be necessary with read + if (time - _lastPadCheckTime < PAD_CHECK_TIME) { + DEBUG_EXIT_FUNC(); + return false; + } + + _lastPadCheckTime = time; + SceCtrlData pad; + + sceCtrlPeekBufferPositive(&pad, 1); // Peek ignores sleep. Read sleeps thread + + bool haveEvent; + + memset(&event, 0, sizeof(event)); + + if (_keyboard->isVisible()) + haveEvent = _keyboard->processInput(event, pad); + else + haveEvent = getEvent(event, pad); + + if (haveEvent) + { + PSP_DEBUG_PRINT("Have event[%s]\n", haveEvent ? "true" : "false"); + PSP_DEBUG_PRINT("event.type[%d]\n", event.type); + } + + DEBUG_EXIT_FUNC(); + + return haveEvent; +} + +bool InputHandler::getEvent(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + + _buttonsChanged = pad.Buttons ^ _prevButtons; + bool haveEvent = false; + + // Collect events from different sources + haveEvent = getDpadEvent(event, pad); + + if (!haveEvent) + haveEvent = getButtonEvent(event, pad); + + if (!haveEvent) + haveEvent = getNubEvent(event, pad); + + _prevButtons = pad.Buttons; + + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +bool InputHandler::getDpadEvent(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + + int newDpadX = 0, newDpadY = 0; + bool haveEvent = false; + + if (DOWN(PSP_CTRL_UP)) { + newDpadY++; + if (DOWN(PSP_CTRL_RTRIGGER)) // Shifting causes diagonals + newDpadX++; + } + if (DOWN(PSP_CTRL_RIGHT)) { + newDpadX++; + if (DOWN(PSP_CTRL_RTRIGGER)) + newDpadY--; + } + if (DOWN(PSP_CTRL_DOWN)) { + newDpadY--; + if (DOWN(PSP_CTRL_RTRIGGER)) + newDpadX--; + } + if (DOWN(PSP_CTRL_LEFT)) { + newDpadX--; + if (DOWN(PSP_CTRL_RTRIGGER)) + newDpadY++; + } + + if (newDpadX != _dpadX || newDpadY != _dpadY) { + if (_dpadX == 0 && _dpadY == 0) { // We were in the middle so we pressed dpad + event.type = Common::EVENT_KEYDOWN; + event.kbd.keycode = translateDpad(newDpadX, newDpadY); + event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0'; // Get ascii + _dpadX = newDpadX; + _dpadY = newDpadY; + } + else if (newDpadX == 0 && newDpadY == 0) {// We're now centered so we unpressed dpad + event.type = Common::EVENT_KEYUP; + event.kbd.keycode = translateDpad(_dpadX, _dpadY); + event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0'; + _dpadX = newDpadX; + _dpadY = newDpadY; + } else { // we moved from one pressed dpad direction to another one + event.type = Common::EVENT_KEYUP; // first release the last dpad direction + event.kbd.keycode = translateDpad(_dpadX, _dpadY); + event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0'; + _dpadX = 0; // so that we'll pick up a new dpad movement the next round + _dpadY = 0; + } + + PSP_DEBUG_PRINT("Keypad event. DpadX[%d], DpadY[%d]\n", _dpadX, _dpadY); + haveEvent = true; + } + + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +inline Common::KeyCode InputHandler::translateDpad(int x, int y) { + DEBUG_ENTER_FUNC(); + Common::KeyCode key; + + if (x == -1) { + if (y == -1) + key = Common::KEYCODE_KP1; + else if (y == 0) + key = Common::KEYCODE_KP4; + else /* y == 1 */ + key = Common::KEYCODE_KP7; + } else if (x == 0) { + if (y == -1) + key = Common::KEYCODE_KP2; + else /* y == 1 */ + key = Common::KEYCODE_KP8; + } else {/* x == 1 */ + if (y == -1) + key = Common::KEYCODE_KP3; + else if (y == 0) + key = Common::KEYCODE_KP6; + else /* y == 1 */ + key = Common::KEYCODE_KP9; + } + + DEBUG_EXIT_FUNC(); + return key; +} + + +bool InputHandler::getButtonEvent(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + bool haveEvent = false; + + if (PRESSED(PSP_CTRL_SELECT)) + _keyboard->setVisible(true); + + else if (CHANGED(PSP_4BUTTONS | PSP_TRIGGERS | PSP_CTRL_START)) { + if (CHANGED(PSP_CTRL_CROSS)) { + event.type = DOWN(PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP; + event.mouse.x = _cursor->getX(); // Could this have to do with SCI enter problem? + event.mouse.y = _cursor->getY(); + PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "LButtonDown" : "LButtonUp"); + } else if (CHANGED(PSP_CTRL_CIRCLE)) { + event.type = DOWN(PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP; + event.mouse.x = _cursor->getX(); + event.mouse.y = _cursor->getY(); + PSP_DEBUG_PRINT("%s\n", event.type == Common::EVENT_LBUTTONDOWN ? "RButtonDown" : "RButtonUp"); + } else { + //any of the other buttons. + event.type = _buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP; + event.kbd.ascii = 0; + event.kbd.flags = 0; + + if (CHANGED(PSP_CTRL_LTRIGGER)) { + event.kbd.keycode = Common::KEYCODE_ESCAPE; + event.kbd.ascii = 27; + } else if (CHANGED(PSP_CTRL_START)) { + event.kbd.keycode = Common::KEYCODE_F5; + event.kbd.ascii = Common::ASCII_F5; + if (DOWN(PSP_CTRL_RTRIGGER)) { + event.kbd.flags |= Common::KBD_CTRL; // Main menu to allow RTL + } + } else if (CHANGED(PSP_CTRL_SQUARE)) { + event.kbd.keycode = Common::KEYCODE_PERIOD; + event.kbd.ascii = '.'; + } else if (CHANGED(PSP_CTRL_TRIANGLE)) { + event.kbd.keycode = Common::KEYCODE_RETURN; + event.kbd.ascii = '\r'; + } else if (DOWN(PSP_CTRL_RTRIGGER)) { // An event + event.kbd.flags |= Common::KBD_SHIFT; + } + PSP_DEBUG_PRINT("Ascii[%d]. Key %s.\n", event.kbd.ascii, event.type == Common::EVENT_KEYDOWN ? "down" : "up" ); + } + + haveEvent = true; + } + + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +bool InputHandler::getNubEvent(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + + bool haveEvent = false; + int32 analogStepX = pad.Lx; // Goes up to 255. + int32 analogStepY = pad.Ly; + + int32 oldX = _cursor->getX(); + int32 oldY = _cursor->getY(); + + analogStepX = modifyNubAxisMotion(analogStepX); + analogStepY = modifyNubAxisMotion(analogStepY); + + if (analogStepX != 0 || analogStepY != 0) { + + PSP_DEBUG_PRINT("raw x[%d], y[%d]\n", analogStepX, analogStepY); + + // If no movement then this has no effect + if (DOWN(PSP_CTRL_RTRIGGER)) { + // Fine control mode for analog + if (analogStepX != 0) { + if (analogStepX > 0) + _cursor->increaseXY(2, 0); + else + _cursor->increaseXY(-2, 0); + } + + if (analogStepY != 0) { + if (analogStepY > 0) + _cursor->increaseXY(0, 2); + else + _cursor->increaseXY(0, -2); + } + } else { // Regular speed movement + _cursor->increaseXY(analogStepX, 0); + _cursor->increaseXY(0, analogStepY); + } + + int32 newX = _cursor->getX(); + int32 newY = _cursor->getY(); + + if ((oldX != newX) || (oldY != newY)) { + event.type = Common::EVENT_MOUSEMOVE; + event.mouse.x = newX; + event.mouse.y = newY; + haveEvent = true; + + PSP_DEBUG_PRINT("Nub event. X[%d], Y[%d]\n", newX, newY); + } + } + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +inline int32 InputHandler::modifyNubAxisMotion(int32 input) { + DEBUG_ENTER_FUNC(); + const int MIN_NUB_MOTION = 30; + + input -= 128; // Center on 0. + + if (input < -MIN_NUB_MOTION - 1) + input += MIN_NUB_MOTION + 1; // reduce the velocity + else if (input > MIN_NUB_MOTION) + input -= MIN_NUB_MOTION; // same + else // between these points, dampen the response to 0 + input = 0; + + + DEBUG_EXIT_FUNC(); + return input; +} diff --git a/backends/platform/psp/input.h b/backends/platform/psp/input.h new file mode 100644 index 0000000000..64775b9b1d --- /dev/null +++ b/backends/platform/psp/input.h @@ -0,0 +1,63 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 43618 2009-08-21 22:44:49Z joostp $ + * + */ + +#ifndef PSP_INPUT_H +#define PSP_INPUT_H + +#include "common/scummsys.h" +#include "common/events.h" +#include "backends/platform/psp/display_client.h" +#include "backends/platform/psp/default_display_client.h" +#include "backends/platform/psp/pspkeyboard.h" +#include "backends/platform/psp/cursor.h" +#include <pspctrl.h> + +class InputHandler { +public: + InputHandler() : _cursor(0), _keyboard(0), _prevButtons(0), _lastPadCheckTime(0), _buttonsChanged(0), _dpadX(0), _dpadY(0) {} + + void init(); + bool getAllInputs(Common::Event &event); + void setKeyboard(PSPKeyboard *keyboard) { _keyboard = keyboard; } + void setCursor(Cursor *cursor) { _cursor = cursor; } + +private: + Cursor *_cursor; + PSPKeyboard *_keyboard; + uint32 _prevButtons; + uint32 _lastPadCheckTime; + uint32 _buttonsChanged; + int32 _dpadX, _dpadY; + int32 _accelX, _accelY; + + bool getEvent(Common::Event &event, SceCtrlData &pad); + bool getDpadEvent(Common::Event &event, SceCtrlData &pad); + bool getButtonEvent(Common::Event &event, SceCtrlData &pad); + bool getNubEvent(Common::Event &event, SceCtrlData &pad); + int32 modifyNubAxisMotion(int32 input); + Common::KeyCode translateDpad(int x, int y); +}; + +#endif /* PSP_INPUT_H */ diff --git a/backends/platform/psp/memory.cpp b/backends/platform/psp/memory.cpp new file mode 100644 index 0000000000..9cf7ba7c6c --- /dev/null +++ b/backends/platform/psp/memory.cpp @@ -0,0 +1,227 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $ + * + */ + +#include "common/scummsys.h" +#include "common/singleton.h" +#include "common/list.h" +#include "backends/platform/psp/psppixelformat.h" +#include "backends/platform/psp/memory.h" + +// Class Copier -------------------------------------------------------------------------- +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ + +#include "backends/platform/psp/trace.h" + +void Copier::copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *format /* = NULL */) { + DEBUG_ENTER_FUNC(); + + uint32 prefixDst = (((uint32)dst) & 0x3); + prefixDst = prefixDst ? 4 - prefixDst : 0; // prefix only if we have address % 4 != 0 + uint32 prefixSrc = (((uint32)src) & 0x3); + prefixSrc = prefixSrc ? 4 - prefixSrc : 0; // prefix only if we have address % 4 != 0 + uint32 *dst32, *src32; + bool swapRB = format ? format->swapRB : false; // take swap value from pixelformat if it's given +#ifdef __PSP_DEBUG_PRINT__ + uint32 debugBytes = bytes; + const byte *debugDst = dst, *debugSrc = src; +#endif + uint32 words, remainingBytes; + + //PSP_DEBUG_PRINT("dst[%p], src[%p], bytes[%d], swap[%s], prefixDst[%u], prefixSrc[%u]\n", dst, src, bytes, swapRB ? "true" : "false", prefixDst, prefixSrc); + + if (prefixDst || prefixSrc) { // we're not aligned to word boundaries + if (prefixDst != prefixSrc) { // worst case: we can never be aligned. this mode is highly inefficient. try to get engines not to use this mode too much + PSP_DEBUG_PRINT("misaligned copy of %u bytes from %p to %p\n", bytes, src, dst); + if ((prefixDst & 1) || (prefixSrc & 1)) + copy8(dst, src, bytes); // no swap is possible on 8 bit + else + copy16((uint16 *)dst, (uint16 *)src, bytes, format); + + goto test; + } + + // Do the prefix: the part to get us aligned + if (prefixDst & 1) { // byte + copy8(dst, src, prefixDst); // no swap available + } else { // short + copy16((uint16 *)dst, (uint16 *)src, prefixDst, format); + } + if (bytes > prefixDst) // check that we can afford to subtract from bytes + bytes -= prefixDst; + else { + DEBUG_EXIT_FUNC(); + return; + } + dst32 = (uint32 *)(dst + prefixDst); + src32 = (uint32 *)(src + prefixSrc); + } else { // We're aligned to word boundaries + dst32 = (uint32 *)dst; + src32 = (uint32 *)src; + } + + words = bytes >> 2; + remainingBytes = bytes & 0x3; + + if (swapRB) { // need to swap + for (; words > 0; words--) { + *dst32 = format->swapRedBlue32(*src32); + dst32++; + src32++; + } + } else { // no swapping + for (; words > 0; words--) { + *dst32 = *src32; + dst32++; + src32++; + } + } + + // Do any remaining bytes + if (remainingBytes) { + if (remainingBytes & 1) // we have bytes left + copy8((byte *)dst32, (byte *)src32, remainingBytes); + else // 16bits left + copy16((uint16*)dst32, (uint16 *)src32, remainingBytes, format); + } + +test: + // debug +#ifdef __PSP_DEBUG_PRINT__ + bool mismatch = false; + + for (uint32 i=0; i<debugBytes; i++) { + if (debugDst[i] != debugSrc[i]) { + if (mismatch == false) { + PSP_DEBUG_PRINT_SAMELN("mismatch in copy:\n"); + PSP_DEBUG_PRINT("dst[%p], src[%p], bytes[%u], swap[%s], prefixDst[%u], prefixSrc[%u]\n", debugDst, debugSrc, debugBytes, swapRB ? "true" : "false", prefixDst, prefixSrc); + mismatch = true; + } + PSP_DEBUG_PRINT_SAMELN("%x!=%x ", debugSrc[i], debugDst[i]); + } + } + if (mismatch) + PSP_DEBUG_PRINT("\n"); +#endif + + DEBUG_EXIT_FUNC(); +} + +inline void Copier::copy8(byte *dst, const byte *src, uint32 bytes) { + for (; bytes > 0; bytes--) { + *dst = *src; + dst++; + src++; + } +} + +inline void Copier::copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixelFormat *format /* = NULL */) { + uint32 shorts = bytes >> 1; + uint32 remainingBytes = bytes & 1; + bool swapRB = format ? format->swapRB : false; + + if (swapRB) { + for (; shorts > 0 ; shorts--) { + *dst = format->swapRedBlue16(*src); + dst++; + src++; + } + } else { + for (; shorts > 0 ; shorts--) { + *dst = *src; + dst++; + src++; + } + } + if (remainingBytes) + *(byte *)dst = *(byte *)src; +} + + +// Class VramAllocator ----------------------------------- + +DECLARE_SINGLETON(VramAllocator) + +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ + +#include "backends/platform/psp/trace.h" + + +void *VramAllocator::allocate(int32 size, bool smallAllocation /* = false */) { + DEBUG_ENTER_FUNC(); + assert (size > 0); + + byte *lastAddress = smallAllocation ? (byte *)VRAM_SMALL_ADDRESS : (byte *)VRAM_START_ADDRESS; + Common::List<Allocation>::iterator i; + + // Find a block that fits, starting from the beginning + for (i = _allocList.begin(); i != _allocList.end(); ++i) { + byte *currAddress = (*i).address; + + if (currAddress - lastAddress >= size) // We found a match + break; + + if ((*i).getEnd() > lastAddress) + lastAddress = (byte *)(*i).getEnd(); + } + + if (lastAddress + size > (byte *)VRAM_END_ADDRESS) { + PSP_DEBUG_PRINT("No space for allocation of %d bytes. %d bytes already allocated.\n", + size, _bytesAllocated); + return NULL; + } + + _allocList.insert(i, Allocation(lastAddress, size)); + _bytesAllocated += size; + + PSP_DEBUG_PRINT("Allocated in VRAM, size %u at %p.\n", size, lastAddress); + PSP_DEBUG_PRINT("Total allocated %u, remaining %u.\n", _bytesAllocated, (2 * 1024 * 1024) - _bytesAllocated); + + DEBUG_EXIT_FUNC(); + return lastAddress; +} + +// Deallocate a block from VRAM +void VramAllocator::deallocate(void *address) { + DEBUG_ENTER_FUNC(); + address = (byte *)CACHED(address); // Make sure all addresses are the same + + Common::List<Allocation>::iterator i; + + // Find the Allocator to deallocate + for (i = _allocList.begin(); i != _allocList.end(); ++i) { + if ((*i).address == address) { + _bytesAllocated -= (*i).size; + _allocList.erase(i); + PSP_DEBUG_PRINT("Deallocated address[%p], size[%u]\n", (*i).address, (*i).size); + DEBUG_EXIT_FUNC(); + return; + } + } + + PSP_DEBUG_PRINT("Address[%p] not allocated.\n", address); + DEBUG_EXIT_FUNC(); +} diff --git a/backends/platform/psp/memory.h b/backends/platform/psp/memory.h new file mode 100644 index 0000000000..79af46c68b --- /dev/null +++ b/backends/platform/psp/memory.h @@ -0,0 +1,80 @@ + +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $ + * + */ + +#ifndef PSP_MEMORY_H +#define PSP_MEMORY_H + +#define UNCACHED(x) ((byte *)(((uint32)(x)) | 0x40000000)) /* make an uncached access */ +#define CACHED(x) ((byte *)(((uint32)(x)) & 0xBFFFFFFF)) /* make an uncached access into a cached one */ + +/** + * Class that does memory copying and swapping if needed + */ +class Copier { +public: + static void copy(byte *dst, const byte *src, uint32 bytes, PSPPixelFormat *format = NULL); + static void copy8(byte *dst, const byte *src, uint32 bytes); + static void copy16(uint16 *dst, const uint16 *src, uint32 bytes, PSPPixelFormat *format = NULL); +}; + +/** + * Class that allocates memory in the VRAM + */ +class VramAllocator : public Common::Singleton<VramAllocator> { +public: + VramAllocator() : _bytesAllocated(0) {} + void *allocate(int32 size, bool smallAllocation = false); // smallAllocation e.g. palettes + void deallocate(void *pointer); + + static inline bool isAddressInVram(void *address) { + if ((uint32)(CACHED(address)) >= VRAM_START_ADDRESS && (uint32)(CACHED(address)) < VRAM_END_ADDRESS) + return true; + return false; +} + + +private: + /** + * Used to allocate in VRAM + */ + struct Allocation { + byte *address; + uint32 size; + void *getEnd() { return address + size; } + Allocation(void *Address, uint32 Size) : address((byte *)Address), size(Size) {} + Allocation() : address(0), size(0) {} + }; + + enum { + VRAM_START_ADDRESS = 0x04000000, + VRAM_END_ADDRESS = 0x04200000, + VRAM_SMALL_ADDRESS = VRAM_END_ADDRESS - (4*1024) // 4K in the end for small allocations + }; + Common::List <Allocation> _allocList; // List of allocations + uint32 _bytesAllocated; +}; + +#endif /* PSP_MEMORY_H */ diff --git a/backends/platform/psp/module.mk b/backends/platform/psp/module.mk index 4396530d5b..f7191fe14f 100644 --- a/backends/platform/psp/module.mk +++ b/backends/platform/psp/module.mk @@ -1,9 +1,15 @@ MODULE := backends/platform/psp -MODULE_OBJS := \ - powerman.o \ +MODULE_OBJS := powerman.o \ psp_main.o \ osys_psp.o \ + psppixelformat.o \ + memory.o \ + display_manager.o \ + display_client.o \ + default_display_client.o \ + input.o \ + cursor.o \ trace.o \ psploader.o \ pspkeyboard.o diff --git a/backends/platform/psp/osys_psp.cpp b/backends/platform/psp/osys_psp.cpp index 8b4c005221..022c10f5a8 100644 --- a/backends/platform/psp/osys_psp.cpp +++ b/backends/platform/psp/osys_psp.cpp @@ -23,6 +23,7 @@ * */ +#include <pspuser.h> #include <pspgu.h> #include <pspdisplay.h> @@ -33,40 +34,21 @@ #include "common/events.h" #include "common/scummsys.h" -#include "osys_psp.h" -#include "trace.h" -#include "powerman.h" +#include "backends/platform/psp/osys_psp.h" +#include "backends/platform/psp/powerman.h" #include "backends/saves/psp/psp-saves.h" #include "backends/timer/default/default-timer.h" #include "graphics/surface.h" #include "sound/mixer_intern.h" -#include "backends/platform/psp/pspkeyboard.h" +//#define __PSP_DEBUG_FUNCS__ /* For debugging function calls */ +//#define __PSP_DEBUG_PRINT__ /* For debug printouts */ +#include "backends/platform/psp/trace.h" -#define SAMPLES_PER_SEC 44100 - -#define PIXEL_SIZE (4) -#define BUF_WIDTH (512) -#define PSP_SCREEN_WIDTH 480 -#define PSP_SCREEN_HEIGHT 272 -#define PSP_FRAME_SIZE (BUF_WIDTH * PSP_SCREEN_HEIGHT * PIXEL_SIZE) -#define MOUSE_SIZE 128 -#define KBD_DATA_SIZE 130560 - -#define MAX_FPS 30 - -unsigned int __attribute__((aligned(16))) displayList[2048]; -unsigned short __attribute__((aligned(16))) clut256[256]; -unsigned short __attribute__((aligned(16))) mouseClut[256]; -unsigned short __attribute__((aligned(16))) cursorPalette[256]; -unsigned int __attribute__((aligned(16))) mouseBuf256[MOUSE_SIZE*MOUSE_SIZE]; - -unsigned long RGBToColour(unsigned long r, unsigned long g, unsigned long b) { - return (((b >> 3) << 10) | ((g >> 3) << 5) | ((r >> 3) << 0)) | 0x8000; -} +#define SAMPLES_PER_SEC 44100 static int timer_handler(int t) { DefaultTimerManager *tm = (DefaultTimerManager *)g_system->getTimerManager(); @@ -74,87 +56,51 @@ static int timer_handler(int t) { return t; } -const OSystem::GraphicsMode OSystem_PSP::s_supportedGraphicsModes[] = { - { "320x200 (centered)", "320x200 16-bit centered", CENTERED_320X200 }, - { "435x272 (best-fit, centered)", "435x272 16-bit centered", CENTERED_435X272 }, - { "480x272 (full screen)", "480x272 16-bit stretched", STRETCHED_480X272 }, - { "362x272 (4:3, centered)", "362x272 16-bit centered", CENTERED_362X272 }, - {0, 0, 0} -}; - - -OSystem_PSP::OSystem_PSP() : _screenWidth(0), _screenHeight(0), _overlayWidth(0), _overlayHeight(0), - _offscreen(0), _overlayBuffer(0), _overlayVisible(false), _shakePos(0), _lastScreenUpdate(0), - _mouseBuf(0), _prevButtons(0), _lastPadCheck(0), _mixer(0) { - memset(_palette, 0, sizeof(_palette)); - - _cursorPaletteDisabled = true; - - //init SDL - uint32 sdlFlags = SDL_INIT_AUDIO | SDL_INIT_TIMER; - SDL_Init(sdlFlags); - - _clut = clut256; - _mouseBuf = (byte *)mouseBuf256; - _graphicMode = STRETCHED_480X272; - - _mouseX = PSP_SCREEN_WIDTH >> 1; // Mouse in the middle of the screen - _mouseY = PSP_SCREEN_HEIGHT >> 1; - _dpadX = _dpadY = 0; - - - // Init GU - sceGuInit(); - sceGuStart(0, displayList); - sceGuDrawBuffer(GU_PSM_8888, (void *)0, BUF_WIDTH); - sceGuDispBuffer(PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT, (void*)PSP_FRAME_SIZE, BUF_WIDTH); - sceGuDepthBuffer((void*)(PSP_FRAME_SIZE * 2), BUF_WIDTH); - sceGuOffset(2048 - (PSP_SCREEN_WIDTH/2), 2048 - (PSP_SCREEN_HEIGHT/2)); - sceGuViewport(2048, 2048, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); - sceGuDepthRange(0xC350, 0x2710); - sceGuScissor(0, 0, PSP_SCREEN_WIDTH, PSP_SCREEN_HEIGHT); - sceGuEnable(GU_SCISSOR_TEST); - sceGuFrontFace(GU_CW); - sceGuEnable(GU_TEXTURE_2D); - sceGuClear(GU_COLOR_BUFFER_BIT|GU_DEPTH_BUFFER_BIT); - sceGuFinish(); - sceGuSync(0,0); - - sceDisplayWaitVblankStart(); - sceGuDisplay(1); - +void OSystem_PSP::initSDL() { + SDL_Init(SDL_INIT_AUDIO | SDL_INIT_TIMER); } -OSystem_PSP::~OSystem_PSP() { +OSystem_PSP::~OSystem_PSP() {} - free(_offscreen); - free(_overlayBuffer); - free(_mouseBuf); - delete _keyboard; +#define PSP_SCREEN_WIDTH 480 +#define PSP_SCREEN_HEIGHT 272 - _offscreen = 0; - _overlayBuffer = 0; - _mouseBuf = 0; - sceGuTerm(); -} +void OSystem_PSP::initBackend() { + DEBUG_ENTER_FUNC(); + _cursor.enableCursorPalette(false); + _cursor.setXY(PSP_SCREEN_WIDTH >> 1, PSP_SCREEN_HEIGHT >> 1); // Mouse in the middle of the screen + + // Set pointers for display manager + _displayManager.setCursor(&_cursor); + _displayManager.setScreen(&_screen); + _displayManager.setOverlay(&_overlay); + _displayManager.setKeyboard(&_keyboard); + _displayManager.init(); + + // Set pointers for input handler + _inputHandler.setCursor(&_cursor); + _inputHandler.setKeyboard(&_keyboard); + _inputHandler.init(); + + initSDL(); -void OSystem_PSP::initBackend() { _savefile = new PSPSaveFileManager; _timer = new DefaultTimerManager(); - _keyboard = new PSPKeyboard(); - _keyboard->load(); - + PSP_DEBUG_PRINT("calling keyboard.load()\n"); + _keyboard.load(); // Load virtual keyboard files into memory + setTimerCallback(&timer_handler, 10); setupMixer(); OSystem::initBackend(); + + DEBUG_EXIT_FUNC(); } - bool OSystem_PSP::hasFeature(Feature f) { return (f == kFeatureOverlaySupportsAlpha || f == kFeatureCursorHasPalette); } @@ -167,733 +113,251 @@ bool OSystem_PSP::getFeatureState(Feature f) { } const OSystem::GraphicsMode* OSystem_PSP::getSupportedGraphicsModes() const { - return s_supportedGraphicsModes; + return _displayManager.getSupportedGraphicsModes(); } - int OSystem_PSP::getDefaultGraphicsMode() const { - return STRETCHED_480X272; + DEBUG_ENTER_FUNC(); + + int ret = _displayManager.getDefaultGraphicsMode(); + + DEBUG_EXIT_FUNC(); + return ret; } bool OSystem_PSP::setGraphicsMode(int mode) { - _graphicMode = mode; - return true; + DEBUG_ENTER_FUNC(); + + int ret = _displayManager.setGraphicsMode(mode); + + DEBUG_EXIT_FUNC(); + return ret; } bool OSystem_PSP::setGraphicsMode(const char *name) { - int i = 0; - - while (s_supportedGraphicsModes[i].name) { - if (!strcmpi(s_supportedGraphicsModes[i].name, name)) { - _graphicMode = s_supportedGraphicsModes[i].id; - return true; - } - i++; - } - - return false; + DEBUG_ENTER_FUNC(); + + int ret = _displayManager.setGraphicsMode(name); + + DEBUG_EXIT_FUNC(); + return ret; } int OSystem_PSP::getGraphicsMode() const { - return _graphicMode; + DEBUG_ENTER_FUNC(); + + int ret = _displayManager.getGraphicsMode(); + + DEBUG_EXIT_FUNC(); + return ret; } -void OSystem_PSP::initSize(uint width, uint height, const Graphics::PixelFormat *format) { - PSPDebugTrace("initSize\n"); - - _screenWidth = width; - _screenHeight = height; +#ifdef USE_RGB_COLOR - const int scrBufSize = _screenWidth * _screenHeight * (format ? format->bytesPerPixel : 4); +Graphics::PixelFormat OSystem_PSP::getScreenFormat() const { + return _screen.getScummvmPixelFormat(); +} - _overlayWidth = PSP_SCREEN_WIDTH; //width; - _overlayHeight = PSP_SCREEN_HEIGHT; //height; +Common::List<Graphics::PixelFormat> OSystem_PSP::getSupportedFormats() { + return _displayManager.getSupportedPixelFormats(); +} - free(_overlayBuffer); - _overlayBuffer = (OverlayColor *)memalign(16, _overlayWidth * _overlayHeight * sizeof(OverlayColor)); +#endif - free(_offscreen); - _offscreen = (byte *)memalign(16, scrBufSize); - bzero(_offscreen, scrBufSize); +void OSystem_PSP::initSize(uint width, uint height, const Graphics::PixelFormat *format) { + DEBUG_ENTER_FUNC(); + + _displayManager.setSizeAndPixelFormat(width, height, format); - clearOverlay(); - memset(_palette, 0xFFFF, 256 * sizeof(unsigned short)); + _cursor.setVisible(false); + _cursor.setLimits(_screen.getWidth(), _screen.getHeight()); - _mouseVisible = false; - sceKernelDcacheWritebackAll(); + DEBUG_EXIT_FUNC(); } int16 OSystem_PSP::getWidth() { - return _screenWidth; + DEBUG_ENTER_FUNC(); + + int16 ret = (int16)_screen.getWidth(); + + DEBUG_EXIT_FUNC(); + return ret; } int16 OSystem_PSP::getHeight() { - return _screenHeight; + DEBUG_ENTER_FUNC(); + + int16 ret = (int16)_screen.getHeight(); + + DEBUG_EXIT_FUNC(); + return ret; } void OSystem_PSP::setPalette(const byte *colors, uint start, uint num) { - const byte *b = colors; + DEBUG_ENTER_FUNC(); + + _screen.setPartialPalette(colors, start, num); + _cursor.setScreenPalette(colors, start, num); + _cursor.clearKeyColor(); - for (uint i = 0; i < num; ++i) { - _palette[start + i] = RGBToColour(b[0], b[1], b[2]); - b += 4; - } - - //copy to CLUT - memcpy(_clut, _palette, 256 * sizeof(unsigned short)); - - //force update of mouse CLUT as well, as it may have been set up before this palette was set - memcpy(mouseClut, _palette, 256 * sizeof(unsigned short)); - mouseClut[_mouseKeyColour] = 0; - - sceKernelDcacheWritebackAll(); + DEBUG_EXIT_FUNC(); } void OSystem_PSP::setCursorPalette(const byte *colors, uint start, uint num) { - const byte *b = colors; - - for (uint i = 0; i < num; ++i) { - cursorPalette[start + i] = RGBToColour(b[0], b[1], b[2]); - b += 4; - } - - cursorPalette[0] = 0; + DEBUG_ENTER_FUNC(); - _cursorPaletteDisabled = false; + _cursor.setCursorPalette(colors, start, num); + _cursor.enableCursorPalette(true); + _cursor.clearKeyColor(); // Do we need this? - sceKernelDcacheWritebackAll(); + DEBUG_EXIT_FUNC(); } void OSystem_PSP::disableCursorPalette(bool disable) { - _cursorPaletteDisabled = disable; + DEBUG_ENTER_FUNC(); + + _cursor.enableCursorPalette(!disable); + + DEBUG_EXIT_FUNC(); } void OSystem_PSP::copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h) { - //Clip the coordinates - if (x < 0) { - w += x; - buf -= x; - x = 0; - } - - if (y < 0) { - h += y; - buf -= y * pitch; - y = 0; - } - - if (w > _screenWidth - x) { - w = _screenWidth - x; - } - - if (h > _screenHeight - y) { - h = _screenHeight - y; - } - - if (w <= 0 || h <= 0) - return; + DEBUG_ENTER_FUNC(); + _screen.copyFromRect(buf, pitch, x, y, w, h); - byte *dst = _offscreen + y * _screenWidth + x; - - if (_screenWidth == pitch && pitch == w) { - memcpy(dst, buf, h * w); - } else { - do { - memcpy(dst, buf, w); - buf += pitch; - dst += _screenWidth; - } while (--h); - } - sceKernelDcacheWritebackAll(); - + DEBUG_EXIT_FUNC(); } Graphics::Surface *OSystem_PSP::lockScreen() { - _framebuffer.pixels = _offscreen; - _framebuffer.w = _screenWidth; - _framebuffer.h = _screenHeight; - _framebuffer.pitch = _screenWidth; - _framebuffer.bytesPerPixel = 1; + DEBUG_ENTER_FUNC(); - return &_framebuffer; + Graphics::Surface *ret = _screen.lockAndGetForEditing(); + + DEBUG_EXIT_FUNC(); + return ret; } void OSystem_PSP::unlockScreen() { - // The screen is always completely update anyway, so we don't have to force a full update here. - sceKernelDcacheWritebackAll(); + DEBUG_ENTER_FUNC(); + // The screen is always completely updated anyway, so we don't have to force a full update here. + _screen.unlock(); + + DEBUG_EXIT_FUNC(); } void OSystem_PSP::updateScreen() { - u32 now = getMillis(); - if (now - _lastScreenUpdate < 1000 / MAX_FPS) - return; - - _lastScreenUpdate = now; - - sceGuStart(0, displayList); - - sceGuClearColor(0xFF000000); - sceGuClear(GU_COLOR_BUFFER_BIT); - - sceGuClutMode(GU_PSM_5551, 0, 0xFF, 0); - sceGuClutLoad(32, clut256); // upload 32*8 entries (256) - sceGuTexMode(GU_PSM_T8, 0, 0, 0); // 8-bit image - if (_screenWidth == 320) - sceGuTexImage(0, 512, 256, _screenWidth, _offscreen); - else - sceGuTexImage(0, 512, 512, _screenWidth, _offscreen); - sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGB); - sceGuTexFilter(GU_LINEAR, GU_LINEAR); - sceGuTexOffset(0,0); - sceGuAmbientColor(0xFFFFFFFF); - sceGuColor(0xFFFFFFFF); - - Vertex *vertices = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex)); - vertices[0].u = 0.5f; - vertices[0].v = 0.5f; - vertices[1].u = _screenWidth - 0.5f; - vertices[1].v = _screenHeight - 0.5f; - - switch (_graphicMode) { - case CENTERED_320X200: - vertices[0].x = (PSP_SCREEN_WIDTH - 320) / 2; - vertices[0].y = (PSP_SCREEN_HEIGHT - 200) / 2; - vertices[0].z = 0; - vertices[1].x = PSP_SCREEN_WIDTH - (PSP_SCREEN_WIDTH - 320) / 2; - vertices[1].y = PSP_SCREEN_HEIGHT - (PSP_SCREEN_HEIGHT - 200) / 2; - vertices[1].z = 0; - break; - case CENTERED_435X272: - vertices[0].x = (PSP_SCREEN_WIDTH - 435) / 2; - vertices[0].y = 0; vertices[0].z = 0; - vertices[1].x = PSP_SCREEN_WIDTH - (PSP_SCREEN_WIDTH - 435) / 2; - vertices[1].y = PSP_SCREEN_HEIGHT; - vertices[1].z = 0; - break; - case STRETCHED_480X272: - vertices[0].x = 0; - vertices[0].y = 0; - vertices[0].z = 0; - vertices[1].x = PSP_SCREEN_WIDTH; - vertices[1].y = PSP_SCREEN_HEIGHT; - vertices[1].z = 0; - break; - case CENTERED_362X272: - vertices[0].x = (PSP_SCREEN_WIDTH - 362) / 2; - vertices[0].y = 0; - vertices[0].z = 0; - vertices[1].x = PSP_SCREEN_WIDTH - (PSP_SCREEN_WIDTH - 362) / 2; - vertices[1].y = PSP_SCREEN_HEIGHT; - vertices[1].z = 0; - break; - } - - if (_shakePos) { - vertices[0].y += _shakePos; - vertices[1].y += _shakePos; - } - - sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertices); - if (_screenWidth == 640) { - // 2nd draw - Vertex *vertices2 = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex)); - sceGuTexImage(0, 512, 512, _screenWidth, _offscreen+512); - vertices2[0].u = 512 + 0.5f; - vertices2[0].v = vertices[0].v; - vertices2[1].u = vertices[1].u; - vertices2[1].v = _screenHeight - 0.5f; - vertices2[0].x = vertices[0].x + (vertices[1].x - vertices[0].x) * 511 / 640; - vertices2[0].y = 0; - vertices2[0].z = 0; - vertices2[1].x = vertices[1].x; - vertices2[1].y = vertices[1].y; - vertices2[1].z = 0; - sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertices2); - } - - - // draw overlay - if (_overlayVisible) { - Vertex *vertOverlay = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex)); - vertOverlay[0].x = 0; - vertOverlay[0].y = 0; - vertOverlay[0].z = 0; - vertOverlay[1].x = PSP_SCREEN_WIDTH; - vertOverlay[1].y = PSP_SCREEN_HEIGHT; - vertOverlay[1].z = 0; - vertOverlay[0].u = 0.5f; - vertOverlay[0].v = 0.5f; - vertOverlay[1].u = _overlayWidth - 0.5f; - vertOverlay[1].v = _overlayHeight - 0.5f; - sceGuTexMode(GU_PSM_4444, 0, 0, 0); // 16-bit image - sceGuDisable(GU_ALPHA_TEST); - sceGuEnable(GU_BLEND); - - //sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0); - sceGuBlendFunc(GU_ADD, GU_FIX, GU_ONE_MINUS_SRC_ALPHA, 0xFFFFFFFF, 0); - - if (_overlayWidth > 320) - sceGuTexImage(0, 512, 512, _overlayWidth, _overlayBuffer); - else - sceGuTexImage(0, 512, 256, _overlayWidth, _overlayBuffer); - - sceGuTexFunc(GU_TFX_REPLACE, GU_TCC_RGBA); - sceGuDrawArray(GU_SPRITES,GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D,2,0,vertOverlay); - // need to render twice for textures > 512 - if ( _overlayWidth > 512) { - Vertex *vertOverlay2 = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex)); - sceGuTexImage(0, 512, 512, _overlayWidth, _overlayBuffer + 512); - vertOverlay2[0].u = 512 + 0.5f; - vertOverlay2[0].v = vertOverlay[0].v; - vertOverlay2[1].u = vertOverlay[1].u; - vertOverlay2[1].v = _overlayHeight - 0.5f; - vertOverlay2[0].x = PSP_SCREEN_WIDTH * 512 / 640; - vertOverlay2[0].y = 0; - vertOverlay2[0].z = 0; - vertOverlay2[1].x = PSP_SCREEN_WIDTH; - vertOverlay2[1].y = PSP_SCREEN_HEIGHT; - vertOverlay2[1].z = 0; - sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertOverlay2); - } - sceGuDisable(GU_BLEND); - } + DEBUG_ENTER_FUNC(); - // draw mouse - if (_mouseVisible) { - sceGuTexMode(GU_PSM_T8, 0, 0, 0); // 8-bit image - sceGuClutMode(GU_PSM_5551, 0, 0xFF, 0); - sceGuClutLoad(32, _cursorPaletteDisabled ? mouseClut : cursorPalette); // upload 32*8 entries (256) - sceGuAlphaFunc(GU_GREATER, 0, 0xFF); - sceGuEnable(GU_ALPHA_TEST); - sceGuTexImage(0, MOUSE_SIZE, MOUSE_SIZE, MOUSE_SIZE, _mouseBuf); - sceGuTexFunc(GU_TFX_MODULATE, GU_TCC_RGBA); - - Vertex *vertMouse = (Vertex *)sceGuGetMemory(2 * sizeof(Vertex)); - vertMouse[0].u = 0.5f; - vertMouse[0].v = 0.5f; - vertMouse[1].u = _mouseWidth - 0.5f; - vertMouse[1].v = _mouseHeight - 0.5f; - - //adjust cursor position - int mX = _mouseX - _mouseHotspotX; - int mY = _mouseY - _mouseHotspotY; - - if (_overlayVisible) { - float scalex, scaley; - - scalex = (float)PSP_SCREEN_WIDTH /_overlayWidth; - scaley = (float)PSP_SCREEN_HEIGHT /_overlayHeight; - - vertMouse[0].x = mX * scalex; - vertMouse[0].y = mY * scaley; - vertMouse[0].z = 0; - vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex; - vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley; - vertMouse[1].z = 0; - } else - switch (_graphicMode) { - case CENTERED_320X200: - vertMouse[0].x = (PSP_SCREEN_WIDTH - 320) / 2 + mX; - vertMouse[0].y = (PSP_SCREEN_HEIGHT - 200) / 2 + mY; - vertMouse[0].z = 0; - vertMouse[1].x = vertMouse[0].x + _mouseWidth; - vertMouse[1].y = vertMouse[0].y + _mouseHeight; - vertMouse[1].z = 0; - break; - case CENTERED_435X272: - { - float scalex, scaley; - - scalex = 435.0f / _screenWidth; - scaley = 272.0f / _screenHeight; - - vertMouse[0].x = (PSP_SCREEN_WIDTH - 435) / 2 + mX * scalex; - vertMouse[0].y = mY * scaley; - vertMouse[0].z = 0; - vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex; - vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley; - vertMouse[1].z = 0; - } - break; - case CENTERED_362X272: - { - float scalex, scaley; - - scalex = 362.0f / _screenWidth; - scaley = 272.0f / _screenHeight; - - vertMouse[0].x = (PSP_SCREEN_WIDTH - 362) / 2 + mX * scalex; - vertMouse[0].y = mY * scaley; - vertMouse[0].z = 0; - vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex; - vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley; - vertMouse[1].z = 0; - } - break; - case STRETCHED_480X272: - { - float scalex, scaley; - - scalex = (float)PSP_SCREEN_WIDTH / _screenWidth; - scaley = (float)PSP_SCREEN_HEIGHT / _screenHeight; - - vertMouse[0].x = mX * scalex; - vertMouse[0].y = mY * scaley; - vertMouse[0].z = 0; - vertMouse[1].x = vertMouse[0].x + _mouseWidth * scalex; - vertMouse[1].y = vertMouse[0].y + _mouseHeight * scaley; - vertMouse[1].z = 0; - } - break; - } - sceGuDrawArray(GU_SPRITES, GU_TEXTURE_32BITF|GU_VERTEX_32BITF|GU_TRANSFORM_2D, 2, 0, vertMouse); - } - - if (_keyboard->isVisible()) { - _keyboard->render(); - } - - sceGuFinish(); - sceGuSync(0,0); - - sceDisplayWaitVblankStart(); - sceGuSwapBuffers(); + _displayManager.renderAll(); + + DEBUG_EXIT_FUNC(); } void OSystem_PSP::setShakePos(int shakeOffset) { - _shakePos = shakeOffset; + DEBUG_ENTER_FUNC(); + + _screen.setShakePos(shakeOffset); + + DEBUG_EXIT_FUNC(); } void OSystem_PSP::showOverlay() { - _overlayVisible = true; + DEBUG_ENTER_FUNC(); + + _overlay.setVisible(true); + _cursor.setLimits(_overlay.getWidth(), _overlay.getHeight()); + _cursor.useGlobalScaler(false); // mouse with overlay is 1:1 + + DEBUG_EXIT_FUNC(); } void OSystem_PSP::hideOverlay() { - PSPDebugTrace("OSystem_PSP::hideOverlay called\n"); - _overlayVisible = false; + DEBUG_ENTER_FUNC(); + + _overlay.setVisible(false); + _cursor.setLimits(_screen.getWidth(), _screen.getHeight()); + _cursor.useGlobalScaler(true); // mouse needs to be scaled with screen + + DEBUG_EXIT_FUNC(); } void OSystem_PSP::clearOverlay() { - PSPDebugTrace("clearOverlay\n"); + DEBUG_ENTER_FUNC(); - bzero(_overlayBuffer, _overlayWidth * _overlayHeight * sizeof(OverlayColor)); - sceKernelDcacheWritebackAll(); -} + _overlay.clearBuffer(); -void OSystem_PSP::grabOverlay(OverlayColor *buf, int pitch) { - int h = _overlayHeight; - OverlayColor *src = _overlayBuffer; - - do { - memcpy(buf, src, _overlayWidth * sizeof(OverlayColor)); - src += _overlayWidth; - buf += pitch; - } while (--h); + DEBUG_EXIT_FUNC(); } -void OSystem_PSP::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) { - PSPDebugTrace("copyRectToOverlay\n"); - - //Clip the coordinates - if (x < 0) { - w += x; - buf -= x; - x = 0; - } - - if (y < 0) { - h += y; - buf -= y * pitch; - y = 0; - } +void OSystem_PSP::grabOverlay(OverlayColor *buf, int pitch) { + DEBUG_ENTER_FUNC(); - if (w > _overlayWidth - x) { - w = _overlayWidth - x; - } + _overlay.copyToArray(buf, pitch); - if (h > _overlayHeight - y) { - h = _overlayHeight - y; - } - - if (w <= 0 || h <= 0) - return; + DEBUG_EXIT_FUNC(); +} +void OSystem_PSP::copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h) { + DEBUG_ENTER_FUNC(); - OverlayColor *dst = _overlayBuffer + (y * _overlayWidth + x); + _overlay.copyFromRect(buf, pitch, x, y, w, h); - if (_overlayWidth == pitch && pitch == w) { - memcpy(dst, buf, h * w * sizeof(OverlayColor)); - } else { - do { - memcpy(dst, buf, w * sizeof(OverlayColor)); - buf += pitch; - dst += _overlayWidth; - } while (--h); - } - sceKernelDcacheWritebackAll(); + DEBUG_EXIT_FUNC(); } int16 OSystem_PSP::getOverlayWidth() { - return _overlayWidth; + return (int16) _overlay.getWidth(); } int16 OSystem_PSP::getOverlayHeight() { - return _overlayHeight; + return (int16) _overlay.getHeight(); } - void OSystem_PSP::grabPalette(byte *colors, uint start, uint num) { - uint i; - uint16 color; - - for (i = start; i < start + num; i++) { - color = _palette[i]; - *colors++ = ((color & 0x1F) << 3); - *colors++ = (((color >> 5) & 0x1F) << 3); - *colors++ = (((color >> 10) & 0x1F) << 3); - *colors++ = (color & 0x8000 ? 255 : 0); - } + DEBUG_ENTER_FUNC(); + + _screen.getPartialPalette(colors, start, num); + + DEBUG_EXIT_FUNC(); } -bool OSystem_PSP::showMouse(bool visible) { - bool last = _mouseVisible; - _mouseVisible = visible; +bool OSystem_PSP::showMouse(bool v) { + DEBUG_ENTER_FUNC(); + + PSP_DEBUG_PRINT("%s\n", v ? "true" : "false"); + bool last = _cursor.isVisible(); + _cursor.setVisible(v); + + DEBUG_EXIT_FUNC(); + return last; } void OSystem_PSP::warpMouse(int x, int y) { - //assert(x > 0 && x < _screenWidth); - //assert(y > 0 && y < _screenHeight); - _mouseX = x; - _mouseY = y; -} + DEBUG_ENTER_FUNC(); -void OSystem_PSP::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) { - //TODO: handle cursorTargetScale - _mouseWidth = w; - _mouseHeight = h; - - _mouseHotspotX = hotspotX; - _mouseHotspotY = hotspotY; - - _mouseKeyColour = keycolor & 0xFF; - - memcpy(mouseClut, _palette, 256 * sizeof(unsigned short)); - mouseClut[_mouseKeyColour] = 0; - - for (unsigned int i = 0; i < h; i++) - memcpy(_mouseBuf + i * MOUSE_SIZE, buf + i * w, w); - - sceKernelDcacheWritebackAll(); + _cursor.setXY(x,y); + + DEBUG_EXIT_FUNC(); } -#define PAD_CHECK_TIME 40 -#define PAD_DIR_MASK (PSP_CTRL_UP | PSP_CTRL_DOWN | PSP_CTRL_LEFT | PSP_CTRL_RIGHT) - -bool OSystem_PSP::processInput(Common::Event &event) { - s8 analogStepAmountX = 0; - s8 analogStepAmountY = 0; - - sceCtrlSetSamplingCycle(0); - sceCtrlSetSamplingMode(1); - sceCtrlReadBufferPositive(&pad, 1); - - bool usedInput, haveEvent; - - haveEvent = _keyboard->processInput(event, pad, usedInput); - - if (usedInput) // Check if the keyboard used up the input - return haveEvent; - - uint32 buttonsChanged = pad.Buttons ^ _prevButtons; - - int newDpadX = 0, newDpadY = 0; - event.kbd.ascii = 0; - event.kbd.flags = 0; - - if (pad.Buttons & PSP_CTRL_UP) { - newDpadY += 1; - if (pad.Buttons & PSP_CTRL_RTRIGGER) - newDpadX += 1; - } - if (pad.Buttons & PSP_CTRL_RIGHT) { - newDpadX += 1; - if (pad.Buttons & PSP_CTRL_RTRIGGER) - newDpadY -= 1; - } - if (pad.Buttons & PSP_CTRL_DOWN) { - newDpadY -= 1; - if (pad.Buttons & PSP_CTRL_RTRIGGER) - newDpadX -= 1; - } - if (pad.Buttons & PSP_CTRL_LEFT) { - newDpadX -= 1; - if (pad.Buttons & PSP_CTRL_RTRIGGER) - newDpadY += 1; - } - //fprintf(stderr, "x=%d, y=%d, oldx=%d, oldy=%d\n", newDpadX, newDpadY, _dpadX, _dpadY); - if (newDpadX != _dpadX || newDpadY != _dpadY) { - if (_dpadX == 0 && _dpadY == 0) {// We pressed dpad - event.type = Common::EVENT_KEYDOWN; - event.kbd.keycode = getDpadEvent(newDpadX, newDpadY); - event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0'; - _dpadX = newDpadX; - _dpadY = newDpadY; - } - else if (newDpadX == 0 && newDpadY == 0) {// We unpressed dpad - event.type = Common::EVENT_KEYUP; - event.kbd.keycode = getDpadEvent(_dpadX, _dpadY); - event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0'; - _dpadX = newDpadX; - _dpadY = newDpadY; - } else { // we moved from one pressed dpad to another one - event.type = Common::EVENT_KEYUP; // first release the last dpad direction - event.kbd.keycode = getDpadEvent(_dpadX, _dpadY); - event.kbd.ascii = event.kbd.keycode - Common::KEYCODE_KP0 + '0'; - _dpadX = 0; // so that we'll pick up a new dpad movement - _dpadY = 0; - } - - _prevButtons = pad.Buttons; - return true; - - } else if (buttonsChanged & (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER | PSP_CTRL_START | - PSP_CTRL_SELECT | PSP_CTRL_SQUARE | PSP_CTRL_TRIANGLE)) { - if (buttonsChanged & PSP_CTRL_CROSS) { - event.type = (pad.Buttons & PSP_CTRL_CROSS) ? Common::EVENT_LBUTTONDOWN : Common::EVENT_LBUTTONUP; - } else if (buttonsChanged & PSP_CTRL_CIRCLE) { - event.type = (pad.Buttons & PSP_CTRL_CIRCLE) ? Common::EVENT_RBUTTONDOWN : Common::EVENT_RBUTTONUP; - } else { - //any of the other buttons. - event.type = buttonsChanged & pad.Buttons ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP; - - if (buttonsChanged & PSP_CTRL_LTRIGGER) { - event.kbd.keycode = Common::KEYCODE_ESCAPE; - event.kbd.ascii = 27; - } else if (buttonsChanged & PSP_CTRL_START) { - event.kbd.keycode = Common::KEYCODE_F5; - event.kbd.ascii = Common::ASCII_F5; - if (pad.Buttons & PSP_CTRL_RTRIGGER) { - event.kbd.flags = Common::KBD_CTRL; // Main menu to allow RTL - } -/* } else if (buttonsChanged & PSP_CTRL_SELECT) { - event.kbd.keycode = Common::KEYCODE_0; - event.kbd.ascii = '0'; -*/ } else if (buttonsChanged & PSP_CTRL_SQUARE) { - event.kbd.keycode = Common::KEYCODE_PERIOD; - event.kbd.ascii = '.'; - } else if (buttonsChanged & PSP_CTRL_TRIANGLE) { - event.kbd.keycode = Common::KEYCODE_RETURN; - event.kbd.ascii = 13; - } else if (pad.Buttons & PSP_CTRL_RTRIGGER) { - event.kbd.flags |= Common::KBD_SHIFT; - } - - } - - event.mouse.x = _mouseX; - event.mouse.y = _mouseY; - _prevButtons = pad.Buttons; - return true; - } - - uint32 time = getMillis(); - if (time - _lastPadCheck > PAD_CHECK_TIME) { - _lastPadCheck = time; - int16 newX = _mouseX; - int16 newY = _mouseY; - - if (pad.Lx < 100) { - analogStepAmountX = pad.Lx - 100; - } else if (pad.Lx > 155) { - analogStepAmountX = pad.Lx - 155; - } - - if (pad.Ly < 100) { - analogStepAmountY = pad.Ly - 100; - } else if (pad.Ly > 155) { - analogStepAmountY = pad.Ly - 155; - } - - if (analogStepAmountX != 0 || analogStepAmountY != 0) { - - _prevButtons = pad.Buttons; - - // If no movement then this has no effect - if (pad.Buttons & PSP_CTRL_RTRIGGER) { - // Fine control mode for analog - if (analogStepAmountX != 0) { - if (analogStepAmountX > 0) - newX += 1; - else - newX -= 1; - } - - if (analogStepAmountY != 0) { - if (analogStepAmountY > 0) - newY += 1; - else - newY -= 1; - } - } else { - newX += analogStepAmountX >> ((_screenWidth == 640) ? 2 : 3); - newY += analogStepAmountY >> ((_screenWidth == 640) ? 2 : 3); - } - - if (newX < 0) - newX = 0; - if (newY < 0) - newY = 0; - if (_overlayVisible) { - if (newX >= _overlayWidth) - newX = _overlayWidth - 1; - if (newY >= _overlayHeight) - newY = _overlayHeight - 1; - } else { - if (newX >= _screenWidth) - newX = _screenWidth - 1; - if (newY >= _screenHeight) - newY = _screenHeight - 1; - } - - if ((_mouseX != newX) || (_mouseY != newY)) { - event.type = Common::EVENT_MOUSEMOVE; - event.mouse.x = _mouseX = newX; - event.mouse.y = _mouseY = newY; - return true; - } - } - } - - return false; -} +void OSystem_PSP::setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format) { + DEBUG_ENTER_FUNC(); -inline Common::KeyCode OSystem_PSP::getDpadEvent(int x, int y) { - Common::KeyCode key; - - if (x == -1) { - if (y == -1) - key = Common::KEYCODE_KP1; - else if (y == 0) - key = Common::KEYCODE_KP4; - else /* y == 1 */ - key = Common::KEYCODE_KP7; - } else if (x == 0) { - if (y == -1) - key = Common::KEYCODE_KP2; - else /* y == 1 */ - key = Common::KEYCODE_KP8; - } else {/* x == 1 */ - if (y == -1) - key = Common::KEYCODE_KP3; - else if (y == 0) - key = Common::KEYCODE_KP6; - else /* y == 1 */ - key = Common::KEYCODE_KP9; + PSP_DEBUG_PRINT("pbuf[%p], w[%u], h[%u], hotspot:X[%d], Y[%d], keycolor[%d], scale[%d], pformat[%p]\n", buf, w, h, hotspotX, hotspotY, keycolor, cursorTargetScale, format); + if (format) { + PSP_DEBUG_PRINT("format: bpp[%d], rLoss[%d], gLoss[%d], bLoss[%d], aLoss[%d], rShift[%d], gShift[%d], bShift[%d], aShift[%d]\n", format->bytesPerPixel, format->rLoss, format->gLoss, format->bLoss, format->aLoss, format->rShift, format->gShift, format->bShift, format->aShift); } - - return key; + + _cursor.setKeyColor(keycolor); + _cursor.setCursorTargetScale(cursorTargetScale); + _cursor.setSizeAndScummvmPixelFormat(w, h, format); + _cursor.setHotspot(hotspotX, hotspotY); + _cursor.clearKeyColor(); + _cursor.copyFromArray(buf); + + DEBUG_EXIT_FUNC(); } bool OSystem_PSP::pollEvent(Common::Event &event) { @@ -905,8 +369,7 @@ bool OSystem_PSP::pollEvent(Common::Event &event) { PowerMan.pollPauseEngine(); - return processInput(event); - + return _inputHandler.getAllInputs(event); } @@ -997,7 +460,6 @@ void OSystem_PSP::setupMixer(void) { void OSystem_PSP::quit() { SDL_CloseAudio(); SDL_Quit(); - sceGuTerm(); sceKernelExitGame(); } diff --git a/backends/platform/psp/osys_psp.h b/backends/platform/psp/osys_psp.h index ed920e53c1..23eba870e9 100644 --- a/backends/platform/psp/osys_psp.h +++ b/backends/platform/psp/osys_psp.h @@ -32,139 +32,123 @@ #include "sound/mixer_intern.h" #include "backends/base-backend.h" #include "backends/fs/psp/psp-fs-factory.h" +#include "backends/platform/psp/display_client.h" +#include "backends/platform/psp/default_display_client.h" +#include "backends/platform/psp/cursor.h" #include "backends/platform/psp/pspkeyboard.h" +#include "backends/platform/psp/display_manager.h" +#include "backends/platform/psp/input.h" #include <SDL.h> -#include <pspctrl.h> - -enum GraphicModeID { - CENTERED_320X200, - CENTERED_435X272, - STRETCHED_480X272, - CENTERED_362X272 -}; - class OSystem_PSP : public BaseBackend { -public: - static const OSystem::GraphicsMode s_supportedGraphicsModes[]; - static OSystem *instance(); - -protected: - struct Vertex { - float u,v; - float x,y,z; - }; - - uint16 _screenWidth; - uint16 _screenHeight; - uint16 _overlayWidth; - uint16 _overlayHeight; - byte *_offscreen; - OverlayColor *_overlayBuffer; - uint16 _palette[256]; - bool _overlayVisible; - uint32 _shakePos; - uint32 _lastScreenUpdate; - - Graphics::Surface _framebuffer; - - bool _mouseVisible; - int _mouseX, _mouseY; - int _dpadX, _dpadY; - int _mouseWidth, _mouseHeight; - int _mouseHotspotX, _mouseHotspotY; - byte _mouseKeyColour; - byte *_mouseBuf; - bool _cursorPaletteDisabled; - - int _graphicMode; - unsigned short* _clut; - PSPKeyboard *_keyboard; - - uint32 _prevButtons; - uint32 _lastPadCheck; - uint32 _padAccel; - - SceCtrlData pad; - +private: + Common::SaveFileManager *_savefile; Audio::MixerImpl *_mixer; Common::TimerManager *_timer; - Common::KeyCode getDpadEvent(int x, int y); + // All needed sub-members + Screen _screen; + Overlay _overlay; + Cursor _cursor; + DisplayManager _displayManager; + PSPKeyboard _keyboard; + InputHandler _inputHandler; -public: - OSystem_PSP(); - virtual ~OSystem_PSP(); + void initSDL(); - virtual void initBackend(); - - virtual bool hasFeature(Feature f); - virtual void setFeatureState(Feature f, bool enable); - virtual bool getFeatureState(Feature f); +public: + OSystem_PSP() : _savefile(0), _mixer(0), _timer(0) {} + ~OSystem_PSP(); - virtual const GraphicsMode *getSupportedGraphicsModes() const; - virtual int getDefaultGraphicsMode() const; - virtual bool setGraphicsMode(int mode); + static OSystem *instance(); + + void initBackend(); + + // Feature related + bool hasFeature(Feature f); + void setFeatureState(Feature f, bool enable); + bool getFeatureState(Feature f); + + // Graphics related + const GraphicsMode *getSupportedGraphicsModes() const; + int getDefaultGraphicsMode() const; + bool setGraphicsMode(int mode); bool setGraphicsMode(const char *name); - virtual int getGraphicsMode() const; - - virtual void initSize(uint width, uint height, const Graphics::PixelFormat *format); - virtual int16 getWidth(); - virtual int16 getHeight(); - - virtual void setPalette(const byte *colors, uint start, uint num); - virtual void grabPalette(byte *colors, uint start, uint num); - virtual void setCursorPalette(const byte *colors, uint start, uint num); - virtual void disableCursorPalette(bool disable); - virtual void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h); - virtual Graphics::Surface *lockScreen(); - virtual void unlockScreen(); - virtual void updateScreen(); - virtual void setShakePos(int shakeOffset); - - virtual void showOverlay(); - virtual void hideOverlay(); - virtual void clearOverlay(); - virtual void grabOverlay(OverlayColor *buf, int pitch); - virtual void copyRectToOverlay(const OverlayColor *buf, int pitch, int x, int y, int w, int h); - virtual int16 getOverlayHeight(); - virtual int16 getOverlayWidth(); - virtual Graphics::PixelFormat getOverlayFormat() const { return Graphics::createPixelFormat<4444>(); } - - virtual bool showMouse(bool visible); - virtual void warpMouse(int x, int y); - virtual void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format); - - virtual bool pollEvent(Common::Event &event); - virtual bool processInput(Common::Event &event); - - virtual uint32 getMillis(); - virtual void delayMillis(uint msecs); - + int getGraphicsMode() const; +#ifdef USE_RGB_COLOR + virtual Graphics::PixelFormat getScreenFormat() const; + virtual Common::List<Graphics::PixelFormat> getSupportedFormats(); +#endif + + // Screen size + void initSize(uint width, uint height, const Graphics::PixelFormat *format); + int16 getWidth(); + int16 getHeight(); + + // Palette related + void setPalette(const byte *colors, uint start, uint num); + void grabPalette(byte *colors, uint start, uint num); + void setCursorPalette(const byte *colors, uint start, uint num); + void disableCursorPalette(bool disable); + + // Screen related + void copyRectToScreen(const byte *buf, int pitch, int x, int y, int w, int h); + Graphics::Surface *lockScreen(); + void unlockScreen(); + void updateScreen(); + void setShakePos(int shakeOffset); + + // Overlay related + 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 getOverlayHeight(); + int16 getOverlayWidth(); + Graphics::PixelFormat getOverlayFormat() const { return Graphics::createPixelFormat<4444>(); } + + // Mouse related + bool showMouse(bool visible); + void warpMouse(int x, int y); + void setMouseCursor(const byte *buf, uint w, uint h, int hotspotX, int hotspotY, uint32 keycolor, int cursorTargetScale, const Graphics::PixelFormat *format); + + // Events and input + bool pollEvent(Common::Event &event); + bool processInput(Common::Event &event); + + // Time + uint32 getMillis(); + void delayMillis(uint msecs); + + // Timer typedef int (*TimerProc)(int interval); - virtual void setTimerCallback(TimerProc callback, int interval); + void setTimerCallback(TimerProc callback, int interval); + Common::TimerManager *getTimerManager() { return _timer; } - virtual MutexRef createMutex(void); - virtual void lockMutex(MutexRef mutex); - virtual void unlockMutex(MutexRef mutex); - virtual void deleteMutex(MutexRef mutex); + // Mutex + MutexRef createMutex(void); + void lockMutex(MutexRef mutex); + void unlockMutex(MutexRef mutex); + void deleteMutex(MutexRef mutex); + // Sound static void mixCallback(void *sys, byte *samples, int len); - virtual void setupMixer(void); - - Common::SaveFileManager *getSavefileManager() { return _savefile; } + void setupMixer(void); Audio::Mixer *getMixer() { return _mixer; } - Common::TimerManager *getTimerManager() { return _timer; } + + // Misc + Common::SaveFileManager *getSavefileManager() { return _savefile; } FilesystemFactory *getFilesystemFactory() { return &PSPFilesystemFactory::instance(); } void getTimeAndDate(TimeDate &t) const; - virtual void quit(); + void quit(); - virtual Common::SeekableReadStream *createConfigReadStream(); - virtual Common::WriteStream *createConfigWriteStream(); -}; + Common::SeekableReadStream *createConfigReadStream(); + Common::WriteStream *createConfigWriteStream(); +}; #endif /* OSYS_PSP_H */ diff --git a/backends/platform/psp/powerman.cpp b/backends/platform/psp/powerman.cpp index 2f0086089c..b4391b0b8d 100644 --- a/backends/platform/psp/powerman.cpp +++ b/backends/platform/psp/powerman.cpp @@ -23,24 +23,23 @@ * */ +//#define __PSP_DEBUG_FUNCS__ /* can put this locally too */ +//#define __PSP_DEBUG_PRINT__ +#include "backends/platform/psp/trace.h" + #include <psppower.h> #include <pspthreadman.h> -#include "./powerman.h" -#include "./trace.h" +#include "backends/platform/psp/powerman.h" #include "engine.h" DECLARE_SINGLETON(PowerManager) -#ifdef __PSP_DEBUG_SUSPEND__ -void PowerManager::debugPM() { - PSPDebugTrace("PM status is %d. Listcount is %d. CriticalCount is %d. ThreadId is %x. Error = %d\n", _PMStatus, _listCounter, - _criticalCounter, sceKernelGetThreadId(), _error); +// Function to debug the Power Manager (we have no output to screen) +inline void PowerManager::debugPM() { + PSP_DEBUG_PRINT("PM status[%d]. Listcount[%d]. CriticalCount[%d]. ThreadId[%x]. Error[%d]\n", + _PMStatus, _listCounter, _criticalCounter, sceKernelGetThreadId(), _error); } -#else - #define debugPM() - #define PMStatusSet(x) -#endif /* __PSP_DEBUG_SUSPEND__ */ /******************************************* @@ -49,7 +48,8 @@ void PowerManager::debugPM() { * ********************************************/ PowerManager::PowerManager() { - + DEBUG_ENTER_FUNC(); + _flagMutex = NULL; /* Init mutex handle */ _listMutex = NULL; /* Init mutex handle */ _condSuspendable = NULL; /* Init condition variable */ @@ -57,33 +57,34 @@ PowerManager::PowerManager() { _condSuspendable = SDL_CreateCond(); if (_condSuspendable <= 0) { - PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condSuspendable\n"); + PSP_ERROR("Couldn't create Suspendable condition variable\n"); } _condPM = SDL_CreateCond(); if (_condPM <= 0) { - PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create condPM\n"); + PSP_ERROR("Couldn't create PM condition variable\n"); } _flagMutex = SDL_CreateMutex(); if (_flagMutex <= 0) { - PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create flagMutex\n"); + PSP_ERROR("Couldn't create flag Mutex\n"); } _listMutex = SDL_CreateMutex(); if (_listMutex <= 0) { - PSPDebugSuspend("PowerManager::PowerManager(): Couldn't create listMutex\n"); + PSP_ERROR("Couldn't create list Mutex\n"); } _suspendFlag = false; - _criticalCounter = 0; - _pauseFlag = 0; _pauseFlagOld = 0; _pauseClientState = 0; - -#ifdef __PSP_DEBUG_SUSPEND__ + _criticalCounter = 0; // How many are in the critical section + _pauseFlag = 0; + _pauseFlagOld = 0; + _pauseClientState = 0; _listCounter = 0; PMStatusSet(kInitDone); _error = 0; -#endif + + DEBUG_EXIT_FUNC(); } /******************************************* @@ -92,26 +93,24 @@ PowerManager::PowerManager() { * ********************************************/ int PowerManager::registerSuspend(Suspendable *item) { + DEBUG_ENTER_FUNC(); // Register in list - PSPDebugSuspend("In registerSuspend\n"); debugPM(); if (SDL_mutexP(_listMutex) != 0) { - PSPDebugTrace("PowerManager::registerSuspend(): Couldn't lock _listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't lock _listMutex[%p]\n", _listMutex); } _suspendList.push_front(item); -#ifdef __PSP_DEBUG_SUSPEND__ _listCounter++; -#endif if (SDL_mutexV(_listMutex) != 0) { - PSPDebugTrace("PowerManager::registerSuspend(): Couldn't unlock _listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex); } - - PSPDebugSuspend("Out of registerSuspend\n"); + debugPM(); + DEBUG_EXIT_FUNC(); return 0; } @@ -121,27 +120,25 @@ int PowerManager::registerSuspend(Suspendable *item) { * ********************************************/ int PowerManager::unregisterSuspend(Suspendable *item) { - - PSPDebugSuspend("In unregisterSuspend\n"); + DEBUG_ENTER_FUNC(); debugPM(); // Unregister from stream list if (SDL_mutexP(_listMutex) != 0) { - PSPDebugTrace("PowerManager::unregisterSuspend(): Couldn't unlock _listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex); } _suspendList.remove(item); -#ifdef __PSP_DEBUG_SUSPEND__ _listCounter--; -#endif if (SDL_mutexV(_listMutex) != 0) { - PSPDebugTrace("PowerManager::unregisterSuspend(): Couldn't unlock _listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't unlock _listMutex[%p]\n", _listMutex); } - PSPDebugSuspend("Out of unregisterSuspend\n"); + PSP_DEBUG_PRINT("Out of unregisterSuspend\n"); debugPM(); + DEBUG_EXIT_FUNC(); return 0; } @@ -151,10 +148,9 @@ int PowerManager::unregisterSuspend(Suspendable *item) { * ********************************************/ PowerManager::~PowerManager() { - -#ifdef __PSP_DEBUG_SUSPEND__ + DEBUG_ENTER_FUNC(); + PMStatusSet(kDestroyPM); -#endif SDL_DestroyCond(_condSuspendable); _condSuspendable = 0; @@ -167,6 +163,8 @@ int PowerManager::unregisterSuspend(Suspendable *item) { SDL_DestroyMutex(_listMutex); _listMutex = 0; + + DEBUG_EXIT_FUNC(); } /******************************************* @@ -184,14 +182,14 @@ void PowerManager::pollPauseEngine() { if ((pause != _pauseFlagOld) && g_engine) { // Check to see if we have an engine if (pause && _pauseClientState == PowerManager::Unpaused) { - _pauseClientState = PowerManager::Pausing; // Tell PM we're in the middle of pausing + _pauseClientState = PowerManager::Pausing; // Tell PM we're in the middle of pausing g_engine->pauseEngine(true); - PSPDebugSuspend("Pausing engine in PowerManager::pollPauseEngine()\n"); + PSP_DEBUG_PRINT_FUNC("Pausing engine\n"); _pauseClientState = PowerManager::Paused; // Tell PM we're done pausing } else if (!pause && _pauseClientState == PowerManager::Paused) { g_engine->pauseEngine(false); - PSPDebugSuspend("Unpausing for resume in PowerManager::pollPauseEngine()\n"); + PSP_DEBUG_PRINT_FUNC("Unpausing for resume\n"); _pauseClientState = PowerManager::Unpaused; // Tell PM we're in the middle of pausing } @@ -205,7 +203,7 @@ void PowerManager::pollPauseEngine() { * Use this for small critical sections where you can easily restore the previous state. * ********************************************/ - int PowerManager::blockOnSuspend() { +int PowerManager::blockOnSuspend() { return beginCriticalSection(true); } @@ -216,26 +214,28 @@ void PowerManager::pollPauseEngine() { * Make sure to call endCriticalSection or the PSP won't suspend. ********************************************/ - int PowerManager::beginCriticalSection(bool justBlock) { +int PowerManager::beginCriticalSection(bool justBlock) { + DEBUG_ENTER_FUNC(); + int ret = NotBlocked; if (SDL_mutexP(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't lock flagMutex %d\n", _flagMutex); + PSP_ERROR("PowerManager::blockOnSuspend(): Couldn't lock flagMutex[%p]\n", _flagMutex); ret = Error; } // Check the access flag if (_suspendFlag == true) { - PSPDebugSuspend("We're being blocked!\n"); + PSP_DEBUG_PRINT("We're being blocked!\n"); debugPM(); ret = Blocked; // If it's true, we wait for a signal to continue if (SDL_CondWait(_condSuspendable, _flagMutex) != 0) { - PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't wait on cond %d\n", _condSuspendable); + PSP_DEBUG_PRINT("PowerManager::blockOnSuspend(): Couldn't wait on cond[%p]\n", _condSuspendable); } - PSPDebugSuspend("We got blocked!!\n"); + PSP_DEBUG_PRINT("We got blocked!!\n"); debugPM(); } @@ -244,18 +244,20 @@ void PowerManager::pollPauseEngine() { _criticalCounter++; if (SDL_mutexV(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::blockOnSuspend(): Couldn't unlock flagMutex %d\n", _flagMutex); + PSP_ERROR("PowerManager::blockOnSuspend(): Couldn't unlock flagMutex[%p]\n", _flagMutex); ret = Error; } + DEBUG_EXIT_FUNC(); return ret; } int PowerManager::endCriticalSection() { + DEBUG_ENTER_FUNC(); int ret = 0; if (SDL_mutexP(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::endCriticalSection(): Couldn't lock flagMutex %d\n", _flagMutex); + PSP_ERROR("PowerManager::endCriticalSection(): Couldn't lock flagMutex[%p]\n", _flagMutex); ret = Error; } @@ -264,26 +266,27 @@ int PowerManager::endCriticalSection() { if (_criticalCounter <= 0) { if (_suspendFlag == true) { // If the PM is sleeping, this flag must be set - PSPDebugSuspend("Unblocked thread waking up the PM.\n"); + PSP_DEBUG_PRINT("Unblocked thread waking up the PM.\n"); debugPM(); SDL_CondBroadcast(_condPM); - PSPDebugSuspend("Woke up the PM\n"); + PSP_DEBUG_PRINT("Woke up the PM\n"); debugPM(); } if (_criticalCounter < 0) { // Check for bad usage of critical sections - PSPDebugTrace("PowerManager::endCriticalSection(): Error! Critical counter is %d\n", _criticalCounter); + PSP_ERROR("Critical counter[%d]\n", _criticalCounter); debugPM(); } } if (SDL_mutexV(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::endCriticalSection(): Couldn't unlock flagMutex %d\n", _flagMutex); + PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex); ret = Error; } + DEBUG_EXIT_FUNC(); return ret; } @@ -293,6 +296,7 @@ int PowerManager::endCriticalSection() { * ********************************************/ int PowerManager::suspend() { + DEBUG_ENTER_FUNC(); int ret = 0; if (_pauseFlag) return ret; // Very important - make sure we only suspend once @@ -325,7 +329,7 @@ int PowerManager::suspend() { // Now we set the suspend flag to true to cause reading threads to block if (SDL_mutexP(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::suspend(): Couldn't lock flagMutex %d\n", _flagMutex); + PSP_ERROR("Couldn't lock flagMutex[%p]\n", _flagMutex); _error = Error; ret = Error; } @@ -342,7 +346,7 @@ int PowerManager::suspend() { } if (SDL_mutexV(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::suspend(): Couldn't unlock flagMutex %d\n", _flagMutex); + PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex); _error = Error; ret = Error; } @@ -351,22 +355,22 @@ int PowerManager::suspend() { // Loop over list, calling suspend() if (SDL_mutexP(_listMutex) != 0) { - PSPDebugTrace("PowerManager::suspend(): Couldn't lock listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't lock listMutex[%p]\n", _listMutex); _error = Error; ret = Error; } PMStatusSet(kIteratingListSuspend); // Iterate - Common::List<Suspendable *>::iterator i = _suspendList.begin(); + Common::List<Suspendable *>::iterator i; - for (; i != _suspendList.end(); ++i) { + for (i = _suspendList.begin(); i != _suspendList.end(); ++i) { (*i)->suspend(); } PMStatusSet(kDoneIteratingListSuspend); if (SDL_mutexV(_listMutex) != 0) { - PSPDebugTrace("PowerManager::suspend(): Couldn't unlock listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't unlock listMutex[%p]\n", _listMutex); _error = Error; ret = Error; } @@ -374,6 +378,7 @@ int PowerManager::suspend() { scePowerUnlock(0); // Allow the PSP to go to sleep now + DEBUG_EXIT_FUNC(); return ret; } @@ -383,6 +388,7 @@ int PowerManager::suspend() { * ********************************************/ int PowerManager::resume() { + DEBUG_ENTER_FUNC(); int ret = 0; // Make sure we can't get another suspend @@ -394,7 +400,7 @@ int PowerManager::resume() { // First we notify our Suspendables. Loop over list, calling resume() if (SDL_mutexP(_listMutex) != 0) { - PSPDebugTrace("PowerManager::resume(): Couldn't lock listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't lock listMutex[%p]\n", _listMutex); _error = Error; ret = Error; } @@ -409,7 +415,7 @@ int PowerManager::resume() { PMStatusSet(kDoneIteratingListResume); if (SDL_mutexV(_listMutex) != 0) { - PSPDebugTrace("PowerManager::resume(): Couldn't unlock listMutex %d\n", _listMutex); + PSP_ERROR("Couldn't unlock listMutex[%p]\n", _listMutex); _error = Error; ret = Error; } @@ -418,7 +424,7 @@ int PowerManager::resume() { // Now we set the suspend flag to false if (SDL_mutexP(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::resume(): Couldn't lock flagMutex %d\n", _flagMutex); + PSP_ERROR("Couldn't lock flagMutex %p\n", _flagMutex); _error = Error; ret = Error; } @@ -430,14 +436,14 @@ int PowerManager::resume() { // Signal the other threads to wake up if (SDL_CondBroadcast(_condSuspendable) != 0) { - PSPDebugTrace("PowerManager::resume(): Couldn't broadcast condition %d\n", _condSuspendable); + PSP_ERROR("Couldn't broadcast condition[%p]\n", _condSuspendable); _error = Error; ret = Error; } PMStatusSet(kDoneSignallingSuspendedThreadsResume); if (SDL_mutexV(_flagMutex) != 0) { - PSPDebugTrace("PowerManager::resume(): Couldn't unlock flagMutex %d\n", _flagMutex); + PSP_ERROR("Couldn't unlock flagMutex[%p]\n", _flagMutex); _error = Error; ret = Error; } @@ -447,5 +453,6 @@ int PowerManager::resume() { scePowerUnlock(0); // Allow new suspends + DEBUG_EXIT_FUNC(); return ret; } diff --git a/backends/platform/psp/powerman.h b/backends/platform/psp/powerman.h index 78c403fa5c..4a9167f2bf 100644 --- a/backends/platform/psp/powerman.h +++ b/backends/platform/psp/powerman.h @@ -118,7 +118,6 @@ public: kDoneSignallingSuspendedThreadsResume, kDoneResume }; -#ifdef __PSP_DEBUG_SUSPEND__ volatile int _listCounter; /* How many people are in the list - just for debugging */ @@ -129,11 +128,9 @@ public: public: int getPMStatus() { return _PMStatus; } -#endif /* __PSP_DEBUG_SUSPEND__ */ - }; // For easy access #define PowerMan PowerManager::instance() - #endif /* POWERMAN_H */ +#endif /* POWERMAN_H */ diff --git a/backends/platform/psp/psp_main.cpp b/backends/platform/psp/psp_main.cpp index 581f6234b4..c3770cb41f 100644 --- a/backends/platform/psp/psp_main.cpp +++ b/backends/platform/psp/psp_main.cpp @@ -26,8 +26,10 @@ #define USERSPACE_ONLY //don't use kernel mode features #ifndef USERSPACE_ONLY -#include <pspkernel.h> -#include <pspdebug.h> + #include <pspkernel.h> + #include <pspdebug.h> +#else + #include <pspuser.h> #endif #include <psppower.h> @@ -118,10 +120,10 @@ int CallbackThread(SceSize /*size*/, void *arg) { cbid = sceKernelCreateCallback("Power Callback", (SceKernelCallbackFunction)power_callback, 0); if (cbid >= 0) { if (scePowerRegisterCallback(-1, cbid) < 0) { - PSPDebugTrace("SetupCallbacks(): Couldn't register callback for power_callback\n"); + PSP_ERROR("Couldn't register callback for power_callback\n"); } } else { - PSPDebugTrace("SetupCallbacks(): Couldn't create a callback for power_callback\n"); + PSP_ERROR("Couldn't create a callback for power_callback\n"); } sceKernelSleepThreadCB(); @@ -167,4 +169,3 @@ int main(void) { return res; } - diff --git a/backends/platform/psp/pspkeyboard.cpp b/backends/platform/psp/pspkeyboard.cpp index be8b98a3f8..d6fa0621b9 100644 --- a/backends/platform/psp/pspkeyboard.cpp +++ b/backends/platform/psp/pspkeyboard.cpp @@ -24,16 +24,19 @@ */ //#define PSP_KB_SHELL /* Need a hack to properly load the keyboard from the PSP shell */ + #ifdef PSP_KB_SHELL -#define PSP_KB_SHELL_PATH "ms0:/psp/game4xx/scummvm-1.0.0rc1/" /* path to kbd.zip */ + #define PSP_KB_SHELL_PATH "ms0:/psp/game4xx/scummvm-solid/" /* path to kbd.zip */ #endif -//#define PSP_KB_DEBUG +//#define __PSP_DEBUG_FUNCS__ /* For debugging the stack */ +//#define __PSP_DEBUG_PRINT__ + +#include "backends/platform/psp/trace.h" #include <malloc.h> #include "pspkernel.h" -#include <pspgu.h> #include "png.h" -#include "pspkeyboard.h" +#include "backends/platform/psp/pspkeyboard.h" #include "common/keyboard.h" #include "common/fs.h" #include "common/unzip.h" @@ -94,314 +97,145 @@ void pngReadStreamRead(png_structp png_ptr, png_bytep data, png_size_t length) { file->read(data, length); } +// Array with file names +const char *PSPKeyboard::_guiStrings[] = { + "keys4.png", "keys_s4.png", + "keys_c4.png", "keys_s_c4.png", + "nums4.png", "nums_s4.png", + "syms4.png", "syms_s4.png" +}; + // Constructor PSPKeyboard::PSPKeyboard() { + DEBUG_ENTER_FUNC(); + _init = false; // we're not initialized yet _prevButtons = 0; // Reset previous buttons - _dirty = true; // keyboard needs redrawing - _mode = 0; // charset selected. (0 - letters, 1 - uppercase 2 - numbers 3 - symbols) + _dirty = false; // keyboard needs redrawing + _mode = 0; // charset selected. (0: letters, 1: uppercase 2: numbers 3: symbols) _oldCursor = kCenter; // Center cursor by default - _moved_x = 20; // Default starting location - _moved_y = 50; + _movedX = 20; // Default starting location + _movedY = 50; _moved = false; // Keyboard wasn't moved recently _state = kInvisible; // We start invisible _lastState = kInvisible; + + // Constant renderer settings + _renderer.setAlphaBlending(true); + _renderer.setColorTest(false); + _renderer.setUseGlobalScaler(false); + + DEBUG_EXIT_FUNC(); } // Destructor PSPKeyboard::~PSPKeyboard() { - if (!_init) return; - - int a; - for (a = 0; a < guiStringsSize; a++) { - free(_keyTextures[a].texture); - free(_keyTextures[a].palette); - _keyTextures[a].texture = NULL; - _keyTextures[a].palette = NULL; + DEBUG_ENTER_FUNC(); + + if (!_init) { + DEBUG_EXIT_FUNC(); + return; + } + + for (int i = 0; i < guiStringsSize; i++) { + _buffers[i].deallocate(); + _palettes[i].deallocate(); } _init = false; + + DEBUG_EXIT_FUNC(); } -// Array with file names -const char *PSPKeyboard::_guiStrings[] = { - "keys4.png", "keys_s4.png", - "keys_c4.png", "keys_s_c4.png", - "nums4.png", "nums_s4.png", - "syms4.png", "syms_s4.png" -}; - -// Defines for working with PSP buttons -#define CHANGED(x) (buttonsChanged & (x)) -#define PRESSED(x) ((buttonsChanged & (x)) && (pad.Buttons & (x))) -#define UNPRESSED(x) ((buttonsChanged & (x)) && !(pad.Buttons & (x))) -#define DOWN(x) (pad.Buttons & (x)) -#define UP(x) (!(pad.Buttons & (x))) -#define PSP_DPAD (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT) -#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE) - -/* - * Attempts to read a character from the controller - * Uses the state machine. - */ -bool PSPKeyboard::processInput(Common::Event &event, SceCtrlData &pad, bool &usedInput) { - usedInput = false; // Assume we don't use an input - bool haveEvent = false; // Whether we have an event for the event manager to process - event.kbd.flags = 0; - unsigned int keyDown; - uint32 buttonsChanged = _prevButtons ^ pad.Buttons; - - if (!_init) // In case we never had init - goto END; - - if (PRESSED(PSP_CTRL_SELECT)) { +void PSPKeyboard::setVisible(bool val) { + if (val && _state == kInvisible && _init) { // Check also that were loaded correctly _lastState = _state; - _state = kMove; // Check for move or visible state - usedInput = true; - goto END; - } - - if (_state == kInvisible) // Return if we're invisible - goto END; - - if (DOWN(PSP_DPAD | PSP_4BUTTONS | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER | PSP_CTRL_START)) - usedInput = true; // for now, we neutralize all button inputs - - // Check for moving the keyboard onscreen - if (_state == kMove) { - if (UNPRESSED(PSP_CTRL_SELECT)) { - _state = (_lastState == kInvisible) ? kDefault : kInvisible; // Back to previous state - _dirty = true; - - if (_moved) { // We moved the keyboard. Keep the keyboard onscreen - _state = kDefault; - _moved = false; // reset moved flag - } - } - else if (DOWN(PSP_DPAD)) { - _moved = true; - _dirty = true; - - if (DOWN(PSP_CTRL_DOWN)) - increaseKeyboardLocationY(5); - else if (DOWN(PSP_CTRL_UP)) - increaseKeyboardLocationY(-5); - else if (DOWN(PSP_CTRL_LEFT)) - increaseKeyboardLocationX(-5); - else /* DOWN(PSP_CTRL_RIGHT) */ - increaseKeyboardLocationX(5); - } - usedInput = true; // We used up the input (select was held down) - goto END; - } - - - // Handle 4 buttons + 2 triggers - if (_state == kDefault || _state == kCornersSelected) { - unsigned int changed; - - if (_state == kDefault) { // Handle default state - changed = CHANGED(PSP_4BUTTONS); // We only care about the 4 buttons - if (PRESSED(PSP_CTRL_LTRIGGER)) { // Don't say we used up the input - _state = kLTriggerDown; - goto END; - } - else if (PRESSED(PSP_CTRL_RTRIGGER)) { // Don't say we used up the input - _state = kRTriggerDown; - goto END; - } - - if (DOWN(PSP_4BUTTONS)) - usedInput = true; // Make sure these button presses don't get through - } else { /* _state == kCornersSelected */ - // We care about 4 buttons + triggers (for letter selection) - changed = CHANGED(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER); - - if (DOWN(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER)) - usedInput = true; // Make sure these button presses don't get through - } - - if (changed) { //pressing a char select button -- both states - - int innerChoice; - - if (UNPRESSED(PSP_CTRL_TRIANGLE)) { - innerChoice = 0; - event.type = Common::EVENT_KEYUP; // We give priority to key_up - } else if (UNPRESSED(PSP_CTRL_CIRCLE)) { - innerChoice = 1; - event.type = Common::EVENT_KEYUP; // We give priority to key_up - } else if (UNPRESSED(PSP_CTRL_CROSS)) { - innerChoice = 2; - event.type = Common::EVENT_KEYUP; // We give priority to key_up - } else if (UNPRESSED(PSP_CTRL_SQUARE)) { - innerChoice = 3; - event.type = Common::EVENT_KEYUP; // We give priority to key_up - } else if (UNPRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) { - innerChoice = 4; - event.type = Common::EVENT_KEYUP; // We give priority to key_up - } else if (UNPRESSED(PSP_CTRL_RTRIGGER) && _state == kCornersSelected) { - innerChoice = 5; - event.type = Common::EVENT_KEYUP; // We give priority to key_up - } else if (PRESSED(PSP_CTRL_TRIANGLE)) { - innerChoice = 0; - event.type = Common::EVENT_KEYDOWN; - } else if (PRESSED(PSP_CTRL_CIRCLE)) { - innerChoice = 1; - event.type = Common::EVENT_KEYDOWN; - } else if (PRESSED(PSP_CTRL_CROSS)) { - innerChoice = 2; - event.type = Common::EVENT_KEYDOWN; - } else if (PRESSED(PSP_CTRL_SQUARE)) { - innerChoice = 3; - event.type = Common::EVENT_KEYDOWN; - } else if (PRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) { - innerChoice = 4; - event.type = Common::EVENT_KEYDOWN; // We give priority to key_up - } else /* (UNPRESSED(PSP_CTRL_RTRIGGER)) && _state == kCornersSelected */ { - innerChoice = 5; - event.type = Common::EVENT_KEYDOWN; // We give priority to key_up - } - - #define IS_UPPERCASE(x) ((x) >= (unsigned short)'A' && (x) <= (unsigned short)'Z') - #define TO_LOWER(x) ((x) += 'a'-'A') - - //Now grab the value out of the array - short choice = _modeChar[_mode][_oldCursor][innerChoice]; - - event.kbd.ascii = choice <= 255 ? choice : 0; - - // Handle upper-case which is missing in Common::KeyCode - if (IS_UPPERCASE(choice)) { - event.kbd.keycode = (Common::KeyCode) TO_LOWER(choice); - event.kbd.flags = Common::KBD_SHIFT; - } else - event.kbd.keycode = (Common::KeyCode) choice; - - haveEvent = (choice != Common::KEYCODE_INVALID) ? true : false; // We have an event/don't if it's invalid - usedInput = true; - } - } - - // Check for movement of cursor - if (_state == kDefault || _state == kCornersSelected) { - // Check if a dependent button is down - if (_state == kDefault) - keyDown = DOWN(PSP_4BUTTONS); - else /* if (_state == kCornersSelected) */ - keyDown = DOWN(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER); - - Cursor cursor = _oldCursor; - - // Find where the cursor is pointing - if (keyDown == false) { // Don't allow movement if a nub-dependent key is down - cursor = kCenter; - _state = kDefault; - - if (DOWN(PSP_DPAD)) { - _state = kCornersSelected; - usedInput = true; // Make sure the pressed d-pad is used up - - if (DOWN(PSP_CTRL_UP)) - cursor = kUp; - else if (DOWN(PSP_CTRL_RIGHT)) - cursor = kRight; - else if (DOWN(PSP_CTRL_DOWN)) - cursor = kDown; - else if (DOWN(PSP_CTRL_LEFT)) - cursor = kLeft; - } - } - - if (cursor != _oldCursor) { //If we've moved, update dirty and return - _dirty = true; - _oldCursor = cursor; - usedInput = true; // We 'used up' the input - //goto END; // We didn't find an event - } - } - - // Deal with trigger states - if (_state == kRTriggerDown) { - usedInput = true; - - if (UNPRESSED(PSP_CTRL_RTRIGGER)) { - _dirty = true; - - if(_mode > 1) - _mode = 0; - else - _mode = (_mode == 0) ? 1 : 0; - - usedInput = true; - _state = kDefault; - - goto END; - } - } else if (_state == kLTriggerDown) { - usedInput = true; - - if (UNPRESSED(PSP_CTRL_LTRIGGER)) { - _dirty = true; - - if(_mode < 2) - _mode = 2; - else - _mode = (_mode == 2) ? 3 : 2; - - usedInput = true; - _state = kDefault; - - goto END; - } + _state = kMove; } - - // Handle start button: enter plus make keyboard invisible - if (CHANGED(PSP_CTRL_START)) { - event.kbd.ascii = '\n'; - event.kbd.keycode = Common::KEYCODE_RETURN; - event.type = DOWN(PSP_CTRL_START) ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP; - usedInput = true; // Don't let start get through - haveEvent = true; - if (UP(PSP_CTRL_START)) - _state = kInvisible; // Make us invisible if unpressed + else if ( !val && _state != kInvisible) { + _lastState = _state; + _state = kInvisible; } - -END: - _prevButtons = pad.Buttons; - return haveEvent; + setDirty(); } - /* move the position the keyboard is currently drawn at */ void PSPKeyboard::moveTo(const int newX, const int newY) { - _moved_x = newX; - _moved_y = newY; + DEBUG_ENTER_FUNC(); + + _movedX = newX; + _movedY = newY; + setDirty(); + + DEBUG_EXIT_FUNC(); } /* move the position the keyboard is currently drawn at */ void PSPKeyboard::increaseKeyboardLocationX(int amount) { - int newX = _moved_x + amount; + DEBUG_ENTER_FUNC(); + + int newX = _movedX + amount; - if (newX > PSP_SCREEN_WIDTH - 5 || newX < 0 - 140) // clamp + if (newX > PSP_SCREEN_WIDTH - 5 || newX < 0 - 140) { // clamp + DEBUG_EXIT_FUNC(); return; - _moved_x = newX; + } + _movedX = newX; + setDirty(); + + DEBUG_EXIT_FUNC(); } /* move the position the keyboard is currently drawn at */ void PSPKeyboard::increaseKeyboardLocationY(int amount) { - int newY = _moved_y + amount; + DEBUG_ENTER_FUNC(); + + int newY = _movedY + amount; - if (newY > PSP_SCREEN_HEIGHT - 5 || newY < 0 - 140) // clamp + if (newY > PSP_SCREEN_HEIGHT - 5 || newY < 0 - 140) { // clamp + DEBUG_EXIT_FUNC(); return; - _moved_y = newY; + } + _movedY = newY; + setDirty(); + + DEBUG_EXIT_FUNC(); } /* draw the keyboard at the current position */ void PSPKeyboard::render() { - _dirty = false; + DEBUG_ENTER_FUNC(); + + unsigned int currentBuffer = _mode<<1; + + // Draw the background letters + // Set renderer to current buffer & palette + _renderer.setBuffer(&_buffers[currentBuffer]); + _renderer.setPalette(&_palettes[currentBuffer]); + _renderer.setOffsetOnScreen(_movedX, _movedY); + _renderer.setOffsetInBuffer(0, 0); + _renderer.setDrawWholeBuffer(); + _renderer.render(); + + // Get X and Y coordinates for the orange block int x, y; + convertCursorToXY(_oldCursor, x, y); + + const int OrangeBlockSize = 64; + const int GrayBlockSize = 43; + + // Draw the current Highlighted Selector (orange block) + _renderer.setBuffer(&_buffers[currentBuffer + 1]); + _renderer.setPalette(&_palettes[currentBuffer + 1]); + _renderer.setOffsetOnScreen(_movedX + (x * GrayBlockSize), _movedY + (y * GrayBlockSize)); + _renderer.setOffsetInBuffer(x * OrangeBlockSize, y * OrangeBlockSize); + _renderer.setDrawSize(OrangeBlockSize, OrangeBlockSize); + _renderer.render(); + + DEBUG_EXIT_FUNC(); +} - switch(_oldCursor) { +inline void PSPKeyboard::convertCursorToXY(CursorDirections cur, int &x, int &y) { + switch(cur) { case kUp: x = 1; y = 0; @@ -423,76 +257,17 @@ void PSPKeyboard::render() { y = 1; break; } - - // Draw the background letters - surface_draw_offset(&_keyTextures[_mode<<1], 0, 0, 0, 0, - _keyTextures[_mode<<1].texture_width, - _keyTextures[_mode<<1].texture_height); - - // Draw the current Highlighted Selector (orange bit) - surface_draw_offset(&_keyTextures[(_mode<<1) + 1], - //Offset from the current draw position to render at - x * 43, y * 43, - //internal offset of the image - x * 64, y * 64, - //size to render (always the same) - 64, 64); -} - - -// Render the given surface at the current screen position offset by screenX, screenY -// the surface will be internally offset by offsetX,offsetY. And the size of it to be drawn will be intWidth,intHeight -void PSPKeyboard::surface_draw_offset(struct gu_surface* surface, int screenX, int screenY, int offsetX, int offsetY, int intWidth, int intHeight) { - sceGuAlphaFunc( GU_GREATER, 0, 0xff ); - sceGuEnable( GU_ALPHA_TEST ); - sceGuTexFunc(GU_TFX_BLEND,GU_TCC_RGBA); - sceGuTexEnvColor(0xFF000000); - sceGuBlendFunc(GU_ADD, GU_SRC_ALPHA, GU_ONE_MINUS_SRC_ALPHA, 0, 0 ); - sceGuEnable(GU_BLEND); - if (surface->paletteSize == 256) { // 8-bit - sceGuClutMode(GU_PSM_8888, 0, 0xFF, 0); - sceGuClutLoad(32, surface->palette); // upload 32*8 entries (256) - sceGuTexMode(GU_PSM_T8, 0, 0, 0); // 8-bit image - } else if (surface->paletteSize == 16) { // 4-bit - sceGuClutMode(GU_PSM_8888, 0, 0x0F, 0); - sceGuClutLoad(2, surface->palette); // upload 2*8 entries (16) - sceGuTexMode(GU_PSM_T4, 0, 0, 0); // 4-bit image - } else { // 32-bit - sceGuTexMode(GU_PSM_8888,0,0,GU_FALSE); - } - sceGuTexImage(0,surface->surface_width, surface->surface_height,surface->surface_width, surface->texture); - sceGuTexFunc(GU_TFX_MODULATE,GU_TCC_RGBA); - - Vertex* c_vertices = (Vertex*)sceGuGetMemory(2 * sizeof(Vertex)); - - c_vertices[0].u = offsetX; - c_vertices[0].v = offsetY; - c_vertices[0].x = _moved_x + screenX; - c_vertices[0].y = _moved_y + screenY; - c_vertices[0].z = 0; - c_vertices[0].color = 0xFFFFFFFF; - - c_vertices[1].u = offsetX + intWidth; - c_vertices[1].v = offsetY + intHeight; - c_vertices[1].x = _moved_x + screenX + intWidth; - c_vertices[1].y = _moved_y + screenY + intHeight; - c_vertices[1].z = 0; - c_vertices[1].color = 0xFFFFFFFF; - - sceGuDrawArray(GU_SPRITES,GU_TEXTURE_32BITF|GU_COLOR_8888|GU_VERTEX_32BITF|GU_TRANSFORM_2D,2,0,c_vertices); - - sceGuDisable( GU_BLEND ); - sceGuDisable( GU_ALPHA_TEST ); } -/* load all the guibits that make up the OSK */ +/* load the keyboard into memory */ bool PSPKeyboard::load() { - unsigned char *temp_texture = NULL; - uint32 *temp_palette = NULL; - int a; + DEBUG_ENTER_FUNC(); - if (_init) + if (_init) { + PSP_DEBUG_PRINT("keyboard already loaded into memory\n"); + DEBUG_EXIT_FUNC(); return true; + } // For the shell, we must use a hack #ifdef PSP_KB_SHELL @@ -500,221 +275,131 @@ bool PSPKeyboard::load() { #else /* normal mode */ Common::FSNode node("."); // Look in current directory #endif -#ifdef PSP_KB_DEBUG - fprintf(stderr, "path = %s\n", node.getPath().c_str()); -#endif + PSP_DEBUG_PRINT("path[%s]\n", node.getPath().c_str()); Common::Archive *fileArchive = NULL; Common::Archive *zipArchive = NULL; Common::SeekableReadStream * file = 0; if (node.getChild("kbd").exists() && node.getChild("kbd").isDirectory()) { -#ifdef PSP_KB_DEBUG - fprintf(stderr, "found directory ./kbd\n"); -#endif + PSP_DEBUG_PRINT("found directory ./kbd\n"); fileArchive = new Common::FSDirectory(node.getChild("kbd")); } if (node.getChild("kbd.zip").exists()) { -#ifdef PSP_KB_DEBUG - fprintf(stderr, "found kbd.zip\n"); -#endif + PSP_DEBUG_PRINT("found kbd.zip\n"); zipArchive = Common::makeZipArchive(node.getChild("kbd.zip")); } - // Loop through different png images - for (a = 0; a < guiStringsSize; a++) { + int i; + + // Loop through all png images + for (i = 0; i < guiStringsSize; i++) { uint32 height = 0, width = 0, paletteSize = 0; -#ifdef PSP_KB_DEBUG - fprintf(stderr, "load(): Opening %s.\n", _guiStrings[a]); -#endif + PSP_DEBUG_PRINT("Opening %s.\n", _guiStrings[i]); // Look for the file in the kbd directory - if (fileArchive && fileArchive->hasFile(_guiStrings[a])) { - -#ifdef PSP_KB_DEBUG - fprintf(stderr, "load(): found it in kbd directory.\n"); -#endif + if (fileArchive && fileArchive->hasFile(_guiStrings[i])) { + PSP_DEBUG_PRINT("found it in kbd directory.\n"); - file = fileArchive->createReadStreamForMember(_guiStrings[a]); + file = fileArchive->createReadStreamForMember(_guiStrings[i]); if (!file) { - fprintf(stderr, "load(): Can't open kbd/%s for keyboard. No keyboard will load.\n", _guiStrings[a]); + PSP_ERROR("Can't open kbd/%s for keyboard. No keyboard will load.\n", _guiStrings[i]); goto ERROR; } } // We didn't find it. Look for it in the zip file - else if (zipArchive && zipArchive->hasFile(_guiStrings[a])) { + else if (zipArchive && zipArchive->hasFile(_guiStrings[i])) { + PSP_DEBUG_PRINT("found it in kbd.zip.\n"); -#ifdef PSP_KB_DEBUG - fprintf(stderr, "load(): found it in kbd.zip.\n"); -#endif - - file = zipArchive->createReadStreamForMember(_guiStrings[a]); + file = zipArchive->createReadStreamForMember(_guiStrings[i]); if (!file) { - fprintf(stderr, "Can't open %s in kbd.zip for keyboard. No keyboard will load.\n", _guiStrings[a]); + PSP_ERROR("Can't open %s in kbd.zip for keyboard. No keyboard will load.\n", _guiStrings[i]); goto ERROR; } } else { // Couldn't find the file - fprintf(stderr, "load(): Can't find %s for keyboard. No keyboard will load.\n", _guiStrings[a]); + PSP_ERROR("Can't find %s for keyboard. No keyboard will load.\n", _guiStrings[i]); goto ERROR; } - if (get_png_image_size(file, &width, &height, &paletteSize) == 0) { // Check image size and palette size + if (getPngImageSize(file, &width, &height, &paletteSize) == 0) { // Check image size and palette size // Allocate memory for image -#ifdef PSP_KB_DEBUG - fprintf(stderr, "load(): width=%d, height=%d, paletteSize=%d\n", width, height, paletteSize); -#endif - + PSP_DEBUG_PRINT("width[%d], height[%d], paletteSize[%d]\n", width, height, paletteSize); + _buffers[i].setSize(width, height, Buffer::kSizeByTextureSize); + if (paletteSize) { // 8 or 4-bit image - uint32 textureSize = 0; - if (paletteSize <= 16) { // 4 bit - paletteSize = 16; - textureSize = (width * height)>>1; + _buffers[i].setPixelFormat(PSPPixelFormat::Type_Palette_4bit); + _palettes[i].setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_4bit); + paletteSize = 16; } else if (paletteSize <= 256){ // 8-bit image paletteSize = 256; - textureSize = width * height; + _buffers[i].setPixelFormat(PSPPixelFormat::Type_Palette_8bit); + _palettes[i].setPixelFormats(PSPPixelFormat::Type_4444, PSPPixelFormat::Type_Palette_8bit); } else { - fprintf(stderr, "Error: palette of %d too big!\n", paletteSize); + PSP_ERROR("palette of %d too big!\n", paletteSize); goto ERROR; } -#ifdef PSP_KB_DEBUG - fprintf(stderr, "load(): allocating %d bytes for texture and %d for palette\n", textureSize, paletteSize*4); -#endif - temp_texture = (u8 *)malloc(textureSize); - temp_palette = (uint32 *)memalign(16, paletteSize<<2); - memset(temp_palette, 0, paletteSize<<2); // Set to 0 since we might only fill some of it + } else { // 32-bit image - temp_texture = (unsigned char *)malloc((width * height)<<2); + _buffers[i].setPixelFormat(PSPPixelFormat::Type_8888); } + + _buffers[i].allocate(); + _palettes[i].allocate(); // Try to load the image file->seek(0); // Go back to start - if (load_png_image(file, temp_texture, temp_palette) != 0) + if (loadPngImage(file, _buffers[i], _palettes[i]) != 0) goto ERROR; else { // Success -#ifdef PSP_KB_DEBUG - fprintf(stderr, "Managed to load the image.\n"); -#endif - // we need to store the texture in an image of width and heights of 2^n sizes - _keyTextures[a].texture_width = width; // original size - _keyTextures[a].texture_height = height; - _keyTextures[a].surface_width = convert_pow2(width); // converted size - _keyTextures[a].surface_height = convert_pow2(height); - _keyTextures[a].palette = temp_palette; - _keyTextures[a].paletteSize = paletteSize; - - uint32 size; - - if (paletteSize == 16) // 4 bit - size = (_keyTextures[a].surface_width * _keyTextures[a].surface_height)>>1; - else if (paletteSize == 256) // 8-bit - size = _keyTextures[a].surface_width * _keyTextures[a].surface_height; - else // 32 bit - size = (_keyTextures[a].surface_width * _keyTextures[a].surface_height)<<2; - -#ifdef PSP_KB_DEBUG - fprintf(stderr, "load(): perm texture width=%d, height=%d, size=%d\n", _keyTextures[a].surface_width, _keyTextures[a].surface_height, size); -#endif - _keyTextures[a].texture = (unsigned char *)memalign(16, size); // Allocate memory - - block_copy(&_keyTextures[a], temp_texture); // Copy temp texture to permanent texture + PSP_DEBUG_PRINT("Managed to load the image\n"); if (paletteSize == 16) // 4-bit - flipNibbles(&_keyTextures[a]); - - free(temp_texture); + _buffers[i].flipNibbles(); delete file; } } - else + else { + PSP_ERROR("couldn't obtain PNG image size\n"); goto ERROR; + } } /* for loop */ + _init = true; delete fileArchive; delete zipArchive; + DEBUG_EXIT_FUNC(); return true; ERROR: - // Error .. Couldn't get png info from one of the needed files - free(temp_texture); delete file; delete fileArchive; delete zipArchive; - for (int b = 0; b < a; b++) { - free(_keyTextures[b].texture); - free(_keyTextures[b].palette); - _keyTextures[b].texture = NULL; + for (int j = 0; j < i; j++) { + _buffers[j].deallocate(); + _palettes[j].deallocate(); } _init = false; + + DEBUG_EXIT_FUNC(); return false; } -// Copy texture from regular size image to power of 2 size image -// -void PSPKeyboard::block_copy(gu_surface* surface, u8 *texture) { - u32 stride = 0, width = 0; - - switch(surface->paletteSize) { - case 16: // 4-bit - width = surface->texture_width >> 1; - stride = (surface->surface_width - surface->texture_width)>>1; - break; - case 256: // 8-bit - width = surface->texture_width; - stride = surface->surface_width - surface->texture_width; - break; - case 0: // 32-bit - width = surface->texture_width << 2; - stride = (surface->surface_width - surface->texture_width)<<2; - break; - default: - fprintf(stderr, "Error in block_copy: bad value in paletteSize = %d\n", surface->paletteSize); - return; - } - - u8 *src = texture; - u8 *dest = surface->texture; - - for (unsigned int y = 0; y < surface->texture_height; y++) { - memcpy(dest, src, width); - dest += width; - src += width; - - // skip at the end of each line - if (stride > 0) { - dest += stride; - } - } -} - -// Convert 4 bit images to match weird PSP format -// -void PSPKeyboard::flipNibbles(gu_surface* surface) { - u32 *dest = (u32 *)surface->texture; - - for (u32 y = 0; y < surface->texture_height; y++) { - for (u32 x = 0; x < (surface->surface_width >> 3); x++) { - u32 val = *dest; - *dest++ = ((val >> 4) & 0x0F0F0F0F) | ((val << 4) & 0xF0F0F0F0); - } - } - -} - - static void user_warning_fn(png_structp png_ptr, png_const_charp warning_msg) { // ignore PNG warnings } /* Get the width and height of a png image */ -int PSPKeyboard::get_png_image_size(Common::SeekableReadStream *file, uint32 *png_width, uint32 *png_height, u32 *paletteSize) { +int PSPKeyboard::getPngImageSize(Common::SeekableReadStream *file, uint32 *png_width, uint32 *png_height, u32 *paletteSize) { + DEBUG_ENTER_FUNC(); + png_structp png_ptr; png_infop info_ptr; unsigned int sig_read = 0; @@ -723,12 +408,14 @@ int PSPKeyboard::get_png_image_size(Common::SeekableReadStream *file, uint32 *pn png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) { + DEBUG_EXIT_FUNC(); return -1; } png_set_error_fn(png_ptr, (png_voidp) NULL, (png_error_ptr) NULL, user_warning_fn); info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); + DEBUG_EXIT_FUNC(); return -1; } // Set the png lib to use our read function @@ -746,22 +433,27 @@ int PSPKeyboard::get_png_image_size(Common::SeekableReadStream *file, uint32 *pn *png_width = width; *png_height = height; + + DEBUG_EXIT_FUNC(); return 0; } // Load a texture from a png image // -int PSPKeyboard::load_png_image(Common::SeekableReadStream *file, unsigned char *ImageBuffer, uint32 *palette) { +int PSPKeyboard::loadPngImage(Common::SeekableReadStream *file, Buffer &buffer, Palette &palette) { + DEBUG_ENTER_FUNC(); + png_structp png_ptr; png_infop info_ptr; unsigned int sig_read = 0; png_uint_32 width, height; int bit_depth, color_type, interlace_type; - size_t x, y; + size_t y; png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (png_ptr == NULL) { - fprintf(stderr, "load_png_image(): Error: couldn't create read struct to load keyboard.\n"); + PSP_ERROR("Couldn't create read struct to load keyboard\n"); + DEBUG_EXIT_FUNC(); return -1; } // Use dummy error function @@ -769,11 +461,13 @@ int PSPKeyboard::load_png_image(Common::SeekableReadStream *file, unsigned char info_ptr = png_create_info_struct(png_ptr); if (info_ptr == NULL) { + PSP_ERROR("Couldn't create info struct to load keyboard\n"); png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); + DEBUG_EXIT_FUNC(); return -1; } - // Set the png lib to use our read function + // Set the png lib to use our customized read function png_set_read_fn(png_ptr, (void *)file, pngReadStreamRead); png_set_sig_bytes(png_ptr, sig_read); @@ -784,71 +478,278 @@ int PSPKeyboard::load_png_image(Common::SeekableReadStream *file, unsigned char png_set_strip_16(png_ptr); if (color_type == PNG_COLOR_TYPE_PALETTE) { - // We copy the palette - uint32 *dstPal = palette; + // Copy the palette png_colorp srcPal = info_ptr->palette; for(int i=0; i < info_ptr->num_palette; i++) { unsigned char alphaVal = (i < info_ptr->num_trans) ? info_ptr->trans[i] : 0xFF; // Load alpha if it's there - *dstPal++ = GU_ARGB(alphaVal, srcPal->red, srcPal->green, srcPal->blue); + palette.setSingleColorRGBA(i, srcPal->red, srcPal->green, srcPal->blue, alphaVal); srcPal++; } - - unsigned char *line = (unsigned char*) malloc(info_ptr->rowbytes); - if (!line) { - png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); - return -1; - } - - for (y = 0; y < height; y++) { - png_read_row(png_ptr, line, png_bytep_NULL); - memcpy(&ImageBuffer[y * info_ptr->rowbytes], line, info_ptr->rowbytes); - } - - free(line); } else { // Not a palettized image + // Round up grayscale images if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) png_set_gray_1_2_4_to_8(png_ptr); // Convert trans channel to alpha for 32 bits if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) png_set_tRNS_to_alpha(png_ptr); + // Filler for alpha? png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER); + } - u32* line = (u32*) malloc(width<<2); - if (!line) { - png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); - return -1; - } - - u32* Image = (u32 *)ImageBuffer; - for (y = 0; y < height; y++) { - png_read_row(png_ptr, (u8*) line, png_bytep_NULL); - for (x = 0; x < width; x++) { - Image[y*width + x] = line[x]; - } - } + unsigned char *line = (unsigned char*) malloc(info_ptr->rowbytes); + if (!line) { + png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL); + PSP_ERROR("Couldn't allocate line\n"); + DEBUG_EXIT_FUNC(); + return -1; + } - free(line); + for (y = 0; y < height; y++) { + png_read_row(png_ptr, line, png_bytep_NULL); + buffer.copyFromRect(line, info_ptr->rowbytes, 0, y, width, 1); // Copy into buffer + //memcpy(buffer.getPixels()[y * buffer.getWidthInBytes()], line, info_ptr->rowbytes); } + free(line); + png_read_end(png_ptr, info_ptr); png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL); + DEBUG_EXIT_FUNC(); return 0; } -// Function to get the lowest power of 2 higher than our image size -// -uint32 PSPKeyboard::convert_pow2(uint32 size) { - uint32 pow_counter = 0; - - for (; pow_counter < 32; pow_counter++) { - // Find the first value which is higher - if ((size >> pow_counter) == 0) { - // take already good values into account - if (((uint32) 1 << pow_counter) != size) - return ((uint32)1 << pow_counter); - else - return ((uint32)1 << (pow_counter-1)); +// Defines for working with PSP buttons +#define CHANGED(x) (_buttonsChanged & (x)) +#define PRESSED(x) ((_buttonsChanged & (x)) && (pad.Buttons & (x))) +#define UNPRESSED(x) ((_buttonsChanged & (x)) && !(pad.Buttons & (x))) +#define DOWN(x) (pad.Buttons & (x)) +#define UP(x) (!(pad.Buttons & (x))) +#define PSP_DPAD (PSP_CTRL_DOWN|PSP_CTRL_UP|PSP_CTRL_LEFT|PSP_CTRL_RIGHT) +#define PSP_4BUTTONS (PSP_CTRL_CROSS | PSP_CTRL_CIRCLE | PSP_CTRL_TRIANGLE | PSP_CTRL_SQUARE) + +/* + * Attempts to read a character from the controller + * Uses the state machine. + * returns whether we have an event + */ +bool PSPKeyboard::processInput(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + + bool haveEvent = false; // Whether we have an event for the event manager to process + event.kbd.flags = 0; + + _buttonsChanged = _prevButtons ^ pad.Buttons; + + if (!_init) // In case we never had init + return false; + if (_state == kInvisible) // Return if we're invisible + return false; + if (_state != kMove && PRESSED(PSP_CTRL_SELECT)) { + _lastState = _state; + _state = kMove; // Check for move or visible state + } + else if (CHANGED(PSP_CTRL_START)) { // Handle start button: enter, make KB invisible + event.kbd.ascii = '\r'; + event.kbd.keycode = Common::KEYCODE_RETURN; + event.type = DOWN(PSP_CTRL_START) ? Common::EVENT_KEYDOWN : Common::EVENT_KEYUP; + haveEvent = true; + _dirty = true; + if (UP(PSP_CTRL_START)) + _state = kInvisible; // Make us invisible if unpressed + } + // Check for being in state of moving the keyboard onscreen or pressing select + else if (_state == kMove) + handleMoveState(pad); + else if (_state == kDefault) + haveEvent = handleDefaultState(event, pad); + else if (_state == kCornersSelected) + haveEvent = handleCornersSelectedState(event, pad); + else if (_state == kRTriggerDown) + handleRTriggerDownState(pad); // Deal with trigger states + else if (_state == kLTriggerDown) + handleLTriggerDownState(pad); // Deal with trigger states + + _prevButtons = pad.Buttons; + + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +void PSPKeyboard::handleMoveState(SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + if (UP(PSP_CTRL_SELECT)) { + // Toggle between visible and invisible + _state = (_lastState == kInvisible) ? kDefault : kInvisible; + _dirty = true; + + if (_moved) { // We moved the keyboard. Keep the keyboard onscreen anyway + _state = kDefault; + _moved = false; // reset moved flag } + } else if (DOWN(PSP_DPAD)) { // How we move the KB onscreen + _moved = true; + _dirty = true; + + if (DOWN(PSP_CTRL_DOWN)) + increaseKeyboardLocationY(5); + else if (DOWN(PSP_CTRL_UP)) + increaseKeyboardLocationY(-5); + else if (DOWN(PSP_CTRL_LEFT)) + increaseKeyboardLocationX(-5); + else /* DOWN(PSP_CTRL_RIGHT) */ + increaseKeyboardLocationX(5); } - return 0; + DEBUG_EXIT_FUNC(); +} + +bool PSPKeyboard::handleDefaultState(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + bool haveEvent = false; + + if (PRESSED(PSP_CTRL_LTRIGGER)) // Don't say we used up the input + _state = kLTriggerDown; + else if (PRESSED(PSP_CTRL_RTRIGGER)) // Don't say we used up the input + _state = kRTriggerDown; + else if (CHANGED(PSP_4BUTTONS)) // We only care about the 4 buttons + haveEvent = getInputChoice(event, pad); + else if (!DOWN(PSP_4BUTTONS)) // Must be up to move cursor + getCursorMovement(pad); + + DEBUG_EXIT_FUNC(); + return haveEvent; } +bool PSPKeyboard::handleCornersSelectedState(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + // We care about 4 buttons + triggers (for letter selection) + bool haveEvent = false; + + if (CHANGED(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER)) + haveEvent = getInputChoice(event, pad); + if (!DOWN(PSP_4BUTTONS | PSP_CTRL_RTRIGGER | PSP_CTRL_LTRIGGER)) // Must be up to move cursor + getCursorMovement(pad) + + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +bool PSPKeyboard::getInputChoice(Common::Event &event, SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + int innerChoice; + bool haveEvent = false; + + if (UNPRESSED(PSP_CTRL_TRIANGLE)) { + innerChoice = 0; + event.type = Common::EVENT_KEYUP; // We give priority to key_up + } else if (UNPRESSED(PSP_CTRL_CIRCLE)) { + innerChoice = 1; + event.type = Common::EVENT_KEYUP; // We give priority to key_up + } else if (UNPRESSED(PSP_CTRL_CROSS)) { + innerChoice = 2; + event.type = Common::EVENT_KEYUP; // We give priority to key_up + } else if (UNPRESSED(PSP_CTRL_SQUARE)) { + innerChoice = 3; + event.type = Common::EVENT_KEYUP; // We give priority to key_up + } else if (UNPRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) { + innerChoice = 4; + event.type = Common::EVENT_KEYUP; // We give priority to key_up + } else if (UNPRESSED(PSP_CTRL_RTRIGGER) && _state == kCornersSelected) { + innerChoice = 5; + event.type = Common::EVENT_KEYUP; // We give priority to key_up + } else if (PRESSED(PSP_CTRL_TRIANGLE)) { + innerChoice = 0; + event.type = Common::EVENT_KEYDOWN; + } else if (PRESSED(PSP_CTRL_CIRCLE)) { + innerChoice = 1; + event.type = Common::EVENT_KEYDOWN; + } else if (PRESSED(PSP_CTRL_CROSS)) { + innerChoice = 2; + event.type = Common::EVENT_KEYDOWN; + } else if (PRESSED(PSP_CTRL_SQUARE)) { + innerChoice = 3; + event.type = Common::EVENT_KEYDOWN; + } else if (PRESSED(PSP_CTRL_LTRIGGER) && _state == kCornersSelected) { + innerChoice = 4; + event.type = Common::EVENT_KEYDOWN; // We give priority to key_up + } else /* (PRESSED(PSP_CTRL_RTRIGGER)) && _state == kCornersSelected */ { + innerChoice = 5; + event.type = Common::EVENT_KEYDOWN; // We give priority to key_up + } + + #define IS_UPPERCASE(x) ((x) >= (unsigned short)'A' && (x) <= (unsigned short)'Z') + #define TO_LOWER(x) ((x) += 'a'-'A') + + //Now grab the value out of the array + short choice = _modeChar[_mode][_oldCursor][innerChoice]; + + event.kbd.ascii = choice <= 255 ? choice : 0; + + // Handle upper-case which is missing in Common::KeyCode + if (IS_UPPERCASE(choice)) { + event.kbd.keycode = (Common::KeyCode) TO_LOWER(choice); + event.kbd.flags = Common::KBD_SHIFT; + } else + event.kbd.keycode = (Common::KeyCode) choice; + + haveEvent = (choice != Common::KEYCODE_INVALID) ? true : false; // We have an event/don't if it's invalid + + DEBUG_EXIT_FUNC(); + return haveEvent; +} + +void PSPKeyboard::getCursorMovement(SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + CursorDirections cursor; + + // Find where the cursor is pointing + cursor = kCenter; + _state = kDefault; + + if (DOWN(PSP_DPAD)) { + _state = kCornersSelected; + + if (DOWN(PSP_CTRL_UP)) + cursor = kUp; + else if (DOWN(PSP_CTRL_RIGHT)) + cursor = kRight; + else if (DOWN(PSP_CTRL_DOWN)) + cursor = kDown; + else if (DOWN(PSP_CTRL_LEFT)) + cursor = kLeft; + } + + if (cursor != _oldCursor) { //If we've moved, update dirty and return + _dirty = true; + _oldCursor = cursor; + } + DEBUG_EXIT_FUNC(); +} + +void PSPKeyboard::handleLTriggerDownState(SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + if (UNPRESSED(PSP_CTRL_LTRIGGER)) { + _dirty = true; + + if(_mode < 2) + _mode = 2; + else + _mode = (_mode == 2) ? 3 : 2; + + _state = kDefault; + } + DEBUG_EXIT_FUNC(); +} + +void PSPKeyboard::handleRTriggerDownState(SceCtrlData &pad) { + DEBUG_ENTER_FUNC(); + if (UNPRESSED(PSP_CTRL_RTRIGGER)) { + _dirty = true; + + if(_mode > 1) + _mode = 0; + else + _mode = (_mode == 0) ? 1 : 0; + + _state = kDefault; + } + DEBUG_EXIT_FUNC(); +} diff --git a/backends/platform/psp/pspkeyboard.h b/backends/platform/psp/pspkeyboard.h index b9681c1e0e..457476e844 100644 --- a/backends/platform/psp/pspkeyboard.h +++ b/backends/platform/psp/pspkeyboard.h @@ -28,13 +28,14 @@ #include "common/events.h" #include "common/stream.h" +#include "backends/platform/psp/display_client.h" #include <pspctrl.h> //number of modes #define MODE_COUNT 4 #define guiStringsSize 8 /* size of guistrings array */ -class PSPKeyboard { +class PSPKeyboard : public DisplayClient { private: enum State { @@ -49,67 +50,63 @@ private: public: PSPKeyboard(); ~PSPKeyboard(); + bool load(); // Load keyboard into memory bool isInit() { return _init; } // Check for initialization bool isDirty() { return _dirty; } // Check if needs redrawing + void setDirty() { _dirty = true; } + void setClean() { _dirty = false; } bool isVisible() { return _state != kInvisible; } // Check if visible - bool processInput(Common::Event &event, SceCtrlData &pad, bool &usedInput); // Process input + void setVisible(bool val); + bool processInput(Common::Event &event, SceCtrlData &pad); // Process input void moveTo(const int newX, const int newY); // Move keyboard void render(); // Draw the keyboard onscreen private: - struct gu_surface { - u32 surface_width; - u32 surface_height; - u32 texture_width; - u32 texture_height; - u8 *texture; - u32 *palette; - u32 paletteSize; + enum CursorDirections { + kUp = 0, + kRight, + kDown, + kLeft, + kCenter }; + Buffer _buffers[guiStringsSize]; + Palette _palettes[guiStringsSize]; + GuRenderer _renderer; -// structures used for drawing the keyboard - struct Vertex { - float u, v; - unsigned int color; - float x,y,z; - }; - - void surface_draw_offset(struct gu_surface* surface, - int screenX, int screenY, int offsetX, int offsetY, int intWidth, int intHeight); - void block_copy(gu_surface* surface, u8 *texture); - int load_png_image(Common::SeekableReadStream *, unsigned char *ImageBuffer, uint32 *palette); - int get_png_image_size(Common::SeekableReadStream *, uint32 *png_width, uint32 *png_height, u32 *paletteSize); + int loadPngImage(Common::SeekableReadStream *file, Buffer &buffer, Palette &palette); + int getPngImageSize(Common::SeekableReadStream *, uint32 *png_width, uint32 *png_height, u32 *paletteSize); uint32 convert_pow2(uint32 size); - void flipNibbles(gu_surface* surface); // Convert to PSP 4-bit format void increaseKeyboardLocationX(int amount); // Move keyboard onscreen void increaseKeyboardLocationY(int amount); - + void convertCursorToXY(CursorDirections cur, int &x, int &y); + + void handleMoveState(SceCtrlData &pad); + bool handleDefaultState(Common::Event &event, SceCtrlData &pad); + bool handleCornersSelectedState(Common::Event &event, SceCtrlData &pad); + bool getInputChoice(Common::Event &event, SceCtrlData &pad); + void getCursorMovement(SceCtrlData &pad); + void handleRTriggerDownState(SceCtrlData &pad); + void handleLTriggerDownState(SceCtrlData &pad); + static short _modeChar[MODE_COUNT][5][6]; static const char *_guiStrings[]; bool _init; - unsigned int _prevButtons; // A bit pattern. + uint32 _prevButtons; // A bit pattern. + uint32 _buttonsChanged; + bool _dirty; // keyboard needs redrawing int _mode; // charset selected. (0 - letters or 1 - numbers) - int _moved_x; // location we've moved the KB to onscreen - int _moved_y; + int _movedX; // location we've moved the KB to onscreen + int _movedY; bool _moved; // whether the keyboard was moved - gu_surface _keyTextures[guiStringsSize]; - + State _state; // State of keyboard Keyboard state machine State _lastState; - enum Cursor { - kUp = 0, - kRight, - kDown, - kLeft, - kCenter - }; - - Cursor _oldCursor; // Point to place of last cursor + CursorDirections _oldCursor; // Point to place of last cursor }; -#endif /* PSPKEYBOARD_H */
\ No newline at end of file +#endif /* PSPKEYBOARD_H */ diff --git a/backends/platform/psp/psploader.h b/backends/platform/psp/psploader.h index 70022d65de..13dcf6ef98 100644 --- a/backends/platform/psp/psploader.h +++ b/backends/platform/psp/psploader.h @@ -135,4 +135,3 @@ extern "C" { } #endif /* PSPLOADER_H */ - diff --git a/backends/platform/psp/psppixelformat.cpp b/backends/platform/psp/psppixelformat.cpp new file mode 100644 index 0000000000..7758f2c26b --- /dev/null +++ b/backends/platform/psp/psppixelformat.cpp @@ -0,0 +1,166 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $ + * + */ + +#include "common/scummsys.h" +#include "backends/platform/psp/psppixelformat.h" + +//#define __PSP_DEBUG_FUNCS__ /* For debugging function calls */ +//#define __PSP_DEBUG_PRINT__ /* For debug printouts */ + +#include "backends/platform/psp/trace.h" + +// class PSPPixelFormat -------------------------------------- + +void PSPPixelFormat::set(Type type, bool swap /* = false */) { + DEBUG_ENTER_FUNC(); + PSP_DEBUG_PRINT("type = %d\n", type); + + format = type; + swapRB = swap; + + switch (type) { + case Type_4444: + case Type_5551: + case Type_5650: + bitsPerPixel = 16; + break; + case Type_8888: + bitsPerPixel = 32; + break; + case Type_Palette_8bit: + bitsPerPixel = 8; + break; + case Type_Palette_4bit: + bitsPerPixel = 4; + break; + case Type_None: + bitsPerPixel = 0; + break; + default: // This is an error, but let's continue anyway + PSP_ERROR("Unhandled value of pixel type[%d]\n", type); + bitsPerPixel = 16; + break; + } + + PSP_DEBUG_PRINT("bitsPerPixel[%u]\n", bitsPerPixel); + DEBUG_EXIT_FUNC(); +} + +// Convert from ScummVM general PixelFormat to our pixel format +// For buffer and palette. +void PSPPixelFormat::convertFromScummvmPixelFormat(const Graphics::PixelFormat *pf, + PSPPixelFormat::Type &bufferType, + PSPPixelFormat::Type &paletteType, + bool &swapRedBlue) { + swapRedBlue = false; // no red-blue swap by default + PSPPixelFormat::Type *target = 0; // which one we'll be filling + + if (!pf) { // Default, pf is NULL + bufferType = Type_Palette_8bit; + paletteType = Type_5551; + } else { // We have a pf + if (pf->bytesPerPixel == 1) { + bufferType = Type_Palette_8bit; + target = &paletteType; // The type describes the palette + } else if (pf->bytesPerPixel == 2) { + paletteType = Type_None; + target = &bufferType; // The type describes the buffer + } else { + PSP_ERROR("Unknown bpp[%u] in pixeltype. Reverting to 8bpp\n", pf->bytesPerPixel); + bufferType = Type_Palette_8bit; + target = &paletteType; // The type describes the palette + } + + // Find out the exact type of the target + if (pf->rLoss == 3 && pf->bLoss == 3) { + if (pf->gLoss == 3) + *target = Type_5551; + else + *target = Type_5650; + } else if (pf->rLoss == 4 && pf->gLoss == 4 && pf->bLoss == 4) { + *target = Type_4444; + } else if (pf->gLoss == 0 && pf->gShift == 8) { + *target = Type_8888; + } else if ((pf->gLoss == 0 && pf->gShift == 0) || + (pf->gLoss == 8 && pf->gShift == 0)) { // Default CLUT8 can have weird values + *target = Type_5551; + } else { + PSP_ERROR("Unknown Scummvm pixel format.\n"); + PSP_ERROR("\trLoss[%d], gLoss[%d], bLoss[%d], aLoss[%d]\n\trShift[%d], gShift[%d], bShift[%d], aShift[%d]\n", + pf->rLoss, pf->gLoss, pf->bLoss, pf->aLoss, + pf->rShift, pf->gShift, pf->bShift, pf->aShift); + *target = Type_Unknown; + } + + if (pf->rShift != 0) {// We allow backend swap of red and blue + swapRedBlue = true; + PSP_DEBUG_PRINT("detected red/blue swap\n"); + } + } +} + +Graphics::PixelFormat PSPPixelFormat::convertToScummvmPixelFormat(PSPPixelFormat::Type type) { + Graphics::PixelFormat pf; + + switch(type) { + case Type_4444: + pf.bytesPerPixel = 2; + pf.aLoss = 4; pf.rLoss = 4; pf.gLoss = 4; pf.bLoss = 4; + pf.aShift = 12; pf.rShift = 0; pf.gShift = 4; pf.bShift = 8; + break; + case Type_5551: + pf.bytesPerPixel = 2; + pf.aLoss = 7; pf.rLoss = 3; pf.gLoss = 3; pf.bLoss = 3; + pf.aShift = 15; pf.rShift = 0; pf.gShift = 5; pf.bShift = 10; + break; + case Type_5650: + pf.bytesPerPixel = 2; + pf.aLoss = 8; pf.rLoss = 3; pf.gLoss = 2; pf.bLoss = 3; + pf.aShift = 0; pf.rShift = 0; pf.gShift = 5; pf.bShift = 11; + break; + case Type_8888: + pf.bytesPerPixel = 4; + pf.aLoss = 0; pf.rLoss = 0; pf.gLoss = 0; pf.bLoss = 0; + pf.aShift = 24; pf.rShift = 0; pf.gShift = 8; pf.bShift = 16; + break; + default: + PSP_ERROR("Unhandled PSPPixelFormat[%u]\n", type); + break; + } + + return pf; +} + +uint32 PSPPixelFormat::convertTo32BitColor(uint32 color) { + DEBUG_ENTER_FUNC(); + uint32 r,g,b,a, output; + + colorToRgba(color, r, g, b, a); + output = ((b << 16) | (g << 8) | (r << 0) | (a << 24)); + PSP_DEBUG_PRINT_FUNC("input color[%x], output[%x]\n", color, output); + + DEBUG_EXIT_FUNC(); + return output; +} diff --git a/backends/platform/psp/psppixelformat.h b/backends/platform/psp/psppixelformat.h new file mode 100644 index 0000000000..8a7283df43 --- /dev/null +++ b/backends/platform/psp/psppixelformat.h @@ -0,0 +1,240 @@ +/* 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: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/trunk/backends/platform/psp/osys_psp.cpp $ + * $Id: osys_psp.cpp 46126 2009-11-24 14:18:46Z fingolfin $ + * + */ + +#ifndef PSP_PIXEL_FORMAT_H +#define PSP_PIXEL_FORMAT_H + +#include "graphics/pixelformat.h" +#include "backends/platform/psp/trace.h" + +/** + * Specialized PixelFormat class + * Supports only those formats which the PSP allows, including 4 bit palettes. + * Also provides accurate color conversion (needed for color masking) + * As well as swapping of red and blue channels (needed by HE games, for example) + */ +struct PSPPixelFormat{ + enum Type { + Type_None, + Type_4444, + Type_5551, + Type_5650, + Type_8888, + Type_Palette_8bit, + Type_Palette_4bit, + Type_Unknown + }; + + Type format; + uint32 bitsPerPixel; ///< Must match bpp of selected type + bool swapRB; ///< Swap red and blue values when reading and writing + + PSPPixelFormat() : format(Type_Unknown), bitsPerPixel(0), swapRB(false) {} + void set(Type type, bool swap = false); + static void convertFromScummvmPixelFormat(const Graphics::PixelFormat *pf, + PSPPixelFormat::Type &bufferType, + PSPPixelFormat::Type &paletteType, + bool &swapRedBlue); + static Graphics::PixelFormat convertToScummvmPixelFormat(PSPPixelFormat::Type type); + uint32 convertTo32BitColor(uint32 color); + + inline uint32 rgbaToColor(uint32 r, uint32 g, uint32 b, uint32 a) { + uint32 color; + + switch(format) { + case Type_4444: + color = (((b >> 4) << 8) | ((g >> 4) << 4) | ((r >> 4) << 0) | ((a >> 4) << 12)); + break; + case Type_5551: + color = (((b >> 3) << 10) | ((g >> 3) << 5) | ((r >> 3) << 0) | ((a >> 7) << 15)); + break; + case Type_5650: + color = (((b >> 3) << 11) | ((g >> 2) << 5) | ((r >> 3) << 0)); + break; + case Type_8888: + color = (((b >> 0) << 16) | ((g >> 0) << 8) | ((r >> 0) << 0) | ((a >> 0) << 24)); + break; + default: + color = 0; + break; + } + return color; + } + + inline void colorToRgba(uint32 color, uint32 &r, uint32 &g, uint32 &b, uint32 &a) { + switch(format) { + case Type_4444: + a = (color >> 12) & 0xF; // Interpolate to get true colors + b = (color >> 8) & 0xF; + g = (color >> 4) & 0xF; + r = (color >> 0) & 0xF; + a = a << 4 | a; + b = b << 4 | b; + g = g << 4 | g; + r = r << 4 | r; + break; + case Type_5551: + a = (color >> 15) ? 0xFF : 0; + b = (color >> 10) & 0x1F; + g = (color >> 5) & 0x1F; + r = (color >> 0) & 0x1F; + b = b << 3 | b >> 2; + g = g << 3 | g >> 2; + r = r << 3 | r >> 2; + break; + case Type_5650: + a = 0xFF; + b = (color >> 11) & 0x1F; + g = (color >> 5) & 0x3F; + r = (color >> 0) & 0x1F; + b = b << 3 | b >> 2; + g = g << 2 | g >> 4; + r = r << 3 | r >> 2; + break; + case Type_8888: + a = (color >> 24) & 0xFF; + b = (color >> 16) & 0xFF; + g = (color >> 8) & 0xFF; + r = (color >> 0) & 0xFF; + break; + default: + a = b = g = r = 0; + break; + } + } + + inline uint32 setColorAlpha(uint32 color, byte alpha) { + switch(format) { + case Type_4444: + color = (color & 0x0FFF) | (((uint32)alpha >> 4) << 12); + break; + case Type_5551: + color = (color & 0x7FFF) | (((uint32)alpha >> 7) << 15); + break; + case Type_8888: + color = (color & 0x00FFFFFF) | ((uint32)alpha << 24); + break; + case Type_5650: + default: + break; + } + return color; + } + + inline uint32 pixelsToBytes(uint32 pixels) { + switch (bitsPerPixel) { + case 4: + pixels >>= 1; + break; + case 16: + pixels <<= 1; + break; + case 32: + pixels <<= 2; + break; + case 8: + break; + default: + PSP_ERROR("Incorrect bitsPerPixel value[%u]. pixels[%u]\n", bitsPerPixel, pixels); + break; + } + return pixels; + } + + inline uint16 swapRedBlue16(uint16 color) { + uint16 output; + + switch (format) { + case Type_4444: + output = (color & 0xf0f0) | ((color & 0x000f)<<8) | ((color & 0x0f00)>>8); + break; + case Type_5551: + output = (color & 0x83e0) | ((color & 0x001f)<<10) | ((color & 0x7c00)>>10); + break; + case Type_5650: + output = (color & 0x07e0) | ((color & 0x001f)<<11) | ((color & 0xf800)>>11); + break; + default: + PSP_ERROR("invalid format[%u] for swapping\n", format); + output = 0; + break; + } + return output; + } + + inline uint32 swapRedBlue32(uint32 color) { + uint32 output; + + switch (format) { + case Type_4444: + output = (color & 0xf0f0f0f0) | + ((color & 0x000f000f)<<8) | ((color & 0x0f000f00)>>8); + break; + case Type_5551: + output = (color & 0x83e083e0) | + ((color & 0x001f001f)<<10) | ((color & 0x7c007c00)>>10); + break; + case Type_5650: + output = (color & 0x07e007e0) | + ((color & 0x001f001f)<<11) | ((color & 0xf800f800)>>11); + break; + case Type_8888: + output = (color & 0xff00ff00) | + ((color & 0x000000ff)<<16) | ((color & 0x00ff0000)>>16); + break; + default: + PSP_ERROR("invalid format[%u] for swapping\n", format); + output = 0; + break; + } + + return output; + } + + // Return whatever color we point at + inline uint32 getColorValueAt(byte *pointer) { + uint32 result; + + switch (bitsPerPixel) { + case 4: // We can't distinguish a 4 bit color with a pointer + case 8: + result = (uint32)*pointer; + break; + case 16: + result = (uint32)*(uint16 *)pointer; + break; + case 32: + result = *(uint32 *)pointer; + break; + default: + result = 0; + PSP_ERROR("Incorrect bitsPerPixel value[%u].\n", bitsPerPixel); + break; + } + return result; + } +}; + +#endif /* PSP_PIXEL_FORMAT_H */ diff --git a/backends/platform/psp/trace.cpp b/backends/platform/psp/trace.cpp index 28696c30a6..030dafdf1d 100644 --- a/backends/platform/psp/trace.cpp +++ b/backends/platform/psp/trace.cpp @@ -23,47 +23,33 @@ * */ +#define TRACE_C +#include <pspkernel.h> +#include <pspdebug.h> +#include "backends/platform/psp/trace.h" -#include "./trace.h" +int psp_debug_indent = 0; - -void PSPDebugTrace (const char *format, ...) { -#ifdef __PSP_DEBUG__ - va_list opt; - char buff[2048]; - int bufsz, fd; - - va_start(opt, format); - bufsz = vsnprintf( buff, (size_t) sizeof(buff), format, opt); - va_end(opt); - - fd = sceIoOpen("MS0:/DTRACE.TXT", PSP_O_RDWR | PSP_O_CREAT | PSP_O_APPEND, 0777); - - if (fd <= 0) - return; - - sceIoWrite(fd, (const void*)buff, bufsz); - sceIoClose(fd); -#endif /* __PSP_DEBUG__ */ -} - -void PSPDebugTrace (const char * filename, const char *format, ...) { -#ifdef __PSP_DEBUG__ +void PSPDebugTrace (bool alsoToScreen, const char *format, ...) { va_list opt; - char buff[2048]; - int bufsz, fd; + char buffer[2048]; + int bufsz; + FILE *fd = 0; va_start(opt, format); - bufsz = vsnprintf( buff, (size_t) sizeof(buff), format, opt); + bufsz = vsnprintf( buffer, (size_t) sizeof(buffer), format, opt); va_end(opt); - fd = sceIoOpen(filename, PSP_O_RDWR | PSP_O_CREAT | PSP_O_APPEND, 0777); - - if (fd <= 0) + //fd = fopen("MS0:/SCUMMTRACE.TXT", "ab"); + fd = fopen("SCUMMTRACE.TXT", "ab"); + + if (fd == 0) return; - sceIoWrite(fd, (const void*)buff, bufsz); - sceIoClose(fd); -#endif /* __PSP_DEBUG__ */ + fwrite(buffer, 1, bufsz, fd); + fclose(fd); + + if (alsoToScreen) + fprintf(stderr, buffer); } diff --git a/backends/platform/psp/trace.h b/backends/platform/psp/trace.h index ef8992ceb2..b77ecb4732 100644 --- a/backends/platform/psp/trace.h +++ b/backends/platform/psp/trace.h @@ -29,25 +29,94 @@ #include <stdio.h> #include <psptypes.h> -#include <pspkernel.h> #include <stdarg.h> -#include <pspdebug.h> // Use these defines for debugging -//#define __PSP_DEBUG__ -//#define __PSP_DEBUG_SUSPEND__ +//#define __PSP_PRINT_TO_FILE__ +//#define __PSP_PRINT_TO_FILE_AND_SCREEN__ +//#define __PSP_DEBUG_FUNCS__ /* can put this locally too */ +//#define __PSP_DEBUG_PRINT__ -void PSPDebugTrace (const char *filename, const char *format, ...); -void PSPDebugTrace (const char *format, ...); +void PSPDebugTrace (bool alsoToScreen, const char *format, ...); -#ifdef __PSP_DEBUG_SUSPEND__ -#define PSPDebugSuspend(format,...) PSPDebugTrace(format, ## __VA_ARGS__) -#else -#define PSPDegbugSuspend(x) -#define PSPDebugSuspend(format,...) -#endif /* __PSP_DEBUG_SUSPEND__ */ +#ifndef TRACE_C +extern int psp_debug_indent; +#endif +#endif /* TRACE_H */ -#endif // TRACE_H +// From here on, we allow multiple definitions +#undef __PSP_PRINT__ +#undef PSP_ERROR +#undef __PSP_INDENT__ +#undef PSP_INFO_PRINT +#undef PSP_INFO_PRINT_INDENT +#undef PSP_DEBUG_PRINT +#undef PSP_DEBUG_PRINT_FUNC +#undef PSP_DEBUG_PRINT_SAMELN +#undef PSP_DEBUG_DO +#undef DEBUG_ENTER_FUNC +#undef DEBUG_EXIT_FUNC +#undef INLINE +/* Choose to print to file/screen/both */ +#ifdef __PSP_PRINT_TO_FILE__ + #define __PSP_PRINT__(format,...) PSPDebugTrace(false, format, ## __VA_ARGS__) +#elif defined __PSP_PRINT_TO_FILE_AND_SCREEN__ + #define __PSP_PRINT__(format,...) PSPDebugTrace(true, format, ## __VA_ARGS__) +#else /* default - print to screen */ + #define __PSP_PRINT__(format,...) fprintf(stderr, format, ## __VA_ARGS__) +#endif /* PSP_PRINT_TO_FILE/SCREEN */ + +/* Error function */ +#define PSP_ERROR(format,...) __PSP_PRINT__("Error in %s: " format, __PRETTY_FUNCTION__, ## __VA_ARGS__) + +/* Do the indent */ +#define __PSP_INDENT__ for(int _i=psp_debug_indent; _i>0; _i--) \ + __PSP_PRINT__( " ") + +/* always print */ +#define PSP_INFO_PRINT(format,...) __PSP_PRINT__(format, ## __VA_ARGS__) +/* always print, with indent */ +#define PSP_INFO_PRINT_INDENT(format,...) { __PSP_INDENT__; \ + __PSP_PRINT__(format, ## __VA_ARGS__); } + +#ifdef __PSP_DEBUG_PRINT__ + /* printf with indents */ + #define PSP_DEBUG_PRINT_SAMELN(format,...) __PSP_PRINT__(format, ## __VA_ARGS__) + #define PSP_DEBUG_PRINT(format,...) { __PSP_INDENT__; \ + __PSP_PRINT__(format, ## __VA_ARGS__); } + #define PSP_DEBUG_PRINT_FUNC(format,...) { __PSP_INDENT__; \ + __PSP_PRINT__("In %s: " format, __PRETTY_FUNCTION__, ## __VA_ARGS__); } + #define PSP_DEBUG_DO(x) (x) + +#else /* no debug print */ + #define PSP_DEBUG_PRINT_SAMELN(format,...) + #define PSP_DEBUG_PRINT(format,...) + #define PSP_DEBUG_PRINT_FUNC(format,...) + #define PSP_DEBUG_DO(x) +#endif /* __PSP_DEBUG_PRINT__ */ + +/* Debugging function calls */ +#ifdef __PSP_DEBUG_FUNCS__ + #define DEBUG_ENTER_FUNC() PSP_INFO_PRINT_INDENT("++ %s\n", __PRETTY_FUNCTION__); \ + psp_debug_indent++ + + #define DEBUG_EXIT_FUNC() psp_debug_indent--; \ + if (psp_debug_indent < 0) PSP_ERROR("debug indent < 0\n"); \ + PSP_INFO_PRINT_INDENT("-- %s\n", __PRETTY_FUNCTION__) + + #define INLINE /* don't want to inline so we get function names properly */ + +#else /* Don't debug function calls */ + #define DEBUG_ENTER_FUNC() + #define DEBUG_EXIT_FUNC() + #define INLINE inline +#endif /* __PSP_DEBUG_FUNCS__ */ + +// Undef the main defines for next time +#undef __PSP_PRINT_TO_FILE__ +#undef __PSP_PRINT_TO_FILE_AND_SCREEN__ +#undef __PSP_DEBUG_FUNCS__ +#undef __PSP_DEBUG_PRINT__ |