OpenGl et C++ Builder (XE6)

Version imprimable

11/04/2018, 12h30
Pasqualini

OpenGl et C++ Builder (XE6)

Bonjour,
quelqu'un a-t-il utilisé OpenGl avec C++ Builder ?
Suffit-t-il d'ajouter les fichiers *.lib et *.h nécessaire,
ou faut-il également charger un logiciel supplémentaire ?
Et dans ce cas quel logiciel ?
Merci
12/04/2018, 20h01
Mat.M

bonsoir oui les fichiers .lib suffisent et sans doute on peut se passer des fichiers .h
Il faut créer un projet win32 et non utilisant la VCL
Mais utiliser la VCL avec Open GL ça doit être possible également ; chercher sur Internet il doit exister certainement des "wrappers"
13/04/2018, 10h34
Pasqualini

Citation:

Envoyé par Mat.M

bonsoir oui les fichiers .lib suffisent et sans doute on peut se passer des fichiers .h
Il faut créer un projet win32 et non utilisant la VCL
Mais utiliser la VCL avec Open GL ça doit être possible également ; chercher sur Internet il doit exister certainement des "wrappers"

Merci,
dois je comprendre qu'il me suffirait d'inclure les 2 ou 3 fichiers lib pour pouvoir utiliser OpenGl ?
Je vais essayer et vous dirais ce qui se passe.
13/04/2018, 13h24
Lung

Citation:

Envoyé par Mat.M

Il faut créer un projet win32 et non utilisant la VCL

Qu'est ce que tu veux dire ? Je ne comprends pas ?
Du temps où je faisais des projets opengl, mes projets étaient VCL (sous delphi, mais c'est pareil).
13/04/2018, 15h40
Mat.M

@Lung avec Delphi ou C++ Builder on peut faire des projets soit avec la VCL pour gérer les fenêtres et autres classes soit des programmes win32 "nus" où il faut tout gérer.
14/04/2018, 11h43
Pasqualini

Il est en effet possible d'utiliser OpenGl avec un projet VCL.
Comme Lung a utilisé OpenGl, je lui demanderai probablement une aide.
Le remerciant par avance.

Je m'étais contenté d'ajouter les bibliothèques utiles dans les uses.

Sinon, voici un exemple d'initialisation (c'est du delphi) dans un de mes vieux projet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
   InitOpenGL(FormGL.Canvas.Handle, 32, True);
 
...
 
function TFormGL.InitOpenGL(const DC: HDC; const nColorBits: Integer; const bDoubleBuffer, bAffMsg: Boolean): Boolean;
var
   PFD: TPixelFormatDescriptor;
   nPixelFormat: Integer;
   szErreur: String;
begin
   // Initialisation de la structure d'information sur le PFD.
   FillChar(PFD, SizeOf(PFD), 0);
   with PFD do
   begin
      nSize := Sizeof(TPixelFormatDescriptor);
      if bDoubleBuffer then
         dwFlags := PFD_DOUBLEBUFFER or PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL
      else
         dwFlags := PFD_DRAW_TO_WINDOW or PFD_SUPPORT_OPENGL;
      iPixelType := PFD_TYPE_RGBA;
      nVersion := 1;
      cColorBits := nColorBits;
      cdepthBits := 16;
      cRedBits := 0;
      cRedShift := 0;
      cGreenBits := 0;
      cGreenShift := 0;
      cBlueBits := 0;
      cBlueShift := 0;
      cAlphaBits := 0;
      cAlphaShift := 0;
      cAccumBits := 0;
      cAccumRedBits := 0;
      cAccumGreenBits := 0;
      cAccumBlueBits := 0;
      cAccumAlphaBits := 0;
      cStencilBits := 24;
      cAuxBuffers := 0;
      iLayerType := PFD_MAIN_PLANE;
      bReserved := 0;
      dwLayerMask := 0;
      dwVisibleMask := 0;
      dwDamageMask := 0;
   end;
 
   // Récupération du DC passé en paramètre, dans une variable Globale.
   _hDCGlobal := DC;
 
   // Choix du PFD adapté pour le DC reçu en paramètre.
   nPixelFormat := ChoosePixelFormat(DC, @PFD);
 
   // Vérification si l'index du PFD supporté à été trouvé.
   Result := (nPixelFormat <> 0);
   if not Result Then
   begin
      szErreur := 'Erreur PFD :  ' + SysErrorMessage(GetLastError);
      ...
      Exit;
   end;
 
   // Vérification si le PFD trouvé peut être appliqué sur le DC.
   Result := SetPixelFormat(DC, nPixelFormat, @PFD);
   if not Result then
   begin
      szErreur := 'Erreur application PFD sur le DC :  ' + SysErrorMessage(GetLastError);
      ...
      Exit;
   end;
 
   // Vérification si OpenGL peut créer la passerelle qui lui permettra de dessiner sur ce DC.
   _GLContext := wglCreateContext(DC);
   Result := _GLContext <> 0;
   if not Result then
   begin
      szErreur := 'Erreur OpenGL (wglCreateContext):  ' + SysErrorMessage(GetLastError);
      ...
      Exit;
   end;
 
   // Vérification si OpenGL peut se servir de ce DC pour dessiner.
   Result := wglMakeCurrent(DC, _GLContext);
   if not Result then
   begin
      szErreur := 'Erreur OpenGL (wglMakeCurrent):  ' + SysErrorMessage(GetLastError);
      ..
      Exit;
   end;
 
   // Test des erreurs OpenGL.
   if TestErreur('Pré-initialisations OpenGL', bAffMsg) then
      _bErreurInit := True;
end;

Je ne dis pas que c'est parfait, mais c'est pour donner des idées ...

Merci, l’adaptation à C++ Builder ne doit poser aucun problème.

J'ai essayé d'adapter un programme Opengl, ,que j'ai trouvé sur Internet.
Il s'agit de créer une "éponge de Menger".
C'est une fractale tridimensionnelle.

Je bute sur une difficulté. Elle est due aux fonctions glut....:
Code:

1 2 3 4 5 6 7 8 9 10 11 glutInit(&argc, argv); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); glEnable(GL_DEPTH_TEST); glutInitWindowSize(500,500); glutInitWindowPosition(0,0); glutCreateWindow(*argv); glutReshapeFunc(reshape); glutDisplayFunc(display); glutIdleFunc(idle); glutMainLoop();
Je n'ai pas trouvé le glut.h et la librairie qui lui correspond.
Peu-t-on réaliser les mêmes opérations sans glut.. ?
Pouvez vous me secourir ?
Merci.