[PYTHON] Wie man Ass / Alembic mit HtoA benutzt

Einführung

Bereits jedes Jahr ~~ Alter ~~ Der jährliche Houdini Adventskalender. Nun, ich habe darüber nachgedacht, was ich schreiben soll, aber da ich Arnold dieses Jahr nur berühre, möchte ich Informationen schreiben, die in HtoA (Arnold für Houdini) hilfreich zu sein scheinen. Arnold ist einer der Renderer

• Houdini(HtoA)
• Maya(MtoA)
• 3dsMax(MaxtoA)
• Cinema4D(C4DtoA)
• Softimage(SitoA)
• Katana(KtoA)
• Gaffer(GafferArnold)
• Blender(BtoA) ―― Darüber hinaus unterstützen Golaem, Massive, Nuke usw. auch Arnold.

Mit anderen Worten, es ist ein Renderer, den die meisten großen Softwareprogramme unterstützen, und es kann als De-facto-De-facto-Standard in der Videoindustrie bezeichnet werden. Darüber hinaus ist es kostengünstig, dass Sie jedes DCC mit einer Batch-Rendering-Lizenz rendern können. Darüber hinaus können Sie Shader nicht nur in C ++, sondern auch in ** O ** pen ** S ** hading ** L ** anguage (OSL) schreiben und MaterialX (später beschrieben) schnell unterstützen. Oder ist es USD als nächstes? Ich freue mich darauf. Der Houdini-Standard-Mantra-Renderer ist eine großzügige Spezifikation, die Houdini-Benutzer kostenlos so oft verwenden können, wie sie möchten. Der Shader ist mit dem bekannten VEX einfach zu schreiben, daher gefällt es mir, aber der Nachteil, dass er nur mit Houdini funktioniert, ist schmerzhaft. Arnold kann in einer Ass-Datei (** A ** rnold ** S ** cene ** S ** ource) gerendert werden (** Kick Ass **), die ein standardisiertes Szenenbeschreibungsformat ist. .. Mit anderen Worten, wenn Sie ein DCC in ass exportieren, können Sie ein beliebiges DCC rendern.

Wenn du Arnold verstehst, ist es besser, Arsch zu studieren. Hier ist eine empfohlene Seite als Referenz. https://arnoldsupport.com/category/ass/

** Beachten Sie, dass Houdini eine Houdini Indie-, Houdini Core- oder Houdini FX-Lizenz benötigt, um einen Drittanbieter-Renderer wie Arnold zu verwenden. Außerdem kann die Houdini Indie-Version keine Ass-Dateien ausgeben: sob: ** Bitte studieren Sie, indem Sie ass in der Houdini Core / FX-Umgebung, der Maya-Umgebung ausgeben (Studentenversion, Heimlizenz ist ebenfalls möglich).

Wenn Sie eine in Maya erstellte Render-Szene rendern möchten, die mit der Houdini-Render-Szene auf Houdini koexistiert, exportieren Sie einfach ass aus MtoA und lesen Sie sie in HtoA. Führen Sie ** Arnold-Menü → Stand In ** exportieren auf MtoA aus, überprüfen Sie die Informationen, die Sie ausgeben möchten, und exportieren Sie die ass-Datei. Fügen Sie einfach ** Arnold Procedural ** oder ** Arnold Include ** in den HtoA / obj -Kontext ein und geben Sie die Ass-Datei an, um Mayas Arnold-Szene direkt auf Houdini aufzunehmen. Für Szenen mit Maya-spezifischen Shadern muss der Pfad dieser DLL im Plugin Path von Arnold ROP angegeben werden. Mit zunehmender Version wird der DCC-spezifische Shader jedoch auf den reinen Arnold-Shader umgestellt. Es wird. Erwartungen für die Zukunft. Ein Beispiel für den Import einer Maya-Szene in Houdini über eine Arschdatei und die Koexistenz mit Mr. Pig. Es ist bequem. Wenn Sie jedoch ein anderes DCC-Objekt in Houdni bearbeiten möchten, müssen Sie es derzeit in einem Zwischenformat wie Alembic / FBX (im Folgenden USD) in Houdini importieren, einen Arnold-Shader zuweisen und es rendern. Darüber hinaus kann es nützlich sein, sich auf Maya vorzubereiten, daher möchte ich es vorstellen.

Die Houdini-Dateierweiterung ist ** hip ** Arnold Dateierweiterung ist ** ass ** ** Hüfte und Arsch !!! **: Denken: Irgendwie scheint es kompatibel zu sein: spy_tone1:

Übergeben Sie beliebige Attribute von Maya über Alembic an Houdini

Fügen Sie Maya-Formen Punkt- / Grundattribute für Houdini hinzu

Houdini benutzt oft die Ruheposition. Ruheposition ist das japanische Wort für "Ruheposition". Wenn es Arnold ist, bedeutet es Pref (Positionsreferenz), und wenn es Maya ist, bedeutet es Referenzobjekt. Der Grund, warum dies erforderlich ist, besteht darin, dass beim Erstellen eines Shaders durch Projizieren einer Textur auf eine Geometrie in 2D / 3D (z. B. Kameraprojektion) die projizierte Textur rutschig erscheint, wenn sich die Geometrie verformt. In diesem Fall verwenden wir die Technik, das Ergebnis der 2D / 3D-Projektion auf die nicht transformierte Geometrie in die transformierte Geometrie zurückzugeben. Wenn Sie sich nicht sicher sind, lesen Sie hier. https://houdini.prisms.xyz/wiki/index.php?title=Rest_Attrib Um die Ruheposition in Maya festzulegen, führen Sie im Menü ** Textur ** ** Texturreferenzobjekt erstellen ** und in Arnold ** Referenzpositionen exportieren * in der Arnold-Eigenschaft der Maya-Form aus, um dies widerzuspiegeln. Ist zu aktivieren *. Ich hasse diese Methode, weil sie Maya-spezifisch ist und auf Geometrie in einem Referenzformat verweist. Und es kann nicht nur in Alembic als Attribut ausgegeben werden. Im Idealfall möchte ich der Geometrie eine Ruheposition als Scheitelpunktattribut hinzufügen und dieses Attribut nach Alembic exportieren.

Sie können Maya-Formen ** optional Scheitelpunkt- / Gesichtsattribute hinzufügen, indem Sie MEL ** erstellen. Ich zeige Ihnen also, wie das geht. ** Im Allgemeinen ** Maya-Scheitelpunktattribut <-> Houdini-Punktattribut, Maya-Gesichtsattribut <-> primitives Houdini-Attribut. Dieses Mal möchte ich die Ruheposition als Scheitelpunktattribut hinzufügen, aber ich möchte auch erklären, wie ein Scheitelpunkt- / Gesichtsattribut hinzugefügt wird, indem ein Gesichtsattribut hinzugefügt wird, das den Shader-Namen für jedes Gesicht enthält.

Der Pymel-Code ist unten. Dies ist ein ** Skript für Maya, das einer Form, der der SG ** einen Arnold-Shader zugewiesen hat, eine Ruheposition und einen shop_materialpath hinzufügt. Da wir die Scheitelpunktkoordinaten im Weltraum erhalten, gehen wir davon aus, dass die Transformation des Objekts, das Sie nach Alembic exportieren möchten, eingefroren ist.

• Ein Scheitelpunktattribut mit dem Namen "rest", das die Positionsinformationen der Geometrie des aktuellen Rahmens speichert
• Ein Gesichtsattribut mit dem Namen "shop_materialpath", das den der Geometrie zugewiesenen Shader-Namen als "/ shop / maya / shader name" speichert

Kann hinzugefügt werden. Wenn Sie dies anwenden, können Sie Velocity und Cd hinzufügen. Versuchen Sie es also bitte.

ausruhen und einkaufen_PyMEL-Skript zum Hinzufügen eines Materialpfads

import pymel.core as pm
#Deklarieren Sie ein Wörterbuch, in dem der Schlüssel der Formname und der Wert ein Paar Listen von Gesichtsattributwerten für diese Form ist
dictAttributes = {}
context = "/shop/maya/"
for eachSG in pm.ls(type="shadingEngine"):
	members = pm.sets(eachSG,q=True,nodesOnly=False)
	#Einspruch gegen SG/Überspringen, wenn keine Komponente zugewiesen ist
	if len(members)==0:
		continue
	#Wenn SG kein Shader zugewiesen ist, überspringen Sie ihn.
	#Ein Surface Shader, bei dem der Eingangsanschluss des aiSurfaceShader von SG in Arnold priorisiert wird. Wenn nicht, wird der Surface Shader des Eingangsanschlusses von SurfaceShader verwendet.
	shader = (pm.listConnections(eachSG+".aiSurfaceShader",p=False,c=False,s=True,d=False) or [""])[0]
	if shader == "":
		shader = (pm.listConnections(eachSG+".surfaceShader",p=False,c=False,s=True,d=False) or [""])[0]
	if shader == "":
		continue
	shaderName = shader.name()
	#Verzweigungsverarbeitung basierend darauf, ob es sich um eine Zuordnung auf Objektebene oder eine Zuordnung auf Komponentenebene handelt.
	#Bereiten Sie auf Objektebene eine Liste vor, die so groß ist wie die Anzahl aller Flächen, und schreiben Sie den Shader-Namen auf alle Elemente in der Liste.
	#Schreiben Sie auf Komponentenebene Informationen zum Shader-Namen in den Index dieser Fläche
	for eachMember in members:
		#Verarbeitung, wenn SG einem Objekt zugeordnet ist
		if type(eachMember) == pm.nodetypes.Mesh:
			dictAttributes[eachMember]={"shader":[],"rest":[]}
			dictAttributes[eachMember]["shader"] = [context+shaderName]*eachMember.numFaces()
			for vtxIndex in range(eachMember.numVertices()):
				position = pm.pointPosition(eachMember+".vtx["+str(vtxIndex)+"]",world=True).get()
				dictAttributes[eachMember]["rest"].append( [position[0],position[1],position[2]] )
		#Verarbeitung, wenn SG an das Gesicht gebunden ist
		elif eachMember._ComponentLabel__ == "f":
			listComponents = pm.ls(eachMember,flatten=True)
			shape = eachMember._node
			if shape not in dictAttributes:
				dictAttributes[shape]={"shader":[],"rest":[]}
				dictAttributes[shape]["shader"]= [""]*eachMember.totalSize()
				for vtxIndex in range(shape.numVertices()):
					dictAttributes[shape]["rest"].append( pm.pointPosition(shape+".vtx["+str(vtxIndex)+"]",world=True) )
			#Schreiben Sie den Shader-Namen in den Index der entsprechenden Liste
			for index in eachMember.indices():
				dictAttributes[shape]["shader"][index] = context+shaderName
restAttributeName = "rest"
shaderAttributeName = "shop_materialpath"
for eachShape in dictAttributes:
	#Attribut "Ruheposition" hinzugefügt
	if not pm.attributeQuery(restAttributeName+"_AbcGeomScope",node=eachShape,exists=True):
		pm.addAttr(eachShape, dataType="string", longName=restAttributeName+"_AbcGeomScope")
	pm.setAttr(eachShape+"."+restAttributeName+"_AbcGeomScope", "var")
	if not pm.attributeQuery(restAttributeName,node=eachShape,exists=True):
		pm.addAttr(eachShape,dataType="vectorArray",longName=restAttributeName)
	pm.setAttr(eachShape+"."+restAttributeName,dictAttributes[eachShape]["rest"])
	#shop_Materialpfadattribut hinzugefügt
	if not pm.attributeQuery(shaderAttributeName+"_AbcGeomScope",node=eachShape,exists=True):
		pm.addAttr(eachShape, dataType="string", longName=shaderAttributeName+"_AbcGeomScope")
	pm.setAttr(eachShape+"."+shaderAttributeName+"_AbcGeomScope", "uni")
	if not pm.attributeQuery(shaderAttributeName,node=eachShape,exists=True):
		pm.addAttr(eachShape,dataType="stringArray",longName=shaderAttributeName)
	pm.setAttr(eachShape+"."+shaderAttributeName,dictAttributes[eachShape]["shader"])

Bei der Ausführung werden benutzerdefinierte Attribute wie unten gezeigt hinzugefügt. Ich denke, dass der Wert im Format eines numerischen Wert- / Zeichenfolgenfelds angezeigt wird, wenn es sich um ein normales Attribut handelt. Da der hinzugefügte rest / shop_materialpath jedoch ein Array-Wert für jeden Scheitelpunkt / jede Fläche ist, kann der Wert nicht über die GUI bestätigt werden. Ich wünschte, ich könnte es im Komponenten-Editor überprüfen. .. .. Ich füge hier absichtlich einen Attributnamen mit dem Namen "attribute name_AbcGeomScope" hinzu, was Sinn macht.

Haben Sie bemerkt, dass beim Hinzufügen eines Array-Wertattributs zu einer Form nicht genügend Informationen vorhanden sind? Ist es ein Objektattribut pro Objekt? Ist es ein vertikales Attribut? Ist es ein gesichtsbasiertes Attribut? Sie müssen es explizit angeben. Selbst in Houdini geben Sie beim Berühren der Wrangle-SOP absichtlich an, welches Attribut von Point / Vertex / Primitive / Detail mit dem Parameter "Run Over" verwendet wird. ** Maya fügt der Form Attribute hinzu ** Oben müssen Sie als zusätzliche Informationen angeben, welches Attribut Scheitelpunkt, Fläche oder Objekt ist. Mayas Alembic Importer / Exporter definiert das Suffix "_AbcGeomScope" als die Metadaten, die diese Rolle spielen. Diese Informationen finden Sie im Code, der auf Alembics Github veröffentlicht wurde. https://github.com/alembic/alembic/blob/master/maya/AbcExport/AttributesWriter.cpp Es scheint, dass Sie "vtx", "fvr", "uni" und "var" für den Wert der Zeichenfolge "_AbcGeomScope" angeben können. Wenn kein anderer Wert oder "_AbcGeomScope" festgelegt ist, wird dies als "const" behandelt, dh es handelt sich um ein Attribut pro Objekt. Dieses Mal wollte Alembic, der von der Maya-Seite geschrieben wurde, als Houdinis Point-Attribut in Houdini und shop_materialpath als uni in Houdini erkannt werden, daher lautet der obige Code Es ist eine solche Bezeichnung.

Bereiten Sie nun das Modell vor. Hier haben wir drei Typen vorbereitet: eine deformierende Kugel, eine Kugel mit einer zugewiesenen Shaderfläche und den Boden. Mit hinzugefügten Attributen und mehreren Geometrien, die Sie nach Houdini exportieren möchten, ausgewählt ** Führen Sie das Menü Cache → Alembic-Cache → Auswahl nach Alembic exportieren ... **. Fügen Sie ein Attribut wie unten gezeigt hinzu.

_AbcGeomScope wird nur von Mayas alembischem Importeur / Exporteur benötigt, um die Art des Attributs zu bestimmen, daher werden nur rest und shop_materialpath benötigt. ** Ogawa ** wird für ** Dateiformat ** benötigt. Arnold unterstützt nur ** Ogawa **. ** Face-Sets schreiben ** ist erforderlich, wenn Attribute pro Gesicht zugewiesen wurden. Als ich die von Maya ausgegebene Alembic-Datei in Houdini importierte, wurde die Ruheposition als restPoint-Attribut erfasst: entspannt: Das primitive Attribut shop_materialpath wird ebenfalls geladen. Wenn Sie einen Shader in diesen Pfad einfügen, ist keine Neuzuweisung von Material erforderlich. Platzieren Sie den Shader im Kontext "/ shop". Mit der Arnold Python-API können Sie die Shader-Informationen in einer aus Maya exportierten Ass-Datei analysieren und als Shader-Diagramm auf Houdini reproduzieren. Es tut mir leid, dass ich die Methode nicht veröffentlichen kann. Sie können es selbst versuchen, indem Sie auf die unten beschriebene Arnold Python-API verweisen: japanese_ogre:

(Hinzugefügt am 13. Dezember 2019) Von HtoA5.0.0 (Arnold6) wurde die Funktion zum Erstellen einer Ass-Datei als Shader-Diagramm hinzugefügt. https://docs.arnoldrenderer.com/display/A5AFHUG/HtoA+5.0.0

Wenn ich nach dem Platzieren des Shaders versuche, ihn mit Arnold ROP zu rendern, wenn ich Alembic als normale Houdini-Geometrie lade, wird er gerendert, aber wenn er noch gepackt ist, wird der Shader nicht reflektiert. So weisen Sie Packed Alembic einen Shader zu

--Verwenden Sie material_attribute --Verwenden Sie MaterialX

• Verwenden Sie aiOperator

Es ist möglich, eine dieser zu verwenden. Die Methode mit MaterialX und aiOperator erlaubt derzeit nur Zuweisungen auf Objektebene.

Shader-Zuweisung mit material_attribute

Die Funktion material_attribute kann den in Packed Alembic definierten shop_materialpath erkennen und Shader zuweisen. Dies ist etwas, was ich schon immer machen wollte, aber es wird mit HtoA 4.2.0 möglich, das dieses Jahr veröffentlicht wurde. https://docs.arnoldrenderer.com/display/A5AFHUG/HtoA+4.2.0 In diesem Versionshinweis

Add per primitive shop_materialpath translation in the alembic procedural

Ist geschrieben. Ja, aus diesem Grund habe ich in Maya das Attribut "shop_materialpath" hinzugefügt. Aktivieren Sie einfach "Referenzierte Materialien exportieren" in Arnold ROP und es wird der Pfad des Attributs "shop_materialpath" in Packed Alembic angezeigt und ein Shader zugewiesen.

Shader-Zuordnung mit MaterialX

Sowohl MtoA als auch HtoA haben MaterialX-Exporteure. Ich mache meinen eigenen Exporteur, weil er so schäbig ist, aber hier zeige ich Ihnen, wie Sie Shader Packed Alembic mit einem Standard-MaterialX-Exporter zuweisen. Was ist MaterialX? Interessenten finden Sie unter https://www.materialx.org/. Eigentlich übersetze ich die Spezifikationen ins Japanische. https://materialx.prisms.xyz/ Wenn Sie mehrere Geometrien in MaterialX ausgeben möchten, die auf Maya ausgewählt sind, führen Sie ** Arnold-Menü Dienstprogramme → Auswahl nach MaterialX exportieren ** aus. Setzen Sie einfach das Ausgabeziel der MaterialX-Datei (.mtlx) auf ** Dateiname ** und den entsprechenden Namen auf ** Look Name ** und ** Export **. Dann wird eine solche XML-Datei generiert. Definieren Sie das Shader-Schema mit dem Element "xi: include". Wenn Sie einen benutzerdefinierten Shader hinzugefügt haben, fügen Sie hier ein neues Shader-Schema hinzu. ** Bemerkenswert ist der Wert des Attributs geom des Elements <materialassign>. ** ** ** MaterialX kann mit dem durch dieses geom-Attribut angegebenen * Platzhalter * auf die interne Geometriehierarchie des Packed Alembic zugreifen. Dieser von Standard MaterialX ausgegebene Wert ist unpraktisch. Dieses Mal schreiben wir den Teil von geom =" / Gonyogonyo " in geom =" * / Gonyogonyo " im Texteditor um. Verbinden Sie einfach die MaterialX-ROP mit der Arnold-ROP, setzen Sie die Auswahl auf den Pfad des Alembic-Objekts, die MaterialX-Datei auf den Pfad der MaterialX-Datei und den Look auf den Look-Namen und das Rendering. Das Shader-Diagramm und die Shader-Zuweisung werden automatisch verarbeitet. .. Das Schöne an MaterialX ist, dass Sie das Shader-Diagramm in HtoA nicht neu erstellen müssen und sich der Hierarchie nicht bewusst sein müssen, da Sie Shader-Zuweisungen mit Platzhaltern vornehmen können. Wie Sie dem Rendering-Ergebnis entnehmen können, ist eine Shader-Zuweisung für jedes Gesicht nicht möglich.

Farbzuweisung mit aiOperator

** material_attribute ** ermöglicht Face-by-Face-Zuweisungen, aber das eigentliche Shader-Diagramm muss im Kontext / shop erstellt werden, was wie eine hohe Hürde erscheint. ** MaterialX ** ist praktisch, aber es kann für Künstler schwierig sein, sein XML zu bearbeiten. Mit ** aiOperator ** kann sogar ein Künstler mit einer kleinen Studie bearbeiten, und Mayas Shader-Diagramm kann als Ass-Datei importiert und gesteuert werden. Wenn ich Arnold berühre, denke ich, dass die Arschdatei nützlich ist. ** Die ass-Datei wird hauptsächlich zur Beschreibung der Szene verwendet, sie wird jedoch auch als Datei vorbereitet, die Shader-Diagramme definiert, als Datei, die Lichter definiert, und als Datei, die Rendereinstellungen definiert. Sie können es als vorbereiten. ** ** ** Erfahren Sie, wie Sie mit aiOperator Maya-Shader-Diagramme über eine Ass-Datei importieren. Geben Sie auf Maya zunächst nur die Ass-Datei des Shaders aus. ** Führen Sie das Arnold-Menü aus → Stand In → Export Stand In **. Aktivieren Sie im Exportelement nur "Shader" und exportieren Sie die Ass-Datei. Nennen Sie diese Datei beispielsweise "ShadersOnly.ass".

Platzieren Sie auf Houdini ein ** Arnold Include ** -Objekt im Kontext / obj. Geben Sie hier die Datei "ShadersOnly.ass" an. Auf diese Weise können Sie Maya-Shader-Diagramme importieren.

Um einem von ** Arnold Include ** erfassten Shader-Diagramm einem beliebigen Objekt zuzuweisen, fügen Sie im Kontext / out den ** Set Parameter ROP ** von aiOperator hinzu und fügen Sie ihn ** Arnold ROP ** hinzu. Verbinden Geben Sie dann unter ** Auswahl ** den Pfad des Objekts ein, dem Sie den Shader zuweisen möchten, und geben Sie im Parameter ** Assignment_1 ** den in der Ass-Datei beschriebenen Shader [0] = "Shader-Name" ein. Als ich versuchte, damit zu rendern, konnte ich einen Shader zuweisen. Sie können anderen Objekten Shader zuweisen, indem Sie auf die gleiche Weise eine Verbindung zu Arnold ROP herstellen.

e? : Ohr: Ist es lästig?

Nun, das stimmt. Erstellen wir also ein Skript, das die ass-Datei entschlüsselt und automatisch ** aiOperator ** einrichtet. Die hier benötigte Ass-Datei enthält die Shader-Informationen und die Form, die diesen Shader bindet. Die von ** Arnold Include ** gelesene Ass-Datei enthält nur Shader-Informationen, nicht welchen Shader an welche Form gebunden werden soll. Führen Sie daher ** Export StandIn ** erneut aus und Aktivieren Sie im Element "Exportieren" die Option "Formen" und "Shader", um die Ass-Datei zu exportieren. Zum Beispiel "ShapesShaders.ass".

Python-Skript, das aiOperator automatisch einrichtet

import arnold
arnold.AiBegin()
assFilePath = "F:/AdventCalendar2019/ShapesShaders.ass"
dicShapes={}
result = arnold.AiASSLoad(assFilePath)
nodeIter = arnold.AiUniverseGetNodeIterator(arnold.AI_NODE_SHAPE)
while not arnold.AiNodeIteratorFinished(nodeIter):
	node = arnold.AiNodeIteratorGetNext(nodeIter)
	nodeName = arnold.AiNodeGetName(node)
	nodeEntry = arnold.AiNodeGetNodeEntry(node)
	if nodeName == "root" or nodeName == "":
		continue
	dicShapes[nodeName]={}
	parmIter = arnold.AiNodeEntryGetParamIterator(nodeEntry)
	while not arnold.AiParamIteratorFinished(parmIter):
		parm = arnold.AiParamIteratorGetNext(parmIter)
		parmName = arnold.AiParamGetName(parm)
		if parmName == "shader":
			dicShapes[nodeName][parmName] = []
			parmArray = arnold.AiNodeGetArray(node,parmName)
			for arrayIndex in range(arnold.AiArrayGetNumElements(parmArray)):
				dicShapes[nodeName][parmName].append(arnold.AiNodeGetName(arnold.AiArrayGetPtr(parmArray, arrayIndex)))
		elif parmName == "visibility":
			dicShapes[nodeName][parmName] = arnold.AiNodeGetInt(node,parmName)
	arnold.AiParamIteratorDestroy(parmIter)
arnold.AiNodeIteratorDestroy(nodeIter)

subnet = hou.node("/out").createNode("subnet","setParms")
merge = subnet.createNode("merge","Merge")
for shapeIndex,eachShape in enumerate(dicShapes):
	setParameterNode = subnet.createNode("set_parameter",eachShape)
	merge.setInput(shapeIndex,setParameterNode)
	setParameterNode.parm("selection").set("*/"+eachShape)
	setParameterNode.parm("assignment").set(1)
	setParameterNode.parm("assignment_1").set("visibility="+str(dicShapes[eachShape]["visibility"]))
	for shaderIndex,eachShader in enumerate(dicShapes[eachShape]["shader"]):
		setParameterNode.parm("assignment").set(shaderIndex+2)
		setParameterNode.parm("assignment_"+str(shaderIndex+2)).set("shader["+str(shaderIndex)+"]=\""+str(dicShapes[eachShape]["shader"][shaderIndex])+"\"")

Wenn ich dieses Skript ausführe, wird ein setParms-Subnetz im Kontext / out erstellt, und Set-Parameter-ROPs werden erstellt und darin für die Anzahl der in der ass-Datei definierten Objekte zusammengeführt. Verbinden Sie dieses Subnetz mit dem Arnold ROP. Sie können jetzt rendern. Wie MaterialX unterstützt aiOperator nur Shader-Zuweisungen auf Objektebene, daher ist dies das Ergebnis. Wenn Ihr Modell jedoch keine Face-by-Face-Shader-Zuweisungen hat, können Sie die Arnold Python-API mit einer Ass-Datei verwenden, um Dev in Houdini zu suchen, auch wenn Sie nicht in Maya sind.

Überprüfungsumgebung: Maya2019 MtoA3.3.0.2 Houdini17.5.425 HtoA4.4.1

Zusammenfassung

• Sie können in Maya auch Scheitelpunkt- / Gesichtsattribute hinzufügen, um sie über Alembic in Houdini zu bringen.
• Wenn du Arnold verstehst, solltest du Arsch verstehen
• Ich habe Ihnen die Verwendung der Arnold Python-API beigebracht
• Wenn Sie eine Pipeline mit ass erstellen, können Sie zwischen mehreren DCCs rendern.

Ende: Umarmen: