ici on parlera rendu

Table of Contents

Un null pour run du python

on va creer un node pour run des scripts python a partir d'un null.

  • modifier un null avec edit parameter interface
  • mettre un parm string, en multi-string et en langage python l'appeller pythonCode
  • mettre un bouton (le nommer RunCode par exemple) avec ce code en callback script:
exec(kwargs['node'].parm('pythonCode').eval())

Mantra legacy

Shadow matte

Comment recupper uniquement les ombres d'un objet sur un sol (par exemple).

  • aller dans le contexte shop
  • dropper un node shadow matte
  • assigner ce materiaux sur le sol
  • dans le node mantra mettre le sol en forced object et les autres objets en matte object
  • faire un rendu, checker l'apha, il contient les ombres. le tour est joue !

shadowMatte

Materiaux

Modifier tout les materiaux d'un coup

ici on chercher a modifier un parametre des nodes normal_map du moteur arnold


import hou
#color
color=hou.Color((1,1,1))

import nodesearch
#cherche par hda
matchType = nodesearch.NodeType("*arnold::normal_map*")
#cherche quimporte le nom du node
matchName = nodesearch.Name("*")
match = nodesearch.Group([matchType,matchName])

#!!! cherche a partir de ce chemin !!!
net = hou.node("/")
#cherche de maniere recursive

# tout ce joue ici
for node in match.nodes(net,recursive =True):
    node.setColor(color)
    #specific child
    nodePath = str(node.path())
    hou.node(nodePath).setColor(color)
    hou.node(nodePath).parm("strength").set(0.6)

  • on cherche dans toute la scene

  • si on veu cibler un matnet en particulier il faut faire : net = hou.node("chemin/vers/un/matnet ")

  • on set le parametre "strenght" a 0.6

  • mettre dans un null qui run du python, faire run.

Convertir toutes les textures en .rat

Mantra converti en rat les textures a chaque rendu. Dans certain cas on voudra eviter cette etape pour optimiser les temps de rendu

from os import listdir,path,system,environ,walk

myPath = hou.pwd()
parent = str(myPath.parent().parent().path())
import nodesearch
matchType = nodesearch.NodeType("*cgMaterial*")
matchName = nodesearch.Name("*")
match = nodesearch.Group([matchType,matchName])
net = hou.node("/")
for node in match.nodes(net,recursive =True):
    print (node.path())
    parent = str(node.path())

    print (parent)
    textList = [
    hou.parm(parent+"/texture_diffuse_base_color/map").eval(),
    hou.parm(parent+"/texture_roughness/map").eval(),
    hou.parm(parent+"/texture_normal/map").eval()
    ]
    print (textList[0])

    ext = "exr"

    for i in textList:
        if len(i)>1:
            print "cool"
            pathSplit= i.split("/")
            roots = "/".join(pathSplit[:-1]) + "/"
            print roots
            dirPath = roots
            result = next(walk(dirPath))[2]
            print (result)

            for file in result:
                if file[-3:]==ext:
                    file = roots + file
                    print file
                    system("iconvert "+file+" "+file[:-3]+"rat")  
                    ratMap = file[:-3]+"rat"
                    print ("...")
                    print ("convert to -> "+ratMap)      
            break
  • on va chercher tout les cgMaterial (a remplacer par le nom de votre shader maison)
  • si on veu cibler un matnet ou un sahder en particulier il faut faire : net = hou.node("chemin/vers/un/matnet ")
  • on va lister les map qu'on veut convertir
  • on les enregistre au même endroit dans le système

Changer les extension des texture de exr vers rat par exemple

on va remplacer .exr par .rat dans les chemin des textures

from os import listdir,path,system,environ

# node courant
myPath = hou.pwd()
# parent deux niveau au dessus 
parent = str(myPath.parent().parent().path())
import nodesearch
#cherche par hda
matchType = nodesearch.NodeType("*texture::2.0")
matchName = nodesearch.Name("*")
match = nodesearch.Group([matchType,matchName])
net = hou.node("/")

ext = "exr"
toExt = "rat"

for node in match.nodes(net,recursive =True):
    map = node.parm("map").eval()

    if map[-3:]== ext :
        ratMap = map[:-3]+ toExt
        node.parm("map").set(ratMap)
        print ("rename -> " +ratMap)
  • on va chercher tout les node texture::2.0 (a remplacer par le nom de votre node de texture)
  • si on veu cibler un matnet ou un shader en particulier il faut faire : net = hou.node("chemin/vers/un/matnet ")
  • on remplace l'extension .exr par .rat

Intercaler un node entre deux nodes

# exemple de code python
# ajouter un node remap 
# node A
roughLum  = hou.node('../luminance2')
#node B
roughBind = roughLum.outputs()[0] 
#node C entre A et B
fit = roughLum.createOutputNode("fit")
roughBind.setInput(0,fit)
#range bien le node C 
fit.moveToGoodPosition()
# mettre des valeurs par defaut
fit.parm("destmax").set(0.5)

Modifier des parametre d'un matériaux

# exemple de code python
# set toutes les texture comme suis 
racineTexture = "$HFS/houdini/pic/"
# diffuse texture
hou.parm('../texture_diffuse/map').set(racineTexture + "Mandril.pic")
# ior texture
hou.parm('../texture_ior/map').set("")
#ior valeur 
hou.parm('../principledshader1/ior').set(1.2)
#roughness texture
hou.parm('../texture_roughness/map').set("")
#metalness texture
hou.parm('../texture_metalness/map').set("")
#normal texture
hou.parm('../texture_normal/map').set("")
#displace texture
hou.parm('../displacetexture1/texture').set("")

#uncheck les tic box udim
hou.parm('../texture_diffuse/udim').set(0)

Faire des opération sur une selection de nodes

nodes = hou.selectedNodes()

for node in nodes:
    txt = node.parm("map").eval()
    txt = txt.replace("<udim>","%(UDIM)d")
    node.parm("map").set(txt)

setter des parametre pour tout les nodes textures d'un matnet par exemples

# exemple de code python
#color
blue=hou.Color((1,0,1))
# node courant
myPath = hou.pwd()
# parent deux niveau au dessus 
parent = str(myPath.parent().parent())
import nodesearch
#cherche par hda
matchType = nodesearch.NodeType("*texture*")
#cherche quimporte le nom du node
matchName = nodesearch.Name("*")
match = nodesearch.Group([matchType,matchName])
#!!! cherche a partir de ce chemin !!!
net = hou.node("/obj/chaiseLongue/mantra_mat/")
#cherche de maniere recursive

# tout ce joue ici
for node in match.nodes(net,recursive =True):
    #node.setColor(blue)
    #specific child
    try:
        txt = node.parm("map").eval()
        txt = txt.replace("<udim>","%(UDIM)d")
        node.parm("map").set(txt)
        print (txt)
    except:
        pass

Arnold legacy

custom aovs

On va creer un aovs a partir d'un attribut custom dans un shader (l'equivalent d'une bind import/export de mantra)

doc arnold

  • dans un arnold material builder
  • on drop un node user_data en float ou rgb ou autre selon les besoins
  • on le connect a un aov_write en float ou rgb ou autre selon les besoins on lui donne un nom ex: "myColor"
  • on drop un node passthrough
  • on connect le standard_surface en input passthrought et le aov_write en eval1
  • on connect le passthrough au material_output
  • dnas le node de rendu arnold dans l'onglet output ajoutez un aovs et nommez le "myColor"
  • et le tour est joué

customAovs

Houdini