Die Transformieren einer Scene Graph Entität definiert die Ort (Position), die Drehung (Ausrichtung) und den Maßstab (Größe) einer Entität. Um eine Scene Graph Entität zu Transformieren, muss die Entität eine transform_component haben. Die transform_component enthält zwei Felder, die du entweder über UEFN oder Verse-Code bearbeiten kannst:
Ursprung: Ein optionaler Ursprung, aus dem LocalTransform berechnet wird.
LocalTransform: Eine
(/Verse.org/SpatialMath:)transformrelativ zum Parent der Entität, oder zu Ursprung, wenn das optional Feld Ursprung festgelegt ist.
Der Ursprung einer Entität ist die Entität, aus der die LocalTransform der transform_component einer Entität berechnet wird. Dies ist der Wert des Feldes Ursprung, wenn das Feld Ursprung auf der transform_componentis festgelegt ist, oder der Parent der Entität in der Scene Graph Hierarchie, wenn das Feld Ursprung nicht festgelegt ist.
Es ist wichtig, zwischen einem Transformieren und der Transform_Component zu unterscheiden. Ein Transformieren ist ein Zusammensetzung/zusammengesetzt Datentyp, der in der Datei /Verse.org/SpatialMath definiert ist Modul, das die folgenden Größen im Koordinatensystem Links-oben-vorwärts (LUF) speichert:
Translation (
vector3): Die Position eines Objekts.Rotation (
rotation): Die Ausrichtung des Objekts.Scale (
vector3): Die Größe des Objekts.
Die transform_component ist eine Verse-Klasse, die in der Datei /Verse.org/SceneGraph Modul, das die LocalTransform einer Scene-Graph-Entität und optional einen alternativen Ursprung speichert. Du kannst dir die transform_component als einen Container vorstellen, der einer Entität für eine Transformation bereitgestellt wird, die ihren Platz in der Simulation definiert.
Verse-Transformationen
Scene Graph verwendet /Verse.org/SpatialMath des Moduls transformiert wird. Verse-Modul-Transformationen verwenden das rechtshändige LUF-Koordinatensystem. Um eine Verse-Transformation zu erstellen, kannst du den Klassenarchetyp und die eingebauten Methoden zum Erstellen von Drehungen verwenden.
# Transform specifying all fields
MyTransform:transform = transform:
Translation := vector3{Left := 2.0, Up := -4.0, Forward := 8.0}
Rotation := MakeRotationFromEulerDegrees(-90.0, 180.0, 0.0)
Scale := vector3{Left := 2.0, Up := 4.0, Forward := 2.0}
# Transform specifying only Translation
MyOtherTransform:transform = transform:
Translation := vector3{Up := 512.0}
Weitere Informationen über das Koordinatensystem in UEFN findest du auf der Seite /UnrealEngine.com/Temporary/SpatialMath Modul und das Verse-Modul Transformieren.
Konstruiere eine Entität mit einer transform_component
Du kannst eine Entität im UEFN-Outliner oder über Verse konstruieren.
In UEFN
Über das Menü Actors platzieren kannst du schnell eine Scene Graph Entität zu deinem Projekt hinzufügen.
Wenn du eine Scene Graph-Entität über das Menü Actors platzieren zu deinem Projekt hinzufügst, ist die Entität standardmäßig mit einer transform_component ausgerüstet.
Wenn du möchtest, kannst du die transform_component entfernen, indem du zu deiner kürzlich platzierten Entität im Outliner-Panel navigierst, die transform_component suchst und Komponente entfernen auswählst.
Nachfolgend siehst du, dass die betreffende Entität keine transform_component mehr hat.
In Verse
Wenn du eine Scene Graph Entität über Verse-Code mit dem Klassenarchetyp erstellst:
MyEntity:entity = entity{}Die Entität ist nicht mit einer transform_component ausgerüstet. Stattdessen muss eine transform_component zu deiner Entität hinzugefügt werden. Die bevorzugten Methoden für die Arbeit mit Transformationen sind SetLocalTransform und SetGlobalTransform. Diese Funktionen verarbeiten das Erstellen der Transformieren-Komponente, das Festlegen der Werte und das gleichzeitige Hinzufügen der Transformieren-Komponente zur Entität.
MyEntity:entity = entity{}
# Add entity to simulation entity so MyEntity begins simulating when play begins
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
# Identity transform
IdentityTransform:transform = transform:
Translation := vector3{Left := 0.0, Up := 0.0, Forward := 0.0}
Rotation := MakeRotationFromEulerDegrees(0.0, 0.0, 0.0)
Du kannst die Komponente auch direkt mit AddComponents hinzufügen:
# Add entity to simulation entity so MyEntity begins simulating when play begins
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
# Use AddComponents
MyEntity.AddComponents(array{ transform_component{ Entity := MyEntity }})
# Same as above, but more readable if adding multiple components at once
MyEntity.AddComponents of array:
transform_component{Entity := MyEntity}Weitere Methoden zum Hinzufügen einer transform_component zu einer Scene Graph Entität über Verse-Code werden im Abschnitt „Arbeiten mit der transform_component in Verse“ besprochen.
So wird das Transformieren einer Entität berechnet
Die wichtigste Operation, die du an einer Scene Graph Entität mit der transform_component durchführen kannst, ist das Abrufen oder Setzen der Transformieren einer Entität.
Es gibt zwei Typen von Transformieren, die dich interessieren könnten: lokales Transformieren und globales Transformieren. Um die Transformation einer Entität effektiv zu manipulieren, ist es wichtig zu verstehen, wie diese Transformationen berechnet werden.
Das lokale Transformieren ist das Transformieren in Bezug auf den Ursprung einer Entität. Das lokale Transformieren einer beliebigen Scene Graph Entität ist der Wert des Feldes LocalTransform in der transform_component einer Scene Graph Entität.
Das globale Transformieren ist das Transformieren in Bezug auf den Ursprung des LUF-Koordinatensystems im globalen Raum. Das globale Transformieren einer Scene-Graph-Entität wird berechnet, indem die LocalTransform einer Entität mit folgenden Elementen zusammengesetzt wird:
Das globale Transformieren des Parent der Entität, wenn das Feld Ursprung nicht auf der transform_component der Entität festgelegt ist, oder
Das globale Transformieren des Ursprungs der Entität, wenn das Feld Ursprung auf der Transformieren-Komponente der Entität festgelegt ist.
Im Folgenden wird ein Beispiel dafür mit Verschiebung ohne Drehung oder Skalierung bearbeitet, so dass die resultierenden Transformationen durch Hinzufügen von Verschiebungen berechnet werden können. Da dieses Beispiel davon ausgeht, dass die Drehung und der Maßstab in allen Transformationen als ihre jeweiligen Identität belassen werden, wird eine Abkürzung verwendet, um sich auf die Transformation einer Entität durch den Transformationsverschiebungsvektor der Entität zu beziehen.
Betrachte drei Scene Graph Entitäten, die wie folgt organisiert sind:
BaseEntity: LocalTransform (0.0, 0.0, 0.0) im LUF-Koordinatensystem.
A: LocalTransform (750.0, 100,0, 0,0).
B: LocalTransform (-250.0, 100,0, 0,0).
Nachfolgend sind die drei Entitäten in einer Szene aufgeführt, in der BaseEntity keine mesh_component hat, A ein Würfel ist und B ein Kegel ist:
Nehmen wir zum Beispiel an, du möchtest sowohl das lokale Transformieren als auch das globale Transformieren von Entität B bestimmen. Das lokale Transformieren ist schnell zu sehen: Sie ist der Wert des Feldes LocalTransform der Entität B transform_component, wie unten zu sehen:
Das lokale Transformieren von Entität B ist (-250.0, 100,0, 0,0).
Um das globale Transformieren von Entität B zu berechnen, würdest du die Hierarchie von Entität B zurück zur simulation entity zurückverfolgen und Transformationen beginnend bei der simulation entity und dann bis zu Entität B zusammensetzen. Die Simulationsentität ist der Stamm der aktuellen Simulation, unter der alle anderen simulierenden Entitäten Children sind.
Dies sind die Schritte zur Berechnung des globalen Transformierens von Entität B:
Die Simulationsentität ist der Ausgangspunkt der aktuellen Simulation.
Globales Transformieren der Simulation Entity: (0.0, 0.0, 0.0).
Die BaseEntity ist ein Kind der simulation entity. Die BaseEntity hat eine lokale Transformieren von (0.0, 0.0, 0.0), wie in Bild 1.0 zu sehen. Die Zusammensetzung des globalen Transformierens der Simulation Entity mit dem lokalen Transformieren der Basisentität ergibt:
Globales Transformieren von BaseEntity: (0.0, 0.0, 0.0) + (0.0, 0.0, 0.0) = (0.0, 0.0, 0.0).
Entität A ist ein Child von BaseEntity. Entität A hat ein lokales Transformieren von (750.0, 100.0, 0.0) wie in Bild 1.1 zu sehen. Das Zusammensetzen des globalen Transformierens von BaseEntity mit der Positionstransformation von Entität A ergibt:
Entität A globales Transformieren: (0.0, 0.0, 0.0) + (750.0, 100.0, 0.0) = (750.0, 100,0, 0,0).
Die Entität B ist ein Kind der Entität A. Entität B hat ein lokales Transformieren von (-250.0, 100.0, 0.0) wie in Bild 1.2 zu sehen. Wenn du das globale Transformieren von A mit der Positionstransformation von Entität B zusammensetzt, erhältst du:
Entität B global transformieren: (750.0, 100.0, 0.0) + (-250.0, 100.0, 0.0) = (500.0, 200,0, 0,0).
Daher ist das globale Transformieren von Entität B(500.0, 200.0, 0.0) im LUF-Koordinatensystem exportieren.
Arbeiten mit der transform_component im Editor
Mit LocalTransform und Ursprung kannst du das Transformieren einer Entität manipulieren.
Lokale Transformation
Das Feld LocalTransform der transform_component einer Entität ist die (/Verse.org/SpatialMath:)transform einer Entität in Bezug auf ihren Ursprung. Wenn das Ursprung-Feld nicht explizit gesetzt ist, ist der Ursprung einer Entität standardmäßig ihr Parent in der Scene Graph Hierarchie. Das Feld LocalTransform ist ein bearbeitbares Feld, das in UEFN angezeigt wird und in dem du eine Entität direkt bearbeitest:
Verschiebung: Position relativ zum übergeordneten oder manuell definierten Ursprung.
Ändere die Verschiebung einer Entität, um sie im Level zu bewegen.
Drehung: Ausrichtung relativ zum Parent oder manuell definierten Ursprung.
Ändere die Drehung einer Entität, um sie um den Drehpunkt der Entität zu drehen.
Maßstab: Größe relativ zum übergeordneten oder manuell definierten Ursprung.
Ändere den Maßstab einer Entität, um sie größer oder kleiner zu machen.
Ursprung
Der Ursprung der transform_component einer Entität ist das Objekt, in Bezug auf das LocalTransform berechnet wird. Dieses Feld in der transform_component ist optional. Standardmäßig ist die LocalTransform der transform_component die Transformation der Entität, basierend auf dem Ursprung der Entität, berechnet in Bezug auf die parent entity der besitzenden Entität. Du kannst optional das Ursprung-Feld in der transform_component einer Entität setzen, um die LocalTransform in Bezug auf ein anderes Objekt als das Parent-Objekt der Entität zu berechnen.
Zum Beispiel kannst du den Ursprung einer Entität so festlegen, dass er eine ganz andere Entität ist. Du kannst dieses Feld mit jeder Klasse setzen, die das Verse Ursprung Interface implementiert. Um insbesondere das Feld „Ursprung“ auf eine andere Scene Graph Entität zu setzen, wähle die Klasse entity_origin, dann die Entität aus, die der neue Ursprung sein soll.
Es ist wichtig, zwischen dem Ursprung in Bezug auf die transform_component und dem Ursprung des LUF-Koordinatensystems zu unterscheiden. Der Ursprung des LUF-Koordinatensystems ist der Punkt im Welt-Bereich mit der Verschiebung (0.0, 0.0, 0.0).
Der Ursprung der transform_component einer Entität ist der Ort, an dem sich eine Entität befindet, wenn die transform_component LocalTransform der Entität Translation (0.0, 0.0, 0.0) hat.
Im Folgenden wird ein Beispiel gezeigt, wie das Feld „Ursprung“ und „LocalTransform“ in der Praxis funktionieren. Betrachte eine BaseEntity, die sich am Ursprung des Welt-Bereichs befindet, mit der Child-Entität A, die durch den Würfel mesh_component dargestellt wird, und der Child-Entität B, die durch den Kegel mesh_component dargestellt wird.
Wie im obigen Bild zu sehen ist, befindet sich BaseEntity am Ursprung des Welt-Bereichs, da sein Ursprungsfeld in der transform_component unset ist und LocalTransform auf den Ursprung des Welt-Bereichs gesetzt ist.
Wie unten gezeigt, kannst du sehen, dass das Feld Ursprung von Entität A ebenfalls nicht gesetzt ist, sodass LocalTransform in Bezug auf die transform_component ihres Parents, BaseEntity, berechnet wird.
Da sich BaseEntity am Ursprung des Welt-Raums befindet und die Verschiebung der LocalTransform von Entität A auf vector3{Left := 750.0, Up := 100.0, Forward := 0.0} gesetzt ist, befindet sich Entität A bei vector3{Left := 750.0, Up := 100.0, Forward := 0.0}. Die Drehung und der Maßstab von Entität A bleiben unverändert, da die Drehung und der Maßstab von LocalTransform auf der BaseEntity die jeweiligen Identitäten sind.
In dem Bild unten siehst du, dass das Feld Ursprung von Entität B, das auch ein Child von BaseEntity ist, auf ihrer transform_component als Entität A festgelegt ist.
Dadurch ist das Feld LocalTransform der Entität B auf seiner transform_component relativ zur berechneten Transformation der Entität A. Da LocalTransform von Entität B auf vector3{Left := -250.0, Up := 100.0, Forward := 0.0} und LocalTransform von Entität A auf vector3{Left := 750.0, Up := 100.0, Forward := 0.0} gesetzt ist, ist das globale Transformieren von Entität B ist vector3{Left := 500.0, Up := 200.0, Forward := 0.0}.
Wenn du die Drehungskomponente des Feldes LocalTransform der Entität A transform_component auf -90,0 Grad um die Vorwärtsachse änderst, dreht sich auch Entität B um -90,0 Grad um die Vorwärtsachse. Das liegt daran, dass die Drehung eines Kindes auch vom Parent geerbt wird.
Arbeiten mit der transform_component in Verse
Du kannst mit GetComponent prüfen, ob eine Entität eine transform_component besitzt:
MyEntityNoTransform:entity = entity{}
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntityNoTransform})
MyEntityWithTransform:entity = entity{}
MyEntityWithTransform.AddComponents of array:
transform_component{Entity := MyEntityWithTransform}
if (SimEntity := Entity.GetSimulationEntity[]):
Anstatt die transform_component mit GetComponent abzurufen und direkt mit der transform_component zu arbeiten, wird der empfohlene Weg, mit der transform_component zu interagieren, über die Entitätserweiterungsmethoden.
Transform
Mit den Entitätserweiterungsmethoden SetLocalTransform oder SetGlobalTransform kannst du das lokale oder globale Transformieren deiner Entität direkt festlegen.
MyEntity:entity = entity{}
MyTransform:transform = transform{}
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
# Set the local transform
MyEntity.SetLocalTransform(MyTransform)
MyOtherEntity:entity = entity{}
Diese Erweiterungsmethoden sind die bevorzugte Methode, um die Transformation für eine Scene-Graph-Entität in Verse-Code festzulegen. Diese Methoden legen explizit das lokale (in Bezug auf den Parent der Entität) oder globale (in Bezug auf den Weltursprung) Transformieren der betreffenden Entität fest. Wenn die Entität beim Aufruf einer dieser Funktionen keine transform_component hat, wird implizit eine transform_component erstellt und der Entität hinzugefügt. Nach einem dieser Funktionsaufrufe verfügt die Entität nun über eine transform_component. Du kannst dies mit einem nachfolgenden Aufruf von GetComponent.bestätigen.
if (MyEntity.GetComponent[transform_component]):
# success, entity has a transform_component
else:
# failure, entity does not have a transform_component
Mit Erweiterungsmethoden kannst du das lokale oder globale Transformieren der assoziierten transform_component einer Entität abrufen. GetLocalTransform gibt die Transformieren einer Entität in Bezug auf ihre parent entity oder das angegebene Ursprungsfeld zurück, wenn es set ist. Wenn die Entität keine transform_component hat, gibt diese Funktion die Identitätstransformation zurück.
# Entity object
MyEntity:entity = entity{}
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
# Obtain the local transform with respect to Parent or Origin (if set)
EntityLocalTransform := MyEntity.GetLocalTransform() # no transform component, returns identity
MyOtherEntity:entity = entity{}
GetGlobalTransform gibt die Transformation einer Entität in Bezug auf den Weltursprung zurück. Wenn die Entität keine transform_component hat, gibt diese Funktion das globale Transformieren des nächsten Vorfahren mit einer transform_component zurück.
# Entity object
MyEntity:entity
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
# Obtain the global transform
EntityGlobalTransform := MyEntity.GetGlobalTransform() # returns global transform of Simulation Entity
Ursprung
Du kannst auch Entitätserweiterungsmethoden für Operationen verwenden, die das Feld transform_component Ursprung umfassen. Du kannst das Feld Ursprung der transform_component deiner Entität mit der Entitätserweiterungsmethode SetOrigin direkt festlegen.
MyEntity:entity = entity{}
MyOtherEntity:entity = entity{}
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity, MyOtherEntity})
MyEntity.SetLocalTransform(transform{Translation := vector3{Left := 100.0}})
# Construct an entity_origin object and set the new origin of MyEntity to MyOtherEntity
NewOrigin:entity_origin = entity_origin{Entity := MyOtherEntity}
Um den Ursprung einer Entität in Verse-Code zu erhalten, verwende GetOrigin.
MyEntity:entity = entity{}
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
if (OriginValue := MyEntity.GetOrigin[]):
# should not succeed
else:
# should fail, no transform_component on entity MyEntity
GetOrigin entscheidet, ob für eine Entität das Feld „Ursprung“ festgelegt ist, und gibt den Wert dieses Felds zurück, wenn dies der Fall ist. Andernfalls schlägt der Aufruf fehl. Im Erfolgsfall ist der Rückgabetyp von GetOrigin ein Ursprungsobjekt, eine Verse-Klasse, welche die Ursprungsschnittstelle implementiert. Dieses Interface bietet eine einzelne Funktion GetTransform, um die Transformation des angegebenen Ursprungs der Entität zu erhalten. Du kannst auch prüfen, ob das alternative Feld „Ursprung“ auf eine Entität festgelegt ist und bestimmen, welche Entität als Ursprung deiner Entität festgelegt ist.
if:
OriginValue := MyOtherEntity.GetOrigin[] # get Origin object
OriginEntityCast := entity_origin[OriginValue] # cast to entity_origin
then:
# Obtain the entity that is set as MyOtherEntity's Origin field on its transform_component
MyOtherEntityOrigin := OriginEntityCast.Entity
# Obtain the origin's transform
TransformOfOrigin := OriginEntityCast.GetTransform()
Schließlich kannst du das Feld Ursprung der transform_component einer Entität mit ResetOrigin zurücksetzen.
MyEntity.ResetOrigin()Nach dem Aufruf von ResetOrigin wird das Feld Ursprung der transform_component von MyEntity zurückgesetzt und die Transformation von MyEntity wird nun in Bezug auf die parent entity von MyEntity in der Scene Graph Hierarchie berechnet.
Abhängige Komponenten
Einige andere Scene Graph Komponenten sind auf die transform_component angewiesen, um zu funktionieren. Dazu gehören:
light_component und seine Child-Klassen
mesh_component
particle_system_component aktualisiert
Wenn du eine dieser Komponenten zu einer Scene Graph Entität hinzufügst, die nicht bereits eine transform_component hat, wird die transform_component standardmäßig der Entität hinzugefügt.
Hinweis zu XYZ-Transformieren
Transformationen mit dem XIZ-Koordinatensystem sind in der Datei /UnrealEngine.com/Temporary/SpatialMath Verse-Modul. Diese Transformationen werden weiterhin von Kreativmodus-Geräten und Props in der /Fortnite.com verwendet Verse-Modul. Weitere Informationen über den Status dieser Transformationen und die Konvertierung zwischen verschiedenen Transformationstypen in Verse findest du auf der Seite Left-Up-Forward Coordinate System.