![\"DE_intro\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/DE_intro.png\")
<\/p>\n[:de]Eines der Hauptprobleme der Wiedergabe ist ihre Perfektion. Baumobjekten, die aus vielen Blattelementen bestehen, auf die das gleiche Material aufgetragen wurde, fehlen oft die nat\u00fcrlichen Variationen, die der Betrachter erwarten w\u00fcrde. In unserem Produktionsablauf sind wir t\u00e4glich mit diesem Problem konfrontiert. Da wir immer versuchen, die Qualit\u00e4t unserer Architektur-Renderings zu verbessern, haben wir uns entschieden, ein einfach zu bedienendes Skript zu erstellen, mit dem wir zuf\u00e4llige Material-IDs setzen k\u00f6nnen, um die Wahrnehmung nat\u00fcrlicher Variationen zu erm\u00f6glichen.<\/p>\n
Unsere wichtigste Software zur Erstellung von Inhalten ist 3ds Max, daher haben wir ein Makro-Skript (in MAXScript) f\u00fcr dieses Problem erstellt.<\/p>\n
<\/p>\n
Es gibt grunds\u00e4tzlich zwei m\u00f6gliche Ans\u00e4tze zur L\u00f6sung dieses Problems. Die iterative erste iteriert durch alle Fl\u00e4chen, um eine zuf\u00e4llige Material-ID festzulegen, w\u00e4hrend die rekursive erste Version die gro\u00dfe Menge an Fl\u00e4chen in kleinere Teilgruppen aufteilt und dann allen in dieser Gruppe enthaltenen Elementen eine Material-ID zuweist; verbunden mit der Fl\u00e4chenauswahl.<\/p>\n
Zuerst haben wir den iterativen Ansatz implementiert, um einen Blick auf seine M\u00f6glichkeiten und Einschr\u00e4nkungen zu werfen. Danach dachten wir \u00fcber m\u00f6gliche Optimierungen und andere Ideen nach, wie dieses Problem effizienter gel\u00f6st werden k\u00f6nnte, mit einem optimalen Gleichgewicht zwischen Geschwindigkeit und einem visuell hochwertigen Ergebnis. Deshalb haben wir die rekursive Version weiter untersucht, um das Problem von einem anderen perspektivischen Standpunkt aus zu l\u00f6sen.<\/p>\n
function<\/span> changeIDsIterative obj minID maxID stepSize =<\/span>\n(<\/span>\n\tgetElement =<\/span> polyop.<\/span>getElementsUsingFace\n\tsetFaceID =<\/span> polyop.<\/span>setFaceMatID\n\t\t\t\n\trange =<\/span> 1<\/span>\n\t\t\t\n\tfor<\/span> i =<\/span> 1<\/span> to<\/span> obj.<\/span>numfaces by stepSize do<\/span> (<\/span>\n\t\t\t\t\n\t\trandomID =<\/span> random minID maxID\n\t\t\t\t\n\t\trange =<\/span> i +<\/span> stepSize\n\t\t\t\t\n\t\tif<\/span>(<\/span>range ><\/span> obj.<\/span>numfaces)<\/span> do<\/span> (<\/span>\n\t\t\trange =<\/span> obj.<\/span>numfaces\n\t\t)<\/span>\n\t\t\n\t\telement =<\/span> getElement obj #<\/span>{i..<\/span>range}\n\t\tsetFaceID obj element randomID\n\t)<\/span>\n)<\/span>\n<\/pre>\nIm Grunde genommen iteriert dieses Skript durch alle Fl\u00e4chen mit einem bestimmten Schritt. Dabei nimmt es die Elemente, die mit den Fl\u00e4chen innerhalb des Stufenbereichs verbunden sind und gibt dieser Auswahl von Fl\u00e4chen eine zuf\u00e4llige Material-ID im Bereich der minimalen ID und der maximalen ID (minID <= ID <= maxID).<\/p>\n
Gr\u00f6\u00dfere Werte der Schrittweite w\u00fcrden zu einer h\u00f6heren Geschwindigkeit f\u00fchren, indem viele Fl\u00e4chen \u00fcbersprungen werden, aber zu einer sichtbaren Wiederholung der gleichen verwendeten Material-ID.<\/p>\n
Die Anzahl der Funktionsaufrufe zum Setzen einer zuf\u00e4lligen Material-ID h\u00e4ngt also von der Schrittweite s<\/em> ab:<\/p>\n![\"Formel0\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/Formel0.png\")
<\/p>\n
Vielleicht ist Ihnen aufgefallen, dass in den ersten beiden Zeilen zwei Funktionsaufrufe Variablen zugeordnet sind.<\/p>\n
getElement =<\/span> polyop.<\/span>getElementsUsingFace\nsetFaceID =<\/span> polyop.<\/span>setFaceMatID\n<\/pre>\nDies geschieht aus Leistungsgr\u00fcnden. Durch die Iinitialisierung des Funktionsaufrufs als Variable sind diese vielen Funktionsaufrufe etwas schneller auszuf\u00fchren.<\/p>\n
Rekursive Version<\/h3>\nfunction<\/span> changeIDs depth obj minFace maxFace minID maxID =<\/span>\n(<\/span>\n\tif<\/span>(<\/span>depth ><\/span> 0<\/span>)<\/span> then<\/span> (<\/span> -<\/span>-<\/span>Clustering,<\/span> if<\/span> depth !=<\/span> 0<\/span>\n\t\tpartSize =<\/span> (<\/span>(<\/span>maxFace -<\/span> minFace)<\/span> \/<\/span> 2<\/span> +<\/span> 1<\/span>)<\/span> as<\/span> Integer<\/span> -<\/span>-<\/span>calculate the clustersize\n\t\t\n\t\tchangeIDs (<\/span>depth-<\/span>1<\/span>)<\/span> obj minFace (<\/span>partSize +<\/span> minFace)<\/span> minID maxID -<\/span>-<\/span> first part\n\t\tchangeIDs (<\/span>depth-<\/span>1<\/span>)<\/span> obj (<\/span>partSize +<\/span> minFace +<\/span> 1<\/span>)<\/span> maxFace minID maxID -<\/span>-<\/span> second<\/span> part \n\t\t\n\t)<\/span> else<\/span> (<\/span> -<\/span>-<\/span>set<\/span> material IDs\n\t\tgetElement =<\/span> polyop.<\/span>getElementsUsingFace\n\t\tsetFaceID =<\/span> polyop.<\/span>setFaceMatID\n\t\t\n\t\trandomID =<\/span> random minID maxID \n -<\/span>-<\/span>get<\/span> a random ID between the given values\n\t\telement =<\/span> getElement obj #<\/span>{minFace..<\/span>maxFace} \n -<\/span>-<\/span>select<\/span> all elements with<\/span> faces in the given cluster of faces\n\t\tsetFaceID obj element randomID \n -<\/span>-<\/span>set<\/span> the random ID to<\/span> all faces in the selection\n\t)<\/span>\n)<\/span>\n<\/pre>\nDie rekursive Version teilt die riesige Menge von in kleinere Gruppen von Fl\u00e4chen auf, bevor eine Material-ID festgelegt wird.<\/p>\n
Der Algorithmus teilt grunds\u00e4tzlich die Anzahl der Fl\u00e4chen in H\u00e4lften, bis der depth-wert Null ist. Dann w\u00e4hlt das Skript f\u00fcr jeden Unterabschnitt alle Elemente aus, die mit den Fl\u00e4chen des Unterabschnitts verbunden sind, und weist ihnen eine zuf\u00e4llige ID zu. Der zweite Teil ist also gleich der iterativen Version.<\/p>\n
Der einzige Unterschied besteht in der Art und Weise der Auswahl der Fl\u00e4chen.<\/p>\n
Beispiel f\u00fcr depth = 3<\/p>\n
![\"DepthValue\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/DepthValue.png\")
<\/p>\n
Also die Anzahl der Teile, bei denen eine zuf\u00e4llige Material-ID gesetzt werden soll:<\/p>\n
![\"Formel2\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/Formel2.png\")
<\/p>\n
Die Anzahl der faces rekursiv in Unterteile zu zerlegen, geht sehr schnell. Der Hauptengpass dieses Skripts ist der Zugriff der 3dx Max-Schnittstellen getElement und setFaceID.<\/p>\n
Die \u00e4quivalenten Parameter f\u00fcr iterative und rekursive Funktionsaufrufe k\u00f6nnen durch berechnet werden:<\/p>\n
![\"Formel1\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/Formel1.png\")
<\/p>\n
Welche ist jetzt besser?<\/h3>\n
Im Grunde leisten beide Versionen die gleiche Arbeit und sollten ein vergleichbares Ergebnis liefern k\u00f6nnen. Die Hauptunterschiede sind die Parameter und das interne Verfahren.<\/p>\n
Wenn Sie ein Objekt mit vielen Polygonen haben und (fast) jedes Element eine zuf\u00e4llige Material-ID haben sollte, dann ist die iterative Version einfacher zu benutzen, weil Sie einfach 1 oder vergleichbar niedrige Werte f\u00fcr die Schrittweite s<\/em>. oder andere kleine Werte eingeben. Dann w\u00fcrde das Skript jeder Fl\u00e4che eine zuf\u00e4llige ID zuweisen und eine zuf\u00e4llige ID festlegen. Aber andererseits, wenn die Elemente viele faces haben, w\u00fcrde die Arbeit oft mehr als einmal durchgef\u00fchrt werden. Dies wird auch wegen der vielen Schnittstellenzugriffe von 3ds Max sehr langsam sein.<\/p>\nDann w\u00e4re es einfacher, den rekursiven Ansatz zu verwenden und mit kleinen Werten f\u00fcr die depth zu beginnen, bis man ein zufriedenstellendes Ergebnis mit gen\u00fcgend Mischung erh\u00e4lt, indem man den depth-wert erh\u00f6ht.<\/p>\n
Beispiele<\/h2>\nUnterschiedliche Material-IDs: 3<\/h3>\n
![\"DE_mat\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/DE_mat.png\")
<\/p>\n
Laufzeit: iterativ<\/h3>\n
![\"Iterative\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/itereative.png\")
<\/p>\n
Laufzeit: rekursive<\/h3>\n
![\"Rekursiv\"](\"http:\/\/www.lefx.de\/wp-content\/uploads\/2016\/02\/rekursiv.png\")
<\/p>\n