From 07daba6efa05a59271ce4173a2b500b27773e523 Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Thu, 10 Dec 2015 00:47:16 +0300 Subject: Copy modernopengl into mobileopengl2 backend. In future it will be reworked into OpenGL ES 2. --- src/CMakeLists.txt | 2 + src/Makefile.am | 2 + src/enums/render/rendertype.h | 3 +- src/render/mobileopengl2graphics.cpp | 1372 ++++++++++++++++++++++++++++++++++ src/render/mobileopengl2graphics.h | 140 ++++ src/render/rendererslistsdl.h | 18 +- src/render/rendererslistsdl2.h | 18 +- src/resources/image.h | 1 + 8 files changed, 1543 insertions(+), 13 deletions(-) create mode 100644 src/render/mobileopengl2graphics.cpp create mode 100644 src/render/mobileopengl2graphics.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index d26960d28..a6d39bb7c 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1007,6 +1007,8 @@ SET(SRCS render/mglxinit.cpp render/mglxinit.h render/mglxtypes.h + render/mobileopengl2graphics.cpp + render/mobileopengl2graphics.h render/mobileopenglgraphics.cpp render/mobileopenglgraphics.h render/modernopenglgraphics.cpp diff --git a/src/Makefile.am b/src/Makefile.am index e8d71f876..aa6a254c1 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -512,6 +512,8 @@ SRC += events/actionevent.h \ render/mglxinit.cpp \ render/mglxinit.h \ render/mglxtypes.h \ + render/mobileopengl2graphics.cpp \ + render/mobileopengl2graphics.h \ render/mobileopenglgraphics.cpp \ render/mobileopenglgraphics.h \ render/modernopenglgraphics.cpp \ diff --git a/src/enums/render/rendertype.h b/src/enums/render/rendertype.h index 9799b92fc..b0be9f351 100644 --- a/src/enums/render/rendertype.h +++ b/src/enums/render/rendertype.h @@ -29,7 +29,8 @@ enum RenderType RENDER_GLES_OPENGL = 3, RENDER_SDL2_DEFAULT = 4, RENDER_MODERN_OPENGL = 5, - RENDER_NULL = 6, + RENDER_GLES2_OPENGL = 6, + RENDER_NULL = 7, RENDER_LAST }; diff --git a/src/render/mobileopengl2graphics.cpp b/src/render/mobileopengl2graphics.cpp new file mode 100644 index 000000000..b049d2ede --- /dev/null +++ b/src/render/mobileopengl2graphics.cpp @@ -0,0 +1,1372 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2015 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * 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 + * 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, see . + */ + +#if defined USE_OPENGL && !defined ANDROID + +#include "render/mobileopengl2graphics.h" + +#include "configuration.h" +#include "graphicsmanager.h" +#include "graphicsvertexes.h" +#include "logger.h" + +#include "render/mgl.h" + +#include "render/shaders/shaderprogram.h" +#include "render/shaders/shadersmanager.h" + +#include "resources/image.h" +#include "resources/imagerect.h" +#include "resources/openglimagehelper.h" + +#include "utils/delete2.h" +#include "utils/sdlcheckutils.h" +#include "utils/sdlhelper.h" + +#include "debug.h" + +#define vertFill2D(var, x1, y1, x2, y2, dstX, dstY, w, h) \ + var[vp + 0] = dstX; \ + var[vp + 1] = dstY; \ + var[vp + 2] = x1; \ + var[vp + 3] = y1; \ + \ + var[vp + 4] = dstX + w; \ + var[vp + 5] = dstY; \ + var[vp + 6] = x2; \ + var[vp + 7] = y1; \ + \ + var[vp + 8] = dstX + w; \ + var[vp + 9] = dstY + h; \ + var[vp + 10] = x2; \ + var[vp + 11] = y2; \ + \ + var[vp + 12] = dstX; \ + var[vp + 13] = dstY; \ + var[vp + 14] = x1; \ + var[vp + 15] = y1; \ + \ + var[vp + 16] = dstX; \ + var[vp + 17] = dstY + h; \ + var[vp + 18] = x1; \ + var[vp + 19] = y2; \ + \ + var[vp + 20] = dstX + w; \ + var[vp + 21] = dstY + h; \ + var[vp + 22] = x2; \ + var[vp + 23] = y2; + +GLuint MobileOpenGL2Graphics::mTextureBinded = 0; +#ifdef DEBUG_DRAW_CALLS +unsigned int MobileOpenGL2Graphics::mDrawCalls = 0; +unsigned int MobileOpenGL2Graphics::mLastDrawCalls = 0; +#endif + +MobileOpenGL2Graphics::MobileOpenGL2Graphics() : + mIntArray(nullptr), + mIntArrayCached(nullptr), + mProgram(nullptr), + mAlphaCached(1.0F), + mVpCached(0), + mFloatColor(1.0F), + mMaxVertices(500), + mProgramId(0U), + mSimpleColorUniform(0U), + mPosAttrib(0), + mTextureColorUniform(0U), + mScreenUniform(0U), + mDrawTypeUniform(0U), + mVao(0U), + mVbo(0U), + mEbo(0U), + mVboBinded(0U), + mEboBinded(0U), + mAttributesBinded(0U), + mColorAlpha(false), + mTextureDraw(false), +#ifdef DEBUG_BIND_TEXTURE + mOldTexture(), + mOldTextureId(0), +#endif + mFbo() +{ + mOpenGL = RENDER_GLES2_OPENGL; + mName = "mobile OpenGL ES 2"; +} + +MobileOpenGL2Graphics::~MobileOpenGL2Graphics() +{ + deleteArraysInternal(); + deleteGLObjects(); +} + +void MobileOpenGL2Graphics::deleteGLObjects() +{ + delete2(mProgram); + if (mVbo) + { +// logger->log("delete buffer vbo: %u", mVbo); + mglDeleteBuffers(1, &mVbo); + } + if (mEbo) + { +// logger->log("delete buffer ebo: %u", mEbo); + mglDeleteBuffers(1, &mEbo); + } + if (mVao) + mglDeleteVertexArrays(1, &mVao); +} + +void MobileOpenGL2Graphics::initArrays(const int vertCount) +{ + mMaxVertices = vertCount; + if (mMaxVertices < 500) + mMaxVertices = 500; + else if (mMaxVertices > 1024) + mMaxVertices = 1024; + + // need alocate small size, after if limit reached reallocate to double size + const size_t sz = mMaxVertices * 4 + 30; + vertexBufSize = mMaxVertices; + if (!mIntArray) + mIntArray = new GLint[sz]; + if (!mIntArrayCached) + mIntArrayCached = new GLint[sz]; +} + +void MobileOpenGL2Graphics::postInit() +{ + mglGenVertexArrays(1, &mVao); + mglBindVertexArray(mVao); + mglGenBuffers(1, &mVbo); +// logger->log("gen vbo buffer: %u", mVbo); + bindArrayBuffer(mVbo); + mglGenBuffers(1, &mEbo); +// logger->log("gen ebo buffer: %u", mEbo); + bindElementBuffer(mEbo); + + logger->log("Compiling shaders"); + mProgram = shaders.getSimpleProgram(); + if (!mProgram) + { + graphicsManager.logError(); + logger->safeError("Shader creation error. See manaplus.log."); + } + mProgramId = mProgram->getProgramId(); + if (!mProgram) + logger->error("Shaders compilation error."); + + logger->log("Shaders compilation done."); + mglUseProgram(mProgramId); + + mPosAttrib = mglGetAttribLocation(mProgramId, "position"); + mglEnableVertexAttribArray(mPosAttrib); + mglVertexAttribIFormat(mPosAttrib, 4, GL_INT, 0); + + mSimpleColorUniform = mglGetUniformLocation(mProgramId, "color"); + mScreenUniform = mglGetUniformLocation(mProgramId, "screen"); + mDrawTypeUniform = mglGetUniformLocation(mProgramId, "drawType"); + mTextureColorUniform = mglGetUniformLocation(mProgramId, "alpha"); + + mglUniform1f(mTextureColorUniform, 1.0f); + + mglBindVertexBuffer(0, mVbo, 0, 4 * sizeof(GLint)); + mglVertexAttribBinding(mPosAttrib, 0); +// mglVertexAttribIPointer(mPosAttrib, 4, GL_INT, 4 * sizeof(GLint), 0); + mAttributesBinded = mVbo; + + mglUniform2f(mScreenUniform, + static_cast(mWidth) / 2.0f, + static_cast(mHeight) / 2.0f); +} + +void MobileOpenGL2Graphics::screenResized() +{ + deleteGLObjects(); + mVboBinded = 0U; + mEboBinded = 0U; + mAttributesBinded = 0U; + postInit(); +} + +void MobileOpenGL2Graphics::deleteArrays() +{ + deleteArraysInternal(); +} + +void MobileOpenGL2Graphics::deleteArraysInternal() +{ + delete [] mIntArray; + mIntArray = nullptr; + delete [] mIntArrayCached; + mIntArrayCached = nullptr; +} + +bool MobileOpenGL2Graphics::setVideoMode(const int w, const int h, + const int scale, + const int bpp, + const bool fs, + const bool hwaccel, + const bool resize, + const bool noFrame) +{ + setMainFlags(w, h, scale, bpp, fs, hwaccel, resize, noFrame); + + return setOpenGLMode(); +} + +void MobileOpenGL2Graphics::setColor(const Color &color) +{ + mColorAlpha = (color.a != 255); + if (mColor != color) + { + mColor = color; + mglUniform4f(mSimpleColorUniform, + static_cast(color.r) / 255.0F, + static_cast(color.g) / 255.0F, + static_cast(color.b) / 255.0F, + static_cast(color.a) / 255.0F); + } +} + +void MobileOpenGL2Graphics::setColorAlpha(const float alpha) +{ + if (mAlphaCached != alpha) + { + mAlphaCached = alpha; + mglUniform1f(mTextureColorUniform, alpha); + } +} + +void MobileOpenGL2Graphics::drawQuad(const int srcX, const int srcY, + const int dstX, const int dstY, + const int width, const int height) +{ + const int texX2 = srcX + width; + const int texY2 = srcY + height; + const int x2 = dstX + width; + const int y2 = dstY + height; + + GLint vertices[] = + { + dstX, dstY, srcX, srcY, + x2, dstY, texX2, srcY, + dstX, y2, srcX, texY2, + x2, y2, texX2, texY2 + }; + +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); + mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), + vertices, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +} + +void MobileOpenGL2Graphics::drawRescaledQuad(const int srcX, const int srcY, + const int dstX, const int dstY, + const int width, const int height, + const int desiredWidth, + const int desiredHeight) +{ + const int texX2 = srcX + width; + const int texY2 = srcY + height; + const int x2 = dstX + desiredWidth; + const int y2 = dstY + desiredHeight; + + GLint vertices[] = + { + dstX, dstY, srcX, srcY, + x2, dstY, texX2, srcY, + dstX, y2, srcX, texY2, + x2, y2, texX2, texY2 + }; + +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); + mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), + vertices, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +} + +void MobileOpenGL2Graphics::drawImage(const Image *const image, + int dstX, int dstY) +{ + drawImageInline(image, dstX, dstY); +} + +void MobileOpenGL2Graphics::drawImageInline(const Image *const image, + int dstX, int dstY) +{ + FUNC_BLOCK("Graphics::drawImage", 1) + if (!image) + return; + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(GL_TEXTURE_2D, image->mGLImage); + setTexturingAndBlending(true); + bindArrayBufferAndAttributes(mVbo); + setColorAlpha(image->mAlpha); + + const ClipRect &clipArea = mClipStack.top(); + const SDL_Rect &imageRect = image->mBounds; + drawQuad(imageRect.x, imageRect.y, + dstX + clipArea.xOffset, dstY + clipArea.yOffset, + imageRect.w, imageRect.h); +} + +void MobileOpenGL2Graphics::copyImage(const Image *const image, + int dstX, int dstY) +{ + drawImageInline(image, dstX, dstY); +} + +void MobileOpenGL2Graphics::testDraw() +{ +/* + GLint vertices[] = + { + 0, 0, 0, 0, + 800, 0, 800, 0, + 0, 600, 0, 600, + 800, 600, 800, 600 + }; +*/ +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); +// logger->log("allocate ebo: %d, %ld", mEboBinded, sizeof(elements)); +// mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), +// vertices, GL_STREAM_DRAW); +// mglBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), +// elements, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +// glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_INT, 0); +} + +void MobileOpenGL2Graphics::drawImageCached(const Image *const image A_UNUSED, + int A_UNUSED x, int y A_UNUSED) +{ +} + +void MobileOpenGL2Graphics::drawPatternCached(const Image *const image A_UNUSED, + const int x A_UNUSED, + const int y A_UNUSED, + const int w A_UNUSED, + const int h A_UNUSED) +{ +} + +void MobileOpenGL2Graphics::completeCache() +{ +} + +void MobileOpenGL2Graphics::drawRescaledImage(const Image *const image, + int dstX, int dstY, + const int desiredWidth, + const int desiredHeight) +{ + if (!image) + return; + + const SDL_Rect &imageRect = image->mBounds; + + // Just draw the image normally when no resizing is necessary, + if (imageRect.w == desiredWidth && imageRect.h == desiredHeight) + { + drawImageInline(image, dstX, dstY); + return; + } + + setColorAlpha(image->mAlpha); +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + setTexturingAndBlending(true); + bindArrayBufferAndAttributes(mVbo); + + const ClipRect &clipArea = mClipStack.top(); + // Draw a textured quad. + drawRescaledQuad(imageRect.x, imageRect.y, + dstX + clipArea.xOffset, dstY + clipArea.yOffset, + imageRect.w, imageRect.h, + desiredWidth, desiredHeight); +} + +void MobileOpenGL2Graphics::drawPattern(const Image *const image, + const int x, const int y, + const int w, const int h) +{ + drawPatternInline(image, x, y, w, h); +} + +void MobileOpenGL2Graphics::drawPatternInline(const Image *const image, + const int x, const int y, + const int w, const int h) +{ + if (!image) + return; + + const SDL_Rect &imageRect = image->mBounds; + const int srcX = imageRect.x; + const int srcY = imageRect.y; + const int iw = imageRect.w; + const int ih = imageRect.h; + + if (iw == 0 || ih == 0) + return; + + const ClipRect &clipArea = mClipStack.top(); + const int x2 = x + clipArea.xOffset; + const int y2 = y + clipArea.yOffset; + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + + setTexturingAndBlending(true); + bindArrayBufferAndAttributes(mVbo); + setColorAlpha(image->mAlpha); + + unsigned int vp = 0; + const unsigned int vLimit = mMaxVertices * 4; + + for (int py = 0; py < h; py += ih) + { + const int height = (py + ih >= h) ? h - py : ih; + const int texY2 = srcY + height; + const int dstY = y2 + py; + for (int px = 0; px < w; px += iw) + { + const int width = (px + iw >= w) ? w - px : iw; + const int dstX = x2 + px; + + const int texX2 = srcX + width; + + vertFill2D(mIntArray, + srcX, srcY, texX2, texY2, + dstX, dstY, width, height); + + vp += 24; + if (vp >= vLimit) + { + drawTriangleArray(vp); + vp = 0; + } + } + } + if (vp > 0) + drawTriangleArray(vp); +} + +void MobileOpenGL2Graphics::drawRescaledPattern(const Image *const image, + const int x, const int y, + const int w, const int h, + const int scaledWidth, + const int scaledHeight) +{ + if (!image) + return; + + if (scaledWidth == 0 || scaledHeight == 0) + return; + + const SDL_Rect &imageRect = image->mBounds; + const int srcX = imageRect.x; + const int srcY = imageRect.y; + const int iw = imageRect.w; + const int ih = imageRect.h; + if (iw == 0 || ih == 0) + return; + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + + setTexturingAndBlending(true); + bindArrayBufferAndAttributes(mVbo); + setColorAlpha(image->mAlpha); + + unsigned int vp = 0; + const unsigned int vLimit = mMaxVertices * 4; + + const ClipRect &clipArea = mClipStack.top(); + const int x2 = x + clipArea.xOffset; + const int y2 = y + clipArea.yOffset; + + const float scaleFactorW = static_cast(scaledWidth) / iw; + const float scaleFactorH = static_cast(scaledHeight) / ih; + + for (int py = 0; py < h; py += scaledHeight) + { + const int height = (py + scaledHeight >= h) + ? h - py : scaledHeight; + const int dstY = y2 + py; + const int scaledY = srcY + height / scaleFactorH; + for (int px = 0; px < w; px += scaledWidth) + { + const int width = (px + scaledWidth >= w) + ? w - px : scaledWidth; + const int dstX = x2 + px; + const int scaledX = srcX + width / scaleFactorW; + + vertFill2D(mIntArray, + srcX, srcY, scaledX, scaledY, + dstX, dstY, width, height); + + vp += 24; + if (vp >= vLimit) + { + drawTriangleArray(vp); + vp = 0; + } + } + } + if (vp > 0) + drawTriangleArray(vp); +} + +inline void MobileOpenGL2Graphics::drawVertexes(const + OpenGLGraphicsVertexes &ogl) +{ + const std::vector &vp = ogl.mVp; + const std::vector &vbos = ogl.mVbo; + std::vector::const_iterator ivp; + std::vector::const_iterator ivbo; + const std::vector::const_iterator ivp_end = vp.end(); + +/* + if (vp.size() != vbos.size()) + logger->log("different size in vp and vbos"); +*/ + + for (ivp = vp.begin(), ivbo = vbos.begin(); + ivp != ivp_end; + ++ ivp, ++ ivbo) + { + bindArrayBufferAndAttributes(*ivbo); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif +// logger->log("draw from array: %u", *ivbo); + glDrawArrays(GL_TRIANGLES, 0, *ivp / 4); + } +} + +void MobileOpenGL2Graphics::calcPattern(ImageVertexes *const vert, + const Image *const image, + const int x, const int y, + const int w, const int h) const +{ + calcPatternInline(vert, image, x, y, w, h); +} + +void MobileOpenGL2Graphics::calcPatternInline(ImageVertexes *const vert, + const Image *const image, + const int x, const int y, + const int w, const int h) const +{ + if (!image || !vert) + return; + + const SDL_Rect &imageRect = image->mBounds; + const int srcX = imageRect.x; + const int srcY = imageRect.y; + const int iw = imageRect.w; + const int ih = imageRect.h; + + if (iw == 0 || ih == 0) + return; + + const ClipRect &clipArea = mClipStack.top(); + const int x2 = x + clipArea.xOffset; + const int y2 = y + clipArea.yOffset; + + const unsigned int vLimit = mMaxVertices * 4; + + OpenGLGraphicsVertexes &ogl = vert->ogl; + unsigned int vp = ogl.continueVp(); + + GLint *intArray = ogl.continueIntTexArray(); + + for (int py = 0; py < h; py += ih) + { + const int height = (py + ih >= h) ? h - py : ih; + const int dstY = y2 + py; + const int texY2 = srcY + height; + for (int px = 0; px < w; px += iw) + { + const int width = (px + iw >= w) ? w - px : iw; + const int dstX = x2 + px; + const int texX2 = srcX + width; + + vertFill2D(intArray, + srcX, srcY, texX2, texY2, + dstX, dstY, width, height); + + vp += 24; + if (vp >= vLimit) + { + intArray = ogl.switchIntTexArray(); + ogl.switchVp(vp); + vp = 0; + } + } + } + ogl.switchVp(vp); +} + +void MobileOpenGL2Graphics::calcTileCollection(ImageCollection *const vertCol, + const Image *const image, + int x, int y) +{ + if (!vertCol || !image) + return; + if (vertCol->currentGLImage != image->mGLImage) + { + ImageVertexes *const vert = new ImageVertexes(); + vertCol->currentGLImage = image->mGLImage; + vertCol->currentVert = vert; + vert->image = image; + vertCol->draws.push_back(vert); + calcTileVertexesInline(vert, image, x, y); + } + else + { + calcTileVertexesInline(vertCol->currentVert, image, x, y); + } +} + +void MobileOpenGL2Graphics::drawTileCollection(const ImageCollection + *const vertCol) +{ + if (!vertCol) + return; + setTexturingAndBlending(true); +/* + if (!vertCol) + { + logger->log("MobileOpenGL2Graphics::drawTileCollection" + " vertCol is nullptr"); + } +*/ + const ImageVertexesVector &draws = vertCol->draws; + const ImageCollectionCIter it_end = draws.end(); + for (ImageCollectionCIter it = draws.begin(); it != it_end; ++ it) + { + const ImageVertexes *const vert = *it; + const Image *const image = vert->image; + + setColorAlpha(image->mAlpha); +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + drawVertexes(vert->ogl); + } +} + +void MobileOpenGL2Graphics::calcPattern(ImageCollection* const vertCol, + const Image *const image, + const int x, const int y, + const int w, const int h) const +{ + if (!vertCol || !image) + return; + ImageVertexes *vert = nullptr; + if (vertCol->currentGLImage != image->mGLImage) + { + vert = new ImageVertexes(); + vertCol->currentGLImage = image->mGLImage; + vertCol->currentVert = vert; + vert->image = image; + vertCol->draws.push_back(vert); + } + else + { + vert = vertCol->currentVert; + } + + calcPatternInline(vert, image, x, y, w, h); +} + +void MobileOpenGL2Graphics::calcTileVertexes(ImageVertexes *const vert, + const Image *const image, + int dstX, int dstY) const +{ + calcTileVertexesInline(vert, image, dstX, dstY); +} + +void MobileOpenGL2Graphics::calcTileVertexesInline(ImageVertexes *const vert, + const Image *const image, + int dstX, int dstY) const +{ + if (!vert || !image) + return; + + const SDL_Rect &imageRect = image->mBounds; + const int srcX = imageRect.x; + const int srcY = imageRect.y; + const int w = imageRect.w; + const int h = imageRect.h; + + if (w == 0 || h == 0) + return; + + const ClipRect &clipArea = mClipStack.top(); + const int x2 = dstX + clipArea.xOffset; + const int y2 = dstY + clipArea.yOffset; + + const unsigned int vLimit = mMaxVertices * 4; + + OpenGLGraphicsVertexes &ogl = vert->ogl; + + unsigned int vp = ogl.continueVp(); + + int texX2 = srcX + w; + int texY2 = srcY + h; + + GLint *const intArray = ogl.continueIntTexArray(); + + vertFill2D(intArray, + srcX, srcY, texX2, texY2, + x2, y2, w, h); + + vp += 24; + if (vp >= vLimit) + { + ogl.switchIntTexArray(); + ogl.switchVp(vp); + vp = 0; + } + + ogl.switchVp(vp); +} + +void MobileOpenGL2Graphics::drawTileVertexes(const ImageVertexes *const vert) +{ + if (!vert) + return; + const Image *const image = vert->image; + + setColorAlpha(image->mAlpha); +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + setTexturingAndBlending(true); + bindArrayBufferAndAttributes(mVbo); + + drawVertexes(vert->ogl); +} + +void MobileOpenGL2Graphics::calcWindow(ImageCollection *const vertCol, + const int x, const int y, + const int w, const int h, + const ImageRect &imgRect) +{ + if (!vertCol) + return; + ImageVertexes *vert = nullptr; + const Image *const image = imgRect.grid[4]; + if (!image) + return; + if (vertCol->currentGLImage != image->mGLImage) + { + vert = new ImageVertexes(); + vertCol->currentGLImage = image->mGLImage; + vertCol->currentVert = vert; + vert->image = image; + vertCol->draws.push_back(vert); + } + else + { + vert = vertCol->currentVert; + } + calcImageRect(vert, x, y, w, h, imgRect); +} + +void MobileOpenGL2Graphics::updateScreen() +{ + BLOCK_START("Graphics::updateScreen") +#ifdef DEBUG_DRAW_CALLS + mLastDrawCalls = mDrawCalls; + mDrawCalls = 0; +#endif +#ifdef USE_SDL2 + SDL_GL_SwapWindow(mWindow); +#else + SDL_GL_SwapBuffers(); +#endif +#ifdef DEBUG_OPENGL + if (isGLNotNull(mglFrameTerminator)) + mglFrameTerminator(); +#endif +// may be need clear? +// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + BLOCK_END("Graphics::updateScreen") +} + +void MobileOpenGL2Graphics::beginDraw() +{ + setOpenGLFlags(); + glDisable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB); + glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB, GL_FASTEST); + pushClipArea(Rect(0, 0, mRect.w, mRect.h)); +} + +void MobileOpenGL2Graphics::endDraw() +{ + popClipArea(); +} + +void MobileOpenGL2Graphics::prepareScreenshot() +{ + if (config.getBoolValue("usefbo")) + graphicsManager.createFBO(mRect.w, mRect.h, &mFbo); +} + +SDL_Surface* MobileOpenGL2Graphics::getScreenshot() +{ + const int h = mRect.h; + const int w = mRect.w - (mRect.w % 4); + GLint pack = 1; + + SDL_Surface *const screenshot = MSDL_CreateRGBSurface( + SDL_SWSURFACE, w, h, 24, + 0xff0000, 0x00ff00, 0x0000ff, 0x000000); + + if (!screenshot) + return nullptr; + + if (SDL_MUSTLOCK(screenshot)) + SDL_LockSurface(screenshot); + + const size_t lineSize = 3 * w; + GLubyte *const buf = new GLubyte[lineSize]; + + // Grap the pixel buffer and write it to the SDL surface + glGetIntegerv(GL_PACK_ALIGNMENT, &pack); + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glReadPixels(0, 0, w, h, GL_RGB, GL_UNSIGNED_BYTE, screenshot->pixels); + + // Flip the screenshot, as OpenGL has 0,0 in bottom left + const int h2 = h / 2; + for (int i = 0; i < h2; i++) + { + GLubyte *const top = static_cast( + screenshot->pixels) + lineSize * i; + GLubyte *const bot = static_cast( + screenshot->pixels) + lineSize * (h - 1 - i); + + memcpy(buf, top, lineSize); + memcpy(top, bot, lineSize); + memcpy(bot, buf, lineSize); + } + + delete [] buf; + + if (config.getBoolValue("usefbo")) + graphicsManager.deleteFBO(&mFbo); + + glPixelStorei(GL_PACK_ALIGNMENT, pack); + + if (SDL_MUSTLOCK(screenshot)) + SDL_UnlockSurface(screenshot); + + return screenshot; +} + +void MobileOpenGL2Graphics::pushClipArea(const Rect &area) +{ + Graphics::pushClipArea(area); + const ClipRect &clipArea = mClipStack.top(); + + glScissor(clipArea.x * mScale, + (mRect.h - clipArea.y - clipArea.height) * mScale, + clipArea.width * mScale, + clipArea.height * mScale); +} + +void MobileOpenGL2Graphics::popClipArea() +{ + if (mClipStack.empty()) + return; + Graphics::popClipArea(); + if (mClipStack.empty()) + return; + + const ClipRect &clipArea = mClipStack.top(); + glScissor(clipArea.x * mScale, + (mRect.h - clipArea.y - clipArea.height) * mScale, + clipArea.width * mScale, + clipArea.height * mScale); +} + +void MobileOpenGL2Graphics::drawPoint(int x, int y) +{ + setTexturingAndBlending(false); + bindArrayBufferAndAttributes(mVbo); + const ClipRect &clipArea = mClipStack.top(); + GLint vertices[] = + { + x + clipArea.xOffset, y + clipArea.yOffset, 0, 0 + }; +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); + mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), + vertices, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_POINTS, 0, 1); +} + +void MobileOpenGL2Graphics::drawLine(int x1, int y1, int x2, int y2) +{ + setTexturingAndBlending(false); + bindArrayBufferAndAttributes(mVbo); + const ClipRect &clipArea = mClipStack.top(); + GLint vertices[] = + { + x1 + clipArea.xOffset, y1 + clipArea.yOffset, 0, 0, + x2 + clipArea.xOffset, y2 + clipArea.yOffset, 0, 0 + }; +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); + mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), + vertices, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_LINES, 0, 2); +} + +void MobileOpenGL2Graphics::drawRectangle(const Rect& rect) +{ + setTexturingAndBlending(false); + bindArrayBufferAndAttributes(mVbo); + const ClipRect &clipArea = mClipStack.top(); + const int x1 = rect.x + clipArea.xOffset; + const int y1 = rect.y + clipArea.yOffset; + const int x2 = x1 + rect.width; + const int y2 = y1 + rect.height; + GLint vertices[] = + { + x1, y1, 0, 0, + x1, y2, 0, 0, + x2, y2, 0, 0, + x2, y1, 0, 0 + }; + +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); + mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), + vertices, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_LINE_LOOP, 0, 4); +} + +void MobileOpenGL2Graphics::fillRectangle(const Rect& rect) +{ + setTexturingAndBlending(false); + bindArrayBufferAndAttributes(mVbo); + const ClipRect &clipArea = mClipStack.top(); + const int x1 = rect.x + clipArea.xOffset; + const int y1 = rect.y + clipArea.yOffset; + const int x2 = x1 + rect.width; + const int y2 = y1 + rect.height; + GLint vertices[] = + { + x1, y1, 0, 0, + x2, y1, 0, 0, + x1, y2, 0, 0, + x2, y2, 0, 0 + }; + +// logger->log("allocate: %d, %ld", mVboBinded, sizeof(vertices)); + mglBufferData(GL_ARRAY_BUFFER, sizeof(vertices), + vertices, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); +} + +void MobileOpenGL2Graphics::setTexturingAndBlending(const bool enable) +{ + if (enable) + { + if (!mTextureDraw) + { + mTextureDraw = true; + mglUniform1f(mDrawTypeUniform, 1.0f); + } + if (!mAlpha) + { + glEnable(GL_BLEND); + mAlpha = true; + } + } + else + { + if (mTextureDraw) + { + mTextureDraw = false; + mglUniform1f(mDrawTypeUniform, 0.0f); + } + if (mAlpha && !mColorAlpha) + { + glDisable(GL_BLEND); + mAlpha = false; + } + else if (!mAlpha && mColorAlpha) + { + glEnable(GL_BLEND); + mAlpha = true; + } + } +} + +void MobileOpenGL2Graphics::drawRectangle(const Rect& rect A_UNUSED, + const bool filled A_UNUSED) +{ +} + +void MobileOpenGL2Graphics::drawNet(const int x1, const int y1, + const int x2, const int y2, + const int width, const int height) +{ + unsigned int vp = 0; + const unsigned int vLimit = mMaxVertices * 4; + + setTexturingAndBlending(false); + bindArrayBufferAndAttributes(mVbo); + const ClipRect &clipArea = mClipStack.top(); + const GLint dx = clipArea.xOffset; + const GLint dy = clipArea.yOffset; + + const GLint xs1 = x1 + dx; + const GLint xs2 = x2 + dx; + const GLint ys1 = y1 + dy; + const GLint ys2 = y2 + dy; + + for (int y = y1; y < y2; y += height) + { + mIntArray[vp + 0] = xs1; + mIntArray[vp + 1] = y; + mIntArray[vp + 2] = 0; + mIntArray[vp + 3] = 0; + + mIntArray[vp + 4] = xs2; + mIntArray[vp + 5] = y; + mIntArray[vp + 6] = 0; + mIntArray[vp + 7] = 0; + + vp += 8; + if (vp >= vLimit) + { + drawLineArrays(vp); + vp = 0; + } + } + + for (int x = x1; x < x2; x += width) + { + mIntArray[vp + 0] = x; + mIntArray[vp + 1] = ys1; + mIntArray[vp + 2] = 0.0f; + mIntArray[vp + 3] = 0.0f; + + mIntArray[vp + 4] = x; + mIntArray[vp + 5] = ys2; + mIntArray[vp + 6] = 0.0f; + mIntArray[vp + 7] = 0.0f; + + vp += 8; + if (vp >= vLimit) + { + drawLineArrays(vp); + vp = 0; + } + } + + if (vp > 0) + drawLineArrays(vp); +} + +void MobileOpenGL2Graphics::bindTexture(const GLenum target, + const GLuint texture) +{ + if (mTextureBinded != texture) + { + mTextureBinded = texture; + glBindTexture(target, texture); + } +} + +void MobileOpenGL2Graphics::removeArray(const uint32_t sz, + uint32_t *const arr) +{ + mglDeleteBuffers(sz, arr); + for (size_t f = 0; f < sz; f ++) + { + if (arr[f] == mVboBinded) + mVboBinded = 0; +// logger->log("delete buffers: %u", arr[f]); + } +} + +void MobileOpenGL2Graphics::bindArrayBuffer(const GLuint vbo) +{ + if (mVboBinded != vbo) + { + mVboBinded = vbo; +// logger->log("bind array: %u", vbo); + mglBindBuffer(GL_ARRAY_BUFFER, vbo); +/* + if (mglIsBuffer(vbo) != GL_TRUE) + logger->log("bind wrong buffer: %u", vbo); +*/ + mAttributesBinded = 0U; + } +} + +void MobileOpenGL2Graphics::bindElementBuffer(const GLuint ebo) +{ + if (mEboBinded != ebo) + { + mEboBinded = ebo; + logger->log("bind element: %u", ebo); + mglBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo); +/* + if (mglIsBuffer(ebo) != GL_TRUE) + logger->log("bind wrong buffer: %u", vbo); +*/ + } +} + +void MobileOpenGL2Graphics::bindArrayBufferAndAttributes(const GLuint vbo) +{ + if (mVboBinded != vbo) + { + mVboBinded = vbo; +// logger->log("bind array: %u", vbo); + mglBindBuffer(GL_ARRAY_BUFFER, vbo); +/* + if (mglIsBuffer(vbo) != GL_TRUE) + logger->log("bind wrong buffer: %u", vbo); +*/ + + mAttributesBinded = mVboBinded; +// logger->log("bind vertex buffer: %u", mVboBinded); + mglBindVertexBuffer(0, mVboBinded, 0, 4 * sizeof(GLint)); +// mglVertexAttribIPointer(mPosAttrib, 4, GL_INT, 4 * sizeof(GLint), 0); +// mglVertexAttribBinding(mPosAttrib, 0); + } + else if (mAttributesBinded != mVboBinded) + { + mAttributesBinded = mVboBinded; +// logger->log("bind vertex buffer: %u", mVboBinded); + mglBindVertexBuffer(0, mVboBinded, 0, 4 * sizeof(GLint)); +// mglVertexAttribIPointer(mPosAttrib, 4, GL_INT, 4 * sizeof(GLint), 0); +// mglVertexAttribBinding(mPosAttrib, 0); + } +} + +void MobileOpenGL2Graphics::bindAttributes() +{ + if (mAttributesBinded != mVboBinded) + { + mAttributesBinded = mVboBinded; + mglBindVertexBuffer(0, mVboBinded, 0, 4 * sizeof(GLint)); +// mglVertexAttribIPointer(mPosAttrib, 4, GL_INT, 4 * sizeof(GLint), 0); +// mglVertexAttribBinding(mPosAttrib, 0); + } +} + +void MobileOpenGL2Graphics::dumpSettings() +{ + GLint test[1000]; + logger->log("\n\n"); + logger->log("start opengl dump"); + for (int f = 0; f < 65535; f ++) + { + test[0] = 0; + test[1] = 0; + test[2] = 0; + test[3] = 0; + glGetIntegerv(f, &test[0]); + if (test[0] || test[1] || test[2] || test[3]) + { + logger->log("\n%d = %d, %d, %d, %d", f, + test[0], test[1], test[2], test[3]); + } + } +} + +void MobileOpenGL2Graphics::drawImageRect(const int x, const int y, + const int w, const int h, + const ImageRect &imgRect) +{ + #include "render/graphics_drawImageRect.hpp" +} + +void MobileOpenGL2Graphics::calcImageRect(ImageVertexes *const vert, + const int x, const int y, + const int w, const int h, + const ImageRect &imgRect) +{ + #include "render/graphics_calcImageRect.hpp" +} + +void MobileOpenGL2Graphics::clearScreen() const +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); +} + +void MobileOpenGL2Graphics::createGLContext() +{ + if (mGLContext) + SDL::makeCurrentContext(mGLContext); + else + mGLContext = SDL::createGLContext(mWindow, 3, 3, 0x01); +} + +void MobileOpenGL2Graphics::finalize(ImageCollection *const col) +{ + if (!col) + return; + FOR_EACH (ImageCollectionIter, it, col->draws) + finalize(*it); +} + +void MobileOpenGL2Graphics::finalize(ImageVertexes *const vert) +{ + // in future need convert in each switchVp/continueVp + + if (!vert) + return; + OpenGLGraphicsVertexes &ogl = vert->ogl; + const std::vector &vp = ogl.mVp; + std::vector::const_iterator ivp; + const std::vector::const_iterator ivp_end = vp.end(); + std::vector &intTexPool = ogl.mIntTexPool; + std::vector::const_iterator ft; + const std::vector::const_iterator ft_end = intTexPool.end(); + std::vector &vbos = ogl.mVbo; + std::vector::const_iterator ivbo; + + const int sz = static_cast(intTexPool.size()); + vbos.resize(sz); + mglGenBuffers(sz, &vbos[0]); +/* + for (int f = 0; f < sz; f ++) + logger->log("gen buffers: %u", vbos[f]); +*/ + + for (ft = intTexPool.begin(), ivp = vp.begin(), ivbo = vbos.begin(); + ft != ft_end && ivp != ivp_end; + ++ ft, ++ ivp, ++ ivbo) + { + bindArrayBuffer(*ivbo); +/* + logger->log("allocate: %d, %ld", mVboBinded, + (*ivp) * sizeof(GLint)); +*/ + mglBufferData(GL_ARRAY_BUFFER, (*ivp) * sizeof(GLint), + *ft, GL_STATIC_DRAW); + } + + for (std::vector::iterator it = intTexPool.begin(); + it != intTexPool.end(); ++ it) + { + delete [] (*it); + } + intTexPool.clear(); +} + +void MobileOpenGL2Graphics::drawTriangleArray(const int size) +{ +// logger->log("allocate: %d, %ld", mVboBinded, size * sizeof(GLint)); + mglBufferData(GL_ARRAY_BUFFER, size * sizeof(GLint), + mIntArray, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_TRIANGLES, 0, size / 4); +} + +void MobileOpenGL2Graphics::drawTriangleArray(const GLint *const array, + const int size) +{ +// logger->log("allocate: %d, %ld", mVboBinded, size * sizeof(GLint)); + mglBufferData(GL_ARRAY_BUFFER, size * sizeof(GLint), + array, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_TRIANGLES, 0, size / 4); +} + +void MobileOpenGL2Graphics::drawLineArrays(const int size) +{ +// logger->log("allocate: %d, %ld", mVboBinded, size * sizeof(GLint)); + mglBufferData(GL_ARRAY_BUFFER, size * sizeof(GLint), + mIntArray, GL_STREAM_DRAW); +#ifdef DEBUG_DRAW_CALLS + mDrawCalls ++; +#endif + glDrawArrays(GL_LINES, 0, size / 4); +} + +#ifdef DEBUG_BIND_TEXTURE +void MobileOpenGL2Graphics::debugBindTexture(const Image *const image) +{ + const std::string texture = image->getIdPath(); + if (mOldTexture != texture) + { + if ((!mOldTexture.empty() || !texture.empty()) + && mOldTextureId != image->mGLImage) + { + logger->log("bind: %s (%d) to %s (%d)", mOldTexture.c_str(), + mOldTextureId, texture.c_str(), image->mGLImage); + } + mOldTextureId = image->mGLImage; + mOldTexture = texture; + } +} +#else +void MobileOpenGL2Graphics::debugBindTexture(const Image *const image A_UNUSED) +{ +} +#endif + +#endif // USE_OPENGL diff --git a/src/render/mobileopengl2graphics.h b/src/render/mobileopengl2graphics.h new file mode 100644 index 000000000..ea31daf6b --- /dev/null +++ b/src/render/mobileopengl2graphics.h @@ -0,0 +1,140 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2015 The ManaPlus Developers + * + * This file is part of The ManaPlus Client. + * + * 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 + * 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, see . + */ + +#ifndef RENDER_MOBILEOPENGL2GRAPHICS_H +#define RENDER_MOBILEOPENGL2GRAPHICS_H + +#if defined USE_OPENGL && !defined ANDROID + +#include "localconsts.h" +#include "render/graphics.h" + +#include "resources/fboinfo.h" + +#ifdef ANDROID +#include +#include +#include +#else +#ifndef USE_SDL2 +#define GL_GLEXT_PROTOTYPES 1 +#endif +#include +#ifndef __native_client__ +#include +#endif +#endif + +class OpenGLGraphicsVertexes; +class ShaderProgram; + +class MobileOpenGL2Graphics final : public Graphics +{ + public: + MobileOpenGL2Graphics(); + + A_DELETE_COPY(MobileOpenGL2Graphics) + + ~MobileOpenGL2Graphics(); + + void postInit() override final; + + void setColor(const Color &color) override final; + + void screenResized() override final; + + void finalize(ImageCollection *const col) override final; + + void finalize(ImageVertexes *const vert) override final; + + void testDraw() override final; + + void removeArray(const uint32_t id, + uint32_t *const arr) override final A_NONNULL(3); + + void createGLContext() override final; + + #include "render/graphicsdef.hpp" + + #include "render/openglgraphicsdef.hpp" + + #include "render/openglgraphicsdefadvanced.hpp" + + private: + void deleteGLObjects(); + + inline void drawQuad(const int srcX, const int srcY, + const int dstX, const int dstY, + const int width, const int height); + + inline void drawRescaledQuad(const int srcX, const int srcY, + const int dstX, const int dstY, + const int width, const int height, + const int desiredWidth, + const int desiredHeight); + + inline void drawTriangleArray(const int size); + + inline void drawTriangleArray(const GLint *const array, + const int size); + + inline void drawLineArrays(const int size); + + inline void bindArrayBuffer(const GLuint vbo); + + inline void bindArrayBufferAndAttributes(const GLuint vbo); + + inline void bindAttributes(); + + inline void bindElementBuffer(const GLuint ebo); + + GLint *mIntArray A_NONNULLPOINTER; + GLint *mIntArrayCached A_NONNULLPOINTER; + ShaderProgram *mProgram; + float mAlphaCached; + int mVpCached; + + float mFloatColor; + int mMaxVertices; + GLuint mProgramId; + GLuint mSimpleColorUniform; + GLint mPosAttrib; + GLint mTextureColorUniform; + GLuint mScreenUniform; + GLuint mDrawTypeUniform; + GLuint mVao; + GLuint mVbo; + GLuint mEbo; + GLuint mVboBinded; + GLuint mEboBinded; + GLuint mAttributesBinded; + bool mColorAlpha; + bool mTextureDraw; +#ifdef DEBUG_BIND_TEXTURE + std::string mOldTexture; + unsigned mOldTextureId; +#endif + FBOInfo mFbo; +}; +#endif + +#endif // RENDER_MOBILEOPENGL2GRAPHICS_H diff --git a/src/render/rendererslistsdl.h b/src/render/rendererslistsdl.h index 9bb0e1353..3c09b5dc8 100644 --- a/src/render/rendererslistsdl.h +++ b/src/render/rendererslistsdl.h @@ -58,7 +58,8 @@ const int renderToIndex[] = 1, // RENDER_SAFE_OPENGL 1, // RENDER_GLES_OPENGL 1, // RENDER_SDL2_DEFAULT - 1 // RENDER_MODERN_OPENGL + 1, // RENDER_MODERN_OPENGL + 1 // RENDER_GLES2_OPENGL }; #else // ANDROID @@ -71,7 +72,8 @@ const RenderType indexToRender[] = RENDER_NORMAL_OPENGL, RENDER_SAFE_OPENGL, RENDER_GLES_OPENGL, - RENDER_MODERN_OPENGL + RENDER_MODERN_OPENGL, + RENDER_GLES2_OPENGL }; const char *OPENGL_NAME[] = @@ -85,10 +87,12 @@ const char *OPENGL_NAME[] = // TRANSLATORS: draw backend N_("Mobile OpenGL ES"), // TRANSLATORS: draw backend - N_("Modern OpenGL") + N_("Modern OpenGL"), + // TRANSLATORS: draw backend + N_("Mobile OpenGL ES 2"), }; -const int renderModesListSize = 5; +const int renderModesListSize = 6; const int renderToIndex[] = { @@ -97,7 +101,8 @@ const int renderToIndex[] = 2, // RENDER_SAFE_OPENGL 3, // RENDER_GLES_OPENGL 0, // RENDER_SDL2_DEFAULT - 4 // RENDER_MODERN_OPENGL + 4, // RENDER_MODERN_OPENGL + 5 // RENDER_GLES2_OPENGL }; #endif // ANDROID @@ -126,7 +131,8 @@ const int renderToIndex[] = 0, // RENDER_SAFE_OPENGL 0, // RENDER_GLES_OPENGL 0, // RENDER_SDL2_DEFAULT - 0 // RENDER_MODERN_OPENGL + 0, // RENDER_MODERN_OPENGL + 0 // RENDER_GLES2_OPENGL }; #endif // USE_OPENGL diff --git a/src/render/rendererslistsdl2.h b/src/render/rendererslistsdl2.h index 3629438b8..d40b8617a 100644 --- a/src/render/rendererslistsdl2.h +++ b/src/render/rendererslistsdl2.h @@ -56,7 +56,8 @@ const int renderToIndex[] = 2, // RENDER_SAFE_OPENGL 2, // RENDER_GLES_OPENGL 1, // RENDER_SDL2_DEFAULT - 2 // RENDER_MODERN_OPENGL + 2, // RENDER_MODERN_OPENGL + 2 // RENDER_GLES_OPENGL }; #else // ANDROID @@ -70,7 +71,8 @@ const RenderType indexToRender[] = RENDER_NORMAL_OPENGL, RENDER_SAFE_OPENGL, RENDER_GLES_OPENGL, - RENDER_MODERN_OPENGL + RENDER_MODERN_OPENGL, + RENDER_GLES2_OPENGL }; const char *OPENGL_NAME[] = @@ -86,10 +88,12 @@ const char *OPENGL_NAME[] = // TRANSLATORS: draw backend N_("Mobile OpenGL ES"), // TRANSLATORS: draw backend - N_("Modern OpenGL") + N_("Modern OpenGL"), + // TRANSLATORS: draw backend + N_("Mobile OpenGL ES 2") }; -const int renderModesListSize = 6; +const int renderModesListSize = 7; const int renderToIndex[] = { @@ -98,7 +102,8 @@ const int renderToIndex[] = 3, // RENDER_SAFE_OPENGL 4, // RENDER_GLES_OPENGL 1, // RENDER_SDL2_DEFAULT - 5 // RENDER_MODERN_OPENGL + 5, // RENDER_MODERN_OPENGL + 6 // RENDER_GLES2_OPENGL }; #endif // ANDROID @@ -130,7 +135,8 @@ const int renderToIndex[] = 0, // RENDER_SAFE_OPENGL 0, // RENDER_GLES_OPENGL 1, // RENDER_SDL2_DEFAULT - 0 // RENDER_MODERN_OPENGL + 0, // RENDER_MODERN_OPENGL + 0 // RENDER_GLES2_OPENGL }; #endif // USE_OPENGL diff --git a/src/resources/image.h b/src/resources/image.h index 0484f52b7..804df4c2e 100644 --- a/src/resources/image.h +++ b/src/resources/image.h @@ -67,6 +67,7 @@ class Image notfinal : public Resource friend class TestLauncher; #ifdef USE_OPENGL friend class AtlasManager; + friend class MobileOpenGL2Graphics; friend class MobileOpenGLGraphics; friend class ModernOpenGLGraphics; friend class NormalOpenGLGraphics; -- cgit v1.2.3-60-g2f50