Script flightgear

Merci Clément,
Il est très important, de faire le tour de la question et de regarder partout. Cela va conditionner la structure du script, et cela évitera de devoir tout réecrire à mi-chemin.

Pour le sens des rotations et l'orientation de l'espace j'ai finalement trouvé çà:
http://fr.wikipedia.org/wiki/R%C3%A8gle_de_la_main_droite

Alexis a écrit:Peu importe le temps que ça dure dans FG et blender, on aura le même déroulement de l'animation. Et pour l'instant à l'utilisateur de se débrouiller pour la durée de l'animation dans FG (il peut voir ce qui marche dans blender et le remettre dans FG).

On peut synchroniser blender et FG. Dans blender l'onglet Render de la partie prorpiété, tu définis le frame rate, par défaut 24fps, 24 images par seconde. Si ton animation dure 72 images cela veut dire que ton animation dure 3sec (24 fps). Le script pourrai écrire la durée de l'animation, et d'avoir le même résultat dans flightgear et blender. Il faut que le script calcul, un coefficient de temps pour chaque frame (image) pour pouvoir passer de l'un à l'autre.

Voici un début de script d'export d'armature.
Ce n'est qu'un début, il est destructeur car il faut faire un Apply>Location et un Apply>Rotation, pour pouvoir récupérer les coordonnées des bones. Apres cela le lien de parenté de blender deviens "obscure" (tout les points parents sont à zéro ).
Je n'ai pas vérifier en détail son fonctionnement, mais il a l'air de passer correctement.
A recopier dans une fenêtre script de blender puis le lancer "Run script"
Il possède deux fonctions récursives, ce qui ne le rend pas forcement facile à lire .

Code:

import bpy





def recherche_mesh_object( object ):
   ret = []
   for obj in bpy.data.objects:
      if obj.type != 'MESH':
         continue
      if obj.parent:
         if obj.parent.name == object.name:
            ret.append( obj.name )
   return ret


def recherche_mesh_object_enfant( object_armature, list ):
   for obj_armature in bpy.data.objects:
      if obj_armature.type != 'ARMATURE':
         continue
      if obj_armature.parent:
         if obj_armature.parent.name == object_armature.name:
            recherche_mesh_object_enfant(obj_armature, list)
            list +=  recherche_mesh_object(obj_armature)


def recherche_armature_enfant( object_armature ):      
   ret = []
   for obj_armature in bpy.data.objects:
      if obj_armature.type != 'ARMATURE':
         continue
      if obj_armature.parent:
         if obj_armature.parent.name == object_armature.name:
            ret.append( obj_armature )
   return ret

def ecrit_armature( object_armature ):
   print( "<animation>" )
   print( "\t<!-- %s -->" % object_armature.name )
   list = []
   recherche_mesh_object_enfant( object_armature, list )
   for mesh_name in list:
      print( "\t<object-name>%s</object-name>" % mesh_name )
   
   for obj_mesh_name in recherche_mesh_object( object_armature ):
      print( "\t<object-name>%s</object-name>" % obj_mesh_name )

   print( "\t<axis>" )
   print( "\t\t<x1-m>%s</x1-m>" % str(object_armature.data.bones[0].tail.x) )
   print( "\t\t<y1-m>%s</y1-m>" % str(object_armature.data.bones[0].tail.y) )
   print( "\t\t<z1-m>%s</z1-m>" % str(object_armature.data.bones[0].tail.z) )
   print( "\t\t<x2-m>%s</x2-m>" % str(object_armature.data.bones[0].head.x) )
   print( "\t\t<y2-m>%s</y2-m>" % str(object_armature.data.bones[0].head.y) )
   print( "\t\t<z2-m>%s</z2-m>" % str(object_armature.data.bones[0].head.z) )
   print( "\t</axis>" )   

   print( "</animation>" )

   for obj_armature_enfant in recherche_armature_enfant( object_armature ):
      ecrit_armature( obj_armature_enfant )


def recherche_object_armature( armature ):
   for object in bpy.data.objects:
      if object.data.name == armature.name:
         return object
   return None
   
def ecrit_armatures_all():
   for armature in bpy.data.armatures:
      #print( "Armature %s" % armature.name )
      obj = recherche_object_armature( armature )
      if obj != None:
         if obj.parent == None:
            ecrit_armature( obj )
         #print( "Trouvé %s" % obj.name )


print( "-------------------" )
ecrit_armatures_all()

Bon .... y a du boulot ... et je compte sur vous ....

J'ai réussi à fabriquer des fichiers xml, pour incorporer un avion d' x-plane. Tout s''est fait avec des scripts blender.
J'ai pas mal tourné en rond pour changer la vitesse de la propriété

Et bien moi je viens d'essayer de faire fonctionner tes 3 fichiers "anim_props.py", "anim_ui.py" et "__init__.py" je fais "Ctrl+Alt+u" je clic sur "Install Addon..." je vais séléctionner le fichier "__init__.py", je valide, ça reviens sur la liste des addons mais rien à été ajouté, la console de Blender ne dit pas un mot :/

J'y connais presque rien à Blender par contre je m'y connais en programmation donc si j'arrive à faire fonctionner ce truc avec Blender je pourrais aider

J'utilise Blender 2.62, dites moi exactement dans quel dossier mettre quels fichiers? dans quels fichiers mettre quel code source? Où cliquer pour ajouter ça à Blender? Comment utiliser l'addon une fois ajouter?

Merci d'avance !

Super nouvelle, merci Clément, car y a vraiment beaucoup de boutot à faire ....

Pour incorporer le script, voilà la démarche
Tu créé un répertoire
Tu mets les 3 fichiers dedans.
Puis tu recopies le répertoire (pas les fichiers) dans le répertoire des scripts de blender. Pour linux : "répertoire d'installation"/2.62/scripts/addons
(Mieux moi j'utilise les liens au lieu de faire la recopie... mais pour l'instant fait la recopie)
Tu ouvres blender
Tu ouvres la configuration de blender CTRL+ALT+U
Tu choisis l'onglet "addons"
Tu choisis la catégorie "Import-Export"
Dans la liste il y maintenant le script dont le nom est : Import-Export: Flightgear
Tu coches uniquement la case à cocher à côté du petit bonhomme
Tu refermes la fenêtre de configuration

Ce script modifie uniquement un "panel" de blender ...
pour le voir
Tu créé une armature (SHIFT-A) dans le menu qui apparait tu chosis "Armature>bone"
Tu verras dans la fenêtre 3D un nouveau panel "Flightgear" (dans la partie "Tools" de la fenêtre 3D (touche T pour faire aparaietre disparaitre))
Maintenant tu peux choisir familly suivant plusieurs choix
Si tu choisi "controls"
Quelque propriété de controls ont été remplies

A+


P.S. Vérifie la console car il y aura certainement un problème d'import de module python. Regarde le post d'alexis il y a la solution ...

_run_ a écrit:
Pour incorporer le script, voilà la démarche
Tu créé un répertoire ==> C'est OK
Tu mets les 3 fichiers dedans. ==> C'est OK (j'en profite pour faire la correction qu'Alexis à faites concernant la version de python)
Puis tu recopies le répertoire (pas les fichiers) dans le répertoire des scripts de blender. Pour linux : "répertoire d'installation"/2.62/scripts/addons ==> C'est OK
Tu ouvres blender ==> C'est OK (bon ça c'est facile )
Tu ouvres la configuration de blender CTRL+ALT+U ==> C'est OK
Tu choisis l'onglet "addons" ==> C'est OK
Tu choisis la catégorie "Import-Export" ==> C'est OK
Dans la liste il y maintenant le script dont le nom est : Import-Export: Flightgear ==> Négatif
Tu coches uniquement la case à cocher à côté du petit bonhomme
Tu refermes la fenêtre de configuration

J'ai mis le dossier qui contient le script dans mon "répertoire d'installation/scripts/addon" ET dans mon $HOME/.blender/script/addon rien y fait

Ce doit etre un probleme avec les modules python
C est la ligne qui contient io_utils ....... Regarde le post de alexis ... Regarde les messages consoles

_run_ a écrit:C est la ligne qui contient io_utils ....... Regarde le post de alexis ... Regarde les messages consoles

J'ai bien pris note du post d'Alexis. Avec la modif d'Alexis ou sans la modif d'Alexis le résultat est le même : je n'ai rien qui ressemble à "Import-Export: Flightgear" dans ma liste et la console de Blender ne mets aucun message et la console python non plus.

J'ai toujours tenu une distance de sécurité avec Blender jusqu'à maintenant... ben je crois que c'est pas l'heure du changement

Attention au niveau des répertoires .....
C'est une installe à partir de quels fichier ???
Un dépot , les fichiers du site blender, du site graphicsall, ou des sources ...
Dans certains cas tu as
$HOME/.blender/scripts/addon -> non
mais aussi
$HOME/.blender/2.62/scripts/addon -> oui

Mon installation est la suivante :
J'ai Blender 2.49 qui a été installé il y a fort longtemps via Synaptic (je suis sous Linux Mint un dérivé de Ubuntu). Blender 2.49 est donc installé dans mon /usr
Les modules supplémentaire doivent être mis dans /home/clement/.blender/script/blender

J'ai Blender 2.62 qui a été installé il y a seulement quelques semaines, j'ai téléchargé cette version de Blender sur le site blender.org. Le fichier téléchargé était un fichier tar.bz2 que j'ai décompressé. Une fois le fichier tar.bz2 décompressé j'ai placé le dossier dossier "Blender 2.62" dans mon "/home/clement". Ce dossier contient le programme blender que je lance via un terminal en faisant "./blender". Ce dossier contient aussi un dossier "2.62/scripts/addons" dans lequel je mets les modules supplémentaire.

Je crois que c'est foutu d'avance :/

F-JJTH a écrit: Ce dossier contient aussi un dossier "2.62/scripts/addons" dans lequel je mets les modules supplémentaire.

C'est le bon ...

pour avoir a la fin
/home/clement/Blender 2.62/2.62/scripts/addons/tartanpion/__init__.py
/home/clement/Blender 2.62/2.62/scripts/addons/tartanpion/anim_ui.py
/home/clement/Blender 2.62/2.62/scripts/addons/tartanpion/anim_props.py

le sous répertoire tartanpion est très impotant aussi, peut importe le nom. C'est la manière de python de créer des modules, par l'intermédiaire du fichier __init__.py

_run_ a écrit:
pour avoir a la fin
/home/clement/Blender 2.62/2.62/scripts/addons/tartanpion/__init__.py
/home/clement/Blender 2.62/2.62/scripts/addons/tartanpion/anim_ui.py
/home/clement/Blender 2.62/2.62/scripts/addons/tartanpion/anim_props.py

C'est bien ce que j'ai Mais ça marche pô

J'avais eu le même souci à une époque sous Ubuntu, le script d'import de .ac ne fonctionnait pas sur la 2.5 nouvellement installée.
Il me semble qu'en désinstallant la version du dépôt, puis en réinstallant la 2.5 et les scripts, tout était rentré dans l'ordre.
Les 2 versions ne cohabitaient pas.

Eh si, c'était un problème python, sur ma machine j'ai python 2.7.2 et python 3.2.2 d'installé à partir des dépôts.

avec les versions issues de blender.org, j'ai toujours au démarrage de blender la ligne suivant dans la console :

Code:

found bundled python: /home/rene/blender/build/blender-2.63-linux-glibc27-x86_64/2.63/python

Je n'ai pas ce message avec la version des dépôts officiel et non-officiel.
Ce qui n'empêche pas les scripts de fonctionnés.

Dans la page download de blender.org

Code:

Requires glibc 2.7, includes Python 3.2, FFmpeg
Suits most recent Linux distributions

Sur ma machine j'ai deux exécutable python : /usr/bin/python et /usr/bin/python3.2 (ce sont des liens vers /usr/bin/python2.7 et /usr/bin/python3.2mu)

Salut,
Je termine actuellement mon projet de fin d'étude, je manque un peu de temps, j'aurais tout le temps la semaine prochaine de donner un coup de main !

J'ai pris le temps de regarder le dernier script que tu as posté. J'ai à peu près compris son fonctionnement, c'est pas si compliqué.

Bon j'ai désinstallé la version 2.49b avec synaptic. Supprimé mon dossier .blender situé dans mon /home/clement. J'ai refait la procédure entière indiqué par René... même résultat... Dommage

Je suis dispo jusqu'à 6 heures, sur mumble


Il n'y a aucune raison que cela ne fonctionne pas chez toi. Sur mon micro portable , j'ai la version 2.49b d'installé avec les dépôts d'ubuntu (/usr/share/bin....). Puis les versions 2.51, 2.59, 2.63 à partir de blender.org. Tout cela avec python 2.6. Toutes ces dernières versions dans un répertoire de mon home. Et cela cohabite bien.
Sur mon ordi, il y a les versions 2.63.10 d'un dépot non officlel (/usr/share/bin/ etc... ) et les des versions de blender.org d'autres de graphicsall.org dans mon home. Avec python2.7 et python3.2 (officiels). C'est vraiment une grosse pagaille, sur mon ordi, mais je ne crois pas avec fait des modifications. Tous cohabitent.

A+

Une petite modification du script d'export d'animation
A essayer dans une fenêtre script de blender:
Important : le script n'exporte que la sélection, mais il exporte en plus l'interpolation.
Le début, la fin des frames, ça totalité, la propriété flightgear, le paramètre "factor" sont écrit en "dur"
C'est juste pour montrer la faisabilité de la chose ...

Code:

import bpy
from math import degrees




def affiche_interpolation( fcurve ):
   frame_deb = 1.0
   frame_fin = 60.0
   nb_frame = frame_fin -   frame_deb
   print( "\t<!-- temps : %0.2f -->" % (nb_frame / 24) )
   print( "\t<interpolation>" )
   for keyframe in fcurve.keyframe_points:
      ind = (keyframe.co.x-frame_deb) / nb_frame
      val = degrees(keyframe.co.y)
      print( "\t\t<entry><ind> %0.4f </ind><dep> %0.4f </dep></entry>" % (ind, val) )
   print( "\t</interpolation>" )


def recherche_keyframe( object_armature ):
   fcurves = object_armature.animation_data.action.fcurves
   for i in range(len(fcurves)):
      if fcurves[i].data_path.find('rotation_euler') != -1:
         affiche_interpolation( fcurves[i+1] )
         return
         
   
def recherche_mesh_object( object ):
   ret = []
   for obj in bpy.data.objects:
      if obj.type != 'MESH':
         continue
      if obj.parent:
         if obj.parent.name == object.name:
            ret.append( obj.name )
   return ret


def recherche_mesh_object_enfant( object_armature, list ):
   for obj_armature in bpy.data.objects:
      if obj_armature.type != 'ARMATURE':
         continue
      if obj_armature.parent:
         if obj_armature.parent.name == object_armature.name:
            recherche_mesh_object_enfant(obj_armature, list)
            list +=  recherche_mesh_object(obj_armature)


def recherche_armature_enfant( object_armature ):      
   ret = []
   for obj_armature in bpy.data.objects:
      if obj_armature.type != 'ARMATURE':
         continue
      if obj_armature.parent:
         if obj_armature.parent.name == object_armature.name:
            ret.append( obj_armature )
   return ret

def ecrit_armature( object_armature ):
   print( "<animation>" )
   print( "\t<!-- %s -->" % object_armature.name )
   print( "\t<type>rotate</type>" )

   list = []
   recherche_mesh_object_enfant( object_armature, list )
   for mesh_name in list:
      print( "\t<object-name>%s</object-name>" % mesh_name )
   
   for obj_mesh_name in recherche_mesh_object( object_armature ):
      print( "\t<object-name>%s</object-name>" % obj_mesh_name )

   head = object_armature.data.bones[0].head
   tail = object_armature.data.bones[0].tail
   
   m = object_armature.matrix_world
   
   h = m * head
   t = m * tail
   v = t - h
   print( "\t<property>gear/gear[0]/position-norm</property>" )
   print( "\t<factor>122.0</factor>" )

   print( "\t<axis>" )
   print( "\t\t<x1-m>%0.4f</x1-m>" % h.x )
   print( "\t\t<y1-m>%0.4f</y1-m>" % h.y )
   print( "\t\t<z1-m>%0.4f</z1-m>" % h.z )
   print( "\t\t<x2-m>%0.4f</x2-m>" % t.x )
   print( "\t\t<y2-m>%0.4f</y2-m>" % t.y )
   print( "\t\t<z2-m>%0.4f</z2-m>" % t.z )
   print( "\t</axis>" )   

   recherche_keyframe( object_armature )

   print( "</animation>" )

   for obj_armature_enfant in recherche_armature_enfant( object_armature ):
      ecrit_armature( obj_armature_enfant )


def ecrit_armatures_all():
   print( "<PropertyList>" )
   print( "<path>extra.ac</path>" )
   #for obj in bpy.data.objects:
   for obj in bpy.context.selected_objects:
      if obj.type != 'ARMATURE':
         continue
      if obj != None:
         if obj.parent == None:
            ecrit_armature( obj )
         #print( "Trouvé %s" % obj.name )
   print( "</PropertyList>" )


print( "-------------------" )
ecrit_armatures_all()

Je dois avouer que je n'arrive pas encore à cerner les différentes étapes nécessaire pour réaliser ce script. Donc je vais commencer par du simple... du très simple
Je propose que l'on nomme le dossier "io_fganim". Nous avons déjà un dossier nommé "io_scene_ac" dans le dépôt.

(Ah j'avais prévenu que je commencerai par du simple )

Bon plus sérieusement Je vais lancer une "todolist" :

Que dois faire le script ?
- À partir de Blender, le script dois pouvoir créer un fichier XML d'animation reconnu par FG : Écriture du XML
- Le script doit pouvoir lire un ficher XML d'animation provenant de FG et appliqué les animations au modèle actuellement dans Blender : Lecture du XML

1) Écriture du XML
- Le script doit pouvoir créer les animations de mouvement reconnu par FG (rotate, translate, ?scale?)
- Le script doit pouvoir appliquer des "offsets" et "factor"
- Le script doit avoir un dictionnaire des principales propriété de FG (aileron, profondeur, gouverne, trim....)
- Le dictionnaire doit connaître le champs de variation (-1 à 1, 0 à 1) des propriétés du dictionnaire
- Ajouter une petite interface de test constitué de "scrollbar" qui permet de faire varier les propriétés du dictionnaire pour pouvoir visionner les mouvements dans Blender
- ?Le script doit permettre d'appliquer une animation "range" en fonction de valeur renseigné, ou en fonction de propriété FG?
- ?Le script doit permettre d'appliquer une animation "select" en fonction de propriété FG?
- Le script doit pouvoir appliquer une animation "pick", l'utilisateur pourra indiquer quel clic de la souris doit être assigner, et le comportement du clic (action à réaliser)


2) Lecture du XML
- Le script doit permettre de mettre en mouvement les parties mobile en appliquant les restrictions présente dans le XML
- L'utilisateur devra ouvrir le fichier .ac ET le fichier .xml associé
- Que se passe-t-il si le fichier XML contient des animations non reconnu ? Il faudra faire attention à ce que les animations non-reconnu ne soit pas supprimé lors de l'export.

Voilà ce sont des idées, complétez, modifiez, supprimez, commentez
Je pense que je me préoccuperai principalement de l'interface (menu déroulant contenant les animations applicable à un objet, affichage d'une boite de dialogue en fonction du type d'animation choisie, proposition de propriétés standard ou bien renseignement d'une propriété particulière...)

Amicalement,
Clément

Merci Clément,

Bonne initiative.
Préambule : nous avons des compétence différentes, et complémentaires. Je connais assez bien blender et ses possibilités, par contre j'ai de grosses lacunes avec flightgear.
Les animations (de base) de blender peuvent-être rotation, translation, scale. Comme tu écris (?scale?) je me doute que ces animations ne sont pas utiles à flightgear. Autant les ignorées, il ne seront pas pris en compte par le script. Un détail important, blender permet de gérer les rotations suivant des angles mais aussi avec des "quaternions", il faudra imposer les rotations de type Euler XYZ. Le paramètre Y contient l'angle autour de l'axe. Pile-poil ce qui nous faut.
De même pour les translations, blender est plus souple. Il permet de changer la position de la bone à chaque keyframe. Donc plus qu'une translation. Mais heureusement on peut rajouter une contrainte sur une bone, "limit_location" ou "limit_rotation". En rajoutant une contrainte qui force la postion sur Y ou la rotation sur Y , on obtient ce que l'on veut.
De la même manière, dans blender une armature peut avoir plusieurs bones. Je pense qu'il serait mieux de ne créer que des armatures à une seule bone. Si l'on veut une translation puis une rotation, il faudra enchaîner deux armatures liées avec un lien de parenté.
En bidoullant, les xml de flightgear, j'ai remarqué que les propriétés changent de nom lorsque l'on utilise Yasim ou JSBsim. (Est-ce que je me trompe???). Il faudra que le dictionnaire, contienne ces deux cas.
Peux-tu me détailler les animations de type pick (??clic dans le cockpit ??) et range.(??valeur du variomètre par exemple??)

Pour ne pas mélanger les informations xml du script avec les informations faites manuellement. Je pense que l'on pourrai créér un fichier xml, avec comme structure de nom "ficher_anim.xml" fichier fait référence au fichier ac: fichier.ac et _anim.xml pour dire que c'est une animation. Ensuite dans le fichier xml de base on peut inclure ce fichier :
<path>répertoire/fuselage_anim.xml</path>

et aussi l'entourer d'une balise commentaire exemple :
<!-- script fg2blender !!!! don't remove -->
<path>répertoire/fuselage_anim.xml</path>
<!-- script fg2blender !!!! don't remove -->

De cette manière on ne touche pas aux modifications manuelles. Et le script identifie très facilement ce qu'il peut modifié.

Pourquoi ne pas créer un fichier xls (open-office) dans le dépot avec la todo-list dedans ...

Pour la lecture ... lorsque l'animation n'est pas reconnue, le script ne devra pas y toucher. Mieux, une animation reconnue ne devra passer dans le nouveau xml 'fichier_anim.xml' qu'après la notification d'une boîte de dialogue avec validation.

Voilà plusieurs idéés qui me viennent à l'esprit.

Amicalement ..

Oui j'ai oublié de dire que tout ce que j'ai mis entre point d'interrogation c'était pour indiquer que ce sont des idées à ne pas forcément prendre au "sérieux". Disons que y'en a pas forcément l'utilité.
L'animation "scale" qui permet de redimensionner un objet est très très peu utilisé (y'a pas grand chose qui change de taille dans un avion sauf si on se crash lol)

mais aussi avec des "quaternions"

hmmm je reviens... j'avais chercher un dico

De la même manière, dans blender une armature peut avoir plusieurs bones. Je pense qu'il serait mieux de ne créer que des armatures à une seule bone. Si l'on veut une translation puis une rotation, il faudra enchaîner deux armatures liées avec un lien de parenté.

Ça tombe bien que tu parle de ça car justement j'ai voulu expérimenté ça ce matin, forcément j'ai pas réussi... L'exemple que j'ai pris ce matin c'était le système mécanique des volets du dr400-jsbsim. Le volet est actionné par un axe qui va d'avant en arrière et qui fait donc pivoter le volet. J'ai donc mis un "bone" qui crée la rotation du volet et j'ai voulu associé la rotation du volet à la translation de l'axe. Pour mieux voir de quoi je veux parler tu peux tester le dr400-jsbsim, te placé sous une aile pour voir le mécanisme du volet et tu actionne le volets. Un autre exemple très similaire c'est le fonctionnement d'un moteur : le villebrequin fait une rotation, ce qui se traduit par une translation de la bielle qui elle aussi subit une petite rotation à sa base, tandis que le piston subit une translation parfaite de haut en bas. Si on arrive à recréer une animation de cette complexité je pense qu'on aura gagné et que tout le reste sera possible.

Concernant les différences entre JSBSim et Yasim il est vrai que certains noms de propriété peuvent varier, par exemple sur le dr400-jsbsim, les propriétés situé dans /surface-positions/ ne sont pas utilisé alors qu'avec Yasim elle le sont. La solution à cela est de proposé à l'utilisateur d'utiliser une propriété générique (présente dans le dictionnaire) ou bien de renseigner sa propre propriété. Par exemple : L'utilisateur sélectionne le "bone" qui gère la profondeur, il va ensuite sélectionner "elevator" dans la liste déroulante des types d'objet, le champs "property" s'auto-remplie avec la propriété "/surface-positions/elevator-pos-norm" mais si cette propriété ne convient pas à l'utilisateur il peut parfaitement éditer ce champs.

Concernant les animations de type "pick" :
Tout d'abord, l'animation de type "pick" permet de dire, purement et simplement, que l'objet est cliquable. Un exemple simple :

Code:


<animation>
  <type>pick</type>
  <object-name>button.onoff</object-name>
</animation>


Avec ce code je viens de dire que l'objet nommé "button.onoff" est cliquable, c'est tout. Je n'ai pas dit ce qui devait se passer lorsque l'on clique dessus.
Pour cette animation on peut définir plusieurs chose :
- Que doit faire ce bouton si je clique dessus avec le clic droit de la souris ?
- Que doit faire ce bouton si je clique dessus avec le clic gauche de la souris ?
- Que doit faire ce bouton si je clique dessus avec le clic du milieu de la souris ?
- Que doit faire ce bouton si je fais rouler ma roulette vers l'avant ?
- Que doit faire ce bouton si je fais rouler ma roulette vers l'arrière ?
- Que doit faire ce bouton lorsque je relâche le clic de ma souris ? (on peut très bien dire : tant que le clic de ma souris est enfoncé : tu fais ça, dès que je relâche le clic de ma souris tu fais ça)
- Est-ce que si je maintiens enfoncé le clic de ma souris, l'action doit se répéter ? si oui, elle doit se répéter tout les combien de temps ? (très pratique pour incrémenter une valeur)
- On peut indiquer si l'objet cliquable est visible ou si c'est juste une zone cliquable, dans le cas d'une zone cliquable seul les arrêtes de l'objet seront visible lorsque l'on aura pressé Ctrl+c

Voici un exemple d'une zone cliquable :

Code:


  <animation>
    <type>pick</type>
    <visible>false</visible>
    <object-name>flapsdown</object-name>
    <action>
      <button>0</button>  <!-- 0 = clic gauche, 1 = clic milieu (clic roulette), 2 = clic droit
      <repeatable>true</repeatable> <!-- Ici on dit que tant que le clic est maintenu on répète l'action (dans cette exemple : tant que le bouton est maintenu on abaisse les volets) -->
      <interval-sec>0.3</interval-sec> <!-- La répétition intervient tout les 0.3 secondes, donc tant que le clic est maintenu, on abaisse 1 cran de volet toute les 0.3 secondes -->
      <binding> <!-- Lorsque le bouton de la souris est enfoncé... -->
        <command>property-assign</command> <!-- ...on met la propriété... -->
        <property>controls/flight/flaps-anim</property> <!-- ...controls/flight/flaps-anim... -->
        <value type="int">1</value> <!-- à la valeur 1 -->
      </binding>         
      <mod-up> <!-- Lorsque le bouton de la souris est relâché... -->
        <binding>
          <command>property-assign</command> <!-- ...on met la propriété... -->
          <property>controls/flight/flaps-anim</property> <!-- ...controls/flight/flaps-anim... -->
          <value type="int">0</value> <!-- à la valeur 0 -->
        </binding>         
      </mod-up>
    </action>
  </animation>


Il existe une grande quantité de <command>, mais cela ne nous concerne pas vraiment, il suffit d'avoir un dictionnaire qui les répertorie, ça sera à l'utilisateur de sélectionner la commande qu'il veut. On ne fera que lui mettre à disposition la liste des commandes les plus courantes.

De cette manière on ne touche pas aux modifications manuelles. Et le script identifie très facilement ce qu'il peut modifié.

Tu veux dire qu'on se servirait de commentaire pour repérer là où le script est censé interpréter le XML ?

Pour ne pas mélanger les informations xml du script avec les informations faites manuellement. Je pense que l'on pourrai créér un fichier xml, avec comme structure de nom "ficher_anim.xml" fichier fait référence au fichier ac: fichier.ac et _anim.xml pour dire que c'est une animation. Ensuite dans le fichier xml de base on peut inclure ce fichier :
<path>répertoire/fuselage_anim.xml</path>

Mieux, une animation reconnue ne devra passer dans le nouveau xml 'fichier_anim.xml' qu'après la notification d'une boîte de dialogue avec validation.

Hmmm... alors là j'ai rien compris

Amicalement,
Clément

F-JJTH a écrit:

De cette manière on ne touche pas aux modifications manuelles. Et le script identifie très facilement ce qu'il peut modifié.

Tu veux dire qu'on se servirait de commentaire pour repérer là où le script est censé interpréter le XML ?

Pour ne pas mélanger les informations xml du script avec les informations faites manuellement. Je pense que l'on pourrai créér un fichier xml, avec comme structure de nom "ficher_anim.xml" fichier fait référence au fichier ac: fichier.ac et _anim.xml pour dire que c'est une animation. Ensuite dans le fichier xml de base on peut inclure ce fichier :
<path>répertoire/fuselage_anim.xml</path>

Mieux, une animation reconnue ne devra passer dans le nouveau xml 'fichier_anim.xml' qu'après la notification d'une boîte de dialogue avec validation.

Hmmm... alors là j'ai rien compris

Amicalement,
Clément

Lol .....

Presque .... on se servirait du commentaire pour dire au script qu'ici il peut faire ce qu'il veut . Pas besoin de boite de dialogue.

Exemple (issu du model dc-3) dans le fichier Models/main.xml on a

Code:

  <!-- Gouvernes de direction -->
  <animation>
    <type>rotate</type>
    <object-name>direction</object-name>
    <property>surface-positions/rudder-pos-norm</property>
    <factor> -25 </factor>
    <center>
    <x-m> 8.076 </x-m>
    <y-m> 0.000 </y-m>
    <z-m> 2.368 </z-m>
    </center>
    <axis>
      <x> 0 </x>
      <y> 0 </y>
      <z> 1 </z>
    </axis>
  </animation>



On importe le modèle dans blender et le script interprete tout ce qu'il peut .. puis apres modification dans blender et demande de sauvegarde. Le script modifiera le main.xml, et on aurai un truc du genre dans le fichier main.xml

Code:


<!-- script bidulle -->
<model>
  <path>Aircraft/Douglas-Dc3/Models/direction_anim.xml</path>
</model>
<!-- script bidulle -->


puis un nouveau fichier direction_anim.xml

Code:

 <PropertyList>

  <path>direction.ac</path>
 <animation>
    <type>rotate</type>
    <object-name>direction</object-name>
    <property>surface-positions/rudder-pos-norm</property>
    <factor> -25 </factor>
    <center>
    <x-m> 8.076 </x-m>
    <y-m> 0.000 </y-m>
    <z-m> 2.368 </z-m>
    </center>
    <axis>
      <x> 0 </x>
      <y> 0 </y>
      <z> 1 </z>
    </axis>
  </animation>
</PropertyList>




Le script sauvegarde le maillage direction.ac, et sauvegarde l'animation avec le fichier direction_anim.xml. Il met à jour le fichier main.xml, en retirant l'ancienne animation et la remplace pas 3 lignes.

La fois suivante, le script détecte le commentaire et ne demandera plus de confirmation pour modifier main.xml . Le créateur pourra modifier les noms comme bon lui semble, ou l'animation , mais à lui de faire le ménage si il fait des fichiers "orphelins"

Bon je dit ça ... mais c'est peut-être une mauvaise idée ....

lol .. si l'idée n'est pas comprise alors c'est sûr, l'idée est mauvaise ... lol

+++

P.S. De toute façon je crois que le script devra gérer plusieurs fichiers .ac, et il y aura un casse-tête avec ça. Pour l'instant je vois pas comment gérer plusieurs fichier ac, d'une manière exhaustive. Je pense aux layers de blender mais il n'y a que 20, mais aussi les groups (avec blender on peut créer des groupes de mesh) un groupe=un fichier .ac

J'avais aussi pensé au groupes, je sais que ça existe, mais je connais pas du tout.

Quand à lire des fichiers modifiés par les utilisateurs, ça n'est pas impossible, ils se présentent toujours de la même manière, tout ce qui change d'un auteur à l'autre c'est le nombre de tabulations ou d'espaces avant les balises, la mise en forme des interpolations. J'avais commencé un script pour mettre en forme les fichiers xml, si on pouvais passer tout les fichiers dans cette petite moulinette de mise en forme, ils seraient tous lisibles. Il faudrait donc définir des règles de mise en forme.


Sinon, je suis d'accord sur le fait que des animations comme scale n'ont pas (pour l'instant) besoin d'être présente dans le script, c'est presque jamais utilisé. Par contre, il y a aussi conditions en xml qui pourraient être intégrées. Un exemple :

Code:


   <animation>
      <type>spin</type>
      <object-name>Train2Roue</object-name>
      <property>gear/gear[0]/rollspeed-ms</property>
      <factor>8.2</factor>
      <condition>
         <equals>
            <property>gear/gear[0]/position-norm</property>
            <value>1</value>
         </equals>
      </condition>
      <center>
         <x-m>0.956</x-m>
         <y-m>-1.289</y-m>
         <z-m>-1.277</z-m>
      </center>
      <axis>
         <x>0.0</x>
         <y>-1.0</y>
         <z>0.0</z>
      </axis>
   </animation>


Pour que la roue tourne que quand le train est sorti. Il y a aussi des exemples dans les animations d'hélices.

C'est l'impression que me donne les groupes. On définira autant de groupes que l'on voudra de fichier .ac. Il faudra rajouter dans blender des propriétés aux groups. Comme ils sont accessible avec bpy.data.groups cela ne devrait pas poser de problème.
par exemple:
bpy.data.groups['empennage'].fg_fichier_ac = 'empennage.ac'
bpy.data.groups['empennage'].fg_directory = 'Models/'

Pour créer un groupe. Il faut sélectionner plusieurs objets puis faire CTRL-G. Dans propriété>objet il y a une partie groups et l'on change le nom du groupe là dedans.



@Clément
Blender, même avec sa nouvelle interface, n'est pas du tout intuitif.
Via le forum je ne peut que te donner des indications .... c'est pas toujours évident
La fenêtre 3D a deux "extensions" Tools Shelf avec la touche T et propertie avec la touche N
Dans la fenêtre 3D
-Pour créer une armature
SHIFT-A un menu apparait Armature>Single Bone
-Changer de mode
CTRL-TAB pose mode ou object mode
-tu selectiones l'armature
-tu passes en pose mode
De la fenêtre 3D tu regardes la partie propertie (touche N)
tu vois Location X=, Y=, Z
et en desous
tu vois Rotation (W,X,Y,Z)
Quaternion
Ici tu changes et tu passes en Euler XYZ (En pose mode car en object mode la rotation est déjà en Euler XYZ) il faut le faire manuellement en pose mode

Tu changes de fenêtre. Tu regardes la partie properties, avec tous ces boutons. Et là tu clic sur le bouton "Bone Constraints"
-Ici tu rajoute une contrainte (ce n'est valable qu'en pose mode) "Add Constraint"
-tu choisis Limit Rotation
-tu coches LimitX et LimitZ.
-tu changes World Space en Local Space

Qu'est-ce que l'on vient de faire ???
A chaque fois que l'on voudras ajouter une keyframe (une position à un temps t) la seule rotation possible sera une rotation autour de l'axe de la bone.

Pour insérer une keyframe
-Touche I dans la fenêtre 3D choisir (location ou rotation)


Pour associer un objet à une Armature
Tu sélectionnes l'objet puis l'armature. (l'ordre est important)
-CTRL-P dans le menu tu fais un parenté de Bone

Tu peux associer un objet mesh(maillage) mais aussi une autre armature.
J'espère que j'etais clair ....

Pour les translations tu fais à peut pres la meme chose, mais tu fais une limit_location cette fois . En n'autorisant que Y et aussi en "Local Space".

A++