Board index » cppbuilder » convert old c++ to new borland builder c++

convert old c++ to new borland builder c++

I am learning opengl in c++ and useing borland builder to compile it,
how would i go about converting it to be used with the full capabilty of
builder so that i can have my click at once buttons and object inspector
and so on, I have the base intisation code from a tutrioal that ints the
gl window i want to convert it to c++ builder so it displays on the form
i think figured out some of it but the pixelformat really comfuses me,
here is the c++ code for the opengl, I got it off of nehe.gamedev.net
really cool tutorial there.
i dont think my version of the code is that helpful i just turned alot
of theses into funtions and called them from the event oncreate but
there some things that need to be changed that are beyond me. Thanks to
anyone to helps

this is lesson 1
i really suggest if you would like to help to cut and paste this into a
new doc

/*
 *              This Code Was Created By Jeff Molofee 2000
 *              A HUGE Thanks To Fredric Echols For Cleaning Up
 *              And Optimizing This Code, Making It More Flexible!
 *              If You've Found This Code Useful, Please Let Me Know.
 *              Visit My Site At nehe.gamedev.net
 */

#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

#include <vcl.h>         // VCL.H Added by Patrick Salmons
                         // For C++ Builder 4 Compatibility on
06/03/2000
                         // Header File For The Visual Class Library
USELIB ("glaux.lib");    // GLAUX.LIB Added by Patrick Salmons
                         // A recompile of the Auxilary Graphics Library
not issued with C++ Builder 4

HDC             hDC=NULL;               // Private GDI Device Context
HGLRC           hRC=NULL;               // Permanent Rendering 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

Quote
}

int InitGL(GLvoid)                                                                              // All Setup For OpenGL Goes Here
{
        glShadeModel(GL_SMOOTH);                                                        // Enable Smooth Shading
        glClearColor(0.0f, 0.0f, 0.0f, 0.5f);                           // Black Background
        glClearDepth(1.0f);                                                                     // Depth Buffer Setup
        glEnable(GL_DEPTH_TEST);                                                        // Enables Depth Testing
        glDepthFunc(GL_LEQUAL);                                                         // The Type Of Depth Testing To Do
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Really Nice
Perspective Calculations
        return TRUE;                                                                            // Initialization Went OK

Quote
}

int DrawGLScene(GLvoid)                                                                 // Here's Where We Do All The Drawing
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear Screen And
Depth Buffer
        glLoadIdentity();                                                                       // Reset The Current Modelview Matrix
        return TRUE;                                                                            // Everything Went OK

Quote
}

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
        }

Quote
}

/*      This Code Creates Our OpenGL Window.  Parameters Are:                                   *
 *      title                   - Title To Appear At The Top Of The Window                              *
 *      width                   - Width Of The GL Window Or Fullscreen Mode                             *
 *      height                  - Height Of The GL Window Or Fullscreen Mode                    *
 *      bits                    - Number Of Bits To Use For Color (8/16/24/32)                  *
 *      fullscreenflag  - Use Fullscreen Mode (TRUE) Or Windowed Mode (FALSE)
*/

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 Size, 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;                                                                                   // 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,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
                {
                        // If The Mode Fails, Offer Two Options.  Quit Or Use Windowed Mode.
                        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;               // Windowed Mode Selected.  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;                                                                   // 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

        // Create The Window
        if (!(hWnd=CreateWindowEx(      dwExStyle,                                                      // Extended Style For The
Window
                                                                "OpenGL",                                                     // Class Name
                                                                title,                                                          // Window Title
                                                                dwStyle |                                                       // Defined Window Style
                                                                WS_CLIPSIBLINGS |                                       // Required Window Style
                                                                WS_CLIPCHILDREN,                                        // Required Window Style
                                                                0, 0,                                                           // Window Position
                                                                WindowRect.right-WindowRect.left,       // Calculate Window Width
                                                                WindowRect.bottom-WindowRect.top,       // Calculate Window Height
                                                                NULL,                                                           // No Parent Window
                                                                NULL,                                                           // No Menu
                                                                hInstance,                                                      // Instance
                                                                NULL)))                                                         // Dont 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
...

read more »

 

Re:convert old c++ to new borland builder c++


well i found what i was looking for, someone has tutorial for it at

http://www.bytamin-c.com/

check it out

Re:convert old c++ to new borland builder c++


C++Builder can compile that code......

No need to convert it, actually it's better, becuase it'll
be around 60KB...... In VCL it would be
around 260KB in size.....

Other Threads