Dorian Fevrier's blog

Ce que j'aimerais voir plus souvent, comme quelqu'un qui saute d'une application à l'autre (pas complètement débutant donc)... C'est une explication de comment Houdini fonctionne "sous le capot". Il y a des brides d'information un peu partout mais la plupart des tutoriaux se focalisent sur l'effet qu'ils essaient de faire.

Il n'y a aucun secret sur comment Houdini fonctionne. Tout ce qui se fait dans Houdini peut être exprimé par un node. Que le node soit un opérateur codé en C++, en VEX (ou les nodes VOP représentant les fonctions VEX), Python, ou bien Digital Asset Houdini (HDA), chaque node fait son boulot et met son résultat en cache. Il n'y a pas de niveau plus bas que les nodes. Dans Houdini, les nodes sont les routines atomiques/fonctions/programmes les plus bas niveaux. Par exemple, un node de type SOP prend la géométrie entrante et la traite en un bloc, puis cache son résultat qu'on peut visualiser:

• Dans le viewport.
• Via bouton milieu de souris (MMB) sur un node pour connaitre ses statistiques.
• Dans la Details View, pour voir les valeurs des attributs.

Si il s'agit d'un SOP modificateur, il aura une dépendance sur son node d'entrée. S'il y a un changement en amont, le node actuel sera contraint de s'évaluer. S'il y a un paramètre en référence sur un autre node et que le node est marqué comme "dirty" et affecte ce node, ce node sera contraint de s'évaluer.

Graph et dépendances

Pour expliquer la structure de "cooking" (ndt: dans Houdini, calculer une node se dit "cook") d'un graph de SOP, pour chaque cook (changement de frame, de paramètre, etc...), le graph commence à partir du node en Display/Render (ndt: petit rectangle bleu) puis remonte la chaine à la recherche de nodes ayant changé et évalue les dépendances pour chacun d’entre eux en demandant également à ces nodes s'il y a eu des changements, et ce, jusqu'à ce qu'il atteigne les nodes en tête du graph.

Vous pouvez configurer quelques options dans le Performance Monitor pour forcer Houdini à fonctionner de l'ancienne manière (H11) et voir l'arbre de l'ordre d'évaluation si vous le souhaitez. Faites-le. Il est "obligatoire" que vous le fassiez si vous souhaitez avoir une meilleure compréhension de Houdini. Il faut absolument que vous utilisiez le Performance Monitor si vous voulez voir comment les graphs sont évalués car il se base sur l'ordre de création ainsi que les dépendances. Oui, supprimer et remettre un object peut et va changer l'ordre d'évaluation et peut parfois résoudre des crashs. Si vous n'avez pas encore utilisé le Performance Monitor, alors allez-y. Utilisez-le. N'oubliez cependant pas de le désactiver car il a un impact significatif sur les performances.

Une autre astuce est d'utiliser le bouton milieu de souris (MMB) sur un node pour voir ce qu'il a mis en cache depuis sa dernière évaluation. L'utilisation de la mémoire, les attributs actuellement stockés, etc... Le bouton milieu de souris (MMB) est aussi utilisé que le bouton gauche. Vous pouvez voir si le node est "time dependent" ou non, ce qui aura une incidence sur la façon dont il s'évalue et comment cela affectera ses nodes en dépendance.

Vous pouvez utiliser le bouton droit de souris sur le node et ouvrir la Dependency view de cet opérateur qui vous listera toutes ses références et ses dépendances. Vous pouvez utiliser la touche "d" sur le graph puis, dans le Network Editor Display Options, onglet Dependency, activer un certain nombre d'options (liens et halos) permettant de mieux comprendre les dépendances entre les nodes.

Un File System

Houdini est un file system, en mémoire, et sur le disque sous la forme d'un fichier "cpio" .hip. Si vous le souhaitez, vous pouvez utiliser un shell puis lancer la commande hexpand sur un fichier .hip. Ceci "étalera" le fichier Houdini sous la forme d'une structure de dossier que vous pouvez lire et modifier si vous le souhaitez. Puis rassembler le tout avec la commande hcollapse. Si vous voulez vraiment voir comment Houdini fonctionne en bas niveau, c'est par ici qu'il faut commencer. C'est simplement une commande Houdini hscript qui construit les nodes dans les dossiers des nodes eux-mêmes. Chaque node est construit en trois fichiers distincts:

• Le fichier qui ajoute le node et le connecte aux autres nodes.
• Le fichier de paramètre qui définit les paramètres des nodes.
• Et un fichier qui récupère les infos supplémentaires du node.

Si vous lockez un SOP, les informations de ce node seront rassemblées de manière binaire en un seul et même fichier.

C'est pour cette raison que les fichiers .hip sont très petit et qu'il est inutile et déconseillé de locker ces SOP. Il est préférable de cacher un node sur le disque plutôt que de le locker, mais rien ne vous empêche de le faire. Quand vous ouvrez un fichier .hip, tous les nodes sont ajoutés, connectés, leurs paramètres sont modifiés, et les nodes sont "cookés"/évalués. Il existe différents types de graph de node et les nodes d'un type spécifique ne fonctionnent que dans le dossier d'un type de node spécifique. C'est ce qui fait qu'on peut se retrouver bloquer un peu partout, surtout si on a l'habitude de travailler avec le Build Desktop, que je n'apprécie pas au passage. Il est conseillé d'avoir un arbre quelque part dans l'interface pour visualiser comment le graph se présente quand vous travaillez. C'est également très pratique pour naviguer rapidement dans votre scène. Le Technical Desktop est un bon choix pour quand on récupère le travail de quelqu'un d'autre car il y a une arborescence et quelques autres volets tels que la Details View, Render Scheduler et autres. Si vous voulez utiliser le Technical Desktop et comprendre un travail fait avec le Build Desktop, ouvrez simplement graph puis l'onglet Parameter et maintenant le coté droit est identique au Build Desktop, mais vous pouvez voir la Tree View et voir ou les nodes sont mis.

Technical Desktop

Un nouveau fichier Houdini est un livre non lu, bourré d'idées intéressantes. En utilisant un Desktop qui expose un onglet Tree View, vous pouvez rapidement voir ce que l'utilisateur a essayé de faire en quelques secondes. Encore une fois, utilisez le Technical Desktop dès le départ si vous utilisez le Build Desktop (si vous me connaissez, vous saurez que je vous forcerais à avoir une Tree View sous les yeux). Vous pouvez rapidement traverser la scène et inspecter le graph. Si ce n'est pas assez, vous pouvez ouvrir le Performance Monitor et voir quel node fait le plus gros travail.

Il n'y a pas vraiment besoin de vidéos, juste un fichier .hip. Bien entendu, c'est une vraie aide si la scène est commentée et les nodes nommés en fonction de leurs intentions.

SOP

Les questions comme: Où les Attributs sont stockés, comment les récupérer (en VOP, Python, Expression), Différence entre les Primitives / Points / Vertex / Volume, les différents Contexts, tout spécialement les explications plus générales sur les contextes DOP / POP... Solver et Multisolver... comme un tutorial Houdini général mais de niveau intermédiaire vers avancé...

Restons sur les SOPs.

Dans Houdini, les attributs sont une partie intrinsèque de la géométrie qui est cachée par chaque SOP et non une entité distincte qui doit être gérée indépendamment. C'est ce qui rend les SOPs si élégant. Ce fil entre deux SOP, c'est la géométrie qui passe d'un SOP à l'autre, ces attributs et tout le reste. Et non un lien par attribut (ce qui, dans d'autres logiciels, peut être un attribut géométrie, un attribut paramètre, etc...). Ceci permet à Houdini de manipuler une énorme quantité de géométrie avec beaucoup d'attributs très facilement. Tous les SOPs feront de leur mieux pour traiter les attributs en conséquence (certains mieux que d'autres et pour ces dernier, n'hésitez pas à envoyer un RFE ou un Bug à Side Effects pour voir si quelque chose peut être fait).

Vous pouvez créer des attributs géométriques supplémentaires dans Houdini en utilisant ces SOPs:

• Point SOP créé les attributs de point "standard".
• Vertex SOP créé les attributs de vertex "standard".
• Primitive SOP créé les attributs de primitive "standard".
• Utilisez le SOP Attribute Create pour créer un attribut ponctuel de différentes classes (float, vector, etc...) de point, vertex, primitive ou Detail.
• Utilisez les VEX/VOPs pour créer un attribut de point standard et ponctuel.
• utilisez les SOPs Python pour créer un attribut de géométrie standard ou ponctuel.

Distinction entre point et vertex

Dans Houdini, une clarification qui doit être faite est la distinction entre un attribut de type "point" et un attribut de type "vertex". Certains logiciels utilisent le terme vertex pour désigner soit les attributs de point ou les attributs de prim/vertex. Les jeux vidéos sont attaché à cette définition rendant la confusion encore plus grande, mais hélas, ce n'est pas correct. Dans Houdini, vous devez faire la distinction entre les attributs de point et les attributs de vertex très tôt. Un attribut de point est le niveau le plus bas qu'une information puisse avoir. Par exemple, vector4 P position (la quatrième information étant le poids dans le cas des NURBS) et un attribut de point qui définit un point dans l'espace. C'est tout ce dont vous avez besoin: des points. Pas de primitives ou autres. Vous pouvez ensuite instancier des choses sur ces points au moment du rendu. Vous pouvez assigner n'importe quel attribut supplémentaire sur ce point.

Pour construire une Primitive, vous avez besoin d'un point (dans le cas d'une Primitive vextex) pour référencer une position et un poid. Dans le cas d'un polygone, ce sont les vertex du polygone qui indexent ces points. Vous pouvez visualiser ces informations dans la Details View en inspectant les attributs des vertex. Le numéro de vertex est présentés sous la forme <primitive_number>:<vertex_number> et la première colonne ("Point Num") affiche à quels points chaque vertex se réfère.

Bien évidemment, vous pouvez avoir plusieurs vertex se référant au même point et c'est ce "partage" qui permet d'obtenir un shading doux par défaut, sans utiliser les normales des vertex (car les normales des points seront moyennées automatiquement par les vertex se partageant ce point).

Par exemple, dans le cas d'une Primitive Sphere, il y a un simple point dans l'espace, puis une primitive de type sphere avec un seul vertex qui référence la position du point pour placer la sphère. Puis il y a les données intrinsèques de la sphère (qui seront disponible dans la prochaine version majeur (ndt: Houdini 12)) ou vous pourrez voir les propriétés de cette sphère tel que ces bornes (ou vous pouvez augmenter le diamètre), son volume, etc...

Les autres types de primitives composés d'un seul point et d'un seul vertex sont les primitives de type volume, metaball, grille VDB, archive Alembic, etc...

Comment, par exemple, un SOP de type Transform sait faire la différence entre transformer une primitive de type sphère une primitive de type sphère polygonale? La réponse est qu'il a été programmé pour gérer les primitives de type sphères d'une manière compatible avec n'importe quelle géométrie polygonale. Il en est de même avec les Volumes. Il a été programmé pour gérer les volumes de manière à donner à l'utilisateur final le résultat souhaité.

Cela signifie que tout SOP correctement codés se chargera tout type de primitives de manière cohérente. Certains SOPs sont uniquement destinés aux surfaces paramétriques (Basis, Refine, Carve, etc) et d'autres pour les polygones (PolySplit, etc), mais pour la plupart, la majorité des SOPs peuvent fonctionner avec tous les types de primitives.

Les Attributs

Qu'en est-il des attributs? Le SOP Carve, par exemple, peut découper n'importe quelle géométrie polygonale à un point donné. Il interpolera probablement bilinéairement tous les attributs présents sur la géométrie entrante puis cachera le résultat. C'est ce comportement automatique pour n'importe quel point, vertex, primitive et attributs particuliers qui fluidifie le travail avec le s SOP.

Comment Houdini sait quoi faire avec les vertex attributs quand la position P, la vélocité V et la normale de la surface N doivent être traités différemment? Si par exemple, vous exécuter une rotation via un SOP Transform et que la géométrie a des normales N, des vecteurs de vélocité V, et un cache de position "rest", chaque attribut sera traité correctement (en fait, N car c'est un attribut par défaut connu mais pour les attributs customs, vous pouvez spécifier une "intention" sur le vecteur qui lui dira si il doit être considéré comme un type vecteur, une position en 3 float, ou de type normal de surface). C'est ce comportement automatique avec les attributs combiné au fait que vous n'ayez pas à gérer les attributs à la main qui rend l'utilisation des SOPs facile et puissant, sans avoir à recourir au code.

Rappelez-vous que chaque SOP est un petit programme en lui-même. Il aura ses propres comportements, ces propres variables locales s'il supporte plusieurs attributs dans son code, ses propres paramètres, sa propre manière de gérer les différents types de primitive (polygones, NURBS, Beziers, Volumes, grilles VDB, Metaballs, etc...). Si vous traitez chaque SOP comme un plugin autonome, vous êtes sur la bonne voie. Chaque SOP a sa propre page d'aide rédigée correctement qui vous expliquera ce que ce plugin fait, ce que font les paramètres, les variables locales disponibles s'il y en a, les nodes liés à ce node, et finalement, des fichiers d'exemple que vous pouvez loader dans la scène courante ou une scène externe.

Beaucoup de hardcores users d'Houdini amassent de l’expérience uniquement en trainant dans les fichiers d'exemples de l'aide et c'est une très bonne façon d’apprendre Houdini car tout y est fait de node. Pour vous dire, si nous avions locké la géométrie dans les fichiers d'aides, le téléchargement de Houdini prendrait des gigas. Il n'y a donc que des nodes dans l'aide et ce sont les seules choses que vous ayez besoin de connaitre.

Je ne vais pas parler des DOPs pour l'instant car c'est un type différent pensé pour la simulation. Invariablement, un graph de DOPs finit par être référencé par un SOP pour aller chercher de la géométrie. Donc au final, c'est juste de la géométrie, et donc, des SOPs.

Shelf Tools et scripts

Je grince des dents quand je vois quelqu'un utiliser un Shelf Tools dans un tutoriel... (Je veux savoir exactement ce qui se passe)

Les Shelf Tools où ils sont, mais je comprends ce que vous voulez dire. Oui, il n'y a rien qui puisse connecter un tas de node dans différents graphs puis vous référencer le tout. Faites cela pour en partant de zéro pour une simulation une ou deux fois, super! Faites cela des dizaines de fois par semaine, et bien c'est là que les Shelf Tools et les HDAs vous rendent la vie plus simple.

Mais ne soyez pas effrayés par les Shelf Tools. Tout ces outils sont de simples scripts qui placent les opérateurs ensembles et set les valeurs des paramètres pour vous. Il n'y a aucune quand au fichier .hip que vous sauvez. Si vous êtes du genre ultra-hardcore, vous ne sauvez même pas le fichier .hip et que vous refaites toutes les connections de zéro, tout le temps, chaque fois d'une manière un peu différente, en évoluant, en apprenant. Donc si vous trouvez cette logique des Shelf Tools aussi détestable, sachez que chaque fois que vous ouvrez une scène .hip, vous trichez. :P Ca me rappelle l'argument du menuisier quant à ce qui est construit à la main et ce qui ne l'est pas. Je veux dire, à partir du moment où vous utilisez n'importe quoi d'autres que vos ongles et vos dents pour travailler le bois, vous trichez, mais nous ne faisons pas la distinction pour autant. Les menuisiers utilisent du métal et du verre pour travailler le bois parce que les ongles mettent trop de temps à repousser et les dents endommagées ne repoussent pas. Mais je m'égare...

Racontez ça à des power users d'autres applications qui ont tapé un code propre et impec mais qui ont toujours peur que la prochaine release rende leurs routines favorites obsolètes. Avec des nodes, vous avez un type et des paramètres. S'ils ne changent pas de build en build, ils se chargeront correctement. Je peux ouvrir des fichiers d'avant qu'il soit de type .hip, quand ils portaient l'extension .mot (de Sage pour ceux qui se souviennent) de 1995. Ils s'ouvrent toujours, avec quelques petites erreurs tout de même mais ils s'ouvrent toujours. Un SOP Point est un SOP Point et un SOP Copy est un SOP Copy. Aucune crainte que des trucs deviennent obsolètes. Il suffit de taper la commande "ophide" dans le textport de Houdini et vous pourrez encore trouver les SOPs Limb et Arm (wtf?). LOL!

La première chose que je fais chaque matin? Téléchargez la dernière build. Lire le log des builds. S'il y a quelque chose d'intéressant dans cette build, je fais un test en partant de zéro. Alors lisez forums si vous avez le temps et répondez à des questions à partir de zéro si vous le pouvez. Tout ça au nom de la pratique.

Comme précisé plus haut, gardez à l'esprit qu'un fichier .hip est une simple collection de fichier de script dans un système de dossier sauvé sur le disque. Un HDA Houdini est de la même vaine. Idem pour un Shelf Tool: Un script qui ajoute et connecte des nodes et change leurs paramètres. Générer un amas de géométrie et le stocker dans un node de shape ne vous permettra jamais de savoir comment vous y êtes arrivés.

Afin d'aider l'utilisateur à suivre qui a créé quoi, vous pouvez utiliser le raccourcis clavier "N" dans n'importe quel graph pour basculer le nom du node entre:

Label par défaut

Le nom de l'outil qui a créé ce node

Rien

Ceci combiné aux options d'affichages des dépendances du graph (raccourci "d") devrait vous permettre de comprendre ce que chaque Shelf Tool fait dans votre scene.

Naviger dans le File System Houdini

Si vous voulez creuser encore plus profond, vous pouvez utiliser l'onglet textport et utiliser les commandes:

• opcf (aliasé en cd)
• opls (aliasé en ls)
• oppwd (aliasé en oppwd et pwd)

Et ce, pour naviguer dans la scène Houdini via le textport comme vous le feriez dans un shell unix.

Une commande que j'aime montrer à ceux qui s’intéressent plus particulièrement à comment Houdini fonctionne. Taper (par exemple):

cd /obj

Puis de faire un:

opls -al

Et voir leur liste de node:

/ -> cd /obj
/obj -> opls
grid_object1
/obj -> opls -al
----h--- ipr_camera (3)                 May  3 17:22 Narann [rwxrwxrwx]
d---e--- grid_object1 (5)               May  3 17:31 Narann [rwxrwxrwx]
----h--- ipr_camera1 (3)                May  3 17:26 Narann [rwxrwxrwx]
----h--- ipr_camera2 (3)                May  3 17:26 Narann [rwxrwxrwx]

Vous aurez un retour très similaire à ceux qu'on peut avoir dans un shell unix listant les fichiers. Gardez à l'esprit que Houdini "EST" un file system avec des dépendances complexes supplémentaires toutes triées pour vous. Il y a des permissions user/group/other. Oui, vous pouvez utiliser opchmod (non aliasé en chmod mais ça se fait facilement faite avec la commande hscript alias) pour changer la permission des nodes.

Par exemple:

opchmod 000 * supprimera toutes les permissions read/write/execute de tous les nodes du répertoire courant.

/obj -> opchmod 000 *
/obj -> opls -al
----h--- ipr_camera (3)                 May  3 17:46 Narann [---------]
d---e-cs grid_object1 (5)               May  3 17:46 Narann [---------]
----h--- ipr_camera1 (3)                May  3 17:46 Narann [---------]
----h--- ipr_camera2 (3)                May  3 17:46 Narann [---------]

Et devinez quoi? Les paramètres ne sont plus disponibles à la modification.

N'oubliez pas de le dire à vos victimes ou de leur régler leur souci sinon vous pourriez bien perdre votre job tout seul. opchmod 777 * rend les permissions. Un opls -al vous permettra de le vérifier.

Maintenant, vous savez ce que notre système de licence fait aux états des nodes. Vous pouvez modifier les permissions read et execute de tous les nodes, mais la permission write d'un node DOP ou SOP n'est modifiable que si vous possedez la licence Houdini FX.

Tout en sachant ça, le fichier .hip est vraiment un livre d'histoire avec beaucoup de façon de savoir qui a créé quel node et quand, quel tool il a utilisé pour le créer, quelles dépendances possèdent ce node, est ce qu'il est time dépendant, et plus... Tout ça en inspectant rapidement.

Conclusion

Après tout ça, apprendre Houdini se résume simplement à apprendre chaque node et pratiquer, pratiquer, pratiquer. Oh! Et si vous ne le savez pas encore, beaucoup de nodes ont une histoire riche (certains sont plus vieux de 30 ans) et peuvent faire beaucoup de choses. Donc inspirez-vous de tout ça, lisez la documentation des nodes, étudiez les fichiers d'exemples et avancez. Plus vous maitriserez de nodes, plus vous aurez de manière de résoudre un problème, plus vite vous travaillerez et meilleurs vous serez. Plus vous ferez ça et plus pertinents seront vos choix. La courbe d'apprentissage est sans fin, visuel et WYSIWYG. B)