Blender (jusqu'à 2.49)
Python 
Script: créer des menus interactif avec les module Draw et BGL
 
    Début   Index
précédentPython: Patatoïdes (5) 
Python: shadows Suivant

Nous avons vu comment construire une surface reticulée en ajoutant des points dans l'espace et en les transformant au fur et à mesure en sommet. Mais on peut se poser la question suivante: est-il possible de récupérer les sommets dans une surface particulière. Cela ne pose aucun problème, il suffit d'utiliser la liste d'objet  faces. Ou eventuellement de travailler avec un réseau maillé carré. Nous remettons   les explications sur ce point particulier à plus tard (mais le lecteur impatient peut charger le  fichier: tst_mand007.blend  qui est copieusement documenté).

Le lecteur attentif et curieux remarquera qu'il y a dans cet exemple des curseurs et du texte qui ne font pas partie de l'interface habituelle de Blender.Il est  effectivement possible d'ajouter ses propres menus sur des fonds plus ou moins décorés (l'exemple le plus intéresssant ces dernier temps étant le "Shell Factory" ),

Cela est possible grâce à l'importation du module Draw.  Ce module offre des fonctions de base pour créer une vrai interface graphique à l'intérieur même de Blender. Il est constitué de deux parties, l'une d'elle supporte les fonctions et les variables necessaires à la gestion d'une fenêtre par le script, l'autre autorise le scrit  à faire usage des outils internes pour l'interfacage graphique (bouton, menus etc.).

Il faut bien comprendre que ce module permet surtout de prendre le contrôle de la fenêtre de script dans laquelle le script  a été lancé.

La fonction la plus importante est la fonction Draw.Register c'est elle qui permet d'indiquer quelles sont les fonctions du script qui contrôlent l'interface, généralement ce sont les fonctions draw, bevent et event .
 

#
# un script devrait finir par ces lignes:
#
....

def draw():
    global glisseur
    glClear(GL_COLOR_BUFFER_BIT)
    glRasterPos2d(100,320)
    Text(" Exemple de GUI ")
    slideur=Slider("glisseur :  ", 2, 140, 200, 200, 18, slideur.val, 0, 5)
    #....
    Button("Sortie", 1, 140, 10, 80, 19)
    #... 

def event(evt, val):
    if (evt== QKEY and not val): 
      Exit()

def bevent(evt):
    #... ici la gestion des "evt"
    if (evt==1):
      #chaque evenement possède un numéro, en fait il s'agit de la valeur qui 
      #se trouve juste après la cahine de caractère qui définit le nom, par exemple
      # "Sortie" pour le bouton qui est utilisé dans cette exemple.
       Exit()
   #...il peut y en avoir d'autres et cela vaut mieux!

Register(draw, event, bevent)
 

Ce qu'il faut remarquer: la fonction draw() ne passe pas d'argument. Si on veut modifier des paramétres ou des valeurs à l'intérieur de cette fonction il faut déclarer les variables qui les contiennent comme "global" . En python  les variables qui sont déclarées à l'intérieur de bloc sont crées et seulement utilisables dans ce bloc. A moins de les lier à l'ensemble du script par le code global.

Créer un script de "menu déroulant".

Le Module Draw possède une méthode Menu qui se décompose comme suit:

                                                      Menu(options, evenement, x, y, longueur, hauteur, defaut, [tuyau outil])

Les options sont les différents items que l'on trouvera dans le menu. Comme pour les autres boutons, ces options sont présentées entre guillemets.  Elle sont séparées par le caractère pipeline "|". La première de toutes est le titre, déclaré par %t. Viennent ensuite les boutons eux-même. Chaque bouton est défini par un Nom puis est suivi de son code de placement dans la liste %xN. Des options correctements définies ressembleraient à cela: "Titre %t | NomB1 %x1| NomB2 %x2 | NomB3 %x3".

Ce qu'il faut savoir et comprendre: c'est en cliquant  un des items du menu que l'on documente la variable val qui est elle attachée à l'objet menu. Dans l'exemple ci-dessus NomB1%x1 renverra la valeur 1 qui sera contenue par Menu.val, alors que NomB2%x2 renverra la valeur 2 et ainsi de suite. Il faudra utiliser ce résultat dans un test conditionnel du type :

 if (Menu.val==quelquechose):
                faitcecicela
elif (Menu.val==quelquechosededifferent):
                faitautrechose
à l'intérieur  de la fonction draw().

L'evenement est le numéro du bouton qui permettra de faire effectuer un test conditionnel par  la fonction de gestion des évènements, le plus souvent nommée bevent(). On peut donner la valeur d'évènement que l'on désire, il faut simplement faire attention à ne pas attribuer la même à un autre bouton.

Les valeurs x et y positionnent le bouton dans la fenêtre d'exécution du script.

Longueur, hauteur définissent les dimensions physiques du bouton.

Defaut, contient simplement la valeur par défaut du bouton.

[tuyau outil] une chaine de caractère attachée au bouton qui apparaîtra lorsque la souris passera au-dessus.


Nous nous contenterons de décrire les différents ingrédients nécessaires et l'ordre dans lequel on doit les déclarer. Notez que ce petit script est largement inspiré d'un fichier en téléchargement libre sur ftp://ftp.blender.nl/pub.
 
#importation des modules
import Blender
from Blender.Draw import *
from Blender.BGL import *
 

#cre'ation de l'objet bouton qui servira de support au menu de'roulant
menu= Create(2)
 

#de'finition de la fonction draw dans laquel sont effectue'es les ope'rations de dessins et d'affichage
def draw():

#globalisation de la variable
global menu
 

#choix de la couleur du fond de la fene^tre
glClearColor(1.0,1.0,0.5, 0.0)
#mise en couleur du fond de la fene^tre
glClear(GL_COLOR_BUFFER_BIT)

#re'serve un espace me'moire pour afficher un graphisme
bitmap= Buffer(GL_BYTE, (64, 64, 4))
#remplissage du graphisme avec des couleurs
for y in range(0, 64):
   for x in range(0, 64):

   #test conditionnel sur la valeur du bouton de menu
   if (menu.val==1):
      bitmap[y][x][0]= x*4
      bitmap[y][x][1]= y*4
      bitmap[y][x][2]= (x+y)/4

   elif (menu.val==2): 
      bitmap[y][x][0]= x*4
      bitmap[y][x][1]= y*4
      bitmap[y][x][2]= (128-x+y)/4

   elif (menu.val==3): 
      bitmap[y][x][0]= (64-x)*4
      bitmap[y][x][1]= (64-y)*4
      bitmap[y][x][2]= (x+y)/4

   elif (menu.val==4): 
      bitmap[y][x][0]= x*2
      bitmap[y][x][1]= (64-y)*4
       bitmap[y][x][2]= (x+y)/4

 #positionnement du curseur 2D
 glRasterPos2i(210, 200)

 #affichage du sprite
 glDrawPixels(64, 64, GL_RGBA, GL_UNSIGNED_BYTE, bitmap)

 #definition du menu 
 menu=Menu("Menu%t| Option 1%x1| Option 2%x2| Option 3%x3| Option 4%x4", 2, 170, 180, 100, 18, menu.val)

#bouton de sortie
Button("Exit", 1, 100, 10, 80, 19)
 

def event(evt, val): 
 if (evt== QKEY and not val): Exit()


def bevent(evt):

 if   (evt== 1): Exit()

#c'est ici que se joue
 elif (evt== 2): Draw()

 elif (evt== 3):
  for ob in Blender.Object.GetSelected():

   ob.dRotX= rotation[0].val
   ob.dRotY= rotation[1].val
   ob.dRotZ= rotation[2].val
  Blender.Redraw()


Register(draw, event, bevent)
 

tester ce script
 
précédentPython: Patatoïdes (5) 
 Python: shadows Suivant
Vers le  Haut de page


 

 

Les questions concernant cette page  peuvent être posées sur  :
news://news.zoo-logique.org/3D.Blender

Livre en français
Blender : apprenez, pratiquez, Créez, livre, Ed. Campus Press, coll. Starter Kit
Blender Starter Kit

Forum
FAQ
Lexique
Didacticiels
Compilations
Blender2KT
Débuter
Modelage
Blender python
Materiaux
Lumière
Animation
API python (eng)
Archives nzn
Statistiques
Doc flash Sculptris
Galerie Sculptris

mon site de démos sur youtube