How to compile openGL code which is in C++ in ubuntu

Hi,

I am trying to compile openGL code which is written in c++ ..but i am getting error msgs like this

root@lxdevenv:~/Desktop# g++ diss.cpp -o diss -I/usr/X11R6/include/ -L/usr/X11R6/lib -lX11 -lXi -lXmu -lglut -lGL -lGLU

diss.cpp:1:23: error: windows.h: No such file or directory
diss.cpp:2:22: error: gl\gl.h: No such file or directory
diss.cpp:3:23: error: gl\glu.h: No such file or directory
diss.cpp:4:24: error: gl\glaux.h: No such file or directory
diss.cpp:6: error: �HDC' does not name a type
diss.cpp:7: error: �HGLRC' does not name a type
diss.cpp:8: error: �HWND' does not name a type
diss.cpp:9: error: �HINSTANCE' does not name a type
diss.cpp:12: error: �TRUE' was not declared in this scope
diss.cpp:13: error: �TRUE' was not declared in this scope
diss.cpp:15: error: �LRESULT' does not name a type
diss.cpp:17: error: �GLvoid' does not name a type
diss.cpp:32: error: �GLvoid' was not declared in this scope
diss.cpp:33: error: expected �,' or �;' before �{' token
diss.cpp:40: error: �GLvoid' was not declared in this scope
diss.cpp:41: error: expected �,' or �;' before �{' token
diss.cpp:47: error: �GLvoid' does not name a type
diss.cpp:89: error: �BOOL' does not name a type
diss.cpp:254: error: �LRESULT' does not name a type
diss.cpp:315: error: expected initializer before �WinMain'
root@lxdevenv:~/Desktop#

but when im working openGL code in C .. i compiled it successfully..

my code is which is getting above error mgs is :

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

HDC hDC=NULL;
HGLRC hRC=NULL;
HWND hWnd=NULL;
HINSTANCE hInstance;

bool keys[256];
bool active=TRUE;
bool fullscreen=TRUE;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{

glViewport\(0,0,width,height\);                    

glMatrixMode\(GL_PROJECTION\);                    
glLoadIdentity\(\);                                


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

glMatrixMode\(GL_MODELVIEW\);            
glLoadIdentity\(\);                    

}

int InitGL(GLvoid)
{
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
return TRUE;
}

int DrawGLScene(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
return TRUE;
}

GLvoid KillGLWindow(GLvoid)
{
if (fullscreen)
{
ChangeDisplaySettings(NULL,0);
ShowCursor(TRUE);
}

if \(hRC\)                                            
\{
    if \(!wglMakeCurrent\(NULL,NULL\)\)                    
    \{
        MessageBox\(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION\);
    \}

    if \(!wglDeleteContext\(hRC\)\)    
    \{
        MessageBox\(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION\);
    \}
    hRC=NULL;                    
\}

if \(hDC && !ReleaseDC\(hWnd,hDC\)\)
\{
    MessageBox\(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION\);
    hDC=NULL;                    
\}

if \(hWnd && !DestroyWindow\(hWnd\)\)    
\{
    MessageBox\(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION\);
    hWnd=NULL;                                        
\}

if \(!UnregisterClass\("OpenGL",hInstance\)\)            
\{
    MessageBox\(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION\);
    hInstance=NULL;                                    
\}

}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat;
WNDCLASS wc;
DWORD dwExStyle;
DWORD dwStyle;
RECT WindowRect;
WindowRect.left=(long)0;
WindowRect.right=(long)width;
WindowRect.top=(long)0;
WindowRect.bottom=(long)height;

fullscreen=fullscreenflag;            

hInstance            = GetModuleHandle\(NULL\);    
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\)\)                                    
\{
    MessageBox\(NULL,"Failed To Register The Window Class.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                            
\}

if \(fullscreen\)                                                
\{
    DEVMODE dmScreenSettings;                                
    memset\(&dmScreenSettings,0,sizeof\(dmScreenSettings\)\);    
    dmScreenSettings.dmSize=sizeof\(dmScreenSettings\);        
    dmScreenSettings.dmPelsWidth    = width;                
    dmScreenSettings.dmPelsHeight    = height;                
    dmScreenSettings.dmBitsPerPel    = bits;                    
    dmScreenSettings.dmFields=DM\_BITSPERPEL|DM\_PELSWIDTH|DM_PELSHEIGHT;

    
    if \(ChangeDisplaySettings\(&dmScreenSettings,CDS\_FULLSCREEN\)!=DISP\_CHANGE_SUCCESSFUL\)
    \{
    
        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\)                                        
\{
    dwExStyle=WS\_EX_APPWINDOW;                        
    dwStyle=WS_POPUP;                                
    ShowCursor\(FALSE\);                                
\}
else
\{
    dwExStyle=WS\_EX_APPWINDOW | WS\_EX_WINDOWEDGE;    
    dwStyle=WS_OVERLAPPEDWINDOW;                    
\}

AdjustWindowRectEx\(&WindowRect, dwStyle, FALSE, dwExStyle\);    


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;            
\}

static    PIXELFORMATDESCRIPTOR pfd=
\{
    sizeof\(PIXELFORMATDESCRIPTOR\),
    1,                            
    PFD\_DRAW\_TO_WINDOW |        
    PFD\_SUPPORT_OPENGL |        
    PFD_DOUBLEBUFFER,            
    PFD\_TYPE_RGBA,                
    bits,                        
    0, 0, 0, 0, 0, 0,                            
    0,                                            
    0,                                            
    0,                                            
    0, 0, 0, 0,                                    
    16,                                            
    0,                                            
    0,                                            
    PFD\_MAIN_PLANE,                                
    0,                                            
    0, 0, 0                                        
\};

if \(!\(hDC=GetDC\(hWnd\)\)\)                            
\{
    KillGLWindow\(\);                                
    MessageBox\(NULL,"Can't Create A GL Device Context.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                
\}

if \(!\(PixelFormat=ChoosePixelFormat\(hDC,&pfd\)\)\)    
\{
    KillGLWindow\(\);                                
    MessageBox\(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                
\}

if\(!SetPixelFormat\(hDC,PixelFormat,&pfd\)\)        
\{
    KillGLWindow\(\);                                
    MessageBox\(NULL,"Can't Set The PixelFormat.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                
\}

if \(!\(hRC=wglCreateContext\(hDC\)\)\)                
\{
    KillGLWindow\(\);                                
    MessageBox\(NULL,"Can't Create A GL Rendering Context.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                
\}

if\(!wglMakeCurrent\(hDC,hRC\)\)                    
\{
    KillGLWindow\(\);                                
    MessageBox\(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                
\}

ShowWindow\(hWnd,SW_SHOW\);                        
SetForegroundWindow\(hWnd\);                        
SetFocus\(hWnd\);                                    
ReSizeGLScene\(width, height\);                    

if \(!InitGL\(\)\)                                    
\{
    KillGLWindow\(\);                                
    MessageBox\(NULL,"Initialization Failed.","ERROR",MB\_OK|MB_ICONEXCLAMATION\);
    return FALSE;                                
\}

return TRUE;                                    

}

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\);

}

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\("Tutorial - OpenGl",640,480,16,fullscreen\)\)
\{
    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\);                            

}

give me the solution if any one knows ,,, it will appreciated ,,,,

Thank U.

"U" is not a word.

Please use code tags for code. they make it readable. [ code ] stuff [ /code ] without the spaces in the tags.

Ubuntu does not have any of the dozens of windows-specific functions being used here. The code will have to be completely rewritten. It is possible to write opengl code that will work unmodified in both windows and ubuntu, but whoever wrote this did not bother.

Further problems:

Ubuntu of course does not have windows.h.

Ubuntu does not use backslashes for path seperators, things like gl\gl.h should be gl/gl.h

The above code looks like a MFC which is for Windows.
This will not work under Ubuntu. Try to implement the same using windowing API's like FLTK or even a simple glut will work.