API Blender Python dans Houdini (Python 3)

Python 3 devient Production Builds dans Houdini 18.5

Houdini 18.5 --Python 3 a été ajouté à Production Builds Items. Maintenant que vous pouvez utiliser Python3, vous devriez pouvoir utiliser des bibliothèques qui ne sont disponibles que dans la série Python3! Donc, cette fois, je vais mettre bpy (Blender Python) qui peut être utilisé dans Python 3.7 dans Houdini.

J'ai utilisé la version Windows suivante de Houdini. houdini-py3-18.5.351-win64-vc141.exe

Construire bpy

Étant donné que bpy en tant que module Python n'est pas actuellement distribué, il est nécessaire de le construire à partir du code source en se référant à ce qui suit. Building Blender as a Python Module

Établir un environnement de construction

Vous pouvez facilement trouver un article japonais sur la construction de Blender à partir du code source, donc si vous avez besoin de plus d'informations, veuillez le chercher.

• Visual Studio 2019
• CMake
• Git
• Subversion

Peut-être que ce n'est pas grave si la zone est installée ...?

Supprimer le code source

Je vais supprimer le code source en me référant à https://developer.blender.org/diffusion/B/. Je pense que vous pouvez le compresser à partir du miroir sur github.

Construire

Si vous développez le code source, vous verrez la structure de répertoire pour ce qui suit.

Ouvrez une invite de commande dans ce répertoire (où se trouve make.bat)

make bpy

Lorsque vous exécutez, les autres bibliothèques requises pour la construction seront supprimées par Subversion et construites. (Dès que vous démarrez, il vous sera demandé si vous souhaitez supprimer les autres bibliothèques dont vous avez besoin, alors appuyez sur y pour continuer). La première fois prendra beaucoup de temps.

Organiser les artefacts de construction pour la lecture dans Houdini

Construire des artefacts (répertoire du code source de blender) \ .. \ build_windows_Bpy_x64_vc16_Release \ bin \ Release C'est dedans.

bpy.pyd, libfftw3-3.dll Placez ces deux dans le répertoire lisible en python de Houdini. Les DLL requises peuvent augmenter ou diminuer à mesure que la version de Blender change. Ici, il est disposé ci-dessous. C: \ Users \ (nom d'utilisateur) \ Documents \ houdini18.5 \ python3.7libs

2.90 (version intégrée du mélangeur)

Placez ce dossier dans le répertoire où se trouve l'exe Houdini installé. La définition de variables d'environnement peut aider ailleurs (non vérifiée). Ici, il est disposé ci-dessous. C:\Program Files\Side Effects Software\Houdini 18.5.351\bin

Utilisez l'API Blender Python

Confirmer l'importation bpy

Il est enfin prêt à être utilisé. Assurez-vous que ʻimport bpy` peut être exécuté sans erreur dans Python Shell ou Python (SOP). S'il y a un problème avec l'artefact de construction ou l'emplacement de placement, une erreur se produira ou Houdini plantera.

Lire le fichier .blend

Créez un processus pour lire un fichier .blend avec Python (SOP).

Préparation des données de test

J'ai préparé un .blend avec des cubes et Susanne. Susanne est coupée en deux et les modificateurs Miroir et Subdivision sont définis.

Écrire du code Python en Python (SOP)

Nom dans l'attribut primitif N, uv avec les attributs Vertex J'ai écrit le code à lire.

Les paramètres sont les suivants.

import os
import bpy
from bpy_extras.io_utils import axis_conversion

node = hou.pwd()
geo = node.geometry()

#Préparez les attributs à définir
name_attrib = geo.addAttrib(hou.attribType.Prim, 'name', '')
normal_attrib = geo.addAttrib(hou.attribType.Vertex, 'N', (0.0, 0.0, 0.0))
uv_attrib = geo.addAttrib(hou.attribType.Vertex, 'uv', (0.0, 0.0, 0.0))

#Lire les paramètres
blend_file = node.parm('blend_file').evalAsString()
apply_modifier = node.parm('apply_modifier').evalAsInt()
object_names = [ s.strip() for s in node.parm('objects').evalAsString().split() ]

if len(blend_file)>0:
    # .Mélange ouvert
    bpy.ops.wm.open_mainfile(filepath=blend_file)
    #Lire tous les objets si aucun nom n'est défini
    if len(object_names)==0:
        object_names = bpy.data.objects.keys()
else:
    #Ouvrez le fichier initial du blender et éteignez Susanne
    bpy.ops.wm.read_homefile(app_template='')
    bpy.ops.mesh.primitive_monkey_add()
    object_names = ['Suzanne']

depsgraph = bpy.context.evaluated_depsgraph_get()
#Une matrice qui transforme l'orientation de l'axe du mixeur en l'orientation de l'axe Houdini
axis_conv_mat = axis_conversion(
    from_forward='-Y', from_up='Z',  
    to_forward='Z', to_up='Y'
    ).to_4x4()
    
#Ouvre un objet avec le nom spécifié
for obj_name in object_names:
    obj = bpy.data.objects[obj_name]
    if obj.type!='MESH':
        continue
    
    #Appliquer des modificateurs si nécessaire
    ob_for_convert = obj.evaluated_get(depsgraph) if apply_modifier else obj.original

    #Extraire le maillage de l'objet
    try:
        me = ob_for_convert.to_mesh()
    except:
        me = None
    if me is None:
        continue
        
    #Appliquer la transformation d'axe et la transformation d'objet au maillage
    me.transform( axis_conv_mat @ obj.matrix_world )
    
    #Que faire si une échelle négative est appliquée
    if obj.matrix_world.determinant() < 0.0:
        me.flip_normals()
    
    #Calculer le sommet normal
    me.calc_normals_split()

    #Obtenez des données UV
    uv_layer = me.uv_layers.active.data[:] if len(me.uv_layers) > 0 else None

    #Créer des points
    points = [ hou.Vector3(v.co) for v in me.vertices ]
    pt_list = geo.createPoints(points)

    #Comme l'ordre des sommets des polygones est différent entre mélangeur et houdini, convertissez
    loop_indices_list = list()
    for mpoly in me.polygons:
        count = len(mpoly.loop_indices)
        loop_indices_list.append( [ mpoly.loop_indices[(count-i)%count] for i in range(0, count) ] )

    for loop_indices in loop_indices_list:
        poly = geo.createPolygon()
        poly.setAttribValue(name_attrib, obj_name)
        for i in loop_indices:
            #Créer un polygone
            v = poly.addVertex( pt_list[ me.loops[i].vertex_index ] )
            # N attribute 
            v.setAttribValue(normal_attrib,  me.loops[i].normal)
            # uv attribute 
            if uv_layer:
                uv = uv_layer[i].uv
                v.setAttribValue(uv_attrib, (uv[0], uv[1], 0.0))

Le paramètre Nom de l'objet peut maintenant être sélectionné à partir de ▽ dans le script de menu comme indiqué ci-dessous.

import os
import bpy

name_list = list()

node = hou.pwd()
blend_file = node.parm('blend_file').evalAsString()
#Vérification de l'existence du fichier
if not os.path.exists(blend_file):
    return name_list

#Énumérer les noms des objets Mesh
objects = bpy.data.objects
for obj in objects:
    if obj.type == 'MESH':
        name_list.extend( [obj.name]*2 )

return name_list

J'écris un commentaire dans le code, donc je ne l'expliquerai pas en détail. Le code pour obtenir les informations de maillage avec l'API Blender Python (Répertoire d'installation de Blender) \ (version de Blender) \ scripts \ addons Ceux qui commencent par io_ ci-dessous sont des add-ons Importer / Exporter, ce sera donc utile. Le code ci-dessus a été écrit en référence à io_scene_obj.

Autre

Le journal suivant est généré lorsque le fichier .blend est lu par bpy. Je ne savais pas comment arrêter cela de l'extérieur.

Si cela vous gêne, commentez ce code de sortie de journal lors de la construction de bpy et il ne sera pas affiché.

source\blender\blenkernel\intern\blendfile.c

int BKE_blendfile_read(bContext *C,
                       const char *filepath,
                       const struct BlendFileReadParams *params,
                       ReportList *reports)
{
  BlendFileData *bfd;
  bool success = false;

  /* Don't print startup file loading. */
  if (params->is_startup == false) {
    printf("Read blend: %s\n", filepath);
  }
  ...
}