ARB_Multisample.cpp

Go to the documentation of this file.

/*========================================================================================

  Name:   ARB_multisample.cpp
        Author: Colt "MainRoach" McAnlis
        Date:   4/29/04
        Desc:   This file contains the context to load a WGL extension from a string
                    As well as collect the sample format available based upon the graphics card.

========================================================================================*/

#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>

#include "arb_multisample.h"

// Declairations We'll Use
#define WGL_SAMPLE_BUFFERS_ARB           0x2041
#define WGL_SAMPLES_ARB                      0x2042

bool    arbMultisampleSupported = false;
int             arbMultisampleFormat    = 0;

// WGLisExtensionSupported: This Is A Form Of The Extension For WGL
bool WGLisExtensionSupported(const char *extension)
{
        const size_t extlen = strlen(extension);
        const char *supported = NULL;

        // Try To Use wglGetExtensionStringARB On Current DC, If Possible
        PROC wglGetExtString = wglGetProcAddress("wglGetExtensionsStringARB");

        if (wglGetExtString)
                supported = ((char*(__stdcall*)(HDC))wglGetExtString)(wglGetCurrentDC());

        // If That Failed, Try Standard Opengl Extensions String
        if (supported == NULL)
                supported = (char*)glGetString(GL_EXTENSIONS);

        // If That Failed Too, Must Be No Extensions Supported
        if (supported == NULL)
                return false;

        // Begin Examination At Start Of String, Increment By 1 On False Match
        for (const char* p = supported; ; p++)
        {
                // Advance p Up To The Next Possible Match
                p = strstr(p, extension);

                if (p == NULL)
                        return false;                                                                                                                   // No Match

                // Make Sure That Match Is At The Start Of The String Or That
                // The Previous Char Is A Space, Or Else We Could Accidentally
                // Match "wglFunkywglExtension" With "wglExtension"

                // Also, Make Sure That The Following Character Is Space Or NULL
                // Or Else "wglExtensionTwo" Might Match "wglExtension"
                if ((p==supported || p[-1]==' ') && (p[extlen]=='\0' || p[extlen]==' '))
                        return true;                                                                                                                    // Match
        }
}

// InitMultisample: Used To Query The Multisample Frequencies
bool InitMultisample(HINSTANCE hInstance,HWND hWnd,PIXELFORMATDESCRIPTOR pfd)
{  
         // See If The String Exists In WGL!
        if (!WGLisExtensionSupported("WGL_ARB_multisample"))
        {
                arbMultisampleSupported=false;
                return false;
        }

        // Get Our Pixel Format
        PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");  
        if (!wglChoosePixelFormatARB) 
        {
                arbMultisampleSupported=false;
                return false;
        }

        // Get Our Current Device Context
        HDC hDC = GetDC(hWnd);

        int             pixelFormat;
        int             valid;
        UINT    numFormats;
        float   fAttributes[] = {0,0};

        // These Attributes Are The Bits We Want To Test For In Our Sample
        // Everything Is Pretty Standard, The Only One We Want To 
        // Really Focus On Is The SAMPLE BUFFERS ARB And WGL SAMPLES
        // These Two Are Going To Do The Main Testing For Whether Or Not
        // We Support Multisampling On This Hardware.
        int iAttributes[] =
        {
                WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
                WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
                WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
                WGL_COLOR_BITS_ARB,24,
                WGL_ALPHA_BITS_ARB,8,
                WGL_DEPTH_BITS_ARB,16,
                WGL_STENCIL_BITS_ARB,0,
                WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
                WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
                WGL_SAMPLES_ARB,4,
                0,0
        };

        // First We Check To See If We Can Get A Pixel Format For 4 Samples
        valid = wglChoosePixelFormatARB(hDC,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
 
        // If We Returned True, And Our Format Count Is Greater Than 1
        if (valid && numFormats >= 1)
        {
                arbMultisampleSupported = true;
                arbMultisampleFormat = pixelFormat;     
                return arbMultisampleSupported;
        }

        // Our Pixel Format With 4 Samples Failed, Test For 2 Samples
        iAttributes[19] = 2;
        valid = wglChoosePixelFormatARB(hDC,iAttributes,fAttributes,1,&pixelFormat,&numFormats);
        if (valid && numFormats >= 1)
        {
                arbMultisampleSupported = true;
                arbMultisampleFormat = pixelFormat;      
                return arbMultisampleSupported;
        }
          
        // Return The Valid Format
        return  arbMultisampleSupported;
}

---