Discussion :

[Rian83]

Bonsoir a tous,

Je viens vous voir car mon partenaire et moi sommes a la ramasse.

On voudrait a l'aide d'un fichier .obj en texte prendre chaque points et les placer en 3D donc avec LablGl. Apres apres conception de ce petit code TEST cela ne fonctionne pas, j'ai un affichage "buge" (par exemple si je met mon shell derriere, la fenetre va avoir les ecriture du shell et si je la deplace elle va les garder ^^)
Et j'ai meme pas les quelques points ...


Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
let idList =
  GlList.create `compile;;
 
 
let addPoint x y z =
  GlDraw.begins `points;
  GlDraw.vertex3(x,y,z);
  GlDraw.ends();;
 
 
let renderScene =
  GlClear.clear[`color;`depth];
  GlClear.color(255.0,255.0,255.0);
 
  GlList.begins idList `compile; (* Commence une liste de dessin*)
 
  addPoint 0.0 0.0 1.0;
  addPoint 0.2 0.2 1.0;
  addPoint (-0.2) 0.2 1.0;
  addPoint 0.2 (-0.2) 1.0;
  addPoint (-0.2) (-0.2) 1.0;
 
  GlList.ends(); (* Une fois tous les points ajout	,
		  on termine la liste *)
 
  GlList.call(idList); (* Affiche toute la liste *)
  Gl.flush();;
 
 
let main =
  ignore(Glut.init Sys.argv);
  Glut.initDisplayMode ~alpha:true ~double_buffer:true ~depth:true ();
  Glut.initWindowPosition ~x:100 ~y:100;
  Glut.initWindowSize ~w:500 ~h:500;
  ignore(Glut.createWindow ~title:"Afficher un point");
  GlClear.color(1.,1.,1.);
  (*GlClear.color ~red:1. ~green:1. ~blue:1. ~alpha:1.;*)
 
 
  Glut.displayFunc ~cb:(fun () -> renderScene);
  Glut.mainLoop();;
 
let _ = main()

Et je l'execute avec : lablglut xxxx.ml


Si vous pouviez m'aider

Merci a tous, amicalement

[Rian83]

Petite nouveaute :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
let main =
  ignore(Glut.init Sys.argv);
  Glut.initDisplayMode ~alpha:true ~depth:true ();
  Glut.initWindowPosition ~x:100 ~y:100;
  Glut.initWindowSize ~w:500 ~h:500;
  ignore(Glut.createWindow ~title:"Afficher un point");
  (*GlClear.color ~red:1. ~green:1. ~blue:1. ~alpha:1.;*)
 
 
 
  Glut.displayFunc ~cb:
    begin fun () ->
      GlClear.color(0.0,255.0,0.0);
      GlClear.clear [`color];
      GlDraw.color(255.0,0.0,0.0);
      GlMat.mode `projection;
      GlMat.load_identity ();
      GlMat.ortho ~x:(0.0,0.0) ~y:(0.0,0.0) ~z:(0.0,0.0);
      GlDraw.point_size 10.;
      GlDraw.begins `points;
      GlDraw.vertex3((-1.),(-1.),(-1.));
      GlDraw.vertex3((1.),(-1.),(-0.5));
      GlDraw.vertex3((1.),(1.),(0.5));
      GlDraw.vertex3((-1.),(1.),(1.));
      GlDraw.ends();
      Gl.flush()
    end;
 
  Glut.mainLoop();;
 
let _ = main()

Cela m'affiche 4 points rouge sur fond vert (normal ^^) met dans les 4 angles ^o)
Et je n'arrive pas a ce qu'ils soient ailleurs, j'ai essayer de gerer GlMat.ortho mais je n'y comprends rien a cette fonction.

Pouvez vous m'aider ?

Amicalement Rian

[Rian83]

UP ?

[adtunum]

Bon désolé pour la réponse tardive, je ne sais pas si tu as résolu tes problèmes depuis, mais comme il n'y a pas de suite, je réponds tout de même. Sinon concernant l'OpenGL généralement il y a peu de réponses sur le forum OCaml, si tu as d'autre question OpenGL tu auras plus de succès sur le forum OpenGL.

Il y a plusieurs problèmes avec ce bout de code.
Je vais commencer par le fait que renderScene est un scalaire et non une function.
OCaml ne s'en plaint pas car au niveau typage il n'y a pas d'incohérence puisqu'il vaut unit et qu'il est fournit là où il faut unit. cependant l'ensemble des commandes qu'il contient ne seront exécutées qu'une seule fois lorsque ce lien sera calculé. Pour mieux me faire comprendre voici un exemple équivalent, ci-dessous, le lien 'a' est lié à la valeur entière 19, mais entretemps une commande d'IO est exécutée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
# let a =
    print_endline "defining a";
    (19)
  ;;
defining a
val a : int = 19
# a ;;
- : int = 19

C'est la même chose avec 'renderScene', il faut remplacer "let renderScene =" par "let renderScene = function () ->" ou bien "let renderScene () =".

Et de la même manière il faudra remplacer "Glut.displayFunc ~cb: (fun () -> renderScene);" par "Glut.displayFunc ~cb: (fun () -> renderScene());" ou plus simplement "Glut.displayFunc ~cb:renderScene;".

Une autre erreur, mineure celle-ci, est de donner à GlClear.color (glClearColor) des valeurs supérieures à 1.0.

Une autre erreur conceptuelle dans le callback display est de définir la display list à chaque fois, et non une seule fois au départ. Il y a plusieurs façon de gérer la chose, soit compiler la list dans une fonction séparée du callback display et appeler cette fonction qu'une seule fois lors de l'initialisation d'OpenGL, soit définir globalement idList comme ref None et dans le callback d'affichage matcher sa valeur, si None compiler puis définir idList comme Some _list, et lorsqu'on match sur Some appeler GlList.call.

Il y a une erreur dans l'utilisation conjointe des deux fonctions GlList.create et GlList.begins. Soit on utilise GlList.gen_lists puis GlList.begins soit on utilise GlList.create, puisque cette dernière est définie comme suit dans le source de lablgl (fichier src/glList.ml) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
let create mode =
  let l = gen_lists ~len:1 in begins l ~mode; l

Lors de l'initialisation de glut tu définit ~double_buffer:true cependant à la fin du callback d'affichage tu n'appèles pas Glut.swapBuffers. Deplus Glut.postRedisplay n'est jamais appelé à aucun endroit il en résulte que le callback d'affichage n'est appelé qu'une fois (avec renderScene transformé en fonction évidement).

Ensuite tu définis comme couleur de fond du blanc, mais tu ne définis aucune couleur pour le dessin, or en OpenGL par défaut le fond est noir et les primitives en blanc. Il en résulte que tu dessines en blanc sur fond blanc, donc on ne voit rien.

Sinon c'est pas une erreur mais c'est maladroit, tu appèles chaque coordonnées dans un glBegins `points, il vaudrait mieux grouper tous les points dans une liste ou un tableau puis faire un seul Array.iter ou List.iter GlDraw.vertex3 points; à l'intérieur d'un seul GlDraw.begins `points.

Voici l'équivalent avec ces divers corrections :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
let idList = ref None
 
let addPoints pnts =
  GlDraw.begins `points;
  List.iter GlDraw.vertex3 pnts;
  GlDraw.ends();;
 
 
let renderScene() =
  GlClear.clear[`color;`depth];
 
  begin match !idList with
  | None ->
      let _list = GlList.create `compile_and_execute in
 
      GlDraw.color (0.0, 0.0, 0.0);
      addPoints [ 0.0, 0.0, 1.0;
                  0.2, 0.2, 1.0;
                  (-0.2), 0.2, 1.0;
                  0.2, (-0.2), 1.0;
                  (-0.2), (-0.2), 1.0 ];
 
      GlList.ends(); (* Une fois tous les points ajout,
                        on termine la liste *)
 
      idList := Some _list;
 
  | Some idList ->
      GlList.call idList; (* Affiche toute la liste *)
  end;
 
  Gl.flush();
  Glut.swapBuffers();
  Glut.postRedisplay();
;;
 
let () =
  ignore(Glut.init Sys.argv);
  Glut.initDisplayMode ~alpha:true ~double_buffer:true ~depth:true ();
  Glut.initWindowPosition ~x:100 ~y:100;
  Glut.initWindowSize ~w:500 ~h:500;
  ignore(Glut.createWindow ~title:"Afficher un point");
  GlClear.color(1.0,1.0,1.0);
  Glut.displayFunc ~cb:renderScene;
  Glut.keyboardFunc ~cb:(fun ~key ~x ~y -> if key = 27 then exit 0);
  Glut.mainLoop();;

ici on a à la fois Glut.postRedisplay et `compile_and_execute (et non juste `compile). Dans cette version du script en fait on pourait se contenter de l'un ou l'autre uniquement. Si on enlève Glut.postRedisplay on affichera qu'une seule frame, donc il faut `compile_and_execute sinon juste la compilation n'affichera rien. Tel qu'est ce code il n'y a pas d'animation donc Glut.postRedisplay n'est pas vraiement nécessaire, seulement si on prend la peine de créer une display list c'est qu'on cherche à optimiser l'affichage des frames suivantes donc qu'on souhaite faire une animation quelconque. Glut.postRedisplay peut être utilisé à divers endrois, soit à la fin du callback d'affichage ce que l'on vois souvent en OpenGL, soit dans un callback d'interaction avec l'utilisateur après avoir changé un paramètre qui affecte l'affichage, soit encore dans un timer (qui lui aussi change des paramètres affectant l'affichage).

Sinon voici l'autre solution avec la display list compilée dans une fonction séparée appelée à l'initialisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
let addPoints ~points =
  GlDraw.begins `points;
  Array.iter GlDraw.vertex3 points;
  GlDraw.ends();;
 
 
let compile_list () =
  let idList = GlList.create `compile in (* Commence une liste de dessin *)
 
  GlDraw.color (0.0, 0.0, 0.0);
 
  addPoints [| 0.0, 0.0, 1.0;
               0.2, 0.2, 1.0;
               (-0.2), 0.2, 1.0;
               0.2, (-0.2), 1.0;
               (-0.2), (-0.2), 1.0 |];
 
  GlList.ends(); (* Une fois tous les points ajout,
                    on termine la liste *)
  (idList)
;;
 
 
let renderScene idList () =
  GlClear.clear[`color;`depth];
  GlList.call idList; (* Affiche toute la liste *)
  Gl.flush();
  Glut.swapBuffers();
  Glut.postRedisplay();;
 
 
let () =
  ignore(Glut.init Sys.argv);
  Glut.initDisplayMode ~alpha:true ~double_buffer:true ~depth:true ();
  Glut.initWindowPosition ~x:100 ~y:100;
  Glut.initWindowSize ~w:500 ~h:500;
  ignore(Glut.createWindow ~title:"Afficher un point");
  GlClear.color(1.,1.,1.);
 
  let idList = compile_list() in
 
  Glut.displayFunc ~cb:(renderScene idList);
  Glut.mainLoop();;

Sinon pour finir je me permet de signaler que glMLite supporte désormais les VBOs (qui est la méthode la plus performante pour afficher les primitives) et que c'est le seul binding avec lequel on peut les utiliser. En effet les VBOs sont totalement absentes de LablGL et dans glcaml les fonctions sont présentes mais ne peuvent fonctionner car glcaml utilise un générateur de code qui ne fait pas la différence entre les pointeurs C qui sont des paramètres ou qui renvoient un résultat.