GraphicsManager Class Reference

#include <graphicsmanager.h>

Public Member Functions
	GraphicsManager ()
	~GraphicsManager ()
void	createRenderers ()
void	initGraphics ()
bool	getAllVideoModes (StringVect &modeList)
void	detectPixelSize ()
std::string	getDensityString () const
int	getDensity () const
TestMain *	startDetection ()
int	detectGraphics ()
bool	supportExtension (const std::string &ext) const
void	updateTextureCompressionFormat () const
bool	checkGLVersion (const int major, const int minor) const
bool	checkGLesVersion (const int major, const int minor) const
bool	checkSLVersion (const int major, const int minor) const
bool	checkPlatformVersion (const int major, const int minor) const
void	initOpenGLFunctions ()
void	updateExtensions ()
void	updatePlanformExtensions ()
void	initOpenGL ()
void	updateLimits ()
int	getMaxVertices () const
bool	getUseAtlases () const
void	logVersion () const
void	setGLVersion ()
void	detectVideoSettings ()
void	createTextureSampler ()
bool	isUseTextureSampler () const
void	updateDebugLog () const
std::string	getGLVersion () const

Static Public Member Functions
static void	deleteRenderers ()
static void	setVideoMode ()
static SDL_Surface *	createWindow (const int w, const int h, const int bpp, const int flags)
static void	updateTextureFormat ()
static void	createFBO (const int width, const int height, FBOInfo *const fbo)
static void	deleteFBO (FBOInfo *const fbo)
static std::string	getGLString (const int num)
static void	logString (const char *const format, const int num)
static GLenum	getLastError ()
static std::string	errorToString (const GLenum error)
static void	logError ()
static GLenum	getLastErrorCached ()
static void	resetCachedError ()

Private Attributes
std::set< std::string >	mExtensions
std::set< std::string >	mPlatformExtensions
std::string	mGlVersionString
std::string	mGlVendor
std::string	mGlRenderer
std::string	mGlShaderVersionString
int	mMinor
int	mMajor
int	mSLMinor
int	mSLMajor
int	mPlatformMinor
int	mPlatformMajor
int	mMaxVertices
int	mMaxFboSize
uint32_t	mMaxWidth
uint32_t	mMaxHeight
uint32_t	mWidthMM
uint32_t	mHeightMM
int32_t	mDensity
bool	mUseTextureSampler
GLuint	mTextureSampler
int	mSupportDebug
bool	mSupportModernOpengl
bool	mGles
bool	mUseAtlases

Static Private Attributes
static GLenum	mLastError

Detailed Description

Definition at line 72 of file graphicsmanager.h.

Constructor & Destructor Documentation

GraphicsManager()

GraphicsManager::GraphicsManager

(

)

Definition at line 137 of file graphicsmanager.cpp.

                                 :
    mExtensions(),
    mPlatformExtensions(),
    mGlVersionString(),
    mGlVendor(),
    mGlRenderer(),
    mGlShaderVersionString(),
    mMinor(0),
    mMajor(0),
    mSLMinor(0),
    mSLMajor(0),
    mPlatformMinor(0),
    mPlatformMajor(0),
    mMaxVertices(500),
    mMaxFboSize(0),
    mMaxWidth(0),
    mMaxHeight(0),
    mWidthMM(0),
    mHeightMM(0),
    mDensity(-1),
#ifdef USE_OPENGL
    mUseTextureSampler(true),
    mTextureSampler(0),
    mSupportDebug(0),
    mSupportModernOpengl(false),
    mGles(false),
#endif  // USE_OPENGL
    mUseAtlases(false)
{
}

~GraphicsManager()

GraphicsManager::~GraphicsManager

(

)

Definition at line 168 of file graphicsmanager.cpp.

{
#ifdef USE_OPENGL
    if (isGLNotNull(mglGenSamplers) && mTextureSampler)
        mglDeleteSamplers(1, &mTextureSampler);
#endif  // USE_OPENGL
}

References isGLNotNull, and mTextureSampler.

Member Function Documentation

checkGLesVersion()

bool GraphicsManager::checkGLesVersion	(	const int	major,
		const int	minor
	)		const

Definition at line 930 of file graphicsmanager.cpp.

{
    return mGles && (mMajor > major || (mMajor == major && mMinor >= minor));
}

References mGles, mMajor, and mMinor.

Referenced by initGraphics(), and updateTextureCompressionFormat().

checkGLVersion()

bool GraphicsManager::checkGLVersion	(	const int	major,
		const int	minor
	)		const

Definition at line 920 of file graphicsmanager.cpp.

{
    return mMajor > major || (mMajor == major && mMinor >= minor);
}

References mMajor, and mMinor.

Referenced by detectGraphics(), initGraphics(), initOpenGLFunctions(), updateExtensions(), and updateTextureCompressionFormat().

checkPlatformVersion()

bool GraphicsManager::checkPlatformVersion	(	const int	major,
		const int	minor
	)		const

Definition at line 935 of file graphicsmanager.cpp.

{
    return mPlatformMajor > major || (mPlatformMajor == major
        && mPlatformMinor >= minor);
}

References mPlatformMajor, and mPlatformMinor.

Referenced by updatePlanformExtensions().

checkSLVersion()

bool GraphicsManager::checkSLVersion	(	const int	major,
		const int	minor
	)		const

Definition at line 925 of file graphicsmanager.cpp.

{
    return mSLMajor > major || (mSLMajor == major && mSLMinor >= minor);
}

References mSLMajor, and mSLMinor.

createFBO()

void GraphicsManager::createFBO ( const int  width, const int  height, FBOInfo *const  fbo  )

static

Definition at line 942 of file graphicsmanager.cpp.

{
    if (!fbo)
        return;
 
    // create a texture object
    glGenTextures(1, &fbo->textureId);
    glBindTexture(OpenGLImageHelper::mTextureType, fbo->textureId);
    glTexParameterf(OpenGLImageHelper::mTextureType,
        GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameterf(OpenGLImageHelper::mTextureType,
        GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameterf(OpenGLImageHelper::mTextureType,
        GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameterf(OpenGLImageHelper::mTextureType,
        GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexImage2D(OpenGLImageHelper::mTextureType, 0, GL_RGBA8, width, height,
        0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
    glBindTexture(OpenGLImageHelper::mTextureType, 0);
 
    // create a renderbuffer object to store depth info
    mglGenRenderbuffers(1, &fbo->rboId);
    mglBindRenderbuffer(GL_RENDERBUFFER, fbo->rboId);
    mglRenderbufferStorage(GL_RENDERBUFFER,
        GL_DEPTH_COMPONENT, width, height);
    mglBindRenderbuffer(GL_RENDERBUFFER, 0);
 
    // create a framebuffer object
    mglGenFramebuffers(1, &fbo->fboId);
    mglBindFramebuffer(GL_FRAMEBUFFER, fbo->fboId);
 
    // attach the texture to FBO color attachment point
    mglFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
        OpenGLImageHelper::mTextureType, fbo->textureId, 0);
 
    // attach the renderbuffer to depth attachment point
    mglFramebufferRenderbuffer(GL_FRAMEBUFFER,
        GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo->rboId);
 
    mglBindFramebuffer(GL_FRAMEBUFFER, fbo->fboId);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}

References GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER, GL_RENDERBUFFER, and OpenGLImageHelper::mTextureType.

Referenced by MobileOpenGLScreenshotHelper::prepare(), and OpenGLScreenshotHelper::prepare().

createRenderers()

void GraphicsManager::createRenderers

(

)

Definition at line 340 of file graphicsmanager.cpp.

{
    RenderType useOpenGL = RENDER_SOFTWARE;
    if (!settings.options.noOpenGL)
    {
        if (settings.options.renderer < 0)
        {
            useOpenGL = intToRenderType(config.getIntValue("opengl"));
            settings.options.renderer = CAST_S32(useOpenGL);
        }
        else
        {
            useOpenGL = intToRenderType(settings.options.renderer);
        }
    }
 
    // Setup image loading for the right image format
    ImageHelper::setOpenGlMode(useOpenGL);
 
    // Create the graphics context
    switch (useOpenGL)
    {
        case RENDER_SOFTWARE:
            RENDER_SOFTWARE_INIT
            mUseTextureSampler = false;
            break;
        case RENDER_LAST:
        case RENDER_NULL:
        default:
            break;
        case RENDER_NORMAL_OPENGL:
            RENDER_NORMAL_OPENGL_INIT
            break;
        case RENDER_SAFE_OPENGL:
            RENDER_SAFE_OPENGL_INIT
            break;
        case RENDER_MODERN_OPENGL:
            RENDER_MODERN_OPENGL_INIT
            break;
        case RENDER_GLES2_OPENGL:
            RENDER_GLES2_OPENGL_INIT
            break;
        case RENDER_GLES_OPENGL:
            RENDER_GLES_OPENGL_INIT
            break;
        case RENDER_SDL2_DEFAULT:
            RENDER_SDL2_DEFAULT_INIT
            break;
    }
    mUseAtlases = (useOpenGL == RENDER_NORMAL_OPENGL ||
        useOpenGL == RENDER_SAFE_OPENGL ||
        useOpenGL == RENDER_MODERN_OPENGL ||
        useOpenGL == RENDER_GLES_OPENGL ||
        useOpenGL == RENDER_GLES2_OPENGL) &&
        config.getBoolValue("useAtlases");
 
#else  // USE_OPENGL
 
void GraphicsManager::createRenderers()
{
    RenderType useOpenGL = RENDER_SOFTWARE;
    if (!settings.options.noOpenGL)
        useOpenGL = intToRenderType(config.getIntValue("opengl"));
 
    // Setup image loading for the right image format
    ImageHelper::setOpenGlMode(useOpenGL);
 
    // Create the graphics context
    switch (useOpenGL)
    {
        case RENDER_SOFTWARE:
        case RENDER_SAFE_OPENGL:
        case RENDER_GLES_OPENGL:
        case RENDER_GLES2_OPENGL:
        case RENDER_MODERN_OPENGL:
        case RENDER_NORMAL_OPENGL:
        case RENDER_NULL:
        case RENDER_LAST:
        default:
#ifndef USE_SDL2
        case RENDER_SDL2_DEFAULT:
            imageHelper = new SDLImageHelper;
            surfaceImageHelper = imageHelper;
            mainGraphics = new SDLGraphics;
            screenshortHelper = new SdlScreenshotHelper;
#else  // USE_SDL2
 
            imageHelper = new SDL2SoftwareImageHelper;
            surfaceImageHelper = new SurfaceImageHelper;
            mainGraphics = new SDL2SoftwareGraphics;
            screenshortHelper = new Sdl2SoftwareScreenshotHelper;
 
#endif  // USE_SDL2
 
            break;
#ifdef USE_SDL2
        case RENDER_SDL2_DEFAULT:
            imageHelper = new SDLImageHelper;
            surfaceImageHelper = new SurfaceImageHelper;
            mainGraphics = new SDLGraphics;
            mainGraphics->setRendererFlags(SDL_RENDERER_ACCELERATED);
            screenshortHelper = new SdlScreenshotHelper;
            break;
#endif  // USE_SDL2
    };
#endif  // USE_OPENGL
}

References CAST_S32, config, Configuration::getBoolValue(), Configuration::getIntValue(), imageHelper, intToRenderType(), mainGraphics, mUseAtlases, mUseTextureSampler, Options::noOpenGL, Settings::options, RENDER_GLES2_OPENGL, RENDER_GLES2_OPENGL_INIT, RENDER_GLES_OPENGL, RENDER_GLES_OPENGL_INIT, RENDER_LAST, RENDER_MODERN_OPENGL, RENDER_MODERN_OPENGL_INIT, RENDER_NORMAL_OPENGL, RENDER_NORMAL_OPENGL_INIT, RENDER_NULL, RENDER_SAFE_OPENGL, RENDER_SAFE_OPENGL_INIT, RENDER_SDL2_DEFAULT, RENDER_SDL2_DEFAULT_INIT, RENDER_SOFTWARE, RENDER_SOFTWARE_INIT, Options::renderer, screenshortHelper, ImageHelper::setOpenGlMode(), settings, surfaceImageHelper, and SurfaceImageHelper.

Referenced by initGraphics().

createTextureSampler()

void GraphicsManager::createTextureSampler

(

)

Definition at line 1445 of file graphicsmanager.cpp.

{
    GLenum err = getLastError();
    if (err)
        logger->log(errorToString(err));
    if (mUseTextureSampler)
    {
        logger->log1("using texture sampler");
        mglGenSamplers(1, &mTextureSampler);
        if (getLastError() != GL_NO_ERROR)
        {
            mUseTextureSampler = false;
            logger->log1("texture sampler error");
            OpenGLImageHelper::setUseTextureSampler(mUseTextureSampler);
            return;
        }
        OpenGLImageHelper::initTextureSampler(mTextureSampler);
        mglBindSampler(0, mTextureSampler);
        if (getLastError() != GL_NO_ERROR)
        {
            mUseTextureSampler = false;
            logger->log1("texture sampler error");
        }
    }
    OpenGLImageHelper::setUseTextureSampler(mUseTextureSampler);
#if !defined(ANDROID) && !defined(__SWITCH__)
    SafeOpenGLImageHelper::setUseTextureSampler(false);
#endif  // ANDROID
}

References errorToString(), getLastError(), OpenGLImageHelper::initTextureSampler(), Logger::log(), Logger::log1(), logger, mTextureSampler, mUseTextureSampler, OpenGLImageHelper::setUseTextureSampler(), and SafeOpenGLImageHelper::setUseTextureSampler().

Referenced by initOpenGL().

createWindow()

SDL_Surface * GraphicsManager::createWindow ( const int  w, const int  h, const int  bpp, const int  flags  )

static

Definition at line 640 of file graphicsmanager.cpp.

{
    return SDL_SetVideoMode(w, h, bpp, flags);
}

Referenced by detectGraphics(), main(), and Graphics::setOpenGLMode().

deleteFBO()

void GraphicsManager::deleteFBO ( FBOInfo *const  fbo )

static

Definition at line 986 of file graphicsmanager.cpp.

{
    if (!fbo)
        return;
 
    mglBindFramebuffer(GL_FRAMEBUFFER, 0);
    if (fbo->fboId)
    {
        mglDeleteFramebuffers(1, &fbo->fboId);
        fbo->fboId = 0;
    }
    mglBindRenderbuffer(GL_RENDERBUFFER, 0);
    if (fbo->rboId)
    {
        mglDeleteRenderbuffers(1, &fbo->rboId);
        fbo->rboId = 0;
    }
    if (fbo->textureId)
    {
        glDeleteTextures(1, &fbo->textureId);
        fbo->textureId = 0;
    }
}

References GL_FRAMEBUFFER, and GL_RENDERBUFFER.

Referenced by MobileOpenGLScreenshotHelper::getScreenshot(), and OpenGLScreenshotHelper::getScreenshot().

deleteRenderers()

void GraphicsManager::deleteRenderers ( )

static

Definition at line 448 of file graphicsmanager.cpp.

{
    delete2(mainGraphics)
    if (imageHelper != surfaceImageHelper)
        delete surfaceImageHelper;
    surfaceImageHelper = nullptr;
    delete2(imageHelper)
}

References delete2, imageHelper, mainGraphics, and surfaceImageHelper.

Referenced by Client::gameClear(), and initGraphics().

detectGraphics()

int GraphicsManager::detectGraphics

(

)

< Allow any video depth/pixel-format

< Create an OpenGL rendering context

Definition at line 184 of file graphicsmanager.cpp.

{
    logger->log1("start detecting best mode...");
    logger->log1("enable opengl mode");
    int textureSampler = 0;
    int compressTextures = 0;
#if !defined(ANDROID) && !defined(__native_client__) && !defined(__SWITCH__)
    mainGraphics = new NormalOpenGLGraphics;
#endif  // !defined(ANDROID) && !defined(__native_client__)
 
    SDL_Window *const window = createWindow(100, 100, 0,
        SDL_ANYFORMAT | SDL_OPENGL);
    mainGraphics->setWindow(window, 100, 100);
    mainGraphics->createGLContext(false);
 
    initOpenGL();
    logVersion();
 
    RenderType mode = RENDER_NORMAL_OPENGL;
 
    // detecting features by known renderers or vendors
    if (findI(mGlRenderer, "gdi generic") != std::string::npos)
    {
        // windows gdi OpenGL emulation
        logger->log("detected gdi drawing");
        logger->log("disable OpenGL");
        mode = RENDER_SOFTWARE;
    }
    else if (findI(mGlRenderer, "Software Rasterizer") != std::string::npos)
    {
        // software OpenGL emulation
        logger->log("detected software drawing");
        logger->log("disable OpenGL");
        mode = RENDER_SOFTWARE;
    }
    else if (findI(mGlRenderer, "Indirect") != std::string::npos)
    {
        // indirect OpenGL drawing
        logger->log("detected indirect drawing");
        logger->log("disable OpenGL");
        mode = RENDER_SOFTWARE;
    }
    else if (findI(mGlVendor, "VMWARE") != std::string::npos)
    {
        // vmware emulation
        logger->log("detected VMWARE driver");
        logger->log("disable OpenGL");
        mode = RENDER_SOFTWARE;
    }
    else if (findI(mGlVendor, "NVIDIA") != std::string::npos)
    {
        // hope it can work well
        logger->log("detected NVIDIA driver");
        config.setValue("useTextureSampler", true);
        textureSampler = 1;
        mode = RENDER_NORMAL_OPENGL;
    }
 
    // detecting feature based on OpenGL version
    if (!checkGLVersion(1, 1))
    {
        // very old OpenGL version
        logger->log("OpenGL version too old");
        mode = RENDER_SOFTWARE;
    }
 
    if (mode != RENDER_SOFTWARE && findI(mGlVersionString, "Mesa")
        != std::string::npos)
    {
        // Mesa detected. In latest Mesa look like compression broken.
        config.setValue("compresstextures", false);
        compressTextures = 0;
    }
 
    config.setValue("opengl", CAST_S32(mode));
    config.setValue("videoconfigured", true);
    config.write();
 
    logger->log("detection complete");
    return CAST_U32(mode)
        | (1024 * textureSampler) | (2048 * compressTextures);
}

References CAST_S32, CAST_U32, checkGLVersion(), config, Graphics::createGLContext(), createWindow(), findI(), initOpenGL(), Logger::log(), Logger::log1(), logger, logVersion(), mainGraphics, mGlRenderer, mGlVendor, mGlVersionString, RENDER_NORMAL_OPENGL, RENDER_SOFTWARE, SDL_Window, Configuration::setValue(), Graphics::setWindow(), and Configuration::write().

Referenced by TestLauncher::testVideoDetection().

detectPixelSize()

void GraphicsManager::detectPixelSize

(

)

Definition at line 1663 of file graphicsmanager.cpp.

{
    SDL_SysWMinfo info;
    SDL_VERSION(&info.version)
    if (SDL::getWindowWMInfo(mainGraphics->getWindow(), &info))
    {
#ifdef WIN32
        HDC hdc = GetDC(info.window);
        if (hdc)
        {
//            SetProcessDPIAware();
            mMaxWidth = GetDeviceCaps(hdc, HORZRES);
            mMaxHeight = GetDeviceCaps(hdc, VERTRES);
            mWidthMM = GetDeviceCaps(hdc, HORZSIZE);
            mHeightMM = GetDeviceCaps(hdc, VERTSIZE);
        }
#elif defined USE_X11
        Display *const display = info.info.x11.display;
        if (display)
        {
            Screen *const screen = XDefaultScreenOfDisplay(display);
            if (!screen)
                return;
 
            const int screenNum = XScreenNumberOfScreen(screen);
            mMaxWidth = DisplayWidth(display, screenNum);
            mMaxHeight = DisplayHeight(display, screenNum);
            mWidthMM = DisplayWidthMM(display, screenNum);
            mHeightMM = DisplayHeightMM(display, screenNum);
        }
#endif  // WIN32
    }
#if defined ANDROID
#ifdef USE_SDL2
    const int dpi = atoi(getenv("DISPLAY_DPI"));
    if (dpi <= 120)
        mDensity = 0;
    else if (dpi <= 160)
        mDensity = 1;
    else if (dpi <= 213)
        mDensity = 2;
    else if (dpi <= 240)
        mDensity = 3;
    else if (dpi <= 320)
        mDensity = 4;
//    else if (dpi <= 480)
    else
        mDensity = 5;
    mMaxWidth = atoi(getenv("DISPLAY_RESOLUTION_WIDTH"));
    mMaxHeight = atoi(getenv("DISPLAY_RESOLUTION_HEIGHT"));
    mWidthMM = atoi(getenv("DISPLAY_WIDTH_MM"));
    mHeightMM = atoi(getenv("DISPLAY_HEIGHT_MM"));
#else  // USE_SDL2
 
    SDL_ANDROID_GetMetrics(&mMaxWidth, &mMaxHeight,
        &mWidthMM, &mHeightMM, &mDensity);
#endif  // USE_SDL2
#endif  // defined ANDROID
 
    logger->log("screen size in pixels: %ux%u", mMaxWidth, mMaxHeight);
    logger->log("screen size in millimeters: %ux%u", mWidthMM, mHeightMM);
    logger->log("actual screen density: " + getDensityString());
    const int density = config.getIntValue("screenDensity");
    if (density > 0 && density <= densitySize)
    {
        mDensity = density - 1;
        logger->log("selected screen density: " + getDensityString());
    }
}

References config, densitySize, getDensityString(), Configuration::getIntValue(), Graphics::getWindow(), SDL::getWindowWMInfo(), Actions::info(), Logger::log(), logger, mainGraphics, mDensity, mHeightMM, mMaxHeight, mMaxWidth, and mWidthMM.

Referenced by initGraphics().

detectVideoSettings()

void GraphicsManager::detectVideoSettings

(

)

Definition at line 1528 of file graphicsmanager.cpp.

{
    config.setValue("videodetected", true);
    TestMain *const test = startDetection();
 
    if (test)
    {
        const Configuration &conf = test->getConfig();
        int val = conf.getValueInt("opengl", -1);
        if (val >= 0 && val < CAST_S32(RENDER_LAST))
        {
            config.setValue("opengl", val);
            val = conf.getValue("useTextureSampler", -1);
            if (val != -1)
                config.setValue("useTextureSampler", val);
            val = conf.getValue("compresstextures", -1);
            if (val != -1)
                config.setValue("compresstextures", val);
        }
        config.setValue("textureSize", conf.getValue("textureSize",
            "1024,1024,1024,1024,1024,1024"));
        config.setValue("testInfo", conf.getValue("testInfo", ""));
        config.setValue("sound", conf.getValue("sound", 0));
        delete test;
    }
}

References CAST_S32, config, TestMain::getConfig(), ConfigurationObject::getValue(), ConfigurationObject::getValueInt(), RENDER_LAST, Configuration::setValue(), and startDetection().

Referenced by Client::gameInit().

errorToString()

std::string GraphicsManager::errorToString ( const GLenum  error )

static

Definition at line 1488 of file graphicsmanager.cpp.

{
    if (error)
    {
        std::string errmsg("Unknown error");
        switch (error)
        {
            case GL_INVALID_ENUM:
                errmsg = "GL_INVALID_ENUM";
                break;
            case GL_INVALID_VALUE:
                errmsg = "GL_INVALID_VALUE";
                break;
            case GL_INVALID_OPERATION:
                errmsg = "GL_INVALID_OPERATION";
                break;
            case GL_STACK_OVERFLOW:
                errmsg = "GL_STACK_OVERFLOW";
                break;
            case GL_STACK_UNDERFLOW:
                errmsg = "GL_STACK_UNDERFLOW";
                break;
            case GL_OUT_OF_MEMORY:
                errmsg = "GL_OUT_OF_MEMORY";
                break;
            default:
                break;
        }
        return "OpenGL error: " + errmsg;
    }
    return "";
}

References Actions::error().

Referenced by createTextureSampler(), OpenGLImageHelper::glLoad(), SafeOpenGLImageHelper::glLoad(), and logError().

getAllVideoModes()

bool GraphicsManager::getAllVideoModes

(

StringVect &

modeList

)

getDensity()

int GraphicsManager::getDensity ( ) const

inline

Definition at line 103 of file graphicsmanager.h.

        { return mDensity; }

References mDensity.

Referenced by setConfigDefaults2().

getDensityString()

std::string GraphicsManager::getDensityString

(

)

const

Definition at line 1733 of file graphicsmanager.cpp.

{
    if (mDensity >= 0 && mDensity < densitySize)
        return densityNames[mDensity];
    return "";
}

References densityNames, densitySize, and mDensity.

Referenced by detectPixelSize(), and Theme::selectSkin().

getGLString()

std::string GraphicsManager::getGLString ( const int  num )

static

Definition at line 878 of file graphicsmanager.cpp.

{
    const char *str = reinterpret_cast<const char*>(mglGetString(num));
    return str ? str : "";
}

References mglGetString.

Referenced by setGLVersion().

getGLVersion()

std::string GraphicsManager::getGLVersion ( ) const

inline

Definition at line 174 of file graphicsmanager.h.

        { return mGlVersionString; }

References mGlVersionString.

getLastError()

GLenum GraphicsManager::getLastError ( )

static

Definition at line 1475 of file graphicsmanager.cpp.

{
    GLenum tmp = glGetError();
    GLenum error = GL_NO_ERROR;
    while (tmp != GL_NO_ERROR)
    {
        error = tmp;
        mLastError = tmp;
        tmp = glGetError();
    }
    return error;
}

References Actions::error(), and mLastError.

Referenced by createTextureSampler(), OpenGLImageHelper::glLoad(), SafeOpenGLImageHelper::glLoad(), logError(), and TestLauncher::testTextures().

getLastErrorCached()

static GLenum GraphicsManager::getLastErrorCached ( )

inlinestatic

Definition at line 177 of file graphicsmanager.h.

        { return mLastError; }

References mLastError.

Referenced by TestLauncher::testTextures().

getMaxVertices()

int GraphicsManager::getMaxVertices ( ) const

inline

Definition at line 144 of file graphicsmanager.h.

        { return mMaxVertices; }

References mMaxVertices.

Referenced by Graphics::setOpenGLMode().

getUseAtlases()

bool GraphicsManager::getUseAtlases ( ) const

inline

Definition at line 147 of file graphicsmanager.h.

        { return mUseAtlases; }

References mUseAtlases.

Referenced by MapReader::loadEmptyAtlas(), and MapReader::readTileset().

initGraphics()

void GraphicsManager::initGraphics

(

)

Definition at line 536 of file graphicsmanager.cpp.

{
    openGLMode = intToRenderType(config.getIntValue("opengl"));
#ifdef USE_OPENGL
    OpenGLImageHelper::setBlur(config.getBoolValue("blur"));
#if !defined(ANDROID) && !defined(__SWITCH__)
    SafeOpenGLImageHelper::setBlur(config.getBoolValue("blur"));
#endif  // ANDROID
    SurfaceImageHelper::SDLSetEnableAlphaCache(
        config.getBoolValue("alphaCache") &&
        openGLMode == RENDER_SOFTWARE);
    ImageHelper::setEnableAlpha((config.getFloatValue("guialpha") != 1.0F ||
        openGLMode != RENDER_SOFTWARE) &&
        config.getBoolValue("enableGuiOpacity"));
#else  // USE_OPENGL
    SurfaceImageHelper::SDLSetEnableAlphaCache(
        config.getBoolValue("alphaCache"));
    ImageHelper::setEnableAlpha(config.getFloatValue("guialpha") != 1.0F &&
        config.getBoolValue("enableGuiOpacity"));
#endif  // USE_OPENGL
    createRenderers();
    setVideoMode();
    detectPixelSize();
#ifdef USE_OPENGL
    if (config.getBoolValue("checkOpenGLVersion") == true)
    {
        const RenderType oldOpenGLMode = openGLMode;
        if (openGLMode == RENDER_MODERN_OPENGL)
        {
            if (!mSupportModernOpengl || !checkGLVersion(3, 0))
            {
                logger->log("Fallback to normal OpenGL mode");
                openGLMode = RENDER_NORMAL_OPENGL;
            }
        }
        if (openGLMode == RENDER_NORMAL_OPENGL)
        {
            if (!checkGLVersion(2, 0))
            {
                logger->log("Fallback to safe OpenGL mode");
                openGLMode = RENDER_SAFE_OPENGL;
            }
        }
        if (openGLMode == RENDER_GLES_OPENGL)
        {
            if (!checkGLVersion(2, 0) && !checkGLesVersion(1, 0))
            {
                logger->log("Fallback to safe OpenGL mode");
                openGLMode = RENDER_SAFE_OPENGL;
            }
        }
        if (openGLMode == RENDER_GLES2_OPENGL)
        {
            // +++ here need check also not implemented gles flag
            if (!checkGLVersion(2, 0))
            {
                logger->log("Fallback to software mode");
                openGLMode = RENDER_SOFTWARE;
            }
        }
 
        if (openGLMode != oldOpenGLMode)
        {
            deleteRenderers();
            settings.options.renderer = CAST_S32(openGLMode);
            config.setValue("opengl", settings.options.renderer);
            createRenderers();
            setVideoMode();
            detectPixelSize();
        }
    }
#if !defined(ANDROID) && !defined(__APPLE__)
    const std::string str = config.getStringValue("textureSize");
    STD_VECTOR<int> sizes;
    splitToIntVector(sizes, str, ',');
    const size_t pos = CAST_SIZE(openGLMode);
    if (sizes.size() <= pos)
        settings.textureSize = 1024;
    else
        settings.textureSize = sizes[pos];
    logger->log("Detected max texture size: %u", settings.textureSize);
#endif  // !defined(ANDROID) && !defined(__APPLE__)
#endif  // USE_OPENGL
}

References CAST_S32, CAST_SIZE, checkGLesVersion(), checkGLVersion(), config, createRenderers(), deleteRenderers(), detectPixelSize(), Configuration::getBoolValue(), Configuration::getFloatValue(), Configuration::getIntValue(), Configuration::getStringValue(), intToRenderType(), Logger::log(), logger, mSupportModernOpengl, openGLMode, Settings::options, RENDER_GLES2_OPENGL, RENDER_GLES_OPENGL, RENDER_MODERN_OPENGL, RENDER_NORMAL_OPENGL, RENDER_SAFE_OPENGL, RENDER_SOFTWARE, Options::renderer, OpenGLImageHelper::setBlur(), SafeOpenGLImageHelper::setBlur(), ImageHelper::setEnableAlpha(), settings, Configuration::setValue(), setVideoMode(), splitToIntVector(), and Settings::textureSize.

Referenced by Client::initGraphics().

initOpenGL()

void GraphicsManager::initOpenGL

(

)

Definition at line 1434 of file graphicsmanager.cpp.

{
    setGLVersion();
    updateExtensions();
    initOpenGLFunctions();
    updatePlanformExtensions();
    updateDebugLog();
    createTextureSampler();
    updateLimits();
}

References createTextureSampler(), initOpenGLFunctions(), setGLVersion(), updateDebugLog(), updateExtensions(), updateLimits(), and updatePlanformExtensions().

Referenced by detectGraphics(), and Graphics::setOpenGLMode().

initOpenGLFunctions()

void GraphicsManager::initOpenGLFunctions

(

)

Definition at line 1010 of file graphicsmanager.cpp.

{
#ifdef __native_client__
    emulateFunction(glTextureSubImage2DEXT);
#else  // __native_client__
 
    const bool is10 = checkGLVersion(1, 0);
    const bool is11 = checkGLVersion(1, 1);
    const bool is12 = checkGLVersion(1, 2);
    const bool is13 = checkGLVersion(1, 3);
    const bool is15 = checkGLVersion(1, 5);
    const bool is20 = checkGLVersion(2, 0);
    const bool is21 = checkGLVersion(2, 1);
    const bool is30 = checkGLVersion(3, 0);
    const bool is33 = checkGLVersion(3, 3);
    const bool is41 = checkGLVersion(4, 1);
    const bool is42 = checkGLVersion(4, 2);
    const bool is43 = checkGLVersion(4, 3);
    const bool is44 = checkGLVersion(4, 4);
    const bool is45 = checkGLVersion(4, 5);
    mSupportModernOpengl = true;
 
    // Texture sampler
    if (is10 && (is33 || supportExtension("GL_ARB_sampler_objects")))
    {
        logger->log1("found GL_ARB_sampler_objects");
        assignFunction(glGenSamplers)
        assignFunction(glDeleteSamplers)
        assignFunction(glBindSampler)
        assignFunction(glSamplerParameteri)
        if (isGLNotNull(mglGenSamplers)
            && config.getBoolValue("useTextureSampler"))
        {
            mUseTextureSampler &= true;
        }
        else
        {
            mUseTextureSampler = false;
        }
    }
    else
    {
        logger->log1("texture sampler not found");
        mUseTextureSampler = false;
    }
 
    if (!is11)
    {
        mSupportModernOpengl = false;
        emulateFunction(glTextureSubImage2DEXT);
        return;
    }
 
/*
    if (findI(mGlVendor, "NVIDIA") != std::string::npos ||
        mGlVersionString.find("Mesa 10.6.") != std::string::npos ||
        mGlVersionString.find("Mesa 11.1.1") != std::string::npos ||
        mGlVersionString.find("Mesa 11.1.2") != std::string::npos ||
        mGlVersionString.find("Mesa 11.1.3") != std::string::npos ||
        mGlVersionString.find("Mesa 11.2") != std::string::npos ||
        (findI(mGlRenderer, "AMD Radeon HD") != std::string::npos &&
        (mGlVersionString.find(
        "Compatibility Profile Context 14.") != std::string::npos ||
        mGlVersionString.find(
        "Compatibility Profile Context 15.") != std::string::npos)))
    {
        logger->log1("Not checked for DSA because on "
            "NVIDIA or AMD or in Mesa it broken");
        emulateFunction(glTextureSubImage2DEXT);
    }
    else
*/
    {   // not for NVIDIA. in NVIDIA atleast in windows drivers DSA is broken
        // Mesa 10.6.3 show support for DSA, but it broken. Works in 10.7 dev
        if (config.getBoolValue("enableDSA") == true)
        {
            if (is45)
            {
                logger->log1("found GL_EXT_direct_state_access");
                assignFunction(glTextureSubImage2D)
            }
            else if (supportExtension("GL_EXT_direct_state_access"))
            {
                logger->log1("found GL_EXT_direct_state_access");
                assignFunctionEmu2(glTextureSubImage2DEXT,
                    "glTextureSubImage2DEXT")
            }
            else if (supportExtension("GL_ARB_direct_state_access"))
            {
                logger->log1("found GL_ARB_direct_state_access");
                logger->log1("GL_EXT_direct_state_access not found");
                assignFunction(glTextureSubImage2D)
            }
            else
            {
                logger->log1("GL_EXT_direct_state_access not found");
                logger->log1("GL_ARB_direct_state_access not found");
                emulateFunction(glTextureSubImage2DEXT);
            }
        }
        else
        {
            logger->log1("Direct state access disabled in settings");
            emulateFunction(glTextureSubImage2DEXT);
        }
    }
 
    if (is12 && (is42 || supportExtension("GL_ARB_texture_storage")))
    {
        logger->log1("found GL_ARB_texture_storage");
        assignFunction(glTexStorage2D)
    }
    else
    {
        logger->log1("GL_ARB_texture_storage not found");
    }
 
    if (is13 || supportExtension("GL_ARB_multitexture"))
    {
        logger->log1("found GL_ARB_multitexture or OpenGL 1.3");
        assignFunction(glActiveTexture)
    }
    else
    {
        emulateFunction(glActiveTexture);
        logger->log1("GL_ARB_multitexture not found");
    }
 
    if (is20 || supportExtension("GL_ARB_explicit_attrib_location"))
    {
        logger->log1("found GL_ARB_explicit_attrib_location or OpenGL 2.0");
        assignFunction(glBindAttribLocation)
    }
    else
    {
        logger->log1("GL_ARB_explicit_attrib_location not found");
    }
 
    if (is30 || supportExtension("GL_ARB_framebuffer_object"))
    {   // frame buffer supported
        logger->log1("found GL_ARB_framebuffer_object");
        assignFunction(glGenRenderbuffers)
        assignFunction(glBindRenderbuffer)
        assignFunction(glRenderbufferStorage)
        assignFunction(glGenFramebuffers)
        assignFunction(glBindFramebuffer)
        assignFunction(glFramebufferTexture2D)
        assignFunction(glFramebufferRenderbuffer)
        assignFunction(glDeleteFramebuffers)
        assignFunction(glDeleteRenderbuffers)
        assignFunction(glCheckFramebufferStatus)
    }
    else if (supportExtension("GL_EXT_framebuffer_object"))
    {   // old frame buffer extension
        logger->log1("found GL_EXT_framebuffer_object");
        assignFunctionEXT(glGenRenderbuffers)
        assignFunctionEXT(glBindRenderbuffer)
        assignFunctionEXT(glRenderbufferStorage)
        assignFunctionEXT(glGenFramebuffers)
        assignFunctionEXT(glBindFramebuffer)
        assignFunctionEXT(glFramebufferTexture2D)
        assignFunctionEXT(glFramebufferRenderbuffer)
        assignFunctionEXT(glDeleteFramebuffers)
        assignFunctionEXT(glDeleteRenderbuffers)
    }
    else
    {   // no frame buffer support
        logger->log1("GL_ARB_framebuffer_object or "
            "GL_EXT_framebuffer_object not found");
        config.setValue("usefbo", false);
    }
 
    // debug extensions
    if (is43 || supportExtension("GL_KHR_debug"))
    {
        logger->log1("found GL_KHR_debug");
        assignFunction(glDebugMessageControl)
        assignFunction(glDebugMessageCallback)
        assignFunction(glPushDebugGroup)
        assignFunction(glPopDebugGroup)
        assignFunction(glObjectLabel)
        mSupportDebug = 2;
    }
    else if (supportExtension("GL_ARB_debug_output"))
    {
        logger->log1("found GL_ARB_debug_output");
        assignFunctionARB(glDebugMessageControl)
        assignFunctionARB(glDebugMessageCallback)
        mSupportDebug = 1;
    }
    else
    {
        logger->log1("debug extensions not found");
        mSupportDebug = 0;
    }
 
    if (supportExtension("GL_GREMEDY_frame_terminator"))
    {
        logger->log1("found GL_GREMEDY_frame_terminator");
        assignFunction2(glFrameTerminator, "glFrameTerminatorGREMEDY")
    }
    else
    {
        logger->log1("GL_GREMEDY_frame_terminator not found");
    }
    if (is44 || supportExtension("GL_EXT_debug_label"))
    {
        logger->log1("found GL_EXT_debug_label");
        assignFunction2(glLabelObject, "glObjectLabel")
        if (isGLNull(mglLabelObject))
            assignFunctionEXT(glLabelObject)
        assignFunctionEXT(glGetObjectLabel)
    }
    else
    {
        logger->log1("GL_EXT_debug_label not found");
    }
    if (supportExtension("GL_GREMEDY_string_marker"))
    {
        logger->log1("found GL_GREMEDY_string_marker");
        assignFunction2(glPushGroupMarker, "glStringMarkerGREMEDY")
    }
    else
    {
        logger->log1("GL_GREMEDY_string_marker not found");
    }
    if (supportExtension("GL_EXT_debug_marker"))
    {
        logger->log1("found GL_EXT_debug_marker");
        assignFunctionEXT(glInsertEventMarker)
        assignFunctionEXT(glPushGroupMarker)
        assignFunctionEXT(glPopGroupMarker)
    }
    else
    {
        logger->log1("GL_EXT_debug_marker not found");
    }
    if (is15 && (is30 || supportExtension("GL_EXT_timer_query")))
    {
        logger->log1("found GL_EXT_timer_query");
        assignFunction(glGenQueries)
        assignFunction(glBeginQuery)
        assignFunction(glEndQuery)
        assignFunction(glDeleteQueries)
        assignFunction(glGetQueryObjectiv)
        assignFunctionEXT(glGetQueryObjectui64v)
    }
    else
    {
        logger->log1("GL_EXT_timer_query not supported");
    }
    if (is20 && (is43 || supportExtension("GL_ARB_invalidate_subdata")))
    {
        logger->log1("found GL_ARB_invalidate_subdata");
        assignFunction(glInvalidateTexImage)
    }
    else
    {
        logger->log1("GL_ARB_invalidate_subdata not supported");
    }
    if (is21 && (is30 || supportExtension("GL_ARB_vertex_array_object")))
    {
        logger->log1("found GL_ARB_vertex_array_object");
        assignFunction(glGenVertexArrays)
        assignFunction(glBindVertexArray)
        assignFunction(glDeleteVertexArrays)
        assignFunction(glVertexAttribPointer)
        assignFunction(glEnableVertexAttribArray)
        assignFunction(glDisableVertexAttribArray)
        assignFunction(glVertexAttribIPointer)
    }
    else
    {
        mSupportModernOpengl = false;
        logger->log1("GL_ARB_vertex_array_object not found");
    }
    if (is20 || supportExtension("GL_ARB_vertex_buffer_object"))
    {
        assignFunction(glGenBuffers)
        assignFunction(glDeleteBuffers)
        assignFunction(glBindBuffer)
        assignFunction(glBufferData)
        assignFunction(glIsBuffer)
    }
    else
    {
        mSupportModernOpengl = false;
        logger->log1("buffers extension not found");
    }
    if (is43 || supportExtension("GL_ARB_copy_image"))
    {
        logger->log1("found GL_ARB_copy_image");
        assignFunction(glCopyImageSubData)
    }
    else
    {
        logger->log1("GL_ARB_copy_image not found");
    }
    if (is44 || supportExtension("GL_ARB_clear_texture"))
    {
        logger->log1("found GL_ARB_clear_texture");
        assignFunction(glClearTexImage)
        assignFunction(glClearTexSubImage)
    }
    else
    {
        logger->log1("GL_ARB_clear_texture not found");
    }
    if (is20 || supportExtension("GL_ARB_shader_objects"))
    {
        logger->log1("found GL_ARB_shader_objects");
        assignFunction(glCreateShader)
        assignFunction(glDeleteShader)
        assignFunction(glGetShaderiv)
        assignFunction(glGetShaderInfoLog)
        assignFunction(glGetShaderSource)
        assignFunction(glShaderSource)
        assignFunction(glCompileShader)
        assignFunction(glLinkProgram)
        assignFunction(glGetProgramInfoLog)
        assignFunction(glDeleteProgram)
        assignFunction(glCreateProgram)
        assignFunction(glAttachShader)
        assignFunction(glDetachShader)
        assignFunction(glGetAttachedShaders)
        assignFunction(glGetUniformLocation)
        assignFunction(glGetActiveUniform)
        assignFunction(glGetProgramiv)
        assignFunction(glUseProgram)
        assignFunction(glValidateProgram)
        assignFunction(glGetAttribLocation)
        assignFunction(glUniform1f)
        assignFunction(glUniform2f)
        assignFunction(glUniform3f)
        assignFunction(glUniform4f)
 
        if (is30 || supportExtension("GL_EXT_gpu_shader4"))
        {
            logger->log1("found GL_EXT_gpu_shader4");
            assignFunction(glBindFragDataLocation)
        }
        else
        {
            mSupportModernOpengl = false;
            logger->log1("GL_EXT_gpu_shader4 not supported");
        }
        if (is41 || supportExtension("GL_ARB_separate_shader_objects"))
        {
            logger->log1("found GL_ARB_separate_shader_objects");
            assignFunction(glProgramUniform1f)
            assignFunction(glProgramUniform2f)
            assignFunction(glProgramUniform3f)
            assignFunction(glProgramUniform4f)
        }
        else
        {
            logger->log1("GL_ARB_separate_shader_objects not supported");
        }
        if (is43 || supportExtension("GL_ARB_vertex_attrib_binding"))
        {
            logger->log1("found GL_ARB_vertex_attrib_binding");
            assignFunction(glBindVertexBuffer)
            assignFunction(glVertexAttribBinding)
            assignFunction(glVertexAttribFormat)
            assignFunction(glVertexAttribIFormat)
        }
        else
        {
            mSupportModernOpengl = false;
            logger->log1("GL_ARB_vertex_attrib_binding not supported");
        }
        if (is44 || supportExtension("GL_ARB_multi_bind"))
        {
            logger->log1("found GL_ARB_multi_bind");
            assignFunction(glBindVertexBuffers)
        }
        else
        {
            logger->log1("GL_ARB_multi_bind not supported");
        }
    }
    else
    {
        mSupportModernOpengl = false;
        logger->log1("shaders not supported");
    }
 
#ifdef WIN32
    assignFunctionARB(wglGetExtensionsString)
#endif  // WIN32
#endif  // __native_client__
}

References assignFunction, assignFunction2, assignFunctionARB, assignFunctionEmu2, assignFunctionEXT, checkGLVersion(), config, emulateFunction, Configuration::getBoolValue(), isGLNotNull, isGLNull, Logger::log1(), logger, mSupportDebug, mSupportModernOpengl, mUseTextureSampler, Configuration::setValue(), and supportExtension().

Referenced by initOpenGL().

isUseTextureSampler()

bool GraphicsManager::isUseTextureSampler ( ) const

inline

Definition at line 163 of file graphicsmanager.h.

        { return mUseTextureSampler; }

References mUseTextureSampler.

Referenced by Graphics::setOpenGLMode().

logError()

void GraphicsManager::logError ( )

static

Definition at line 1521 of file graphicsmanager.cpp.

{
    const GLenum error = GraphicsManager::getLastError();
    if (error != GL_NO_ERROR)
        logger->log(errorToString(error));
}

References Actions::error(), errorToString(), getLastError(), Logger::log(), and logger.

Referenced by OpenGLImageHelper::copySurfaceToImage(), NormalOpenGLGraphics::drawLineArrayf(), NormalOpenGLGraphics::drawLineArrayi(), MobileOpenGL2Graphics::drawLineArrays(), MobileOpenGLGraphics::drawLineArrays(), ModernOpenGLGraphics::drawLineArrays(), drawQuad(), MobileOpenGL2Graphics::drawQuad(), ModernOpenGLGraphics::drawQuad(), NormalOpenGLGraphics::drawQuadArrayfi(), NormalOpenGLGraphics::drawQuadArrayfiCached(), NormalOpenGLGraphics::drawQuadArrayii(), NormalOpenGLGraphics::drawQuadArrayiiCached(), drawRescaledQuad(), MobileOpenGL2Graphics::drawRescaledQuad(), ModernOpenGLGraphics::drawRescaledQuad(), MobileOpenGL2Graphics::drawTriangleArray(), ModernOpenGLGraphics::drawTriangleArray(), MobileOpenGLGraphics::drawTriangleArrayfs(), MobileOpenGLGraphics::drawTriangleArrayfsCached(), emuglTextureSubImage2DEXT(), OpenGLImageHelper::glLoad(), MobileOpenGL2Graphics::postInit(), ModernOpenGLGraphics::postInit(), MobileOpenGL2Graphics::testDraw(), ModernOpenGLGraphics::testDraw(), and NormalOpenGLGraphics::testDraw().

logString()

void GraphicsManager::logString ( const char *const  format, const int  num  )

static

Definition at line 869 of file graphicsmanager.cpp.

{
    const char *str = reinterpret_cast<const char*>(mglGetString(num));
    if (!str)
        logger->log(format, "?");
    else
        logger->log(format, str);
}

References Logger::log(), logger, and mglGetString.

logVersion()

void GraphicsManager::logVersion

(

)

const

Definition at line 912 of file graphicsmanager.cpp.

{
    logger->log("gl vendor: " + mGlVendor);
    logger->log("gl renderer: " + mGlRenderer);
    logger->log("gl version: " + mGlVersionString);
    logger->log("glsl version: " + mGlShaderVersionString);
}

References Logger::log(), logger, mGlRenderer, mGlShaderVersionString, mGlVendor, and mGlVersionString.

Referenced by detectGraphics(), and Graphics::setOpenGLMode().

resetCachedError()

static void GraphicsManager::resetCachedError ( )

inlinestatic

Definition at line 180 of file graphicsmanager.h.

        { mLastError = GL_NO_ERROR; }

References mLastError.

Referenced by TestLauncher::testTextures().

setGLVersion()

void GraphicsManager::setGLVersion

(

)

Definition at line 884 of file graphicsmanager.cpp.

{
    mGlVersionString = getGLString(GL_VERSION);
    std::string version = mGlVersionString;
    if (findCutFirst(version, "OpenGL ES "))
        mGles = true;
    sscanf(version.c_str(), "%5d.%5d", &mMajor, &mMinor);
    logger->log("Detected gl version: %d.%d", mMajor, mMinor);
    mGlVendor = getGLString(GL_VENDOR);
    mGlRenderer = getGLString(GL_RENDERER);
    mGlShaderVersionString = getGLString(GL_SHADING_LANGUAGE_VERSION);
    version = mGlShaderVersionString;
    cutFirst(version, "OpenGL ES GLSL ES ");
    cutFirst(version, "OpenGL ES GLSL ");
    cutFirst(version, "OpenGL ES ");
    sscanf(version.c_str(), "%5d.%5d", &mSLMajor, &mSLMinor);
    logger->log("Detected glsl version: %d.%d", mSLMajor, mSLMinor);
#ifdef ANDROID
    if (!mMajor && !mMinor)
    {
        logger->log("Overriding detected OpenGL version on Android to 1.0");
        mGles = true;
        mMajor = 1;
        mMinor = 0;
    }
#endif  // ANDROID
}

References cutFirst(), findCutFirst(), getGLString(), Logger::log(), logger, mGles, mGlRenderer, mGlShaderVersionString, mGlVendor, mGlVersionString, mMajor, mMinor, mSLMajor, and mSLMinor.

Referenced by initOpenGL(), and Graphics::setOpenGLMode().

setVideoMode()

void GraphicsManager::setVideoMode ( )

static

Definition at line 457 of file graphicsmanager.cpp.

{
    const int bpp = 0;
    const bool fullscreen = config.getBoolValue("screen");
    const bool hwaccel = config.getBoolValue("hwaccel");
    const bool enableResize = config.getBoolValue("enableresize");
    const bool noFrame = config.getBoolValue("noframe");
    const bool allowHighDPI = config.getBoolValue("allowHighDPI");
 
#ifdef ANDROID
//    int width = config.getValue("screenwidth", 0);
//    int height = config.getValue("screenheight", 0);
    StringVect videoModes;
    SDL::getAllVideoModes(videoModes);
    if (videoModes.empty())
        logger->error("no video modes detected");
    STD_VECTOR<int> res;
    splitToIntVector(res, videoModes[0], 'x');
    if (res.size() != 2)
        logger->error("no video modes detected");
 
    int width = res[0];
    int height = res[1];
#elif defined __native_client__
#ifdef USE_SDL2
    // not implemented
#else  // USE_SDL2
 
    const SDL_VideoInfo* info = SDL_GetVideoInfo();
    int width = info->current_w;
    int height = info->current_h;
#endif  // USE_SDL2
#elif defined __SWITCH__
    int width = 1280;
    int height = 720;
#else  // defined __native_client__
 
    int width = config.getIntValue("screenwidth");
    int height = config.getIntValue("screenheight");
#endif  // defined __native_client__
 
    const int scale = config.getIntValue("scale");
 
    // Try to set the desired video mode
    if (!mainGraphics->setVideoMode(width, height, scale, bpp,
        fullscreen, hwaccel, enableResize, noFrame, allowHighDPI))
    {
        logger->log(strprintf("Couldn't set %dx%dx%d video mode: %s",
            width, height, bpp, SDL_GetError()));
 
        const int oldWidth = config.getValueInt("oldscreenwidth", -1);
        const int oldHeight = config.getValueInt("oldscreenheight", -1);
        const int oldFullscreen = config.getValueInt("oldscreen", -1);
        if (oldWidth != -1 && oldHeight != -1 && oldFullscreen != -1)
        {
            config.deleteKey("oldscreenwidth");
            config.deleteKey("oldscreenheight");
            config.deleteKey("oldscreen");
 
            config.setValueInt("screenwidth", oldWidth);
            config.setValueInt("screenheight", oldHeight);
            config.setValue("screen", oldFullscreen == 1);
            if (!mainGraphics->setVideoMode(oldWidth, oldHeight,
                scale,
                bpp,
                oldFullscreen != 0,
                hwaccel,
                enableResize,
                noFrame,
                allowHighDPI))
            {
                logger->safeError(strprintf("Couldn't restore %dx%dx%d "
                    "video mode: %s", oldWidth, oldHeight, bpp,
                    SDL_GetError()));
            }
        }
    }
}

References config, ConfigurationObject::deleteKey(), Logger::error(), SDL::getAllVideoModes(), Configuration::getBoolValue(), Configuration::getIntValue(), ConfigurationObject::getValueInt(), Actions::info(), Logger::log(), logger, mainGraphics, Logger::safeError(), Configuration::setValue(), Configuration::setValueInt(), Graphics::setVideoMode(), splitToIntVector(), and strprintf().

Referenced by initGraphics().

startDetection()

TestMain * GraphicsManager::startDetection

(

)

Definition at line 177 of file graphicsmanager.cpp.

{
    TestMain *const test = new TestMain;
    test->exec(false);
    return test;
}

References TestMain::exec().

Referenced by Setup_Video::action(), and detectVideoSettings().

supportExtension()

bool GraphicsManager::supportExtension

(

const std::string &

ext

)

const

Definition at line 758 of file graphicsmanager.cpp.

{
    return mExtensions.find(ext) != mExtensions.end();
}

References mExtensions.

Referenced by Graphics::getMemoryUsage(), initOpenGLFunctions(), Graphics::setOpenGLMode(), Graphics::updateMemoryInfo(), and updateTextureCompressionFormat().

updateDebugLog()

void GraphicsManager::updateDebugLog

(

)

const

Definition at line 1648 of file graphicsmanager.cpp.

{
    if (mSupportDebug && config.getIntValue("debugOpenGL"))
    {
        logger->log1("Enable OpenGL debug log");
        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
 
        mglDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE,
            0, nullptr, GL_TRUE);
        mglDebugMessageCallback(&debugCallback, this);
    }
}

References config, debugCallback(), Configuration::getIntValue(), GL_DEBUG_OUTPUT, GL_DEBUG_OUTPUT_SYNCHRONOUS, Logger::log1(), logger, and mSupportDebug.

Referenced by initOpenGL().

updateExtensions()

void GraphicsManager::updateExtensions

(

)

Definition at line 648 of file graphicsmanager.cpp.

{
    mExtensions.clear();
    logger->log1("opengl extensions: ");
    if (checkGLVersion(3, 0))
    {   // get extensions in new way
        assignFunction2(glGetStringi, "glGetStringi")
        std::string extList;
        int num = 0;
        glGetIntegerv(GL_NUM_EXTENSIONS, &num);
        for (int f = 0; f < num; f ++)
        {
            std::string str = reinterpret_cast<const char*>(
                mglGetStringi(GL_EXTENSIONS, f));
            mExtensions.insert(str);
            extList.append(str).append(" ");
        }
        logger->log1(extList.c_str());
    }
    else
    {   // get extensions in old way
        char const *extensions = reinterpret_cast<char const *>(
            mglGetString(GL_EXTENSIONS));
        if (extensions)
        {
            logger->log1(extensions);
            splitToStringSet(mExtensions, extensions, ' ');
        }
    }
}

References assignFunction2, checkGLVersion(), GL_NUM_EXTENSIONS, Logger::log1(), logger, mExtensions, mglGetString, and splitToStringSet().

Referenced by initOpenGL().

updateLimits()

void GraphicsManager::updateLimits

(

)

Definition at line 1403 of file graphicsmanager.cpp.

{
    GLint value = 0;
#ifdef __native_client__
    mMaxVertices = 500;
#else  // __native_client__
 
    glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, &value);
    logger->log("GL_MAX_ELEMENTS_VERTICES: %d", value);
 
    mMaxVertices = value;
 
    value = 0;
    glGetIntegerv(GL_MAX_ELEMENTS_INDICES, &value);
    logger->log("GL_MAX_ELEMENTS_INDICES: %d", value);
    if (value < mMaxVertices)
        mMaxVertices = value;
    if (!mMaxVertices)
    {
        logger->log("Got 0 max amount of vertices or indicies. "
            "Overriding to 500");
        mMaxVertices = 500;
    }
#endif  // __native_client__
 
    value = 0;
    glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &value);
    logger->log("Max FBO size: %d", value);
    mMaxFboSize = value;
}

References GL_MAX_ELEMENTS_INDICES, GL_MAX_ELEMENTS_VERTICES, Logger::log(), logger, mMaxFboSize, and mMaxVertices.

Referenced by initOpenGL().

updatePlanformExtensions()

void GraphicsManager::updatePlanformExtensions

(

)

Definition at line 679 of file graphicsmanager.cpp.

{
    SDL_SysWMinfo info;
    SDL_VERSION(&info.version)
    if (SDL::getWindowWMInfo(mainGraphics->getWindow(), &info))
    {
#ifdef WIN32
        if (!mwglGetExtensionsString)
            return;
 
        HDC hdc = GetDC(info.window);
        if (hdc)
        {
            const char *const extensions = mwglGetExtensionsString(hdc);
            if (extensions)
            {
                logger->log1("wGL extensions:");
                logger->log1(extensions);
                splitToStringSet(mPlatformExtensions, extensions, ' ');
            }
        }
#elif defined USE_X11
        Display *const display = info.info.x11.display;
        if (display)
        {
            Screen *const screen = XDefaultScreenOfDisplay(display);
            if (!screen)
                return;
 
            const int screenNum = XScreenNumberOfScreen(screen);
            const char *const extensions = glXQueryExtensionsString(
                display, screenNum);
            if (extensions)
            {
                logger->log1("glx extensions:");
                logger->log1(extensions);
                splitToStringSet(mPlatformExtensions, extensions, ' ');
            }
            glXQueryVersion(display, &mPlatformMajor, &mPlatformMinor);
            if (checkPlatformVersion(1, 1))
            {
                const char *const vendor1 = glXQueryServerString(
                    display, screenNum, GLX_VENDOR);
                if (vendor1)
                    logger->log("glx server vendor: %s", vendor1);
                const char *const version1 = glXQueryServerString(
                    display, screenNum, GLX_VERSION);
                if (version1)
                    logger->log("glx server version: %s", version1);
                const char *const extensions1 = glXQueryServerString(
                    display, screenNum, GLX_EXTENSIONS);
                if (extensions1)
                {
                    logger->log1("glx server extensions:");
                    logger->log1(extensions1);
                }
 
                const char *const vendor2 = glXGetClientString(
                    display, GLX_VENDOR);
                if (vendor2)
                    logger->log("glx client vendor: %s", vendor2);
                const char *const version2 = glXGetClientString(
                    display, GLX_VERSION);
                if (version2)
                    logger->log("glx client version: %s", version2);
                const char *const extensions2 = glXGetClientString(
                    display, GLX_EXTENSIONS);
                if (extensions2)
                {
                    logger->log1("glx client extensions:");
                    logger->log1(extensions2);
                }
            }
            logger->log("width=%d", DisplayWidth(display, screenNum));
        }
#endif  // WIN32
    }
}

References checkPlatformVersion(), Graphics::getWindow(), SDL::getWindowWMInfo(), Actions::info(), Logger::log(), Logger::log1(), logger, mainGraphics, mPlatformExtensions, mPlatformMajor, mPlatformMinor, and splitToStringSet().

Referenced by initOpenGL().

updateTextureCompressionFormat()

void GraphicsManager::updateTextureCompressionFormat

(

)

const

Definition at line 763 of file graphicsmanager.cpp.

{
    const int compressionFormat = config.getIntValue("compresstextures");
    // using extensions if can
    if (checkGLVersion(3, 1) ||
        checkGLesVersion(2, 0) ||
        supportExtension("GL_ARB_texture_compression"))
    {
        GLint num = 0;
        mglGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &num);
        logger->log("support %d compressed formats", num);
        GLint *const formats = new GLint[num > 10
            ? CAST_SIZE(num) : 10];
        mglGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, formats);
        for (int f = 0; f < num; f ++)
            logger->log(" 0x%x", CAST_U32(formats[f]));
 
        if (compressionFormat)
        {
            for (int f = 0; f < num; f ++)
            {
                switch (formats[f])
                {
                    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
                        if (compressionFormat == 1)
                        {
                            delete []formats;
                            useCompression(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
                            return;
                        }
                        break;
                    case GL_COMPRESSED_RGBA_FXT1_3DFX:
                        if (compressionFormat == 2)
                        {
                            delete []formats;
                            useCompression(GL_COMPRESSED_RGBA_FXT1_3DFX)
                            return;
                        }
                        break;
                    case GL_COMPRESSED_RGBA_BPTC_UNORM_ARB:
                        if (compressionFormat == 4)
                        {
                            delete []formats;
                            useCompression(GL_COMPRESSED_RGBA_BPTC_UNORM_ARB)
                            return;
                        }
                        break;
                    default:
                        break;
                }
            }
            if (compressionFormat == 3)
            {
                delete []formats;
                useCompression(GL_COMPRESSED_RGBA_ARB)
                return;
            }
 
            // workaround for MESA bptc compression detection
            if (compressionFormat == 4
                && supportExtension("GL_ARB_texture_compression_bptc"))
            {
                delete []formats;
                useCompression(GL_COMPRESSED_RGBA_BPTC_UNORM_ARB)
                return;
            }
        }
        delete []formats;
        if (compressionFormat)
            logger->log1("no correct compression format found");
    }
    else
    {
        if (compressionFormat)
            logger->log1("no correct compression format found");
    }
}

References CAST_SIZE, CAST_U32, checkGLesVersion(), checkGLVersion(), config, Configuration::getIntValue(), GL_COMPRESSED_RGBA_ARB, GL_COMPRESSED_RGBA_BPTC_UNORM_ARB, GL_COMPRESSED_RGBA_FXT1_3DFX, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, Logger::log(), Logger::log1(), logger, mglGetIntegerv, supportExtension(), and useCompression.

Referenced by Graphics::setOpenGLMode().

updateTextureFormat()

void GraphicsManager::updateTextureFormat ( )

static

Definition at line 841 of file graphicsmanager.cpp.

{
    const int renderer = settings.options.renderer;
 
    // using default formats
    if (renderer == RENDER_MODERN_OPENGL ||
        renderer == RENDER_GLES_OPENGL ||
        renderer == RENDER_GLES2_OPENGL ||
        config.getBoolValue("newtextures"))
    {
        OpenGLImageHelper::setInternalTextureType(GL_RGBA);
#if !defined(ANDROID) && !defined(__SWITCH__)
        SafeOpenGLImageHelper::setInternalTextureType(GL_RGBA);
#endif  // ANDROID
 
        logger->log1("using RGBA texture format");
    }
    else
    {
        OpenGLImageHelper::setInternalTextureType(4);
#if !defined(ANDROID) && !defined(__SWITCH__)
        SafeOpenGLImageHelper::setInternalTextureType(4);
#endif  // ANDROID
 
        logger->log1("using 4 texture format");
    }
}

References config, Configuration::getBoolValue(), Logger::log1(), logger, Settings::options, RENDER_GLES2_OPENGL, RENDER_GLES_OPENGL, RENDER_MODERN_OPENGL, Options::renderer, OpenGLImageHelper::setInternalTextureType(), SafeOpenGLImageHelper::setInternalTextureType(), and settings.

Referenced by Graphics::setOpenGLMode().

Field Documentation

mDensity

int32_t GraphicsManager::mDensity

private

Definition at line 224 of file graphicsmanager.h.

Referenced by detectPixelSize(), getDensity(), and getDensityString().

mExtensions

std::set<std::string> GraphicsManager::mExtensions

private

Definition at line 185 of file graphicsmanager.h.

Referenced by supportExtension(), and updateExtensions().

mGles

bool GraphicsManager::mGles

private

Definition at line 235 of file graphicsmanager.h.

Referenced by checkGLesVersion(), and setGLVersion().

mGlRenderer

std::string GraphicsManager::mGlRenderer

private

Definition at line 193 of file graphicsmanager.h.

Referenced by detectGraphics(), logVersion(), and setGLVersion().

mGlShaderVersionString

std::string GraphicsManager::mGlShaderVersionString

private

Definition at line 195 of file graphicsmanager.h.

Referenced by logVersion(), and setGLVersion().

mGlVendor

std::string GraphicsManager::mGlVendor

private

Definition at line 191 of file graphicsmanager.h.

Referenced by detectGraphics(), logVersion(), and setGLVersion().

mGlVersionString

std::string GraphicsManager::mGlVersionString

private

Definition at line 189 of file graphicsmanager.h.

Referenced by detectGraphics(), getGLVersion(), logVersion(), and setGLVersion().

mHeightMM

uint32_t GraphicsManager::mHeightMM

private

Definition at line 222 of file graphicsmanager.h.

Referenced by detectPixelSize().

mLastError

GLenum GraphicsManager::mLastError

staticprivate

Definition at line 197 of file graphicsmanager.h.

Referenced by getLastError(), getLastErrorCached(), and resetCachedError().

mMajor

int GraphicsManager::mMajor

private

Definition at line 202 of file graphicsmanager.h.

Referenced by checkGLesVersion(), checkGLVersion(), and setGLVersion().

mMaxFboSize

int GraphicsManager::mMaxFboSize

private

Definition at line 214 of file graphicsmanager.h.

Referenced by updateLimits().

mMaxHeight

uint32_t GraphicsManager::mMaxHeight

private

Definition at line 218 of file graphicsmanager.h.

Referenced by detectPixelSize().

mMaxVertices

int GraphicsManager::mMaxVertices

private

Definition at line 212 of file graphicsmanager.h.

Referenced by getMaxVertices(), and updateLimits().

mMaxWidth

uint32_t GraphicsManager::mMaxWidth

private

Definition at line 216 of file graphicsmanager.h.

Referenced by detectPixelSize().

mMinor

int GraphicsManager::mMinor

private

Definition at line 200 of file graphicsmanager.h.

Referenced by checkGLesVersion(), checkGLVersion(), and setGLVersion().

mPlatformExtensions

std::set<std::string> GraphicsManager::mPlatformExtensions

private

Definition at line 187 of file graphicsmanager.h.

Referenced by updatePlanformExtensions().

mPlatformMajor

int GraphicsManager::mPlatformMajor

private

Definition at line 210 of file graphicsmanager.h.

Referenced by checkPlatformVersion(), and updatePlanformExtensions().

mPlatformMinor

int GraphicsManager::mPlatformMinor

private

Definition at line 208 of file graphicsmanager.h.

Referenced by checkPlatformVersion(), and updatePlanformExtensions().

mSLMajor

int GraphicsManager::mSLMajor

private

Definition at line 206 of file graphicsmanager.h.

Referenced by checkSLVersion(), and setGLVersion().

mSLMinor

int GraphicsManager::mSLMinor

private

Definition at line 204 of file graphicsmanager.h.

Referenced by checkSLVersion(), and setGLVersion().

mSupportDebug

int GraphicsManager::mSupportDebug

private

Definition at line 231 of file graphicsmanager.h.

Referenced by initOpenGLFunctions(), and updateDebugLog().

mSupportModernOpengl

bool GraphicsManager::mSupportModernOpengl

private

Definition at line 233 of file graphicsmanager.h.

Referenced by initGraphics(), and initOpenGLFunctions().

mTextureSampler

GLuint GraphicsManager::mTextureSampler

private

Definition at line 229 of file graphicsmanager.h.

Referenced by createTextureSampler(), and ~GraphicsManager().

mUseAtlases

bool GraphicsManager::mUseAtlases

private

Definition at line 238 of file graphicsmanager.h.

Referenced by createRenderers(), and getUseAtlases().

mUseTextureSampler

bool GraphicsManager::mUseTextureSampler

private

Definition at line 227 of file graphicsmanager.h.

Referenced by createRenderers(), createTextureSampler(), initOpenGLFunctions(), and isUseTextureSampler().

mWidthMM

uint32_t GraphicsManager::mWidthMM

private

Definition at line 220 of file graphicsmanager.h.

Referenced by detectPixelSize().

---

The documentation for this class was generated from the following files:

• src/graphicsmanager.h (986a3bf)
• src/graphicsmanager.cpp (986a3bf)