GLUT or wgl which one

Hi evri1;

a while i was reading this book leisurly"opengl superbible"and it was mostly done in glut and now that im reading this book"opengl
gameprogramming" it says that GLUT implementation is mostly for demos and small programs. am i right to assume:

1-GLUT is a poor simulation of GUI done with bare essentials to mimick an operating system to make opengl os independent?

2-and to actually make some serious app in window , i have to use wgl as rod said it , within "window architect" which i prefer sinceive been doing win32 for couple of years now




what about claims that MS on purpose is slow to update its opengl libraries is it true?if so should i use their opengl libs?

is it true again that its better to reference SGI libs"silicon graphics"?or mesa or or or ,,,its getting so confusing just to start
with can any one simplify all this for me specially which to use?

thx

cheers!

yes you're pretty much correct in your assumptions. GLUT is for simple stuff and people who are learning, it's so you can learn OpenGL without having the hassle of setting up a window and setting up the pixel format and setting up the rendering/device contexts. I'm not too sure about the rest of the stuff, because it's never been a serious issue for me. If you want a suggestion, i.e how I started, use NeHe's lesson1 (.here ) as a sort of basecode. Whenever you learn something new in opengl, just plug it into the drawglscene functin. That single source file has become a standard religiously followed by my friends (yes I have one or a few) when we start projects. Not only that but you'll get so used to looking at it you'll be able to write your own basecode. I hope all goes well.


EDIT:

I've always known SGI to mean silicon graphics.

thx silvercord again do u program on vc++6 and windows own lib for opengl32?

im reading on this book actualy done by friends of nehe"gamedev.net kevin hawkins and on some programs when i import it to vc++6 i get the error for glut32.dll not being found.
now i checked lib files in vc directory and noticed that glu32 is there so i cant figure as why im getting that error message?

and last one how do i find out that the version of opengl on my compiler is the latest libs"version 1.2"?

excuse me for the number of questions it figures when u r a beginner at something.

cheers!

Yes I do programming with visual C++ 6 and 'windows own opengl' functions (wgl/wiggle). If you are trying to use the code from OpenGL game programming you shouldn't need the GLUT library installed at all. chance are you are including a glut header file into your project but you do not have the .dll in the windows32 folder of your system (that's where all your opengl related dlls should go).

You should be able to check the version in GL.h, just use ctrl F and keep pressing f3 until you get what you are looking for. In your actual header file you should only see GL_VERSION 1_1 or something like that, because:

from the latest GL.h header file:

Quote:

---

OpenGL v1.2, 1.3 or 1.4 are included with the drivers for your OpenGL video cards. So you only need to make sure you have the latest OpenGL driver for your video card. If you do not have the latest driver with OpenGL 1.2 or 1.3 or 1.4 support, either use GLSetup (for Win95/98 only) or contact the video card manufacturer directly and ask them for an OpenGL 1.2/1.3/1.4 driver for your card and OS.

---

EDIT: I hope I answered your questions, if I didn't just keep asking :)

Wow, You guys act like GLUT is a curse:p .
It's just for people not feeling like getting through the fuss of
learning all routines required to get OpenGL working for
the specific platform. Yes it's a little slower than using the
platfom specific routines but it isn't such a disaster using it.

thx silvercord again i promise promise promise !
to be more clear on my questions these are my questions;


To all opengl vets:

1- do u use version1.1 headers and libs offered by ms on your
vc++6?

2-if yes why? when its a version (what i mean is the version that developers use) going back to 95 and i read there is newer version 1.2 (by sgi) out since 1999 but ms hasnt implemented it yet. so if
we use the older version how can we utilize the awesom new capabilities of new videocards like nvidia?

3- if i want to use the newer version headers and libs lets say 1.2
can i simply download it and extract the libs and header as i normaly do to vc++6 lib and include files?

4-why is opengl ARB lagging in sending out updated versions "like MS SDK" so it wont fall behind directx with newer technologies which it updates yearly .?

5-why the info about opengl so scattered and not centralized like DIRECTX MS and u have to learn by examples?


any answers to these or part of it in details need to go to FAQ section because these are i believe major questions for any
dude who is a beginner to opengl programming.

thx in advance

Quote:

---

Originally posted by SAMSAM
why the info about opengl so scattered and not centralized

---

there we go

Again samsam to answer your questions about the newest OpenGL libraries, if you have the latest video drivers then you have the latest version of OpenGL.

If you downloaded the header and library files from opengl.org ( here ) as well as the latest video drivers from your video card's manufacturer then you have everything up to date, and you need not worry about anything.

You will see this at that URL:

Quote:

---

OpenGL v1.2, 1.3 or 1.4 are included with the drivers for your OpenGL video cards. So you only need to make sure you have the latest OpenGL driver for your video card

---

If you want you may email me
[email protected]

EDIT:

Quote:

---

3- if i want to use the newer version headers and libs lets say 1.2
can i simply download it and extract the libs and header as i normaly do to vc++6 lib and include files?

---

You need to download the OpenGL library and header files from the site posted above, if you have an updated version of your video card then the DLLs you download will contain the latest version of OpenGL. If you do not understand the correlation between the OpenGL dlls and your video card's dlls, you may want to read this thread here

To be honest with you I think you are getting a bit too hung up on the best way to start OpenGL, if you download the library files from opengl.org and have an up to date video card driver then you are OK. As I suggested before, take a look into downloading lesson1 from here (bottom of the page). When you learn something new in OpenGL simply plug it into the drawglscene() function :)

Hope I'm helping.

I agree with silver on this matter actually.

BTW SGI = Silicon Graphics.

Ok thx all i have assume version 1.4 with my nvidia gef440
that they say on nvidia website is part of their 4.09 update drivers that i downloaded a while back.

note*opengl game programming is a good book with horrible CD
support .be mindfull if u buy it because %30 of its source code
crash upon compiling i will send u this example of the first program that wont crash but shows just the window and no triangle rotating and i dont know why"by the way this code itsnot even on their cd because of some screwup that they said happend during developing the CD"

Code:

---


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

float angle = 0.0f;


HDC g_HDC;

void SetupPixelFormat(HDC hdc)
{
int npixelformat;

static PIXELFORMATDESCRIPTOR pfd = {
        sizeof(PIXELFORMATDESCRIPTOR),
                1,
                PFD_DRAW_TO_WINDOW |
                PFD_SUPPORT_OPENGL |
                PFD_DOUBLEBUFFER,
                PFD_TYPE_RGBA,
                32,
                0, 0, 0, 0, 0, 0,
                0,
                0,
                0,
                0, 0, 0, 0,
                16,
                0,
                0,
                PFD_MAIN_PLANE,
                0,
                0, 0, 0,};
       
       
        npixelformat = ChoosePixelFormat(hdc, &pfd);
        SetPixelFormat(hdc, npixelformat, &pfd);
        }

LRESULT  CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        static HGLRC hRC;
        static HDC hdc;
        char  hello[] = "HELLO SARA";
        int width, height;


        switch(message){

        case WM_CREATE:

                hdc = GetDC(hwnd);
                g_HDC = hdc;

                SetupPixelFormat(hdc);

                hRC = wglCreateContext(hdc);
                return 0;
                break;

    case WM_CLOSE:

                wglMakeCurrent(hdc, NULL);
                wglDeleteContext(hRC);
                PostQuitMessage(0);
                return 0;
                break;

        case WM_SIZE:
                height = HIWORD (lParam);
                width  = LOWORD (lParam);
                if(height == 0)
                {
                        height = 1;
                }

                glViewport(0, 0, width, height);
                glMatrixMode(GL_PROJECTION);
                glLoadIdentity();
                gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 1.0f, 1000.0f);
                glMatrixMode(GL_MODELVIEW);
                glLoadIdentity();
                return 0;
                break;
        default:
                break;
        }
        return (DefWindowProc(hwnd, message, wParam, lParam));
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{



       
       
       
    static char szAppName[] = TEXT ("opengl") ;
          BOOL  done;
    HWND        hwnd ;
    MSG          msg ;
    WNDCLASSEX    wndclass ;
    wndclass.cbSize        = sizeof(wndclass);
    wndclass.style        = CS_HREDRAW | CS_VREDRAW ;
    wndclass.lpfnWndProc  = WndProc ;
    wndclass.cbClsExtra    = 0 ;
    wndclass.cbWndExtra    = 0 ;
    wndclass.hInstance    = hInstance ;
    wndclass.hIcon        = LoadIcon (NULL, IDI_APPLICATION);
    wndclass.hCursor      = LoadCursor (NULL, IDC_ARROW) ;
    wndclass.hbrBackground = NULL;
    wndclass.lpszMenuName  = NULL ;
    wndclass.lpszClassName = szAppName ;
    wndclass.hIconSm      = LoadIcon(NULL, IDI_APPLICATION);

    RegisterClassEx(&wndclass);

       

hwnd = CreateWindow ( szAppName,                  // window class name
                          TEXT ("opengl"), // window caption
                          WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_SYSMENU | WS_CLIPCHILDREN|WS_CLIPSIBLINGS,      // window style
                          100,              // initial x position
                          100,              // initial y position
                          400,              // initial x size
                          400,              // initial y size
                          NULL,                      // parent window handle
                          NULL,                      // window menu handle
                          hInstance,                  // program instance handle
                          NULL) ; 

              if(!hwnd)
                return 0; 
   
    ShowWindow (hwnd, iCmdShow) ;
    UpdateWindow (hwnd) ;
    done = FALSE;

        while(!done)
        {
                PeekMessage(&msg, hwnd, 0, 0, PM_REMOVE);
                if(msg.message == WM_QUIT)
                {
                        done  = TRUE;
                }
                else
                {




        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();
        angle = angle + 0.1f;

        if(angle >= 360.0f)
      angle = 0.0f;
        glTranslatef(0.0f, 0.0f, -5.0f);
        glRotatef(angle, 0.0f, 0.0f, 1.0f);
        glColor3f(1.0f, 0.0f, 0.0f);
       
       
        glBegin(GL_TRIANGLES);

        glVertex3f(0.0f, 0.0f, 0.0f);
        glVertex3f(1.0f, 0.0f, 0.0f);
        glVertex3f(1.0f, 1.0f, 0.0f);

        glEnd();

        SwapBuffers(g_HDC);

        TranslateMessage(&msg);
        DispatchMessage(&msg);
                }
        }

        return  msg.wParam;
}

---

Quote:

---

opengl game programming is a good book with horrible CD
support .be mindfull if u buy it because %30 of its source code
crash upon compiling

---

i couldn't disagree more, i have never had a problem, i love the book and think it has great cd support.

Quote:

---

Originally posted by SAMSAM
note*opengl game programming is a good book with horrible CD
support .be mindfull if u buy it because %30 of its source code
crash upon compiling

---

Eehm, What compiler is used for examples in that book? your
compiler?

Visual Studio 6 (i forget if it was pro or std, but i use std)

Quote:

---

Originally posted by RoD
Visual Studio 6

---

Well now, What compiler do you have SAMSAM?

>>shows just the window and no triangle rotating and i dont know why

You opengl files aren't placed in the right places! Double check them, its not the books fault, its yours :P

No that's not true RoD the code just doesn't work. I fixed the PeekMessage function and made the order of things 'proper' (i.e if there is a message, if it's quit then done equals true, otherwise translate/dispatch message, otherwise draw the scene) but I still could not get it to work. I put a messagebox function in the draw scene part saying "this is the drawscene function" to see if it was even getting to the drawing part, and in fact it was. This leads me to believe there was something wrong with the way the pixel format was set up, but I don't care to take the time to fix that code properly :)

I typed the code in EXACT to the book, and it runs. When i had that problem i merely made sure my opengl files (from opengl.org) were placed right, which they weren't. After i fixed them i have had NO problems.

i just copied and pasted the code that SAMSAM posted and tried it and it didn't work. I fixed the errors I mentioned with no success and decided the error was elsewhere.

I tried the code and adjusted it here and there (code's a mess),
but it seems to just reject flipping the backbuffer.

I think you're right Trav, but I am not sure why it would skip the call to swapbuffers, and I do not mind because nehes basecode works :)

Oke, I think i fixed, The problem was it din't created a rendering
context whatsoever.

Code:

---

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

float angle = 0.0f;

HDC g_HDC;

void SetupPixelFormat(HDC hdc)
{
        int npixelformat;

        static PIXELFORMATDESCRIPTOR pfd =
        {
                sizeof(PIXELFORMATDESCRIPTOR),
                        1,
                        PFD_DRAW_TO_WINDOW |
                        PFD_SUPPORT_OPENGL |
                        PFD_DOUBLEBUFFER,
                        PFD_TYPE_RGBA,
                        32,
                        0, 0, 0, 0, 0, 0,
                        0,
                        0,
                        0,
                        0, 0, 0, 0,
                        16,
                        0,
                        0,
                        PFD_MAIN_PLANE,
                        0,
                        0, 0, 0
        };
       
        npixelformat = ChoosePixelFormat(hdc, &pfd);
        SetPixelFormat(hdc, npixelformat, &pfd);
       
        HGLRC hRC=wglCreateContext(g_HDC);
        wglMakeCurrent(g_HDC,hRC);
}

LRESULT  CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        static HGLRC hRC;
       
        char  hello[] = "HELLO SARA";
        int width, height;


        switch(message){

        case WM_CREATE:

                g_HDC = GetDC(hwnd);

                SetupPixelFormat(g_HDC);

                hRC = wglCreateContext(g_HDC);
                return 0;
                break;

    case WM_CLOSE:

                wglMakeCurrent(g_HDC, NULL);
                wglDeleteContext(hRC);
                PostQuitMessage(0);
                return 0;
                break;

        case WM_SIZE:
                height = HIWORD (lParam);
                width  = LOWORD (lParam);
                if(height == 0)
                {
                        height = 1;
                }

                glViewport(0, 0, width, height);
                glMatrixMode(GL_PROJECTION);
                glLoadIdentity();
                gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 1.0f, 1000.0f);
                glMatrixMode(GL_MODELVIEW);
                glLoadIdentity();
                return 0;
                break;
        default:
                break;
        }
        return (DefWindowProc(hwnd, message, wParam, lParam));
}

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
                    PSTR szCmdLine, int iCmdShow)
{



       
       
       
    static char szAppName[] = TEXT ("opengl") ;
          BOOL  done;
    HWND        hwnd ;
    MSG          msg ;
    WNDCLASSEX    wndclass ;
    wndclass.cbSize        = sizeof(wndclass);
    wndclass.style        = CS_HREDRAW | CS_VREDRAW ;
    wndclass.lpfnWndProc  = WndProc ;
    wndclass.cbClsExtra    = 0 ;
    wndclass.cbWndExtra    = 0 ;
    wndclass.hInstance    = hInstance ;
    wndclass.hIcon        = LoadIcon (NULL, IDI_APPLICATION);
    wndclass.hCursor      = LoadCursor (NULL, IDC_ARROW) ;
    wndclass.hbrBackground = NULL;
    wndclass.lpszMenuName  = NULL ;
    wndclass.lpszClassName = szAppName ;
    wndclass.hIconSm      = LoadIcon(NULL, IDI_APPLICATION);

    RegisterClassEx(&wndclass);

       

hwnd = CreateWindow ( szAppName,                  // window class name
                          TEXT ("opengl"), // window caption
                          WS_OVERLAPPEDWINDOW | WS_VISIBLE | WS_SYSMENU | WS_CLIPCHILDREN|WS_CLIPSIBLINGS,      // window style
                          100,              // initial x position
                          100,              // initial y position
                          400,              // initial x size
                          400,              // initial y size
                          NULL,                      // parent window handle
                          NULL,                      // window menu handle
                          hInstance,                  // program instance handle
                          NULL) ; 

              if(!hwnd)
                return 0; 
   
    ShowWindow (hwnd, iCmdShow) ;
    UpdateWindow (hwnd) ;
    done = FALSE;

        while(!done)
        {
                if(PeekMessage(&msg, hwnd, 0, 0, PM_REMOVE))
                {
                        if(msg.message == WM_QUIT)
                        {
                                done  = TRUE;
                        }
                        else
                        {
                                TranslateMessage(&msg);
                                DispatchMessage(&msg);
                        }
                }
                else
                {
                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                        glLoadIdentity();
                        angle = angle + 0.1f;

                        if(angle >= 360.0f)
                                angle = 0.0f;
                       
                        glTranslatef(0.0f, 0.0f, -5.0f);
                        glRotatef(angle, 0.0f, 0.0f, 1.0f);
                        glColor3f(1.0f, 0.0f, 0.0f);
                                               
                        glBegin(GL_TRIANGLES);

                                glVertex3f(0.0f, 0.0f, 0.0f);
                                glVertex3f(1.0f, 0.0f, 0.0f);
                                glVertex3f(1.0f, 1.0f, 0.0f);

                        glEnd();

                        SwapBuffers(g_HDC);
                }
        }
        return  (int)msg.wParam;
}

---

lmao no rendering context? AHAHAHA, where was that code from again? That's pretty sad, I didn't even look for a rc because i figured it would've been in there.

Only diff is i pragma'd some setting instead of doing it by hand.

Code:

---

/*        Steven Billington
*/

/*        Here we set the libraries to be used in the program, and
        trim some of the excess off of windows
*/

#define WIN32_LEAN_AND_MEAN
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "glaux.lib")
#pragma comment(linker, "/subsystem:windows")


/*        Include all needed headers for the project. Windows brings in
        everything needed for the basic application, and the other three
        bring in OpenGL related functions.
*/

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


/*        These are our global variables. These are ok in this program,
        but i wouldn't reccomend making a habit out of using global
        variables.

        angle:        Holds current angle of rotating triangle
        g_HDC:        Global Device Context
*/

float angle = 0.0f;               
HDC g_HDC;       
                       

/*        Function:        SetupPixelFormat
       
        Purpose:        This function gets the setup for the pixel format,
                                go figure right?
*/

void SetupPixelFormat(HDC hDC)
{
        int nPixelFormat;        /*        Pixel format index*/

        static PIXELFORMATDESCRIPTOR pfd = {
                sizeof(PIXELFORMATDESCRIPTOR),                                //size of structure
                1,                                                                                        //version, always set to one
                PFD_DRAW_TO_WINDOW |                                                //support window
                PFD_SUPPORT_OPENGL |                                                //support opengl
                PFD_DOUBLEBUFFER,                                                        //support double buffering
                PFD_TYPE_RGBA,                                                                //RGBA color mode
                32,                                                                                        //32bit color mode
                0,0,0,0,0,0,                                                                //ignore color bits, not used
                0,                                                                                        //no alpha buffer
                0,                                                                                        //ignore shift bit
                0,                                                                                        //no accumulation buffer
                0,0,0,0,                                                                        //ignore accumulation buffers
                16,                                                                                        //16 bit zbuffer size
                0,                                                                                        //no stencil buffer
                0,                                                                                        //no auxiliary buffer
                PFD_MAIN_PLANE,                                                                //main drawing plane
                0,                                                                                        //reserved
                0,0,0 };                                                                        //layer masks ignored

        /*        Choose best matching pixel format, return index*/
        nPixelFormat = ChoosePixelFormat(hDC,&pfd);

        /*        Set pixel format to device context*/
        SetPixelFormat(hDC,nPixelFormat,&pfd);
}

/*        Function:        WndProc

        Purpose:        This is our Windows Procedure Event Handler
*/

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        static HGLRC hRC;                                                //rendering context
        static HDC hDC;                                                        //device context
        char string[] = "Hello World!";                        //display text
        int width, height;                                                //window width, height

        switch(message)
        {
                case WM_CREATE:                                                //window is being created

                        hDC = GetDC(hwnd);                                //get current windows device context
                        g_HDC = hDC;
                        SetupPixelFormat(hDC);                        //call your pixel format setup function

                        //create rendering context and make it current
                        hRC = wglCreateContext(hDC);
                        wglMakeCurrent(hDC,hRC);

                        return 0;
                        break;

                case WM_CLOSE:                                                //window is closing

                        //deselect rendering context and delete it
                        wglMakeCurrent(hDC,NULL);
                        wglDeleteContext(hRC);

                        //send WM_QUIT to messagr queue
                        PostQuitMessage(0);

                        return 0;
                        break;

                case WM_SIZE:

                        height = HIWORD(lParam);        //get height and width
                        width = LOWORD(lParam);

                        if (height == 0)                        //don't want a divide by 0
                        {
                                height = 1;
                        }

                        //reset the viewport to new dimensions
                        glViewport(0,0,width,height);
                        glMatrixMode(GL_PROJECTION);                //set projection matrix
                        glLoadIdentity();                                        //reset proj matrix

                        //calculate aspect ratio of window
                        gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f);

                        glMatrixMode(GL_MODELVIEW);                        //set modelview matrix
                        glLoadIdentity();                                        //reset mdeolv matrix

                        return 0;
                        break;

                default:
                        break;


        }

        return (DefWindowProc(hwnd,message,wParam,lParam));
}

/*        Function:        WinMain

        Purpose:        Do i need to state this? Ok, its the main function.
*/

int APIENTRY WinMain(HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR    lpCmdLine,
                    int      nCmdShow)
{
        WNDCLASSEX  windowClass;                //window class
        HWND                hwnd;                                //window handle
        MSG                        msg;                                //message
        bool                done;                                //flag saying when app is complete

        /*        Fill out the window class structure*/
        windowClass.cbSize = sizeof(WNDCLASSEX);
        windowClass.style = CS_HREDRAW | CS_VREDRAW;
        windowClass.lpfnWndProc = WndProc;
        windowClass.cbClsExtra = 0;
        windowClass.cbWndExtra = 0;
        windowClass.hInstance = hInstance;
        windowClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
        windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
        windowClass.hbrBackground = NULL;
        windowClass.lpszMenuName = NULL;
        windowClass.lpszClassName = "MyClass";
        windowClass.hIconSm = LoadIcon(NULL, IDI_WINLOGO);

        /*        Register window class*/
        if (!RegisterClassEx(&windowClass))
        {
                return 0;
        }

        /*        Class registerd, so now create window*/
        hwnd = CreateWindowEx(NULL,                                                //extended style
                                                  "MyClass",                                //class name
                                                  "A Real OGL Win App",                //app name
                                                  WS_OVERLAPPEDWINDOW |                //window style
                                                  WS_VISIBLE |
                                                  WS_SYSMENU |
                                                  WS_CLIPCHILDREN |
                                                  WS_CLIPSIBLINGS,
                                                  100,100,                                        //x/y coords
                                                  400,400,                                        //width,height
                                                  NULL,                                                //handle to parent
                                                  NULL,                                                //handle to menu
                                                  hInstance,                                //application instance
                                                  NULL);                                        //no extra parameter's

        /*        Check if window creation failed*/
        if (!hwnd)
        {
                return 0;
        }

        ShowWindow(hwnd,SW_SHOW);                //displays window
        UpdateWindow(hwnd);                                //update window

        done = false;                                        //inititalize condition variable

        //main message loop
        while(!done)
        {
                PeekMessage(&msg,hwnd,NULL,NULL,PM_REMOVE);

                if (msg.message == WM_QUIT)
                {
                        done = true;
                }

                else
                {
                        //do rendering here
                        //clear screen and depth buffer
                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                        glLoadIdentity();                //reset modelview matrix

                        angle = angle + 0.1f;                //increase rotation angle counter

                        if (angle >= 360.0f)                //reset angle counter
                        {
                                angle = 0.0f;
                        }

                        glTranslatef(0.0f,0.0f,-5.0f);                        //move back 5 units
                        glRotatef(angle,0.0f,0.0f,1.0f);                //rotate along z-axis

                        glColor3f(1.0,0.0f,0.0f);                                //set color to red
                        glBegin(GL_TRIANGLES);                                        //draw the triangle
                                glVertex3f(0.0f,1.0f,0.0f);
                                glVertex3f(0.0f,0.0f,0.0f);                       
                                glVertex3f(1.0f,0.0f,0.0f);
                        glEnd();

                        SwapBuffers(g_HDC);                                                //bring back buffer to foreground

                        TranslateMessage(&msg);
                        DispatchMessage(&msg);

                }

        }


        return msg.wParam;;
}

---

Quote:

---

Originally posted by Silvercord
I didn't even look for a rc because i figured it would've been in there.

---

That's what i thought:p .

well I've gotta hand it to you trav, I was too quick to make assumptions and you weren't. That's probably a very good quality to have (not making assumptions).

hi i checked my vc++6 include files :
it has these files

gl.h
glu.h
glaux.h
glut.h

in my libs it has;

glut32
glu32
glaux
opengl32

in my setting\links i have;

kernel32.lib user32.lib gdi32.lib glu32.lib GLAUX.lib opengl32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /incremental:yes /pdb:"Debug/sia3d0019.pdb" /debug /machine:I386 /out:"Debug/sia3d0019.exe" /pdbtype:sept


so i think i have all the files .

by the way at first when i got warning about PeekMessage i changed NULL to 0 .in the book its NULL,



question?

should i continue reding this book or giveit up for another one before it starts me in opengl on the wrong foot?

i hope petzold would write a book about opengl everything he writes is so solid and full of details. does he know opengl?heh

$89 ahhhhh

>>should i continue reding this book or giveit up for another one before it starts me in opengl on the wrong foot?


theres nothing wrong with the book.

Rod gote say i typed the whole code without pasting because this source is not in the cd its suppose to be in chapter 2 and its not there. that one line i missed was the problem but i guess the compiler cant warn me about it.

it is a good book no question but its just the cd which in my case i have to install chapters one at the time.

anyway i forgot to say thx to you for finding that dumb mistake by me so how come all that define :
#define WIN32_LEAN_AND_MEAN
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "glaux.lib")
#pragma comment(linker, "/subsystem:windows")

was missing in the book and is it necessary?

I like opengl already ,10 functions and 20 something extra line of code will give u a opengl window "WOW"

i checked the similar code with directdraw7 "just the parts related to directdraw"u compare yourself;

Code:

---


#define INITGUID

#define WINDOW_WIDTH  800         
#define WINDOW_HEIGHT 600
#define SCREEN_WIDTH  800           
#define SCREEN_HEIGHT 600

int G_Init(void *parms=NULL);
int G_Shutdown(void *parms=NULL);
int G_Main(void *parms=NULL);

LPDIRECTDRAW7        lpdd        = NULL;
LPDIRECTDRAWSURFACE7 lpddsprimary = NULL; 
LPDIRECTDRAWSURFACE7 lpddsback    = NULL;
LPDIRECTDRAWPALETTE  lpddpal      = NULL; 
DDSURFACEDESC2      ddsd;               
DDSCAPS2            ddscaps;           
HRESULT              ddrval; 


    int G_Init(void *parms)
{



// create object and test for error
if (DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
  return(0);

// set cooperation level to windowed mode normal
if (lpdd->SetCooperativeLevel(main_window_handle,
          DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
          DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT)!=DD_OK)
    return(0);

// set the display mode
if (lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,SCREEN_BPP,0,0)!=DD_OK)
  return(0);

// Create the primary surface
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize        = sizeof(ddsd);
ddsd.dwFlags        = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;

if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK)
  return(0);

// return success
return(1);
} // end Game_Init

///////////////////////////////////////////////////////////

int G_Shutdown(void *parms)
{



// first release the primary surface
if (lpddsprimary!=NULL)
  lpddsprimary->Release();
     
// release the directdraw object
if (lpdd!=NULL)
  lpdd->Release();

// return success
return(1);
} // end Game_Shutdown

///////////////////////////////////////////////////////////

int G_Main(void *parms)
{


UCHAR *video_buffer = NULL; // used to draw

// check of user is trying to exit
if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
    PostMessage(main_window_handle, WM_DESTROY,0,0);



// set up the surface description to lock the surface
memset(&ddsd,0,sizeof(ddsd));
ddsd.dwSize = sizeof(ddsd);



lpddsprimary->Lock(NULL,&ddsd,
            DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);



video_buffer = (UCHAR *)ddsd.lpSurface;





for (int index=0; index<100; index++)
    {
    // get random x,y
    int x = rand()%SCREEN_WIDTH;
    int y = rand()%SCREEN_HEIGHT;

   
    video_buffer[x + y*ddsd.lPitch] = rand()%256;
    }


lpddsprimary->Unlock(NULL);

// return success
return(1);
} // end G_Main

///////////////////////////////////////////////////////////

---

may be d3d8 is even longer i dont know.

#define WIN32LEANANDMEAN trims down the windows libraries used

#pragma comment(lib, "libname.lib") is another way of telling your compiler what libraries to link to (instead of manually going to project, settings, link, and then typing it in everytime). I.e I have a single heaer file in MainGL in my Include directory that has all of the necessary links to necessary library files as well as header files. I.e when I want to start a new opengl project I just do
#include <MainGL\Main.h>
and maingl has
#pragma comment(lib, "libnam.lib") for all of the named opengl library files

this is (a part of) my main.h header file which I include in every opengl project

Code:

---

#include <windows.h>
#include <gl\gl.h>                       
#include <gl\glu.h>                       
#include <gl\glaux.h>               
#include <fstream.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
typedef unsigned char byte;
typedef unsigned short word;

#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")
#pragma comment(lib, "glaux.lib")

---

Oh and SAMSAM, you are going fast with this stuff, so don't start thinking to yourself things like "oh man this is such a big book, I absolutely must go fast so I can get really really good" because you are going at a good pace. Just make sure you take enough time to learn something, and have fun! :)

EDIT:
and yes, i know, fstream.h isn't the standard :) There are good reasons for that, actually
EDIT1: OpenGL Game Programming is an awesome book, I like it a lot. I would recommend getting at least one other opengl book, though, because personally I never ever buy just one book on a particular topic.

Ok i made this small code few days ago out of bordom in GDI .that you can move in the tunnel with up arrow and down arrow "i know its pointless and not refined" by the way i couldnt attach the bitmap DDB so in the code please delete few lines related to bitmap and u get white color instead of bitmap at the end of the tunnel.

but can anyone do this(if u get the time) in opengl, i be very curious and interested to see it done that way.

thank u all for your comments. i think this thread has gone long enough.


[code]


#include "resource.h"
#include <stdio.h>
#define ID_TIMER 1
static HBITMAP hbitmap;
LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
PSTR szCmdLine, int iCmdShow)
{
static char szAppName[] = TEXT ("Hell0 Sara") ;

HWND hwnd ;
MSG msg ;
WNDCLASSEX wndclass ;
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC ;
wndclass.lpfnWndProc = WndProc ;
wndclass.cbClsExtra = 0 ;
wndclass.cbWndExtra = 0 ;
wndclass.hInstance = hInstance ;
wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wndclass.hCursor = LoadCursor (NULL, IDC_ARROW) ;
wndclass.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wndclass.lpszMenuName = NULL ;
wndclass.lpszClassName = szAppName ;
wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

RegisterClassEx(&wndclass);






hwnd = CreateWindow (szAppName, // window class name
TEXT ("The, Hello Little Sara"), // window caption
WS_OVERLAPPEDWINDOW, // window style
CW_USEDEFAULT, // initial x position
CW_USEDEFAULT, // initial y position
CW_USEDEFAULT, // initial x size
CW_USEDEFAULT, // initial y size
NULL, // parent window handle
NULL, // window menu handle
hInstance, // program instance handle
NULL) ; // creation parameters

ShowWindow (hwnd, iCmdShow) ;
UpdateWindow (hwnd) ;

while (GetMessage (&msg, NULL, 0, 0))
{
TranslateMessage (&msg) ;
DispatchMessage (&msg) ;
}
return msg.wParam ;
}

LRESULT CALLBACK WndProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
BOOL b = TRUE;

static HDC hdc, hdcmem;
PAINTSTRUCT ps ;
static HBRUSH hbrush;

static BITMAP bitmap;

static int cxchar, cychar, cxclient, cyclient, i, j = 0, p = 0, n = 255, m = 45, f = 50, d = 50, s = 130,
cxs, cys;
HINSTANCE hInstance;
TEXTMETRIC tm;
static RECT rect, rect1, rc, rect2;
static HRGN ergn; //not utilized yet






switch (message)
{
case WM_CREATE:
// SetTimer(hwnd, ID_TIMER, 500, NULL); //not utilized yet



hInstance = ((LPCREATESTRUCT) lParam)->hInstance;
hbitmap = LoadBitmap(hInstance, TEXT ("mojo2"));
GetObject(hbitmap, sizeof(BITMAP), &bitmap);
cxs = bitmap.bmWidth;
cys = bitmap.bmHeight;






hdc = GetDC(hwnd);



GetTextMetrics(hdc, &tm);

cxchar = tm.tmAveCharWidth;
cychar = tm.tmHeight + tm.tmExternalLeading;
ReleaseDC(hwnd, hdc);



return 0;
case WM_SIZE:

cxclient = LOWORD(lParam);

cyclient = HIWORD(lParam);

return 0;
case WM_PAINT:

hdc = BeginPaint (hwnd, &ps) ;
GetUpdateRect(hwnd, &rect, FALSE);

for(i = 0; i < 130 ; i++){
rect.left = i * cxclient / 255 ;
rect.top = i * cyclient / 255 ;
rect.right = cxclient - i * cxclient / 255 ;
rect.bottom = cyclient - i * cyclient / 255 ;





hbrush = CreateSolidBrush(RGB(255 - p, 255 - p, 255 - p));
p += 2;

FillRect(hdc, &rect, hbrush);

}


//extra tunnel not utilized yet

/* for(i = 0; i < 130 ; i++){

rect1.left = i ;
rect1.top = cyclient / 2 + i ;
rect1.right = (cxclient / 3) - i ;
rect1.bottom = (cyclient) - i ;

hbrush = CreateSolidBrush(RGB(255 - p, 255 - p, 255 - p));
p += 2;
FillRect(hdc, &rect1, hbrush);

}*/


hbrush = CreateSolidBrush(RGB(245, 245, 245));
SelectObject(hdc, hbrush);

rect2.left = s * cxclient / 255 ;
rect2.top = s * cyclient / 255 ;
rect2.right = cxclient - s * cxclient / 255 ;
rect2.bottom = cyclient - s * cyclient / 255 ;





Rectangle(hdc, rect2.left ,rect2.top ,rect2.right , rect2.bottom);





hdcmem = CreateCompatibleDC(hdc);
SelectObject(hdcmem, hbitmap);



StretchBlt(hdc,s * cxclient / 255 , s * cyclient / 255,(cxclient - s * cxclient / 255) - s * cxclient / 255 ,
(cyclient - s * cyclient / 255) - s * cyclient / 255 , hdcmem, 0, 0, cxs, cys,
MERGECOPY);

DeleteDC(hdcmem);


DeleteObject(hbrush);
hbrush = CreateSolidBrush(RGB(255, 0, 0));
SelectObject(hdc, hbrush);
rc.left =(cxclient / 2)- 5;
rc.top = cyclient - (m + 25);
rc.right = cxclient / 2 + f ;
rc.bottom= (cyclient - m) + d + 20;
Ellipse(hdc, (cxclient / 2)- 5, cyclient - m ,cxclient / 2 + f, (cyclient - m) + d);
DeleteObject(hbrush);

p = 0;
EndPaint (hwnd, &ps) ;
return 0 ;

// case WM_TIMER:

// b = !b; //not utilized yet
// return 0;
case WM_KEYDOWN:
switch(wParam){
case VK_UP:
if(m < (cyclient / 2 ) && f > 0 && d > 0){
m += 15;
f -=2;
d -=2;
}else{

f -=2;
d -=2;
}
s--;
break;
case VK_DOWN:
if( m >= 25 && f > 0 && d > 0){
m -= 15;
f +=2;
d +=2;

}
s++;
break;
}


InvalidateRect(hwnd, &rect2, TRUE);InvalidateRect(hwnd, &rc, FALSE);
return 0;
case WM_DESTROY:

//KillTimer(hwnd, ID_TIMER);


DeleteObject(hbrush);
PostQuitMessage (0) ;
return 0 ;
}
return DefWindowProc (hwnd, message, wParam, lParam) ;
}

well I've never ever done a bitmap game or anything, in fact I've seriously had no luck with bitmap games, the bitmaps always seemed to cut out and crap, but this is a simple example that should give you the right idea. I'm not sure from what source I learned to used bitmaps, I think a cross between nehe and gl game programming, but anyway this is a pretty straight forward program except for the variable SHORT asdf, for some reason the last variable that checked movement made the bitmap blink out, I've had that happen before (does anyone know why?) so I just had the last variable be a dummy variable :)

EDIT: w, a, s, and d move the bitmap around the screen, i accidently included vector files from another project, pay no attention to those (too lazy to re upload)

I dont know why but after this iprogram i got the urge to brush my teeth more.often!.


thx for the code.:D

My cd has all the code, maybe you got a bad print/copy?

RoD while u r here i have a question:

I do everything in C and know of general terms about C++ but except basic stuff i cant do a major C++ program .now in tutorials i see for instance;

CCAMERA::positioncamera(float x);

and i know its a member function of class camera its not that hard.

but if it gets more complicated than this i be having problem

1-do i need to learn more on C++ or my knowledg of it is enough to get me through opengl framework environment?


2-is CCAMERA a opengl standard function?if not how do i differentiate between opengl stand functions and application tutorial function when it comes to tricky codes like CCAMERA?

1) I'm going through it. If i can, you can lol.

2) i honestly don't know, i'm not into the cameras yet. Silver or Travis would know.

It's hard to say if you absolutely must learn all of the important aspects of C++ in order to be able to understand game tutorials. I find that most tutorials don't bother to use the advance aspects of C++, such as templated classes/functions or polymorphism. Ultimately, however, C++ is probably the better language for game programming (using objects just works really good).

For example in a project I'm working on I've got an stl vector of GameEntities. GameEntity is a base class with SendMessage, PutMessage, and GetMessage functions all used for communicating with a GameController_t object. GameEntity also has virtual Load and CallDraw methods. GameEntity is used like this in my game:

std::vector<GameEntity> Entities; // all of the 'characters' in my game
//Player, Enemy, and Planet are some classes which derive from GameEntity

Entities.push_back(Player());
for(i = 0; i < NumEnemies; i++) {
Entities.push_back(Enemy());
}
for(i = 0; i < NumPlanets; i++) {
Entities.push_back(Planet());
}

That example shows a way you can use polymorphism in C++ for games, and if you understand what I'm getting at it 'just makes sense'. It makes sense because each Player, Enemy and Planet in the game is a gameentity, and each gameentity needs to be able to send, put, and getmessages from the gamecontroller, but each gameentity also needs to be able to define its own load and drawing methods. If you don't understand a lot of what I'm talking about don't worry too much, but I think it'll pay great dividends to learn C++ and get into object oriented programming.

Quote:

---

Originally posted by SAMSAM
2-is CCAMERA a opengl standard function?if not how do i differentiate between opengl stand functions and application tutorial function when it comes to tricky codes like CCAMERA?

---

There's a camera function build into OpenGL, But you can write
one yourself, It's very easy.

[edit]

CCamera is not an OpenGL class, At least not a standard one.

If it's a class, it's not OpenGL. If you can see the implementation of it, it's not OpenGL.

thx for a while after seeing that ,i thought i have to deal with classes then friends and buddies of classes then their granchildren "inheritance" and toddlers"protected" and unidentified guests"virtual functions" and what have u .great!

so i can still do it through my own C functions after i get little bit more comfy with opengl.

do all of u do programming full time?

and do u make a living at it ?
how did u get interested in it?

i dont know about u ppl like travis and rod and silvercord you are all probably lucky enough to be in university right now and your main task is programming so keep doing it .me i am in my thirties
long time ago left university "mech eng" unfinished and started my own buss that i should say makes me pretty good money but i missed the academic life and it was late u know "child mortgage,,,,,," 5 years ago while playing quake and chatting with quake players online started getting intersted in programming ,that got me on the road to realy do it as hobby

BASIC->html->C dos->win32 API----its great u know why? because i do it for the fun of it , and not for money(eventhough i iwouldnt mind the money).

i said all that to tell u folks that i envy you because your main preocupation is something u like "programming" so u can devote ur time to it. so stick to it
and u wont regret it when u be my age assuming u are all in your 20s.

good wishes!

one question though ;

1-if i code a small game engine in GDI and rather than displaying
repetative bitmaps and rotatations and tranformation of them,
use system colors and manupulate a static"multishade" scenery
and base the mvements not on changing the frame but changing its attributes and make everything realy lean and trim to the max.then can this game be as fast as the opengl or dx
version of it "i know that the code cant have direct access to vid mem but in this case does it realy matter"?
and if its slower by ur experience on comparing a GDI game and 3d game of the same

type what average FPS difference is between the two?

dont mind me with my many questions u dont have to answer them all;

cheers!

I'm going to take a crack at this because no one else has. I would say no, your GDI game won't ever be as fast a OpenGL or directx, although I'm not exactly sure how GDI works. It says that GDI doens't access hardware directly, rather it 'interacts with device drivers on behalf of the application'. I don't know what the difference is between accessing hardware directly and interacting with the drivers, but every GDI game I've seen gets bogged down with not-that-much going on in the game (compared to OpenGL). Also, isn't GDI limited to just 2d graphics with bitmaps and stuff?

Wasn't GDI incredibly slow?

that's what i've always thought. The most recent game with GDI I've seen was Hunter's space shooters, and that would run OK for a while, but when there were multiple space ships it would really bog things down.

Also, isn't GDI limited to just 2d graphics with bitmaps and stuff?


yes and no;

offcourse you are not going to get incredible scenes like MYST but

you can manipulate a bitmap per frame with the right shading to make it a legitimate 3d scene(i have done a few samples a while back on my other comp before it crashed and i lost 3.5 years worth of sample work i had done)but the good thing about GDI based graphic is that its much more portable compare to directx

...(using COM and its different interfaces has actually defeated the original purpose of MS to make directx device independent
by using different versions interface to different COMs)

last note*

you can even make a crude 3D scene with 8bit(256 colors) and use of pallett manager in GDI . so it can be done.

it can be done as good as dx version if john carmack was doing it.

haha!

by the way in an interview he said he is involved with a rocket project that will fundamentaly change the core technology that NASA is using to send man to space.so no
more new versions of quake ,for a while.

he is only 29 years old

He was 29 in 2000, and I don't see how armadillo aerospace could change the way nasa does anything. Heck their 'spaceship' looks like nothing more than a platform with engines, which is pretty cool, but that means they won't even be able to go into orbit because if they got going too fast the pilot would burn up upon re-entry.

EDIT: I guess they really are planning on sending a person into space with these things they're building, but I still don't see how it's feasible