video.cpp

Go to the documentation of this file.

#include "video.h"
#include "Logger.h"
 
#define WIP_DH_SUPPORT 1
 
#ifdef _LINUX // Linux
  void (*wglGetProcAddress(const char *function_name))(void)
  {
    return glXGetProcAddress((GLubyte*)function_name);
  }
#endif
 
#ifdef _WINDOWS
// Create an OpenGL pixel format descriptor
PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be
{
    sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
    1, // Version Number
    PFD_DRAW_TO_WINDOW | // Format Must Support Window
    PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
    PFD_DOUBLEBUFFER, // Must Support Double Buffering
    PFD_TYPE_RGBA, // Request An RGBA Format
    16, // Select Our Color Depth (same as desktop)
    0, 0, 0, 0, 0, 0, // Color Bits Ignored
    1, // Alpha Buffer
    0, // Shift Bit Ignored
    0, // No Accumulation Buffer
    0, 0, 0, 0, // Accumulation Bits Ignored
    16, // 16Bit Z-Buffer (Depth Buffer)  
    0, // No Stencil Buffer
    0, // No Auxiliary Buffer
    PFD_MAIN_PLANE, // Main Drawing Layer
    0, // Reserved
    0, 0, 0 // Layer Masks Ignored
};
#endif
 
VideoSettings video;
 
VideoSettings::VideoSettings() = default;
 
VideoSettings::~VideoSettings()
{
#ifdef _WINDOWS
    // Clear the rendering context
    wglMakeCurrent(nullptr, nullptr);
 
    if (hRC)
    {
        wglDeleteContext(hRC);
        hRC = nullptr;
    }
 
    if (hDC)
    {
        ReleaseDC(hWnd, hDC);
        hDC = nullptr;
    }
#endif
}
 
bool VideoSettings::Init()
{
    if (init)
        return true;
 
    int gladVersion = gladLoaderLoadGL();
 
    if (!gladVersion)
    {
        LOG_ERROR << "glad failed to initialize OpenGL loader.";
        return false;
    }
    else
    {
        LOG_INFO << "glad successfully initiated (OpenGL " << GLAD_VERSION_MAJOR(gladVersion) << "." << GLAD_VERSION_MINOR(gladVersion) << ").";
    }
 
#ifdef _WINDOWS
    if (hDC)
        gladLoaderLoadWGL(hDC);
#endif
 
    // Now get some specifics on the card
    // First up, the details
    if (GLAD_GL_EXT_texture_filter_anisotropic)
        glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint*)&AnisofilterLevel);
    else
        AnisofilterLevel = 0;
 
    glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&numTextureUnits);
    vendor = ((char*)glGetString(GL_VENDOR));
    version = ((char*)glGetString(GL_VERSION));
    renderer = ((char*)glGetString(GL_RENDERER));
 
    const double num = atof((char*)glGetString(GL_VERSION));
    supportOGL20 = (num >= 2.0);
    if (supportOGL20)
        supportNPOT = true;
    else
        supportNPOT = GLAD_GL_ARB_texture_non_power_of_two;
 
    supportFragProg = GLAD_GL_ARB_fragment_program;
    supportVertexProg = GLAD_GL_ARB_vertex_program;
    supportGLSL = GLAD_GL_ARB_shading_language_100;
    supportShaders = (supportFragProg && supportVertexProg);
    supportMultiTex = GLAD_GL_ARB_multitexture;
    supportDrawRangeElements = GLAD_GL_EXT_draw_range_elements;
#if WIP_DH_SUPPORT > 0
    supportVBO = false;
#else
  supportVBO = GLAD_GL_ARB_vertex_buffer_object;
#endif
    supportCompression = GLAD_GL_ARB_texture_compression && GLAD_GL_ARB_texture_cube_map && GLAD_GL_EXT_texture_compression_s3tc;
    supportPointSprites = GLAD_GL_ARB_point_sprite && GLAD_GL_ARB_point_parameters;
#ifdef _WINDOWS
    supportPBO = GLAD_WGL_ARB_pbuffer && GLAD_WGL_ARB_render_texture;
    supportAntiAlias = GLAD_WGL_ARB_multisample;
    supportWGLPixelFormat = GLAD_WGL_ARB_pixel_format;
#endif
    supportFBO = GLAD_GL_EXT_framebuffer_object;
 
    // deactivate FBO for Intel cards, glReadPixels is known to be buggy for those cards...
    if (strcmp(vendor, "Intel") == 0)
        supportFBO = false;
 
    supportTexRects = GLAD_GL_ARB_texture_rectangle;
 
    // Now output and log the info
    LOG_INFO << "Video Renderer:" << renderer;
    LOG_INFO << "Video Vendor:" << vendor;
    LOG_INFO << "Driver Version:" << version;
 
 
    if (std::string(renderer) == std::string("GDI Generic"))
    {
        LOG_INFO << "Warning: Running in software mode, this is not enough. Please try updating your video drivers.";
        // bloody oath - wtb a graphics card
        hasHardware = false;
    }
    else
    {
        hasHardware = true;
    }
 
    LOG_INFO << "Support wglPixelFormat:" << (supportWGLPixelFormat ? "true" : "false");
    LOG_INFO << "Support Texture Compression:" << (supportCompression ? "true" : "false");
    LOG_INFO << "Support Draw Range Elements:" << (supportDrawRangeElements ? "true" : "false");
    LOG_INFO << "Support Vertex Buffer Objects:" << (supportVBO ? "true" : "false");
    LOG_INFO << "Support Point Sprites:" << (supportPointSprites ? "true" : "false");
    LOG_INFO << "Support Pixel Shaders:" << (supportFragProg ? "true" : "false");
    LOG_INFO << "Support Vertex Shaders:" << (supportVertexProg ? "true" : "false");
    LOG_INFO << "Support GLSL:" << (supportGLSL ? "true" : "false");
    LOG_INFO << "Support Anti-Aliasing:" << (supportAntiAlias ? "true" : "false");
    LOG_INFO << "Support Pixel Buffer Objects:" << (supportPBO ? "true" : "false");
    LOG_INFO << "Support Frame Buffer Objects:" << (supportFBO ? "true" : "false");
    LOG_INFO << "Support Non-Power-of-Two:" << (supportNPOT ? "true" : "false");
    LOG_INFO << "Support Rectangle Textures:" << (supportTexRects ? "true" : "false");
    LOG_INFO << "Support OpenGL 2.0:" << (supportOGL20 ? "true" : "false");
 
    // Max texture sizes
    GLint texSize;
    // Rectangle
    if (GLAD_GL_ARB_texture_rectangle)
    {
        glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB, &texSize);
        LOG_INFO << "Max Rectangle Texture Size Supported:" << texSize;
    }
    // Square
    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &texSize);
    LOG_INFO << "Max Texture Size Supported:" << texSize;
 
    // Debug:
    //supportPointSprites = false; // Always set to false,  for now.
    //supportVBO = false;
    //supportFBO = false;
    //supportNPOT = false;
    //supportPBO = false;
    //supportCompression = false;
    //supportTexRects = false;
 
    init = true;
 
    return true;
}
 
void VideoSettings::InitGL()
{
    if (!Init())
        return;
 
    GLenum err = glGetError();
    if (err)
        LOG_ERROR << __FUNCTION__ << __FILE__ << err << "An error occured on line" << __LINE__;
 
    if (supportDrawRangeElements && supportVBO)
    {
        glEnableClientState(GL_VERTEX_ARRAY);
        glEnableClientState(GL_NORMAL_ARRAY);
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    }
    else
    {
        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    }
 
    if (supportAntiAlias && curCap.aaSamples > 0)
        glEnable(GL_MULTISAMPLE_ARB);
 
    // Colour and materials
    glEnable(GL_COLOR_MATERIAL);
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT);
    glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
    glColorMaterial(GL_FRONT_AND_BACK, GL_EMISSION);
    glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
 
    // For environmental mapped meshes
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 18.0f);
 
 
    // TODO: Implement a scene graph, or scene manager to optimise OpenGL?
    // Default texture settings.
    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
    /*
    glTexEnvf(GL_TEXTURE_ENV,GL_RGB_SCALE, 1.000000);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_RGB, GL_CONSTANT);
    glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB, GL_MODULATE);
    glTexEnvf(GL_TEXTURE_ENV,GL_ALPHA_SCALE, 1.000000);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_ALPHA, GL_CONSTANT);
    glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA, GL_REPLACE);
    */
 
    /*
    // Alpha blending texture settings.
    glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
    glTexEnvf(GL_TEXTURE_ENV,GL_RGB_SCALE, 1.000000);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_RGB, GL_CONSTANT);
    glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB, GL_MODULATE);
    glTexEnvf(GL_TEXTURE_ENV,GL_ALPHA_SCALE, 1.000000);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA, GL_PREVIOUS);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA, GL_TEXTURE);
    glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE2_ALPHA, GL_CONSTANT);
    glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA, GL_MODULATE);
    */
 
    glAlphaFunc(GL_GEQUAL, 0.9f);
    glDepthFunc(GL_LEQUAL);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glPixelStorei(GL_PACK_SWAP_BYTES, GL_FALSE);
    glPixelStorei(GL_PACK_LSB_FIRST, GL_FALSE);
 
    glShadeModel(GL_SMOOTH);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
    err = glGetError();
    if (err)
        LOG_ERROR << __FUNCTION__ << __FILE__ << err << "An error occured on line" << __LINE__;
}
 
void VideoSettings::EnumDisplayModes()
{
#ifdef _WINDOWS
    if (!hasHardware)
        return;
 
    // Error check
    if (!hDC)
    {
        LOG_ERROR << "Unable to enumerate display modes.  Invalid HDC.";
        return;
    }
 
    // This is where we do the grunt work of checking the caps
    // find out how many pixel formats we have
    std::vector<int> iAttributes;
    iAttributes.reserve(12);
    std::vector<int> results;
 
    iAttributes.push_back(WGL_NUMBER_PIXEL_FORMATS_ARB);
    results.resize(2); // 2 elements
    wglGetPixelFormatAttribivARB(hDC, 0, 0, 1, &iAttributes[0], &results[0]);
    // get the number of contexts we can create
    const size_t num_pfd = results[0];
    iAttributes.clear();
    results.clear();
 
    // error check
    if (num_pfd == 0)
    {
        LOG_ERROR << "Could not find any display modes.  Video Card might not support the function.";
        hasHardware = false;
        return;
    }
 
    iAttributes.push_back(WGL_DRAW_TO_WINDOW_ARB);
    iAttributes.push_back(WGL_STENCIL_BITS_ARB);
    iAttributes.push_back(WGL_ACCELERATION_ARB);
    iAttributes.push_back(WGL_DEPTH_BITS_ARB);
    iAttributes.push_back(WGL_SUPPORT_OPENGL_ARB);
    iAttributes.push_back(WGL_DOUBLE_BUFFER_ARB);
    iAttributes.push_back(WGL_PIXEL_TYPE_ARB);
    iAttributes.push_back(WGL_COLOR_BITS_ARB);
    iAttributes.push_back(WGL_ALPHA_BITS_ARB);
    iAttributes.push_back(WGL_ACCUM_BITS_ARB);
 
    if (GLAD_GL_ARB_multisample)
    {
        iAttributes.push_back(WGL_SAMPLE_BUFFERS_ARB);
        iAttributes.push_back(WGL_SAMPLES_ARB);
    }
 
    results.resize(iAttributes.size());
 
    // Reset our list of card capabilities.
    capsList.clear();
 
    for (size_t i = 0; i < num_pfd; i++)
    {
        if (!wglGetPixelFormatAttribivARB(hDC, static_cast<int>(i) + 1, 0, (UINT)iAttributes.size(), &iAttributes[0], &results[0]))
            return;
 
        // once we make it here we can look at the pixel data to make sure this is a context we want to use
        // results[0] is WGL_DRAW_TO_WINDOW,  since we only work in windowed mode,  no need to return results for fullscreen mode
        // results[4] is WGL_SUPPORT_OPENGL,  obvious if the mode doesn't support opengl then its useless to us.
        // results[3] is bitdepth,  if it has a 0 bitdepth then its useless to us
        if (results[0] == GL_TRUE && results[4] == GL_TRUE && results[3] > 0)
        {
            // what we have here is a contect which is drawable to a window, is in rgba format and is accelerated in some way
            // so now we pull the infomation, fill a structure and shove it into our map
            VideoCaps caps{};
 
            if (GLAD_GL_ARB_multisample)
            {
                caps.sampleBuffer = results[10];
                caps.aaSamples = results[11];
            }
            else
            {
                caps.sampleBuffer = false;
                caps.aaSamples = 0;
            }
 
            caps.accum = results[9];
            caps.alpha = results[8];
            caps.colour = results[7];
            //caps.pixelType = results[6]; /* WGL_TYPE_RGBA_ARB*/
            caps.doubleBuffer = results[5];
            caps.zBuffer = results[3];
            caps.hwAcc = results[2];
            /*WGL_FULL_ACCELERATION_ARB / WGL_GENERIC_ACCELERATION_ARB / WGL_NO_ACCELERATION_ARB;*/
            caps.stencil = results[1];
            capsList.push_back(caps); // insert into the map
        }
    }
#endif
}
 
// This function basically just uses any available display mode
bool VideoSettings::GetAvailableMode()
{
#ifdef _WINDOWS
    render = false;
 
    if (!hWnd)
        return false;
 
    // Clear the rendering context
    wglMakeCurrent(nullptr, nullptr);
 
    if (hRC)
    {
        wglDeleteContext(hRC);
        hRC = nullptr;
    }
 
    if (hDC)
    {
        ReleaseDC(hWnd, hDC);
        hDC = nullptr;
    }
 
    hDC = GetDC(hWnd); // Grab A Device Context For This Window
    if (hDC == nullptr)
    {
        // Did We Get A Device Context?
        // Failed
        //throw std::runtime_error("Failed To Get Device Context");
        LOG_ERROR << "Failed To Get Device Context.";
        return false;
    }
 
    pixelFormat = ChoosePixelFormat(hDC, &pfd); // Find A Compatible Pixel Format
    if (pixelFormat == 0)
    {
        // Did We Find A Compatible Format?
        // Failed
        //throw std::runtime_error("Failed To Acuire PixelFormat");
        LOG_ERROR << "Failed To Accquire PixelFormat.";
        return false;
    }
 
    if (SetPixelFormat(hDC, pixelFormat, &pfd) == false)
    {
        // Try To Set The Pixel Format
        // Failed
        //throw std::runtime_error("Failed To SetPixelFormat");
        LOG_ERROR << "Failed To SetPixelFormat.";
        return false;
    }
 
    hRC = wglCreateContext(hDC); // Try To Get A Rendering Context
    if (hRC == nullptr)
    {
        // Did We Get A Rendering Context?
        // Failed
        //throw std::runtime_error("Failed To Get OpenGL Context");
        LOG_ERROR << "Failed To Get OpenGL Context.";
        return false;
    }
 
    SetCurrent();
    render = true;
#endif
    return true;
}
 
bool VideoSettings::GetCompatibleWinMode(VideoCaps caps)
{
#ifdef _WINDOWS
    if (!hasHardware)
        return false;
 
    // Ask the WGL for the clostest match to this pixel format
    if (!hDC)
    {
        LOG_ERROR << "Attempted to Get a Compatible Window Mode Without a Valid Window";
        //throw std::runtime_error("VideoSettings::GetCompatibleWinMode() : Attempted to Get a Compatible Window Mode Without a Valid Window");
        return false;
    }
 
    std::vector<int> iAttributes;
    iAttributes.reserve(22);
    std::vector<int> results;
    unsigned int numformats;
    const float fAtrributes[] = {0, 0};
 
    iAttributes.push_back(WGL_DRAW_TO_WINDOW_ARB);
    iAttributes.push_back(GL_TRUE);
    iAttributes.push_back(WGL_ACCELERATION_ARB);
    iAttributes.push_back(caps.hwAcc);
    iAttributes.push_back(WGL_COLOR_BITS_ARB);
    iAttributes.push_back(caps.colour); // min color required
    iAttributes.push_back(WGL_ALPHA_BITS_ARB);
    iAttributes.push_back(caps.alpha); // min alpha bits
    iAttributes.push_back(WGL_DEPTH_BITS_ARB);
    iAttributes.push_back(caps.zBuffer);
    iAttributes.push_back(WGL_STENCIL_BITS_ARB);
    iAttributes.push_back(caps.stencil);
    if (caps.aaSamples != 0)
    {
        iAttributes.push_back(WGL_SAMPLE_BUFFERS_ARB);
        iAttributes.push_back(caps.sampleBuffer);
        iAttributes.push_back(WGL_SAMPLES_ARB);
        iAttributes.push_back(caps.aaSamples);
    }
    iAttributes.push_back(WGL_DOUBLE_BUFFER_ARB);
    iAttributes.push_back(caps.doubleBuffer);
    if (caps.accum != 0)
    {
        iAttributes.push_back(WGL_ACCUM_BITS_ARB);
        iAttributes.push_back(caps.accum);
    }
    iAttributes.push_back(0);
    iAttributes.push_back(0);
 
    const int status = wglChoosePixelFormatARB(hDC, &iAttributes[0], fAtrributes, 1, &pixelFormat, &numformats);
    // find a matching format
    if (status == GL_TRUE && numformats)
    {
        // we have a matching format, extract the details
        iAttributes.clear();
        iAttributes.push_back(WGL_COLOR_BITS_ARB);
        iAttributes.push_back(WGL_ALPHA_BITS_ARB);
        iAttributes.push_back(WGL_DEPTH_BITS_ARB);
        iAttributes.push_back(WGL_STENCIL_BITS_ARB);
        iAttributes.push_back(WGL_SAMPLE_BUFFERS_ARB);
        iAttributes.push_back(WGL_SAMPLES_ARB);
        iAttributes.push_back(WGL_DOUBLE_BUFFER_ARB);
        iAttributes.push_back(WGL_ACCUM_BITS_ARB);
        iAttributes.push_back(WGL_ACCELERATION_ARB);
        results.resize(iAttributes.size());
 
        if (!wglGetPixelFormatAttribivARB(hDC, pixelFormat, PFD_MAIN_PLANE, (UINT)iAttributes.size(), &iAttributes[0],
                                          &results[0]))
        {
            //int i = GetLastError();
            return false;
        }
 
        curCap.aaSamples = results[5];
        curCap.accum = results[7];
        curCap.alpha = results[1];
        curCap.colour = results[0];
        curCap.doubleBuffer = results[6];
        curCap.sampleBuffer = results[4];
        curCap.stencil = results[3];
        curCap.zBuffer = results[2];
        curCap.hwAcc = results[8];
 
        for (size_t i = 0; i < capsList.size(); i++)
        {
            if (capsList[i].colour == curCap.colour &&
                capsList[i].zBuffer == curCap.zBuffer &&
                capsList[i].alpha == curCap.alpha &&
                capsList[i].hwAcc == curCap.hwAcc &&
                capsList[i].doubleBuffer == curCap.doubleBuffer &&
                capsList[i].sampleBuffer == curCap.sampleBuffer &&
                capsList[i].aaSamples == curCap.aaSamples)
            {
                capIndex = static_cast<int>(i);
                break;
            }
        }
 
        return true;
    }
#endif
    return false;
}
 
#ifdef _WINDOWS
void VideoSettings::SetHandle(HWND hwnd, int bpp = 16)
{
    hWnd = hwnd;
    desktopBPP = bpp;
 
    //pfd.cColorBits = desktopBPP;
 
    if (!secondPass)
        GetAvailableMode();
 
    if (!init && !secondPass)
    {
        Init();
        if (supportWGLPixelFormat)
        {
            EnumDisplayModes();
            GetCompatibleWinMode(curCap);
        }
    }
 
    if (hasHardware && supportWGLPixelFormat)
        SetMode();
}
#endif
 
void VideoSettings::Release()
{
#ifdef _WINDOWS
    // Clear the rendering context
    wglMakeCurrent(nullptr, nullptr);
 
    if (hRC)
    {
        wglDeleteContext(hRC);
        hRC = nullptr;
    }
 
    if (hDC)
    {
        ReleaseDC(hWnd, hDC);
        hDC = nullptr;
    }
#endif
}
 
void VideoSettings::SetMode()
{
#ifdef _WINDOWS
    if (!hWnd)
        return;
 
    // Clear the rendering context
    wglMakeCurrent(nullptr, nullptr);
 
    if (hRC)
    {
        wglDeleteContext(hRC);
        hRC = nullptr;
    }
 
    if (hDC)
    {
        ReleaseDC(hWnd, hDC);
        hDC = nullptr;
    }
 
    hDC = GetDC(hWnd);
    if (!hDC)
    {
        // Did We Get A Device Context?
        LOG_ERROR << "Can't Create A GL Device Context.";
        return;
    }
 
    unsigned int numFormats;
    const float fAttributes[] = {0, 0};
    std::vector<int> AttributeList;
    AttributeList.reserve(22);
 
    AttributeList.push_back(WGL_DRAW_TO_WINDOW_ARB);
    AttributeList.push_back(GL_TRUE);
    AttributeList.push_back(WGL_SUPPORT_OPENGL_ARB);
    AttributeList.push_back(GL_TRUE);
    AttributeList.push_back(WGL_ACCELERATION_ARB);
    AttributeList.push_back(curCap.hwAcc);
    AttributeList.push_back(WGL_COLOR_BITS_ARB);
    AttributeList.push_back(curCap.colour);
    AttributeList.push_back(WGL_ALPHA_BITS_ARB);
    AttributeList.push_back(curCap.alpha);
    AttributeList.push_back(WGL_DEPTH_BITS_ARB);
    AttributeList.push_back(curCap.zBuffer);
    //AttributeList.push_back(WGL_STENCIL_BITS_ARB);
    //AttributeList.push_back(curCap.stencil);
    AttributeList.push_back(WGL_DOUBLE_BUFFER_ARB);
    AttributeList.push_back(curCap.doubleBuffer);
 
    // 8229 being software mode
    if (curCap.hwAcc != 8229 && curCap.accum != 0)
    {
        AttributeList.push_back(WGL_ACCUM_BITS_ARB);
        AttributeList.push_back(curCap.accum);
    }
 
    if (curCap.aaSamples != 0 && supportAntiAlias)
    {
        AttributeList.push_back(WGL_SAMPLE_BUFFERS_ARB);
        AttributeList.push_back(GL_TRUE);
        AttributeList.push_back(WGL_SAMPLES_ARB);
        AttributeList.push_back(curCap.aaSamples);
    }
    AttributeList.push_back(0);
    AttributeList.push_back(0);
 
 
    const GLboolean status = wglChoosePixelFormatARB(hDC, &AttributeList[0], fAttributes, 1, &pixelFormat, &numFormats);
    if (status == GL_TRUE && numFormats)
    {
        if (SetPixelFormat(hDC, pixelFormat, &pfd) == FALSE)
        {
            //LOG_ERROR << "Failed To Set Requested Pixel Format.";
            secondPass = true;
            return;
        }
 
        hRC = wglCreateContext(hDC);
        if (!hRC)
        {
            LOG_ERROR << "Error: Failed To Create OpenGL Context.";
            secondPass = true;
            render = false;
            return;
        }
 
        render = true;
        SetCurrent();
    }
    else
    {
        // Error
        // Something went wrong,  fall back to the basic opengl setup
        GetAvailableMode();
    }
#endif
}
 
void VideoSettings::ResizeGLScene(int width, int height) // Resize And Initialize The GL Window
{
    if (height == 0) // Prevent A Divide By Zero By
        height = 1; // Making Height Equal One
 
    glViewport(0, 0, width, height); // Reset The Current Viewport
    //glDepthRange(0.0f,1.0f);
 
    glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
    glLoadIdentity(); // Reset The Projection Matrix
 
    // Calculate The Aspect Ratio Of The Window
    gluPerspective(fov, static_cast<float>(width) / static_cast<float>(height), 0.1f, 1280 * 5);
 
    glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
    glLoadIdentity(); // Reset The Modelview Matrix
}
 
void VideoSettings::SwapBuffers()
{
#ifdef _WINDOWS
    if (hDC)
        ::SwapBuffers(hDC);
#endif
}
 
void VideoSettings::SetCurrent()
{
#ifdef _WINDOWS
    if (!hDC || !hRC || !wglMakeCurrent(hDC, hRC))
    {
        // Try To Activate The Rendering Context
        render = false;
    }
    else
    {
        render = true;
    }
#endif
}