python nuke unpremult for all read and shuffle node

    Voici un petit script qui fait gagner du temps, il crée un node unpremult sous tout les nodes read, shuffle et le script recrée les connections des dependences:

 
#permet de recupere un dictionnaire contenant le node connecte ainsi que l'id de son input
def getOutput(node):
    dep = node.dependent()
    id = []
    for d in dep:
        ip = d.inputs()
        for i in range(ip):
            if d.input(i) == node:
                id.append(i)
    dictNodeInput = dict(zip(dep, id))
    return dictNodeInput


#permet de connecter tout les inputs d'un dict cree par la fonction getOutput() a un node
def setOutput(node, dictInput):
    for e, i in dictInput.items():
        e.setInput(i, node)
    return


read = nuke.allNodes("Read")
s = nuke.allNodes("Shuffle")

for p in s:
    read.append(p)

for r in read:
    d = getOutput(r)
    unp = nuke.nodes.Unpremult()
    unp.setInput(0,r)
    setOutput(unp, d)

Petite astuce dict zip python.

    Voici une petite astuce pour simplifier les attributions "keys", "values" d'un dictionnaire.
Lorsque l'on a deux listes et qu'on veut les combiner dans un dictionnaire on peut le faire sans boucle avec la fonction zip de la class dict. Comme ceci:

 

keys = ['A', 'B', 'C']

values = [1, 2, 3]

dic = dict(zip(keys, values))

print(dic)

>>> {'A': 1, 'B': 2, 'C': 3}

PySide/PyQt QDesktopWidget

Petit pense-bête sur le module Qt QDesktopWidget:

 

#module pour les info ecrans
ff = QtGui.QDesktopWidget()

#recupere les dimension des ecrans.
ff = QtGui.QDesktopWidget().screenGeometry(widget)
#recupere l'index de l ecran ou est place le widget
ff = QtGui.QDesktopWidget().screenNumber(widget)
#recupere le nombre d'ecran du system
ff = QtGui.QDesktopWidget().screenCount()

Slate Material Editor et Py3dsMax (sme)

    Voici quelques fonctions bien utiles pour scripter avec le slate material editor (sme), je vous les présentes a travers un petit script qui permet de stocker tout les matériaux des objets sélectionnés dans une nouvelles vue du sme.

 

from Py3dsMax import mxs

#je recupere la liste des objets selectionnes:
sel = mxs.selection

#je cree une nouvelle vu et recupere son node:
nodeView = mxs.sme.GetView(mxs.sme.CreateView("stock_view"))

#je cree la boucle qui traitera chaque objets:
for node in sel:
 
    #je recupere le node material:
    mat = node.material
 
    #je creer le node material dans la nouvelle vue, je lui donne une position grace a la fonction point2 vector.
    nodeView.CreateNode(mat, mxs.point2(0,0))
 
    #j'execute une commande maxscript qui permet de mettre en ordre les materiaux dans la nouvelles vue.
    mxs.execute('actionMan.executeAction 369891408 "40060"')

Py3dsMax et les modifiers

Voici les principales fonctions py3dsmax pour travailler avec les modifiers:

 
#import de la library py3dsmax
from Py3dsMax import mxs

#cree une liste des objets selectionne
sel = mxs.selection

#cree un modifier avant l'index 6 (l'index 1 est le modifier le plus haut de la pile) 
#pour avoir un modifier toujour en bas de la pile mettre un grand before (ex: 10000)
mxs.addModifier(sel[0], mxs.Skin_Wrap(), before = 6)

#la liste des modifiers de l'objet
ld = sel[0].modifiers

#recupere un modifier par son nom
sk = sel[0].modifiers["Skin_Wrap"]

#recupere le node d'un objet par le nom
corp = mxs.getNodeByName("name_obj")

Zbrush to Max pourquoi c'est mou ?

    J'ai souvent entendu et eu ce problème, "j'ai sorti une décimation (ou high poly) de zbrush avec mes normales... et quand je rends avec max ma modé est toute mole et je perds beaucoup de détails."

Le problème vient des smooth group, faut savoir que par défaut max import des .obj avec un smooth group commun pour tout les poly. Vous pouvez voir ça dans l'editpoly, face mode, smoothing groups.

Tout les poly on un smooth group a 1.










Donc avant de rendre votre modé sortie de ZBrush pensez bien a "Clear All" les smooth groups.

Voila, c'est bête mais on y pense pas toujours.
En image, un petit comparatif:

 Avec smoothing group a 1.

Sans smoothing group.

La modé reste en peu moche (pas de lighting, shader, texture ..)  mais on peu voir qu'on gagne réellement en dureté et en détails.

la recursivité ou la fonction dans la fonction

Voici mon dernier petit utilitaire écrit en python pour 3ds max (py3dsMax), il s'agit d'une boucle récursive, c'est a dire une boucle infinie qui analyse des "éléments" les un après les autres jusqu’à qu'on lui signal par une "clé" de stopper la boucle.

Par exemple c'est très pratique lorsqu'on a des arbres nodales et qu'on veut effectuer une tache sur chacun de leurs nodes:

 


from Py3dsMax import mxs

#le nouveau nom appliqué a tout les nodes.
newName = "Name"

#je recupere ma selection d'objet.
sel = mxs.selection

#je recupere le nombre de slot du material appilque a ma selection.
idMap = mxs.getNumSubTexmaps(sel[0].material)

#je rename le material
sel[0].material.name = newName + sel[0].material.name 

#Je lance ma fonction recursive.
renameNode(idMap, sel[0].material)


def renameNode(idMap, sel):

 for i in range(1, idMap+1):
  slot = mxs.getSubTexmap(sel, i)
  if slot == None :
   print("empty slot")

  else:
   slot.name = newName + slot.name 
   idMap = mxs.getNumSubTexmaps(slot)
   for i in range(1, idMap+1):
    #je relance ma fonction dans cette meme fonction:
    renameNode(idMap, slot)