[PYTHON] Compensez le manque de référence Maya Node

Bonjour à tous. Il semble que ** Maya Road Book ** sera bientôt publié (Présenté par l'auteur) Selon la maya préférée du hacker maya, Dependency Node (DG) , Graphe acyclique dirigé (DAG) sera expliqué. Je suis heureux! Maintenant, préparons le nœud maya en nous référant au document officiel (http://help.autodesk.com/cloudhelp/2017/JPN/Maya-Tech-Docs/Nodes/index.html) [^ 3] .. Si vous êtes un passionné de conversion d'unités, vous le remarquerez bientôt. Oui, je n'ai pas écrit sur decomposeMatrix / eulerToQuat / quatToEuler! Que voulez-vous dire! Cette ** référence ne contient aucun nœud dérivé du plugin **! Avec cela, il est désespéré que le MASH et le Bifrost super cool puissent être contrôlés par des nœuds à partir d'un script. Quel bordel * (Si vous connaissez l'emplacement de la référence sur le nœud dérivé du plug-in, faites-le moi savoir) * Mais ne soyez pas triste! ** Bien qu'il ne soit pas officiel, il est publié sur http://yamahigashi.github.io/maya-node-list/index.html **. Il s'agit de ** Conversion Hodai **. Yay

[^ 3]: Si vous souhaitez vous préparer, n'allez pas ici http://help.autodesk.com/view/MAYAUL/2017/JPN/?guid=__files_DAG_Hierarchy_htm ou http://help.autodesk.com/view/MAYAUL/2017/ Lisez d'abord JPN /? Guid = __ files_Dependency_graph_plugins_htm

La préface de Yota a été allongée, cet article vous expliquera comment récupérer des informations sur les nœuds via un script et comment les exporter vers un document. A travers la génération du document, je vais vous raconter une petite histoire lors de l'exécution du processus souhaité sans démarrer l'interface graphique de maya. Tous les scripts utilisés pour générer le document se trouvent sur ici. (Cependant, veuillez noter que j'utilise beaucoup de très mauvaises manières. * Je pensais que je ne le verrais jamais deux fois. * Veuillez n'apporter que l'idée.)

Aperçu

Tout d'abord, le flux général de génération de documents est

1. Exportez les informations de nœud de mayapy.exe avec reStructured Text (rst)
2. Convertissez le premier exporté en HTML à l'aide de sphinx

Il y a deux étapes.

Début du lot

Vous pouvez également exécuter l'exportation à partir de l'interface graphique maya normale, mais ici nous allons essayer le démarrage par lots. Veuillez vous référer à la documentation officielle pour utiliser mayapy.exe. http://help.autodesk.com/view/MAYAUL/2017/JPN/?guid=GUID-83799297-C629-48A8-BCE4-061D3F275215

Script de lancement

Flux mayapy le script de première génération à partir de la ligne de commande C: \ Program Files \ Autodesk \ Maya2017 \ bin \ mayapy.exe dump_maya_nodes.py Etc.

Le but du processus est ** [Exporter la liste des informations sur les nœuds] **. Réfléchissons maintenant à la manière de gérer un grand nombre de nœuds. Pour écrire les informations du nœud, vous devez d'abord identifier le nœud. Il semble que l'ID puisse être utilisé pour cela. Alors, comment obtenez-vous l'ID? Google? Non Laisser l'ordinateur faire ce qu'il fait. C'est vrai, comptons à partir de 0. [^ 1] Créez un nœud de manière détournée, et s'il y a un hit, continuez le traitement.S'il n'y a rien, il passera tel quel. [^ 2]

C'est quand même, alors exécutons-le en parallèle. Utilisez le module multiprocessing.

[^ 1]: Pendant que je faisais cet article, j'ai remarqué que MPlugin pourrait être capable d'extraire MTypeId. [^ 2]: En passant, je ne sais pas quoi faire avec MTypeId. Je me demande quoi utiliser comme référence lors de la création de mon propre plug-in de nœud, car il s'agit d'un plug-in intégré ... Émettre un identifiant dans Autodesk? Hmm

dump_maya_nodes.py

# https://github.com/yamahigashi/maya-node-list/blob/gh-pages/tool/dump_maya_nodes.py#L1265-L1294
def dump_id_range_using_multiprocessing():

    import multiprocessing as mp
    import itertools  # python 2.x can not iterate over 'long int' cause overflow error
    range = lambda start, stop: iter(itertools.count(start).next, stop)

    process_count = 4  # mp.cpu_count()
    po = mp.Pool(process_count)
    po.map(initialize_process, xrange(process_count))

    start = 0x30000000
    steps = 0x00001000
    end = 0x90000001
    ceil = 1e4

    while start < end:
        # print('start processing...', start)
        res = po.map_async(dump_node_by_id, range(start, start + steps))

        # wait a moment as the main process eat up huge memory
        # when runnig continuously
        if len(po._cache) > ceil:
            print(".", hex(start))
            res.wait()

        start = start + steps

    po.close()
    po.join()

    print('... done processing')

Ça ressemble à ça.

Je vais omettre le multitraitement. Regardons l'ordre de traitement. Tout d'abord, préparez un processus pour process_count dans le pool. Initialisez le processus préparé et chargez le plug-in.

    po.map(initialize_process, xrange(process_count))

C'est une ligne de. La réalité est

def initialize_process(*args):
    load_plugins()


def load_plugins():

    default_plugins = [
        "ik2Bsolver.mll",
        "objExport.mll",
        "dgProfiler.mll",
        "DirectConnect.mll",
        "quatNodes.mll",
        "matrixNodes.mll",
        "ikSpringSolver.mll",
        "animImportExport.mll",
        ...
    ]

    def _l(name):
        try:
            # print "load plugin load: ", name
            cmds.loadPlugin(name)
        except:
            pass
            # print "pass plugin load: ", name

    for n in default_plugins:
        _l(n)

Ça ressemble à ça. Lorsque vous commencez la mayothérapie, elle naîtra à l'état pur, elle chargera donc ce dont vous avez besoin. Ici, nous ne chargeons que le plug-in, mais décrivons-le si nécessaire en fonction du processus tel que le chargement du module.

Définissez l'identifiant au début du traitement, le nombre d'étapes et l'identifiant de fin, tournez la boucle et exécutez le traitement parallèle avec po.map_async à l'intérieur. Si vous souhaitez traiter une grande quantité de cette manière, vous pouvez simplement tourner le pistolet tel quel - c'est-à-dire, selon ce code, si vous faites map_async (dump, range (start, end)) en dehors de la boucle while, vous mourrez à cause de la pression de la mémoire. Par conséquent, après avoir divisé les étapes appropriées et passé à un certain niveau, res.wait () est inséré. Évitez de manquer inépuisablement de ressources de la machine. Le nombre optimal d'étapes et le plafond varieront en fonction de la situation et nécessiteront quelques essais et erreurs.

De plus, si vous définissez process_count sur le noyau de la machine, vous ne pouvez rien faire pendant l'exécution, c'est donc une bonne idée de laisser une certaine marge. Cela prendra une heure.

Obtenir des informations sur le nœud

ici

# https://github.com/yamahigashi/maya-node-list/blob/gh-pages/tool/dump_maya_nodes.py#L43-L91
def dump_node_by_id(raw_id):
        id = om2.MTypeId(raw_id)
        nc = om2.MNodeClass(id)

        typ = om2.MFnDependencyNode()
        obj = typ.create(id, 'test')
        dpn = om2.MFnDependencyNode(obj)

        attributes = {}
        for num in xrange(ac):
            a = om2.MFnAttribute(dpn.attribute(num))
            k, v = inspect_attribute(dpn, a)
            attributes[k] = v

Je vais créer un nœud au fur et à mesure et explorer ses attributs. Voir le code de ʻinspect_attribute () `.

Exporter vers le premier

Si vous souhaitez exporter quelque chose qui est bien formaté, il est pratique d'utiliser un moteur de modèle. Ici, j'ai utilisé Jinja2 (sanctuaire = tempuru). Par conséquent, plaçons le module là où il peut être vu de maya python. Le résultat de la recherche d'attribut du nœud est appliqué au modèle et généré. https://raw.githubusercontent.com/yamahigashi/maya-node-list/gh-pages/source/_templates/node.tpl.rst Voici le modèle.

Shpinx

Une fois que vous êtes arrivé à ce point, il ne vous reste plus qu'à lancer Sphinx. Exécutez make html.

Mise en garde Si vous n'avez pas de projet sphinx, créez et configurez un projet sphinx avant de créer le premier. http://sphinx-users.jp/gettingstarted/make_project.html

en conclusion

Qu'as-tu pensé. C'était une précipitation, mais j'ai regardé la génération du document de liste de nœuds de maya. Chaque personne lisant cet article souhaite générer une liste de nœuds! Il est peu probable qu'une telle chose se produise, et si c'était le cas, quelque chose ne va pas dans le monde. Cependant, il est souvent nécessaire d'avoir des informations qui ne sont pas documentées, pas seulement maya. J'espère que l'essence expliquée ici vous sera utile lorsque vous rencontrez une telle situation. Elle n'apparaissait pas dans cet article, mais en Python, la fonction intégrée help () (également [apparue] dans l'article de @ sporty (http://qiita.com/sporty/items/681aa8bbeac81c71c518). ), Les modules Dir () et ʻinspect` vous permettent d'analyser le code existant. En C #, la réflexion, etc. peut être utilisée. La capacité de trouver des documents est également très importante, mais il sera utile un jour de garder à l'esprit qu'il existe un tel moyen lorsque cela seul ne suffit pas.