OpenGL - Compile error.

Hejsa eksperter.
Jeg er nu sprunget ud i OpenGl, og benytter mig af følgende tutorial:
http://www.euclideanspace.com/software/games/threed/openglcpp/texture/index.htm

- Men, jeg har dog et problem, selvom jeg har fulgt tutorialen til punkt og prikke, så får jeg nogle compile errors, nemlig:

-------------------------
Line 33: expected constructor, destructor, or type conversion before '*' token.
Line 33: expected `,' or `;' before '*' token
Line 53: `TextureImage' undeclared (first use this function)
Line 57: `LoadBMP' undeclared (first use this function)
-------------------------

Er der nogle som kan hjælpe mig, med at løse problemet?
Jeg har følgende sourcecode:

/*
  Tutorial fra: http://www.euclideanspace.com/software/games/setup/openglcpp/first/index.htm
  Husk at linke til libopengl32.a, libglaux.a, libglu32.a, libglut32.a, libglut.a ..
*/


#include <windows.h> // Include windows, som altid, da vi er under windows OS.
#include <gl/gl.h> //OpenGL include
#include <gl/glu.h> //OpenGL include
#include <gl/glext.h> //OpenGL include


using namespace std;


HGLRC hRC = NULL;// Rendering Context, openGL relateret
HDC hDC = NULL; //Device Context, openGL relateret
HWND hWnd = NULL; // Windows relateret, et windows vinduehandle
HINSTANCE hInstance; // Windows relateret, en instance af vinduet vi vil lave.

bool keys[256];    // Antal keys på keyboardet vi bruger.
bool active = TRUE; // Om vinduet er aktivt eller ej.
bool fullscreen = TRUE; // Fullscreen eller ej.

GLfloat    rquad; // Vores firkants rotation
GLuint texture[1]; // Texturen til vores firkant.

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Windows relateret.

//Funktion til at indlæse bitmap
LRESULT    CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

AUX_RGBImageRec *LoadBMP(char *Filename){
  FILE *File=NULL;

  if (!Filename){ // Tjekker om filnavn er specificeret eller ej.
      return NULL;
  }

  File=fopen(Filename,"r");  // Åbner bitmap med read-only

  if (File){ // Hvis filen blev loaded, returner bitmap.
      fclose(File);
      return auxDIBImageLoad(Filename);
  }
  return NULL;
}

//Funktion til at loade bitmap ind som texture:
int LoadGLTextures(){
  int Status=FALSE;
 
  AUX_RGBImageRec *TextureImage[1];

  memset(TextureImage,0,sizeof(void *)*1); // Imagerecord som vi kan gemme vores billede i.
 
  if (TextureImage[0]=LoadBMP("Data/image1.bmp")){ // Derefter loader vi image.bmp ved at kalde loadBMP
      Status=TRUE;

      glGenTextures(1, &texture[0]);
      glBindTexture(GL_TEXTURE_2D, texture[0]);
      glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, 0, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
      glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
  }

  if (TextureImage[0]){
      if (TextureImage[0]->data){
        free(TextureImage[0]->data);
  }

  free(TextureImage[0]);
  }

  return Status;
}

// Nu intialisere vi openGl:
int InitGL(GLvoid){
  if (!LoadGLTextures()){ //Loader textures.
      return FALSE;
  }
  glEnable(GL_TEXTURE_2D); // Slår textures til.
  glShadeModel(GL_SMOOTH); // Vi fortæller opengl, at vi vil have smooth og glatte linjer og fades.
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Når skærmen skal resættes, bruger vi clearcolor, og den farve vi vil resette med. R,G,B,ALPHA
  glEnable(GL_DEPTH_TEST); //Slår Depth test til.
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //
  return TRUE; // Vi returnere true uanset hvad, indsæt selv en fejlhandler her
}

//Funktion til at tegne på skærmen her:
int DrawGLScene(GLvoid){
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Denne linje clears skærmen med den foregivne farve i glClearColor.
  glLoadIdentity(); // Denne linje resetter skærmen til matrix modelview mode.
 
  // Her tegner vi et objekt, en firkant:
  glTranslatef(0.0f,0.0f,-5.0f);
  glRotatef(30.0f,0.0f,1.0f,0.0f);
  glBindTexture(GL_TEXTURE_2D, texture[0]);
  glBegin(GL_QUADS);
  // Front Face
  glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Left
  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Right
  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f); // Top Right
  glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left
  // Back Face
  glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
  glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  // Top Face
  glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
  glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
  // Bottom Face
  glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
  glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
  // Right face
  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);
  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);
  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);
  // Left Face
  glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
  glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);
  glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);
  glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);
  glEnd();
  rquad-=1.15f;
  return TRUE; // Vi returnere true uanset hvad, indsæt selv en fejlhandler her
}

//Funktionen til at resize scenen efter vinduets størrelse (Er ikke nødvendig, men en god idé!)
GLvoid ReSizeGLScene(GLsizei width, GLsizei height){ //Variablerne bredde og højde
  glViewport(0,0,width,height); //Resetter viewport efter bredde og højde angivet som argument.
 
  glMatrixMode(GL_PROJECTION); // Fortæller at vi gerne vil bruge projection matrix (Giver ægte 3deffekt (men ikke sikker))
  glLoadIdentity(); // Vi resetter vores projection matrix, som vi tidligere kaldte.

  gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f); // Vores perspektiv

  glMatrixMode(GL_MODELVIEW); // vi vælger modelview matrix, det er der hvor vores objekter er gemt.
  glLoadIdentity(); // Og nu resetter vi vores modelview matrix.
}

//Funktionen til at dræbe openGl på en pæn måde.
GLvoid KillGLWindow(GLvoid){ // Måden at lukke vinduet ordenligt på.
  if (fullscreen){ // Først tjekker vi om skærmen er fullscreen
      ChangeDisplaySettings(NULL,0); // Vi prøver at skifte til windows skærmen, hvis den er fuldscreen .. Så kan vi destroy den.
      ShowCursor(TRUE); //Vis cursor.
  }

  if (hRC){ // Vi tjekker først om redering objects eksisterer.
      if (!wglMakeCurrent(NULL,NULL)){ //
          MessageBox(NULL,"Release Of DC And RC Failed.","Shutdown Error",MB_OK | MB_ICONINFORMATION);
      }
      if (!wglDeleteContext(hRC)){ // Vi forsøger at destroye Rendering objects.
          MessageBox(NULL,"Release Rendering Context Failed.","Shutdown Error",MB_OK | MB_ICONINFORMATION);
      }
      hRC=NULL;
  }

  if (hDC && !ReleaseDC(hWnd,hDC)){ // Her forsøger vi at frigive vinduet
      MessageBox(NULL,"Release Device Context Failed.","Shutdown Error",MB_OK | MB_ICONINFORMATION);
      hDC=NULL;
  }

  if (hWnd && !DestroyWindow(hWnd)){ // Her forsøger vi at destroye vinduet
      MessageBox(NULL,"Could Not Release hWnd.","Shutdown Error",MB_OK | MB_ICONINFORMATION);
      hWnd=NULL;
  }

  if (!UnregisterClass("OpenGL",hInstance)){ // Vi frigiver vores instance af vinduet
      MessageBox(NULL,"Could Not Unregister Class.","Shutdown Error",MB_OK | MB_ICONINFORMATION);
      hInstance=NULL;
  }
}

// Den vigtigste af alle, den funktion som laver opengl winduet
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag){ // Argumenterne: titel, bredde, højde, antal bits (16,24,32?), fullscreen
  GLuint PixelFormat; // Denne variable gemmer pixelformatet
  WNDCLASS wc; // Denne holder windows class strukturen.
  DWORD dwExStyle; // Windows style informationer (Extended style)
  DWORD dwStyle; // Windows style informationer (Normal style)
  RECT WindowRect; // Her, og de næste 4, definerer bundlinjerne af windows vinduet.
  WindowRect.left=(long)0;
  WindowRect.right=(long)width;
  WindowRect.top=(long)0;
  WindowRect.bottom=(long)height;

  fullscreen=fullscreenflag; // Vi sætter fullscreen

  hInstance = GetModuleHandle(NULL); // Herefter forsøger vi at tage en instans af vores vindue.
  wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
  wc.lpfnWndProc = (WNDPROC) WndProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hInstance = hInstance;
  wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = NULL;
  wc.lpszMenuName = NULL;
  wc.lpszClassName = "OpenGL";

  if (!RegisterClass(&wc)){ //Hvis det fejler, får vi en besked.
      MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
  }
 
  if (fullscreen){ // Her tjekker vi, om vinduet er fullscren, hvis det er, så sætter vi den til fullscreen mode.
      DEVMODE dmScreenSettings;  // Vi definerer en device mode.
      memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // Vi rydder noget memory, til at gemme vores video
      dmScreenSettings.dmSize=sizeof(dmScreenSettings);
      dmScreenSettings.dmPelsWidth = width; // Bredde af bits skærmen skal være, som vi fanger fra funktionens argumenter.
      dmScreenSettings.dmPelsHeight = height; // Højde af bits skærmen skal være, som vi fanger fra funktionens argumenter.
      dmScreenSettings.dmBitsPerPel = bits; // Antal bits skærmen skal være, (16,24,32?), som vi fanger fra funktionens argumenter.
      dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;


      if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL){ // Nu tjekker vi om fullscreen blev sat ordenligt.
        if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES){
            fullscreen=FALSE;
        }else{
            MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
            return FALSE;
        }
      }
  }

  if (fullscreen){ // Her tjekker vi om vi stadig er i fullscreen
      dwExStyle=WS_EX_APPWINDOW; // Vi indstiller extended styles, efter fullscreen
      dwStyle=WS_POPUP; // Vi indstiller styles, efter fullscreen
      ShowCursor(FALSE); // Vi gemmer musen, da vi ikke vil se den i fullscreen
  }else{
      dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Vi indstiller extended styles, efter fullscreen
      dwStyle=WS_OVERLAPPEDWINDOW; // Vi indstiller styles, efter fullscreen
  }
  AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);
 
  //Her laver vi et typisk windows_vindue, (kun windows relateret). følgende styles WS_CLIPSIBLINGS |WS_CLIPCHILDREN, forhindre andre programmer i at tegne indover vores vindue.
  if (!(hWnd=CreateWindowEx( dwExStyle,"OpenGL",title,dwStyle |WS_CLIPSIBLINGS |WS_CLIPCHILDREN,0, 0,WindowRect.right-WindowRect.left,WindowRect.bottom-WindowRect.top,NULL,NULL,hInstance,NULL))){
        KillGLWindow();
        MessageBox(NULL,"Window Creation Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
  }
 
  //Følgende del beskriver pixel formatet:
              //Vi vælger et format der understøtter OpenGL og double buffering, RGBA (red, green, blue, alpha channel)
  static PIXELFORMATDESCRIPTOR pfd={
      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
      bits, // Select Our Color Depth
      0, 0, 0, 0, 0, 0, // Color Bits Ignored
      0, // No 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
  };
 
    if (!(hDC=GetDC(hWnd))){ // Får fat i Device Context
      KillGLWindow(); // Vi kalder funktionen som dræber openGL, hvis det ikke lykkedes
      MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION); // Vi giver en fejl meddelse
      return FALSE;
    }

    if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))){ //Vi finder et pixelformat som passer.
      KillGLWindow(); // Vi kalder funktionen som dræber openGL, hvis det ikke lykkedes
      MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
    }

  if(!SetPixelFormat(hDC,PixelFormat,&pfd)){ // Her sætter vi pixelformatet
      KillGLWindow(); // Vi kalder funktionen som dræber openGL, hvis det ikke lykkedes
      MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
  }

  if (!(hRC=wglCreateContext(hDC))){ //Får fat i Rendering Context.
      KillGLWindow(); // Vi kalder funktionen som dræber openGL, hvis det ikke lykkedes
      MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
  }

  if(!wglMakeCurrent(hDC,hRC)){ // Hvis alt lykkes, gør vi rendering context aktivt
      KillGLWindow(); // Vi kalder funktionen som dræber openGL, hvis det ikke lykkedes
      MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
  }
 
  ShowWindow(hWnd,SW_SHOW); // Vi viser nu vinduet.
  SetForegroundWindow(hWnd); // Vi sætter det til forgrunden
  SetFocus(hWnd); // Vi sætter fokus
  ReSizeGLScene(width, height); // Sætter bredde og højde.

  if (!InitGL()){ // Derefter initialisere vi openGL, hvis det fejler, dræber vi vinduet.
      KillGLWindow();
      MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
      return FALSE;
  }

  return TRUE; // Vi returnere true, med success!
}


//Windows relateret funktion:
LRESULT CALLBACK WndProc( HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam){
  switch (uMsg){
    case WM_ACTIVATE:{
        if (!HIWORD(wParam)){
          active=TRUE;
        }else{
          active=FALSE;
        }
        return 0;
    }

    case WM_SYSCOMMAND:{
        switch (wParam){
          case SC_SCREENSAVE:
          case SC_MONITORPOWER:
          return 0;
      }
      break;
    }

    case WM_CLOSE:{
        PostQuitMessage(0);
        return 0;
    }

    case WM_KEYDOWN:{
        keys[wParam] = TRUE;
        return 0;
    }

    case WM_KEYUP:{
        keys[wParam] = FALSE;
        return 0;
    }

    case WM_SIZE:{
        ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));
        return 0;
    }
}

return DefWindowProc(hWnd,uMsg,wParam,lParam);
}


// Windows main start funktion, udelukkende windows programmering.
int WINAPI WinMain( HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow){
  MSG msg;
  BOOL done=FALSE;
  if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO){
      fullscreen=FALSE;
  }
  if (!CreateGLWindow("Lesson 1",800,600,32,fullscreen)){ // Opret vinduet, med 1440x900 med 32bit
      return 0;
  }

  while(!done){
      if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)){
        if (msg.message==WM_QUIT){
            done=TRUE;
        }else{
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
      }else{
        if (active){
            DrawGLScene();
            SwapBuffers(hDC);
        }
      }
  }
  KillGLWindow();
  return (msg.wParam);
}



----
Og som bonus spørgsmål, hvor jeg kan finde noget om import af 3d objekter?