openGL_tools.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include <windows.h>
#include <gl\gl.h>                   // Header for OpenGL32 Lib
#include <gl\glu.h>                  // GLu32 Lib
#include <gl\glaux.h>                // GLaux Lib

#include "MyString.h"
#include "openGL_tools.h"
#include "MyDebug.h"
#include <math.h>

BOOL OpenGL_TestError(BOOL resultOnMessageBox,BOOL resultOnMyDebug,HWND hWnd) 
{
        MyString fullText;
        MyString text;
        BOOL next = TRUE;
        int nbError=0;
        while(next)
        {
                int error = glGetError();
                //on peut aussi utiliser "gluErrorString", mais on pert le tittle
                switch (error)
                {
                case GL_NO_ERROR: next=FALSE; break;
                case GL_INVALID_ENUM: 
                        text="GL_INVALID_ENUM - An unacceptable value is specified for an enumerated argument.";
                        break;
                case GL_INVALID_VALUE: 
                        text="GL_INVALID_VALUE - A numeric argument is out of range.";
                        break;
                case GL_INVALID_OPERATION:
                        text="GL_INVALID_OPERATION - The specified operation is not allowed in the current state.";
                        break;
                case GL_STACK_OVERFLOW: 
                        text="GL_STACK_OVERFLOW - This function would cause a stack overflow.";
                        break;
                case GL_STACK_UNDERFLOW: 
                        text="GL_STACK_UNDERFLOW - This function would cause a stack underflow.";
                        break;
                case GL_OUT_OF_MEMORY: 
                        text="GL_OUT_OF_MEMORY - There is not enough memory left to execute the function.";
                        break;
                }
                if (error!=GL_NO_ERROR)
                {
                        nbError++;
                        fullText.AddFormat("#%d - %s\n",nbError,(char *)text);
                }       
        }
        if (nbError)
        {
                if (resultOnMessageBox)
                {
                        MyString title;
                        //if (hWnd) KillTimer(hWnd,0);
                        title.Format("OpenGl - %d Errors",nbError);
                        MessageBox(NULL,fullText,title,0);
                        //SetTimer(hWnd,0,timer,NULL);
                }
                if (resultOnMyDebug)
                {
                        if (nbError>1)
                        MyDebug::SendLine("glError","(%d error)\n%s",nbError,(char *)fullText);
                        else MyDebug::SendLine("glError",fullText);
                }
                return TRUE;
        }
        return FALSE;
}

void OpenGL_ViewVersionExtansions(char *extensions,MyString &result)
{
        MyString temp;
        result="";
        for (int i=0;i<(int)strlen(extensions);i++) 
        {
                char letter = extensions[i];
                if (letter==' ')
                {
                        result<<"\n* "<<temp;
                        temp="";
                }
                else temp<<letter;
        }
        if (temp!="") result<<"\n* "<<temp;
}

void OpenGL_ViewVersion()
{   // fonction dois etre appeler apres l'initialisation d'openGL sinon ne retourne rien
        char *extensions = (char *)glGetString(GL_EXTENSIONS);
        MyString temp,resultExt;
        temp<<"Vendor:\t\t"<<(char *)glGetString(GL_VENDOR)<<"\n";
        temp<<"Render:\t\t"<<(char *)glGetString(GL_RENDERER)<<"\n";
        temp<<"Version:\t\t"<<(char *)glGetString(GL_VERSION)<<"\n";
        temp<<"Version(GLU):\t"<<(char *)gluGetString(GLU_VERSION)<<"\n";
        extensions = (char *)glGetString(GL_EXTENSIONS);
        OpenGL_ViewVersionExtansions(extensions,resultExt);
        temp<<"Extensions:"<<resultExt;
        extensions = (char *)gluGetString(GLU_EXTENSIONS);
        OpenGL_ViewVersionExtansions(extensions,resultExt);
        temp<<"\nExtensions(GLU):"<<resultExt;

        MessageBox(NULL,temp,"Info OpenGL",0);          
}

// pour la gestion des extanssion permetant la gestion de l'anti-aliasing
#define WGL_SAMPLE_BUFFERS_ARB           0x2041
#define WGL_SAMPLES_ARB                      0x2042

BOOL OpenGL_ExtensionSupported(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) supported = (char*)glGetString(GL_EXTENSIONS);

        // If That Failed Too, Must Be No Extensions Supported
        if (!supported ) 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) 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 ***********************
        retour pixelFormat -ou- 0 si impossible
        
********************************************************************************** */
#include "wglext.h"             //WGL extensions
#include "glext.h"              //GL extensions

int OpenGL_InitMultisample(HWND hWnd)
{  
        // See If The String Exists In WGL!
        if (!OpenGL_ExtensionSupported("WGL_ARB_multisample")) return FALSE;

        // Get Our Pixel Format
        PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");  
        if (!wglChoosePixelFormatARB) return 0;

        // 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) return  pixelFormat;      

        // 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) return pixelFormat;
        
        return  0; // Return The Valid Format
}


// from URL: http://www.opengl.org/resources/code/basics/redbook/index.html
#define PI_ 3.14159265358979323846

/* accFrustum()
* The first 6 arguments are identical to the glFrustum() call.
*  
* pixdx and pixdy are anti-alias jitter in pixels. 
* Set both equal to 0.0 for no anti-alias jitter.
* eyedx and eyedy are depth-of field jitter in pixels. 
* Set both equal to 0.0 for no depth of field effects.
*
* focus is distance from eye to plane in focus. 
* focus must be greater than, but not equal to 0.0.
*
* Note that accFrustum() calls glTranslatef().  You will 
* probably want to insure that your ModelView matrix has been 
* initialized to identity before calling accFrustum().
*/
void accFrustum(GLdouble left, GLdouble right, GLdouble bottom, 
                                GLdouble top, GLdouble znear, GLdouble zfar, GLdouble pixdx, 
                                GLdouble pixdy, GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
        GLdouble xwsize, ywsize; 
        GLdouble dx, dy;
        GLint viewport[4];

        glGetIntegerv (GL_VIEWPORT, viewport);

        xwsize = right - left;
        ywsize = top - bottom;

        dx = -(pixdx*xwsize/(GLdouble)viewport[2] + eyedx*znear/focus);
        dy = -(pixdy*ywsize/(GLdouble)viewport[3] + eyedy*znear/focus);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glFrustum (left+dx, right+dx, bottom+dy, top+dy, znear, zfar);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glTranslatef (-eyedx, -eyedy, 0.0);
}

/* accPerspective()
* 
* The first 4 arguments are identical to the gluPerspective() call.
* pixdx and pixdy are anti-alias jitter in pixels. 
* Set both equal to 0.0 for no anti-alias jitter.
* eyedx and eyedy are depth-of field jitter in pixels. 
* Set both equal to 0.0 for no depth of field effects.
*
* focus is distance from eye to plane in focus. 
* focus must be greater than, but not equal to 0.0.
*
* Note that accPerspective() calls accFrustum().
*/
void accPerspective(GLdouble fovy, GLdouble aspect, 
                                        GLdouble znear, GLdouble zfar, GLdouble pixdx, GLdouble pixdy, 
                                        GLdouble eyedx, GLdouble eyedy, GLdouble focus)
{
        GLdouble fov2,left,right,bottom,top;

        fov2 = ((fovy*PI_) / 180.0) / 2.0;

        top = znear / (cos(fov2) / sin(fov2));
        bottom = -top;

        right = top * aspect;
        left = -right;

        accFrustum (left, right, bottom, top, znear, zfar,
                pixdx, pixdy, eyedx, eyedy, focus);
}

---