hello.
I’ve been using BCB5 for OpenGL development for more than a year now and basically there’s nothing special about it.
The only library you’ll need in any case is the Opengl32.lib from the Microsoft Platform SDK which is located in <install dir>\CBuilder5\lib\PSDK. CBuilder finds this one automatically, so there’s nothing you have to do to make this work. All you need to do to use OpenGL commands is a simple #include <gl/gl.h> (and <gl/glu.h> if you want to use utils).
When it comes to constructing the rendering loop and doing the OpenGL setup, there are different ways. GLUT requires the least number of code lines but is the most troublesome. C++ Builder is built to be a RAD tool which means that it is tightly bound with the VCL (visual control library, something like MFC, but usable). Getting rid of the VCL in a BCB project is hard. If you don’t need to get your app fully portable or absolutely can’t have the ~3MB vcl-DLLs which have to be present, so your app will run, don’t bother.
If you start with a standard project in BCB, there’s 3 things you’ll need to do:
(1) Include the gl.h/glu.h headers.
(2) Set up OpenGL. This includes the most Windows-specific stuff and works as follows:
(a) Set the PixelFormatDescriptor:
/* This gets the Device Context for your Window’s handle. Handle is a property of the TWinControl class from which TForm descends. /
HDC hDC = GetDC(Handle);
/ Set up a PIXELFORMATDESCRIPTOR structure. The details of this struct are documented in the Windows Platform SDK (BCB-Menu Help->Windows SDK). /
PIXELFORMATDESCRIPTOR pfd = {…};
/ Choose the PixelFormat. If the returned value is 0, an error has occured /
int PixelFormat = ChoosePixelFormat(hDC,&pfd);
/ SetPixelFormat returns TRUE or FALSE. */
BOOL res = SetPixelFormat(hDC, PixelFormat, &pfd);
(b) Create an OpenGL rendering context and make it current:
/* This creates an OpenGL rendering context and returns a handle to it. If it returns NULL, an error has occured. /
HGLRC hRC = wglCreateContext(hDC);
/ Now make the rendering context current. You have to do this before issuing ANY gl* command. */
res = wglMakeCurrent(hDC,hRC);
© Set up the projection matrix. This is already pure OpenGL stuff, Use either glOrtho or gluPerspective.
(3) Do the rendering:
For this you can use a timer or some other mechanism to call your rendering procedure. If you want to create a loop that uses all available resources to render as fast as possible a good idea is to overwrite the Application’s OnIdle event. Every BCB project has a global variable called Application of type TApplication. To set up your own OnIdle event, do the following:
(a) Add a method of suitable type to your form like this:
void __fastcall MyForm::MyIdleEvent(System::TObject* Sender, bool &Done);
(b) Assign the event:
Application->OnIdle = MyIdleEvent;
All Done.
Whenever the Application is idle, your MyIdleEvent procedure will be called. There are two things I’d suggest to include. One ist the parameter &Done. If you set this to false, your application will not release control to other applications but will immediately check, if there’s work to do and, if not, call your IdleEvent again. If you do this, however, I’d suggest adding the line Application->ProcessMessages(). If you don’t, none of your application’s messages will be processed.
All together a generously spaced imlementation of the above take somewhere between 80 and 100 lines including comments, procedure declarations and everything else.
One last word on GLUT. Until today I couldn’t manage to cleanly include GLUT into my OpenGL application. When i need a fast way for simple spheres or the likes, I use quadrics from GLU.
hope this helps. It’s a long read but the implementation is really simple, fast and straightforward.