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
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

#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
                         // 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


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

        glMatrixMode(GL_MODELVIEW);                                                     // Select The Modelview Matrix
        glLoadIdentity();                                                                       // Reset The Modelview Matrix


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


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


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

                if (!wglDeleteContext(hRC))                                             // Are We Able To Delete The RC?
                        MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN
                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
                hDC=NULL;                                                                               // Set DC To NULL

        if (hWnd && !DestroyWindow(hWnd))                                       // Are We Able To Destroy The
                MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK |
                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 |
                hInstance=NULL;                                                                 // Set hInstance To NULL


/*      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
        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;                         // Set Top Value To 0
        WindowRect.bottom=(long)height;         // Set Bottom Value To Requested

        fullscreen=fullscreenflag;                      // Set The Global Fullscreen Flag

        hInstance                       = GetModuleHandle(NULL);                                // Grab An Instance For Our
Window                        = 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
                MessageBox(NULL,"Failed To Register The Window
                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

                // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN
Gets Rid Of Start Bar.
                        // 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
                                fullscreen=FALSE;               // Windowed Mode Selected.  Fullscreen = FALSE
                                // Pop Up A Message Box Letting User Know The Program Is Closing.
                                MessageBox(NULL,"Program Will Now
                                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
                dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;                   // Window Extended
                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
                                                                "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
                                                      ,       // 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
                return FALSE;                                                           // Return FALSE

        static  PIXELFORMATDESCRIPTOR pfd=                              // pfd Tells Windows How We Want
Things To Be
                sizeof(PIXELFORMATDESCRIPTOR),                          // Size Of This Pixel Format
                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

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