[Dev-C++] windows apps

[Jarred <sto...@ya...>]

Hellow I am new on this list and have a question about dev c++. I am trying
to learn using this program to program in C. What is all the code if I chose
windows project it throws in and what will give me a simple doss binary
under the type of project? Thanks for any help. Also in that big mess of
code that is automaticly put in for windows apps where do I put my own code.
----- Original Message -----
From: "Julio Lajara" <ju2...@ya...>
To: <dev...@li...>
Sent: Wednesday, July 18, 2001 11:47 AM
Subject: [Dev-C++] RE: Trouble compiling OpenGL apss


> If you downloaded the complete package of Dev-C++ it
> should have already come with GLUT. I dont know if you
> wrote the code you are having trouble with yourself or
> if you edited the sample code from gamdev.net, but
> here is one of my openGL apps that compiles fine with
> "-lkernel32 -lopengl32 -lglu32 -lglaux" in the project
> options, but I think it has to be a Win32 project
> compiled in C++ with .cpp source code file to work:
>
> #include <windows.h> // Header File For Windows
> #include <gl\gl.h> // Header File For The
> OpenGL32 Library
> #include <gl\glu.h> // Header File For The
> GLu32 Library
> #include <gl\glaux.h> // Header File For The
> GLaux Library
>
> HGLRC hRC=NULL; // Permanent Rendering Context
> HDC     hDC=NULL; // Private GDI Device Context
> HWND hWnd=NULL; // Holds Our Window Handle
> HINSTANCE hInstance; // Holds The Instance Of
> The Application
>
> bool keys[256]; // Array Used For The Keyboard
> Routine
> bool active=TRUE; // Window Active Flag Set To
> TRUE By Default
> bool fullscreen=TRUE; // Fullscreen Flag Set To
> Fullscreen Mode By Default
>
> LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
> // Declaration For WndProc
>
> GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
> // Resize And Initialize The GL Window
> {
> if (height==0) // Prevent A Divide By Zero By
> {
> height=1; // Making Height Equal One
> }
>
> glViewport(0, 0, width, height); // Reset The
> Current Viewport
>
>     glMatrixMode(GL_PROJECTION); // Select The
> Projection Matrix
> glLoadIdentity(); // Reset The Projection
> Matrix
>
> // Calculate The Aspect Ratio Of The Window
>
> gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
>
> glMatrixMode(GL_MODELVIEW);         // Select
> The Modelview Matrix
> glLoadIdentity();             // Reset The
> Modelview Matrix
> }
>
> int InitGL(GLvoid)             // All Setup For
> OpenGL Goes Here
> {
>     glShadeModel(GL_SMOOTH);         // Enables
> Smooth Shading
>     glClearColor(0.0f, 0.0f, 0.0f, 0.0f); // Black
> Background
>     glClearDepth(1.0f); // Depth Buffer Setup
> glEnable(GL_DEPTH_TEST); // Enables Depth
> Testing
> glDepthFunc(GL_LEQUAL); // The Type Of Depth
> Test To Do
>     glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
> // Really Nice Perspective Calculations
>     return TRUE; // Initialization Went OK
> }
>
> int DrawGLScene(GLvoid) // Here's Where We Do
> All The Drawing
> {
> glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
> // Clear The Screen And The Depth Buffer
> glLoadIdentity(); // Reset The Current
> Modelview Matrix
>     glTranslatef(-1.5f,0.0f,-6.0f); // Move Left
> 1.5 Units And Into The Screen 6.0
> glBegin(GL_TRIANGLES); // Drawing Using
> Triangles
> glVertex3f( 0.0f, 1.0f, 0.0f); // Top
> glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left
> glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right
> glEnd(); // Finished Drawing The Triangle
> glTranslatef(3.0f,0.0f,0.0f); // Move Right 3
> Units
> glBegin(GL_QUADS); // Draw A Quad
> glVertex3f(-1.0f, 1.0f, 0.0f); // Top Left
> glVertex3f( 1.0f, 1.0f, 0.0f); // Top Right
> glVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right
> glVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left
> glEnd(); // Done Drawing The Quad
> return TRUE; // Everything Went OK
> }
>
> GLvoid KillGLWindow(GLvoid) // Properly Kill The
> Window
> {
>
> if (fullscreen) // Are We In Fullscreen Mode?
> {
> ChangeDisplaySettings(NULL,0); // If So Switch
> Back To The Desktop
> ShowCursor(TRUE); // Show Mouse Pointer
> }
>
> if (hRC) // Do We Have A Rendering Context?
> {
>
> if (!wglMakeCurrent(NULL,NULL)) // Are We Able
> To Release The DC And RC Contexts?
> {
> MessageBox(NULL,"Release Of DC And RC
> Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
> }
>
> if (!wglDeleteContext(hRC)) // Are We Able To
> Delete The RC?
> {
> MessageBox(NULL,"Release Rendering Context
> Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
> }
> hRC=NULL; // Set RC To NULL
> }
>
> if (hDC && !ReleaseDC(hWnd,hDC)) // Are We Able
> To Release The DC
> {
> MessageBox(NULL,"Release Device Context
> Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
> hDC=NULL; // Set DC To NULL
> }
>
> if (hWnd && !DestroyWindow(hWnd)) // Are We Able
> To Destroy The Window?
> {
> MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN
> ERROR",MB_OK | MB_ICONINFORMATION);
> hWnd=NULL; // Set hWnd To NULL
> }
>
> if (!UnregisterClass("OpenGL",hInstance)) // Are We
> Able To Unregister Class
> {
> MessageBox(NULL,"Could Not Unregister
> Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
> hInstance=NULL; // Set hInstance To NULL
> }
> }
>
> BOOL CreateGLWindow(char* title, int width, int
> height, int bits, bool fullscreenflag)
> {
> GLuint PixelFormat; // Holds The Results After
> Searching For A Match
> WNDCLASS wc; // Windows Class Structure
> DWORD dwExStyle; // Window Extended Style
> DWORD dwStyle; // Window Style
> RECT WindowRect; // Grabs Rectangle Upper Left
> / Lower Right Values
> WindowRect.left=(long)0; // Set Left Value To 0
> WindowRect.right=(long)width; // Set Right Value
> To Requested Width
> WindowRect.top=(long)0; // Set Top Value To 0
> WindowRect.bottom=(long)height; // Set Bottom
> Value To Requested Height
> fullscreen=fullscreenflag; // Set The Global
> Fullscreen Flag
> hInstance = GetModuleHandle(NULL); // Grab An
> Instance For Our Window
> wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; //
> Redraw On Move, And Own DC For Window
> wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc
> Handles Messages
> wc.cbClsExtra = 0; // No Extra Window Data
> wc.cbWndExtra = 0; // No Extra Window Data
> wc.hInstance = hInstance; // Set The Instance
> wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load
> The Default Icon
> wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load
> The Arrow Pointer
> wc.hbrBackground = NULL; // No Background
> Required For GL
> wc.lpszMenuName = NULL; // We Don't Want A Menu
> wc.lpszClassName = "OpenGL"; // Set The Class
> Name
>
> if (!RegisterClass(&wc)) // Attempt To Register
> The Window Class
> {
> MessageBox(NULL,"Failed To Register The Window
> Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Exit And Return FALSE
> }
>
> if (fullscreen) // Attempt Fullscreen Mode?
> {
> DEVMODE dmScreenSettings; // Device Mode
>
> memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
> // Makes Sure Memory's Cleared
> dmScreenSettings.dmSize=sizeof(dmScreenSettings);
> // Size Of The Devmode Structure
> dmScreenSettings.dmPelsWidth = width; // Selected
> Screen Width
> dmScreenSettings.dmPelsHeight = height; //
> Selected Screen Height
> dmScreenSettings.dmBitsPerPel = bits; // Selected
> Bits Per Pixel
>
> dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;
>
> // Try To Set Selected Mode And Get Results.  NOTE:
> CDS_FULLSCREEN Gets Rid Of Start Bar.
> if
>
(ChangeDisplaySettings(&dmScreenSettings,SHOW_FULLSCREEN)!=DISP_CHANGE_SUCCE
SSFUL)
> {
> // If The Mode Fails, Offer Two Options.  Quit Or
> Run In A Window.
> 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; // Select Windowed Mode
> (Fullscreen=FALSE)
> }
> else
> {
> // Pop Up A Message Box Letting User Know The
> Program Is Closing.
> MessageBox(NULL,"Program Will Now
> Close.","ERROR",MB_OK|MB_ICONSTOP);
> return FALSE; // Exit And Return FALSE
> }
> }
> }
>
> if (fullscreen) // Are We Still In Fullscreen
> Mode?
> {
> dwExStyle=WS_EX_APPWINDOW; // Window Extended
> Style
> dwStyle=WS_POPUP; // Windows Style
> ShowCursor(FALSE); // Hide Mouse Pointer
> }
> else
> {
> dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; //
> Window Extended Style
> dwStyle=WS_OVERLAPPEDWINDOW; // Windows Style
> }
>
> AdjustWindowRectEx(&WindowRect, dwStyle, FALSE,
> dwExStyle); // Adjust Window To True Requested Size
>
> if (!(hWnd=CreateWindowEx( dwExStyle, // Extended
> Style For The Window
> "OpenGL", // Class Name
> title, // Window Title
> WS_CLIPSIBLINGS | // Required Window Style
> WS_CLIPCHILDREN | // Required Window Style
> dwStyle, // Selected Window Style
> 0, 0, // Window Position
> WindowRect.right-WindowRect.left, // Calculate
> Adjusted Window Width
> WindowRect.bottom-WindowRect.top, // Calculate
> Adjusted Window Height
> NULL, // No Parent Window
> NULL, // No Menu
> hInstance, // Instance
> NULL))) // Don't Pass Anything To WM_CREATE
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Window Creation
> Error.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> static PIXELFORMATDESCRIPTOR pfd= // pfd Tells
> Windows How We Want Things To Be
> {
> 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))) // Did We Get A Device
> Context?
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Can't Create A GL Device
> Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) //
> Did Windows Find A Matching Pixel Format?
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Can't Find A Suitable
> PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> if(!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are
> We Able To Set The Pixel Format?
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Can't Set The
> PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> if (!(hRC=wglCreateContext(hDC))) // Are We Able
> To Get A Rendering Context?
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Can't Create A GL Rendering
> Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> if(!wglMakeCurrent(hDC,hRC)) // Try To Activate
> The Rendering Context
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Can't Activate The GL Rendering
> Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> ShowWindow(hWnd,SW_SHOW); // Show The Window
> SetForegroundWindow(hWnd); // Slightly Higher
> Priority
> SetFocus(hWnd); // Sets Keyboard Focus To The
> Window
> ReSizeGLScene(width, height); // Set Up Our
> Perspective GL Screen
>
> if (!InitGL()) // Initialize Our Newly Created
> GL Window
> {
> KillGLWindow(); // Reset The Display
> MessageBox(NULL,"Initialization
> Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
> return FALSE; // Return FALSE
> }
>
> return TRUE; // Success
> }
>
> LRESULT CALLBACK WndProc( HWND hWnd, // Handle For
> This Window
> UINT uMsg, // Message For This Window
> WPARAM wParam, // Additional Message
> Information
> LPARAM lParam) // Additional Message
> Information
> {
>
> switch (uMsg) // Check For Windows Messages
> {
>
> case WM_ACTIVATE: // Watch For Window Activate
> Message
> {
> if (!HIWORD(wParam)) // Check Minimization
> State
> {
> active=TRUE; // Program Is Active
> }
> else
> {
> active=FALSE; // Program Is No Longer Active
> }
>
> return 0; // Return To The Message Loop
> }
>
> case WM_SYSCOMMAND: // Intercept System
> Commands
> {
> switch (wParam) // Check System Calls
> {
> case SC_SCREENSAVE: // Screensaver Trying To
> Start?
> case SC_MONITORPOWER: // Monitor Trying To
> Enter Powersave?
> return 0; // Prevent From Happening
> }
> break; // Exit
> }
>
> case WM_CLOSE: // Did We Receive A Close
> Message?
> {
> PostQuitMessage(0); // Send A Quit Message
> return 0; // Jump Back
> }
>
> case WM_KEYDOWN: // Is A Key Being Held Down?
> {
> keys[wParam] = TRUE; // If So, Mark It As TRUE
> return 0; // Jump Back
> }
>
> case WM_KEYUP: // Has A Key Been Released?
> {
> keys[wParam] = FALSE; // If So, Mark It As
> FALSE
> return 0; // Jump Back
> }
>
> case WM_SIZE: // Resize The OpenGL Window
> {
> ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); //
> LoWord=Width, HiWord=Height
> return 0; // Jump Back
> }
> }
>
> // Pass All Unhandled Messages To DefWindowProc
> return DefWindowProc(hWnd,uMsg,wParam,lParam);
> }
>
> int WINAPI WinMain( HINSTANCE hInstance, //
> Instance
> HINSTANCE hPrevInstance, // Previous Instance
> LPSTR lpCmdLine, // Command Line Parameters
> int nCmdShow) // Window Show State
> {
>
> MSG msg; // Windows Message Structure
> BOOL done=FALSE; // Bool Variable To Exit Loop
>
> // Ask The User Which Screen Mode They Prefer
> if (MessageBox(NULL,"Would You Like To Run In
> Fullscreen Mode?", "Start
> FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
> {
> fullscreen=FALSE; // Windowed Mode
> }
>
> // Create Our OpenGL Window
> if (!CreateGLWindow("NeHe's OpenGL
> Framework",640,480,16,fullscreen))
> {
> return 0; // Quit If Window Was Not Created
> }
>
> while(!done) // Loop That Runs Until done=TRUE
> {
>
> if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is
> There A Message Waiting?
> {
>
> if (msg.message==WM_QUIT) // Have We Received A
> Quit Message?
> {
> done=TRUE; // If So done=TRUE
> }
> else // If Not, Deal With Window Messages
> {
> TranslateMessage(&msg); // Translate The
> Message
> DispatchMessage(&msg); // Dispatch The Message
> }
> }
> else // If There Are No Messages
> {
>
> // Draw The Scene.  Watch For ESC Key And Quit
> Messages From DrawGLScene()
> if (active) // Program Active?
> {
> if (keys[VK_ESCAPE]) // Was ESC Pressed?
> {
> done=TRUE; // ESC Signalled A Quit
> }
> else // Not Time To Quit, Update Screen
> {
>
> DrawGLScene(); // Draw The Scene
> SwapBuffers(hDC); // Swap Buffers (Double
> Buffering)
> }
> }
>
> if (keys[VK_F1]) // Is F1 Being Pressed?
> {
> keys[VK_F1]=FALSE; // If So Make Key FALSE
> KillGLWindow(); // Kill Our Current Window
> fullscreen=!fullscreen; // Toggle Fullscreen /
> Windowed Mode
> // Recreate Our OpenGL Window
> if (!CreateGLWindow("NeHe's OpenGL
> Framework",640,480,16,fullscreen))
> {
> return 0; // Quit If Window Was Not Created
> }
> }
> }
> }
>
> // Shutdown
> KillGLWindow(); // Kill The Window
> return (msg.wParam); // Exit The Program
> }
>
>
> =====
> Julio
>
> __________________________________________________
> Do You Yahoo!?
> Get personalized email addresses from Yahoo! Mail
> http://personal.mail.yahoo.com/
>
> _______________________________________________
> Dev-cpp-users mailing list
> Dev...@li...
> http://lists.sourceforge.net/lists/listinfo/dev-cpp-users


_________________________________________________________
Do You Yahoo!?
Get your free @yahoo.com address at http://mail.yahoo.com