[C++ Error] Unit1.h(30): E2303 Type name expected
[C++ Error] Unit1.h(30): E2139 Declaration missing ;
[C++ Error] Unit1.cpp(18): E2268 Call to undefined function '_control87'
[C++ Error] Unit1.cpp(18): E2451 Undefined symbol 'MCW_EM'
[C++ Error] Unit1.cpp(39): E2268 Call to undefined function 'SetupRC'
[C++ Error] Unit1.cpp(43): E2316 '_fastcall TForm1::SetupRC()' is not a member of 'TForm1'

Den Sourcecode habe ich hier:

//die unit.h
#include <vcl.h>
//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <gl/gl.h> 
#include <gl/glu.h>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
void __fastcall FormCreate(TObject *Sender); 
    void __fastcall FormDestroy(TObject *Sender); 
    void __fastcall FormResize(TObject *Sender);
    void __fastcall FormPaint(TObject *Sender); 

private:	// User declarations
HDC hdc; 
    HGLRC hrc;
    int PixelFormat;

public:		// User declarations

    fastcall TForm1(TComponent* Owner);
    void __fastcall IdleLoop(TObject*, bool&);
    void __fastcall RenderGLScene(); 
    void __fastcall SetPixelFormatDescriptor();

        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

//die cpp
//---------------------------------------------------------------------------
//--------------------------------------------------------------------------- 

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) 
    : TForm(Owner) 
{ 
    Application->OnIdle = IdleLoop;
    _control87(MCW_EM, MCW_EM);
}
//--------------------------------------------------------------------------- 
void __fastcall TForm1::IdleLoop(TObject*, bool& done) 
{ 
     done = false; 
     RenderGLScene(); 
     SwapBuffers(hdc); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TForm1::RenderGLScene() 
{ 
     //Place your OpenGL drawing code here 
} 
//--------------------------------------------------------------------------- 
void __fastcall TForm1::FormCreate(TObject *Sender) 
{ 
    hdc = GetDC(Handle); 
    SetPixelFormatDescriptor(); 
    hrc = wglCreateContext(hdc); 
    wglMakeCurrent(hdc, hrc); 
    SetupRC();
}
//--------------------------------------------------------------------------- 
void __fastcall TForm1::SetupRC() 
{ 
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f); 
    glClear(GL_COLOR_BUFFER_BIT); 
    glFlush(); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TForm1::FormDestroy(TObject *Sender) 
{ 
    ReleaseDC(hdc);
    wglMakeCurrent(hdc, NULL); 
    wglDeleteContext(hrc); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TForm1::SetPixelFormatDescriptor() 
{ 
    PIXELFORMATDESCRIPTOR pfd = { 
        sizeof(PIXELFORMATDESCRIPTOR), 
        1, 
        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, 
        PFD_TYPE_RGBA, 
        24, 
        0,0,0,0,0,0, 
        0,0, 
        0,0,0,0,0, 
        32, 
        0, 
        0, 
        PFD_MAIN_PLANE, 
        0, 
        0,0,0 
        }; 
    PixelFormat = ChoosePixelFormat(hdc, &pfd); 
    SetPixelFormat(hdc, PixelFormat, &pfd); 
} 
//--------------------------------------------------------------------------- 
void __fastcall TForm1::FormResize(TObject *Sender) 
{ 
    GLfloat nRange = 200.0f; 
    glViewport(0, 0, ClientWidth, ClientHeight); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity(); 

    if (ClientWidth <= ClientHeight) 
       glOrtho(-nRange, nRange, -nRange*ClientHeight/ClientWidth, 
                nRange*ClientHeight/ClientWidth, -nRange, nRange); 
    else 
       glOrtho(-nRange*ClientWidth/ClientHeight, nRange*ClientWidth/ClientHeight, 
                -nRange, nRange, -nRange, nRange); 

    glMatrixMode(GL_MODELVIEW); 
    glLoadIdentity(); 
} 
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

Ich benutze den BCB 5 Enterprise.

bleiben über.
hast du noch ne Idee?

Edit:
ReleaseDC() kannst du dir zur Not auch noch in der Hilfe ansehen oder in der MSDN im Netz. Dann weißt du auch was da noch fehlt.

P.S. Der Link aus dem FAQ-Beitrag für OpenGL klappt funktioniert nicht bzw. die URL ist falsch. Folgende URL wird bei mir auf gerufen http://www.c-plusplus.net/forum/topic,39422.html es sollte aber http://www.c-plusplus.net/forum/viewtopic.php?t=39422.html heißen

Was will der jetzt?

und was muss alles bei den opengl drawcode alles rein?

Nur die Opengl Befehle?

glTranslatef(-2.0f,0.0f,-6.0f);

glBegin(GL_TRIANGLES); // Ein Dreieck soll gezeichnet werden
glColor3f(0.0f,0.0f,1.0f); // es soll soll blau werden
glVertex3f( 0.0f, 1.0f, 0.0f); // Die obere Ecke des Dreiecks
glVertex3f(-1.0f,-1.0f, 0.0f); // unten links
glVertex3f( 1.0f,-1.0f, 0.0f); // unten rechts
glEnd();

oder noch alle glLoadidenty etc?

Gegen deine Fragen zu OpenGL empfehle ich die Tutorials von NeHe, die sind web-weit bekannt und auch ausreichend.

ps.: ich dachte ich hätte den link hier irgendwo im forum gefunden weis aber net mehr wo

pps.: die kommentare in deinem post sehen stark nach diesem tutorial aus

Die *.h habe ich in den Standard Include Verzeichnis gepackt,die Libs in ein extra Ordner den Ordner in Projectoptions unter Bedingung bei den Libs angegeben.

Nur der Linker macht nachwievor Stress.

Edit: Rechtschreibung...

Nix Bild bleibt grau.

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
	glLoadIdentity();

	glBegin( GL_TRIANGLES ); // Ein Dreieck soll gezeichnet werden

		glColor3f( 0.0f,0.0f,1.0f ); // es soll soll blau werden
		glVertex3f(  0.0f,  1.0f, 0.0f ); // Die obere Ecke des Dreiecks
		glVertex3f( -1.0f, -1.0f, 0.0f ); // unten links
		glVertex3f(  1.0f, -1.0f, 0.0f ); // unten rechts

	glEnd();
	glFinish();

	glFlush();
	SwapBuffers( g_Win.GetHDC() );

MfG Aoeke

Versuchs mal mit dieser Version, ich hab sie ein bischen umgemodelt. Ein Teil der Methoden waren nicht nötig. Zusätzlich hab ich eine Methoe hinzugefügt die ein Koordinatensystem zeichnet, um zu testen ob es funktioniert.

Vielleicht kann man den FAQ-Beitrag ja dahingehend anpassen? (Getestet auf BCB 5 Prof. und BCB 6 Enterprise)

Form1.h

//---------------------------------------------------------------------------

#ifndef frmOpenglH
#define frmOpenglH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <gl/gl.h>
#include <gl/glu.h>
#include <gl/glaux.h>

//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
	void __fastcall FormCreate(TObject *Sender);
	void __fastcall FormDestroy(TObject *Sender);
	void __fastcall FormPaint(TObject *Sender);
	void __fastcall FormResize(TObject *Sender);

private:	// User declarations
	HDC dc;
	HGLRC GLContext;
	HDC InitOpenGL(HWND Handle);

public:		// User declarations
	__fastcall TForm1(TComponent* Owner);
	void drawScene (void);
	void CoordinateSystem(GLdouble x, GLdouble y, GLdouble z);

};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif
// ein paar Farben
const GLfloat colRed[]	= {1, 0, 0},
	colGreen[]     = {0, 1, 0},
	colBlue[]      = {0, 0, 1},
	colYellow[]    = {1, 1, 0},
	colDarkGray[]  = {0.2, 0.2, 0.2},
	colGray[]      = {0.5, 0.5, 0.5},
	colLightGray[] = {0.8, 0.8, 0.8},
	colBlack[]     = {0, 0, 0};

Form1.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include <float.h> //für _control87()
#include "Form1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
	// Floatingpointeinheit initialisieren
	_control87(MCW_EM, MCW_EM);
}
//---------------------------------------------------------------------------
// OpenGl Devicekontext initialisieren
HDC TForm1::InitOpenGL(HWND Handle)
{
    PIXELFORMATDESCRIPTOR pfd;

    memset(&pfd, 0, sizeof(pfd));

    pfd.nSize      = sizeof(PIXELFORMATDESCRIPTOR);
    pfd.nVersion   = 1; // Versionsnummer, 1 notwendig

    pfd.dwFlags    = PFD_DRAW_TO_WINDOW | // Zeichne in ein Fenster
		             PFD_SUPPORT_OPENGL;  // OpenGL anstelle von GDI

    pfd.dwFlags   |= PFD_DOUBLEBUFFER; // flag setzen

    pfd.iPixelType = PFD_TYPE_RGBA; // RGBA Pixel
    pfd.cColorBits = 24; // Farbtiefe 24 Bit
    pfd.cDepthBits = 32; // Tiefenpuffer 32 Bits
    pfd.iLayerType = PFD_MAIN_PLANE; // Einzige Möglichkeit

    HDC dc  = GetDC(Handle);
    int iPF = ChoosePixelFormat(dc, &pfd);

    if (iPF == 0)
        ShowMessage("Fehler bei ChoosePixelFormat");

    SetPixelFormat(dc, iPF, &pfd);
    GLContext = wglCreateContext(dc);

    if (GLContext)
        wglMakeCurrent(dc, GLContext);
    else
        ShowMessage("wglMakeCurrent nicht erfolgreich");

    return dc;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
    dc = InitOpenGL(Handle);
    glEnable(GL_DEPTH_TEST);
    //Hintergrundfarbe setzen (weis)
    glClearColor(1, 1, 1, 1);

    glMatrixMode(GL_MODELVIEW);

    //Auf Z-Achse um 4 nach hinten verschieben
    glTranslated(0, 0, -4);
    glLineWidth(1);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)
{
    ReleaseDC(Handle,dc);
    wglMakeCurrent(dc, NULL);
    wglDeleteContext(GLContext);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
{
    FormResize(Sender);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormResize(TObject *Sender)
{
    glViewport(0, 0, ClientWidth, ClientHeight);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    GLdouble aspect =(double)ClientWidth/ClientHeight;
    gluPerspective(60, aspect, 0.1, 100);

    glMatrixMode(GL_MODELVIEW);
    drawScene();
}
// Koordinatensystem zeichnen
void TForm1::CoordinateSystem(GLdouble x, GLdouble y, GLdouble z)
{
    glBegin(GL_LINES);
        glColor3fv(colRed);
        glVertex3d(-x, 0, 0);
        glVertex3d(x, 0, 0);
        glColor3fv(colGreen);
        glVertex3d(0, -y, 0);
        glVertex3d(0, y, 0);
        glColor3fv(colBlue);
        glVertex3d(0, 0, z);
        glVertex3d(0, 0, -z);
    glEnd();

    double h=0.05;

    glBegin(GL_TRIANGLES); // Pfeil am Ende der X-Achse
        glColor3fv(colRed);
        glVertex3d(x-h, h, 0);
        glVertex3d(x, 0, 0);
        glVertex3d(x-h, -h, 0);
    glEnd();

    glBegin(GL_TRIANGLES); // Pfeil am Ende der Y-Achse
        glColor3fv(colGreen);
        glVertex3d(+h, y-h, 0);
        glVertex3d(0, y, 0);
        glVertex3d(-h, y-h, 0);
    glEnd();

    glBegin(GL_TRIANGLES); // Pfeil am Ende der Z-Achse
        glColor3fv(colBlue);
        glVertex3d(0, +h, z-h);
        glVertex3d(0, 0, z);
        glVertex3d(0, -h, z-h);
    glEnd();
}

// Szene zeichnen
void TForm1::drawScene (void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //Koordinatensystem zeichnen
    CoordinateSystem(1.0, 1.0, 1.0);

    SwapBuffers(dc);
}