From 08f911af478cb3bbede503a3e704b61da713b74e Mon Sep 17 00:00:00 2001 From: Andrei Karas Date: Thu, 19 Jul 2012 21:32:43 +0300 Subject: Rename openglgraphics to normalopenglgraphics. --- src/CMakeLists.txt | 4 +- src/Makefile.am | 4 +- src/commandhandler.cpp | 4 +- src/compoundsprite.cpp | 2 +- src/graphicsmanager.cpp | 2 +- src/graphicsvertexes.cpp | 26 +- src/graphicsvertexes.h | 14 +- src/normalopenglgraphics.cpp | 1431 +++++++++++++++++++++++++++++++++++ src/normalopenglgraphics.h | 175 +++++ src/openglgraphics.cpp | 1424 ---------------------------------- src/openglgraphics.h | 175 ----- src/resources/image.cpp | 2 +- src/resources/image.h | 2 +- src/resources/openglimagehelper.cpp | 4 +- src/resources/subimage.cpp | 2 +- src/safeopenglgraphics.cpp | 53 +- 16 files changed, 1666 insertions(+), 1658 deletions(-) create mode 100644 src/normalopenglgraphics.cpp create mode 100644 src/normalopenglgraphics.h delete mode 100644 src/openglgraphics.cpp delete mode 100644 src/openglgraphics.h diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 94d39ed4a..26a571c54 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -586,8 +586,8 @@ SET(SRCS map.h maplayer.cpp maplayer.h - openglgraphics.cpp - openglgraphics.h + normalopenglgraphics.cpp + normalopenglgraphics.h particle.cpp particle.h particlecontainer.cpp diff --git a/src/Makefile.am b/src/Makefile.am index b69cce69b..2eac1be38 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -599,8 +599,8 @@ manaplus_SOURCES += gui/widgets/avatarlistbox.cpp \ map.h \ maplayer.cpp \ maplayer.h \ - openglgraphics.cpp\ - openglgraphics.h \ + normalopenglgraphics.cpp\ + normalopenglgraphics.h \ particle.cpp \ particle.h \ particlecontainer.cpp \ diff --git a/src/commandhandler.cpp b/src/commandhandler.cpp index 75f4a5331..af87adafd 100644 --- a/src/commandhandler.cpp +++ b/src/commandhandler.cpp @@ -58,7 +58,7 @@ #include "net/tradehandler.h" #if defined USE_OPENGL -#include "openglgraphics.h" +#include "normalopenglgraphics.h" #endif #ifdef DEBUG_DUMP_LEAKS1 @@ -1367,6 +1367,6 @@ void CommandHandler::handleDumpOGL(const std::string &args A_UNUSED, ChatTab *tab A_UNUSED) { #if defined USE_OPENGL - OpenGLGraphics::dumpSettings(); + NormalOpenGLGraphics::dumpSettings(); #endif } diff --git a/src/compoundsprite.cpp b/src/compoundsprite.cpp index f3ccac072..91c8b16bc 100644 --- a/src/compoundsprite.cpp +++ b/src/compoundsprite.cpp @@ -26,7 +26,7 @@ #include "graphics.h" #ifdef USE_OPENGL -#include "openglgraphics.h" +#include "normalopenglgraphics.h" #include "safeopenglgraphics.h" #endif diff --git a/src/graphicsmanager.cpp b/src/graphicsmanager.cpp index f18f8c03d..cb5b2698b 100644 --- a/src/graphicsmanager.cpp +++ b/src/graphicsmanager.cpp @@ -168,7 +168,7 @@ void GraphicsManager::initGraphics(bool noOpenGL) case 1: default: imageHelper = new OpenGLImageHelper; - mainGraphics = new OpenGLGraphics; + mainGraphics = new NormalOpenGLGraphics; break; case 2: imageHelper = new OpenGLImageHelper; diff --git a/src/graphicsvertexes.cpp b/src/graphicsvertexes.cpp index a74d6558b..d09bc2d91 100644 --- a/src/graphicsvertexes.cpp +++ b/src/graphicsvertexes.cpp @@ -42,7 +42,7 @@ SDLGraphicsVertexes::~SDLGraphicsVertexes() } #ifdef USE_OPENGL -OpenGLGraphicsVertexes::OpenGLGraphicsVertexes() : +NormalOpenGLGraphicsVertexes::NormalOpenGLGraphicsVertexes() : ptr(0), mFloatTexArray(nullptr), mIntTexArray(nullptr), @@ -54,12 +54,12 @@ OpenGLGraphicsVertexes::OpenGLGraphicsVertexes() : mVp.reserve(30); } -OpenGLGraphicsVertexes::~OpenGLGraphicsVertexes() +NormalOpenGLGraphicsVertexes::~NormalOpenGLGraphicsVertexes() { clear(); } -void OpenGLGraphicsVertexes::clear() +void NormalOpenGLGraphicsVertexes::clear() { for (std::vector::iterator it = mFloatTexPool.begin(); it != mFloatTexPool.end(); ++ it) @@ -92,38 +92,38 @@ void OpenGLGraphicsVertexes::clear() } } -void OpenGLGraphicsVertexes::init() +void NormalOpenGLGraphicsVertexes::init() { clear(); } -GLfloat *OpenGLGraphicsVertexes::switchFloatTexArray() +GLfloat *NormalOpenGLGraphicsVertexes::switchFloatTexArray() { mFloatTexArray = new GLfloat[vertexBufSize * 4 + 30]; mFloatTexPool.push_back(mFloatTexArray); return mFloatTexArray; } -GLint *OpenGLGraphicsVertexes::switchIntVertArray() +GLint *NormalOpenGLGraphicsVertexes::switchIntVertArray() { mIntVertArray = new GLint[vertexBufSize * 4 + 30]; mIntVertPool.push_back(mIntVertArray); return mIntVertArray; } -GLint *OpenGLGraphicsVertexes::switchIntTexArray() +GLint *NormalOpenGLGraphicsVertexes::switchIntTexArray() { mIntTexArray = new GLint[vertexBufSize * 4 + 30]; mIntTexPool.push_back(mIntTexArray); return mIntTexArray; } -void OpenGLGraphicsVertexes::switchVp(int n) +void NormalOpenGLGraphicsVertexes::switchVp(int n) { mVp.push_back(n); } -int OpenGLGraphicsVertexes::continueVp() +int NormalOpenGLGraphicsVertexes::continueVp() { if (mVp.empty()) { @@ -137,7 +137,7 @@ int OpenGLGraphicsVertexes::continueVp() } } -GLfloat *OpenGLGraphicsVertexes::continueFloatTexArray() +GLfloat *NormalOpenGLGraphicsVertexes::continueFloatTexArray() { if (mFloatTexPool.empty()) { @@ -151,7 +151,7 @@ GLfloat *OpenGLGraphicsVertexes::continueFloatTexArray() return mFloatTexArray; } -GLint *OpenGLGraphicsVertexes::continueIntVertArray() +GLint *NormalOpenGLGraphicsVertexes::continueIntVertArray() { if (mIntVertPool.empty()) { @@ -165,7 +165,7 @@ GLint *OpenGLGraphicsVertexes::continueIntVertArray() return mIntVertArray; } -GLint *OpenGLGraphicsVertexes::continueIntTexArray() +GLint *NormalOpenGLGraphicsVertexes::continueIntTexArray() { if (mIntTexPool.empty()) { @@ -239,7 +239,7 @@ ImageVertexes::ImageVertexes() : { sdl.reserve(30); #ifdef USE_OPENGL - ogl = new OpenGLGraphicsVertexes(); + ogl = new NormalOpenGLGraphicsVertexes(); #endif } diff --git a/src/graphicsvertexes.h b/src/graphicsvertexes.h index 70ba4847b..b44f69179 100644 --- a/src/graphicsvertexes.h +++ b/src/graphicsvertexes.h @@ -34,7 +34,7 @@ #include #include "safeopenglgraphics.h" -#include "openglgraphics.h" +#include "normalopenglgraphics.h" #endif #include @@ -65,12 +65,12 @@ class SafeOpenGLGraphicsVertexes { }; -class OpenGLGraphicsVertexes +class NormalOpenGLGraphicsVertexes { public: - OpenGLGraphicsVertexes(); + NormalOpenGLGraphicsVertexes(); - ~OpenGLGraphicsVertexes(); + ~NormalOpenGLGraphicsVertexes(); GLfloat *switchFloatTexArray(); @@ -131,7 +131,7 @@ class ImageVertexes DoubleRects sdl; #ifdef USE_OPENGL - OpenGLGraphicsVertexes *ogl; + NormalOpenGLGraphicsVertexes *ogl; #endif }; @@ -149,7 +149,7 @@ class GraphicsVertexes #ifdef USE_OPENGL // SafeOpenGLGraphicsVertexes ogl1[5]; - OpenGLGraphicsVertexes ogl[5]; + NormalOpenGLGraphicsVertexes ogl[5]; #endif void init(int x, int y, int w, int h); @@ -167,7 +167,7 @@ class GraphicsVertexes { mPtr = num; } #ifdef USE_OPENGL - OpenGLGraphicsVertexes* getOGL() + NormalOpenGLGraphicsVertexes* getOGL() { return &ogl[mPtr]; } #endif diff --git a/src/normalopenglgraphics.cpp b/src/normalopenglgraphics.cpp new file mode 100644 index 000000000..1114f1620 --- /dev/null +++ b/src/normalopenglgraphics.cpp @@ -0,0 +1,1431 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2012 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 . + */ + +#include "main.h" + +#ifdef USE_OPENGL + +#include "graphicsvertexes.h" +#include "normalopenglgraphics.h" +#include "configuration.h" +#include "logger.h" + +#include "resources/image.h" +#include "resources/openglimagehelper.h" + +#include "utils/stringutils.h" + +#include + +#include "debug.h" + +#ifndef GL_TEXTURE_RECTANGLE_ARB +#define GL_TEXTURE_RECTANGLE_ARB 0x84F5 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 +#endif + +const unsigned int vertexBufSize = 500; + +GLuint NormalOpenGLGraphics::mLastImage = 0; + +NormalOpenGLGraphics::NormalOpenGLGraphics(): + mFloatTexArray(new GLfloat[vertexBufSize * 4 + 30]), + mIntTexArray(new GLint[vertexBufSize * 4 + 30]), + mIntVertArray(new GLint[vertexBufSize * 4 + 30]), + mAlpha(false), + mTexture(false), + mColorAlpha(false), + mFboId(0), + mTextureId(0), +#ifdef DEBUG_BIND_TEXTURE + mRboId(0), + mOldTextureId(0) +#else + mRboId(0) +#endif +{ + mOpenGL = 1; + mName = "fast OpenGL"; +} + +NormalOpenGLGraphics::~NormalOpenGLGraphics() +{ + delete [] mFloatTexArray; + delete [] mIntTexArray; + delete [] mIntVertArray; +} + +bool NormalOpenGLGraphics::setVideoMode(int w, int h, int bpp, bool fs, + bool hwaccel, bool resize, + bool noFrame) +{ + setMainFlags(w, h, bpp, fs, hwaccel, resize, noFrame); + + return setOpenGLMode(); +} + +static inline void drawQuad(const Image *image, + int srcX, int srcY, int dstX, int dstY, + int width, int height) +{ + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + // Find OpenGL normalized texture coordinates. + const float texX1 = static_cast(srcX) / + static_cast(image->getTextureWidth()); + const float texY1 = static_cast(srcY) / + static_cast(image->getTextureHeight()); + const float texX2 = static_cast(srcX + width) / + static_cast(image->getTextureWidth()); + const float texY2 = static_cast(srcY + height) / + static_cast(image->getTextureHeight()); + + GLfloat tex[] = + { + texX1, texY1, + texX2, texY1, + texX2, texY2, + texX1, texY2 + }; + + GLint vert[] = + { + dstX, dstY, + dstX + width, dstY, + dstX + width, dstY + height, + dstX, dstY + height + }; + + glVertexPointer(2, GL_INT, 0, &vert); + glTexCoordPointer(2, GL_FLOAT, 0, &tex); + + glDrawArrays(GL_QUADS, 0, 4); + } + else + { + GLint tex[] = + { + srcX, srcY, + srcX + width, srcY, + srcX + width, srcY + height, + srcX, srcY + height + }; + GLint vert[] = + { + dstX, dstY, + dstX + width, dstY, + dstX + width, dstY + height, + dstX, dstY + height + }; + + glVertexPointer(2, GL_INT, 0, &vert); + glTexCoordPointer(2, GL_INT, 0, &tex); + + glDrawArrays(GL_QUADS, 0, 4); + } +} + +static inline void drawRescaledQuad(Image *image, + int srcX, int srcY, int dstX, int dstY, + int width, int height, + int desiredWidth, int desiredHeight) +{ + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + // Find OpenGL normalized texture coordinates. + const float texX1 = static_cast(srcX) / + static_cast(image->getTextureWidth()); + const float texY1 = static_cast(srcY) / + static_cast(image->getTextureHeight()); + const float texX2 = static_cast(srcX + width) / + static_cast(image->getTextureWidth()); + const float texY2 = static_cast(srcY + height) / + static_cast(image->getTextureHeight()); + + GLfloat tex[] = + { + texX1, texY1, + texX2, texY1, + texX2, texY2, + texX1, texY2 + }; + + GLint vert[] = + { + dstX, dstY, + dstX + desiredWidth, dstY, + dstX + desiredWidth, dstY + desiredHeight, + dstX, dstY + desiredHeight + }; + + glVertexPointer(2, GL_INT, 0, &vert); + glTexCoordPointer(2, GL_FLOAT, 0, &tex); + + glDrawArrays(GL_QUADS, 0, 4); + } + else + { + GLint tex[] = + { + srcX, srcY, + srcX + width, srcY, + srcX + width, srcY + height, + srcX, srcY + height + }; + GLint vert[] = + { + dstX, dstY, + dstX + desiredWidth, dstY, + dstX + desiredWidth, dstY + desiredHeight, + dstX, dstY + desiredHeight + }; + + glVertexPointer(2, GL_INT, 0, &vert); + glTexCoordPointer(2, GL_INT, 0, &tex); + + glDrawArrays(GL_QUADS, 0, 4); + } +} + + +bool NormalOpenGLGraphics::drawImage2(const Image *image, int srcX, int srcY, + int dstX, int dstY, + int width, int height, bool useColor) +{ + if (!image) + return false; + + srcX += image->mBounds.x; + srcY += image->mBounds.y; + + if (!useColor) + glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + + setTexturingAndBlending(true); + + drawQuad(image, srcX, srcY, dstX, dstY, width, height); + + if (!useColor) + { + glColor4ub(static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); + } + + return true; +} + +bool NormalOpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, + int dstX, int dstY, + int width, int height, + int desiredWidth, + int desiredHeight, + bool useColor) +{ + return drawRescaledImage(image, srcX, srcY, + dstX, dstY, + width, height, + desiredWidth, desiredHeight, + useColor, true); +} + +bool NormalOpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, + int dstX, int dstY, + int width, int height, + int desiredWidth, + int desiredHeight, + bool useColor, bool smooth) +{ + if (!image) + return false; + + // Just draw the image normally when no resizing is necessary, + if (width == desiredWidth && height == desiredHeight) + { + return drawImage2(image, srcX, srcY, dstX, dstY, + width, height, useColor); + } + + // When the desired image is smaller than the current one, + // disable smooth effect. + if (width > desiredWidth && height > desiredHeight) + smooth = false; + + srcX += image->mBounds.x; + srcY += image->mBounds.y; + + if (!useColor) + glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + + setTexturingAndBlending(true); + + // Draw a textured quad. + drawRescaledQuad(image, srcX, srcY, dstX, dstY, width, height, + desiredWidth, desiredHeight); + + if (smooth) // A basic smooth effect... + { + glColor4f(1.0f, 1.0f, 1.0f, 0.2f); + drawRescaledQuad(image, srcX, srcY, dstX - 1, dstY - 1, width, height, + desiredWidth + 1, desiredHeight + 1); + drawRescaledQuad(image, srcX, srcY, dstX + 1, dstY + 1, width, height, + desiredWidth - 1, desiredHeight - 1); + + drawRescaledQuad(image, srcX, srcY, dstX + 1, dstY, width, height, + desiredWidth - 1, desiredHeight); + drawRescaledQuad(image, srcX, srcY, dstX, dstY + 1, width, height, + desiredWidth, desiredHeight - 1); + } + + if (!useColor) + { + glColor4ub(static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); + } + + return true; +} + +void NormalOpenGLGraphics::drawImagePattern(const Image *image, int x, int y, + int w, int h) +{ + if (!image) + return; + + const int srcX = image->mBounds.x; + const int srcY = image->mBounds.y; + + const int iw = image->mBounds.w; + const int ih = image->mBounds.h; + + if (iw == 0 || ih == 0) + return; + + const float tw = static_cast(image->getTextureWidth()); + const float th = static_cast(image->getTextureHeight()); + + glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + + setTexturingAndBlending(true); + + unsigned int vp = 0; + const unsigned int vLimit = vertexBufSize * 4; + // Draw a set of textured rectangles + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + float texX1 = static_cast(srcX) / tw; + float texY1 = static_cast(srcY) / th; + + for (int py = 0; py < h; py += ih) + { + const int height = (py + ih >= h) ? h - py : ih; + const int dstY = y + py; + for (int px = 0; px < w; px += iw) + { + int width = (px + iw >= w) ? w - px : iw; + int dstX = x + px; + + float texX2 = static_cast(srcX + width) / tw; + float texY2 = static_cast(srcY + height) / th; + + mFloatTexArray[vp + 0] = texX1; + mFloatTexArray[vp + 1] = texY1; + + mFloatTexArray[vp + 2] = texX2; + mFloatTexArray[vp + 3] = texY1; + + mFloatTexArray[vp + 4] = texX2; + mFloatTexArray[vp + 5] = texY2; + + mFloatTexArray[vp + 6] = texX1; + mFloatTexArray[vp + 7] = texY2; + + mIntVertArray[vp + 0] = dstX; + mIntVertArray[vp + 1] = dstY; + + mIntVertArray[vp + 2] = dstX + width; + mIntVertArray[vp + 3] = dstY; + + mIntVertArray[vp + 4] = dstX + width; + mIntVertArray[vp + 5] = dstY + height; + + mIntVertArray[vp + 6] = dstX; + mIntVertArray[vp + 7] = dstY + height; + + vp += 8; + if (vp >= vLimit) + { + drawQuadArrayfi(vp); + vp = 0; + } + } + } + if (vp > 0) + drawQuadArrayfi(vp); + } + else + { + for (int py = 0; py < h; py += ih) + { + const int height = (py + ih >= h) ? h - py : ih; + const int dstY = y + py; + for (int px = 0; px < w; px += iw) + { + int width = (px + iw >= w) ? w - px : iw; + int dstX = x + px; + + mIntTexArray[vp + 0] = srcX; + mIntTexArray[vp + 1] = srcY; + + mIntTexArray[vp + 2] = srcX + width; + mIntTexArray[vp + 3] = srcY; + + mIntTexArray[vp + 4] = srcX + width; + mIntTexArray[vp + 5] = srcY + height; + + mIntTexArray[vp + 6] = srcX; + mIntTexArray[vp + 7] = srcY + height; + + mIntVertArray[vp + 0] = dstX; + mIntVertArray[vp + 1] = dstY; + + mIntVertArray[vp + 2] = dstX + width; + mIntVertArray[vp + 3] = dstY; + + mIntVertArray[vp + 4] = dstX + width; + mIntVertArray[vp + 5] = dstY + height; + + mIntVertArray[vp + 6] = dstX; + mIntVertArray[vp + 7] = dstY + height; + + vp += 8; + if (vp >= vLimit) + { + drawQuadArrayii(vp); + vp = 0; + } + } + } + if (vp > 0) + drawQuadArrayii(vp); + } + + glColor4ub(static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); +} + +void NormalOpenGLGraphics::drawRescaledImagePattern(Image *image, + int x, int y, + int w, int h, + int scaledWidth, + int scaledHeight) +{ + if (!image) + return; + + if (scaledWidth == 0 || scaledHeight == 0) + return; + + const int srcX = image->mBounds.x; + const int srcY = image->mBounds.y; + + const int iw = image->getWidth(); + const int ih = image->getHeight(); + if (iw == 0 || ih == 0) + return; + + glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); + +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + + setTexturingAndBlending(true); + + unsigned int vp = 0; + const unsigned int vLimit = vertexBufSize * 4; + + // Draw a set of textured rectangles + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + const float tw = static_cast(image->getTextureWidth()); + const float th = static_cast(image->getTextureHeight()); + + const float texX1 = static_cast(srcX) / tw; + const float texY1 = static_cast(srcY) / th; + + const float tFractionW = iw / tw; + const float tFractionH = ih / th; + + for (int py = 0; py < h; py += scaledHeight) + { + const int height = (py + scaledHeight >= h) + ? h - py : scaledHeight; + const int dstY = y + py; + for (int px = 0; px < w; px += scaledWidth) + { + int width = (px + scaledWidth >= w) ? w - px : scaledWidth; + int dstX = x + px; + const float visibleFractionW = static_cast(width) + / scaledWidth; + const float visibleFractionH = static_cast(height) + / scaledHeight; + + const float texX2 = texX1 + tFractionW * visibleFractionW; + const float texY2 = texY1 + tFractionH * visibleFractionH; + + mFloatTexArray[vp + 0] = texX1; + mFloatTexArray[vp + 1] = texY1; + + mFloatTexArray[vp + 2] = texX2; + mFloatTexArray[vp + 3] = texY1; + + mFloatTexArray[vp + 4] = texX2; + mFloatTexArray[vp + 5] = texY2; + + mFloatTexArray[vp + 6] = texX1; + mFloatTexArray[vp + 7] = texY2; + + mIntVertArray[vp + 0] = dstX; + mIntVertArray[vp + 1] = dstY; + + mIntVertArray[vp + 2] = dstX + width; + mIntVertArray[vp + 3] = dstY; + + mIntVertArray[vp + 4] = dstX + width; + mIntVertArray[vp + 5] = dstY + height; + + mIntVertArray[vp + 6] = dstX; + mIntVertArray[vp + 7] = dstY + height; + + vp += 8; + if (vp >= vLimit) + { + drawQuadArrayfi(vp); + vp = 0; + } + } + } + if (vp > 0) + drawQuadArrayfi(vp); + } + else + { + 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 = y + 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 = x + px; + const int scaledX = srcX + width / scaleFactorW; + + mIntTexArray[vp + 0] = srcX; + mIntTexArray[vp + 1] = srcY; + + mIntTexArray[vp + 2] = scaledX; + mIntTexArray[vp + 3] = srcY; + + mIntTexArray[vp + 4] = scaledX; + mIntTexArray[vp + 5] = scaledY; + + mIntTexArray[vp + 6] = srcX; + mIntTexArray[vp + 7] = scaledY; + + mIntVertArray[vp + 0] = dstX; + mIntVertArray[vp + 1] = dstY; + + mIntVertArray[vp + 2] = dstX + width; + mIntVertArray[vp + 3] = dstY; + + mIntVertArray[vp + 4] = dstX + width; + mIntVertArray[vp + 5] = dstY + height; + + mIntVertArray[vp + 6] = dstX; + mIntVertArray[vp + 7] = dstY + height; + + vp += 8; + if (vp >= vLimit) + { + drawQuadArrayii(vp); + vp = 0; + } + } + } + if (vp > 0) + drawQuadArrayii(vp); + } + + glColor4ub(static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); +} + +void NormalOpenGLGraphics::drawImagePattern2(GraphicsVertexes *vert, + const Image *image) +{ + if (!image) + return; + + NormalOpenGLGraphicsVertexes *ogl = vert->getOGL(); + + glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + setTexturingAndBlending(true); + + std::vector *intVertPool = ogl->getIntVertPool(); + std::vector::const_iterator iv; + std::vector::const_iterator iv_end = intVertPool->end(); + std::vector *vp = ogl->getVp(); + std::vector::const_iterator ivp; + std::vector::const_iterator ivp_end = vp->end(); + + // Draw a set of textured rectangles + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + std::vector *floatTexPool = ogl->getFloatTexPool(); + std::vector::const_iterator ft; + std::vector::const_iterator ft_end = floatTexPool->end(); + + for (iv = intVertPool->begin(), ft = floatTexPool->begin(), + ivp = vp->begin(); + iv != iv_end, ft != ft_end, + ivp != ivp_end; + ++ iv, ++ ft, ++ ivp) + { + drawQuadArrayfi(*iv, *ft, *ivp); + } + } + else + { + std::vector *intTexPool = ogl->getIntTexPool(); + std::vector::const_iterator it; + std::vector::const_iterator it_end = intTexPool->end(); + + for (iv = intVertPool->begin(), it = intTexPool->begin(), + ivp = vp->begin(); + iv != iv_end, it != it_end, + ivp != ivp_end; + ++ iv, ++ it, ++ ivp) + { + drawQuadArrayii(*iv, *it, *ivp); + } + } + + glColor4ub(static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); + +} + +void NormalOpenGLGraphics::calcImagePattern(GraphicsVertexes* vert, + Image *image, + int x, int y, int w, int h) +{ + if (!image) + { + vert->incPtr(1); + return; + } + + const int srcX = image->mBounds.x; + const int srcY = image->mBounds.y; + + const int iw = image->mBounds.w; + const int ih = image->mBounds.h; + + if (iw == 0 || ih == 0) + { + vert->incPtr(1); + return; + } + + const float tw = static_cast(image->getTextureWidth()); + const float th = static_cast(image->getTextureHeight()); + + unsigned int vp = 0; + const unsigned int vLimit = vertexBufSize * 4; + + NormalOpenGLGraphicsVertexes *ogl = vert->getOGL(); + ogl->init(); + + // Draw a set of textured rectangles + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + float texX1 = static_cast(srcX) / tw; + float texY1 = static_cast(srcY) / th; + + GLfloat *floatTexArray = ogl->switchFloatTexArray(); + GLint *intVertArray = ogl->switchIntVertArray(); + + for (int py = 0; py < h; py += ih) + { + const int height = (py + ih >= h) ? h - py : ih; + const int dstY = y + py; + for (int px = 0; px < w; px += iw) + { + int width = (px + iw >= w) ? w - px : iw; + int dstX = x + px; + + float texX2 = static_cast(srcX + width) / tw; + float texY2 = static_cast(srcY + height) / th; + + floatTexArray[vp + 0] = texX1; + floatTexArray[vp + 1] = texY1; + + floatTexArray[vp + 2] = texX2; + floatTexArray[vp + 3] = texY1; + + floatTexArray[vp + 4] = texX2; + floatTexArray[vp + 5] = texY2; + + floatTexArray[vp + 6] = texX1; + floatTexArray[vp + 7] = texY2; + + intVertArray[vp + 0] = dstX; + intVertArray[vp + 1] = dstY; + + intVertArray[vp + 2] = dstX + width; + intVertArray[vp + 3] = dstY; + + intVertArray[vp + 4] = dstX + width; + intVertArray[vp + 5] = dstY + height; + + intVertArray[vp + 6] = dstX; + intVertArray[vp + 7] = dstY + height; + + vp += 8; + if (vp >= vLimit) + { + floatTexArray = ogl->switchFloatTexArray(); + intVertArray = ogl->switchIntVertArray(); + ogl->switchVp(vp); + vp = 0; + } + } + } + } + else + { + GLint *intTexArray = ogl->switchIntTexArray(); + GLint *intVertArray = ogl->switchIntVertArray(); + + for (int py = 0; py < h; py += ih) + { + const int height = (py + ih >= h) ? h - py : ih; + const int dstY = y + py; + for (int px = 0; px < w; px += iw) + { + int width = (px + iw >= w) ? w - px : iw; + int dstX = x + px; + + intTexArray[vp + 0] = srcX; + intTexArray[vp + 1] = srcY; + + intTexArray[vp + 2] = srcX + width; + intTexArray[vp + 3] = srcY; + + intTexArray[vp + 4] = srcX + width; + intTexArray[vp + 5] = srcY + height; + + intTexArray[vp + 6] = srcX; + intTexArray[vp + 7] = srcY + height; + + intVertArray[vp + 0] = dstX; + intVertArray[vp + 1] = dstY; + + intVertArray[vp + 2] = dstX + width; + intVertArray[vp + 3] = dstY; + + intVertArray[vp + 4] = dstX + width; + intVertArray[vp + 5] = dstY + height; + + intVertArray[vp + 6] = dstX; + intVertArray[vp + 7] = dstY + height; + + vp += 8; + if (vp >= vLimit) + { + intTexArray = ogl->switchIntTexArray(); + intVertArray = ogl->switchIntVertArray(); + ogl->switchVp(vp); + vp = 0; + } + } + } + } + ogl->switchVp(vp); + vert->incPtr(1); +} + +void NormalOpenGLGraphics::calcTile(ImageVertexes *vert, int dstX, int dstY) +{ + if (!vert) + return; + + Image *image = vert->image; + const int srcX = image->mBounds.x; + const int srcY = image->mBounds.y; + + const int w = image->mBounds.w; + const int h = image->mBounds.h; + + if (w == 0 || h == 0) + return; + + const float tw = static_cast(image->mTexWidth); + const float th = static_cast(image->mTexHeight); + + const unsigned int vLimit = vertexBufSize * 4; + + NormalOpenGLGraphicsVertexes *ogl = vert->ogl; + + unsigned int vp = ogl->ptr; + + // Draw a set of textured rectangles + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + { + float texX1 = static_cast(srcX) / tw; + float texY1 = static_cast(srcY) / th; + + if (!ogl->mFloatTexArray) + ogl->mFloatTexArray = new GLfloat[vertexBufSize * 4 + 30]; + if (!ogl->mIntVertArray) + ogl->mIntVertArray = new GLint[vertexBufSize * 4 + 30]; + + GLfloat *floatTexArray = ogl->mFloatTexArray; + GLint *intVertArray = ogl->mIntVertArray; + + float texX2 = static_cast(srcX + w) / tw; + float texY2 = static_cast(srcY + h) / th; + + floatTexArray[vp + 0] = texX1; + floatTexArray[vp + 1] = texY1; + + floatTexArray[vp + 2] = texX2; + floatTexArray[vp + 3] = texY1; + + floatTexArray[vp + 4] = texX2; + floatTexArray[vp + 5] = texY2; + + floatTexArray[vp + 6] = texX1; + floatTexArray[vp + 7] = texY2; + + intVertArray[vp + 0] = dstX; + intVertArray[vp + 1] = dstY; + + intVertArray[vp + 2] = dstX + w; + intVertArray[vp + 3] = dstY; + + intVertArray[vp + 4] = dstX + w; + intVertArray[vp + 5] = dstY + h; + + intVertArray[vp + 6] = dstX; + intVertArray[vp + 7] = dstY + h; + + vp += 8; + + if (vp >= vLimit) + { + ogl->ptr = vp; + return; + } + } + else + { + if (!ogl->mIntTexArray) + ogl->mIntTexArray = new GLint[vertexBufSize * 4 + 30]; + if (!ogl->mIntVertArray) + ogl->mIntVertArray = new GLint[vertexBufSize * 4 + 30]; + + GLint *intTexArray = ogl->mIntTexArray; + GLint *intVertArray = ogl->mIntVertArray; + + intTexArray[vp + 0] = srcX; + intTexArray[vp + 1] = srcY; + + intTexArray[vp + 2] = srcX + w; + intTexArray[vp + 3] = srcY; + + intTexArray[vp + 4] = srcX + w; + intTexArray[vp + 5] = srcY + h; + + intTexArray[vp + 6] = srcX; + intTexArray[vp + 7] = srcY + h; + + intVertArray[vp + 0] = dstX; + intVertArray[vp + 1] = dstY; + + intVertArray[vp + 2] = dstX + w; + intVertArray[vp + 3] = dstY; + + intVertArray[vp + 4] = dstX + w; + intVertArray[vp + 5] = dstY + h; + + intVertArray[vp + 6] = dstX; + intVertArray[vp + 7] = dstY + h; + + vp += 8; + if (vp >= vLimit) + { + ogl->ptr = vp; + return; + } + } + ogl->ptr = vp; +} + +void NormalOpenGLGraphics::drawTile(ImageVertexes *vert) +{ + if (!vert) + return; + Image *image = vert->image; + + NormalOpenGLGraphicsVertexes *ogl = vert->ogl; + + glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); +#ifdef DEBUG_BIND_TEXTURE + debugBindTexture(image); +#endif + bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); + setTexturingAndBlending(true); + + if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) + drawQuadArrayfi(ogl->mIntVertArray, ogl->mFloatTexArray, ogl->ptr); + else + drawQuadArrayii(ogl->mIntVertArray, ogl->mIntTexArray, ogl->ptr); + + glColor4ub(static_cast(mColor.r), + static_cast(mColor.g), + static_cast(mColor.b), + static_cast(mColor.a)); +} + +void NormalOpenGLGraphics::updateScreen() +{ +// glFlush(); +// glFinish(); + SDL_GL_SwapBuffers(); +// may be need clear? +// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); +} + +void NormalOpenGLGraphics::_beginDraw() +{ + glMatrixMode(GL_TEXTURE); + glLoadIdentity(); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + + glOrtho(0.0, static_cast(mTarget->w), + static_cast(mTarget->h), 0.0, -1.0, 1.0); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + glEnable(GL_SCISSOR_TEST); + glDisable(GL_DITHER); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + + glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST); + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); + glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST); + glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST); + +#ifndef __MINGW32__ + glHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST); +#endif + +// glScalef(0.5f, 0.5f, 0.5f); + + pushClipArea(gcn::Rectangle(0, 0, mTarget->w, mTarget->h)); +} + +void NormalOpenGLGraphics::_endDraw() +{ + popClipArea(); +} + +void NormalOpenGLGraphics::prepareScreenshot() +{ +#if !defined(_WIN32) + if (config.getBoolValue("usefbo")) + { + int h = mTarget->h; + int w = mTarget->w; + + // create a texture object + glGenTextures(1, &mTextureId); + glBindTexture(GL_TEXTURE_2D, mTextureId); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, + GL_RGBA, GL_UNSIGNED_BYTE, nullptr); + glBindTexture(GL_TEXTURE_2D, 0); + + // create a renderbuffer object to store depth info + glGenRenderbuffersEXT(1, &mRboId); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mRboId); + glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, + GL_DEPTH_COMPONENT, w, h); + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); + + // create a framebuffer object + glGenFramebuffersEXT(1, &mFboId); + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFboId); + + // attach the texture to FBO color attachment point + glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, + GL_TEXTURE_2D, mTextureId, 0); + + // attach the renderbuffer to depth attachment point + glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, + GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mRboId); + + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFboId); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + } +#endif +} + +SDL_Surface* NormalOpenGLGraphics::getScreenshot() +{ + const int h = mTarget->h; + const int w = mTarget->w - (mTarget->w % 4); + GLint pack = 1; + + SDL_Surface *screenshot = SDL_CreateRGBSurface( + SDL_SWSURFACE, + w, h, 24, + 0xff0000, 0x00ff00, 0x0000ff, 0x000000); + + if (!screenshot) + return nullptr; + + if (SDL_MUSTLOCK(screenshot)) + SDL_LockSurface(screenshot); + + // 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 + unsigned int lineSize = 3 * w; + GLubyte* buf = static_cast(malloc(lineSize)); + + for (int i = 0; i < (h / 2); i++) + { + GLubyte *top = static_cast( + screenshot->pixels) + lineSize * i; + GLubyte *bot = static_cast( + screenshot->pixels) + lineSize * (h - 1 - i); + + memcpy(buf, top, lineSize); + memcpy(top, bot, lineSize); + memcpy(bot, buf, lineSize); + } + + free(buf); + +#if !defined(_WIN32) + if (config.getBoolValue("usefbo")) + { + glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); + if (mFboId) + { + glDeleteFramebuffersEXT(1, &mFboId); + mFboId = 0; + } + glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); + if (mRboId) + { + glDeleteRenderbuffersEXT(1, &mRboId); + mRboId = 0; + } + if (mTextureId) + { + glDeleteTextures(1, &mTextureId); + mTextureId = 0; + } + } +#endif + + glPixelStorei(GL_PACK_ALIGNMENT, pack); + + if (SDL_MUSTLOCK(screenshot)) + SDL_UnlockSurface(screenshot); + + return screenshot; +} + +bool NormalOpenGLGraphics::pushClipArea(gcn::Rectangle area) +{ + int transX = 0; + int transY = 0; + + if (!mClipStack.empty()) + { + const gcn::ClipRectangle &clipArea = mClipStack.top(); + transX = -clipArea.xOffset; + transY = -clipArea.yOffset; + } + + bool result = gcn::Graphics::pushClipArea(area); + + const gcn::ClipRectangle &clipArea = mClipStack.top(); + transX += clipArea.xOffset; + transY += clipArea.yOffset; + + glPushMatrix(); + if (transX || transY) + { + glTranslatef(static_cast(transX), + static_cast(transY), 0); + } + glScissor(clipArea.x, mTarget->h - clipArea.y - clipArea.height, + clipArea.width, clipArea.height); + + return result; +} + +void NormalOpenGLGraphics::popClipArea() +{ + gcn::Graphics::popClipArea(); + + if (mClipStack.empty()) + return; + + glPopMatrix(); + const gcn::ClipRectangle &clipArea = mClipStack.top(); + glScissor(clipArea.x, mTarget->h - clipArea.y - clipArea.height, + clipArea.width, clipArea.height); +} + +void NormalOpenGLGraphics::setColor(const gcn::Color& color) +{ + mColor = color; + glColor4ub(static_cast(color.r), + static_cast(color.g), + static_cast(color.b), + static_cast(color.a)); + + mColorAlpha = (color.a != 255); +} + +void NormalOpenGLGraphics::drawPoint(int x, int y) +{ + setTexturingAndBlending(false); + + glBegin(GL_POINTS); + glVertex2i(x, y); + glEnd(); +} + +void NormalOpenGLGraphics::drawLine(int x1, int y1, int x2, int y2) +{ + setTexturingAndBlending(false); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + mFloatTexArray[0] = static_cast(x1) + 0.5f; + mFloatTexArray[1] = static_cast(y1) + 0.5f; + mFloatTexArray[2] = static_cast(x2) + 0.5f; + mFloatTexArray[3] = static_cast(y2) + 0.5f; + + drawLineArrayf(4); + + glEnableClientState(GL_TEXTURE_COORD_ARRAY); +} + +void NormalOpenGLGraphics::drawRectangle(const gcn::Rectangle& rect) +{ + drawRectangle(rect, false); +} + +void NormalOpenGLGraphics::fillRectangle(const gcn::Rectangle& rect) +{ + drawRectangle(rect, true); +} + +void NormalOpenGLGraphics::setTargetPlane(int width A_UNUSED, + int height A_UNUSED) +{ +} + +void NormalOpenGLGraphics::setTexturingAndBlending(bool enable) +{ + if (enable) + { + if (!mTexture) + { + glEnable(OpenGLImageHelper::mTextureType); + mTexture = true; + } + + if (!mAlpha) + { + glEnable(GL_BLEND); + mAlpha = true; + } + } + else + { + mLastImage = 0; + if (mAlpha && !mColorAlpha) + { + glDisable(GL_BLEND); + mAlpha = false; + } + else if (!mAlpha && mColorAlpha) + { + glEnable(GL_BLEND); + mAlpha = true; + } + + if (mTexture) + { + glDisable(OpenGLImageHelper::mTextureType); + mTexture = false; + } + } +} + +void NormalOpenGLGraphics::drawRectangle(const gcn::Rectangle& rect, + bool filled) +{ + const float offset = filled ? 0 : 0.5f; + const float x = static_cast(rect.x); + const float y = static_cast(rect.y); + const float width = static_cast(rect.width); + const float height = static_cast(rect.height); + + setTexturingAndBlending(false); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + GLfloat vert[] = + { + x + offset, y + offset, + x + width - offset, y + offset, + x + width - offset, y + height - offset, + x + offset, y + height - offset + }; + + glVertexPointer(2, GL_FLOAT, 0, &vert); + glDrawArrays(filled ? GL_QUADS : GL_LINE_LOOP, 0, 4); + + glEnableClientState(GL_TEXTURE_COORD_ARRAY); +} + +bool NormalOpenGLGraphics::drawNet(int x1, int y1, int x2, int y2, + int width, int height) +{ + unsigned int vp = 0; + const unsigned int vLimit = vertexBufSize * 4; + + setTexturingAndBlending(false); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + + const float xf1 = static_cast(x1); + const float xf2 = static_cast(x2); + const float yf1 = static_cast(y1); + const float yf2 = static_cast(y2); + + for (int y = y1; y < y2; y += height) + { + mFloatTexArray[vp + 0] = xf1; + mFloatTexArray[vp + 1] = static_cast(y); + + mFloatTexArray[vp + 2] = xf2; + mFloatTexArray[vp + 3] = static_cast(y); + + vp += 4; + if (vp >= vLimit) + { + drawLineArrayf(vp); + vp = 0; + } + } + + for (int x = x1; x < x2; x += width) + { + mFloatTexArray[vp + 0] = static_cast(x); + mFloatTexArray[vp + 1] = yf1; + + mFloatTexArray[vp + 2] = static_cast(x); + mFloatTexArray[vp + 3] = yf2; + + vp += 4; + if (vp >= vLimit) + { + drawLineArrayf(vp); + vp = 0; + } + } + + if (vp > 0) + drawLineArrayf(vp); + + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + return true; +} + +void NormalOpenGLGraphics::bindTexture(GLenum target, GLuint texture) +{ + if (mLastImage != texture) + { + mLastImage = texture; + glBindTexture(target, texture); + } +} + +inline void NormalOpenGLGraphics::drawQuadArrayfi(int size) +{ + glVertexPointer(2, GL_INT, 0, mIntVertArray); + glTexCoordPointer(2, GL_FLOAT, 0, mFloatTexArray); + + glDrawArrays(GL_QUADS, 0, size / 2); +} + +inline void NormalOpenGLGraphics::drawQuadArrayfi(GLint *intVertArray, + GLfloat *floatTexArray, + int size) +{ + glVertexPointer(2, GL_INT, 0, intVertArray); + glTexCoordPointer(2, GL_FLOAT, 0, floatTexArray); + + glDrawArrays(GL_QUADS, 0, size / 2); +} + +inline void NormalOpenGLGraphics::drawQuadArrayii(int size) +{ + glVertexPointer(2, GL_INT, 0, mIntVertArray); + glTexCoordPointer(2, GL_INT, 0, mIntTexArray); + + glDrawArrays(GL_QUADS, 0, size / 2); +} + +inline void NormalOpenGLGraphics::drawQuadArrayii(GLint *intVertArray, + GLint *intTexArray, int size) +{ + glVertexPointer(2, GL_INT, 0, intVertArray); + glTexCoordPointer(2, GL_INT, 0, intTexArray); + + glDrawArrays(GL_QUADS, 0, size / 2); +} + +inline void NormalOpenGLGraphics::drawLineArrayi(int size) +{ + glVertexPointer(2, GL_INT, 0, mIntVertArray); + + glDrawArrays(GL_LINES, 0, size / 2); +} + +inline void NormalOpenGLGraphics::drawLineArrayf(int size) +{ + glVertexPointer(2, GL_FLOAT, 0, mFloatTexArray); + + glDrawArrays(GL_LINES, 0, size / 2); +} + +void NormalOpenGLGraphics::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]); + } + } +} + +#ifdef DEBUG_BIND_TEXTURE +void NormalOpenGLGraphics::debugBindTexture(const Image *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 NormalOpenGLGraphics::debugBindTexture(const Image *image A_UNUSED) +{ +} +#endif + +#endif // USE_OPENGL diff --git a/src/normalopenglgraphics.h b/src/normalopenglgraphics.h new file mode 100644 index 000000000..5c86f40e4 --- /dev/null +++ b/src/normalopenglgraphics.h @@ -0,0 +1,175 @@ +/* + * The ManaPlus Client + * Copyright (C) 2004-2009 The Mana World Development Team + * Copyright (C) 2009-2010 The Mana Developers + * Copyright (C) 2011-2012 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 OPENGLGRAPHICS_H +#define OPENGLGRAPHICS_H + +#ifdef USE_OPENGL + +#include "localconsts.h" +#include "main.h" +#include "graphics.h" + +//#define NO_SDL_GLEXT +#define GL_GLEXT_PROTOTYPES 1 + +#include +//#include + +#include + +class NormalOpenGLGraphics : public Graphics +{ + public: + NormalOpenGLGraphics(); + + ~NormalOpenGLGraphics(); + + bool setVideoMode(int w, int h, int bpp, bool fs, + bool hwaccel, bool resize, bool noFrame); + + + /** + * Draws a resclaled version of the image + */ + bool drawRescaledImage(Image *image, int srcX, int srcY, + int dstX, int dstY, + int width, int height, + int desiredWidth, int desiredHeight, + bool useColor); + + /** + * Used to get the smooth rescale option over the standard function. + */ + bool drawRescaledImage(Image *image, int srcX, int srcY, + int dstX, int dstY, + int width, int height, + int desiredWidth, int desiredHeight, + bool useColor, bool smooth); + + void drawImagePattern(const Image *image, + int x, int y, + int w, int h); + + /** + * Draw a pattern based on a rescaled version of the given image... + */ + void drawRescaledImagePattern(Image *image, + int x, int y, int w, int h, + int scaledWidth, int scaledHeight); + + void calcImagePattern(GraphicsVertexes* vert, Image *image, + int x, int y, int w, int h); + + void calcTile(ImageVertexes *vert, int x, int y); + + void drawTile(ImageVertexes *vert); + + void drawImagePattern2(GraphicsVertexes *vert, const Image *image); + + void updateScreen(); + + void _beginDraw(); + void _endDraw(); + + bool pushClipArea(gcn::Rectangle area); + void popClipArea(); + + void setColor(const gcn::Color &color); + + void drawPoint(int x, int y); + + void drawLine(int x1, int y1, int x2, int y2); + + void drawRectangle(const gcn::Rectangle &rect, bool filled); + + void drawRectangle(const gcn::Rectangle &rect); + + void fillRectangle(const gcn::Rectangle &rect); + + void setTargetPlane(int width, int height); + + void drawQuadArrayfi(int size); + + void drawQuadArrayfi(GLint *intVertArray, GLfloat *floatTexArray, + int size); + + void drawQuadArrayii(int size); + + void drawQuadArrayii(GLint *intVertArray, GLint *intTexArray, + int size); + + void drawLineArrayi(int size); + + void drawLineArrayf(int size); + + static void dumpSettings(); + + /** + * Takes a screenshot and returns it as SDL surface. + */ + SDL_Surface *getScreenshot(); + + void prepareScreenshot(); + + bool drawNet(int x1, int y1, int x2, int y2, int width, int height); + + int getMemoryUsage(); + + void updateTextureFormat(); + + static void bindTexture(GLenum target, GLuint texture); + + static GLuint mLastImage; + + protected: + bool drawImage2(const Image *image, + int srcX, int srcY, + int dstX, int dstY, + int width, int height, + bool useColor); + + void setTexturingAndBlending(bool enable); + + void logString(const char *format, GLenum num); + + void updateMemoryInfo(); + + void debugBindTexture(const Image *image); + + private: + GLfloat *mFloatTexArray; + GLint *mIntTexArray; + GLint *mIntVertArray; + bool mAlpha, mTexture; + bool mColorAlpha; + GLuint mFboId; + GLuint mTextureId; + GLuint mRboId; +#ifdef DEBUG_BIND_TEXTURE + std::string mOldTexture; + unsigned mOldTextureId; +#endif +}; +#endif + +#endif diff --git a/src/openglgraphics.cpp b/src/openglgraphics.cpp deleted file mode 100644 index 4edcb089d..000000000 --- a/src/openglgraphics.cpp +++ /dev/null @@ -1,1424 +0,0 @@ -/* - * The ManaPlus Client - * Copyright (C) 2004-2009 The Mana World Development Team - * Copyright (C) 2009-2010 The Mana Developers - * Copyright (C) 2011-2012 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 . - */ - -#include "main.h" - -#ifdef USE_OPENGL - -#include "graphicsvertexes.h" -#include "openglgraphics.h" -#include "configuration.h" -#include "logger.h" - -#include "resources/image.h" -#include "resources/openglimagehelper.h" - -#include "utils/stringutils.h" - -#include - -#include "debug.h" - -#ifndef GL_TEXTURE_RECTANGLE_ARB -#define GL_TEXTURE_RECTANGLE_ARB 0x84F5 -#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 -#endif - -const unsigned int vertexBufSize = 500; - -GLuint OpenGLGraphics::mLastImage = 0; - -OpenGLGraphics::OpenGLGraphics(): - mFloatTexArray(new GLfloat[vertexBufSize * 4 + 30]), - mIntTexArray(new GLint[vertexBufSize * 4 + 30]), - mIntVertArray(new GLint[vertexBufSize * 4 + 30]), - mAlpha(false), - mTexture(false), - mColorAlpha(false), - mFboId(0), - mTextureId(0), -#ifdef DEBUG_BIND_TEXTURE - mRboId(0), - mOldTextureId(0) -#else - mRboId(0) -#endif -{ - mOpenGL = 1; - mName = "fast OpenGL"; -} - -OpenGLGraphics::~OpenGLGraphics() -{ - delete [] mFloatTexArray; - delete [] mIntTexArray; - delete [] mIntVertArray; -} - -bool OpenGLGraphics::setVideoMode(int w, int h, int bpp, bool fs, - bool hwaccel, bool resize, bool noFrame) -{ - setMainFlags(w, h, bpp, fs, hwaccel, resize, noFrame); - - return setOpenGLMode(); -} - -static inline void drawQuad(const Image *image, - int srcX, int srcY, int dstX, int dstY, - int width, int height) -{ - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - // Find OpenGL normalized texture coordinates. - const float texX1 = static_cast(srcX) / - static_cast(image->getTextureWidth()); - const float texY1 = static_cast(srcY) / - static_cast(image->getTextureHeight()); - const float texX2 = static_cast(srcX + width) / - static_cast(image->getTextureWidth()); - const float texY2 = static_cast(srcY + height) / - static_cast(image->getTextureHeight()); - - GLfloat tex[] = - { - texX1, texY1, - texX2, texY1, - texX2, texY2, - texX1, texY2 - }; - - GLint vert[] = - { - dstX, dstY, - dstX + width, dstY, - dstX + width, dstY + height, - dstX, dstY + height - }; - - glVertexPointer(2, GL_INT, 0, &vert); - glTexCoordPointer(2, GL_FLOAT, 0, &tex); - - glDrawArrays(GL_QUADS, 0, 4); - } - else - { - GLint tex[] = - { - srcX, srcY, - srcX + width, srcY, - srcX + width, srcY + height, - srcX, srcY + height - }; - GLint vert[] = - { - dstX, dstY, - dstX + width, dstY, - dstX + width, dstY + height, - dstX, dstY + height - }; - - glVertexPointer(2, GL_INT, 0, &vert); - glTexCoordPointer(2, GL_INT, 0, &tex); - - glDrawArrays(GL_QUADS, 0, 4); - } -} - -static inline void drawRescaledQuad(Image *image, - int srcX, int srcY, int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight) -{ - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - // Find OpenGL normalized texture coordinates. - const float texX1 = static_cast(srcX) / - static_cast(image->getTextureWidth()); - const float texY1 = static_cast(srcY) / - static_cast(image->getTextureHeight()); - const float texX2 = static_cast(srcX + width) / - static_cast(image->getTextureWidth()); - const float texY2 = static_cast(srcY + height) / - static_cast(image->getTextureHeight()); - - GLfloat tex[] = - { - texX1, texY1, - texX2, texY1, - texX2, texY2, - texX1, texY2 - }; - - GLint vert[] = - { - dstX, dstY, - dstX + desiredWidth, dstY, - dstX + desiredWidth, dstY + desiredHeight, - dstX, dstY + desiredHeight - }; - - glVertexPointer(2, GL_INT, 0, &vert); - glTexCoordPointer(2, GL_FLOAT, 0, &tex); - - glDrawArrays(GL_QUADS, 0, 4); - } - else - { - GLint tex[] = - { - srcX, srcY, - srcX + width, srcY, - srcX + width, srcY + height, - srcX, srcY + height - }; - GLint vert[] = - { - dstX, dstY, - dstX + desiredWidth, dstY, - dstX + desiredWidth, dstY + desiredHeight, - dstX, dstY + desiredHeight - }; - - glVertexPointer(2, GL_INT, 0, &vert); - glTexCoordPointer(2, GL_INT, 0, &tex); - - glDrawArrays(GL_QUADS, 0, 4); - } -} - - -bool OpenGLGraphics::drawImage2(const Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, bool useColor) -{ - if (!image) - return false; - - srcX += image->mBounds.x; - srcY += image->mBounds.y; - - if (!useColor) - glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); - -#ifdef DEBUG_BIND_TEXTURE - debugBindTexture(image); -#endif - bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); - - setTexturingAndBlending(true); - - drawQuad(image, srcX, srcY, dstX, dstY, width, height); - - if (!useColor) - { - glColor4ub(static_cast(mColor.r), - static_cast(mColor.g), - static_cast(mColor.b), - static_cast(mColor.a)); - } - - return true; -} - -bool OpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight, - bool useColor) -{ - return drawRescaledImage(image, srcX, srcY, - dstX, dstY, - width, height, - desiredWidth, desiredHeight, - useColor, true); -} - -bool OpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight, - bool useColor, bool smooth) -{ - if (!image) - return false; - - // Just draw the image normally when no resizing is necessary, - if (width == desiredWidth && height == desiredHeight) - { - return drawImage2(image, srcX, srcY, dstX, dstY, - width, height, useColor); - } - - // When the desired image is smaller than the current one, - // disable smooth effect. - if (width > desiredWidth && height > desiredHeight) - smooth = false; - - srcX += image->mBounds.x; - srcY += image->mBounds.y; - - if (!useColor) - glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); - -#ifdef DEBUG_BIND_TEXTURE - debugBindTexture(image); -#endif - bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); - - setTexturingAndBlending(true); - - // Draw a textured quad. - drawRescaledQuad(image, srcX, srcY, dstX, dstY, width, height, - desiredWidth, desiredHeight); - - if (smooth) // A basic smooth effect... - { - glColor4f(1.0f, 1.0f, 1.0f, 0.2f); - drawRescaledQuad(image, srcX, srcY, dstX - 1, dstY - 1, width, height, - desiredWidth + 1, desiredHeight + 1); - drawRescaledQuad(image, srcX, srcY, dstX + 1, dstY + 1, width, height, - desiredWidth - 1, desiredHeight - 1); - - drawRescaledQuad(image, srcX, srcY, dstX + 1, dstY, width, height, - desiredWidth - 1, desiredHeight); - drawRescaledQuad(image, srcX, srcY, dstX, dstY + 1, width, height, - desiredWidth, desiredHeight - 1); - } - - if (!useColor) - { - glColor4ub(static_cast(mColor.r), - static_cast(mColor.g), - static_cast(mColor.b), - static_cast(mColor.a)); - } - - return true; -} - -void OpenGLGraphics::drawImagePattern(const Image *image, int x, int y, - int w, int h) -{ - if (!image) - return; - - const int srcX = image->mBounds.x; - const int srcY = image->mBounds.y; - - const int iw = image->mBounds.w; - const int ih = image->mBounds.h; - - if (iw == 0 || ih == 0) - return; - - const float tw = static_cast(image->getTextureWidth()); - const float th = static_cast(image->getTextureHeight()); - - glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); - -#ifdef DEBUG_BIND_TEXTURE - debugBindTexture(image); -#endif - bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); - - setTexturingAndBlending(true); - - unsigned int vp = 0; - const unsigned int vLimit = vertexBufSize * 4; - // Draw a set of textured rectangles - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - float texX1 = static_cast(srcX) / tw; - float texY1 = static_cast(srcY) / th; - - for (int py = 0; py < h; py += ih) - { - const int height = (py + ih >= h) ? h - py : ih; - const int dstY = y + py; - for (int px = 0; px < w; px += iw) - { - int width = (px + iw >= w) ? w - px : iw; - int dstX = x + px; - - float texX2 = static_cast(srcX + width) / tw; - float texY2 = static_cast(srcY + height) / th; - - mFloatTexArray[vp + 0] = texX1; - mFloatTexArray[vp + 1] = texY1; - - mFloatTexArray[vp + 2] = texX2; - mFloatTexArray[vp + 3] = texY1; - - mFloatTexArray[vp + 4] = texX2; - mFloatTexArray[vp + 5] = texY2; - - mFloatTexArray[vp + 6] = texX1; - mFloatTexArray[vp + 7] = texY2; - - mIntVertArray[vp + 0] = dstX; - mIntVertArray[vp + 1] = dstY; - - mIntVertArray[vp + 2] = dstX + width; - mIntVertArray[vp + 3] = dstY; - - mIntVertArray[vp + 4] = dstX + width; - mIntVertArray[vp + 5] = dstY + height; - - mIntVertArray[vp + 6] = dstX; - mIntVertArray[vp + 7] = dstY + height; - - vp += 8; - if (vp >= vLimit) - { - drawQuadArrayfi(vp); - vp = 0; - } - } - } - if (vp > 0) - drawQuadArrayfi(vp); - } - else - { - for (int py = 0; py < h; py += ih) - { - const int height = (py + ih >= h) ? h - py : ih; - const int dstY = y + py; - for (int px = 0; px < w; px += iw) - { - int width = (px + iw >= w) ? w - px : iw; - int dstX = x + px; - - mIntTexArray[vp + 0] = srcX; - mIntTexArray[vp + 1] = srcY; - - mIntTexArray[vp + 2] = srcX + width; - mIntTexArray[vp + 3] = srcY; - - mIntTexArray[vp + 4] = srcX + width; - mIntTexArray[vp + 5] = srcY + height; - - mIntTexArray[vp + 6] = srcX; - mIntTexArray[vp + 7] = srcY + height; - - mIntVertArray[vp + 0] = dstX; - mIntVertArray[vp + 1] = dstY; - - mIntVertArray[vp + 2] = dstX + width; - mIntVertArray[vp + 3] = dstY; - - mIntVertArray[vp + 4] = dstX + width; - mIntVertArray[vp + 5] = dstY + height; - - mIntVertArray[vp + 6] = dstX; - mIntVertArray[vp + 7] = dstY + height; - - vp += 8; - if (vp >= vLimit) - { - drawQuadArrayii(vp); - vp = 0; - } - } - } - if (vp > 0) - drawQuadArrayii(vp); - } - - glColor4ub(static_cast(mColor.r), - static_cast(mColor.g), - static_cast(mColor.b), - static_cast(mColor.a)); -} - -void OpenGLGraphics::drawRescaledImagePattern(Image *image, - int x, int y, - int w, int h, - int scaledWidth, - int scaledHeight) -{ - if (!image) - return; - - if (scaledWidth == 0 || scaledHeight == 0) - return; - - const int srcX = image->mBounds.x; - const int srcY = image->mBounds.y; - - const int iw = image->getWidth(); - const int ih = image->getHeight(); - if (iw == 0 || ih == 0) - return; - - glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); - -#ifdef DEBUG_BIND_TEXTURE - debugBindTexture(image); -#endif - bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); - - setTexturingAndBlending(true); - - unsigned int vp = 0; - const unsigned int vLimit = vertexBufSize * 4; - - // Draw a set of textured rectangles - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - const float tw = static_cast(image->getTextureWidth()); - const float th = static_cast(image->getTextureHeight()); - - const float texX1 = static_cast(srcX) / tw; - const float texY1 = static_cast(srcY) / th; - - const float tFractionW = iw / tw; - const float tFractionH = ih / th; - - for (int py = 0; py < h; py += scaledHeight) - { - const int height = (py + scaledHeight >= h) - ? h - py : scaledHeight; - const int dstY = y + py; - for (int px = 0; px < w; px += scaledWidth) - { - int width = (px + scaledWidth >= w) ? w - px : scaledWidth; - int dstX = x + px; - const float visibleFractionW = static_cast(width) - / scaledWidth; - const float visibleFractionH = static_cast(height) - / scaledHeight; - - const float texX2 = texX1 + tFractionW * visibleFractionW; - const float texY2 = texY1 + tFractionH * visibleFractionH; - - mFloatTexArray[vp + 0] = texX1; - mFloatTexArray[vp + 1] = texY1; - - mFloatTexArray[vp + 2] = texX2; - mFloatTexArray[vp + 3] = texY1; - - mFloatTexArray[vp + 4] = texX2; - mFloatTexArray[vp + 5] = texY2; - - mFloatTexArray[vp + 6] = texX1; - mFloatTexArray[vp + 7] = texY2; - - mIntVertArray[vp + 0] = dstX; - mIntVertArray[vp + 1] = dstY; - - mIntVertArray[vp + 2] = dstX + width; - mIntVertArray[vp + 3] = dstY; - - mIntVertArray[vp + 4] = dstX + width; - mIntVertArray[vp + 5] = dstY + height; - - mIntVertArray[vp + 6] = dstX; - mIntVertArray[vp + 7] = dstY + height; - - vp += 8; - if (vp >= vLimit) - { - drawQuadArrayfi(vp); - vp = 0; - } - } - } - if (vp > 0) - drawQuadArrayfi(vp); - } - else - { - 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 = y + 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 = x + px; - const int scaledX = srcX + width / scaleFactorW; - - mIntTexArray[vp + 0] = srcX; - mIntTexArray[vp + 1] = srcY; - - mIntTexArray[vp + 2] = scaledX; - mIntTexArray[vp + 3] = srcY; - - mIntTexArray[vp + 4] = scaledX; - mIntTexArray[vp + 5] = scaledY; - - mIntTexArray[vp + 6] = srcX; - mIntTexArray[vp + 7] = scaledY; - - mIntVertArray[vp + 0] = dstX; - mIntVertArray[vp + 1] = dstY; - - mIntVertArray[vp + 2] = dstX + width; - mIntVertArray[vp + 3] = dstY; - - mIntVertArray[vp + 4] = dstX + width; - mIntVertArray[vp + 5] = dstY + height; - - mIntVertArray[vp + 6] = dstX; - mIntVertArray[vp + 7] = dstY + height; - - vp += 8; - if (vp >= vLimit) - { - drawQuadArrayii(vp); - vp = 0; - } - } - } - if (vp > 0) - drawQuadArrayii(vp); - } - - glColor4ub(static_cast(mColor.r), - static_cast(mColor.g), - static_cast(mColor.b), - static_cast(mColor.a)); -} - -void OpenGLGraphics::drawImagePattern2(GraphicsVertexes *vert, - const Image *image) -{ - if (!image) - return; - - OpenGLGraphicsVertexes *ogl = vert->getOGL(); - - glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); -#ifdef DEBUG_BIND_TEXTURE - debugBindTexture(image); -#endif - bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); - setTexturingAndBlending(true); - - std::vector *intVertPool = ogl->getIntVertPool(); - std::vector::const_iterator iv; - std::vector::const_iterator iv_end = intVertPool->end(); - std::vector *vp = ogl->getVp(); - std::vector::const_iterator ivp; - std::vector::const_iterator ivp_end = vp->end(); - - // Draw a set of textured rectangles - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - std::vector *floatTexPool = ogl->getFloatTexPool(); - std::vector::const_iterator ft; - std::vector::const_iterator ft_end = floatTexPool->end(); - - for (iv = intVertPool->begin(), ft = floatTexPool->begin(), - ivp = vp->begin(); - iv != iv_end, ft != ft_end, - ivp != ivp_end; - ++ iv, ++ ft, ++ ivp) - { - drawQuadArrayfi(*iv, *ft, *ivp); - } - } - else - { - std::vector *intTexPool = ogl->getIntTexPool(); - std::vector::const_iterator it; - std::vector::const_iterator it_end = intTexPool->end(); - - for (iv = intVertPool->begin(), it = intTexPool->begin(), - ivp = vp->begin(); - iv != iv_end, it != it_end, - ivp != ivp_end; - ++ iv, ++ it, ++ ivp) - { - drawQuadArrayii(*iv, *it, *ivp); - } - } - - glColor4ub(static_cast(mColor.r), - static_cast(mColor.g), - static_cast(mColor.b), - static_cast(mColor.a)); - -} - -void OpenGLGraphics::calcImagePattern(GraphicsVertexes* vert, Image *image, - int x, int y, int w, int h) -{ - if (!image) - { - vert->incPtr(1); - return; - } - - const int srcX = image->mBounds.x; - const int srcY = image->mBounds.y; - - const int iw = image->mBounds.w; - const int ih = image->mBounds.h; - - if (iw == 0 || ih == 0) - { - vert->incPtr(1); - return; - } - - const float tw = static_cast(image->getTextureWidth()); - const float th = static_cast(image->getTextureHeight()); - - unsigned int vp = 0; - const unsigned int vLimit = vertexBufSize * 4; - - OpenGLGraphicsVertexes *ogl = vert->getOGL(); - ogl->init(); - - // Draw a set of textured rectangles - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - float texX1 = static_cast(srcX) / tw; - float texY1 = static_cast(srcY) / th; - - GLfloat *floatTexArray = ogl->switchFloatTexArray(); - GLint *intVertArray = ogl->switchIntVertArray(); - - for (int py = 0; py < h; py += ih) - { - const int height = (py + ih >= h) ? h - py : ih; - const int dstY = y + py; - for (int px = 0; px < w; px += iw) - { - int width = (px + iw >= w) ? w - px : iw; - int dstX = x + px; - - float texX2 = static_cast(srcX + width) / tw; - float texY2 = static_cast(srcY + height) / th; - - floatTexArray[vp + 0] = texX1; - floatTexArray[vp + 1] = texY1; - - floatTexArray[vp + 2] = texX2; - floatTexArray[vp + 3] = texY1; - - floatTexArray[vp + 4] = texX2; - floatTexArray[vp + 5] = texY2; - - floatTexArray[vp + 6] = texX1; - floatTexArray[vp + 7] = texY2; - - intVertArray[vp + 0] = dstX; - intVertArray[vp + 1] = dstY; - - intVertArray[vp + 2] = dstX + width; - intVertArray[vp + 3] = dstY; - - intVertArray[vp + 4] = dstX + width; - intVertArray[vp + 5] = dstY + height; - - intVertArray[vp + 6] = dstX; - intVertArray[vp + 7] = dstY + height; - - vp += 8; - if (vp >= vLimit) - { - floatTexArray = ogl->switchFloatTexArray(); - intVertArray = ogl->switchIntVertArray(); - ogl->switchVp(vp); - vp = 0; - } - } - } - } - else - { - GLint *intTexArray = ogl->switchIntTexArray(); - GLint *intVertArray = ogl->switchIntVertArray(); - - for (int py = 0; py < h; py += ih) - { - const int height = (py + ih >= h) ? h - py : ih; - const int dstY = y + py; - for (int px = 0; px < w; px += iw) - { - int width = (px + iw >= w) ? w - px : iw; - int dstX = x + px; - - intTexArray[vp + 0] = srcX; - intTexArray[vp + 1] = srcY; - - intTexArray[vp + 2] = srcX + width; - intTexArray[vp + 3] = srcY; - - intTexArray[vp + 4] = srcX + width; - intTexArray[vp + 5] = srcY + height; - - intTexArray[vp + 6] = srcX; - intTexArray[vp + 7] = srcY + height; - - intVertArray[vp + 0] = dstX; - intVertArray[vp + 1] = dstY; - - intVertArray[vp + 2] = dstX + width; - intVertArray[vp + 3] = dstY; - - intVertArray[vp + 4] = dstX + width; - intVertArray[vp + 5] = dstY + height; - - intVertArray[vp + 6] = dstX; - intVertArray[vp + 7] = dstY + height; - - vp += 8; - if (vp >= vLimit) - { - intTexArray = ogl->switchIntTexArray(); - intVertArray = ogl->switchIntVertArray(); - ogl->switchVp(vp); - vp = 0; - } - } - } - } - ogl->switchVp(vp); - vert->incPtr(1); -} - -void OpenGLGraphics::calcTile(ImageVertexes *vert, int dstX, int dstY) -{ - if (!vert) - return; - - Image *image = vert->image; - const int srcX = image->mBounds.x; - const int srcY = image->mBounds.y; - - const int w = image->mBounds.w; - const int h = image->mBounds.h; - - if (w == 0 || h == 0) - return; - - const float tw = static_cast(image->mTexWidth); - const float th = static_cast(image->mTexHeight); - - const unsigned int vLimit = vertexBufSize * 4; - - OpenGLGraphicsVertexes *ogl = vert->ogl; - - unsigned int vp = ogl->ptr; - - // Draw a set of textured rectangles - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - { - float texX1 = static_cast(srcX) / tw; - float texY1 = static_cast(srcY) / th; - - if (!ogl->mFloatTexArray) - ogl->mFloatTexArray = new GLfloat[vertexBufSize * 4 + 30]; - if (!ogl->mIntVertArray) - ogl->mIntVertArray = new GLint[vertexBufSize * 4 + 30]; - - GLfloat *floatTexArray = ogl->mFloatTexArray; - GLint *intVertArray = ogl->mIntVertArray; - - float texX2 = static_cast(srcX + w) / tw; - float texY2 = static_cast(srcY + h) / th; - - floatTexArray[vp + 0] = texX1; - floatTexArray[vp + 1] = texY1; - - floatTexArray[vp + 2] = texX2; - floatTexArray[vp + 3] = texY1; - - floatTexArray[vp + 4] = texX2; - floatTexArray[vp + 5] = texY2; - - floatTexArray[vp + 6] = texX1; - floatTexArray[vp + 7] = texY2; - - intVertArray[vp + 0] = dstX; - intVertArray[vp + 1] = dstY; - - intVertArray[vp + 2] = dstX + w; - intVertArray[vp + 3] = dstY; - - intVertArray[vp + 4] = dstX + w; - intVertArray[vp + 5] = dstY + h; - - intVertArray[vp + 6] = dstX; - intVertArray[vp + 7] = dstY + h; - - vp += 8; - - if (vp >= vLimit) - { - ogl->ptr = vp; - return; - } - } - else - { - if (!ogl->mIntTexArray) - ogl->mIntTexArray = new GLint[vertexBufSize * 4 + 30]; - if (!ogl->mIntVertArray) - ogl->mIntVertArray = new GLint[vertexBufSize * 4 + 30]; - - GLint *intTexArray = ogl->mIntTexArray; - GLint *intVertArray = ogl->mIntVertArray; - - intTexArray[vp + 0] = srcX; - intTexArray[vp + 1] = srcY; - - intTexArray[vp + 2] = srcX + w; - intTexArray[vp + 3] = srcY; - - intTexArray[vp + 4] = srcX + w; - intTexArray[vp + 5] = srcY + h; - - intTexArray[vp + 6] = srcX; - intTexArray[vp + 7] = srcY + h; - - intVertArray[vp + 0] = dstX; - intVertArray[vp + 1] = dstY; - - intVertArray[vp + 2] = dstX + w; - intVertArray[vp + 3] = dstY; - - intVertArray[vp + 4] = dstX + w; - intVertArray[vp + 5] = dstY + h; - - intVertArray[vp + 6] = dstX; - intVertArray[vp + 7] = dstY + h; - - vp += 8; - if (vp >= vLimit) - { - ogl->ptr = vp; - return; - } - } - ogl->ptr = vp; -} - -void OpenGLGraphics::drawTile(ImageVertexes *vert) -{ - if (!vert) - return; - Image *image = vert->image; - - OpenGLGraphicsVertexes *ogl = vert->ogl; - - glColor4f(1.0f, 1.0f, 1.0f, image->mAlpha); -#ifdef DEBUG_BIND_TEXTURE - debugBindTexture(image); -#endif - bindTexture(OpenGLImageHelper::mTextureType, image->mGLImage); - setTexturingAndBlending(true); - - if (OpenGLImageHelper::mTextureType == GL_TEXTURE_2D) - drawQuadArrayfi(ogl->mIntVertArray, ogl->mFloatTexArray, ogl->ptr); - else - drawQuadArrayii(ogl->mIntVertArray, ogl->mIntTexArray, ogl->ptr); - - glColor4ub(static_cast(mColor.r), - static_cast(mColor.g), - static_cast(mColor.b), - static_cast(mColor.a)); -} - -void OpenGLGraphics::updateScreen() -{ -// glFlush(); -// glFinish(); - SDL_GL_SwapBuffers(); -// may be need clear? -// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); -} - -void OpenGLGraphics::_beginDraw() -{ - glMatrixMode(GL_TEXTURE); - glLoadIdentity(); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - glOrtho(0.0, static_cast(mTarget->w), - static_cast(mTarget->h), 0.0, -1.0, 1.0); - - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - glEnable(GL_SCISSOR_TEST); - glDisable(GL_DITHER); - - glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); - - glEnableClientState(GL_VERTEX_ARRAY); - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - - glHint(GL_LINE_SMOOTH_HINT, GL_FASTEST); - glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST); - glHint(GL_POINT_SMOOTH_HINT, GL_FASTEST); - glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST); - -#ifndef __MINGW32__ - glHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST); -#endif - -// glScalef(0.5f, 0.5f, 0.5f); - - pushClipArea(gcn::Rectangle(0, 0, mTarget->w, mTarget->h)); -} - -void OpenGLGraphics::_endDraw() -{ - popClipArea(); -} - -void OpenGLGraphics::prepareScreenshot() -{ -#if !defined(_WIN32) - if (config.getBoolValue("usefbo")) - { - int h = mTarget->h; - int w = mTarget->w; - - // create a texture object - glGenTextures(1, &mTextureId); - glBindTexture(GL_TEXTURE_2D, mTextureId); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w, h, 0, - GL_RGBA, GL_UNSIGNED_BYTE, nullptr); - glBindTexture(GL_TEXTURE_2D, 0); - - // create a renderbuffer object to store depth info - glGenRenderbuffersEXT(1, &mRboId); - glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mRboId); - glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, - GL_DEPTH_COMPONENT, w, h); - glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); - - // create a framebuffer object - glGenFramebuffersEXT(1, &mFboId); - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFboId); - - // attach the texture to FBO color attachment point - glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, - GL_TEXTURE_2D, mTextureId, 0); - - // attach the renderbuffer to depth attachment point - glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, - GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mRboId); - - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFboId); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - } -#endif -} - -SDL_Surface* OpenGLGraphics::getScreenshot() -{ - const int h = mTarget->h; - const int w = mTarget->w - (mTarget->w % 4); - GLint pack = 1; - - SDL_Surface *screenshot = SDL_CreateRGBSurface( - SDL_SWSURFACE, - w, h, 24, - 0xff0000, 0x00ff00, 0x0000ff, 0x000000); - - if (!screenshot) - return nullptr; - - if (SDL_MUSTLOCK(screenshot)) - SDL_LockSurface(screenshot); - - // 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 - unsigned int lineSize = 3 * w; - GLubyte* buf = static_cast(malloc(lineSize)); - - for (int i = 0; i < (h / 2); i++) - { - GLubyte *top = static_cast( - screenshot->pixels) + lineSize * i; - GLubyte *bot = static_cast( - screenshot->pixels) + lineSize * (h - 1 - i); - - memcpy(buf, top, lineSize); - memcpy(top, bot, lineSize); - memcpy(bot, buf, lineSize); - } - - free(buf); - -#if !defined(_WIN32) - if (config.getBoolValue("usefbo")) - { - glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0); - if (mFboId) - { - glDeleteFramebuffersEXT(1, &mFboId); - mFboId = 0; - } - glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0); - if (mRboId) - { - glDeleteRenderbuffersEXT(1, &mRboId); - mRboId = 0; - } - if (mTextureId) - { - glDeleteTextures(1, &mTextureId); - mTextureId = 0; - } - } -#endif - - glPixelStorei(GL_PACK_ALIGNMENT, pack); - - if (SDL_MUSTLOCK(screenshot)) - SDL_UnlockSurface(screenshot); - - return screenshot; -} - -bool OpenGLGraphics::pushClipArea(gcn::Rectangle area) -{ - int transX = 0; - int transY = 0; - - if (!mClipStack.empty()) - { - const gcn::ClipRectangle &clipArea = mClipStack.top(); - transX = -clipArea.xOffset; - transY = -clipArea.yOffset; - } - - bool result = gcn::Graphics::pushClipArea(area); - - const gcn::ClipRectangle &clipArea = mClipStack.top(); - transX += clipArea.xOffset; - transY += clipArea.yOffset; - - glPushMatrix(); - if (transX || transY) - { - glTranslatef(static_cast(transX), - static_cast(transY), 0); - } - glScissor(clipArea.x, mTarget->h - clipArea.y - clipArea.height, - clipArea.width, clipArea.height); - - return result; -} - -void OpenGLGraphics::popClipArea() -{ - gcn::Graphics::popClipArea(); - - if (mClipStack.empty()) - return; - - glPopMatrix(); - const gcn::ClipRectangle &clipArea = mClipStack.top(); - glScissor(clipArea.x, mTarget->h - clipArea.y - clipArea.height, - clipArea.width, clipArea.height); -} - -void OpenGLGraphics::setColor(const gcn::Color& color) -{ - mColor = color; - glColor4ub(static_cast(color.r), - static_cast(color.g), - static_cast(color.b), - static_cast(color.a)); - - mColorAlpha = (color.a != 255); -} - -void OpenGLGraphics::drawPoint(int x, int y) -{ - setTexturingAndBlending(false); - - glBegin(GL_POINTS); - glVertex2i(x, y); - glEnd(); -} - -void OpenGLGraphics::drawLine(int x1, int y1, int x2, int y2) -{ - setTexturingAndBlending(false); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - - mFloatTexArray[0] = static_cast(x1) + 0.5f; - mFloatTexArray[1] = static_cast(y1) + 0.5f; - mFloatTexArray[2] = static_cast(x2) + 0.5f; - mFloatTexArray[3] = static_cast(y2) + 0.5f; - - drawLineArrayf(4); - - glEnableClientState(GL_TEXTURE_COORD_ARRAY); -} - -void OpenGLGraphics::drawRectangle(const gcn::Rectangle& rect) -{ - drawRectangle(rect, false); -} - -void OpenGLGraphics::fillRectangle(const gcn::Rectangle& rect) -{ - drawRectangle(rect, true); -} - -void OpenGLGraphics::setTargetPlane(int width A_UNUSED, int height A_UNUSED) -{ -} - -void OpenGLGraphics::setTexturingAndBlending(bool enable) -{ - if (enable) - { - if (!mTexture) - { - glEnable(OpenGLImageHelper::mTextureType); - mTexture = true; - } - - if (!mAlpha) - { - glEnable(GL_BLEND); - mAlpha = true; - } - } - else - { - mLastImage = 0; - if (mAlpha && !mColorAlpha) - { - glDisable(GL_BLEND); - mAlpha = false; - } - else if (!mAlpha && mColorAlpha) - { - glEnable(GL_BLEND); - mAlpha = true; - } - - if (mTexture) - { - glDisable(OpenGLImageHelper::mTextureType); - mTexture = false; - } - } -} - -void OpenGLGraphics::drawRectangle(const gcn::Rectangle& rect, bool filled) -{ - const float offset = filled ? 0 : 0.5f; - const float x = static_cast(rect.x); - const float y = static_cast(rect.y); - const float width = static_cast(rect.width); - const float height = static_cast(rect.height); - - setTexturingAndBlending(false); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - - GLfloat vert[] = - { - x + offset, y + offset, - x + width - offset, y + offset, - x + width - offset, y + height - offset, - x + offset, y + height - offset - }; - - glVertexPointer(2, GL_FLOAT, 0, &vert); - glDrawArrays(filled ? GL_QUADS : GL_LINE_LOOP, 0, 4); - - glEnableClientState(GL_TEXTURE_COORD_ARRAY); -} - -bool OpenGLGraphics::drawNet(int x1, int y1, int x2, int y2, - int width, int height) -{ - unsigned int vp = 0; - const unsigned int vLimit = vertexBufSize * 4; - - setTexturingAndBlending(false); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - - const float xf1 = static_cast(x1); - const float xf2 = static_cast(x2); - const float yf1 = static_cast(y1); - const float yf2 = static_cast(y2); - - for (int y = y1; y < y2; y += height) - { - mFloatTexArray[vp + 0] = xf1; - mFloatTexArray[vp + 1] = static_cast(y); - - mFloatTexArray[vp + 2] = xf2; - mFloatTexArray[vp + 3] = static_cast(y); - - vp += 4; - if (vp >= vLimit) - { - drawLineArrayf(vp); - vp = 0; - } - } - - for (int x = x1; x < x2; x += width) - { - mFloatTexArray[vp + 0] = static_cast(x); - mFloatTexArray[vp + 1] = yf1; - - mFloatTexArray[vp + 2] = static_cast(x); - mFloatTexArray[vp + 3] = yf2; - - vp += 4; - if (vp >= vLimit) - { - drawLineArrayf(vp); - vp = 0; - } - } - - if (vp > 0) - drawLineArrayf(vp); - - glEnableClientState(GL_TEXTURE_COORD_ARRAY); - return true; -} - -void OpenGLGraphics::bindTexture(GLenum target, GLuint texture) -{ - if (mLastImage != texture) - { - mLastImage = texture; - glBindTexture(target, texture); - } -} - -inline void OpenGLGraphics::drawQuadArrayfi(int size) -{ - glVertexPointer(2, GL_INT, 0, mIntVertArray); - glTexCoordPointer(2, GL_FLOAT, 0, mFloatTexArray); - - glDrawArrays(GL_QUADS, 0, size / 2); -} - -inline void OpenGLGraphics::drawQuadArrayfi(GLint *intVertArray, - GLfloat *floatTexArray, int size) -{ - glVertexPointer(2, GL_INT, 0, intVertArray); - glTexCoordPointer(2, GL_FLOAT, 0, floatTexArray); - - glDrawArrays(GL_QUADS, 0, size / 2); -} - -inline void OpenGLGraphics::drawQuadArrayii(int size) -{ - glVertexPointer(2, GL_INT, 0, mIntVertArray); - glTexCoordPointer(2, GL_INT, 0, mIntTexArray); - - glDrawArrays(GL_QUADS, 0, size / 2); -} - -inline void OpenGLGraphics::drawQuadArrayii(GLint *intVertArray, - GLint *intTexArray, int size) -{ - glVertexPointer(2, GL_INT, 0, intVertArray); - glTexCoordPointer(2, GL_INT, 0, intTexArray); - - glDrawArrays(GL_QUADS, 0, size / 2); -} - -inline void OpenGLGraphics::drawLineArrayi(int size) -{ - glVertexPointer(2, GL_INT, 0, mIntVertArray); - - glDrawArrays(GL_LINES, 0, size / 2); -} - -inline void OpenGLGraphics::drawLineArrayf(int size) -{ - glVertexPointer(2, GL_FLOAT, 0, mFloatTexArray); - - glDrawArrays(GL_LINES, 0, size / 2); -} - -void OpenGLGraphics::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]); - } - } -} - -#ifdef DEBUG_BIND_TEXTURE -void OpenGLGraphics::debugBindTexture(const Image *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 OpenGLGraphics::debugBindTexture(const Image *image A_UNUSED) -{ -} -#endif - -#endif // USE_OPENGL diff --git a/src/openglgraphics.h b/src/openglgraphics.h deleted file mode 100644 index f0d0078a1..000000000 --- a/src/openglgraphics.h +++ /dev/null @@ -1,175 +0,0 @@ -/* - * The ManaPlus Client - * Copyright (C) 2004-2009 The Mana World Development Team - * Copyright (C) 2009-2010 The Mana Developers - * Copyright (C) 2011-2012 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 OPENGLGRAPHICS_H -#define OPENGLGRAPHICS_H - -#ifdef USE_OPENGL - -#include "localconsts.h" -#include "main.h" -#include "graphics.h" - -//#define NO_SDL_GLEXT -#define GL_GLEXT_PROTOTYPES 1 - -#include -//#include - -#include - -class OpenGLGraphics : public Graphics -{ - public: - OpenGLGraphics(); - - ~OpenGLGraphics(); - - bool setVideoMode(int w, int h, int bpp, bool fs, - bool hwaccel, bool resize, bool noFrame); - - - /** - * Draws a resclaled version of the image - */ - bool drawRescaledImage(Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight, - bool useColor); - - /** - * Used to get the smooth rescale option over the standard function. - */ - bool drawRescaledImage(Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight, - bool useColor, bool smooth); - - void drawImagePattern(const Image *image, - int x, int y, - int w, int h); - - /** - * Draw a pattern based on a rescaled version of the given image... - */ - void drawRescaledImagePattern(Image *image, - int x, int y, int w, int h, - int scaledWidth, int scaledHeight); - - void calcImagePattern(GraphicsVertexes* vert, Image *image, - int x, int y, int w, int h); - - void calcTile(ImageVertexes *vert, int x, int y); - - void drawTile(ImageVertexes *vert); - - void drawImagePattern2(GraphicsVertexes *vert, const Image *image); - - void updateScreen(); - - void _beginDraw(); - void _endDraw(); - - bool pushClipArea(gcn::Rectangle area); - void popClipArea(); - - void setColor(const gcn::Color &color); - - void drawPoint(int x, int y); - - void drawLine(int x1, int y1, int x2, int y2); - - void drawRectangle(const gcn::Rectangle &rect, bool filled); - - void drawRectangle(const gcn::Rectangle &rect); - - void fillRectangle(const gcn::Rectangle &rect); - - void setTargetPlane(int width, int height); - - void drawQuadArrayfi(int size); - - void drawQuadArrayfi(GLint *intVertArray, GLfloat *floatTexArray, - int size); - - void drawQuadArrayii(int size); - - void drawQuadArrayii(GLint *intVertArray, GLint *intTexArray, - int size); - - void drawLineArrayi(int size); - - void drawLineArrayf(int size); - - static void dumpSettings(); - - /** - * Takes a screenshot and returns it as SDL surface. - */ - SDL_Surface *getScreenshot(); - - void prepareScreenshot(); - - bool drawNet(int x1, int y1, int x2, int y2, int width, int height); - - int getMemoryUsage(); - - void updateTextureFormat(); - - static void bindTexture(GLenum target, GLuint texture); - - static GLuint mLastImage; - - protected: - bool drawImage2(const Image *image, - int srcX, int srcY, - int dstX, int dstY, - int width, int height, - bool useColor); - - void setTexturingAndBlending(bool enable); - - void logString(const char *format, GLenum num); - - void updateMemoryInfo(); - - void debugBindTexture(const Image *image); - - private: - GLfloat *mFloatTexArray; - GLint *mIntTexArray; - GLint *mIntVertArray; - bool mAlpha, mTexture; - bool mColorAlpha; - GLuint mFboId; - GLuint mTextureId; - GLuint mRboId; -#ifdef DEBUG_BIND_TEXTURE - std::string mOldTexture; - unsigned mOldTextureId; -#endif -}; -#endif - -#endif diff --git a/src/resources/image.cpp b/src/resources/image.cpp index 342bca1b5..4b5fa4f40 100644 --- a/src/resources/image.cpp +++ b/src/resources/image.cpp @@ -26,7 +26,7 @@ #include "resources/resourcemanager.h" #ifdef USE_OPENGL -#include "openglgraphics.h" +#include "normalopenglgraphics.h" #include "safeopenglgraphics.h" #endif diff --git a/src/resources/image.h b/src/resources/image.h index 756c9e23d..84895125c 100644 --- a/src/resources/image.h +++ b/src/resources/image.h @@ -59,7 +59,7 @@ class Image : public Resource friend class OpenGLImageHelper; friend class SDLImageHelper; #ifdef USE_OPENGL - friend class OpenGLGraphics; + friend class NormalOpenGLGraphics; friend class SafeOpenGLGraphics; #endif diff --git a/src/resources/openglimagehelper.cpp b/src/resources/openglimagehelper.cpp index 120288b3f..841f9b3ae 100644 --- a/src/resources/openglimagehelper.cpp +++ b/src/resources/openglimagehelper.cpp @@ -27,7 +27,7 @@ #include "resources/dye.h" #include "resources/resourcemanager.h" -#include "openglgraphics.h" +#include "normalopenglgraphics.h" #include "safeopenglgraphics.h" #include "client.h" @@ -213,7 +213,7 @@ Image *OpenGLImageHelper::glLoad(SDL_Surface *tmpImage) GLuint texture; glGenTextures(1, &texture); if (mUseOpenGL == 1) - OpenGLGraphics::bindTexture(mTextureType, texture); + NormalOpenGLGraphics::bindTexture(mTextureType, texture); else if (mUseOpenGL == 2) SafeOpenGLGraphics::bindTexture(mTextureType, texture); diff --git a/src/resources/subimage.cpp b/src/resources/subimage.cpp index 1b9f745d3..2f4104580 100644 --- a/src/resources/subimage.cpp +++ b/src/resources/subimage.cpp @@ -23,7 +23,7 @@ #include "resources/subimage.h" #ifdef USE_OPENGL -#include "openglgraphics.h" +#include "normalopenglgraphics.h" #include "safeopenglgraphics.h" #endif diff --git a/src/safeopenglgraphics.cpp b/src/safeopenglgraphics.cpp index cc8bcc95b..37001f850 100644 --- a/src/safeopenglgraphics.cpp +++ b/src/safeopenglgraphics.cpp @@ -56,7 +56,7 @@ SafeOpenGLGraphics::~SafeOpenGLGraphics() } bool SafeOpenGLGraphics::setVideoMode(int w, int h, int bpp, bool fs, - bool hwaccel, bool resize, bool noFrame) + bool hwaccel, bool resize, bool noFrame) { setMainFlags(w, h, bpp, fs, hwaccel, resize, noFrame); @@ -141,8 +141,8 @@ static inline void drawRescaledQuad(Image *image, int srcX, int srcY, bool SafeOpenGLGraphics::drawImage2(const Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, bool useColor) + int dstX, int dstY, + int width, int height, bool useColor) { if (!image) return false; @@ -174,10 +174,10 @@ bool SafeOpenGLGraphics::drawImage2(const Image *image, int srcX, int srcY, } bool SafeOpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight, - bool useColor) + int dstX, int dstY, + int width, int height, + int desiredWidth, int desiredHeight, + bool useColor) { return drawRescaledImage(image, srcX, srcY, dstX, dstY, @@ -187,10 +187,10 @@ bool SafeOpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, } bool SafeOpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, - int dstX, int dstY, - int width, int height, - int desiredWidth, int desiredHeight, - bool useColor, bool smooth) + int dstX, int dstY, + int width, int height, + int desiredWidth, int desiredHeight, + bool useColor, bool smooth) { if (!image) return false; @@ -252,7 +252,7 @@ bool SafeOpenGLGraphics::drawRescaledImage(Image *image, int srcX, int srcY, /* Optimising the functions that Graphics::drawImagePattern would call, * so that glBegin...glEnd are outside the main loop. */ void SafeOpenGLGraphics::drawImagePattern(const Image *image, int x, int y, - int w, int h) + int w, int h) { if (!image) return; @@ -296,9 +296,9 @@ void SafeOpenGLGraphics::drawImagePattern(const Image *image, int x, int y, } void SafeOpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y, - int w, int h, - int scaledWidth, - int scaledHeight) + int w, int h, + int scaledWidth, + int scaledHeight) { if (!image) return; @@ -347,15 +347,16 @@ void SafeOpenGLGraphics::drawRescaledImagePattern(Image *image, int x, int y, } bool SafeOpenGLGraphics::calcImageRect(GraphicsVertexes* vert, - int x, int y, int w, int h, - Image *topLeft A_UNUSED, - Image *topRight A_UNUSED, - Image *bottomLeft A_UNUSED, - Image *bottomRight A_UNUSED, - Image *top A_UNUSED, Image *right A_UNUSED, - Image *bottom A_UNUSED, - Image *left A_UNUSED, - Image *center A_UNUSED) + int x, int y, int w, int h, + Image *topLeft A_UNUSED, + Image *topRight A_UNUSED, + Image *bottomLeft A_UNUSED, + Image *bottomRight A_UNUSED, + Image *top A_UNUSED, + Image *right A_UNUSED, + Image *bottom A_UNUSED, + Image *left A_UNUSED, + Image *center A_UNUSED) { if (!vert) return false; @@ -365,7 +366,7 @@ bool SafeOpenGLGraphics::calcImageRect(GraphicsVertexes* vert, } void SafeOpenGLGraphics::calcTile(ImageVertexes *vert A_UNUSED, - int x A_UNUSED, int y A_UNUSED) + int x A_UNUSED, int y A_UNUSED) { } @@ -376,7 +377,7 @@ void SafeOpenGLGraphics::drawTile(ImageVertexes *vert A_UNUSED) } void SafeOpenGLGraphics::drawImageRect2(GraphicsVertexes* vert, - const ImageRect &imgRect) + const ImageRect &imgRect) { if (!vert) return; -- cgit v1.2.3-60-g2f50