Links-Oben-Vorwärts-Koordinatensystem

Einführung des LUF-Koordinatensystems

Alle wichtigen 3D-Werkzeuge zur Erstellung von Inhalten verwenden ein kartesisches Koordinatensystem (X, Y und Z), um Objekte zu positionieren und zu drehen. Die spezifischen Interpretationen dafür, welche Achsen (X, Y oder Z) welche Richtungen (z. B. Links/Rechts, oben/unten und vorne/hinten) darstellen, sind jedoch zwischen den Werkzeugen unterschiedlich. Darüber hinaus unterscheidet sich die Art und Weise, wie Drehungen modelliert werden – die als Händigkeit des Koordinatensystems bezeichnet wird – auch zwischen den verschiedenen Werkzeugen.

Um Verse und UEFN besser an die neuen Standards bei der Erstellung von 3D-Inhalten und andere wichtige Toolsets anzupassen, nehmen wir grundlegende Änderungen an der Darstellung unseres Koordinatensystems vor.

Zuerst führen wir, anstatt Koordinatenachsen mit X, Y und Z zu kennzeichnen, aussagekräftigere Achsennamen ein:

• Links (war -Y)

• Hoch (war Z)

• Vorwärts (war X)

Der Wechsel von dem bisherigen XYZ und FRU zu LUF entspricht somit einem Händigkeitswechsel der Achsen von einem linkshändigen Koordinatensystem (XYZ und FRU) zu einem rechtshändigen Koordinatensystem (LUF).

Zweites wurden die Farben des UEFN-Viewport-Gizmo geändert, um sie an andere Software für die 3D-Inhaltserstellung anzupassen:

• Links: Rot (war grün)

• Oben: Grün (war blau)

• Vorwärts: Blau (war Rot)

Drittens wurden viele Verbesserungen an der Datei /Verse.org/SpatialMath vorgenommen Modul einbinden: 

• Alle Verse-Modulfunktionen der räumlichen Mathematik sind jetzt Rechtshändig Operationen. Daher wurden alle Funktionen mit expliziten Rechtshändig-Varianten entfernt und durch Versionen ersetzt, die standardmäßig Rechtshändig-Operationen verwenden, und Rechtshändig-Indikatoren wurden aus Funktionsnamen entfernt. Weitere Informationen findest du im Abschnitt Rechtshändigkeit weiter unten auf dieser Seite.

• Drehungsfunktionen, die einen Parameter oder einen Ergebniswert beinhalten, haben jetzt Versionen, die Radianten oder Grad akzeptieren oder zurückgeben und sind mit Radianten oder Grad für die jeweilige Variante versehen.

• RotateBy, UnrotateBy, und alle (:rotation).Apply*-Funktionen wurden zu Beginn eines Multiplikationsoperators entfernt, der zwei Drehungen von links nach rechts zusammensetzt. Weitere Informationen findest du im Abschnitt [Transformations- und Rotationsmultiplikationsreihenfolge]() auf dieser Seite.

• RotateVector und UnrotateVector wurden zu Beginn eines Multiplikationsoperators entfernt, der einen vector3 um eine Drehung dreht, in dieser Reihenfolge. Für mehr Informationen, siehe den Abschnitt Änderungen der räumlichen mathematischen Operationen auf dieser Seite.

• TransformVector und TransformVectorNoScale wurden zu Beginn eines Multiplikationsoperators entfernt, der einen vector3 durch eine Transformation in der folgenden Reihenfolge transformiert: Skalierung, Rotation, Verschiebung. Für mehr Informationen, siehe den Abschnitt Änderungen der räumlichen mathematischen Operationen auf dieser Seite.

Viertens verwenden die Standardimporte von Skelett-Meshs aus FBX nun die Option, um die Aufwärts- und Vorwärts-Achsen auszurichten, sodass alle importierten Skelett-Meshs zur Vorwärts-Achse weisen.

Diese Auswirkungen

Diese Änderung des Koordinatensystems wirkt sich auf alle aus, die UEFN oder Transformationen im Modul /Verse.org verwenden, insbesondere auf verschiedene Aspekte von UEFN und Verse, darunter:

• UEFN-Details-Panel

• UEFN-Viewport und Gizmo

• Verse transformieren

XYZ

LUF

UEFN-Details-Panel

Transformationen im UEFN Details-Panel zeigen nun Koordinaten in Bezug auf das LIF-System an.

UEFN-Viewport

Das Mapping zwischen Gizmo-Achsen und Farben hat sich im UEFN-Viewport geändert.

Verse-Transformationen

/Verse.org-Modul-Transformationen verwenden das LUF-System. Das Modul /UnrealEngine.com zur Transformation mit dem XIZ-Koordinatensystem existiert noch immer und wird als Standardtransformation in den Modulen /UnrealEngine.com und /Fortnite.com verwendet.

Da diese beiden Module Transformationstypen enthalten, solltest du Folgendes beachten:

• Wenn du API-Funktionen nutzt, die sowohl /Verse.org-Modul-Transformationen als auch /UnrealEngine.com-Modul-Transformationen in der gleichen Datei verwenden, müssen die Typnamen nach ihrem Pfad qualifiziert sein, um Zweideutigkeiten zwischen den beiden Modulen zu vermeiden. Dies wird im folgenden Beispielausschnitt gezeigt.

  Verse

  Typnamen, die durch den Pfad qualifiziert sind

  using { /UnrealEngine.com/Temporary/SpatialMath }
  using { /Verse.org/SpatialMath }
   
  my_class := class:
  	MyUnrealEngineVector:(/UnrealEngine.com/Temporary/SpatialMath:)vector3 = (/UnrealEngine.com/Temporary/SpatialMath:)vector3{}
  	MyVerseVector:(/Verse.org/SpatialMath:)vector3 = (/Verse.org/SpatialMath:)vector3{}

  Copy full snippet(6 lines long)

• Scene Graph verwendet Transformationen des Moduls /Verse.org. Das bedeutet, dass das Szenendiagramm jetzt nur das LUF-Koordinatensystem verwendet.

• Der Verse Digest verwendet vollständig qualifizierte Verse-Kennungen, um zwischen den in UnrealEngine.com/Temporary/SpatialMath definierten Transformationstypen zu unterscheiden. als auch Verse.org/SpatialMath -Modulen zu unterscheiden.

Konvertierung vom XYZ- zum LUF-System

Wenn du bestehende API-Funktionen nutzt, die zum /Verse.org-Modul-Transformationen-System (LUF) geändert wurden, musst du deine benutzerdefinierten /UnrealEngine.com-Transformationen (XYZ) manuell zum LUF-System konvertieren oder die neu eingeführten FromTransform-Konvertierungsfunktionen nutzen. In diesem Abschnitt findest du mehrere potenzielle Konvertierungsprobleme und die Lösungen dafür.

Mehrdeutigkeit des Konstanten- oder Variablentyps

Mit den letzten Änderungen an der Verse-API definieren sowohl /UnrealEngine.com/Temporary/SpatialMath als auch /Verse.org/SpatialMath die Typen vector3, rotation und transform. Wenn du beide Domänen in deiner Verse-Datei aufnimmst, entsteht eine Typ-Mehrdeutigkeit.

Beispiel für Typ-Mehrdeutigkeit

Die folgende Verse-Datei importiert sowohl /UnrealEngine.com/Temporary/SpatialMath Modulpfad und /Verse.org/SpatialMath Modulpfad, und die benutzerdefinierte Klasse verwendet den unqualifizierten Typ vector3:

using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/SpatialMath }
 
my_class := class:
	MyVectorOne:vector3 = vector3{}	
        #Compile Error: Identifier vector3 could be one of many types: UnrealEngine.com.Temporary.SpatialMath.vector3 or Verse.org.SpatialMath.vector3
	MyVectorTwo:vector3 = vector3{}	
        #Compile Error: Identifier vector3 could be one of many types: UnrealEngine.com.Temporary.SpatialMath.vector3 or Verse.org.SpatialMath.vector3

Daher führt die Typ-Mehrdeutigkeit zu einem Kompilierfehler, wenn du versuchst, diese Datei zu kompilieren, da der Compiler nicht weiß, ob er MyVectorOne und MyVectorTwo als /UnrealEngine.com vector3-Typ oder als /Verse.org vector3-Typ kompilieren soll. Der Nutzer hat dem Compiler nicht genügend Informationen gegeben, damit er weiß, welcher Typ gewünscht ist.

Um diesen Kompilierfehler zu beheben, musst du den Typ von vector3, den jede Variable verwendet, per Pfadangabe qualifizieren. Es gibt mehrere verschiedene Möglichkeiten, wie du diese Konstanten per Pfadangabe qualifizieren kannst, um diesen Fehler zu beheben:

Du kannst jede Konstante oder Variable des Typs vector3 vollständig qualifizieren, wie im folgenden Code-Snippet gezeigt:

using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/SpatialMath }
 
my_class := class:
	MyVectorOne:(/UnrealEngine.com/Temporary/SpatialMath:)vector3 = (/UnrealEngine.com/Temporary/SpatialMath:)vector3{}
	MyVectorTwo:(/Verse.org/SpatialMath:)vector3 = (/Verse.org/SpatialMath:)vector3{}

Du kannst eine Konstante oder Variable aus dem Modul /Verse.org qualifizieren, wie im folgenden Code-Snippet gezeigt:

using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org } # Change the module path to avoid import ambiguity
 
my_class := class:
	MyVectorOne:vector3 = vector3{}
	MyVectorTwo:SpatialMath.vector3 = SpatialMath.vector3{} # Specify the submodule

Du kannst eine Konstante oder Variable aus dem Modul /UnrealEngine.com qualifizieren, wie im folgenden Code-Snippet gezeigt:

using { /UnrealEngine.com/Temporary } # Change the module path to avoid import ambiguity
using { /Verse.org/SpatialMath }
 
my_class := class:
	MyVectorOne:SpatialMath.vector3 = SpatialMath.vector3{} # Specify the submodule
	MyVectorTwo:vector3 = vector3{}

Änderung des Szenendiagramm-Typs

Wenn du die Szenendiagramm-APIs in deinen Verse-Dateien verwendest und keine anderen APIs verwendest, die räumliche Mathematik verwenden, kannst du die Typen der räumlichen Mathematik in deinem Verse-Code ändern, indem du das Modul der räumlichen Mathematik änderst, das du mit dem Schlüsselwort using importierst. Wenn du zum Beispiel den folgenden Code hast:

using { /UnrealEngine.com/Temporary/SpatialMath }
 
my_component := class<final_super>(component):
	@editable # This change will work regardless of this field being editable or not
	MyVector3:vector3 = vector3{}
	MyVector2:vector2 = vector2{}

Du kannst es ändern in:

using { /Verse.org/SpatialMath } # Changed the module path
 
my_component := class<final_super>(component):
	@editable # This change will work regardless of this field being editable or not
	MyVector:vector3 = vector3{} # All transform types now use /Verse.org/SpatialMath
	# MyVector2:vector2 = vector2{} Removed since /Verse.org/SpatialMath does not define a vector2

Die einzige Ausnahme ist, dass alle vector2-Typen entfernt oder konvertiert werden müssen, um vector3 zu verwenden, da das Modul /Verse.org den Typ vector2 derzeit nicht definiert.

Nicht übereinstimmender Funktionstyp

Ein weiteres Szenario, in dem du möglicherweise Typen per Pfad qualifizieren oder deinen Code konvertieren musst, ist wenn:

• Eine aufgerufene Funktion oder zugewiesene Variable erwartet einen Typ aus dem Modul /UnrealEngine.com, erhält aber einen Typ aus dem Modul /Verse.org.

• Eine aufgerufene Funktion oder zugewiesene Variable erwartet einen Typ aus dem Modul /Verse.org, erhält aber einen Typ aus dem Modul /UnrealEngine.com.

Beispiel für nicht übereinstimmende Funktionstypen

Die folgenden zwei Verse-Dateien existieren im selben Projekt. FileOne.verse definiert eine Funktion zum Drucken einer Transformation aus dem Modul /UnrealEngine.com/Temporary/SpatialMath . FileTwo.verse definiert eine konstante Transformation aus dem Modul /Verse.org/SpatialMath und eine Funktion zum Drucken dieses Werts, welche die Funktion von FileOne.verse aufruft.

using { /UnrealEngine.com/Temporary/SpatialMath }
 
PrintTransform(T:transform):void=
	Print("T: {T}")

using { /Verse.org/SpatialMath }
 
my_class := class:
	T:transform = transform{}
 
	DoPrint():void=
		PrintTransform(T)	# Compile error: This function parameter expects a value of type (/UnrealEngine.com/Temporary/SpatialMath:)transform, but this argument is an incompatible value of type (/Verse.org/SpatialMath:)transform.

Dies führt zu einem Kompilierungsfehler, da die Transformationstypen auf zwei verschiedene Typen verweisen, die in verschiedenen Modulen definiert sind.

Um diesen Kompilierungsfehler zu beheben, musst du den Transformationstyp aus dem entsprechenden Modul in den richtigen Transformationstyp konvertieren. Bearbeite den Code in FileTwo.verse, um die Funktion FromTransform zu verwenden, die eine Transformation von /Verse.org/SpatialMath in eine Transformation von /UnrealEngine.com/Temporary/SpatialMath umwandelt.

Eine vollständige Liste der verfügbaren Konvertierungsfunktionen findest du im nächsten Abschnitt.

# Include /UnrealEngine.com to access conversion functions
using { /UnrealEngine.com }
using { /Verse.org/SpatialMath }
 
my_class := class:
	T:transform = transform{}
 
	DoPrint():void=
		PrintTransform(Temporary.SpatialMath.FromTransform(T))  # Compile error fixed after converting transform to the correct type from the proper module

Vektor-, Drehungs- und Transformationstypkonvertierung

Das /UnrealEngine.com-Modul bietet mehrere neue Konvertierungsfunktionen, um zwischen den potenziell mehrdeutigen Typen zu konvertieren, die im /UnrealEngine.com-Modul und im /Verse.org-Modul definiert sind.

Von der räumlichen Mathematik der Unreal Engine zu der räumlichen Mathematik von Verse

# Util function for converting a `vector3` from /UnrealEngine.com/Temporary/SpatialMath to a `vector3` from /Verse.org/SpatialMath.
FromVector3<public>(InVector3:(/UnrealEngine.com/Temporary/SpatialMath:)vector3)<reads>:(/Verse.org/SpatialMath:)vector3

# Util function for converting a `rotation` from /UnrealEngine.com/Temporary/SpatialMath to a `rotation` from /Verse.org/SpatialMath
FromRotation<public>(InRotation:(/UnrealEngine.com/Temporary/SpatialMath:)rotation)<reads>:(/Verse.org/SpatialMath:)rotation

# Util function for converting a `transform` from /UnrealEngine.com/Temporary/SpatialMath to a `transform` from /Verse.org/SpatialMath.
FromTransform<public>(InTransform:(/UnrealEngine.com/Temporary/SpatialMath:)transform)<reads>:(/Verse.org/SpatialMath:)transform

Von der räumlichen Mathematik von Verse zur räumlichen Mathematik von Unreal Engine

# Util function for converting a `vector3` from /Verse.org/SpatialMath to a `vector3` from /UnrealEngine.com/Temporary/SpatialMath.
FromVector3<public>(InVector3:(/Verse.org/SpatialMath:)vector3)<reads>:(/UnrealEngine.com/Temporary/SpatialMath:)vector3

# Util function for converting a `rotation` from /Verse.org/SpatialMath to a `rotation` from /UnrealEngine.com/Temporary/SpatialMath.
FromRotation<public>(InRotation:(/Verse.org/SpatialMath:)rotation)<reads>:(/UnrealEngine.com/Temporary/SpatialMath:)rotation

# Util function for converting a `transform` from /Verse.org/SpatialMath to a `transform` from /UnrealEngine.com/Temporary/SpatialMath.
FromTransform<public>(InTransform:(/Verse.org/SpatialMath:)transform)<reads>:(/UnrealEngine.com/Temporary/SpatialMath:)transform

Verse räumliche math Operationen und Funktionen

Rechtshändigkeit

Alle Verse-Modulfunktionen der räumlichen Mathematik sind jetzt Rechtshändig Operationen. Daher wurden alle Funktionen mit expliziten Händigkeitsvarianten entfernt und durch Versionen ersetzt, die standardmäßig auf Rechtshändig Operationen setzen, und Händigkeitsindikatoren wurden aus Funktionsnamen entfernt. Alle Operationen, bei denen es eine Händigkeitswahl gibt, wie z. B. die Multiplikation eines vector3 mit einer Rotation oder die Multiplikation eines vector3 mit einem Transformieren, sind rechtshändige Operationen.

Zum Beispiel veranschaulicht der folgende Code, dass das Konstruieren einer Drehung von positiven 90 Grad um die Aufwärts-Achse und das Anwenden dieser Drehung auf einen Einheits-Vorwärtsvektor zu einem Einheits-Linksvektor führt:

ForwardToLeft:rotation = MakeRotationFromEulerDegrees(0.0, 90.0, 0.0)
ForwardVector:vector3 = vector3{Forward := 1.0}

ResultantVector:vector3 = ForwardVector * ForwardToLeft 	# Apply rotation on the right of the multiplication operator
Print("{ResultantVector}") # {Forward = 0.000000, Left = 1.000000, Up = 0.000000} = {Forward = 1.000000, Left = 0.000000, Up = 0.000000} * {Axis = {Forward = 0.000000, Left = 0.000000, Up = 1.000000}, Angle = 90.000000}

Reihenfolge der Transformieren- und Drehungsmultiplikation

Du kannst dir Drehungen so vorstellen, dass sie intern durch eine Matrix dargestellt werden. Wenn eine Drehung R auf einen Vektor v angewendet wird, werden sie in der Reihenfolge der Zeilenvektor-Multiplikation angewendet. Das heißt, der Vektor v ist ein Zeilenvektor, und wenn ein Vektor gedreht wird, wird rechts Multiplikation angewendet, um das Ergebnis v' = v * R zu erhalten. Hier ist der resultierende Vektor v' ein neuer Zeilenvektor. Dies funktioniert ähnlich, wenn man eine Transformation T auf einen Vektor v anwendet, v' = v * T, und der resultierende Vektor v' ist ein anderer Zeilenvektor.

Die Reihenfolge ist wichtig, wenn du Drehungen und Transformationen auf Vektoren anwendest. Halte ein Objekt, z. B. ein Buch, mit der Oberseite nach oben und der Vorderseite/dem Einschlag zu dir in der Hand. Das Anwenden einer Rechtshändigen, positiven 90-Grad-Drehung um die Vorwärtsachse führt dazu, dass die Oberseite des Buches nun nach rechts zeigt. Wenn du dann eine 90-Grad-Drehung um die Links-Achse anwendest, zeigt die Vorderseite des Telefons nach oben und die Oberseite des Buchs nach rechts.

Wende nun die gleichen Drehungen in umgekehrter Reihenfolge an. Wende eine 90-Grad-Drehung um die linke Achse an, sodass die Oberseite des Buchs nach vorne und die Vorderseite des Buchs nach oben zeigt. Wenn du dann eine 90-Grad-Drehung um die Vorwärts-Achse anwendest, zeigt die Oben des Buchs nach vorwärts, weiter und die Vorderseite des Buchs nach Rechts. Dies ist nicht die gleiche Ausrichtung wie das Anwenden der Drehungen in der anderen Reihenfolge, um zu veranschaulichen, dass die Reihenfolge der Drehungen wichtig ist.

Wenn du also zwei Drehungen R und R' auf einen Vektor v anwenden möchtest, musst du darauf achten, dass du sie in der gewünschten Reihenfolge anwendest. Wenn du die Drehung R vor der Drehung R' anwenden willst, ist die richtige Reihenfolge v' = v * R * R'.

Das gleiche Prinzip gilt für Drehungen selbst. Wenn du eine Drehung R hast und eine Pre-Drehung PreR auf R anwenden möchtest, die vor der Drehung R stattfindet, und eine Nachdrehung PostR, die nach der Drehung R stattfindet, geschieht dies in der Reihenfolge PreR * R * PostR. Wenn du entsprechend ein Pre-Transformieren-PreT und ein Post-Transformieren-PostT auf ein Transform-T anwenden möchtest, geschieht dies in der Reihenfolge PreT * T * PostT. Anschließend werden diese auf einen Vektor v angewendet, um einen neuen Vektor v' zu erhalten, wie oben, v' = v * PreR * R * PostR oder v' = v * PreT * T * PostT.

Die Assoziativität von Transformationen und Drehungen ist ebenfalls wichtig. Wenn du mehrere Operationen auf einem Vektor in derselben Zeile Verse-Code anwenden möchtest, z. B. eine Transformation, gefolgt von einer Drehung, ist die Zuordnung der Operationen von Bedeutung. Zum Beispiel könntest du versuchen:

ForwardVector:vector3 = vector3{Forward := 1.0}
ForwardToLeftUpOne:transform = transform:
    Translation := vector3{Up := 1.0}
    Rotation := MakeRotationFromEulerDegrees(0.0, 90.0, 0.0)
UpToForward:rotation = MakeRotationFromEulerDegrees(90.0, 0.0, 0.0)

ResultantVector:vector3 = ForwardVector * ForwardToLeftUpOne * UpToForward 	# compiles

Das lässt sich gut kompilieren, da es implizit Operationen zuordnet als:

ResultantVector:vector3 = (ForwardVector * ForwardToLeftUpOne) * UpToForward 	# compiles

Aber wenn du explizit versuchst, anders assoziiert als:

ResultantVector:vector3 = ForwardVector * (ForwardToLeftUpOne * UpToForward) 	# error, no operator'*'(:transform,:rotation)

Dies führt zu einem Fehler. Um diese Fehler zu vermeiden, verknüpfe deine erste Operation explizit zwischen einem Vektor und einer Transformation oder einem Vektor und einer Drehung.

ResultantVector:vector3 = (ForwardVector * ForwardToLeftUpOne) * UpToForward 	# explicitly associated

Änderungen der räumlichen math Operationen

Drehung und Rotationsmultiplikation

RotateBy und UnrotateBy werden entfernt und durch einen Multiplikationsoperator für zwei Drehungen ersetzt.

ForwardToLeft:rotation = MakeRotationFromEulerDegrees(0.0, 90.0, 0.0)
UpToForward:rotation = MakeRotationFromEulerDegrees(90.0, 0.0, 0.0)

UpToLeft:rotation = UpToForward * ForwardToLeft			# RotateBy, correcting for handedness

Um eine Drehung umzukehren („unrotate“), kehre zuerst die Drehung um und multipliziere dann die Drehungen. Um die UpToForward-Drehung von UpToLeft wiederherzustellen, invertierst du die ForwardToLeft-Drehung und wendest sie rechts auf die UpToLeft-Drehung an. Im Folgenden wird STEP für STEP gezeigt, wie das geht.

# The following comments show the steps involved to reach the desired result.
# This involves multiplication on the right by the inverse, associativity, existence and definition of inverse rotation, and existence and definition of identity rotation

# Pseudocode Steps:
# UpToLeft * ForwardToLeft.Invert() = (UpToForward * ForwardToLeft) * ForwardToLeft.Invert()		# multiply on the right by the same expression on both sides of the equality operator
# UpToLeft * ForwardToLeft.Invert() = UpToForward * (ForwardToLeft * ForwardToLeft.Invert())		# reassociate
# UpToLeft * ForwardToLeft.Invert() = UpToForward * IdentityRotation()					# rotation * inverse = identity
# UpToLeft * ForwardToLeft.Invert() = UpToForward								# rotation * identity = rotation

UpToForwardAgain:rotation = UpToLeft * ForwardToLeft.Invert()	# UnrotateBy, correcting for handedness

Vector3 und Rotationsmultiplikation

Auf ähnliche Weise werden Drehen und Unrotate entfernt und durch einen Multiplikationsoperator für einen vector3 ersetzt, der durch eine Rotation nach rechts gedreht wurde.

ForwardVector:vector3 = vector3{Forward:=1.0}
ForwardToLeft:rotation = MakeRotationFromEulerDegrees(0.0, 90.0, 0.0)

LeftVector:vector3 = ForwardVector * ForwardToLeft			# Rotate, correcting for handedness

Um eine Drehung umzukehren (unrotate), kehre zuerst die Drehung um und multipliziere dann die Drehung mit dem Vektor. Um den ForwardVector aus LeftVector zurück zu erhalten, invertiere die ForwardToLeft-Drehung und wende sie rechts auf den LeftVectoran

# The steps involved in achieving this calculation are very similar to the steps shown above for obtaining the correct expression for unrotating by a rotation

ForwardVectorAgain:vector3 = LeftVector * ForwardToLeft.Invert()	# Unrotate, correcting for handedness

Vector3 und Transformieren-Multiplikation

TransformVector und TransformVectorNoScale werden entfernt und durch einen Multiplikationsoperator für einen vector3 ersetzt, der rechts durch ein Transformieren transformiert wird.

DoubleLengthForwardToLeftTranslateUp := transform:
    Translation := vector3{Left := 0.0, Up := 1.0, Forward := 0.0}
    Rotation := MakeRotationFromEulerDegrees(0.0, 90.0, 0.0)
    Scale := vector3{Left := 2.0, Up := 2.0, Forward := 2.0}

ForwardVector:vector3 = vector3{Forward:=1.0}

ResultantVector:vector3 = ForwardVector * DoubleLengthForwardToLeftTranslateUp		# TransformVector

Um eine Transformieren ohne Skalierung (TransformVectorNoScale) durchzuführen, belasse den Standard-Maßstab auf der von Ihnen konstruierten Transformieren.

ForwardToLeftTranslateUpNoScale := transform:
    Translation := vector3{Left := 0.0, Up := 1.0, Forward := 0.0}
    Rotation := MakeRotationFromEulerDegrees(0.0, 90.0, 0.0)

ForwardVector:vector3 = vector3{Forward:=1.0}

ResultantVector:vector3 = ForwardVector * ForwardToLeftTranslateUpNoScale			# TransformVectorNoScale