summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/CMakeLists.txt2
-rw-r--r--src/Makefile.am2
-rw-r--r--src/enums/render/rendertype.h3
-rw-r--r--src/render/mobileopengl2graphics.cpp1372
-rw-r--r--src/render/mobileopengl2graphics.h140
-rw-r--r--src/render/rendererslistsdl.h18
-rw-r--r--src/render/rendererslistsdl2.h18
-rw-r--r--src/resources/image.h1
8 files changed, 1543 insertions, 13 deletions
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 <http://www.gnu.org/licenses/>.
+ */
+
+#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<float>(mWidth) / 2.0f,
+ static_cast<float>(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<float>(color.r) / 255.0F,
+ static_cast<float>(color.g) / 255.0F,
+ static_cast<float>(color.b) / 255.0F,
+ static_cast<float>(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<float>(scaledWidth) / iw;
+ const float scaleFactorH = static_cast<float>(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<int> &vp = ogl.mVp;
+ const std::vector<GLuint> &vbos = ogl.mVbo;
+ std::vector<int>::const_iterator ivp;
+ std::vector<GLuint>::const_iterator ivbo;
+ const std::vector<int>::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<GLubyte*>(
+ screenshot->pixels) + lineSize * i;
+ GLubyte *const bot = static_cast<GLubyte*>(
+ 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<int> &vp = ogl.mVp;
+ std::vector<int>::const_iterator ivp;
+ const std::vector<int>::const_iterator ivp_end = vp.end();
+ std::vector<GLint*> &intTexPool = ogl.mIntTexPool;
+ std::vector<GLint*>::const_iterator ft;
+ const std::vector<GLint*>::const_iterator ft_end = intTexPool.end();
+ std::vector<GLuint> &vbos = ogl.mVbo;
+ std::vector<GLuint>::const_iterator ivbo;
+
+ const int sz = static_cast<int>(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<GLint*>::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 <http://www.gnu.org/licenses/>.
+ */
+
+#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 <GLES/gl.h>
+#include <GLES/glext.h>
+#include <GLES2/gl2.h>
+#else
+#ifndef USE_SDL2
+#define GL_GLEXT_PROTOTYPES 1
+#endif
+#include <SDL_opengl.h>
+#ifndef __native_client__
+#include <GL/glext.h>
+#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;
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-11-19 19:46:41 +0000