Transkripte
1. Einführung in den Baum-Geonoden-Kurs: Willkommen bei drei D-Bäumen
mit Blender-Geometrieknoten. In diesem Kurs werden wir
den leistungsstarken
prozeduralen Arbeitsablauf von
Blended-Geometrieknoten untersuchen den leistungsstarken
prozeduralen Arbeitsablauf von , um
vollständig anpassbare
und realistische Bäume zu erstellen vollständig anpassbare
und realistische Bäume Von der Erzeugung organischer
Stammstrukturen bis hin zur endgültigen Verteilung der Blätter lernen
Sie, wie Sie
natürlich aussehende Bäume mit
verfahrenstechnischer Flexibilität herstellen natürlich aussehende Bäume mit
verfahrenstechnischer Flexibilität Am Ende dieses Kurses wirst
du über die
Fähigkeiten verfügen, Bäume von uralten
Eichen
bis hin zu empfindlichen Bonsai zu erschaffen , alle durch einfach
zu bedienende Perimeter gesteuert werden Wenn du daran interessiert bist,
deine Gemenude-Fähigkeiten
noch weiter zu verbessern, solltest du dir unsere Kurse Blender
Geometernode für Anfänger,
Procedural Bridge Generator und Laubstreuung deine Gemenude-Fähigkeiten
noch weiter zu verbessern, solltest du dir unsere Kurse Blender
Geometernode für Anfänger, nicht entgehen lassen Procedural Diese helfen Ihnen dabei,
Ihre
Techniken zur prozeduralen Modellierung zu verfeinern und
atemberaubende
Freedy-Umgebungen
voller Laub, Architektur und mehr zu schaffen atemberaubende
Freedy-Umgebungen
voller Laub Um Ihnen zu helfen,
Ihre Bäume zum Leben zu erwecken, umfasst
dieser Kurs ein
hochwertiges Ressourcenpaket
mit acht
stilisierten PBR-Materialien, die speziell für
die prozedurale
Nachbildung entwickelt wurden Sie erhalten Kirsch- und Eichenrinde, blühende und nicht blühende
Kirschzweige und saisonale Eichenblätter
für Sommer, Herbst und Frühling sowie Kirschblüten für einen atemberaubenden Effekt fallender Wir werden damit beginnen,
ein prozedurales Baumsystem
von Grund auf aufzubauen ein prozedurales Baumsystem
von Grund auf Sie beginnen mit dem
grundlegenden Knoten mit geteiltem Ende,
einer benutzerdefinierten Knotengruppe, die
Verzweigungsstrukturen
generiert, indem sie
mehrere Kurvensplits iteriert Anhand von Perimetern wie
Anzahl, Länge und Winkel der Äste entwickeln
wir ein
realistisches Wachstumssystem
, das die natürliche Baumbildung nachahmt . Zusätzlich werden wir
eine Geräuschreduzierung implementieren, um der Gesamtform des
Baumes subtile Bewegung und Realismus zu verleihen Sobald der Stamm und die
Äste an ihrem Platz sind, werden
wir unseren Fokus auf
die Platzierung der Blätter verlagern Mithilfe von benutzerdefinierten Attributen wie Länge vom Anfang
und der Länge vom Ende werden
wir bestimmen, wie die Blätter entlang der Zweige verteilt
sind, um natürliche
Wachstumsmuster zu gewährleisten. Als Nächstes werden wir
unser Verfahrenssystem erweitern , um Wurzeln zu generieren. Indem wir das Zweigsystem
so modifizieren, dass es seine Richtung umkehrt, schaffen
wir eine
unterirdische Wurzelstruktur , die sich nahtlos
mit dem Stamm verbindet. Schließlich werden wir Techniken zur
UV-Kartierung untersuchen,
um sicherzustellen, dass Rinden
- und Laubmaterialien nahtlos aufgetragen
werden. Im letzten Abschnitt werden
wir
ein einfaches Partikelsystem integrieren, um fallende Blätter zu
simulieren. Mithilfe der Simulationszone von Blenders werden
wir
Blätter erzeugen und animieren, werden
wir
Blätter erzeugen und animieren die sich im Laufe der Zeit von
den Ästen lösen Dieser Kurs wurde im Hinblick auf
Modularität und Effizienz konzipiert Modularität Durch die Verwendung wiederverwendbarer Knotengruppen können
Sie Randbereiche
wie Baumhöhe,
Astdichte,
Blattbedeckung und mehr schnell anpassen Astdichte,
Blattbedeckung Egal, ob Sie einen
stilisierten Baum für
das Spiel oder eine hyperrealistische
Operation für eine Animation benötigen , unser Setup ermöglicht eine
schnelle Iteration und Anpassung schnelle Am Ende dieses Kurses verfügen
Sie über ein vollständig prozedurales
Baumsystem, verfügen
Sie über ein vollständig prozedurales das anpassbar,
effizient und visuell beeindruckend ist , Ihre kreative
Vision
zum Leben zu erwecken Melden Sie sich jetzt an und fangen Sie an,
Ihre eigenen Credi-Bäume mit
Blenders Omiton Rods zu züchten Ihre eigenen Credi-Bäume mit
Blenders
2. Baumgenerator – Übersicht: Hallo und willkommen
zur Einführung in kostenlose D-Bäume mit
Blender-Geometrieknoten. In diesem Kurs
lernen Sie, wie Sie mithilfe von
Blender-Geometrieknoten
einen vollständig prozeduralen Baum erstellen mithilfe von
Blender-Geometrieknoten
einen vollständig prozeduralen Baum Sie werden ein
realistisches Stamm- und
Verzweigungssystem erstellen , die Blattplatzierung
kontrollieren
und ein einfaches
Partikelsystem für
fallende Blätter hinzufügen, und ein einfaches
Partikelsystem für
fallende Blätter hinzufügen um Ihrem Baum
natürliche Bewegung zu verleihen Um dir dabei
zu helfen, erhältst du außerdem ein kostenloses
Materialpaket mit hochwertigen Eichen- und
Sakura-Texturen und Materialien, die perfekt für diesen
Kurs und zukünftige Bevor wir mit dem Bauen beginnen,
schauen wir uns die Eingaben und , die die Form und Struktur
Ihres Baums bestimmen diese Einstellungen anpassen, können
Sie alles
erstellen,
von kleinen Knochenstellen bis hin zu riesigen Eichen können
Sie alles
erstellen,
von kleinen Knochenstellen bis . Dieser Meter-Knoten ist also
nur ein Modifikator. Wie Sie sehen können, habe ich hier diesen Baummodifikator
auf dieses Objekt angewendet, und Sie können sehen, dass
wir hier nur wenige Parameter haben Einer davon ist Seed, der den Startwert aller
Zufallswerte und
Zufallsgeneratoren
steuert Zufallswerte und
Zufallsgeneratoren Dann gibt es noch die Auflösung, die die Auflösung von Zweigen
steuert. Sie können die Höhe des
Stammes und den Gesamtradius festlegen. Und dann gibt es noch
Material für Wurzeln und Zweige und auch
Steuerelemente für die UEs. Dann können
Sie im Bereich Zweige sehen, dass die erste
Eingabe als Ebenen bezeichnet wird
und das steuert, wie viele Ebenen von Ästen Ihr Baum haben wird. Wenn wir das
zum Beispiel auf nur zwei setzen, dann
gibt es zuerst einen Stamm, der ein separater Zweig
oder
ein Hauptzweig ist . Von diesem Zweig gibt es drei weitere Zweige wie diesen. Und von diesen Zweigen aus gibt es
die zweite Ebene von Filialen, also sieht es ungefähr so aus. Bei den zweiten beiden Eingaben handelt es sich um die
minimale und die maximale Anzahl an Teilungen, was bedeutet, dass Sie kontrollieren können, auf wie viele Zweige jedes Ende
der Verzweigung aufgeteilt wird. Also hier haben wir 3-5. Wenn wir es auf 2-5 setzen, können
Sie sehen, dass es sich jetzt einfach in zwei
Zweige aufteilt Und wenn wir mit Samen herumspielen, sollten
wir
unterschiedliche Ergebnisse erzielen Jetzt können Sie sehen, dass wir
vier davon haben und so weiter. Dann können Sie auch die
Länge der Zweige steuern. Sie können den ersten
und den letzten separat steuern. Wenn wir also die ersten Zweige auf
etwas Langes und zuletzt
auf etwas Kurzes setzen , erhalten
Sie unterschiedliche Ergebnisse. Und es gibt auch eine Zufälligkeit für die
Länge, die bestimmt, wie zufällig die Längen der Zweige Die nächste Sache ist der Winkel
, der den
Winkel der Zweige bestimmt Sie können also sehen, wenn
wir ihn auf Null setzen, dass sie alle nach oben zeigen, und wenn wir
ihn vergrößern, wird der Baum viel breiter und
die Äste wachsen mehr zur Seite. Sie können auch die
Zufälligkeit dieses Winkels steuern, und die letzte Eingabe
ist der Radius fff, im Grunde
die
Dicke der Zweige steuert Jetzt können Sie also sehen, dass
es auf zwei eingestellt ist
und Sie können sehen, dass die
Zweige an den Enden dünn sind Und wenn wir den Wert verringern, können
Sie sehen, dass sie viel
dicker werden , und Sie können
den Gradienten des Radius
, der vom Stamm bis zu den
Enden der Zweige reicht, kontrollieren den Gradienten des Radius
, der . Das nächste Panel, das wir
haben, sind die Wurzeln, und dieses Panel hat im Grunde alle Steuerelemente als Verzweigungen, und Sie können
dieselben Parameter steuern. Also werde ich diesen überspringen. Die nächste ist die
Verschiebung, mit der Sie die Verschiebung
der Zweige
steuern. So können Sie kontrollieren,
wie gerade oder wie schnell Ihr Baum Die nächsten sind Bäume. Also hier können
wir die Bäume kontrollieren. Sie können die Sammlung
der Blätter auswählen. So können wir leicht zwischen diesen
wechseln. Wir können auch die Dichte kontrollieren und aus
drei Optionen wählen , wo die Blätter wachsen
sollen. Es gibt also drei Optionen. Eine davon sind Filialen. Das bedeutet , dass
überall Blätter auf den Zweigen sind. der zweiten Variante die Blätter grundsätzlich
nur an den Enden
der Zweige
verteilt , und wir können auch
die Länge der Segmente kontrollieren , auf
denen sie verteilt sind Und die letzte Option ist die
minimale Z-Position
, bei der Blätter im Grunde
überall
verteilt werden, wo die Position höher als
ein bestimmter Wert ist Wenn wir das also zu drei sagen, können
Sie sehen, dass
wir hier Stufe drei haben und wo die
Position größer ist, sind
die Blätter verteilt Die letzten beiden Dinge sind
Skalierung und Skalierungszufälligkeit, sodass Sie auch kontrollieren können wie skaliert die
ursprünglichen Objekte Und das letzte Panel, das wir hier
haben, sind Partikel, und Sie können es hier sehen Das sind die kleinen
Blätter, die Sie sehen können, und Sie können
ihre Dichte kontrollieren, auch die Physik, sodass wir
die Schwerkraft und einige Geräusche kontrollieren können die Schwerkraft und einige Geräusche die
auf ihre Bewegung einwirken, und auch, wie lange sie leben. Und genau wie bei den Blättern haben
wir eine Sammlung für
Eingabeobjekte und deren Größe. Sie können sehen, dass, wenn wir die Simulation
abspielen, Sie sehen können, dass die Blätter anfangen, von den Blättern zu fallen, und das erzeugt einen
wirklich schönen Effekt.
3. Zweiggenerator-Intro: Willkommen zurück zu drei D-Bäumen mit Blender-Geometrieknoten In dieser Lektion werde ich
die Techniken erläutern, die wir zur Generierung
des Zweigsystems verwenden
werden , und wie wir es mit
unterschiedlichen Perimetern steuern können Zuerst setze ich die
Blattdichte einfach auf Null, damit wir das Zweigsystem besser
erkennen können Und wie Sie sehen können,
können wir die
Struktur auf Linien vereinfachen. Eine
Hauptlinie ist zum Beispiel der Stamm, dann gibt es vier Zweige, in die sie
sich aufteilt, und dann
macht sie im Grunde dasselbe an den
Enden dieser Zweige Das Setup, das wir
erstellen werden, wird also eine
Eingabe für die Geometrie haben In diesem Fall,
wenn wir einen Trunk haben, geben
wir diesen Trunk
dieser Knotengruppe und
geben ihr auch eine Auswahl ,
aus
der die Zweige wachsen sollen. Also wähle ich
mit diesem Kreuz aus. Und was das Setup tun wird,
ist, dass es
abhängig von den Eingaben einfach
Verzweigungen wie diesen generiert . So können wir kontrollieren,
auf wie viele Zweige es
aufgeteilt wird und wie lang und
abgewinkelt diese Zweige sind Und das Ergebnis dieser
Knotengruppe werden diese Zweige sein. Und auch mit Auswahlen, die
diese Endpunkte auswählen Und dann verwenden wir den
rekursiven Ansatz oder etwas, das der Rekursion sehr
ähnlich ist, und dass wir
dieses Setup nach dieser
ersten Iteration wieder verwenden werden , und dieses Setup wird wieder einige weitere Zweige wie diesen
erzeugen Und wenn wir das
zum Beispiel drei-
oder viermal wiederholen , sollten
wir ein
schönes Verzweigungssystem bekommen, sollten
wir ein
schönes Verzweigungssystem bekommen das wir als Grundstruktur für unseren
Geometrieknoten-Modifikator verwenden werden Grundstruktur für unseren
Geometrieknoten-Modifikator Später in diesem Kurs werden
wir auch
einige Attribute für Informationen
über die Zweige benötigen einige Attribute für Informationen
über die Die beiden wichtigsten Attribute
, die Sie benötigen, sind Länge, und die Länge gibt
uns Aufschluss darüber, wie weit jeder Punkt des Zweigs von den Wurzeln entfernt
ist. Also hier unten, Null. Hier in diesem Abschnitt sind es, sagen
wir, zum Beispiel zwei, hier ist es überall kostenlos, und hier an den Enden kann
es wie 3,5 sein. Mit diesem Attribut können
wir den Radius
der Zweige kontrollieren und auch
schöne UV-Maps für sie erstellen. Und der zweite Umkreis entspricht
der Länge vom Ende. Und dieser Umfang wird
fast der Länge entsprechen, aber er wird in eine
andere Richtung
oder in die entgegengesetzte Richtung gehen oder in die entgegengesetzte An den Enden der Zweige werden
es also nur Nullen sein Und wenn wir uns dann
den Wurzeln nähern, wird es zunehmen. Also 0,5 wird hier sein, 1,5 hier, 2,5 hier und 3,5 in den Wurzeln. Mit diesem zweiten Attribut können
wir zum Beispiel Blätter von den Enden her
verteilen, Blätter von den Enden her
verteilen wie ich es in der vorherigen Lektion gezeigt habe, und wir werden einfach
die Zweige trennen , bei denen die Länge vom Ende kleiner
als ein bestimmter Wert ist, und dann können wir Blätter
einfach auf diese Zweige verteilen .
4. Geteilte Enden: Willkommen zurück zu drei D-Bäumen mit Blender Geometri-Knoten In dieser Lektion
werden wir mit der Arbeit an
der Grundlage unseres Modifikators für
Geometro-Knoten beginnen der Grundlage unseres Modifikators für
Geometro-Knoten werden wir an der Knotengruppe im
Verzweigungssystem arbeiten, die uns dabei helfen wird, die grundlegende Verzweigungsstruktur zu erstellen Hier habe ich also eine
frische Blender-Szene, und ich werde damit beginnen,
alles in der Szene zu löschen Und ich füge zum Beispiel eine
einfache Ebene hinzu, weil wir nicht die
Originalgeometrie verwenden werden, sodass Sie hinzufügen können,
was Sie wollen. Dann gehe ich zu Modifikatoren
und füge einen neuen Modifikator hinzu, dem es sich um Geometrieknoten Ich drücke auf Neu und nenne diesen Geometrieknoten-Setup,
zum Beispiel drei Und jetzt können wir mit der
Arbeit am Setup beginnen. Gehen wir also zum Arbeitsbereich von Geomet
Nodes
und wir können damit beginnen, die Gruppeneingabe zu löschen , da wir dieses
Objekt nicht benötigen Der Plan für die
Zweige sieht vor, dass
wir zunächst eine grundlegende
Baumstruktur aus Kurvenlinien erstellen, sodass sie
ungefähr so aussieht Und dann werden wir
diese Kurven
mithilfe von Curve-to-Mesh-Knoten in ein Netz umwandeln . Die Grundlinie oder
die grundlegende Kurvenlinie
wird also der Stamm sein. Fügen wir also eine Kurvenlinie und diese Kurvenlinie
hat zwei Eingänge. Sie hat Start und Ende. Wir können den Anfang so lassen, wie er ist weil wir wollen, dass er
bei 00 beginnt, und das Ende
bestimmt im Grunde die
Höhe des Rumpfes. Wenn wir uns jetzt also den Stamm
ansehen, können
Sie sehen, dass seine
Länge
durch diesen Z-Wert des
Endvektors bestimmt wird . Wir können diese
Werte also trennen, indem wir Combine XYZ verwenden, und jetzt können wir
diesen Z-Wert einzeln steuern Für den Tranghd können wir eine neue
Gruppeneingabe hinzufügen. Drücken wir also N, um dieses Seitenmenü
aufzurufen. Und ich klicke auf dieses
Plus-Symbol, um eine neue Eingabe hinzuzufügen, die ich Trangight nenne Wir können den Standardwert
beispielsweise auf drei
und das Minimum auf Null setzen beispielsweise auf drei
und das Minimum auf Null Um das zu verbinden,
können wir die Gruppeneingabe aufrufen und diese
Stammhöhe mit dem Z-Wert verbinden Sie können sehen, dass es Null ist, also gehe ich zurück zur
Gruppeneingabe zum Modifikator, und jetzt können Sie sehen,
dass wir mit dieser Eingabe
die Höhe der
Kurvenlinie steuern können mit dieser Eingabe
die Höhe der
Kurvenlinie Es gibt auch diese
kleine Warnung, und das liegt daran, dass die
Eingabegeometrie oben sein muss, also verschiebe ich sie einfach nach oben, und jetzt sollte alles in Ordnung sein Jetzt sind wir also im Grunde mit dem Trunk
fertig und können einfach
all diese Knoten auswählen, Strg J
drücken, um den Frame
aufzurufen, und ich nenne diesen
Frame Trunk. Beginnen wir nun mit
der Knotengruppe, die einen Punkt
in mehrere Zweige aufteilt. Lassen Sie uns also eine
neue Knotengruppe erstellen. Ich mache das, indem ich eine Umleitung zu
dieser Verbindung erstelle, also halte ich die Umschalttaste
gedrückt und ziehe mit der Maus
über diese Auswahl. Übrigens, wenn Sie kein Node-Wrangular-Add-On
verwenden, kann
ich es nur empfehlen, da es
Ihren Arbeitsablauf bei Geometrieknoten
und auch bei Shading-Knoten beschleunigt Ihren Arbeitsablauf bei Geometrieknoten
und auch bei Shading-Knoten und auch bei Shading-Knoten Also nochmal, wir können Shift mit der
rechten Maustaste drücken und ziehen,
und schon können wir diese Anzeige abrufen Und jetzt, wenn Sie
diese Umleitung ausgewählt haben, können
Sie Strg G drücken, um eine Knotengruppe
zu erstellen Wenn wir nun die Tabulatortaste drücken, befinden
wir uns außerhalb
dieser Knotengruppe, und Sie können sehen, dass sie nur
einen Eingang und einen Kurvenausgang hat einen Eingang und einen Kurvenausgang Ich werde das in Split-Ends umbenennen , weil dadurch die
Endpunkte der Kurven geteilt werden. Und um zu
dieser Knotengruppe zurückzukehren, können
wir erneut die Tabulatortaste drücken und
wir befinden uns in der Knotengruppe. Diese Knotengruppe wird nur wenige Eingaben
haben. erste ist die Geometrie, die wir hier bereits haben, aber ich werde sie in Geometrie umbenennen. Die zweite ist
die Auswahl, bei
der die Punkte ausgewählt werden, an denen neue Zweige wachsen
sollen. Also erhalte ich einen neuen Input
und nenne ihn Auswahl. Die Art davon wird Mobbing sein. Und das letzte ist
vorerst das Zählen, das ist eine Anzahl von Zweigen, die Sie generieren
möchten Fügen wir also eine neue Eingabe Anzahl, Typ kann Ganzzahl sein, und wir können die Standardeinstellung
zum Beispiel auf drei
und Minimum auf Null setzen. Wenn wir nun diese
Knotengruppe mit der Tabulatortaste verlassen, geben
wir einige
Basisdaten in diese Knotengruppe ein. Also werden wir zuerst
zum Beispiel drei Zweige
erstellen wollen. Also lasst uns die Zählung auf drei addieren. Und was die Auswahl angeht,
wollen
wir diese Zweige nur von diesem Endpunkt aus erweitern. Normalerweise hat die Kurvenlinie also nur zwei Punkte, wobei der Anfang
den Index Null und das
Ende den Index eins hat. Wir können also einfach den
Indexwert verwenden und wenn er gleich ist, addieren wir gleich eins. Dadurch sollte
nur dieser Endpunkt ausgewählt werden. Wir können es mit einem Viewer überprüfen, also drücken Sie die Umschalttaste und klicken Sie auf
die Schaltfläche ganz links Dadurch wird der Viewer aufgerufen, und jetzt können wir diesen
Mobbing-Wert darauf ziehen Und hier kannst du sehen
, dass diese Unterseite schwarz und die
obere weiß ist Die zweite Methode besteht darin,
dies mit Attributtext zu überprüfen. Hier oben
können Sie also Attributtext auswählen, und Sie können sehen, dass hier
eins und hier Null ist. Jetzt haben wir die Auswahl getroffen und gehen zurück
zur Knotengruppe. Wir werden damit beginnen, grundlegende Zweige zu generieren
. Fügen wir also eine Kurvenlinie hinzu
, die Verzweigungen erzeugt. Und diese Kurvenlinie kann
zum Beispiel nur 1 Meter lang sein. Wir wollen
diese Kurvenlinie in
Abhängigkeit von dieser Zähleingabe duplizieren , und das können wir zum
Beispiel tun, indem wir Punkte erstellen. Fügen wir also Punkte hinzu, und wir werden so viele
Punkte erstellen, wie wir Verzweigungen benötigen. Also setze ich diese
Zählung in diese Zählung ein. Und jetzt können Sie sehen, dass
wir hier drei Punkte haben. Um nun die
Punkte durch die Kurven zu ersetzen, können
wir die Instanz für Punkte verwenden. Und die Eingabepunkte sind in unserem Fall
die freien Punkte, und die Instanz, durch
die wir Punkte
ersetzen wollen ,
ist die Kurvenlinie. Wenn wir uns nun die Ausgabe dieser
Instanz ansehen, können
Sie sehen, dass wir drei Instanzen
haben. Aber hier im Viewport können
Sie sehen, dass es immer noch nur eine Linie gibt
, und das liegt daran, dass sie
sich überlappen Um sie ein wenig voneinander zu
unterscheiden, verschiebe
ich sie zunächst auf der X-Achse, sodass sie ein wenig
abgewinkelt sind Und ich werde auch mit dieser Rotation
herumspielen. Also werden wir es je nach Index um die
Z-Achse drehen . Sie werden also gut um die Z-Achse
verteilt sein. Dazu füge ich
Combine XYZ hinzu, weil wir nur den
Z-Wert dieser Drehung kontrollieren
wollen Ich setze diesen
Vektor in die Drehung ein. Wenn wir nun
mit dem Z-Wert herumspielen, können
Sie sehen, dass er sich um die Z-Achse
dreht. Wir wollen für jede Kurve
einen anderen Wert, und um
zwischen den Kurven zu unterscheiden, können
wir die Indexeingabe verwenden. Lassen Sie uns also den Index hinzufügen. Und wenn wir diesen Index
direkt in die Z-Achse stecken, können
Sie sehen, dass
er etwas bewirkt, und das liegt daran, dass
für
die erste Zeile die Eingabe Null ist,
für die zweite Zeile die Eingabe, tut mir leid,
der Index ist eins, und für die dritte Zeile ist
der Index zwei. Wir wollen
diese Linien
gleichmäßig im Kreis verteilen , zum
Beispiel so. Wenn wir also drei Kurven haben, wollen
wir, dass sie so aussehen. Also zwischen ihnen ist es ein
Winkel von 120 Grad. Und um diesen Winkel zu berechnen, können
wir einfach
eine volle Umdrehung machen
, also 360, und ihn durch die
Anzahl der Zweige teilen .
Also lass uns das machen. Ich werde diese
Gruppeneingabe duplizieren und einen Meth-Knoten hinzufügen. Und weil wir hier Radiant
verwenden, müssen
wir zwei Pi
anstelle von 360 Grad verwenden Wir werden also
zwei mal Pi dividieren, was 6,28 durch die
Anzahl der Zweige entspricht. Und das gibt uns den
Winkel zwischen den einzelnen Zweigen. Und um sie gut zu verteilen, können
wir den Index
mit diesem Offset-Winkel multiplizieren. Fügen wir also eine Multiplikation hinzu und setzen sie in die Z-Koordinate ein. Jetzt können Sie sehen, dass
die Zweige schön entlang der Z-Achse gedreht sind
und dass sie gut um den Kreis herum
verteilt sind. Wenn wir diese
Knotengruppe verlassen und den Rabatt erhöhen, können
Sie sehen, dass
es gut funktioniert. Lassen Sie uns den alten
Rotationsansatz durch
etwas Besseres ersetzen . Also setze ich diese
Kurvenlinie auf 0,2 001. Jetzt überlappen sie sich wieder. Aber wenn wir jetzt mit
der Drehung auf der Y-Achse herumspielen , können
Sie sehen, dass sie sich gut
drehen, und wir können den Winkel zwischen den
Zweigen und der Z-Achse
kontrollieren Also
kontrollieren wir diesen Winkel im Grunde mit diesem Wert. Wir wollen diesen
Wert von außen kontrollieren. Um also eine neue Eingabe hinzuzufügen, können
wir diese leere Buchse nehmen
und sie an die Y-Achse anschließen Ich rufe dann das
Seitenmenü auf und benenne es in Winkel um. Wir können den
Untertyp auch auf Winkel setzen, sodass die Einheit im
Modifikator in Grad angegeben wird und der Standardwert etwa
0,5 oder etwas Ähnliches sein
kann 0,5 oder etwas Ähnliches Wenn wir nun
von der Knotengruppe zurückgehen, können
Sie sehen, dass wir den Winkel
in Grad und auch die Anzahl steuern
können in Grad und auch die Anzahl Das nächste, was Sie
wahrscheinlich kontrollieren
möchten , ist die Länge
dieser Zweige. Aber wir werden das tatsächlich später tun , denn jetzt sollten wir
diese Zweige
tatsächlich auf den
Quellpunkten verteilen diese Zweige
tatsächlich auf den
Quellpunkten , um zu sehen, wie sie
tatsächlich aussehen. Lassen Sie uns also diese
Quellgeometrie verwenden. Und wir werden diese Instanzen
erneut verwenden und sie
an den ausgewählten Punkten instanzieren. Wir können
diese Instanz also tatsächlich an Punkten duplizieren, und wir möchten nur dann eine Instanz auf der Quellgeometrie erstellen, wenn
die Auswahl ausgewählt ist. Lassen Sie uns also auch die
Auswahl darin einfügen. Und als Beispiel wollen
wir diese Struktur verwenden, wollen
wir diese Struktur verwenden die wir aus
den Kurvenlinien aufgebaut haben. Also werde ich die
Instanzen auch in diese einfügen. Und wenn ich jetzt ein bisschen
herauszoome, können
Sie sehen, dass wir hier
einige Filialen haben. Und wenn ich zur
Hauptgeometrieknotengruppe gehe, können
Sie sehen, dass wir
den Stamm und die Sorry
und die erste Ebene der Zweige haben . Und jetzt müssen wir auch die Endpunkte
dieser Zweige
ausgeben, weil wir die
gespaltenen Enden wieder so verwenden wollen und
diese
Geometrie einfach als neue Quellpunkte wiederverwenden Um die Auswahl zu erhalten, können
wir zunächst einfach
all diese Instanzen erkennen, und dann sind das
wieder die Kurvenlinien, also können wir einfach
die Punkte nehmen, an denen der Index eins
ist, und diese
als Auswahl verwenden Um den Index jedes
Punktes innerhalb der Kurve zu ermitteln, sollten
wir
einen Spline-Perimeter verwenden
, der
uns den Index in ihnen gibt Wenn wir den Viewer verwenden, können
Sie sehen, dass
alle Enden
der Punkte eine Eins und die
Quellpunkte Null haben Wenn wir einen Index verwenden würden, würden
wir unterschiedliche
Werte erhalten, da dieser Index auf all
diese Splines oder Kurven bezieht, und das ist nicht das, was wir wollen Also verwenden wir einfach diesen
Pline-Perimeterindex. Um eine Auswahl zu treffen, können
wir einfach ein
Gleichheitszeichen verwenden , und wenn
es gleich eins ist, dies unsere Wir können dieses Ergebnis
in die Gruppenausgabe einfügen und es in Auswahl umbenennen.
5. Grundlagen des Filialsystems: Hallo und willkommen zurück zu drei D-Bäumen mit
Blender-Geometon-Stangen Wenn wir nun diese gespaltenen Enden verlassen
, können
wir diese Knotengruppe duplizieren
und diese
Ausgangskurven und die Auswahl
miteinander verbinden Und jetzt können Sie sehen, dass dadurch eine zweite Ebene
der Zweige
entstanden ist. Wenn wir Gelenkgeometrie verwenden und all diese
Teile zusammenfügen, werden
Sie sehen, dass wir eine
sehr einfache Baumstruktur haben, was ziemlich cool aussieht, aber es gibt noch
viele Dinge, die wir zu den gespaltenen Enden hinzufügen
müssen. Zuallererst können Sie sehen, dass diese Zweige an dieser Kurve
ausgerichtet sein sollten, sie sollte
also
ungefähr so aussehen, und sie sollten nicht
gerade zur Z-Achse, sondern
zur Quellkurve ausgerichtet sein. Um das zu tun, können wir zu den geteilten Enden
gehen und
die Drehung dieser
Kurvenlinienstücke steuern die Drehung dieser
Kurvenlinienstücke Und um die richtige Drehung zu erreichen, wollen
wir
diese grundsätzlich an der Tangente der Quellkurven
ausrichten diese grundsätzlich an der Tangente der Quellkurven Wenn wir das
von der Seite betrachten. Also dieser Schritt, das ist zum Beispiel die Quellkurve, ist zum Beispiel die Quellkurve, und ihre Tangente ist ein Vektor, der in diese Richtung
zeigt Und wir wollen die Z-Achse
dieser Kurvengruppe
an dieser Kurventangente
ausrichten , sodass sie
ungefähr so aussieht Für diese Ausrichtung können wir die Option „Drehung am Vektor ausrichten“
verwenden, was genau das macht,
was ich hier gezeichnet habe Und wir wollen die Z-Achse
so ausrichten, dass sie hier
an diesem Vektor ausgewählt ist. Dieser Vektor wird
die Kurventangente sein, also lassen Sie uns
die Kurventangente erhöhen Und das sollte
uns die richtige Drehung geben. Lassen Sie uns also diese Rotation mit
dieser Rotation verbinden. Und jetzt können Sie sehen, dass
die Zweige korrekt entlang der Tangenten
der Quellkurven
gedreht wurden entlang der Tangenten
der Quellkurven
gedreht Wenn wir das erledigt haben, können
wir tatsächlich
eine Längeneingabe hinzufügen, die die
Längen dieser Zweige steuert Rufen wir also das
Seitenmenü auf und fügen eine neue Eingabe hinzu, die wir Länge nennen werden. Und der Standardwert
kann zum Beispiel eins sein. erste Ort, an dem Sie die
Länge der Kurven steuern
können ist dieser, denn hier
steuern wir die grundlegende Kurvenlinie, und wir können im Grunde genommen deren Länge
kontrollieren. Das Problem dabei
ist, dass alle Kurven dieselbe Länge
haben würden und wir
einige Variationen und
Zufälligkeiten in unserem Baum haben wollen , und das würde nicht wirklich natürlich
aussehen, also werden wir diese vermeiden Der zweite Ort, an dem wir das kontrollieren
können, ist
im Grunde die Skala Wenn ich also
mit diesen Werten herumspiele, können
wir hier auch die Länge
der Kurven kontrollieren. Und wir können sogar unterschiedliche Werte
für verschiedene Linien
eingeben, wie Sie hier sehen können,
ist eine rechteckige Eingabe, was bedeutet, dass es Felder gibt, und wir können für jede von ihnen einen anderen
Wert eingeben. Aber wenn ich jetzt einen zufälligen
Wert habe und etwas 1-2. Ich bin mir nicht sicher, ob es wirklich sichtbar
sein wird, aber ob wir
die Anzahl vielleicht auf drei reduzieren. Ja, in diesem
kann man es gut sehen. Sie können sehen, dass es fast so
aussieht, als ob es funktioniert, aber diese Teile hier der zweiten Ebene
sind alle gleich und sie sind nur
unterschiedlich gedreht. Wir wollen so viele
zufällige Dinge wie möglich haben. Um das
noch zufälliger zu machen, werden
wir einen
anderen Ansatz verwenden. Sie können sehen, dass
diese Teile
hier, hier und hier die kürzesten Teile
sind, und sie sind alle gleich. Um das
noch zufälliger zu machen, machen
wir das, nachdem wir die Instanzen
erkannt haben, und wir werden die Endpunkte der Kurven nach dem
Zufallsprinzip verschieben Sie können hier bei
dieser Lösung bleiben, aber ich zeige Ihnen noch bessere Lösung, die
uns mehr Zufälligkeit Lassen Sie uns diesen löschen, bis er wieder
auf eins zurückgeht. Und jetzt werden wir
die Endpunkte
dieser Kurven nehmen und sie
nach dem Zufallsprinzip entlang ihrer Tangente verschieben Fügen wir dazu
eine festgelegte Positionsnotiz hinzu. Und wir werden nur
die Endpunkte verschieben , damit wir diese Auswahl
tatsächlich verwenden können Lassen Sie uns das also
in die Auswahl einbeziehen. Und wenn ich es jetzt
zum Beispiel auf Xxs verschiebe , können
Sie sehen, dass es alle Zweige
verschiebt,
was bedeutet, dass wir
diese Endpunkte separat steuern können diese Endpunkte Die Art und Weise, wie wir
das randomisieren, besteht darin, dass wir einen Tangens von jedem Zweig
erhalten und dann einfach in einem
bestimmten Bereich randomisieren, um ihn schöner Also zuerst wissen wir jetzt, dass diese Punkte 1 Meter
von ihrer Quelle entfernt sind Das ist also einer, weil dieser
Endpunkt auf der ersten Z-Achse liegt. Lassen Sie uns also zuerst diese Punkte
wieder auf diese Quellpunkte
zurücksetzen und dann einen Zufallswert in Richtung
der Kurventangente auswählen ,
um sie zurück zu verschieben Fügen wir also eine Kurventangente hinzu. Und zuerst können wir das
normalisieren, obwohl es wahrscheinlich
normalisiert ist , werden wir es normalisieren Und wenn wir das dann skalieren
und in den Offset einbauen, werden
Sie sehen, dass wir die
Länge dieser Kurven kontrollieren können Wenn wir es auf Null setzen, haben
sie dieselbe Länge wie zuvor. Wenn wir es auf minus eins setzen, können
Sie sehen, dass sie alle zu einem Punkt
zusammenfallen. Wenn wir diesem Vektor nun einen Wert
hinzufügen, können
wir seine Länge mit derselben Technik steuern. Lassen Sie uns also
den Skalenwert duplizieren und zu diesem Original hinzufügen. Und wir setzen dieses
Ergebnis in den Offset ein. Wenn wir es jetzt auf Null setzen, können
Sie sehen, dass alle
Zweige die Länge Null haben. Und wenn ich es
zum Beispiel auf eins erhöhe, befinden
sie sich wieder an der
ursprünglichen Position, aber jetzt
machen die Steuerungen tatsächlich Sinn. Wenn es also eins ist, ist
ihre Länge eins, und wenn ich sie auf zwei setze, ist
ihre Länge zwei. Das Schöne ist, dass es
eine rechteckige Steuerung gibt. Es gibt also Felder und wir können jeden Zweig separat
steuern. Wenn ich jetzt also so einen zufälligen
Wert in diesen einfüge, wirst
du sehen, dass diese Zweige unterschiedliche Werte
oder unterschiedliche Längen
haben. Sie können sehen, dass
es diesen kurzen gibt und Sie können diesen kurzen
nicht in den verschiedenen Teilen finden, also können Sie sehen, dass
er wirklich zufällig ist. Um diese Eingabe zu steuern, können
wir nun einfach die
Längeneingabe verwenden, die wir
erstellt haben, und sie mit der Skala verbinden. Standardmäßig können Sie
sehen, dass sie Null ist, aber jetzt können wir
diese Längen kontrollieren. Und von hier aus können wir
auch
einen zufälligen Wert eingeben und Sie können sehen, dass es
für alle Kurven separat funktioniert. Das Letzte, was
Sie zu dieser Knotengruppe
hinzufügen möchten , ist,
diese Verteilung im Kreis ein wenig zu randomisieren ,
weil
das in einigen Fällen nicht wirklich gut aussieht Wenn
es zum Beispiel nur zwei gibt, können
Sie sehen, dass es so
geradlinig ist, es ist gerade, und wir wollen
das ein wenig randomisieren Gehen wir also zu Split
und Node Group
und wir kontrollieren hier die
Rotation auf der Z-Achse, kombinieren wir XYZ
in diesem Um es ein wenig zu randomisieren, fügen
wir dem einen Wert Fügen wir also einen Add-Node hinzu, und wir werden
den ursprünglichen Wert erhöhen Wenn ich es jetzt an die Z-Achse anschließe, können
Sie sehen, dass
wir die Rotation hier grundsätzlich
steuern können . Wir möchten, dass die Drehung für jede Kurve
unterschiedlich ist. Also verwenden wir einen zufälligen Wert. Und wenn ich ihn hier einfüge, wollen
wir, dass zum Beispiel zwischen minus
eins und positiv liegt. Und wir wollen auch einen anderen
Sitz für jeden von ihnen. Als Sitzplatz
können wir zum Beispiel den Index von diesen
verwenden, und jetzt können Sie sehen, dass sie unterschiedlich sind. In einigen Fällen
könnte es passieren , dass sich alle Filialen
an derselben Position befinden. Nehmen wir an, wir haben
drei Zweige wie diese, und sie können sich in
diese Richtung und Richtung drehen. Das könnte also in
etwa so enden. Der Weg,
dieses Problem zu entfernen, besteht darin,
diese Zufälligkeit an einigen Stellen zu begrenzen Also im Grunde werden wir
diesen Zweig auf diesen Teil beschränken, diesen Zweig auf diesen Teil, und diese Marke ist dieser dritte Teil Die Werte, die wir in den Zufallswert
eingeben wollen,
sind also im Grunde der
Versatzwinkel geteilt durch zwei. gibt uns also diesen Winkel, und wir werden ihn
einfach mit negativem und positivem Wert multiplizieren , und das gibt uns den Bereich. Diese Division
gibt uns also den gesamten Winkel, und wir werden ihn zuerst
durch zwei teilen, um die Hälfte davon zu erhalten, und dann können wir ihn
mit positiven und negativen 0,5 multiplizieren, was uns
diese Grenzwerte geben sollte. Wenn wir
diese Werte nun in Minimum und das Maximum dieser
Zufälligkeit zusammensetzen, werden
Sie feststellen, dass das gut funktioniert Und wir können die Anzahl auch
erhöhen. Und wenn wir von
oben schauen, können Sie sehen dass sie gut randomisiert sind Um das ein bisschen
enger zu machen, können
wir es zum Beispiel sogar durch drei teilen, um engere Grenzen zu erhalten, und ich denke, ich lasse es auf Freeze stehen, damit sie sich
berühren können Okay, der letzte Teil ist, dass wir dieser Knotengruppe einen
Startwert hinzufügen weil wir in der Lage sein wollen, einen Satz all
dieser Zufallswerte zu kontrollieren. Fügen wir also einen neuen Eingang hinzu
und verbinden ihn mit dieser ID. Und ich füge hier einfach read out und wir werden
diese ID in Seat umbenennen. Lassen Sie uns diesen Wert auch nicht verstecken, also deaktivieren Sie diesen Höhenwert ,
da er
standardmäßig für die ID gilt Und jetzt können wir
es von außen kontrollieren, sodass Sie sehen können, dass wir die Zufälligkeit der Rotation auf
der ersten Ebene
und auch auf der zweiten Ebene
kontrollieren können Rotation auf
der ersten Ebene
und auch auf der zweiten Ebene Um dies zu testen, lassen Sie uns auch
auf der dritten Ebene testen. Ich verwende wieder die vorherigen
Kurven und die Auswahl
und füge sie zu
dem Spin zusammen, und füge sie zu
dem Spin zusammen sodass wir
das etwas kürzer machen können. Sie können sehen, dass wir jetzt
eine ziemlich interessante Struktur haben , die ein
bisschen wie ein Baum aussieht. Aber in den nächsten Lektionen werden
wir weitere Details hinzufügen, was das Ganze noch besser machen
wird.
6. Erweitertes Zweigsystem: Willkommen zurück zu kostenlosen D-Bäumen
mit Blender-Geometrieknoten. In dieser Lektion werden wir
weiter an
unserem Verzweigungssystem arbeiten und insbesondere eine neue
Knotengruppe erstellen, die
diese gespaltenen Enden kombiniert und so
ein vollständiges Verzweigungssystem erstellt. Lassen Sie uns also zuerst
diese Knoten löschen, weil wir sie
nicht mehr benötigen, und wir werden
eine neue Knotengruppe erstellen. Also verbinde ich diese
Kurve einfach mit der Ausgabegeometrie an einem Rearut und wenn der Rearut
ausgewählt ist, drücke
ich Strg G, um eine neue Knotengruppe zu
erstellen Ich nenne diese
Knotengruppe ein Zweigsystem. Diese Knotengruppe im
Zweigsystem
funktioniert also so , dass sie
einige Eingaben hat. Eine davon wird
die Auswahl sein, von der aus wir
die Filialen
ausbauen wollen. Nehmen wir an, das ist der Stamm
und das ist die Auswahl, und dann schließen wir
ihn an das Filialsystem an. Die Eingabe, die im
Filialsystem erfolgen wird, ist die Anzahl der Ebenen. Das ist also die Anzahl der
Ebenen der Filialen. So sehen zum Beispiel zwei Ebenen von
Zweigen aus, und wenn wir eine weitere hinzufügen, das drei Ebenen. So können wir kontrollieren,
wie viele Ebenen es gibt. Und später werden wir auch eine
Art Randomisierung hinzufügen. Es wird also die Länge der ersten Zweige
und der letzten Zweige geben, und es wird eine Wechselwirkung
zwischen diesen Werten geben und auch, wie stark sich die
Zweige Es wird also eine minimale
und maximale Anzahl von Verzweigungen geben, die jeweils
generiert werden . Gehen wir
also zur Knotengruppe des Zweigsystems
und fügen einige der Eingaben hinzu Der erste Schritt wird die Auswahl sein. Also füge ich eine neue
Mobbing-Eingabe hinzu und nenne sie Auswahl. Und der nächste wichtige
Punkt ist die Anzahl der Stufen. Fügen wir also eine neue Eingabe hinzu. Dieser wird eine Ganzzahl sein, und wir können ihn Ebenen nennen. Ich denke, das ist vorerst
in Ordnung und wir können anfangen, an
der Gesamtkonfiguration zu arbeiten. Fügen wir also unsere Knotengruppe mit geteilten
Enden hinzu, die die Basis
dieser Knotengruppe bilden wird. Und im Grunde funktioniert
das
so, dass wir eine Wiederholungszone verwenden, der
sich gespaltene
Enden befinden, und die Wiederholungszone iteriert abhängig von der Anzahl der Ebenen , die wir in
diese Knotengruppe eingeben Und nach all
diesen Iterationen wird
es ein
finales Zweigsystem schaffen Fügen wir also eine Wiederholungszone hinzu. Und die Anzahl der Iterationen
wird Ebenen sein, also können wir Ebenen
in Iterationen einbinden, und die Ausgabegeometrie
wird aus
der Stripe-Zone kommen , sodass wir sie in die Ausgabe
einbinden können Die Ausgangsgeometrie wird
der Stamm sein , den wir in diese Knotengruppe eingeben
, sodass wir die
Geometrie auch in diese Geometrie einfügen können Und bei jeder Iteration werden
wir diese Geometrie verwenden, sodass wir sie
in Split-Ends einbauen können Wir haben eine Auswahl getroffen und sie mit der
vorherigen Geometrie verknüpft Fügen wir also die Kinngeometrie und fügen sie im Grunde mit der
Quellgeometrie zusammen. Und wir müssen die Auswahl auch
speichern. Also stecken wir diese Auswahl
in diesen leeren Socket, wodurch hier mit Auswahl ein neuer
Socket erstellt wird, und wir werden diesen
als Auswahl für die nächste Iteration verwenden als Auswahl für die nächste Iteration Für die erste Iteration wird
dies also eine Auswahl
aus der Gruppeneingabe sein Aber später in den nächsten Iterationen wollen
wir die Auswahl
aus diesen neuen Zweigen verwenden Also werden wir das
an die Ausgabe anschließen. Wenn wir nun
diese Knotengruppe verlassen und die Anzahl der Ebenen
erhöhen, können
Sie sehen, dass
sie anfängt zu wachsen. Ich werde auch
mit der Anzahl herumspielen, und Sie können sehen,
dass wir kontrollieren können wie viele Ebenen von
Zweigen es gibt. Wenn wir jetzt überprüfen, wie viele
Kurven es tatsächlich gibt, können
Sie sehen, dass es 16 Splines
gibt, aber das entspricht nicht dem was wir sehen, denn
wenn
wir das zählen, haben wir einen Stamm,
drei Zweige, und jeder von ihnen hat drei Zweige
zweiter Ebene, was zusammen
13 ergeben sollte, aber wir haben 16. Das Problem dabei ist
, dass diese Auswahl die
vorherige Auswahl
nicht löscht Um
diese Auswahl tatsächlich zu korrigieren, erstellen
wir ein neues
benanntes Attribut, das
uns sagt, welche Punkte wir in der
nächsten Iteration erweitern
möchten Und für alte Geometrie setzen
wir es auf „fällt und für neue Geometrie
setzen wir es auf „Auswahl Fügen wir also ein
Store-Attribut hinzu. Und wir können es
wie bei der Auswahl nennen, der Typ ist Bolin, und für all diese Zweige aus früheren
Stufen wird es falsch sein Also lassen wir das bei Falls. Und wenn wir das duplizieren und es an diese gespaltenen Enden anschließen, fügen
wir dem Wert die Auswahl
hinzu. Und jetzt können
wir für die Auswahl
in der nächsten Iteration dieses benannte Attribut
namens S verwenden und es
in die Auswahl einfügen Wenn wir nun
die Stufen auf zwei erhöhen, können
Sie sehen, dass wir
statt 16 nur 13 Splines nach unten
haben .
Das funktioniert also gut Und jetzt können wir damit beginnen
,
diese Eingänge von geteilten
Enden mit diesem Gruppeneingang zu verbinden . Die nächste Eingabe der
gespaltenen Enden ist also Anzahl, und wir
wollen
diese Eingabe eigentlich randomisieren , weil wir nicht
wollen, dass sie konstant ist, aber wir wollen hier einige
Variationen. also zum Beispiel Das erste Level würde sich also zum Beispiel in drei Zweige
aufteilen, dann in vier und dann nur noch in zwei
oder so ähnlich Um das zu tun, fügen wir einen zufälligen Wert hinzu. Der Typ dieses
Zufallswerts wird
Ganzzahlen sein , weil count ebenfalls eine Ganzzahl
ist, und wir fügen diese
Minimal- und Maximalwerte
in Gruppeneingaben Wir können also diesen leeren
grauen Schaltkreis verwenden, um ihn zu verbinden, und dieser Ausgangswert
wird an count angeschlossen Sie können sehen, dass
diese Verbindung jetzt rot ist, aber wir können das beheben. Wir
können dieser Wiederholungszone eine neue Variable
hinzufügen, die uns sagt, in
welcher
Iteration wir uns befinden werden Und wenn wir diese
Iteration mit ID oder C verbinden, wird
das zu einer Konstante
und nicht zu einem Feldwert konvergieren, und dieser sollte nicht mehr gelesen
werden Also haben wir die Wiederholungszone ausgewählt, N gedrückt und gehen zum Knoten, und wir werden eine neue Eingabe hinzufügen, die ich als Iteration nenne
und die Ganzzahl vom Typ zwei setze Und am Anfang wollen wir, dass
sie zum Beispiel
Null ist, und dann wollen
wir sie bei
jeder Iteration um eins erhöhen Fügen wir also bei Mathe hinzu, dass wir
eins hinzufügen und es
für die nächste Iteration speichern Das wird jetzt
jede Iteration inkrementieren. Das bedeutet, dass es für
jede Iteration anders
sein wird und wir es zum Beispiel
für die ID verwenden können , und jetzt
können Sie sehen, dass der Wert
nicht mehr Und das hat
etwas Seltsames erzeugt, aber das liegt daran, dass das Minimum Null und das Maximum 100 ist Wenn wir das auf, sagen wir,
zwei bis fünf ändern , können Sie sehen,
dass es bei der ersten Iteration in fünf Zweige aufgeteilt wurde und bei der nächsten nur 23. Wir wollen auch in der Lage sein, das Saatgut
zu kontrollieren. Lassen Sie uns also auch den
Seed mit dem Gruppeneingang verbinden. Und ich benenne
diese Min und Max einfach in
Min Split Count und
Max Split Count um . Und verschiebe das Set wie immer an
den Anfang der Gruppeneingabe. Jetzt ist die Anzahl der Stufen also randomisiert und die
nächste Eingabe ist Länge weiterer Länge werden wir auch
eine gewisse Randomisierung vornehmen, sodass wir
diesen Zufallswert duplizieren
und ihn auf Float setzen können und ihn auf Float setzen Und wenn wir nun diesen
Zufallswert in diese Länge einbauen, werden
Sie sehen, dass jeder
der Zweige eine
andere Länge hat, und genau das wollen wir das Traurige angeht, können wir den
Sitz aus der Gruppeneingabe diesem Startwert
verbinden und die ID unverändert lassen,
weil
sie standardmäßig den Index auswählt, was für diesen Zweck in
Ordnung ist. Für die Min- und Max-Werte
gibt es nur wenige Optionen, wie wir das kontrollieren können. Und eine Sache, die ich
gerne tun würde, ist, dies
vom aktuellen
Iterationsgrad abhängig zu machen vom aktuellen
Iterationsgrad abhängig , auf dem wir uns befinden So können wir zum Beispiel
lange Zweige auf der ersten Ebene
und dann kürzere Zweige
auf der letzten Ebene
erstellen lange Zweige auf der ersten Ebene und dann kürzere Zweige
auf der letzten Ebene Und wir werden diese auch ein wenig
randomisieren wollen, also werden wir eine
Art Zufälligkeit hinzufügen Fügen wir also eine erste Eingabe hinzu, nämlich die Länge des ersten
Zweigs,
wodurch die Länge der
Zweige auf der ersten Ebene festgelegt wird, und wir können die Standardeinstellung auf
eins und das Minimum auf Null setzen Und ich werde
das duplizieren und es
in letzte Astlänge umbenennen , wodurch die Länge der
letzten Zweige oder
im Grunde der Zweige auf der letzten Ebene gesteuert wird letzten Zweige oder
im Grunde der Zweige wodurch die Länge der
letzten Zweige oder
im Grunde der Zweige auf der letzten Ebene gesteuert wird, und sie
zum Beispiel auf 0,5 setzen . Die letzte Eingabe für
die Zweige ist die Zufälligkeit der Astlänge, also fügen wir auch das hinzu Und wir können diese
Standardwerte unverändert lassen. Um nun die Länge
der Verzweigung auf jeder Ebene zu berechnen, verwenden
wir einen
Kartenschlüssel und auch diesen
I-Wert , den wir als
ID für die Randomisierung verwendet haben Fügen wir also einen Kartenschlüssel hinzu. Und wir werden
dieses I neu zuordnen, weil es
von Null auf die Anzahl
der Stufen minus eins geht von Null auf die Anzahl
der Stufen minus eins Oder in diesem Fall
können wir
es tatsächlich auf den Startwert auf eins erhöhen , und jetzt geht es von
eins auf mehrere Stufen Und jetzt können wir diesen I-Wert einfach mit
Map Wrench von einer
auf mehrere Stufen umordnen Map Wrench von einer
auf mehrere Stufen Und der Bereich, dem wir das neu zuordnen
wollen, reicht von der ersten bis
zur letzten Astlänge Das heißt,
wenn das I eins ist,
was bedeutet, dass wir uns
auf der ersten Ebene befinden, die Ausgabe dieses Map-Zweigs die Länge des wird
die Ausgabe dieses Map-Zweigs die Länge des ersten Zweigs Und wenn wir uns auf der letzten Ebene befinden, wo
das I für Ebenen steht, entspricht die Länge der Zweige der Länge des letzten Zweigs. Wir werden diesen Wert
für die Randomisierung verwenden, und wir werden ihn randomisieren, indem wir zu
dieser Basislänge
einen Zufallswert im
Bereich von minus Zufälligkeit
und Plus-Zufälligkeit hinzufügen zu
dieser Basislänge
einen Zufallswert im Bereich von minus Zufälligkeit
und Plus-Zufälligkeit Wenn ich das visualisiere, nehmen
wir an, hier ist dieser Kartenbereichswert und wir werden ihn in einem Bereich
randomisieren, in dem L minus Zufälligkeit
und
das L plus Zufälligkeit ist und Wenn R also etwas Kleines ist, es in einem kleinen
Bereich zwischen L, und wenn es größer ist, gibt
es Das bedeutet also, dass das Minimum dieses
Zufallswerts Ranch der Karte abzüglich der Zufälligkeit der
Nebenlinien Ziehen wir das also
von der Map Ranch ab. Und das Maximum ist Map
Wrench plus Zufälligkeit, also kann ich das mit
Control Shi D duplizieren und einfach den Typ auf
Addition ändern Wenn wir nun
die Werte auf Minimum und
Maximum setzen und nach draußen gehen, können
Sie sehen, dass wir
die Stufen
je nach Stufe kontrollieren können die Stufen
je nach Stufe Und wenn ich die Stufen erhöhe, werden
Sie feststellen, dass, wenn ich die Länge des ersten Zweigs
ändere, nur
die erste Ebene und auch die anderen geändert werden, aber die größte Änderung
ist auf der ersten Ebene, und wir können auch die Länge
des letzten Zweigs
sowie die Zufälligkeit der Zweige kontrollieren Länge
des letzten Zweigs
sowie die Zufälligkeit der Zweige Stimmt, jetzt denke ich, dass
das Filialsystem bereit für den nächsten Einsatz
ist Wir können auch
mit den Eingaben herumspielen, und Sie können sehen, dass
es
ziemlich nette drei Strukturen generiert . Und das Letzte, was wir
tun können , ist,
diese Eingänge mit
dem Hauptgruppeneingang zu verbinden und auch
ein Panel zu erstellen , das die Zweige
steuert. Lassen Sie uns also ein neues Panel hinzufügen.
Ich werde Zweige zusammenstellen Und jetzt werde ich eine Gruppeneingabe aufrufen und wie immer
diesen leeren Socket verwenden, um diese neuen Eingaben zu
erstellen Und weil, wenn wir
das mit dem Socket verbinden, wird
es den aktuellen
Wert als Standard verwenden. Also werde ich hier einfach ein paar
nette Standardwerte setzen. Also
so etwas. Und jetzt werde ich all diese Eingänge
in der Gruppeneingabe erstellen , indem ich einfach diesen leeren
Schaltkreis in alle hineinziehe. Wenn alle
Eingaben erstellt sind, verschiebe
ich sie einfach
in das rechte Bedienfeld, das ist das Verzweigungsfeld Außerdem verschiebe ich den
Startwert an den Anfang
der Eingänge und verstecke sie
zum Beispiel
an Sockets mit Control H, jetzt
sieht es ziemlich gut Eine weitere Sache, die wir
tun könnten , ist diesen
Baum ein bisschen aufzuräumen. Also werde ich einfach
andere Gruppeneingaben verwenden. Also das ist nicht so chaotisch. Und verbinden Sie diese Eingänge
einfach wieder mit ihren eigenen Gruppeneingängen Jetzt, wenn alles fertig
ist, können
wir zum Modifikator-Schritt übergehen und Sie können mit
dieser grundlegenden Baumstruktur
mit all diesen Eingaben herumspielen dieser grundlegenden Baumstruktur
mit all diesen Eine letzte Sache, die
ich vergessen habe hinzuzufügen, ist die
Steuerung des Winkels, weil
wir das vergessen haben Und mit diesem Aspekt wollen
wir
eigentlich kontrollieren, wie weit das
gesamte Filialsystem verteilt ist. Lassen Sie uns dafür auch schnell neue Eingaben hinzufügen dafür auch schnell neue Eingaben Wir wählen einfach einen Basiswinkel
und dann die Zufälligkeit, und das funktioniert
genauso wie die Astlänge, aber mit nur einem Basiswinkel Fügen wir also die erste
Eingabe zum Winkel und die zweite zur
Winkelzufälligkeit Ich werde diese Gruppeneingabe duplizieren und wir werden dieselbe
Technik wie hier verwenden Also verwende ich einfach
diesen Zufallswert,
verwende diesen, diesen Sat, und wir addieren und
subtrahieren einfach die Zufälligkeit vom Grundwert wie diesem und setzen ihn in
Minimal- und Maximalwerte Dadurch wird
der zufällige Winkel generiert und wir können ihn
in den Winkel einfügen Sie können sehen, dass
jetzt alles flach ist, aber das liegt daran, dass diese
Eingaben auf Null gesetzt sind, also werde ich
es einfach ein wenig erhöhen. Und wir können
den Subtyp
dieser beiden Winkel auch so einstellen , dass
sie in Grad angegeben sind. Das Letzte
, was wir tun sollten ist, diesen Samen mit unserem globalen Saatgut
zu verbinden. Also verbinde ich einfach den Seed von der
Gruppeneingabe mit den geteilten Enden. Und um das Ganze zu beenden, verbinden
wir diese beiden Eingänge mit der
globalen Gruppeneingabe, wieder
mit diesem Grau, legen sie fest und verschieben sie
in das
Branche-Panel und verschieben sie
in das
Branche-Panel
7. Interne Daten: Hallo und willkommen zurück zu kostenlosen D-Bäumen mit
Blender-Geometon-Knoten In dieser Lektion werden
wir
interne Daten implementieren, die wir für die Verteilung
unserer Blätter und für die Bestimmung des Radius jedes
Zweigs für jeden Punkt verwenden
werden unserer Blätter und des Radius jedes
Zweigs für jeden Punkt Ich habe
diese Daten bereits in der
Einführung in Zweige erklärt , werde sie
aber in Kürze
durchgehen beiden handelt es sich um Attribute , die
für jeden Punkt gespeichert werden, und das erste davon ist die Länge. Was am Anfang
der Wurzel Null ist
und dann zunimmt, und dann zunimmt je nachdem, wie weit wir
von der Wurzel entfernt sind. So kann es zum Beispiel ungefähr so
aussehen. Und dann werden wir auch
die Umkehrung dieser
oder entgegengesetzten Version implementieren , die als
Länge vom Ende bezeichnet wird Und dieser wird derselbe sein, aber in die entgegengesetzte Richtung Also an den Enden der
Zweige wird das Null sein. Und
je näher wir der Wurzel kommen, desto mehr wird der Wert steigen. Die Länge vom Ende der Zweige
wird für die
Verteilung der Blätter an
den Enden der Zweige verwendet . So können wir zum Beispiel den Wert auf
Null oder 1,5
setzen, was irgendwo
hier sein kann, und die Blätter werden nur
an diesen Zweigen verteilt. Und die Grundlänge
wird für die
Berechnung
des Radius des Astnetzes verwendet . Okay, lassen Sie uns zu
den Geometrieknoten kommen, und wir werden
beide innerhalb des
Verzweigungssystems implementieren beide innerhalb des
Verzweigungssystems Gehen wir also zum Filialsystem. Und die erste, die
wir verwenden wollen, ist die Länge, weil diese etwas einfacher sein
wird. Also werden wir
diese Attribute speichern. Also zuerst können wir
tatsächlich eine gewisse
Grundlänge für den Kofferraum speichern. Also füge ich das Sterne-Attribut hinzu. Es wird für jeden Punkt Float sein, also sind die Standardwerte in Ordnung, und der Name wird length sein Für diesen Fall
verwenden wir einen Spline-Perimeter, uns
die
Länge jedes Punktes angibt Und wenn wir uns das vorstellen, können
Sie sehen, dass es unten
Null
und oben zwei Wenn wir jetzt zum Filialsystem übergehen, funktioniert
das so, dass zum Beispiel in
dieser ersten Ebene ich
zum Beispiel in
dieser ersten Ebene den Wert einfach verringere. In dieser ersten Ebene hat dieser
Quellpunkt eine Länge von zwei. Für all diese Punkte fügen
wir
zu diesem Grundwert eine Länge hinzu, uns beispielsweise ergibt, wenn diese Kurve eine Länge von eins hat, ergibt sie
an diesem Punkt drei. Die Länge wird also innerhalb
der gespaltenen Enden
implementiert , weil
wir das hier machen können. Also gehe ich zu Split-Ends
und wir werden hier
am Ende speichern , nachdem die Endpunkte
je nach Länge
verschoben Also füge ich ein Attribut mit
dem Namen Store hinzu und setze den Namen auf Länge Und die Länge entspricht der aktuellen Länge
der Kurve plus der Länge
des Quellpunkts. Also fügen wir diesem einen
Wert hinzu,
und der Wert, den wir
verwenden werden , ist die Länge
des Quellpunkts. Also werden wir ihn erfassen, bevor wir die Kurve
darauf instanziieren. Fügen wir also das Capture-Attribut hinzu. Und wir werden die Länge
erfassen. Fügen wir also auch das benannte
Attribut Länge hinzu. Wir werden es so erfassen
und dann diesen Wert in diese Addition einfügen, was bedeutet, dass,
wenn dieser Punkt zum Beispiel zwei hat, diese Kurve eine Länge von 0-1 hat, diese Werte addiert werden, und wir erhalten zwei hier unten und drei
hier oben Wenn wir das also
in einem benannten Attribut speichern, können
wir es jetzt
am Ende dieser Wiederholungszone visualisieren, also rufe ich das
benannte Attribut auf Und jetzt können Sie sehen, dass diese Punkte
etwas andere Werte haben. Vielleicht werde ich mir
das am Ende dieses Filialsystems vorstellen , das das beste sein wird. Und wir können auch
die Anzahl der
Ebenen erhöhen und die
Filialen sichtbarer machen. Wenn wir uns das nun vorstellen, können
Sie sehen, dass
dieser Quellpunkt Attributlänge Null
hat, dann liegt dieser Wert
irgendwo bei drei. Und es gibt 3.7, 4.7. Ordnung, ich glaube, ich habe
einen kleinen Fehler
in den gespaltenen Enden gemacht . Hier müssen zusätzlich
dieser Spline-Umfang
und die Wirbelsäulenlänge angegeben werden ,
die ich zuvor verwendet habe, weil diese Wirbelsäulenlänge
uns nur die Länge der Kurve gibt,
aber wir wollen die Länge
an jedem Punkt Also müssen wir
diesen Spin-Perimeter verwenden. Und wenn wir nun
diese Werte visualisieren, zum Beispiel
mit einem höheren Wert,
dann nehme
ich den Wert größer und
deaktiviere diesen Attributtext Sie können sehen, dass, wenn ich diesen Wert
erhöhe, alle Zweige schwarz werden. Um das noch sichtbarer zu machen, können
wir diese
Kurven an mehr Punkten neu berechnen, und jetzt sehen Sie
diese schöne Grenze zwischen Schwarz und Weiß, die
entlang der Zweige verläuft Das ist also für die Länge. Jetzt wollen wir das
entgegengesetzte Attribut , nämlich die Länge vom Ende. Dieser wird
etwas kniffliger sein,
und das liegt daran, dass wir
das Filialsystem
so aufbauen , dass wir beim Stamm beginnen und
dann
bis zu den Enden weitermachen Aber das beste Szenario
wäre, dass wir am Ende
beginnen
und dann von vorne anfangen würden , aber das ist ein bisschen, das sehr kompliziert sein
wird Also müssen wir einen
Weg finden, die Länge
von den Enden aus zu berechnen. Wir berechnen
das so, dass wir für den Stamm die Länge
in entgegengesetzter Richtung speichern, also die Länge vom Ende. Also oben wird es
Null sein, und unten sind
es zwei, weil dieser
das Ende sein wird. Und hier unten beträgt
die Länge vom Ende zwei. Und dann nehmen
wir bei jeder Iteration die Länge
des nächsten Zweigs Nehmen wir an, dieser ist
einer und fügen ihn zu
all diesen Punkten Dieser wird also Null
plus eins und zwei plus eins sein. Und für diese Kurve speichern wir wieder die umgekehrte
Länge vom Ende Also hier wird Null sein und hier wird eins sein, was diesem entspricht Wenn wir das nun für
jedes Level machen, hat
dieses wieder eins und wir werden alle
vorherigen Punkte in dieser Länge
bearbeiten. Dieser wird also zwei sein. Dieser wird eins sein, und das ist zwei plus eins plus
eins, was vier ist. Und du kannst sehen, dass
das in jedem Level den
Abstand zum Ende vergrößert. Nehmen wir an, das ist 0,5, es ist Null, 0,5,
Eins plus fünf, 2,5 und 4,5 und du kannst
sehen, dass
wir am Ende diesen Wert haben sollten , der der Länge vom Ende
entspricht. Wir werden auch
dieses interne Filialsystem implementieren, aber wir werden nicht auf Split-Ends eingehen, sondern wir bleiben auch hier
in der Wiederholungszone. Und wie zuvor
werden wir
zunächst damit beginnen, dieses Attribut
für den Hauptstamm zu speichern. Verwenden wir also ein anderes
benanntes Attribut, aber wir nennen dieses
eine Länge vom Ende. Und dieses
wird die umgekehrte Länge haben. Um also die umgekehrte Länge zu erhalten, können
wir die
Gesamtlänge
dieser Kurve nehmen und dann
diesen Umfang davon subtrahieren Lassen Sie uns also auch Sorry, Rückenlänge angeben, was
uns die Länge der Kurve ergibt Sie subtrahieren diesen
Längenumfang
, der für
jeden Punkt von
Null zur Länge geht , und beginnen mit
der Länge vom Ende Wenn wir diesen Wert visualisieren, können
Sie sehen, dass er hier oben
Null und unten zwei Jetzt im Filialsystem werden wir genau das
tun, was ich hier
erklärt habe. Für diese neuen Kurven speichern
wir also einfach
die umgekehrte Länge Also verwende ich wieder dieses Attribut mit
dem Nachnamen setze es auf die Länge vom Ende Der Typ wird fließen,
und wir werden denselben
Wert verwenden, den wir hier verwendet haben Wir nehmen also eine Spline-Länge und subtrahieren
den Spline-Umfang eine Spline-Länge und subtrahieren
den Spline-Umfang wie folgt.
Das gibt uns
wieder den
umgekehrten Längenfaktor
und wir speichern die Länge vom und wir speichern Und für alle vorherigen
Stufen, also diesen Socket, addieren
wir die maximale Länge
dieser Nu-Kurven zu
ihrer Länge vom Ende Also werde ich diese duplizieren und wir werden ihre
vorherige Länge vom Ende nehmen, was wir mit
dem benannten Attribut nehmen und eine Länge dieser
Kurven zu dieser Länge
hinzufügen. Das Problem dabei ist, dass diese neuen Kurven unterschiedliche Längen
haben können
und es nicht wirklich eine Möglichkeit gibt, und es nicht wirklich eine Möglichkeit gibt jede unterschiedliche Länge
auf die vorherigen Ebenen zu
bringen. Nehmen wir an, wir haben
den Strunk und dann erzeugt
er zwei Zweige Einer ist kürzer und
einer ist länger. Das vorherige Level hat also, sagen
wir, hier ist
Eins und hier ist Null, und wir können die Länge in diesem Punkt nicht
herausfinden ,
weil
es von diesem Punkt aus, ich weiß nicht, sagen wir,
0,2 ist , aber von diesem Ende aus kann
es wie eins sein. Wir wissen also nicht, welchen
Wert wir hier haben wollen. Und meiner Meinung nach ist es
am besten, wenn wir die maximale
Länge dieser Kurven
hinzufügen oder hinzufügen können. Da das also 0,2 ist
und diese eine ist, verwenden
wir diese Kurve was bedeutet, dass dieser Punkt
den Abstand eins hat, und dieser hat eins
plus eins, was zwei ist. Um diese maximale Länge zu erhalten, können
wir einfach diese Geometrie nehmen und Attributstatistiken verwenden. Und wir werden die maximale
Länge der Kurven wollen. Die Domäne, in der
wir auswählen, ist also Wirbelsäule, und das Attribut, das
wir verwenden möchten, ist diese Länge aus der Rückenlänge. Also werde ich
es duplizieren und es in
das Attribut einfügen und hier
etwas Platz machen. Und im Grunde nehmen wir einfach dieses Maximum und fügen es so
zur vorherigen Länge vom Ende hinzu und speichern
es in der Länge vom Ende. Um es zusammenzufassen:
Für die neuen Kurven speichern
wir den
umgekehrten Längenfaktor und für die alten Kurven fügen
wir einfach die maximale Länge dieser neuen Kurven zu ihrer
vorherigen Länge vom Ende Wenn wir das nun hier visualisieren, verwende
ich wieder das benannte
Attribut length from end Es ist hier. Und dann
können wir wieder das Größere verwenden, denn damit können
wir uns das gut vorstellen. Und wenn ich den Wert erhöhe, kannst
du sehen, dass dieser
Wert gut
von den Enden der
Zweige bis zur Wurzel reicht . Sie können sehen, dass, wenn er Null ist, alle weiß sind,
und wenn ich ihn erhöhe, sind
die Enden schwarz und es geht zur Wurzel.
8. Wurzeln: Willkommen zurück zu kostenlosen D-Bäumen
mit Blender-Geometrieräten. In dieser Lektion werden wir weiter an unserer Baumstruktur arbeiten. Insbesondere werden wir an den Wurzeln
arbeiten. Wenn du versuchst,
Wurzeln für unseren Baum zu zeichnen, also so etwas, beachte, dass diese Form
hier unten der hier oben sehr
ähnlich ist. Und genau das
werden wir verwenden, weil wir
unsere Knotengruppe im Zweigsystem wiederverwenden werden , um die Wurzeln
mit derselben Technik zu erstellen. Gehen wir also zu den Geometri-Knoten, und hier können wir sehen,
dass
wir in diesem Teil unser Verzweigungssystem erstellen, und wir werden
dasselbe hinzufügen, aber für die Wurzeln Dafür können wir also
diese Knotengruppe des Zweigsystems duplizieren diese Knotengruppe des Zweigsystems Und wenn wir uns unseren Stamm
ansehen, werden
wir auch
diesen verwenden, aber wir wollen nicht, dass
Zweige vom oberen Teil,
sondern vom unteren Teil wachsen . Lassen Sie uns hier also unsere Geometrie
mit Geometrie verbinden. Und wenn wir jetzt
dieses Zweigsystem ausgeben , können
wir alles sehen. Aber wenn wir unsere
ursprüngliche Auswahl hier platzieren, haben
wir einen sehr einfachen
Baum, genauso wie zuvor. Als Erstes müssen wir
korrigieren, dass
die Zweige
von unten wachsen sollen . Anstatt also Punkt
mit Index eins, was hier oben ist, wollen wir sie von Punkt
mit Index Null aus
wachsen lassen. Also können wir
das gleich mit
Control h D duplizieren und einfach eins auf Null
ändern. Und wenn das gleich Null
ist, werden die Zweige erzeugt. Jetzt können Sie sehen, dass es die Zweige
erzeugt, aber es gibt ein Problem, weil sie in
die falsche Richtung wachsen. Wir wollen, dass sie
in diese Richtung wachsen statt in diese Richtung. Um das zu beheben, ist
es am einfachsten , einfach die
Stammkurve zu nehmen und sie umzukehren, wodurch die
Richtung dieser Kurve umgekehrt wird. Fügen wir also eine umgekehrte Kurve hinzu
und schließen unseren Kofferraum daran an. Und wenn wir nun diese
Kurve in die Geometrie und diese Auswahl in die
Auswahl des Zweigsystems einfügen, können
Sie sehen, dass
das Zweigsystem genau das
geschaffen hat, wonach
wir suchen, und das sind
die Zweige, die am Boden unseres Stammes wachsen . Was wir nun
tun können, ist, dass wir
diese generierten Kurven
mit den Verzweigungskurven kombinieren können . Also füge ich diese
Geometrien einfach zusammen. Sie können zuerst einfach
eine Gelenkgeometrie hinzufügen und sie separat
verbinden und sie manuell
verbinden, oder
Sie können Strg und Umschalt-Taste gedrückt halten und mit der
rechten Maustaste über
diese beiden Knoten ziehen Dadurch wird
die Gelenkgeometrie generiert und diese beiden
Zweige miteinander verbunden Wenn wir das jetzt ausgeben, können
Sie sehen, dass wir
eine schöne Baumstruktur haben. Das einzige Problem, das
wir jetzt im Setup haben ,
ist, dass dieses Verzweigungssystem die Stammkurve
enthält, genauso wie das Wurzelsystem auch diese Stammkurve enthält. Das bedeutet also, dass es
hier in diesem Abschnitt zwei gleiche Kurven
gibt, die sich überlappen Wir wollen so
etwas nicht, also müssen wir einen
dieser Koffer loswerden Um einen
dieser Trunks loszuwerden, können
wir zum Beispiel Attribut vor all
diesen Knotengruppen für
den Trunk
speichern und dann überprüfen, wo dieses Attribut zugewiesen ist, und wir werden diese Geometrie entfernen Also werden
wir hier zum Beispiel eine hintere Route hinzufügen und wir werden ein Attribut mit
dem Namen speichern Zum Beispiel können wir ein Bolin hinzufügen, wir können es zum Beispiel
Trunk nennen und es auf true setzen Das bedeutet, dass
der Stammkurve jetzt dieses
Trunk-Attribut zugewiesen
wurde Und im
Filialsystem werden wir
dieses Attribut ebenfalls hinzufügen , aber wir werden es auf Stürze setzen. Gehen wir also zum Filialsystem. Und hier, wo wir
unsere neuen Filialen mit
dem gesamten Setup verbinden , fügen
wir ein
Store-Named-Attribut hinzu, und wir werden den
Stamm wieder speichern, ihn aber auf Falls setzen. Wenn wir nun
dieses Filialsystem verlassen und
das benannte Attribut Stamm überprüfen, können
Sie sehen, dass
diese Kurve wahr ist, aber diese Kurven sind alle falsch. Also können wir das verwenden. Und zum Beispiel lösche ich
diesen Stamm aus den Wurzeln, aber Sie können ihn auch
aus Zweigen löschen, aber nur aus einem davon. Fügen wir also eine gelöschte Geometrie hinzu, und wo der Stamm wahr ist, möchten
Sie ihn löschen. Also werde ich es so benutzen. Wenn wir uns das ansehen, können
Sie sehen, dass die Wurzeln den Stamm
nicht enthalten, sondern diese Zweige ihn enthalten. Zusammen ergibt das den ganzen Baum,
ohne dass es zu Überschneidungen kommt den ganzen Baum,
ohne dass es zu Überschneidungen Stimmt. Jetzt hat unser
Kurvensystem also auch Wurzeln, und wir wollen in
der
Lage sein , all diese Parameter zu kontrollieren, was wir
für Zweige kontrollieren können. Wir wollen sie auch
für Wurzeln kontrollieren. Dafür werden wir also
eine Reihe von Gruppeneingaben hinzufügen, und wir werden sie
mit diesem leeren Sockit hinzufügen Für den Sitz können
wir also den vorhandenen verwenden Also lass es uns an den Sitz anschließen. Aber das wird dazu führen, dass diese beiden Knotengruppen dasselbe SAD
verwenden, und wir könnten mit ihnen dieselben
Ergebnisse erzielen. Machen wir es also ein
bisschen anders. Dafür können wir
beispielsweise einen MF-Knoten verwenden. Ich multipliziere gerne mit, und wir werden
diesen Samen
zum Beispiel mit 15 und mit einer
zufälligen Zahl, sagen wir 42, multiplizieren . Und jetzt wird uns das
wahrscheinlich
immer den anderen traurigen Wert geben als der ursprüngliche Wert. Jetzt haben wir also den Sitz, und
jetzt werden wir einfach
all diese Gruppeneingänge oder
Buchsen mit dem Gruppeneingang verbinden . Also werden wir diese
leere Steckdose benutzen und ich werde sie so
anschließen. Und jetzt, wenn all diese
Sockets verbunden sind, können
wir das Site-Menü aufrufen
und ich füge ein neues Panel hinzu, das ich Roots nenne. Um es zu beenden, verschiebe ich all diese Attribute oder Eingaben
in dieses Roots-Panel. Ordnung, jetzt, wo alle
Socuits verbunden sind, können
wir neue Socuits mit
Strg H verstecken und auch
diesen Notizbaum ein wenig bereinigen Ich werde diese Knoten einfach
mit Control J gruppieren und
es Remove Duplicated Trunk nennen es Remove Duplicated Trunk Und wir können das
gesamte Setup auch in Branch System umbenennen. Jetzt können wir zu Modifier gehen und mit unseren Wurzeln
herumspielen. Also setze ich die Level auf etwas Kleineres und mache sie etwas länger und spiele auch mit den Winkeln
herum Wir können auch überprüfen, ob
unsere beiden Attribute,
nämlich Länge und Länge vom Ende, korrekt funktionieren. Also füge ich einfach ein benanntes
Attribut und eine Länge hinzu
und wir werden prüfen, wo es über einem bestimmten
Schwellenwert liegt, und ich werde diese
Attributtexte ausblenden. ich es also erhöhe, können
Sie sehen, dass es von diesem Punkt
hier aus
gut zu den Ästen und
auch zu den Wurzeln geht hier aus
gut zu den Ästen . Und wenn man den
anderen Parameter überprüft, nämlich die Länge
ab dem Ende, kann man sehen, dass er auch wirklich gut
funktioniert.
9. Verschiebung: Willkommen zurück zu drei D-Bäumen mit Blender-Geometrieknoten. In dieser Lektion werden wir
an der Verschiebung
unseres Kurvenaufbaus arbeiten an der Verschiebung
unseres Kurvenaufbaus und diesem Baum
ein etwas natürlicheres Aussehen verleihen . Das funktioniert also so,
dass
wir im Grunde einfach diese Kurven nehmen und sie
durch einige Rauschtexturen ersetzen Aber vorher
müssen wir
kontrollieren können, wie viel Geometrie
dieser Baum tatsächlich hat Wir werden es
mit dieser Resampling-Kurve steuern, aber wir geben dem Benutzer die Möglichkeit, zu
kontrollieren, wie viel Auflösung
wir tatsächlich haben Um das zu tun, ist es
eigentlich besser diesen Typ auf
Länge
umzustellen, weil das
bedeutet, dass er
diese Kurven an gleichmäßig
verteilten Punkten abtastet diese Kurven an gleichmäßig
verteilten Punkten und das nicht von
der Länge der Kurve abhängt Und wir können dieser Knotengruppe einen Perimeter
hinzufügen, was dann die Auflösung sein wird Fügen wir also eine neue
Ganzzahleingabe hinzu, die als Auflösung bezeichnet wird Und wir können den
Standardwert
beispielsweise auf zehn
und den Mindestwert auf eins setzen. Wenn wir die Gruppeneingabe aufrufen, können
wir
diese Auflösung nicht wirklich direkt in diese Resampling-Kurve weil diese
Ganzzahlwerte sehr hoch sind
und Sie sehen können, dass sie
nicht wirklich funktioniert Wir wollen hier ein paar kleinere
Werte. Aber für den Benutzer ist es besser, mit diesen Integer-Werten zu arbeiten. Um diese Länge zu berechnen, können
wir also den MF-Knoten verwenden und einfach eine
Konstante durch diese Auflösung teilen. Das heißt
, wenn wir diese Auflösung
erhöhen, wird diese Division kleiner oder das Ergebnis
wird kleiner, und die Geometrie wird mehr Punkte
haben. Wenn wir also zum Beispiel 0,5 verwenden, können
Sie sehen, dass jetzt, wenn die
Auflösung auf eins eingestellt ist, der Abstand zwischen
den Punkten 0,5 beträgt. Wenn wir es jedoch
beispielsweise auf zehn setzen, betragen die Schritte zwischen den
Punkten 0,05. Also werde ich es vorerst so
belassen, und wir können mit Noise-Texturen an der
Verschiebung arbeiten Dazu werden wir
einen einfachen
Set-Position-Knoten verwenden . Also lass uns das hinzufügen. Und wir werden diese
Offset-Eingabe verwenden, mit der Sie den Baum
in alle Richtungen verschieben
können. Wenn wir jetzt zum Beispiel eine
Rauschtextur hinzufügen, diese Farbe einen
dreidimensionalen Vektor mit den Werten 0-1 Wenn wir dies direkt
in den Offset einfügen, können
Sie bereits sehen, dass es eine Art Verschiebung
bewirkt Und wenn wir
mit der Waage herumspielen, können
Sie sehen, dass der
Baum jetzt viel schöner ist Das Problem ist, dass die Wurzel
des Baumes nicht bei 000 liegt, also das ist das erste Problem, und der ganze Baum bewegt sich
quasi in diese Richtung Das liegt alles an
dieser Farbe, die uns nur
positive Vektoren gibt, und wir wollen auch einige
negative Vektoren. Um das zu ändern, können wir einen Kartenbereich
verwenden und diesen Vektor neu zuordnen,
da die Farbe Vektor von 000111 bis hin zu
negativen Einsen
ist Das hat zur Folge
, dass uns dieser Vektor auch
einige negative Werte liefert Und wenn wir das mit Offset verbinden, können Sie
jetzt sehen, dass der
Baum fast mittig ist,
und das behebt sich können Sie
jetzt sehen, dass der
Baum fast mittig ist, ein wenig. Aber trotzdem ist der Mittelpunkt nicht
genau bei Null, Null, Null. Um das zu ändern, können
wir eines
der Attribute verwenden , die wir speichern, und das ist die Länge. Wenn wir uns die Länge ansehen, können
Sie sehen, dass
die Länge
hier in der Mitte
oder an der Wurzel Null ist hier in der Mitte
oder an der Wurzel und
zu den Ästen hin zunimmt. Wir können diesen Wert verwenden, um diesen Vektor zu
multiplizieren, was dazu führt, dass dieser Punkt
bei Null, Null, Null bleibt, denn wenn wir
den Vektor hier mit
Null multiplizieren , ist er Null. Und wenn wir uns
den Zweigen nähern, wird
es mit eins multipliziert Wenn wir also diese Länge nehmen und diesen Vektor
damit
multiplizieren, können wir dafür eine Skala verwenden Das wird zu so
etwas führen. Sie können sehen, dass die Zweige an den Enden wirklich verzerrt sind, aber dieser Vektor oder diese Rose, der Startpunkt, ist
immer noch bei Null, Null, Null Die Äste
sind hier sehr verschoben , weil die Länge viel höher
ist Und wir wollen, dass dieser
Multiplikator maximal eins ist. Dafür können wir also
eine Klammer verwenden, die
den Wert in einem bestimmten Bereich festlegt Wenn es also höher
als das Maximum ist, wird
es wieder auf das Maximum zurückgesetzt. Wenn wir diesen Wert also auf 0-1 klammern, können
Sie sehen, dass
das jetzt viel besser aussieht Wir können das auch visualisieren, und Sie können sehen, dass
dieser Clamp-Wert diese Vektoren
mit Null multipliziert Aber wenn es irgendwo hier ist, sind
sie bereits das Original und sie werden
mit eins multipliziert Das sieht jetzt also
relativ gut aus, und wir wollen kontrollieren
können, wie stark diese Punkte verzerrt sind Dazu können wir diesen eingegrenzten Wert
mit einer Konstanten multiplizieren . Lassen Sie uns also multiplizieren. Und stecken Sie es in die Waage. Wenn ich jetzt
mit diesem Wert herumspiele, können
Sie sehen, dass ich ändern
kann, wie stark das Rauschen auf die
Verschiebung der Punkte auswirkt. Der zweite Bereich
, den wir ebenfalls
kontrollieren können ,
ist das Ausmaß des Geräuschs Wenn Sie also mit dem
Geräusch herumspielen und es kleiner machen, können
Sie feststellen, dass der Baum eine
viel gleichmäßigere Verzerrung aufweist Und wenn wir es auf
etwas Höheres einstellen, können
Sie sehen, dass es sehr
hart und sehr detailliert ist Um die besten Ergebnisse zu erzielen, ist
es wirklich gut,
einige dieser
Geräuschtexturen miteinander zu kombinieren . Wir werden also zwei davon kombinieren, und wir werden
sie so verwenden wollen, dass die erste eine sehr geringe Skalierung
hat
und eine
Verschiebung wie diese erzeugt, sodass die Zweige sehr glatt sind, und dann
werden wir eine weitere
Rauschtextur anwenden, und dann
werden wir eine weitere
Rauschtextur anwenden die eine
viel höhere Skalierung hat , und diese harten Details
hinzufügen. Wir können das
Setup also noch einmal wiederverwenden und
diese Werte einfach zusammenfügen. Die Werte, die wir kontrollieren
wollen, sind dieser
Multiplikationswert und diese Skala Fügen wir also einige Gruppeneingaben hinzu. Ich drücke N und füge ein neues Panel hinzu, das ich Displacement
nenne. Und ich füge Eingaben für
diese erste Geräuschtextur hinzu. Die erste Eingabe wird also Noise Scale One und
Noise Power One sein. Und ich setze die Standardeinstellung
auf etwa 0,25 und die Leistung ebenfalls auf 0,25, wir können es hier ausprobieren, wie es
aussieht. Vielleicht ist das zu klein. Ich stelle die Stromversorgung auf eins. Und was die zweite Textur angeht
, die du verwenden wirst, können
wir sie einfach duplizieren
und ich benenne sie in Zweien um. Für diese verwende ich eine
Skala von, sagen wir, eins, und die Geräuschstärke zwei
wird einen Standardwert haben Aber zum Beispiel 0,25. Gehen wir nun zum
Modifikator und
setzen diese auch auf ihre
Standardwerte Und wir können diese
Eingänge mit diesem ersten Setup verbinden. Also rufe ich den Gruppeneingang auf
und verbinde diese Geräuschskala eins mit der Skala und die Geräuschstärke
eins mit dieser Multiplikation Ich möchte das Setup duplizieren, also wähle ich einfach diese
Knoten aus und drücke Strg G, und ich benenne
diese Eingaben einfach um Diese Skala ist großartig und die
zweite wird Power sein. Und wir können diese
Knotengruppe Branch Displacement nennen. Und weil wir
eine weitere Verschiebung hinzufügen wollen, werde
ich diese duplizieren und anderen Maßstab
und eine andere Leistung
verwenden. Um diese miteinander zu kombinieren, können
wir einfach diese Vektoren hinzufügen. Fügen wir also eine Addition hinzu und setzen diesen resultierenden
Vektor in den Offset ein. Wenn ich jetzt zu Modifier gehe, können
Sie sehen, dass wir
die Auswirkungen dieser
beiden Texturen kontrollieren können , und wir können einige sehr
interessante Ergebnisse erzielen Um sicherzustellen, dass diese
Rauschtexturen nicht identisch sind, können
wir diese Art von Rauschtextur auf
vier D ändern und diesen W-Perimeter verwenden,
was
in vier D ändern und diesen W-Perimeter verwenden, etwa CT ist Also stecke ich dieses W in den Gruppeneingang und verschiebe es
einfach nach oben Und jetzt verwende ich das Set außerhalb dieser
Knotengruppen. Und wieder werden wir
einige verschiedene Werte von
diesem Sitz mit mehreren Ed-Knoten erhalten . Fügen wir also multipliziere Anzeige hinzu. Also zuerst können
wir wieder ein paar Zufallswerte verwenden. Und ich werde diesen
ersten Wert auf dieses W anwenden und den zweiten
können Sie wirklich einfach ein
paar Zufallswerte verwenden und sie werden wahrscheinlich für jeden Sitz unterschiedliche
Werte haben. Sie werden das an das
zweite W anschließen. Wir können
diese ausblenden und auch neue
Schaltungen mit Control H verstecken. Wenn wir nun den Sitz wechseln, ändern sich auch die Sitze der Geräuschtexturen
. Um das Ganze zu beenden, können wir all diese Noten
auswählen
und das Displacement nennen. Auch diesen vorherigen Teil können
wir Auflösung nennen.
10. Gittergenerierung: Willkommen zurück zu drei D-Bäumen mit geometrischen Blender-Knoten. In dieser Lektion beginnen
wir mit
der Generierung des eigentlichen Netzes unseres Baums und fügen auch einige grundlegende UV-Maps hinzu. Gehen wir also zu den Geometri-Knoten. Und das Erste ist, dass
wir, um ein Netz aus Kurven zu erzeugen, um ein Netz aus Kurven zu erzeugen, einen Knoten von Kurve zu
Masche verwenden , sodass wir diesen Knoten hinzufügen können Und für das Profil werden wir vorerst
einen Kurvenkreis verwenden, weil
wir wollen, dass er kreisförmig ist. Wenn wir nun diese Kurve in Profilkurve einfügen und den Radius
verkleinern, können
Sie sehen, dass wir
nicht wirklich schöne, sondern ein
wirklich einfaches Netz
um unsere Kurvenstruktur herum haben . Vorerst können wir
diese Füllkappen auch überprüfen , damit
die Enden gefüllt sind. Und als Erstes
werden wir mit dem Radius
der Kurve herumspielen. Wenn wir einen festgelegten Kurvenradius hinzufügen, können
Sie sehen, dass
wir mit dieser Notiz den
Radius jedes Punktes kontrollieren können, und wir können
sie separat steuern, was sehr mächtig ist. Für unseren Baum wollen wir also, dass der Radius hier am Anfang zum Beispiel irgendwo um
eins liegt, und hier am Ende
wollen wir, dass er
irgendwo um Null liegt, sodass er abnimmt, je weiter er
geht oder sich
den Enden der Zweige nähert. Um diesen Wert zu erhalten, können
wir unser Längenattribut verwenden
, das wir erfassen. Wenn wir uns also unsere Länge vorstellen, können
Sie sehen, dass sie
hier Null ist und
zu den Enden der Zweige hin zunimmt. Das Problem dabei ist, dass
die Werte sehr hoch sind. Hier am Ende ist so
etwas wie 6,9, aber der ideale Wert
wäre nur eins, und dann können wir dieses Attribut einfach
umdrehen Also, um diese Länge
von Null auf 6,9
oder was der Wert ist, neu zuzuordnen von Null auf 6,9
oder was Wir können einfach die
maximale Länge
dieser Zweige nehmen und
die Länge durch diese teilen Wenn zum Beispiel
die maximale Länge an diesen Zweigen
sieben wäre , würde das zu diesem
Zeitpunkt
etwa 0,95 oder so
ähnlich sein , und genau danach
suchen wir Um also die maximale
Länge dieser Zweige zu ermitteln, können
wir Attributstatistiken verwenden Lassen Sie uns also eine Anmerkung zur
Attributstatistik hinzufügen. Und wir wollen Statistiken
dieser Länge. Lassen Sie uns also dieses
Längenattribut mit einem Attribut verbinden, und wir wollen
dieses Maximum verwenden Um diese Länge nun in
den Bereich Null bis Eins umzurechnen, können
wir
sie einfach durch dieses Maximum teilen. Und wenn wir uns das jetzt vorstellen, werden
Sie sehen, dass hier am
Ende etwa 0,99 ist, und hier am Anfang ist
es irgendwo um Null Das ist also genau das, wonach
wir suchen. Das einzige Problem ist jetzt , dass, wenn man sich die Wurzeln
anschaut, die Werte an den Enden
nicht wirklich eins sind, sondern 0,27 und so weiter Und das liegt daran, dass
die Zweige hier oben viel
länger sind als die Wurzeln Aber die Wurzeln nutzen auch
die maximale Länge
der Zweige. Also müssen wir
diese beiden Teile trennen und
diesen Faktor separat berechnen. Zu diesem Zweck werden wir
diese Berechnung in
das Filialsystem verlagern , wodurch
diese beiden Teile getrennt werden. Also lösche ich einfach
diese Knoten hier und gehe zum Zweigsystem, und wir können
diesen Faktor am Ende
der Wiederholungszone berechnen . Also hier in der Wiederholungszone, am Ende der Wiederholungszone, fügen
wir einen
Attribut-Statistikknoten hinzu und nehmen ein Längenattribut Und teile es einfach
durch das Maximum. Also das Gleiche
wie zuvor. Und hier können wir
diesen Wert einfach in einem anderen Attribut speichern . Also füge ich ein
benanntes Store-Attribut und nenne es zum Beispiel Längenfaktor und füge dieses
Ergebnis in dieses Attribut ein. Wenn wir nun zum Ende
unseres Setups zurückkehren und
diesen Längenfaktor visualisieren, können
Sie sehen, dass die
Zweige jetzt immer noch 0,99 haben, aber die Wurzeln auch
etwas um die 0,807 haben, und sie sind sehr nahe Also das ist nett. Und wenn wir jetzt
zum Beispiel dieses Attribut
an die Funkgeräte anschließen, werden
Sie feststellen, dass die
Zweige hier am Anfang dünn und an
den Enden
der Zweige dicker sind Anfang dünn und an
den Enden
der Zweige dicker Wir wollen das umdrehen und wir wollen die maximale Dicke am Anfang und die
minimale an den Enden Um das umzudrehen, können
wir einfach
den mathematischen Knoten nehmen und
diesen Wert von eins subtrahieren Also so etwas.
Jetzt können Sie sehen, dass die Zweige oder die Wurzel
hier am dicksten sind. Und wenn wir zum Ende gehen, werden
sie immer dünner Dann können Sie
den Gesamtradius auch mit dem
Radius des Kurvenkreises steuern , und es sieht ziemlich gut aus. Derzeit ist der
Rückgang linear. Wenn wir also hier ein Diagramm zeichnen, dann ist hier auf der Y-Achse der Radius und auf der X-Achse der Längenfaktor. Ich markiere es einfach so wie hier. Derzeit, wo der
Längenfaktor Null ist, ist
der Radius eins, und wo der Längenfaktor
eins ist, ist der Radius Null. Es sieht also ungefähr so aus. In einigen Fällen
möchten wir vielleicht, dass die
Äste früher am Baum dünner sind. Wir wollen also, dass die Kurve
ungefähr so aussieht. Andererseits wollen
wir, dass sie länger
dicker sind , je weiter wir bis zum Ende gehen. Also wollen wir, dass
es so aussieht. Um das zu kontrollieren,
könnten wir zum Beispiel
Float Curve verwenden, wo wir
genau so etwas machen können. Wenn wir also nach dieser eine
Float-Kurve hinzufügen, können
wir einfach
mit diesem Wert herumspielen. Jetzt können Sie sehen, dass, wenn ich
es unter die lineare Funktion stelle , Sie sehen können, dass die
Zweige dünner sind, und wenn ich es hier einfüge, sind
sie dicker. Das Problem dabei ist, dass
wir diese Float-Kurve
außerhalb dieser Knotengruppe
oder außerhalb dieses Modifikators nicht wirklich steuern außerhalb dieser Knotengruppe
oder außerhalb dieses Modifikators Wir müssen also einen
anderen Weg finden, dies zu tun. Wir werden das also
tun, indem wir Funktion X für das A
verwenden,
wobei X der Faktor oder unser
Längenfaktor und das A eine
Eingabevariable ist , die
vom Benutzer gesteuert werden
kann . Hier
ist es visualisiert. Wenn also das A oder der
Exponent auf eins gesetzt ist, ist
die Funktion linear Aber wenn ich es auf
etwas niedriger als eins setze, kannst
du sehen, dass die
Funktion eher so funktioniert, was bedeutet, dass die Zweige dicker
werden Und wenn es mehr als eins ist, kannst
du sehen, dass es unter die lineare Funktion fällt, was bedeutet, dass
sie dünner werden. Um das in Blender zu implementieren
, können
wir einfach
diesen Wert nehmen und
einen Bower verwenden und der Exponent
wird der Wert 0-2 sein Wenn wir ihn also auf eins setzen, können
Sie sehen, dass wir dieselben Ergebnisse haben wie mit
der linearen
Funktion Wenn ich es auf etwas kleiner als eins setze, sind sie dicker, und wenn es höher als eins ist, können
Sie sehen, dass
sie dünner sind.
11. UV-Mapping und Verfeinerung: Hallo und willkommen zurück zu Three D Trees with
Blender Geometry Rods Sie können sogar mehr als zwei verwenden, und Sie erhalten ein noch schöneres Gefälle Aber das ist bis zu, ich
werde den
Maximalwert wahrscheinlich auf etwa
drei setzen Maximalwert wahrscheinlich auf etwa und es so belassen Um einige Steuerelemente hinzuzufügen, öffne
ich das Site-Menü, und als Erstes
füge ich den Gesamtradius hinzu. Welches wird den
Radius dieses Kurvenkreises steuern. Ich setze den Standardwert auf 0,15 und der zweite Wert ist der
Radiusabfall
, also dieser Exponent Also füge ich eine neue Eingabe hinzu und
nenne sie Radius Fall Off. Den Untertyp setze
ich auf Schauspieler, weil er in einem kleinen Bereich sein
wird,
also kannst du ihn verwenden Setze Standard auf eins
und setze ihn auf 0-3. Um diese Gruppeneingänge zu verwenden, verbinde
ich sie einfach
über den Gruppeneingang Auch der Radius
zum Kurvenkreis. Wenn ich jetzt zum Modifikator gehe, können
Sie sehen, dass ich
jetzt
den Radius dieser Kurven
und ihren Abfall kontrollieren kann den Radius dieser Kurven
und ihren Abfall Wir könnten
diese Werte auch getrennt
für Zweige und Wurzeln festlegen diese Werte auch getrennt
für Zweige und Wurzeln Dann
wäre es am besten, diese Steuerelemente auch in das
Branch-System
zu integrieren, aber ich bleibe einfach bei dieser Version. Um das ein wenig
zu bereinigen, verschiebe
ich diesen Radius einfach
hierher und jetzt können wir
diese Gruppe von Knoten Radius nennen diese Gruppe von Knoten Radius weil wir hier den Radius
kontrollieren. Das nächste
, was wir noch nicht kontrollieren können, ist
diese Auflösung. Eine Möglichkeit wäre, einfach die Gruppeneingabe zu
bearbeiten, aber wir können es ein
bisschen intelligenter machen. Wir können einfach diese
Auflösungseingabe verwenden, die wir bereits haben, und einfach berechnen, wie viele Punkte der
Kurvenkreis haben sollte. Also für die Auflösung berechnen
wir hier. Und bei dieser Division erhalten
wir einen Versatz
zwischen zwei Punkten. Also dupliziere ich das einfach mit Shift D und Parent mit TP, sodass es nicht innerhalb des Frames ist und verschiebe es
einfach hier nach vorne. Und im Grunde sieht der
Kurvenkreis so aus
und wir wissen, welchen Radius er hat. Wir kennen also diesen R-Wert
und müssen berechnen, wie
viele Punkte er haben wird. Die Information, die wir auch kennen, ist der Abstand zwischen den
Punkten dieser Division. Wir wissen es also, ich werde
hier einfach ein paar Punkte
ziehen, ungefähr so. Und wir wissen, wie lang
diese Lücke sein sollte. Nennen wir es G als Lücke. Und um die Anzahl
der Punkte zu berechnen, die hier reinpassen, können
wir einfach verwenden
, dass die Länge
des Kreises das
Zweifache des Radius ist. Das ergibt uns
die gesamte Länge. Und wenn wir es durch diese Lücke teilen, sollten
wir die Anzahl der
Punkte erhalten , die wir schaffen müssen. Also lasst uns das berechnen. Ich werde diesen Radius
einfach so mit
zwei Pi multiplizieren so mit
zwei Pi und ihn dann einfach durch
diesen Lückenwert dividieren, der hier ist. Und wenn du das in
die Auflösung
einfügst, wirst du sehen, dass der
Wert, den wir erhalten, 17,6 ist Er wird automatisch gerundet, sodass wir diesen Wert nicht
runden müssen Und wenn wir uns jetzt
die Geometrie ansehen und zum Beispiel die Auflösung
verringern, können
Sie auch sehen, dass dadurch die Anzahl der
Punkte automatisch
verringert wird, sodass wir uns darüber keine Gedanken machen
müssen In Ordnung, der letzte Teil
wird also das Generieren der UVs sein. Um die UV-Map zu generieren, benötigen
wir zwei Variablen Eine von ihnen wird zu
den Enden der Zweige hin
zunehmen, und die zweite
muss um die Zweige herum
verlaufen Dadurch werden
unsere Texturkoordinaten generiert. Also zuerst können
wir für dieses Attribut einfach unser
Längenattribut verwenden ,
weil wir es
bereits berechnet haben und es
korrekt berechnet sein sollte. Also können wir einfach dieses verwenden. Und für die zweite Achse können
wir einen Faktor
dieser Kurve verwenden , den
Sie für das Profil verwenden. Wenn Sie sich also diesen Kreis ansehen
und einen einfachen Umfang verwenden, der den Faktor beinhaltet
, können
Sie sehen, dass sich
dieser Faktor 0-1 um den Kreis bewegt, und wir können diesen
Wert für die UV-Strahlung verwenden Wir müssen
dieses Attribut also
mit erfassen , bevor wir das Netz
generieren Fügen wir also das Capture-Attribut hinzu, und wir werden
diesen Faktor für jeden Punkt erfassen wollen. Und jetzt, nach dem Mesh, müssen
wir die UVs erstellen Fügen wir also ein
benanntes Store-Attribut hinzu. Die UVs sind vom Typ
Vektor und sie werden für jede Phasenecke
gespeichert,
also legen wir es so Der Name wird UV-Map lauten. Und der Wert wird ein Vektor sein. Also lass uns XYZ kombinieren. Und für den X-Wert
können wir diesen Faktor verwenden, und für den Y-Wert verwenden
wir diese Länge Wenn wir uns
das jetzt vorstellen, können Sie sehen , dass wir schöne
UVs für den Baum haben Und das einzige Problem ist, wenn
du dir diesen Teil hier ansiehst, kannst
du sehen, dass hier Null ist und hier ist es eins und
es geht herum Aber dann gibt es einen schnellen
Übergang zurück auf Null. Um das zu vermeiden, müssen wir
das ein wenig anders machen. Das Problem, mit dem wir konfrontiert
sind, ist, dass wir,
wenn wir den
Kreisfaktor visualisieren einfach diesen verwenden können
und ich den lösche. Sie können sehen, dass der
Wert am Startpunkt Null ist. Und was den letzten Punkt angeht, ist es
ungefähr 0,9 kostenlos, und dann
geht es schnell gegen Null. Was wir brauchen würden, ist,
dass wir hier
auch eins aus dieser Richtung haben auch eins aus dieser Richtung und hier Null aus
dieser Richtung. Um das zu erreichen, können
wir statt
eines Kurvenkreises eine Spirale verwenden, was keine geschlossene Kurve ist, sondern
an dieser Position zwei Punkte hat. Fügen wir also eine Kurvenspirale hinzu. Lassen Sie uns unsere berechneten Werte verwenden. Für die Auflösung verwenden
wir also denselben Wert. Rotationen, wir wollen nur eine Umdrehung, also setzen
wir sie auf eins Start- und Endradius
werden derselbe sein. Also setzen wir den Radius so
in beide und wir wollen nicht, dass
ich
das einfach visualisiere. Wir wollen nicht, dass die
Kurve eine Höhe hat, also setzen wir die Höhe auf Null. Jetzt können Sie sehen, dass diese Kurve an diesem Punkt
tatsächlich Eins und
Null hat. Es gibt tatsächlich zwei Punkte
und sie überlappen sich. Und wenn wir diese Spirale
anstelle des Kurvenkreises verwenden, sollten
wir viel
bessere Ergebnisse erzielen Jetzt können Sie sehen, dass es
hier an dieser Naht einen harten Übergang
gibt, einen harten Übergang
gibt, was bedeutet, dass die
UV-Maps korrekt sind. Also lösche ich einfach
diesen Kurvenkreis. Aber jetzt haben wir
ein anderes Problem und dass es hier an dieser Stelle Überschneidungen
gibt. Wir können überprüfen, ob es 35.000 Scheitelpunkte
gibt, wenn
wir mit der Maus über diese Ausgabe 35.000 Scheitelpunkte
gibt Und wenn wir „Nach
Entfernung zusammengeführt“ verwenden , gibt es jetzt
nur Es gibt also viele überlappende Scheitelpunkte, die wir Wenn wir uns jetzt die UV-Map
mit dem Viewer ansehen, können
Sie wieder sehen, dass wir diesen harten Übergang
haben, wir hier nicht wollen
, oder
diesen schnellen Übergang Und um das Problem zu beheben, werden wir
dieses Attribut mit dem Nachnamen ersetzen , indem wir
nur diesen Vektor erfassen Also werde ich das entfernen und ein Capture-Attribut
hinzufügen. Wir wollen diesen Vektor erfassen
, der unsere UV-Map speichert, und das Wichtigste
ist, eine Gesichtsecke zu verwenden. Wenn wir nun
diese UV-Map nach der
Zusammenführung nach Entfernung visualisieren , können
Sie sehen, dass
sie jetzt korrekt funktioniert, und weil sie nach
der Zusammenführung nach Entfernung erfolgt, sind
die überlappenden Punkte verschwunden Um das Ganze zu beenden, speichern wir dieses Attribut für die
Gesichtsecke und nennen es UV-Map verbinden wir dieses
erfasste Attribut einfach damit Jetzt sind unsere UV-Maps
fertig und wir können all diese Notizen
auswählen und sie zum Beispiel
einfach Mesh plus
UVs nennen Um nun zu überprüfen, ob es
mit einigen Materialien funktioniert, können
wir unsere Materialien verwenden, die ihr
zum freien Diskurs erhalten werdet Um diese Materialien an die Mischdatei
anzuhängen, können
wir zu Anhängen gehen und die Datei mit
den Materialien
suchen, die Datei mit
den Materialien
suchen, und dort sollte Material sein, es gibt zwei
Materialien für Es gibt Eichenrinde
und Secura-Rinde, also können wir beide hinzufügen. Und wenn wir jetzt
festgelegtes Material hinzufügen und wenn wir
eines dieser Materialien einsetzen, können
Sie sehen, dass wir
schöne Materialien in unserem Baum haben Um das Ganze abzurunden, werden wir
unseren Gruppeneingaben auch
Material hinzufügen . Lassen Sie uns also auf
das Seitenmenü klicken und ich füge eine neue Eingabe hinzu, die ich Material nenne
und zwei Materialien eintippe. Und wir werden
dieses Material einfach für
Gruppenbeiträge für unsere Filialen verwenden . Eine weitere Sache, die
Sie vielleicht
kontrollieren möchten, ist der Maßstab
dieser UV-Maps. Und wir können das einfach tun,
indem wir diesen Vektor
hier skalieren, bevor wir ihn speichern. Wenn wir also eine Skala hinzufügen und damit herumspielen, können
Sie sehen, dass
die Texturen eine höhere
Auflösung haben oder kleiner sind,
wenn ich sie erhöhe, und
das können Sie auch steuern. Also füge ich einfach eine weitere Eingabe hinzu, nämlich die UV-Skala, setze den Standardwert auf eins
und das Minimum auf Null und füge diese
UV-Skala einfach in die Skala ein. Wenn wir es jetzt auf eins setzen, können
Sie sehen, dass wir
die
Skalierung unseres Materials gut kontrollieren und sehr einfach
ändern können.
12. Grundlagen der Blattverteilung: Willkommen zurück zu drei D-Bäumen mit Blender-Geometrieknoten. In dieser Lektion
beginnen wir damit, Blätter zu
unserem Baum hinzuzufügen , und fügen drei verschiedene Optionen hinzu
, um sie zu verteilen. Die drei Arten
der Verteilung
der Sprünge, die wir
implementieren werden, wurden also der Sprünge, die wir
implementieren werden bereits
in einer der ersten Lektionen erklärt , aber ich werde
sie kurz noch einmal durchgehen Die erste Methode wird also Blätter an
allen unseren Zweigen
verteilen, sodass sie überall
hier auf den Zweigen zu finden sein werden Der zweite Typ
wird vom Ende her sein, was bedeutet, dass
wir einfach
diese Zweige nehmen und einen Schwellenwert verwenden um zu kontrollieren, wie weit
die Blätter
noch von den Enden entfernt sein werden. Diese Option liefert meiner
Meinung nach die besten Ergebnisse, und die letzte Option
wird durch
die minimale Z-Achse
oder Z-Position gesteuert . Wir werden also einen Schwellenwert festlegen und Blätter nur an
den Zweigen oder an den Punkten verteilen den Zweigen oder an den Punkten , die über
diesem Schwellenwert liegen. Zunächst
benötigen wir einige Blätter, auf denen du unser Setup
testen wirst findest
du in der Datei , die du
kostenlos bei Discours bekommst Ich gehe zur Datei, füge sie an, in der Datei mit den Objekten gehe ich zur Sammlung, und es gibt nur wenige Sammlungen, und ich werde sie alle
mit Ausnahme dieser Sammlung aufnehmen .
Den brauchen wir nicht Und wenn wir auf Anhängen klicken können
Sie sehen, dass dadurch
eine Reihe von Objekten zu unserer Szene hinzugefügt werden, und sie sind
in diesen Sammlungen gut organisiert Es gibt zwei Hauptsammlungen für Eiche und Sacarabaum Für jedes von ihnen
gibt es verschiedene Blätter. Für Eiche
gibt es also drei Arten von Blättern und auch das Material
, das wir in der
vorherigen Lektion verwendet haben. Und für die Sacara
gibt es zwei Arten von Blättern. Es gibt blühende
und keine blühenden. Und das letzte
sind Blütenblätter, die wir später zum Beispiel
für das
Partikelsystem verwenden können zum Beispiel
für das
Partikelsystem Vorerst werde ich
diese beiden Sammlungen einfach verstecken und anfangen, ein paar Blätter zu verteilen. Gehen wir zu den Geometrieknoten. Und die Art und Weise, wie wir zwischen
diesen drei Typen wählen werden , die erklärt werden, erfolgt über das Menü. Lassen Sie uns also ein Seiten-Panel öffnen und zuerst ein neues Panel hinzufügen, das ich Blätter nenne. Und um zwischen diesen
drei verschiedenen Typen zu wählen, ich die Eingabe aus, welche Art von Menü haben
wird. Ich nenne es wo
, weil es
kontrolliert , wo die
Blätter laichen Und wenn wir jetzt zu Modifier gehen, können
Sie sehen, dass dieses Dropdown
keine Optionen hat Um Optionen hinzuzufügen,
müssen wir
diese Gruppeneingabe mit einer
Art Menüknoten verbinden diese Gruppeneingabe mit einer
Art Menüknoten Dazu können wir einen Menüschalter
hinzufügen, bei
dem es sich im Grunde um
einen Knoten handelt, in dem
Sie eine Reihe von
Optionen hinzufügen und diese
dann mit diesem Menüanschluss steuern können. Also werde ich einfach
diesen Ware-Eingang mit
diesem Menüschalter verbinden diesen Ware-Eingang mit
diesem Menüschalter Und um diese Optionen zu bearbeiten, klicken
wir auf diesen
Menüschalter und gehen zu Node Tap. Und hier können wir
alle Optionen bearbeiten. Die erste Option
werden also Zweige sein. Die zweite ist vom Ende aus, und die dritte ist Min Z für die
minimale Z-Position. Jetzt kann dieser Menüschalter zwischen diesen drei
Geometrieeingaben umschalten. Und wir werden das so machen,
dass wir für jeden Typ eine Kurve
erstellen, auf wir
die Blätter
verteilen wollen, und dann
verwenden wir einfach diese Ausgabe, die mit
dieser Ware ausgewählt wird , und verteilen die
Blätter auf dieser Kurve. Das können wir auch im Modifikator überprüfen, jetzt haben wir diese drei Optionen Wir können jeden von ihnen auswählen, und es sollte
eine dieser Eingaben auswählen Um die Basiskurven zu erstellen, werden
wir also die
Kurven unseres Baumes verwenden, und ich werde diese
nach dem Radius verwenden, weil wir diese
Radiusinformationen
später benötigen , wenn wir
die Blätter verteilen. Nehmen wir also diese Kurven, und die erste Option, die wir hier
haben, sind die Zweige. Das bedeutet, dass wir nur
Kurven wollen, die Zweige sind, und wir müssen
alle anderen löschen. Fügen wir also die gelöschte
Geometrie hinzu. Und um nun
herauszufinden, welche Kurven Verzweigungen
sind und welche nicht, können
wir zum Beispiel das
Längenattribut verwenden, das wir hier haben, und wenn die Länge
größer als die Länge des Stammes ist , weil
die Länge des Stammes
nur am Stamm ist, und dann sind die Längen höher. Wenn also die Länge höher
als die Stammlänge ist, sollten
wir nur die
Äste ermitteln. Brauche das Gegenteil. Wenn wir also alle
Punkte löschen, an denen die Länge
geringer als die Stammhöhe ist , sollten
wir die Zweige erhalten. Lassen Sie uns also das benannte
Attribut Länge ermitteln. Und wenn es weniger
als die Stammhöhe ist, können
wir uns das auch vorstellen, und Sie können sehen, dass all diese Äste unter
dem Stamm weiß sind. Aber das Problem ist, dass einige der Wurzeln
hier nicht gepflückt wurden. Das liegt daran, dass ihre Länge länger als die Stammhöhe
ist und wir keine
Blätter an den Wurzeln haben wollen. Um das Problem zu beheben, können wir auch
hier an diesem Aststamm Informationen speichern, Informationen speichern ob es sich bei den Kurven um Wurzeln
handelt oder nicht. Dazu füge ich den
benannten Attributsatz vom Typ 2 Bolin hinzu und nenne ihn Roots Und für die Besten
sind das meine Filialen. Also werde ich es auf Stürze einstellen. Und für die untersten
, bei denen es sich tatsächlich um Wurzeln handelt, setze
ich sie auf wahr. Wenn wir nun zu diesem Ende übergehen, werden
wir im Grunde genommen wählen, wo
die Länge kleiner als die
Stammhöhe ist oder
ob es sich um Wurzeln handelt. Also werden wir bei benannten
Attributwurzeln vorgehen. Und wenn das stimmt, wollen wir sie
auch löschen, und das sollte
uns eine bessere Auswahl geben. Jetzt können Sie sehen, dass
all diese Wurzeln,
einschließlich des Stammes, weiß sind, was bedeutet, dass alle diese Teile
gelöscht werden. Wenn wir uns das jetzt vorstellen, können
Sie sehen, dass wir nur diese Zweige
haben. Das heißt, wir haben
die erste Option erledigt und können
sie in Zweige einbinden. Und wenn wir das jetzt ausgeben, haben wir
jetzt Zweige ausgewählt,
also haben wir Zweige. Aber wenn wir etwas
anderes auswählen, sind sie leer. Also lass uns die auch machen. Für die Option From End werden
wir wieder die DD-Geometrie verwenden. Und wir möchten
alle Punkte löschen,
bei denen die Länge vom Ende aus
größer als ein bestimmter Schwellenwert ist. Dazu müssen wir also diese Schwellenwerteingabe
hinzufügen. Also füge ich dieser Gruppe neue Eingaben
hinzu und nenne sie Length From End. Und ich setze
den Standardwert zum Beispiel auf eins und setze ihn auch hier zurück. Und wenn wir nun die Länge des
benannten
Attributs vom Ende nehmen, wollen
wir alle Punkte, an denen die
Länge vom Ende
größer als diese Länge
vom Ende ist, aus der Gruppeneingabe löschen Punkte, an denen die
Länge vom Ende
größer als diese Länge
vom Ende ist , oder wenn es Wurzeln gibt. Auch hier werden wir das oder
den Wert oder das mit Wurzeln hinzufügen. Und wenn wir uns das jetzt ansehen, können
Sie sehen, dass wir nur die Enden der Zweige
haben, und wir können es mit
diesem Gruppeneingabe-Perimeter kontrollieren Damit ist auch dieser Teil erledigt. Und jetzt
ist der letzte Teil die minimale Z-Achse. Für diesen benötigen wir also
auch einen Perimeter. Fügen wir also eine neue Eingabe hinzu
und nennen sie Min Z. Und wieder
verwenden wir „Geometrie löschen und löschen alle Punkte, deren
Position auf
der Punkte, deren
Position auf
der Z-Achse unter diesem Schwellenwert liegt Also werden wir Position beziehen. Wir erhalten nur die
Z-Position, wenn wir XYZ trennen, und wenn diese kleiner als
die Z-Haupteingabe sind ,
werden wir sie löschen Es wird also so aussehen. Und wir können diese dritte
Option an diesen Menüschalter anschließen. Wenn wir nun
mit diesen Optionen herumspielen, sollten
wir diese
drei Arten von
Kurven erhalten , auf denen wir die Blätter
verteilen werden. Außerdem noch ein kleiner Tipp, falls Sie
einige hintere Strecken wie diese
untereinander haben einige hintere Strecken wie diese
untereinander und
diese ausrichten möchten, können
Sie sie einfach auswählen und X auf X-Achse skalieren
und auf Null
drücken ,
damit sie auf der X-Achse auf einer Linie ausgerichtet werden . Wir können diese
Knoten auch mit Control J gruppieren, und ich nenne das Blattkurven.
13. Erweiterte Blattplatzierung: Hallo und willkommen zurück zu den kostenlosen D-Bäumen mit
Blender-Geometrieknoten. Und jetzt fangen wir an,
einige Blätter auf diesen Kurven zu erzeugen . Um die Blätter zu erstellen, verwenden
wir also die
Instanz für Punkte. Aber zuerst müssen wir die Punkte
entlang dieser Kurven
verteilen. Die beste Methode,
Punkte zufällig
auf Kurven zu verteilen , besteht darin
, einfach eine Reihe
von Punkten zu erstellen und
dann eine Kurve
mit einem Zufallsfaktor
abzutasten . Dadurch werden sie gut
verteilt. Lassen Sie uns also zunächst einige Punkte hinzufügen. Ich werde zum Beispiel vorerst
200 davon hinzufügen . Und als Ablagerung
verwenden wir eine Beispielkurve. Also werden wir
diese Kurven abtasten. Wir wollen sie alle abtasten,
damit wir alle Kurven überprüfen können, und jetzt können wir nur diesen Faktor
kontrollieren. Wir möchten, dass dieser
Faktor für jeden Punkt randomisiert wird. Fügen wir also den Zufallswert
0-1 hinzu und setzen ihn in den Faktor ein. Und wenn Sie nun diese
Position mit diesen Punkten verbinden, werden
Sie feststellen, dass
die Punkte nur
auf die Zweige verteilt
werden sollten nur
auf die Zweige verteilt
werden Sie können sehen, dass sie
sich ändern,
je nachdem , wie wir diese Kurven festlegen. Aber das Problem ist jetzt
, dass wir nicht wirklich wissen, wie viele Punkte
wir wollen, weil die Teile
manchmal sehr klein sind und wir nicht
viele Blätter an einer Stelle haben wollen. Und manchmal gibt
es lange Kurven, und wir wollen keine großen
Lücken dazwischen, und wir wollen hier
eine schöne Anzahl von Punkten. Um eine große
Anzahl von Punkten zu berechnen, können
wir einfach die Gesamtlänge all
dieser Kurven mit der Kurvenlänge berechnen. Dieser Knoten gibt uns also die Gesamtlänge
all dieser Kurven. Und wenn wir nun
eine neue Eingabe hinzufügen , die wir zum Beispiel
Dichte nennen
können, können wir einfach diese Länge
nehmen und sie
mit der Dichte multiplizieren. Das wird dazu führen, dass unabhängig davon,
wie lang die Kurven sind, die
Dichte der Blätter immer ähnlich ist. Wenn die Länge also
etwas kleiner ist, gibt es nur ein paar Punkte, und wenn diese etwas höher ist, die Länge,
wird es viele Punkte geben. Wenn wir dieses
Multiplikat einsetzen, um jetzt zu zählen und die Dichte auf zehn setzen, können
Sie sehen, dass es viele Punkte
gibt. Aber wenn wir abnehmen oder ich es auf vom Ende setze,
kannst du sehen, dass die Punkte
immer relativ
gut verteilt sind . Ordnung. Jetzt
sind unsere Punkte gut verteilt. Wir können das auch gruppieren und
es Punkteverteilung nennen ,
tut mir leid, Blattpunkte. Und jetzt können wir endlich ein paar Blätter an diesen Punkten platzieren. Auf diese Weise werden wir eine Instanz für Punkte
hinzufügen. Für die Punkte werden wir
die Punkte verwenden , die
wir verteilt haben. Und für die Instanzen werden
wir einige
der Sammlungen verwenden wollen , die
wir aus der Datei angehängt Dazu werden wir eine neue Eingabe
hinzufügen, in der wir
die Sammlung hinzufügen werden Lassen Sie uns also eine Sammlung hinzufügen und eine Sammlung vom Typ zwei
festlegen. Ich werde es
auch in das Panel verschieben. Und stellen Sie hier einige Werte ein. Also
pflücke ich zum Beispiel die Sakura-Blätter Und um diese
Blätter aus der Sammlung zu verteilen, können
wir einfach die
Sammlungsinformationen herausnehmen Für die Eingabe werden wir die
Erfassung unserer Gruppeneingaben verwenden. Wir wollen Kinder trennen
und neu einrichten. Und wir können diese
Instanzen mit den Punkten verbinden. Sie können sehen, dass jetzt alle Blätter in
dieselbe Richtung zeigen und dass sich auch alle
Blätter an jedem Punkt befinden. Also wollen wir nur einen auswählen. Dadurch können wir diese Pi-Instanz
überprüfen. Und wir wollen
diese Blätter auch ein wenig drehen. Der einfachste Weg
wäre also, einfach einen
Zufallswert oder
einen Zufallsvektor von 0-2 Pi zu erzeugen Zufallswert oder
einen Zufallsvektor von 0-2 Pi Und wenn wir es in Rotation versetzen, haben
wir ein paar relativ
schöne Blätter Wenn wir das jetzt
mit unserer Astgeometrie kombinieren, können
Sie sehen, dass es mehrere Probleme geben
kann. Ich stelle für die Dichte
einen kleineren Wert ein, damit es ein bisschen
besser sichtbar ist. Außerdem
setze ich den Radius auf
etwas unter eins Das ist wahrscheinlich nicht der Baum
, den Sie erstellen möchten, aber ich möchte
Ihnen ein kleines Problem zeigen das wir haben, oder? In dieser
Kurve hier gibt es zum Beispiel eine Kurve, und wir instanzieren die Punkte direkt
auf diesen Kurven Das Problem ist, dass
sich das Netz nicht auf diesen Kurven befindet, sondern um sie herum,
weil wir
eine Spirale oder Kurve verwenden , um
ein Profil um sie herum zu erstellen, und wir möchten, dass die Blätter
auf diesem Netz wachsen und
nicht auf den Kurven Um das Problem zu beheben,
müssen wir diesen
Punkt also um den
Radius dieser Kurve verschieben. Die Blätter wachsen also tatsächlich an der Oberfläche und nicht an
der Innenseite des Netzes. Um das zu tun, werden wir, bevor Punkte
Blätter auf den Punkten instanziieren, auch die Position
dieser Punkte festlegen, und wir müssen den
Radius dieser Kurve
im verteilten Punkt nehmen Radius dieser Kurve
im verteilten Punkt Das wird also der Wert sein
, den wir auch abtasten werden. Also füge ich den Radius hinzu. Und jetzt ist dieser Wert der
Radius an einem bestimmten Punkt. Und wenn wir uns diese Zeichnung
ansehen, jede Kurve einige Vektoren. Eine davon ist die Kurventangente, die in
Richtung der Kurve verläuft,
und die zweite
ist die Kurventangente, also die Richtung senkrecht
zur Kurventangente Wenn wir also diese Kurve
normal nehmen und
sie nach dem Radius skalieren, sollten
wir einen richtigen
Offset für die Punkte erhalten Wenn du also diesen
Punkt in den Offset einfügst, wird das Wichtige auch mit dem Gesamtradius
der Verzweigung
multipliziert dem Gesamtradius
der Verzweigung
multipliziert Multiplizieren wir ihn also mit dem
Radius aus der Gruppeneingabe. Und jetzt
ist das Blatt , man kann sehen, dass es sich auf
der Oberfläche des Netzes befindet. Es zeigt nicht in
die richtige Richtung. Es sollte
ungefähr so sein. Wir sind fast da. Um dies noch weiter zu
randomisieren, nehmen
wir den Normalenvektor und drehen ihn um einen zufälligen Wert Wenn wir uns das vorstellen, haben
wir die Verzweigung und sie hat eine Kurventangente
und auch die Kurve In diese Richtung verschieben wir
die Blätter, aber jetzt würde das bewirken dass alle Punkte in dieselbe Richtung versetzt
wären Aber wir wollen das nach dem Zufallsprinzip anordnen, sodass einige von ihnen in dieser, andere in dieser
und dieser Um das zu randomisieren, können
wir diesen Normalvektor, den wir anhand
des Radius skaliert haben, nehmen und eine
Vektordrehung oder Vektordrehung verwenden Mittelpunkt ist 00, Null, und die Achse wird die Tangente sein ,
weil das die Achse ist,
um die wir uns drehen Und für den Winkel können wir
einfach einen zufälligen Wert wählen. Also füge ich einen zufälligen Wert hinzu
und setze ihn auf 022 Pi. Und wenn Sie diesen
resultierenden Vektor in den Offset einbauen, sollten
die Punkte noch zufälliger
verteilt werden Jetzt werde ich
diese Mathematik ein bisschen bereinigen. Also so etwas. Und wir sollten den Seed auch immer mit
unseren Zufallswerten verbinden. Also verbinde ich den Startwert
von der Gruppeneingabe diesem Zufallswert und auch den
Startwert mit diesem Zufallswert. Wenn wir nun den Radiusfluss
wieder auf einen
vernünftigeren Wert setzen und die Dichte
auf etwa zehn setzen, können
Sie sehen, dass wir eine sehr
schöne Verteilung der Blätter haben . Wir können auch sehr einfach zwischen
verschiedenen Blättern wechseln sehr einfach zwischen
verschiedenen Blättern weil es diese Sammlung gibt, und alles funktioniert gut. Eine letzte Option oder ein letzter
Umkreis, den wir
hinzufügen möchten, ist, dass wir die Größe
dieser Blätter kontrollieren können wollen Fügen wir also zwei weitere Eingaben hinzu. Eine davon wird skaliert, standardmäßig auf eins gesetzt, und die zweite ist die Skalierung nach dem Zufallsprinzip. Die Skala wird einfach
hier
gesteuert , wo wir
Blätter an den Punkten instanziieren Und wir werden das so
generieren,
dass wir einfach einen Zufallswert erstellen und Gruppeneingaben verwenden, und das Minimum
dieses Zufallswerts Skala minus Zufälligkeit, und das Maximum ist
Skala plus Sie können also einfach
diese beiden Werte mit dem Zufallswert und auch mit dem
Startwert Und wenn Sie nun
diesen Zufallswert in die Skala eingeben und ihn
auf Standardwerte setzen, können
Sie sehen, dass wir auch hier einige
Variationen haben. Wenn wir auch alle drei
Arten von Blättern überprüfen,
also Zweige, dann
sind die Blätter überall auf den Zweigen. Vom Ende aus können wir
kontrollieren, wie weit die Blätter von den
Enden der Zweige sind, und wir können auch die Mindestanzahl von Xs
kontrollieren, was
bei einigen Baumarten nützlich sein kann. Alles ist prozedural, also können
wir
mit dem Samen herumspielen, und wir erhalten immer einen
ganz anderen Baum.
14. Grundlegendes Partikelsystem: Willkommen zurück zu kostenlosen D-Bäumen
mit Blender-Geometrieknoten. Wir werden unserem Baum noch ein
Detail hinzufügen, und es wird ein sehr einfaches
Partikelsystem sein, fallende
Blätter von unseren Zweigen simuliert. In diesem Fall
werden wir wieder Objekte aus
dem kostenlosen Assetback verwenden , das Sie in diesem Kurs kostenlos
erhalten diesem Kurs kostenlos
erhalten In diesem Fall verwende ich
diese kleinen Secura-Blätter, die sich perfekt
für diese Verwendung Wie das also
tatsächlich funktionieren wird, werden
wir zunächst Simulationszonen
innerhalb der Geometrieknoten verwenden, die es uns ermöglichen,
diese fallenden Blätter und
irgendeine Art von Physik zu simulieren diese fallenden Blätter und
irgendeine Art von Als Erstes
müssen wir also einige Punkte
zu unserer Geometrie hinzufügen Wir werden also eine
ähnliche Technik verwenden , die wir beim
Verteilen von Blättern verwendet haben. Wir werden dieselben Kurven verwenden, aber wir werden nur einige einfache Punkte
auf ihnen platzieren, so wie hier. Und dann werden
wir sie in der
Simulationszone jedes Frames ein wenig nach unten bewegen, sodass es aussieht, als würden
sie fallen, und es wird
auch etwas Rauschen hinzugefügt,
sodass es nicht nur
gerade fallende Blätter sind es wird
auch etwas Rauschen hinzugefügt, , sondern sie werden eine Bewegung
oder so etwas Ähnliches haben. Gehen wir also zu den Geometrieknoten, und ich werde
die Punkte hier unten
unter der Blattstruktur hinzufügen . Das Wichtigste ist, dass kleine Partikel aus
Blättern fallen , für die wir bereits die Kurven haben
, auf denen sie entstehen. Also werden wir diese Kurven wiederverwenden und einige
Punkte darauf verteilen. Wir werden also die Ausgabe
dieses Menüschalters verwenden
, der durch
dieses Attribut ausgewählt wird, und wir werden
ähnliche Techniken verwenden wie bei den Blättern. Also fügen wir eine einfache Kurve hinzu
und wir nehmen
Zufallskurven daraus und weisen diese Positionen
einfach neuen Punkten zu Vorerst füge ich einen Punkteknoten hinzu
und nehmen wir an, wir wollen vier Punkte pro Frame
hinzufügen, also setze ich die Anzahl auf vier Und jetzt müssen wir
alle Kurven überprüfen , weil wir all diese Kurven abtasten
wollen, und der Faktor wird ein Zufallswert
sein. Fügen wir also einen Zufallswert
0-1 hinzu und setzen ihn in den Faktor ein. Wenn wir nun die Position in den Punkteknoten einfügen
und dies visualisieren, werden
Sie sehen, dass wir hier einige Punkte
haben, und wir können den Sitz
mit dem Sitzattribut ändern Um den Sturz zu simulieren, benötigen
wir die
Simulationszone. Fügen wir also eine Simulationszone hinzu. Und das ist der Wiederholungszone sehr
ähnlich. Es hat also einige Geometrieeingaben. Dann macht es einige Dinge
zwischen diesen beiden Knoten. In diesem Fall wird das für jeden Frame
gemacht, und dann ist da noch diese
Ausgabegeometrie. Bei jedem Frame wollen
wir also vier neue
Blätter zu unseren Fallpunkten hinzufügen, und das tun wir, indem wir
diese vier Punkte mit der vorhandenen Geometrie verbinden . Fügen wir also Verbindungsgeometrie hinzu, und wir werden
diese vier Punkte verbinden. Wenn wir nun diese
Simulationszone ausgeben und die Animation
abspielen, können
Sie sehen, dass wir immer noch nur
diese vier Punkte haben. Das liegt daran, dass in jedem Frame dieselben vier
Punkte hinzugefügt werden und sie sich gegenseitig
überlappen Wenn ich diese Ausgabe übertreibe, müssten
wir sehen, dass wir jetzt
404 Punkte haben , weil
wir uns bei Frame 101 befinden Um sie
variabel zu machen, müssen wir den Sitz
steuern und ihn für jeden Rahmen
anders einstellen. Dabei können wir die Szenenzeit verwenden, die uns den
aktuellen Frame gibt. Und wenn wir diesen Frame in
den Sitz stecken und
die Animation zurücksetzen, sollten
wir sehen, dass in jedem Frame neue Punkte
erscheinen. Sie erzeugen allmählich
die Form der ursprünglichen Kurven. Jetzt möchten Sie vielleicht für jeden Frame
eine andere Anzahl von
Punkten hinzufügen . Dafür könnten wir also
einen Zufallswert verwenden und ihn einfach
in die Zählung einbauen. Aber Sie können sehen,
dass das nicht möglich ist weil die Ausgabe dieses
Zufallswerts ein Feld ist, aber diese Punkte benötigen
einen konstanten Wert. Um das zu umgehen,
müssen wir herausfinden
, wie man zufällige
Punkte auf jedem Frame
verteilt oder erzeugt. Das können wir tun, indem anstelle der
Punkteknoten, die nur Punkte an einer
bestimmten Position erzeugen nur Punkte an einer
bestimmten Position erzeugen, zum Beispiel Verteilungspunkte auf
Flächen
verwenden, Verteilungspunkte auf
Flächen
verwenden wo wir dem Objekt eine Art Netz geben
, und es werden Punkte
je nach Dichte und Sitz generiert . Und das wird zu einer
unterschiedlichen Anzahl von
Punkten für jeden Sitz führen . Wir brauchen also auch ein Eingabenetz. Dafür können wir also
jedes beliebige Mesh verwenden. Ich benutze einfach Grid. Und wenn wir uns das
jetzt vorstellen, können
Sie sehen, dass wir das Raster
haben, und es gibt einige
generierte Punkte, und auf jedem Sitz generiert
es eine unterschiedliche
Anzahl von Punkten. Wenn es zum Beispiel
um die Dichte zu eins geht, können
Sie sehen, dass
es manchmal zwei Punkte gibt, manchmal nur einen und
manchmal Null Punkte. Das ist also ziemlich gut. Ein weiteres Problem, mit dem
wir konfrontiert sein könnten
, ist , dass dies nicht von der Länge
dieser Quellkurven
abhängt , was bedeutet, dass
wir, egal
wie lang diese Kurven sind, immer die
gleiche Anzahl von Punkten generieren. Wir können das beheben, indem wir
die Größe dieses Gitters
durch die Kurvenlänge steuern . Das heißt, wenn wir längere Kurven
haben, wird ein größeres Raster erzeugt und mehr Punkte
verteilt, weil mehr Platz zur Verfügung
steht. Auf diese Weise können wir einfach
eine Kurvenlänge verwenden und
sie an die X- oder Y-Achse anschließen. Jetzt können Sie sehen, dass
es Punkte
auf diesem großen Raster generiert . Und wir können
die Dichte auch mit der zweiten Größe auf
der Y-Achse steuern . Aber ich bleibe bei einer
und wir werden die
Dichte mit diesem Dichtewert kontrollieren . Wenn wir nun die entsprechende
Anzahl von Punkten generiert haben, müssen
wir
sie nur noch auf den Kurven verteilen. Also verwenden wir einfach set position. Und als Position werden wir
diese zufällige Position
aus Quellkurven verwenden diese zufällige Position
aus Quellkurven Jetzt können Sie sehen, dass
beim Abspielen der Animation zufällige Punkte
auf alle Kurven verteilt Stimmt das? Wenn ich mir jetzt die Animation
ansehe, können
Sie sehen, dass es immer vier Punkte
gibt, und das liegt daran, dass der Sitz der Verteilerpunkte immer noch derselbe
ist. Also stecke ich auch
den Rahmen an den Sitz. Und jetzt sollten wir eine
unterschiedliche Anzahl von Punkten bekommen. Ich reduziere vielleicht
die Dichte auf 2,02, und Sie können sehen, dass es drei Punkte
gibt, eins, eins, drei, null, zwei, also ist es
gut randomisiert. Richtig. Lassen Sie uns nun
diese Punkte wieder in
diese Simulationszone bringen und diese ausgeben. Und Sie können sehen
, dass wir beim Abspielen der Animation immer mehr Punkte bekommen . Lassen Sie uns dem Ganzen also ein
bisschen Bewegung geben. Für die Bewegung können
wir einfach
eine festgelegte Position verwenden und ihr einfach einen
Offset auf ZxS auf
etwa minus 0,1 geben Offset auf ZxS auf
etwa minus 0,1 Wenn Sie jetzt die Animation abspielen, werden
Sie feststellen, dass die
Punkte fallen Das liegt daran, dass immer diese neuen Punkte
erzeugt werden
und sie alle um minus 0,1 auf
der Z-Achse verschoben werden. Eine Sache, die wir
korrigieren sollten , ist, dass
Sie sehen können, wie schnell
sie fallen, wenn wir jetzt die Animation
abspielen . Aber wenn ich die Bildrate
dieses Projekts
zum Beispiel auf 60 ändere , werden Sie feststellen , dass sie viel schneller
sinken. liegt daran, dass dieser Offset bei
24 FPS liegt und 24 Mal pro Sekunde erfolgt. Wenn wir jedoch Bilder
pro Sekunde auf 60 setzen, erfolgt das 60 Mal pro Sekunde
und es ist viel schneller. Um dies zu kontrollieren, können wir diese Delta-Zeit
verwenden, die uns Zeit
zwischen zwei Frames gibt. Und wenn wir einen Vektor um
diesen Wert skalieren , also so
etwas. Und ich sage das
auf minus eins bei Z X, weil diese
Deltazeit eine sehr kleine Zahl ist. Wenn Sie jetzt die Animation abspielen, können
Sie sehen, dass
sie ziemlich langsam ist. Wenn wir jedoch die Bildrate ändern, sollte sich
die Geschwindigkeit nicht ändern und sie sollte
dieselbe Geschwindigkeit beibehalten. Richtig, also können wir
das zum Beispiel Schwerkraft nennen und wir müssen in der
Lage sein, diese Schwerkraft zu kontrollieren, also werden wir
diesen Wert auf der Z-Achse kontrollieren wollen. Dadurch füge ich
einfach die Kombination XYZ und füge eine neue Gruppeneingabe hinzu, die diesen Z-Wert steuert Für die Punkte füge ich
ein neues Bedienfeld hinzu, das ich Partikel nenne, und ich füge eine neue Eingabe hinzu, die ich Schwerkraft nenne
und die Standardeinstellung auf eins setze Da wir eine positive Schwerkraft
eingeben möchten, dieser Wert
aber negativ sein
muss, multiplizieren
wir
diese Gravitationseingabe zunächst mit einer negativen Zahl und setzen
sie dann in die Z-Koordinate ein. Wenn ich jetzt zum Modifikator gehe und die Schwerkraft auf eins
zurücksetze, muss ich
das
leider auf Multiplikation einstellen Und jetzt sollten wir
fallende Blätter
oder fallende Partikel Ich kann das auch erhöhen und
du wirst sehen, dass
die Punkte schneller oder langsamer fallen. Ordnung. Also lassen wir es
jetzt ein
bisschen Zufall sein. Also
werden wir diesem Offset einen zufälligen Wert
hinzufügen Und dieser
Zufallswert wird von der
Rauschtextur stammen , weil
die Rauschtextur uns ein schönes, gleichmäßiges Rauschen
gibt, und wir können das verwenden, um
diese Punkte zu Lassen Sie uns also eine Rauschtextur hinzufügen. Wir haben bereits
Rauschtexturen verwendet um unseren Baum zu verschieben, und wir haben eine Sache gemacht, diese Farbe neu zuzuordnen, weil
das Vektor ist und wir diesen Vektor verwenden
wollen, und wir haben
ihn von Null, Null, Null, Eins, Eins zu negativen Einsen neu Einsen Wir erhalten also Vektoren, die auch positiv und negativ
sein können und nicht nur Das gibt uns also einen zufälligen Vektor. Und jetzt, wenn wir
diesen Vektor einfach um eine
Konstante skalieren und ihn
zu dieser Schwerkraft addieren, werden
Sie sehen, dass wir hier
sehr verrückte Punkte haben. Ich werde das zum Beispiel
mit 0,1 multiplizieren, jetzt kannst du sehen, dass die
Punkte wackeliger sind, einige von ihnen
bleiben auch an der Stelle Eine Sache, die
wir in
dieser Map-Ranch korrigieren könnten , ist, dass wir diese
Punkte auf der Z-Achse
nicht kontrollieren wollen, sondern nur die Bewegung
auf der X- und Y-Ebene
kontrollieren Also setze ich diese
Z-Coins einfach auf Null, und jetzt gibt
uns diese
Karten-Ranch nur zufällige Vektoren
auf der XY-Ebene
15. Erweiterte Partikelsimulationen: Hallo und willkommen zurück bei Free
D Trees with Blender EmetinRDS Sie können sehen, dass die Punkte mit der gleichen Geschwindigkeit
fallen und dass sie schnörkelig sind Wenn wir die Skalierung auf
etwas Globales einstellen, Sie möglicherweise fest, dass sich einige Punkte
gruppieren. Das liegt daran, dass,
wenn sich die beiden Punkte in
der Nähe oder an derselben Position
befinden, dasselbe Geräusch
auf sie angewendet wird und sie dann denselben Pfad oder dieselbe Richtung
haben Um also für jeden Punkt eine andere
Rauschtextur zu erzeugen, können
wir das auf vier D umschalten, und dieses W ist so etwas wie CD So können wir zum Beispiel einfach den Index jedes Punktes
verwenden. Dieser Index ist
eigentlich nicht die beste Wahl , da sich der Index
während der Simulation ändern kann. Um dies zu beheben,
speichern wir vor Beginn
der Simulation einige Attribute für jeden Punkt und verwenden sie
dann, um zwischen ihnen
zu unterscheiden Also füge ich
hier nach der festgelegten Position, an der wir die Punkte
verteilen, ein Attribut mit
dem
Namen speichern hinzu hier nach der festgelegten Position wir die Punkte
verteilen, ein Attribut mit
dem Und das Erste
, was wir speichern werden wird so etwas wie Index sein, also nenne ich es und
es wird Integer sein. Und ich werde eine Kombination aus
Frame und Index verwenden , um
für jeden Punkt eine eindeutige Zahl zu erstellen. Dafür
können wir zum Beispiel einfach multiplizieren und addieren verwenden. Ich multipliziere den Frame
mit einer Konstanten , sagen
wir 21, und füge
den Index hinzu. Das sollte uns für jeden Punkt eine andere
Zahl geben, und wir können mit
diesem I-Attribut beginnen. Und später können wir
dieses benannte Attribut
als Ausgangspunkt für dieses Geräusch wiederverwenden . Jetzt können Sie sehen, dass das
Rauschen viel gleichmäßiger ist, und wir
möchten kontrollieren können, wie stark diese Geräuschtextur auf
unsere Punkte und auch auf den
Maßstab dieser Geräuschtextur auswirkt unsere Punkte und auch auf den
Maßstab dieser Geräuschtextur Fügen wir also zwei neue Eingaben hinzu. Erstens die Geräuschskala, die ich standardmäßig auf
eins und das Minimum auf Null setze, und zweitens die Geräuschstärke, die ich standardmäßig auf eins setze. Wenn man sich das Setup anschaut, ist
das Seltsame dabei, dass die Schwerkraft
durch die Delta-Zeit skaliert wird, die Rauschtextur
jedoch nicht, und das sollte
eigentlich behoben werden Lassen Sie uns also zuerst
diese beiden Vektoren so
zusammenfügen und danach skalieren
wir den gesamten
Vektor um diese Delta-Zeit Das sollte nun wirklich
unabhängig von der Bildrate sein, und lassen Sie uns die
Eingänge von der Gruppeneingabe verbinden, also rufe ich die Gruppeneingabe auf
und verbinde die Geräuschskala diesem Rauschen und die Rauschleistung diesem Skalenvektor-Mathematikknoten. Ich werde diese Werte auch begründen. Und Sie können sehen, dass wir
schöne fallende Partikel haben. Das Problem, das Sie vielleicht
sehen, ist, dass die Punkte ständig generiert
werden, aber sie werden nie gelöscht. Das kann zu
Problemen mit der Bildrate führen, Das kann zu
Problemen mit der Bildrate führen da es zu viele Blätter
geben könnte und sie sehr verzögert werden würde. Um das Problem zu beheben, benötigen
wir eine Funktion , die die Punkte
nach einiger Zeit ihrer Lebensdauer löscht nach einiger Zeit ihrer Lebensdauer Nehmen wir an, wir legen eine
Lebensdauer von jeweils 0,2 Sekunden fest. Wenn der Punkt also älter
ist oder länger als 2 Sekunden in der Szene ist, wird er gelöscht. Dafür werden wir vor
der Simulation
einige Attribute speichern . Eines davon wird Start sein, was uns die
Zeit gibt, zu der dieser Punkt erstellt wurde. Der Typ wird Float sein.
Und um diesen Wert zu speichern, verwenden
wir einfach die Sekunden, wodurch wir die
aktuellen Sekunden erhalten, und wir speichern ihn
im Startattribut. Das zweite Attribut, das wir verwenden
werden, ist Lifetime, und das speichert, wie lange
dieser Punkt leben sollte. Und jetzt stelle ich
es einfach auf 2 Sekunden ein. Später können wir
das zum Beispiel randomisieren. Nach der Bewegung
der Punkte werden
wir also prüfen, ob jeder Punkt
noch in der Simulation sein sollte, und wenn nicht, werden wir ihn löschen Fügen wir nun Löschgeometrie hinzu, und jetzt müssen wir auswählen, welche
Punkte wir löschen möchten. Sie beginnen
mit dem benannten Attribut. Und um herauszufinden,
wie lange es lebt, verwenden
wir einfach die aktuelle Zeit und ziehen diesen
Start von dieser Zeit ab Diese Subtraktion gibt
uns also Auskunft darüber, wie lange dieser Punkt schon existiert hat Nehmen wir zum Beispiel an,
der Start ist 2 Sekunden und derzeit beträgt die
Zeit 6 Sekunden. Das bedeutet, dass der
Punkt noch 4 Sekunden gültig ist. Und wenn das
länger als die Lebensdauer ist, dann werde
ich das duplizieren
und es auf Lebenszeit setzen. Wir wollen diesen Punkt streichen. Also setzen wir dieses Ergebnis
in die gelöschte Geometrie ein. Und wenn wir jetzt
die Animation abspielen, werden
Sie sehen, dass
die Punkte unten gelöscht werden. liegt daran, dass ihre
Lebensdauer länger
als ihre Schwellenlebensdauer ist und sie gelöscht werden. Wir können
diese Lebensdauer auch nach dem Zufallsprinzip festlegen. Dafür füge ich
zwei Gruppeneingaben hinzu. Eine davon wird lebenslang sein, ich setze den Standardwert auf zwei
und das Minimum auf Null, und die zweite ist
lebenslange Zufälligkeit Was ich standardmäßig auf Null setzen werde. Und jetzt nur klassische
Randomisierung. Wir werden Gruppeneingaben hinzufügen, und das Minimum
des Zufallswerts Lebensdauer
minus Zufälligkeit, und das Maximum ist
Lebensdauer plus Zufälligkeit Das gibt uns also den Bereich ,
in dem wir die
Lebensdauer generieren wollen Und wir werden
diese beiden Werte wie diesen in einen Zufallswert einfügen, und wir können den
Startwert auch anhand der Gruppeneingabe festlegen. Und die ID, um es für jeden Punkt
anders zu machen, wir können diesen I-Wert wiederverwenden, den
wir hier in I speichern, und ich werde
ihn einfach so hierher übertragen. Und das sollte uns für jeden Punkt einen
anderen Wert geben. Und wenn wir
es jetzt lebenslang speichern,
ja, es gibt einige Probleme liegt daran
, dass unsere
Lebensdauer nicht wirklich festgelegt ist. Also setze ich Lebenszeit auf zwei
und Zufälligkeit auf Null. Jetzt
sollte jeder Punkt 2 Sekunden überleben. Aber wenn ich die Zufälligkeit auf eins setze, kann
der Punkt zwischen 1
Sekunde und 3 Sekunden leben. Stimmt das? Ich denke, unsere grundlegende
Partikelsimulation ist abgeschlossen, und jetzt der letzte Teil,
um echte Blätter herzustellen Wir müssen diese Punkte verwenden und einige
Objekte darauf verteilen. Deshalb verwende ich dafür die
Instanz nach Punkten. Und als Instanzen werden
wir einige Blätter verwenden. Also die werden in der Sammlung sein. Und dafür müssen wir zuerst
eine Gruppeneingabe erstellen. Also füge ich eine neue
Gruppeneingabe und Sammlung hinzu, setze den Typ auch auf Sammlung
und verschiebe ihn hierher. Und jetzt füge ich
diese Sammlung einfach von der
Gruppeneingabe zur Sammlungsinformation hinzu. Ich möchte Kinder trennen und
untersuchen, diese Instanzen
in die Instanzeingabe einbinden
und wir wollen, dass jede Instanz
randomisiert wird, also werde ich diese große Instanz überprüfen Jetzt können wir alles sehen, weil wir die Sammlung nicht ausgewählt Und die Kollektion, die ich
verwenden werde , werden diese Blütenblätter sein. Also kann ich das wieder verstecken und hier
Blütenblätter pflücken. Und jetzt können Sie sehen, dass wir
sehr einfache Blätter wie dieses haben . Es gibt ein paar Probleme.
Sie sind alle nach oben gerichtet. Deshalb möchten wir
diese Blätter
zum Beispiel nach dem Zufallsprinzip sortieren Und zweitens haben
sie alle die gleiche Skala, also wollen wir
das ein bisschen randomisieren Lassen Sie uns zunächst die Rotation korrigieren. Und als Erstes könnten
wir einfach eine zufällige Drehung
an diese Drehbuchse anschließen. Aber um das Rendern etwas
besser zu machen, können
wir sie zum Beispiel so drehen, dass
sie immer zur Kamera zeigen, und man kann immer die ganzen Blätter
sehen, was sehr praktisch sein kann,
wenn sie sehr klein sind, sie sind vielleicht nicht immer
sichtbar. Das könnte das Problem beheben und
um die Drehung herauszufinden, wie sie
der Kamera zugewandt sein wird, müssen
wir zuerst das
Kameraobjekt betrachten, damit wir aktives Kameraobjekt
erhalten, das uns die
aktuell aktive Kamera gibt. Um den Standort zu ermitteln, verwenden wir Objektinformationen und
verwenden diesen Standort. Und Sie können sehen, dass diese Blätter
immer zur Z-Achse zeigen. Also wollen wir
die Z-Achse an der
Richtung zur Kamera ausrichten . Um die Richtung zur Kamera zu ermitteln, nehmen
wir einfach unsere
Position und subtrahieren sie von der Position der Kamera Mit Vektormathematik. Das gibt
uns also diesen Richtungsvektor. Und jetzt können wir einfach „Drehung am Vektor
ausrichten“ verwenden weil wir
unsere Z-Achse an diesem Vektor ausrichten wollen, also setze ich das in
Vektor und Rotation ein. Und jetzt sieht das
ein bisschen komisch aus. Das liegt wahrscheinlich daran, dass ich in dieser Szene keine Kamera
habe, also füge ich eine neue Kamera hinzu. Und Sie können sehen, dass
, wenn ich die Kamera bewege, die Blätter zu
ihr zeigen, und ich kann es
mit dieser überprüfen . Sie können sehen, dass ich, wenn ich
aus einem beliebigen Winkel
schaue, immer die Blätter sehen kann. Und zu guter Letzt
können wir
sie auch zufällig um die Z-Achse drehen . Auf diese Weise können wir dieser Drehung
einfach einen zufälligen Wert
hinzufügen, und ich verwende einfach den
Zufallswert 0-2 Pi Und jetzt sollten sie auch eine
zufällige Rotation haben. In Ordnung, das
sieht also ziemlich gut aus. Und jetzt, was die Skala angeht, werden
wir den klassischen Ansatz verwenden Wir fügen einfach Eingaben für Skalierung und Skalenzufälligkeit und berechnen sie einfach auf der
Grundlage dieser Eingaben erste Eingabe ist also Skala, Standard eins, Minimum bis Null, und die zweite Eingabe ist
Skalenzufälligkeit, die Standardeinstellung
Null und das Minimum Null Für einen Wert in diesem Bereich subtrahiere
ich die Zufälligkeit von der
Skala, und für den Höchstwert addiere
ich diese beiden
Werte und setze diese beiden Werte einfach in
das Minimum und das Maximum
des Und das sollte
uns die richtige Skala geben. Wir können auch den Startwert aus der
Gruppeneingabe für den Startwert verwenden, und für die ID können wir
das Attribut I named verwenden. Also füge ich das benannte Attribut
I hinzu und füge es in die ID ein. Also
so etwas sollte funktionieren. Und jetzt können wir
diesen Wert in die Skala einfügen
und Sie können sehen, dass die
Blätter zufällig angeordnet sind Ich stelle die Skala auf Oh, ja, die Skala ist auf eins Ich setze die Skalierung auf etwa 0,2 und zufällig auf 0,1. Und jetzt haben wir diese
schönen kleinen Blätter. Ich werde die Schwerkraft verringern, also ist es etwas langsamer. Und die letzte Eingabe, die wir
vergessen hinzuzufügen, ist Dichte. Also lasst uns das auch beheben. Die Punkte sind
hier in dieser
Verteilung auf Flächen verteilt , und wir wollen in der Lage sein, diese Dichte
zu kontrollieren. Also werde ich eine neue
Eingabe hinzufügen, sie Dichte nennen. Sende devot auf
etwa 0,5, und ich setze es in
diese Dichte-Eingabe Wenn wir das jetzt zurücksetzen, haben
wir hier viele Punkte, und ich könnte das Ausmaß
des Rauschens etwas erhöhen Und wenn ich nur ein paar Blätter haben möchte, setze ich den Wert auf 0,05, aber ich habe immer noch viele Blätter Ich werde das noch weiter reduzieren
und die Lebensdauer verlängern. Jetzt kannst du sehen, dass wir
ein paar ziemlich schöne Blätter haben. Und um das
mit dem ursprünglichen Baum zu kombinieren, füge
ich einfach die Gelenkgeometrie und füge diese
beiden Dinge einfach zusammen. Und was wir jetzt haben, ist dieser wunderschöne Baum
mit fallenden Blättern.