From fb73cef4d9d481f616576a2779b53ea6c8c48b18 Mon Sep 17 00:00:00 2001 From: Angus Lees Date: Tue, 8 Jun 2010 13:15:15 +0000 Subject: [PATCH] Add a few files mistakenly left out of initial Android patch :( svn-id: r49502 --- backends/platform/android/video.cpp | 333 +++++++++++++++++++++++++++ backends/platform/android/video.h | 140 +++++++++++ dists/android/AndroidManifest.xml | 75 ++++++ dists/android/AndroidManifest.xml.in | 64 +++++ 4 files changed, 612 insertions(+) create mode 100644 backends/platform/android/video.cpp create mode 100644 backends/platform/android/video.h create mode 100644 dists/android/AndroidManifest.xml create mode 100644 dists/android/AndroidManifest.xml.in diff --git a/backends/platform/android/video.cpp b/backends/platform/android/video.cpp new file mode 100644 index 000000000000..09d4dba1543f --- /dev/null +++ b/backends/platform/android/video.cpp @@ -0,0 +1,333 @@ +/* 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/null/null.cpp $ + * $Id: null.cpp 34912 2008-11-06 15:02:50Z fingolfin $ + * + */ + +#include "base/main.h" +#include "graphics/surface.h" + +#include +#include + +#include + +#include "common/rect.h" +#include "common/array.h" +#include "common/util.h" +#include "common/tokenizer.h" + +#include "backends/platform/android/video.h" + +#undef LOG_TAG +#define LOG_TAG "ScummVM-video" + +#if 0 +#define ENTER(args...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, args) +#else +#define ENTER(args...) /**/ +#endif + +#if 1 +#define CHECK_GL_ERROR() checkGlError(__FILE__, __LINE__) +static const char* getGlErrStr(GLenum error) { + switch (error) { + case GL_NO_ERROR: return "GL_NO_ERROR"; + case GL_INVALID_ENUM: return "GL_INVALID_ENUM"; + case GL_INVALID_OPERATION: return "GL_INVALID_OPERATION"; + case GL_STACK_OVERFLOW: return "GL_STACK_OVERFLOW"; + case GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW"; + case GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY"; + } + + static char buf[40]; + snprintf(buf, sizeof(buf), "(Unknown GL error code 0x%x)", error); + return buf; +} +static void checkGlError(const char* file, int line) { + GLenum error = glGetError(); + if (error != GL_NO_ERROR) + warning("%s:%d: GL error: %s", file, line, getGlErrStr(error)); +} +#else +#define CHECK_GL_ERROR() do {} while (false) +#endif + +// Supported GL extensions +static bool npot_supported = false; +#ifdef GL_OES_draw_texture +static bool draw_tex_supported = false; +#endif + +static inline GLfixed xdiv(int numerator, int denominator) { + assert(numerator < (1<<16)); + return (numerator << 16) / denominator; +} + +template +static T nextHigher2(T k) { + if (k == 0) + return 1; + --k; + for (uint i = 1; i < sizeof(T)*CHAR_BIT; i <<= 1) + k = k | k >> i; + return k + 1; +} + +void GLESTexture::initGLExtensions() { + const char* ext_string = + reinterpret_cast(glGetString(GL_EXTENSIONS)); + __android_log_print(ANDROID_LOG_INFO, LOG_TAG, + "Extensions: %s", ext_string); + Common::StringTokenizer tokenizer(ext_string, " "); + while (!tokenizer.empty()) { + Common::String token = tokenizer.nextToken(); + if (token == "GL_ARB_texture_non_power_of_two") + npot_supported = true; +#ifdef GL_OES_draw_texture + if (token == "GL_OES_draw_texture") + draw_tex_supported = true; +#endif + } +} + +GLESTexture::GLESTexture() : + _texture_width(0), + _texture_height(0), + _all_dirty(true) +{ + glGenTextures(1, &_texture_name); + // This all gets reset later in allocBuffer: + _surface.w = 0; + _surface.h = 0; + _surface.pitch = _texture_width; + _surface.pixels = NULL; + _surface.bytesPerPixel = 0; +} + +GLESTexture::~GLESTexture() { + debug("Destroying texture %u", _texture_name); + glDeleteTextures(1, &_texture_name); +} + +void GLESTexture::reinitGL() { + glGenTextures(1, &_texture_name); + setDirty(); +} + +void GLESTexture::allocBuffer(GLuint w, GLuint h) { + CHECK_GL_ERROR(); + int bpp = bytesPerPixel(); + _surface.w = w; + _surface.h = h; + _surface.bytesPerPixel = bpp; + + if (w <= _texture_width && h <= _texture_height) + // Already allocated a sufficiently large buffer + return; + + if (npot_supported) { + _texture_width = _surface.w; + _texture_height = _surface.h; + } else { + _texture_width = nextHigher2(_surface.w); + _texture_height = nextHigher2(_surface.h); + } + _surface.pitch = _texture_width * bpp; + + // Allocate room for the texture now, but pixel data gets uploaded + // later (perhaps with multiple TexSubImage2D operations). + CHECK_GL_ERROR(); + glBindTexture(GL_TEXTURE_2D, _texture_name); + CHECK_GL_ERROR(); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + CHECK_GL_ERROR(); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + CHECK_GL_ERROR(); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + CHECK_GL_ERROR(); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + CHECK_GL_ERROR(); + glTexImage2D(GL_TEXTURE_2D, 0, glFormat(), + _texture_width, _texture_height, + 0, glFormat(), glType(), NULL); + CHECK_GL_ERROR(); +} + +void GLESTexture::updateBuffer(GLuint x, GLuint y, GLuint w, GLuint h, + const void* buf, int pitch) { + ENTER("updateBuffer(%u, %u, %u, %u, %p, %d)", x, y, w, h, buf, pitch); + glBindTexture(GL_TEXTURE_2D, _texture_name); + + if (static_cast(w) * bytesPerPixel() == pitch) { + glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, + glFormat(), glType(), buf); + } else { + // GLES removed the ability to specify pitch, so we + // have to do this row by row. + int i = h; + const byte* src = static_cast(buf); + do { + glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, + w, 1, glFormat(), glType(), src); + ++y; + src += pitch; + } while (--i); + } + + setDirtyRect(Common::Rect(x, y, x+w, y+h)); +} + +void GLESTexture::fillBuffer(byte x) { + byte tmpbuf[_surface.h * _surface.w * bytesPerPixel()]; + memset(tmpbuf, 0, _surface.h * _surface.w * bytesPerPixel()); + glBindTexture(GL_TEXTURE_2D, _texture_name); + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, _surface.w, _surface.h, + glFormat(), glType(), tmpbuf); + setDirty(); +} + +void GLESTexture::drawTexture(GLshort x, GLshort y, GLshort w, GLshort h) { + glBindTexture(GL_TEXTURE_2D, _texture_name); + +#ifdef GL_OES_draw_texture + // Great extension, but only works under specific conditions. + // Still a work-in-progress - disabled for now. + if (false && draw_tex_supported && paletteSize() == 0) { + //glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); + const GLint crop[4] = {0, _surface.h, _surface.w, -_surface.h}; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop); + glDrawTexiOES(x, y, 0, w, h); + } else +#endif + { + const GLfixed tex_width = xdiv(_surface.w, _texture_width); + const GLfixed tex_height = xdiv(_surface.h, _texture_height); + const GLfixed texcoords[] = { + 0, 0, + tex_width, 0, + 0, tex_height, + tex_width, tex_height, + }; + glTexCoordPointer(2, GL_FIXED, 0, texcoords); + + const GLshort vertices[] = { + x, y, + x+w, y, + x, y+h, + x+w, y+h, + }; + glVertexPointer(2, GL_SHORT, 0, vertices); + + assert(ARRAYSIZE(vertices) == ARRAYSIZE(texcoords)); + glDrawArrays(GL_TRIANGLE_STRIP, 0, ARRAYSIZE(vertices)/2); + } + + _all_dirty = false; + _dirty_rect = Common::Rect(); +} + +GLESPaletteTexture::GLESPaletteTexture() : + GLESTexture(), + _texture(NULL) +{ +} + +GLESPaletteTexture::~GLESPaletteTexture() { + delete[] _texture; +} + +void GLESPaletteTexture::allocBuffer(GLuint w, GLuint h) { + CHECK_GL_ERROR(); + int bpp = bytesPerPixel(); + _surface.w = w; + _surface.h = h; + _surface.bytesPerPixel = bpp; + + if (w <= _texture_width && h <= _texture_height) + // Already allocated a sufficiently large buffer + return; + + if (npot_supported) { + _texture_width = _surface.w; + _texture_height = _surface.h; + } else { + _texture_width = nextHigher2(_surface.w); + _texture_height = nextHigher2(_surface.h); + } + _surface.pitch = _texture_width * bpp; + + // Texture gets uploaded later (from drawTexture()) + + byte* new_buffer = new byte[paletteSize() + + _texture_width * _texture_height * bytesPerPixel()]; + if (_texture) { + memcpy(new_buffer, _texture, paletteSize()); // preserve palette + delete[] _texture; + } + _texture = new_buffer; + _surface.pixels = _texture + paletteSize(); +} + +void GLESPaletteTexture::fillBuffer(byte x) { + assert(_surface.pixels); + memset(_surface.pixels, x, _surface.pitch * _surface.h); + setDirty(); +} + +void GLESPaletteTexture::updateBuffer(GLuint x, GLuint y, + GLuint w, GLuint h, + const void* buf, int pitch) { + const byte* src = static_cast(buf); + byte* dst = static_cast(_surface.getBasePtr(x, y)); + do { + memcpy(dst, src, w * bytesPerPixel()); + dst += _surface.pitch; + src += pitch; + } while (--h); +} + +void GLESPaletteTexture::uploadTexture() const { + const size_t texture_size = + paletteSize() + _texture_width * _texture_height * bytesPerPixel(); + glCompressedTexImage2D(GL_TEXTURE_2D, 0, glType(), + _texture_width, _texture_height, + 0, texture_size, _texture); + CHECK_GL_ERROR(); +} + +void GLESPaletteTexture::drawTexture(GLshort x, GLshort y, GLshort w, GLshort h) { + if (_all_dirty) { + glBindTexture(GL_TEXTURE_2D, _texture_name); + CHECK_GL_ERROR(); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + CHECK_GL_ERROR(); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + CHECK_GL_ERROR(); + uploadTexture(); + _all_dirty = false; + } + + GLESTexture::drawTexture(x, y, w, h); +} diff --git a/backends/platform/android/video.h b/backends/platform/android/video.h new file mode 100644 index 000000000000..ee707e4cb5f5 --- /dev/null +++ b/backends/platform/android/video.h @@ -0,0 +1,140 @@ +/* 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/null/null.cpp $ + * $Id: null.cpp 34912 2008-11-06 15:02:50Z fingolfin $ + * + */ + +#if defined(ANDROID) + +#include + +#include "graphics/surface.h" + +#include "common/rect.h" +#include "common/array.h" + +class GLESTexture { +public: + static void initGLExtensions(); + + GLESTexture(); + virtual ~GLESTexture(); + virtual void reinitGL(); + virtual void allocBuffer(GLuint width, GLuint height); + const Graphics::Surface* surface_const() const { return &_surface; } + GLuint width() const { return _surface.w; } + GLuint height() const { return _surface.h; } + GLuint texture_name() const { return _texture_name; } + bool dirty() const { return _all_dirty || !_dirty_rect.isEmpty(); } + virtual void updateBuffer(GLuint x, GLuint y, GLuint width, GLuint height, + const void* buf, int pitch); + virtual void fillBuffer(byte x); + virtual void drawTexture() { + drawTexture(0, 0, _surface.w, _surface.h); + } + virtual void drawTexture(GLshort x, GLshort y, GLshort w, GLshort h); + +protected: + virtual byte bytesPerPixel() const = 0; + virtual GLenum glFormat() const = 0; + virtual GLenum glType() const = 0; + virtual size_t paletteSize() const { return 0; }; + void setDirty() { + _all_dirty = true; + _dirty_rect = Common::Rect(); + } + void setDirtyRect(const Common::Rect& r) { + if (!_all_dirty) { + if (_dirty_rect.isEmpty()) + _dirty_rect = r; + else + _dirty_rect.extend(r); + } + } + GLuint _texture_name; + Graphics::Surface _surface; + GLuint _texture_width; + GLuint _texture_height; + bool _all_dirty; + Common::Rect _dirty_rect; // Covers dirty area +}; + +// RGBA4444 texture +class GLES4444Texture : public GLESTexture { +protected: + virtual byte bytesPerPixel() const { return 2; } + virtual GLenum glFormat() const { return GL_RGBA; } + virtual GLenum glType() const { return GL_UNSIGNED_SHORT_4_4_4_4; } +}; + +// RGB565 texture +class GLES565Texture : public GLESTexture { +protected: + virtual byte bytesPerPixel() const { return 2; } + virtual GLenum glFormat() const { return GL_RGB; } + virtual GLenum glType() const { return GL_UNSIGNED_SHORT_5_6_5; } +}; + +// RGB888 256-entry paletted texture +class GLESPaletteTexture : public GLESTexture { +public: + GLESPaletteTexture(); + virtual ~GLESPaletteTexture(); + virtual void allocBuffer(GLuint width, GLuint height); + virtual void updateBuffer(GLuint x, GLuint y, GLuint width, GLuint height, + const void* buf, int pitch); + Graphics::Surface* surface() { + setDirty(); + return &_surface; + } + void* pixels() { + setDirty(); + return _surface.pixels; + } + const byte* palette_const() const { return _texture; }; + byte* palette() { + setDirty(); + return _texture; + }; + virtual void drawTexture() { + drawTexture(0, 0, _surface.w, _surface.h); + } + virtual void drawTexture(GLshort x, GLshort y, GLshort w, GLshort h); + virtual void fillBuffer(byte x); +protected: + virtual byte bytesPerPixel() const { return 1; } + virtual GLenum glFormat() const { return GL_RGB; } + virtual GLenum glType() const { return GL_PALETTE8_RGB8_OES; } + virtual size_t paletteSize() const { return 256 * 3; }; + virtual void uploadTexture() const; + byte* _texture; +}; + +// RGBA8888 256-entry paletted texture +class GLESPaletteATexture : public GLESPaletteTexture { +protected: + virtual GLenum glFormat() const { return GL_RGBA; } + virtual GLenum glType() const { return GL_PALETTE8_RGBA8_OES; } + virtual size_t paletteSize() const { return 256 * 4; }; +}; + +#endif diff --git a/dists/android/AndroidManifest.xml b/dists/android/AndroidManifest.xml new file mode 100644 index 000000000000..9eb1d995f00b --- /dev/null +++ b/dists/android/AndroidManifest.xml @@ -0,0 +1,75 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/dists/android/AndroidManifest.xml.in b/dists/android/AndroidManifest.xml.in new file mode 100644 index 000000000000..a7fd283f0105 --- /dev/null +++ b/dists/android/AndroidManifest.xml.in @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +