(* ============================================================================== *)
(* === Projet ocamlpilot - CG version du 19/04/2005                           === *)
(* ===                                                                        === *)
(* === Ce programme montre comment savoir quelles touches du clavier sont     === *)
(* === appuyees a un instant donne.                                           === *) 
(* ============================================================================== *)



(* ============================================================================== *)
(* === initialisation d'openGL a faire pour chaque programme                  === *)
(* ============================================================================== *)

(* on recupere les arguments specifiques a OpenGL transmis sur la ligne de commande *)
ignore(Glut.init Sys.argv);;

(* initialisation du mode d'affichage :
   alpha : permet de jouer sur la luminosite des objets
   double_buffer : on travaille en double buffering, comme en 2D
   depth : on utilise le Z-buffer pour supprimer les parties cachees *)
Glut.initDisplayMode ~alpha:true ~double_buffer:true ~depth:true ();;

(* taille de la fenetre a l'ouverture *)
Glut.initWindowSize ~w:800 ~h:600;;

(* creation de la fenetre et titre de la fenetre *)
ignore(Glut.createWindow "OcamlPilot");;




(* ============================================================================== *)
(* === gestion des touches clavier                                            === *)
(* ============================================================================== *)

(* on cree un tableau de booleens initialise a false qui indique que toutes les
   touches du clavier sont relachees *)
let touches_normales  = Array.make 256 false;;
let touches_speciales = Array.make   6 false;;


(* la fonction qui met a jour les tableaux ci-dessous : une fois appelee dans le
   main, cette fonction binde les touches clavier avec la mise a jour des booleens
   correspondant. Ensuite, c'est openGL qui s'occupe de tout pour vous. *)
let manage_keyboard () =
  (* keyboardFunc indique a openGL les actions qui doivent etre realisees lorsqu'une
     touche "normale" du clavier est enfoncee. Par normale, on entend les lettres,
     les chiffres, etc, mais pas le page up, page down, etc (voir ci-dessous).
     key = le code ascii de la touche enfoncee
     x,y = position de la souris au moment ou on a enfonce la touche *)
  Glut.keyboardFunc ~cb:(fun ~key ~x ~y -> touches_normales.(key) <- true);

  (* idem mais quand on relache la touche *)
  Glut.keyboardUpFunc ~cb:(fun ~key ~x ~y -> touches_normales.(key) <- false);

  (* quand on appuie sur une touche speciale. Pour voir lesquelles sont permises
     utiliser ocamlbrowser *)
  Glut.specialFunc
    ~cb:(fun ~key ~x ~y -> 
	   match key with
	     | Glut.KEY_LEFT ->      touches_speciales.(0) <- true
	     | Glut.KEY_RIGHT ->     touches_speciales.(1) <- true
	     | Glut.KEY_UP ->        touches_speciales.(2) <- true
	     | Glut.KEY_DOWN ->      touches_speciales.(3) <- true
	     | Glut.KEY_PAGE_UP ->   touches_speciales.(4) <- true
	     | Glut.KEY_PAGE_DOWN -> touches_speciales.(5) <- true
	     | _ -> ());

  (* quand on relache une touche speciale *)
  Glut.specialUpFunc
    ~cb:(fun ~key ~x ~y ->
	   match key with
	     | Glut.KEY_LEFT ->      touches_speciales.(0) <- false
	     | Glut.KEY_RIGHT ->     touches_speciales.(1) <- false
	     | Glut.KEY_UP ->        touches_speciales.(2) <- false
	     | Glut.KEY_DOWN ->      touches_speciales.(3) <- false
	     | Glut.KEY_PAGE_UP ->   touches_speciales.(4) <- false
	     | Glut.KEY_PAGE_DOWN -> touches_speciales.(5) <- false
	     | _ -> ());;



(* ============================================================================== *)
(* === affichage des touches enfoncees sur la console                         === *)
(* ============================================================================== *)
let rec affichage ~value =
  (* affichage des touches normales *)
  print_string "touches normales : ";
  for i = 0 to 255 do
    if touches_normales.(i) then Printf.printf "%c  " (char_of_int i)
  done;
  print_string "\n";

  (* affichage des touches speciales *)
  print_string "touches speciales : ";
  if touches_speciales.(0) then print_string "left  ";
  if touches_speciales.(1) then print_string "right  ";
  if touches_speciales.(2) then print_string "up  ";
  if touches_speciales.(3) then print_string "down  ";
  if touches_speciales.(4) then print_string "pg_up  ";
  if touches_speciales.(5) then print_string "pg_down  ";

  print_string "\n";
  flush Pervasives.stdout;
    
  Glut.timerFunc ~ms:1000 ~cb:affichage ~value:0;;


(* ============================================================================== *)
(* ============================================================================== *)
let main () =
  (* on binde le clavier *)
  manage_keyboard ();
     
  (* creation du timer *)
  Glut.timerFunc ~ms:1000 ~cb:affichage ~value:0;
  
  (* lancement de la boucle principale d'openGL. Ceci doit etre effectue en dernier
     car mainLoop ne rendra la main qu'a la fin de l'execution du programme. *)
  Glut.mainLoop ();;

main ();;