La transformación de una entidad de Scene Graph define la traslación (ubicación), la rotación (orientación) y la escala (tamaño) de una entidad. Para transformar una entidad de Scene Graph, la entidad debe tener un transform_component. transform_component contiene dos campos que puedes manipular mediante UEFN o código Verse:
Origin: origen opcional a partir del cual se calcula LocalTransform.
LocalTransform: una
(/Verse.org/SpatialMath:)transformrelativa al padre de la entidad, o al origen si el campo opcional Origin está definido.
El origen de una entidad es la entidad a partir de la cual se calcula LocalTransform de transform_component de una entidad. Este es el valor del campo Origin si este está establecido en transform_component, o el padre 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 el módulo /Verse.org/SpatialMath que almacena las siguientes cantidades en el sistema de coordenadas Izquierda-Arriba-Delante (LUF):
Traslación (
vector3): la ubicación de un objeto.Rotación (
rotation): la orientación del objeto.Escala (
vector3): el tamaño del objeto.
transform_component es una clase de Verse definida 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 transform_component como un contenedor suministrado a una entidad para una transformación que define su lugar en la simulación.
Transformaciones de Verse
Scene Graph usa transformaciones del módulo /Verse.org/SpatialMath . Las transformaciones del módulo de Verse utilizan el sistema de coordenadas LUF diestro. Para construir una transformación de Verse, puedes utilizar el arquetipo de la 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 Izquierda-Arriba-Delante. 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.
Cómo construir una entidad con un transform_component
Puedes construir una entidad en el esquematizador de UEFN o a través de Verse.
En UEFN
Puedes añadir rápidamente una entidad de Scene Graph a tu proyecto a través del menú Colocar actores.
Cuando añades 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 desde la entidad colocada recientemente en el panel del esquematizador, buscando componente transform_component y seleccionando Eliminar componente.
A continuación puedes ver que la entidad en cuestión ya no tiene un transform_component.
En Verse
Cuando creas una entidad de Scene Graph mediante 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 añadir un transform_component a tu entidad. Los métodos preferidos para trabajar con transformaciones son SetLocalTransform y SetGlobalTransform. Estas funciones se encargan de crear el transform_component, establecer los valores y añadir el componente de transformación 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 explican métodos adicionales para añadir un transform_component a una entidad de Scene Graph mediante código Verse.
Cómo se calcula la transformación de una entidad
La operación más importante que puedes realizar en una entidad de Scene Graph con transform_component es obtener o establecer la transformación de una entidad.
Hay dos tipos de transformación que pueden interesarte: la transformación local y la transformación global. Para manipular eficazmente la transformación de una entidad, es importante comprender cómo se calculan estas transformaciones.
La transformación local es la transformación 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 la transformación de una entidad con:
La transformación global del padre de la entidad si el campo Origin no está establecido en el transform_component de la entidad, o
La transformación global del origen de la entidad si el campo Origin está establecido en el componente transform_component de la entidad.
A continuación se muestra un ejemplo de esto utilizando la traslación sin rotación ni cambio de escala, de modo que las transformaciones resultantes puedan calcularse sumando traslaciones. Como este ejemplo supone que la rotación y la escala se dejan como sus respectivas identidades en todas las transformaciones, se utiliza una abreviatura para referirse a la transformación de una entidad mediante el vector de traslación de transformación de la entidad.
Considera tres entidades de Scene Graph organizadas del siguiente modo:
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 de una escena en la que BaseEntity no tiene mesh_component, A es un cubo y B es un cono:
Por ejemplo, supongamos que quieres determinar tanto la transformación local como la transformación global de la entidad B. La transformación local es fácil de ver: es el valor del campo LocalTransform de la entidad B, como puede verse 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 entidad de simulación y compondrías las transformaciones empezando en la entidad de simulación y luego descendiendo 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 hijos.
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 entidad de simulación: (0.0, 0.0, 0.0).
BaseEntity es una entidad secundaria de la entidad de simulación. BaseEntity tiene una transformación local de (0.0, 0.0, 0.0), como se ve en la Imagen 1.0. La composición de la transformación global de la entidad de simulación con la transformación local de BaseEntity produce:
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 hijo 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. La composición de la transformación global de BaseEntity con la transformación local de la entidad A produce:
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 hijo 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. La composición de la transformación global de A con la transformación local de la entidad B produce:
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
Utilizando LocalTransform y Origin puedes transformar una entidad.
Transformación local
El campo LocalTransform del transform_component de una entidad es (/Verse.org/SpatialMath:)transform de una entidad con respecto a su origen. Si el campo Origin no se establece explícitamente, el origen de una entidad toma por defecto a 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: posición relativa a su origen padre o definido manualmente.
Cambia la traslación de una entidad para moverla por el nivel.
Rotación: orientación relativa a su padre o al origen definido manualmente.
Cambia la rotación de una entidad para girarla alrededor del punto de traslación de la entidad.
Escala: tamaño relativo a su origen padre o definido manualmente.
Cambia la escala de una entidad para hacerla más grande o más pequeña.
Origen
El origen de transform_component de una entidad es el objeto con respecto al cual se calcula LocalTransform. Este campo de transform_component es opcional. De forma predeterminada, LocalTransform de transform_component es la transformación de la entidad basada en el origen de la entidad, calculada con respecto a la entidad padre de la entidad propietaria. Opcionalmente, puedes establecer el campo Origin en transform_component de una entidad para calcular LocalTransform con respecto a un objeto que no sea el padre de la entidad.
Por ejemplo, puedes establecer 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 concreto, para establecer el campo Origin en otra entidad de Scene Graph, elige la clase entity_origin y, a continuación, selecciona la entidad que quieres 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 del espacio del mundo con traslación (0.0, 0.0, 0.0).
El origen de transform_component de una entidad es la posición en la que se encuentra una entidad si LocalTransform de transform_component de la entidad tiene traslación (0.0, 0.0, 0.0).
A continuación se muestra un ejemplo de cómo funcionan en la práctica los campos Origin y LocalTransform. Considera una BaseEntity situada en el origen del espacio del mundo con la entidad hijo A representada por el mesh_component del cubo, y la entidad hijo B representada por el mesh_component del cono.
Como se puede ver en la imagen anterior, BaseEntity se encuentra en el origen del espacio del mundo ya que su campo Origin está sin definir en transform_component y LocalTransform está establecido en el origen del espacio del mundo.
Como se muestra a continuación, puedes ver que el campo Origin de la entidad A también está sin definir, por lo que LocalTransform se calcula con respecto al transform_component de su padre, BaseEntity.
Como BaseEntity se encuentra en el origen del espacio del mundo y la traslación de LocalTransform de la entidad A está establecida en vector3{Left := 750.0, Up := 100.0, Forward := 0.0}, la entidad A se encuentra 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 siguiente, puedes ver que la entidad B, que también es hijo de BaseEntity, tiene su campo Origin en su transform_component establecido como entidad A.
Como resultado, el campo B LocalTransform de la entidad en su transform_component es relativo a la transformación calculada de la entidad A. Como LocalTransform de la entidad B está establecido en vector3{Left := -250.0, Up := 100.0, Forward := 0.0} y 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 rotación del campo LocalTransform del transform_component de la entidad A a -90.0 grados sobre el eje Delante, la entidad B también rota -90.0 grados sobre ese eje. Esto se debe a que la rotación de un hijo también se hereda del padre.
Cómo trabajar con transform_component en Verse
Puedes comprobar 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.
Transform
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 de establecer la transformación en una entidad de Scene Graph en código Verse. Estos métodos establecen explícitamente la transformación local (respecto al padre de la entidad) o global (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 añade a la entidad. Después de cualquiera de estas llamadas a función, la entidad ahora tiene un transform_component. Puedes confirmarlo 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
Utilizando métodos de extensión, puedes obtener la transformación local o la transformación global del transform_component asociado a una entidad. GetLocalTransform devuelve la transformación de una entidad con respecto a su entidad padre o al campo Origin especificado, si está establecido. Si la entidad no tiene 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 mundo. Si la entidad no tiene transform_component, esta función devuelve la transformación global del ancestro más cercano con 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 utilizar métodos de extensión de entidad para operaciones que impliquen el campo Origin de transform_component. Puedes establecer directamente el campo Origin 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 Origin y, si lo tiene, devuelve el valor de ese campo. Si no, la llamada falla. Si todo va bien, el tipo de retorno 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 Origin alternativo está establecido en una entidad y determinar qué entidad está establecida como 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 Origin del transform_component de una entidad con ResetOrigin.
MyEntity.ResetOrigin()Después de llamar a ResetOrigin, el campo Origin del transform_component de MyEntity se restablece y la transformación de MyEntity se calcula ahora con respecto a la entidad padre 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:
light_component y sus clases hijo
mesh_component
particle_system_component
Si añades alguno de estos componentes a una entidad de Scene Graph que no tenga ya un transform_component, este se añade a la entidad por defecto.
Nota sobre las transformaciones XYZ
Las transformaciones que utilizan el sistema de coordenadas XYZ siguen existiendo en el módulo /UnrealEngine.com/Temporary/SpatialMath de Verse. Los dispositivos y elementos del modo Creativo siguen utilizando estas transformaciones en el módulo /Fortnite.com de Verse. Para más información sobre el estado de estas transformaciones y la conversión entre distintos tipos de transformación en Verse, consulta la página Sistema de coordenadas Izquierda-Arriba-Delante.