La transformar de una Entidad de Scene Graph definir la traslación (ubicación), rotación (orientación), y escala (tamaño) de una Entidad. Para transformar una entidad de Scene Graph, la entidad debe tener un transform_component. El transform_component contiene dos campos que puedes manipular a través de código de UEFN o Verse:
Origin: un origen opcional a partir del cual se calcula LocalTransform.
LocalTransform: una
(/Verse.org/SpatialMath:)transformrelativa al elemento primario de la entidad o al origen si el campo de origen opcional está establecido.
El origen de una entidad es la entidad a partir de la cual se calcula el LocalTransform del transform_component de una entidad. Este es el valor del campo Origen si se define el campo Origen en transform_component, o el elemento primario de la Entidad en la jerarquía de Scene Graph si el campo Origen no está definido.
Es importante distinguir entre una transformación y el transform_component. Una transformación es un tipo de datos compuesto definido en el /Verse.org/SpatialMath módulo que almacena las siguientes cantidades en el sistema de coordenadas Left-Up-Forward (LUF):
Traslación (
vector3): la ubicación de un objeto.Rotation (
rotation): la orientación del objeto.Scale (
vector3): el tamaño del objeto.
El transform_component es una clase de Verse que se define en el módulo /Verse.org/SceneGraph que almacena el LocalTransform de una Entidad de Scene Graph y, opcionalmente, un origen alternativo. Puedes pensar en el transform_component como un contenedor suministrado a una Entidad para una transformar que define su lugar en la simulación.
Transformaciones de Verse
Scene Graph usa transformaciones de módulo de /Verse.org/SpatialMath Las transformaciones del módulo de Verse utilizan el sistema de coordenadas LUF. Para construir una transformación de Verse, puedes utilizar el arquetipo de clase y los métodos integrados para crear rotaciones.
# 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}
Para obtener más información sobre el sistema de coordenadas en UEFN, consulta la página Sistema de coordenadas de Left-Up-Forward. Esto también incluye información sobre la conversión entre la transformación XYZ en el módulo /UnrealEngine.com/Temporary/SpatialMath y la transformación del módulo de Verse.
Construye una Entidad con un transform_component
Puedes construir una entidad en el esquematizador de UEFN o a través de Verse.
En UEFN
Puedes agregar rápidamente una entidad de Scene Graph a tu proyecto a través del menú Colocar actores .
Cuando agregas una entidad de Scene Graph a tu proyecto a través del menú Colocar actores, la entidad está equipada con un transform_component por defecto.
Si quieres, puedes eliminar el componente transform_component desplazándote hasta la Entidad colocada recientemente en el panel esquematizador, buscando el componente transform_component y seleccionando Eliminar componente.
Puedes ver a continuación que la entidad en cuestión ya no tiene un transform_component.
En Verse
Cuando creas una entidad de Scene Graph a través de código Verse con el arquetipo de clase:
MyEntity:entity = entity{}La entidad no está equipada con un transform_component. En su lugar, se debe agregar un transform_component a tu entidad. Los métodos preferidos para trabajar con transformaciones son SetLocalTransform y SetGlobalTransform. Estas funciones manejan la creación del componente transformar, el establecimiento de los valores y la adición del componente transformar a la Entidad al mismo tiempo.
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)
También puedes añadir el componente directamente con AddComponents:
# 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}En la sección Cómo trabajar con transform_component en Verse, se analizan métodos adicionales para añadir un transform_component a una entidad de Scene Graph mediante código de Verse.
Cómo se calcula la transformar de una Entidad
La operación más importante que puedes realizar en una Entidad de Scene Graph con transform_component es obtener o definir la transformar de una Entidad.
Hay dos tipos de transformar que te pueden interesar: la transformar local y la transformar global. Para manipular eficazmente la transformar de una Entidad, es importante comprender cómo se calculan estas transformar.
La transformación local es la transformar con respecto al origen de una Entidad. La transformación local de cualquier Entidad de Scene Graph es el valor del campo local en el transform_component de una Entidad de Scene Graph.
La transformación global es la transformación con respecto al origen del sistema de coordenadas LUF en el espacio global. La transformación global de una Entidad de Scene Graph se calcula al componer el LocalTransform de una Entidad con lo siguiente:
La transformar global del elemento base de la Entidad si el campo Origen no está definir en el transform_component de la Entidad, o
La transformar global del origen de la Entidad si el campo Origen está definir en el transform_component de la Entidad.
Lo siguiente funciona a través de un ejemplo de esto usando la traslación sin rotación ni escalado para que las transformaciones resultantes puedan calcularse sumando traslaciones. Como en este ejemplo se supone que la rotación y la escala se dejan como sus respectivas identidades en todas las transformaciones, se utiliza una taquigrafía para referirnos a la transformación de una Entidad mediante el vector de traslación de la transformación de la Entidad.
Considera tres entidades de Scene Graph organizadas de la siguiente manera:
BaseEntity: LocalTransform (0.0, 0.0, 0.0) en el sistema de coordenadas LUF.
A: LocalTransform (750.0, 100.0, 0.0)
B: LocalTransform (-250.0, 100.0, 0.0)
A continuación se muestran las tres entidades en una escena donde BaseEntity no tiene mesh_component, A es un cubo y B es un cono:
Por ejemplo, supongamos que deseas determinar tanto la transformación local como la transformación global de la Entidad B. La transformación local es rápida de ver: es el valor del campo local del componente transformar de la entidad B como se ve a continuación:
La transformación local de la Entidad B es (-250.0, 100.0, 0.0).
Para calcular la transformación global de la Entidad B, rastrearías la jerarquía de la Entidad B hasta la simulation entity y compondrías las transformaciones comenzando en la simulation entity y luego bajando hasta la Entidad B. La entidad de simulación es la raíz de la simulación actual bajo la cual todas las demás entidades de simulación son derivadas.
Estos son los pasos para calcular la transformación global de la entidad B:
La entidad de simulación es la raíz de la simulación actual.
Transformación global de la entidad de simulación: (0.0, 0.0, 0.0).
El BaseEntity es un elemento derivado de la entidad de simulación. La entidad base tiene una transformación local de (0.0, 0.0, 0.0) como se ve en la Imagen 1.0. Compuesto la transformación global de la entidad de simulación con la transformación local de BaseEntity se obtiene:
Transformación global de BaseEntity: (0.0, 0.0, 0.0) + (0.0, 0.0, 0.0) = (0.0, 0.0, 0.0).
La Entidad A es un elemento secundario de BaseEntity. La Entidad A tiene una transformación local de (750.0, 100.0, 0.0) como se ve en la Imagen 1.1. Al componer la transformación global de BaseEntity con la transformar de ubicación de la Entidad A se obtiene lo siguiente:
Transformación global de la Entidad A: (0.0, 0.0, 0.0) + (750.0, 100.0, 0.0) = (750.0, 100.0, 0.0).
La entidad B es un elemento secundario de la entidad A. La Entidad B tiene una transformación local de (-250.0, 100.0, 0.0) como se ve en la Imagen 1.2. Al componer la transformación global de A con la transformación de ubicación de la Entidad B se obtiene lo siguiente:
Transformación global de la Entidad B: (750.0, 100.0, 0.0) + (-250.0, 100.0, 0.0) = (500.0, 200.0, 0.0).
Por lo tanto, la transformación global de la Entidad B es (500.0, 200.0, 0.0) en el sistema de coordenadas LUF.
Cómo trabajar con transform_component en el Editor
Al utilizar LocalTransform y Origin, puedes transformar una Entidad.
Transformación local
El campo LocalTransform del transform_component de una entidad es la (/Verse.org/SpatialMath:)transform de una entidad con respecto a su origen. Si el campo Origen no se define explícitamente, el Origen de una Entidad se establece de forma predeterminada en su padre en la jerarquía de Scene Graph. El campo LocalTransform es un campo editable que aparece en UEFN donde se edita directamente una entidad:
Traslación: ubicación relativa a su origen principal o definido manualmente.
Cambia la traslación de una entidad para moverla por el nivel.
Rotación: Orientación relativa a su origen principal o definido manualmente.
Cambia la rotación de una entidad para rotarla alrededor del punto de pivote de la entidad.
Escala: Tamaño relativo a su origen principal o escala definida manualmente.
Cambia la escala de una entidad para hacerla más grande o más pequeña.
Origen
El origen del transform_component de una entidad es el objeto con respecto al cual se calcula LocalTransform. Este campo en transform_component es opcional. De forma predeterminada, la LocalTransform del transform_component es la transformar de la Entidad basada en el origen de la Entidad, calculada con respecto a la parent entity de la Entidad propietaria. Opcionalmente, puedes definir el campo Origen en el transform_component de una Entidad para calcular el LocalTransform con respecto a un objeto que no sea el elemento primario de la Entidad.
Por ejemplo, puedes definir que el Origen de una Entidad sea una Entidad completamente diferente. Puedes establecer este campo con cualquier clase que implemente la interfaz de origen de Verse. En particular, para definir el campo Origen en otra Entidad de Scene Graph, elige la clase entidad_origin y, luego, selecciona la Entidad que deseas que sea el nuevo origen.
Es importante eliminar la ambigüedad entre el origen con respecto a transform_component y el origen del sistema de coordenadas LUF. El origen del sistema de coordenadas LUF es el punto en el espacio en el entorno con Traslación (0.0, 0.0, 0.0).
El origen del transform_component de una entidad es la ubicación en la que se encuentra una entidad si el transform_component de la entidad LocalTransform tiene Traslación (0.0, 0.0, 0.0).
A continuación, se muestra un ejemplo de cómo funcionan en la práctica el campo Origen y LocalTransform. Considera una BaseEntity ubicada en el origen del espacio en el entorno con la Entidad derivada A representada por el mesh_component de cubo y la Entidad derivada B representada por el mesh_component de cono.
Como se puede ver en la imagen anterior, BaseEntity se encuentra en el origen del espacio en el entorno ya que su campo Origin está unset en el transform_component y LocalTransform está definir en el origen del espacio en el entorno.
Como se muestra a continuación, puedes ver que el campo Origin de la Entidad A también está unset, por lo que LocalTransform se calcula con respecto al transform_component de su base, BaseEntity.
Como BaseEntity está ubicada en el origen del espacio del entorno y la traducción de LocalTransform de la entidad A está establecida en vector3{Left := 750.0, Up := 100.0, Forward := 0.0}, la entidad A está ubicada en vector3{Left := 750.0, Up := 100.0, Forward := 0.0}. La Rotación y la Escala de la entidad A permanecen sin cambios, ya que la Rotación y la Escala de LocalTransform en BaseEntity son las identidades respectivas.
En la imagen a continuación, puedes ver que la Entidad B, que también es un elemento derivado de BaseEntity, tiene su campo de origen en su transform_component definido como Entidad A.
Como resultado, el campo LocalTransform de la entidad B en su transform_component es relativo a la transformación calculada de la entidad A. Dado que el LocalTransform de la entidad B está establecido en vector3{Left := -250.0, Up := 100.0, Forward := 0.0} y el LocalTransform de la entidad A está establecido en vector3{Left := 750.0, Up := 100.0, Forward := 0.0}, la transformación global de la entidad B es vector3{Left := 500.0, Up := 200.0, Forward := 0.0}.
Si cambias el componente Rotation del campo LocalTransform del transform_component de la entidad A a -90.0 grados sobre el eje de avance, la entidad B también rota -90.0 grados sobre el eje de avance. Esto se debe a que la rotación de un derivado también se hereda del primario.
Cómo trabajar con transform_component en Verse
Puedes verificar si una entidad tiene un transform_component con GetComponent:
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[]):
En lugar de recuperar transform_component con GetComponent y trabajar directamente con transform_component, la forma recomendada de interactuar con transform_component es a través de los métodos de extensión de entidad.
Transformar
Puedes establecer directamente la transformación local o global de tu entidad con los métodos de extensión de entidad SetLocalTransform o SetGlobalTransform.
MyEntity:entity = entity{}
MyTransform:transform = transform{}
if (SimEntity := Entity.GetSimulationEntity[]):
SimEntity.AddEntities(array{MyEntity})
# Set the local transform
MyEntity.SetLocalTransform(MyTransform)
MyOtherEntity:entity = entity{}
Estos métodos de extensión son la forma preferida para definir la transformación en una Entidad de Scene Graph en código de Verse. Estos métodos definen explícitamente la transformar local (con respecto al padre de la Entidad) o global (con respecto al origen del mundo) de la Entidad en cuestión. Si la entidad no tiene un transform_component cuando se llama a cualquiera de estas funciones, se crea implícitamente un transform_component y se agrega a la entidad. Después de cualquiera de estas llamadas a función, la Entidad ahora tiene un transform_component. Puedes confirmar esto con una llamada posterior a GetComponent.
if (MyEntity.GetComponent[transform_component]):
# success, entity has a transform_component
else:
# failure, entity does not have a transform_component
Usando métodos de extensión, puedes obtener la transformación local o la transformación global del componente transformar asociado de una Entidad. GetLocalTransform devuelve la transformación de una entidad con respecto a su entidad base o al campo de origen especificado, si está establecido. Si la entidad no tiene un transform_component, esta función devuelve la transformación de identidad.
# 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 devuelve la transformación de una entidad con respecto al origen del entorno. Si la entidad no tiene un transform_component, esta función devuelve la transformación global del ancestro más cercano con un transform_component.
# 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
Origen
También puedes usar métodos de extensión de entidad para operaciones que involucren el campo de origen transform_component. Puedes definir directamente el campo Origen del transform_component de tu Entidad con el método de extensión de Entidad SetOrigin.
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}
Para obtener el origen de una entidad en código Verse, utiliza 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 decide si una entidad tiene establecido su campo Origen y, si lo tiene, devuelve el valor de ese campo. De lo contrario, el llamado falla. En caso de éxito, el tipo devuelto de GetOrigin es un objeto de origen, una clase de Verse que implementa la interfaz de origen. Esta interfaz proporciona una única función GetTransform para obtener la transformación del origen especificado de la Entidad. También puedes comprobar si el campo Origen alternativo está definido en una Entidad y determinar qué Entidad está definida como el origen de tu Entidad.
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()
Por último, puedes restablecer el campo Origen del transform_component de una entidad con ResetOrigin.
MyEntity.ResetOrigin()Después de llamar a ResetOrigin, el campo de origen de transform_component de MyEntity se restablece y la transformación de MyEntity ahora se calcula con respecto a la parent entity de MyEntity en la jerarquía de Scene Graph.
Componentes dependientes
Algunos otros componentes de Scene Graph dependen de transform_component para funcionar. Esto incluye lo siguiente:
light_component y sus clases derivadas
mesh_component
particle_system_component
Si agregas alguno de estos componentes a una entidad de Scene Graph que aún no tiene un transform_component, el transform_component se agrega a la entidad de manera predeterminada.
Nota sobre las transformaciones XYZ
Las transformaciones que utilizan el sistema de coordenadas XYZ todavía existen en el módulo de Verse /UnrealEngine.com/Temporary/SpatialMath. Las utilerías y los dispositivos del modo Creativo todavía utilizan estas transformaciones en el módulo de Verse /Fortnite.com. Para obtener más información sobre el estado de estas transformaciones y la conversión entre diferentes tipos de transformación en Verse, consulta la página Sistema de coordenadas Left-Up-Forward.