tibia-client/src/framework/graphics/graphics.cpp

387 lines
9.7 KiB
C++
Raw Normal View History

2011-08-28 15:17:58 +02:00
/*
* Copyright (c) 2010-2013 OTClient <https://github.com/edubart/otclient>
2011-08-28 15:17:58 +02:00
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
2011-08-14 04:09:11 +02:00
#include "fontmanager.h"
#if OPENGL_ES==2
#include "painterogl2.h"
#elif OPENGL_ES==1
#include "painterogl1.h"
#else
#include "painterogl1.h"
#include "painterogl2.h"
#endif
2011-08-14 04:09:11 +02:00
2011-08-15 16:06:15 +02:00
#include <framework/graphics/graphics.h>
#include <framework/graphics/texture.h>
#include "texturemanager.h"
#include "framebuffermanager.h"
2011-12-25 00:14:12 +01:00
#include <framework/platform/platformwindow.h>
2011-08-15 16:06:15 +02:00
Graphics g_graphics;
Graphics::Graphics()
{
m_maxTextureSize = -1;
m_selectedPainterEngine = Painter_Any;
}
void Graphics::init()
{
2012-06-01 22:39:23 +02:00
g_logger.info(stdext::format("GPU %s", glGetString(GL_RENDERER)));
g_logger.info(stdext::format("OpenGL %s", glGetString(GL_VERSION)));
#if OPENGL_ES==2
g_painterOGL2 = new PainterOGL2;
#elif OPENGL_ES==1
g_painterOGL1 = new PainterOGL1;
#else
2011-12-29 19:18:12 +01:00
// init GL extensions
GLenum err = glewInit();
if(err != GLEW_OK)
2012-06-01 22:39:23 +02:00
g_logger.fatal(stdext::format("Unable to init GLEW: %s", glewGetErrorString(err)));
// overwrite framebuffer API if needed
2012-04-04 04:41:12 +02:00
if(GLEW_EXT_framebuffer_object && !GLEW_ARB_framebuffer_object) {
glGenFramebuffers = glGenFramebuffersEXT;
glDeleteFramebuffers = glDeleteFramebuffersEXT;
glBindFramebuffer = glBindFramebufferEXT;
glFramebufferTexture2D = glFramebufferTexture2DEXT;
glCheckFramebufferStatus = glCheckFramebufferStatusEXT;
2012-04-04 14:56:22 +02:00
glGenerateMipmap = glGenerateMipmapEXT;
2012-04-04 04:41:12 +02:00
}
// opengl 1 is always supported
g_painterOGL1 = new PainterOGL1;
// opengl 2 is only supported in newer hardware
if(GLEW_VERSION_2_0)
g_painterOGL2 = new PainterOGL2;
2011-12-29 19:18:12 +01:00
#endif
2012-04-24 18:37:46 +02:00
// blending is always enabled
glEnable(GL_BLEND);
// determine max texture size
2012-06-22 05:14:13 +02:00
int maxTextureSize = 0;
2012-06-02 20:58:30 +02:00
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
if(m_maxTextureSize == -1 || m_maxTextureSize > maxTextureSize)
m_maxTextureSize = maxTextureSize;
if(Size(m_maxTextureSize,m_maxTextureSize) < g_window.getDisplaySize())
m_cacheBackbuffer = false;
2012-06-11 01:48:53 +02:00
m_alphaBits = 0;
glGetIntegerv(GL_ALPHA_BITS, &m_alphaBits);
m_ok = true;
selectPainterEngine(m_prefferedPainterEngine);
g_textures.init();
g_framebuffers.init();
}
void Graphics::terminate()
{
g_fonts.terminate();
g_framebuffers.terminate();
g_textures.terminate();
#ifdef PAINTER_OGL2
if(g_painterOGL2) {
delete g_painterOGL2;
g_painterOGL2 = nullptr;
}
#endif
#ifdef PAINTER_OGL1
if(g_painterOGL1) {
delete g_painterOGL1;
g_painterOGL1 = nullptr;
}
#endif
g_painter = nullptr;
m_ok = false;
}
bool Graphics::parseOption(const std::string& option)
{
if(option == "-no-draw-arrays")
m_useDrawArrays = false;
else if(option == "-no-fbos")
m_useFBO = false;
else if(option == "-no-mipmaps")
m_useMipmaps = false;
else if(option == "-no-hardware-mipmaps")
m_useHardwareMipmaps = false;
else if(option == "-no-smooth")
m_useBilinearFiltering = false;
2012-04-20 15:18:33 +02:00
else if(option == "-hardware-buffers")
m_useHardwareBuffers = true;
else if(option == "-no-non-power-of-two-textures")
m_useNonPowerOfTwoTextures = false;
else if(option == "-no-clamp-to-edge")
m_useClampToEdge = false;
2012-06-08 18:58:08 +02:00
else if(option == "-no-backbuffer-cache")
m_cacheBackbuffer = false;
else if(option == "-opengl1")
m_prefferedPainterEngine = Painter_OpenGL1;
else if(option == "-opengl2")
m_prefferedPainterEngine = Painter_OpenGL2;
else
return false;
return true;
}
bool Graphics::isPainterEngineAvailable(Graphics::PainterEngine painterEngine)
{
#ifdef PAINTER_OGL2
if(g_painterOGL2 && painterEngine == Painter_OpenGL2)
return true;
#endif
#ifdef PAINTER_OGL1
if(g_painterOGL1 && painterEngine == Painter_OpenGL1)
return true;
#endif
return false;
}
bool Graphics::selectPainterEngine(PainterEngine painterEngine)
{
Painter *painter = nullptr;
Painter *fallbackPainter = nullptr;
PainterEngine fallbackPainterEngine = Painter_Any;
#ifdef PAINTER_OGL2
// always prefer OpenGL 2 over OpenGL 1
if(g_painterOGL2) {
if(!painter && (painterEngine == Painter_OpenGL2 || painterEngine == Painter_Any)) {
m_selectedPainterEngine = Painter_OpenGL2;
painter = g_painterOGL2;
}
fallbackPainter = g_painterOGL2;
fallbackPainterEngine = Painter_OpenGL2;
}
#endif
#ifdef PAINTER_OGL1
// fallback to OpenGL 1 in older hardwares
if(g_painterOGL1) {
if(!painter && (painterEngine == Painter_OpenGL1 || painterEngine == Painter_Any)) {
m_selectedPainterEngine = Painter_OpenGL1;
painter = g_painterOGL1;
}
fallbackPainter = g_painterOGL1;
fallbackPainterEngine = Painter_OpenGL1;
}
#endif
if(!painter) {
painter = fallbackPainter;
m_selectedPainterEngine = fallbackPainterEngine;
}
// switch painters GL state
2012-07-05 20:49:10 +02:00
if(painter) {
if(painter != g_painter) {
if(g_painter)
g_painter->unbind();
painter->bind();
g_painter = painter;
}
if(painterEngine == Painter_Any)
return true;
} else
g_logger.fatal("Neither OpenGL 1.0 nor OpenGL 2.0 painter engine is supported by your platform, "
"try updating your graphics drivers or your hardware and then run again.");
return m_selectedPainterEngine == painterEngine;
}
2011-04-08 07:10:00 +02:00
void Graphics::resize(const Size& size)
2010-11-23 16:30:43 +01:00
{
2012-06-14 20:26:55 +02:00
m_viewportSize = size;
#ifdef PAINTER_OGL1
if(g_painterOGL1)
2012-06-14 20:26:55 +02:00
g_painterOGL1->setResolution(size);
#endif
#ifdef PAINTER_OGL2
if(g_painterOGL2)
2012-06-14 20:26:55 +02:00
g_painterOGL2->setResolution(size);
#endif
}
bool Graphics::canUseDrawArrays()
{
#ifdef OPENGL_ES
return true;
#else
// glDrawArrays is supported by OpenGL 1.1
if(!GLEW_VERSION_1_1)
return false;
return m_useDrawArrays;
#endif
}
bool Graphics::canUseShaders()
2012-01-30 01:00:12 +01:00
{
#if OPENGL_ES==2
return true;
#elif OPENGL_ES==1
return false;
#else
// fragment and vertex programs are supported by OpenGL 2.0
if(GLEW_ARB_vertex_program && GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader)
return true;
return false;
#endif
}
bool Graphics::canUseFBO()
{
#if OPENGL_ES==2
return m_useFBO;
#elif OPENGL_ES==1
return false;
#else
// FBOs are supported by OpenGL 3.0
// or by OpenGL 2.0 with EXT_framebuffer_object (most of the OpenGL 2.0 implementations have this extension)
if(!GLEW_ARB_framebuffer_object || !GLEW_EXT_framebuffer_object)
return false;
return m_useFBO;
#endif
}
bool Graphics::canUseBilinearFiltering()
{
// bilinear filtering is supported by any OpenGL implementation
return m_useBilinearFiltering;
}
bool Graphics::canUseHardwareBuffers()
{
2012-04-20 14:07:47 +02:00
#if OPENGL_ES==2
2012-04-20 15:18:33 +02:00
return m_useHardwareBuffers;
2012-04-20 14:07:47 +02:00
#elif OPENGL_ES==1
// OpenGL ES 1.1 supports it but OpenGL ES 1.0 not
return false;
#else
// vertex buffer objects is supported by OpenGL 1.5
if(!GLEW_ARB_vertex_buffer_object)
return false;
#endif
return m_useHardwareBuffers;
}
bool Graphics::canUseNonPowerOfTwoTextures()
{
#if OPENGL_ES==2
return m_useNonPowerOfTwoTextures;
#elif OPENGL_ES==1
return false;
#else
// power of two textures is supported by OpenGL 2.0
if(!GLEW_ARB_texture_non_power_of_two)
return false;
return m_useNonPowerOfTwoTextures;
#endif
}
bool Graphics::canUseMipmaps()
{
// mipmaps is supported by any OpenGL implementation
return m_useMipmaps;
}
bool Graphics::canUseHardwareMipmaps()
{
#if OPENGL_ES==2
return m_useHardwareMipmaps;
#elif OPENGL_ES==1
return false;
#else
// glGenerateMipmap is supported when FBOs are
if(!GLEW_ARB_framebuffer_object || !GLEW_EXT_framebuffer_object)
return false;
return m_useHardwareMipmaps;
#endif
}
bool Graphics::canUseClampToEdge()
{
#ifdef OPENGL_ES
return m_useClampToEdge;
#else
// GL_CLAMP_TO_EDGE is present in OpenGL 1.2
if(!GLEW_VERSION_1_2)
return false;
return m_useClampToEdge;
#endif
2012-01-30 01:00:12 +01:00
}
2012-06-02 01:21:45 +02:00
bool Graphics::canUseBlendFuncSeparate()
{
2012-06-03 16:10:34 +02:00
#if OPENGL_ES==2
2012-06-02 01:21:45 +02:00
return true;
2012-06-03 16:10:34 +02:00
#elif OPENGL_ES==1
return false;
2012-06-02 01:21:45 +02:00
#else
if(!GLEW_VERSION_1_4)
return false;
return true;
#endif
}
2012-06-08 18:58:08 +02:00
bool Graphics::canCacheBackbuffer()
{
2012-06-11 01:48:53 +02:00
if(!m_alphaBits)
return false;
2012-06-08 18:58:08 +02:00
#if OPENGL_ES==2
return m_cacheBackbuffer;
#elif OPENGL_ES==1
return false;
#else
if(!GLEW_VERSION_1_4)
return false;
return m_cacheBackbuffer;
#endif
}
bool Graphics::hasScissorBug()
{
#if OPENGL_ES==2
return false;
#elif OPENGL_ES==1
return false;
#else
if(!GLEW_VERSION_1_2)
return true;
return false;
#endif
}