`ViewportCamera` es una `Class.Camera` destinada a cámaras que configuras en
tiempo de diseño, como una cámara asignada a `Class.ViewportFrame.CurrentCamera`
o un `ThumbnailCamera` dentro de un `Class.Model`. Tiene las mismas propiedades,
metodos y eventos que `Class.Camera`, pero a diferencia de `Class.Camera`, se
replica, por lo que funciona como se espera en Team Create y cuando se replica desde
el servidor a los clientes.

Usa una `Class.Camera` para la cámara que renderiza el mundo 3D, accesible
a través de `Class.Workspace.CurrentCamera`. Usa un `ViewportCamera` para cualquier otra
cámara que crees y quieras guardar con el lugar.

#### Comportamiento de Autoupgrade

Cuando pegas contenido copiado que contiene una `Class.Camera` en Studio, cualquier
`Class.Camera` se convierte automáticamente en un `ViewportCamera` con las
mismas propiedades. Esto es para facilitar el flujo de trabajo común de configurar una
cámara posicionando la cámara principal del espacio de trabajo y luego copiando y pegando esa
cámara.


ViewportCamera

Una `Class.Camera` que se replica y se guarda como contenido creado, para su uso
con `Class.ViewportFrame|ViewportFrames` o como un ThumbnailCamera.


El objeto `Camera` define una vista del mundo 3D. En una experiencia en ejecución,
cada cliente tiene su propio objeto `Camera` que reside en el `Class.Workspace` local de ese cliente,
accesible a través de la propiedad `Class.Workspace.CurrentCamera`.

Las propiedades más importantes de la cámara son:

- `Class.Camera.CFrame|CFrame` que representa la posición y orientación
de la cámara.

- `Class.Camera.CameraType|CameraType` que es leído por los scripts de
cámara de la experiencia y determina cómo debe actualizarse la cámara en cada fotograma.

- `Class.Camera.CameraSubject|CameraSubject` que es leído por los scripts de
cámara de la experiencia y determina qué objeto debe seguir la cámara.

- `Class.Camera.FieldOfView|FieldOfView` que representa la extensión visible
del mundo observable.

- `Class.Camera.Focus|Focus` que representa el punto al que la cámara está mirando.
Es importante que esta propiedad esté configurada, ya que ciertos elementos visuales serán más
detallados y se actualizarán con más frecuencia dependiendo de cuán cerca estén del
punto de enfoque.

Consulta [Personalizando la Cámara](/workspace/camera) para más
información sobre cómo ajustar y personalizar el comportamiento de la cámara.

#### Almacenando Múltiples Cámaras

Ten en cuenta que al cambiar `Class.Workspace.CurrentCamera` a una nueva
`Class.Camera`, todas las demás `Class.Camera|Cameras` que descienden directamente de
`Class.Workspace` serán destruidas. Si necesitas almacenar múltiples cámaras y
cambiar entre ellas bajo demanda, se recomienda que las almacenes en una
`Class.Folder` o `Class.Model` bajo `Class.Workspace`, dentro de las cuales permanecerán incluso cuando
`Class.Workspace.CurrentCamera|CurrentCamera` sea cambiado.


Este evento se activa cuando la `Class.Camera` ha terminado de interpolarse usando
el método `Class.Camera:Interpolate()`. No se activará si un tween es
interrumpido debido a que se llama nuevamente a `Class.Camera:Interpolate()`.

Se recomienda usar `Class.TweenService` para animar la `Class.Camera`
en su lugar, ya que es más confiable y proporciona más opciones para estilos de easing.


Camera.InterpolationFinished

Se activa cuando la `Class.Camera` ha terminado de interpolarse
usando `Class.Camera:Interpolate()|Interpolate()`.


Este método es utilizado por `PopperCam` en los scripts de cámara predeterminados para asegurar
que no haya obstrucciones entre la `Class.Camera` y su sujeto.

Este método verificará todos los `Class.BasePart|BaseParts` y `Class.Terrain`
en el `Class.Workspace` con las siguientes excepciones:

- Cualquier `Class.Instance` especificada en la `ignoreList` (incluyendo sus
  descendientes) será ignorada
- `Class.BasePart|BaseParts` con `Class.BasePart.CanCollide` establecido en falso
  son ignorados
- `Class.BasePart|BaseParts` con una `Class.BasePart.Transparency` mayor
  que 0.95 serán ignorados. El agua `Class.Terrain` es ignorada.

Ten en cuenta que, como este método requiere una `ignoreList` para ejecutarse, deberías pasar una
tabla vacía cuando no se requiera ninguna.


Camera:GetLargestCutoffDistance

ignoreList

Un array de `Class.Instance|Instances` a ignorar. Los descendientes de estos
instancias también serán ignorados.


La distancia, en studs, que la `Class.Camera` necesita ser empujada
hacia su `Class.Camera.Focus|Focus` para asegurar que no hay
obstrucciones entre el `Class.Camera.Focus|Focus` y
`Class.Camera.CFrame|CFrame` de la `Class.Camera`.


Devuelve cuánto necesita ser empujada la `Class.Camera` hacia su
`Class.Camera.Focus|Focus` para asegurarse de que no haya obstrucciones
entre el `Class.Camera.Focus|Focus` y `Class.Camera.CFrame|CFrame`.


Este método está roto y no debe ser utilizado.

Este método devuelve la velocidad actual de paneo de la `Class.Camera`.

La velocidad de paneo de la `Class.Camera` describe la velocidad a la que la
`Class.Camera` está rotando alrededor de su `Class.Camera.Focus|Focus` alrededor del eje **Y**.


Camera:GetPanSpeed

La velocidad a la que la `Class.Camera` está rotando alrededor de su
`Class.Camera.Focus|Focus` en el eje **Y**.


Devuelve la velocidad actual de 'paneo' de la `Class.Camera`.


Este método devuelve un array de `Class.BasePart|BaseParts` que están
obstruyendo las líneas de visión entre el `Class.Camera.CFrame|CFrame` de la cámara y las
posiciones `Datatype.Vector3` en el array `castPoints`. Cualquier `Class.Instance|Instances`
incluida en el array `ignoreList` será ignorada, junto con sus descendientes.

El parámetro `castPoints` se da como un array de posiciones `Datatype.Vector3`.
Ten en cuenta que el array de `Class.BasePart|BaseParts` devuelto está
en un orden arbitrario, y no se proporciona información adicional de raycast. Si necesitas
datos como la posición de impacto, material de impacto o normal de superficie, deberías optar por el método
`Class.WorldRoot:Raycast()`.

```lua
local camera = workspace.CurrentCamera

local castPoints = {
	Vector3.new(0, 10, 0),
	Vector3.new(0, 15, 0)
}
local ignoreList = {}

local partsObscuringTarget = camera:GetPartsObscuringTarget(castPoints, ignoreList)
```
Si `Class.Terrain` obstruye un punto de lanzamiento, los `Class.BasePart|BaseParts`
que obstruyen el punto de lanzamiento entre el `Class.Terrain` que obstruye y el
punto de lanzamiento no serán devueltos.


Camera:GetPartsObscuringTarget

castPoints

Un array de posiciones `Datatype.Vector3` de puntos de lanzamiento.


Un array de `Class.Instance|Instances` que deben ser ignorados, junto
con sus descendientes.


Un array de `Class.BasePart|BaseParts` que obstruyen las líneas de visión
entre el `Class.Camera.CFrame|CFrame` de la cámara y los
`castPoints`.


Devuelve un array de `Class.BasePart|BaseParts` que están obstruyendo las
líneas de visión entre el `Class.Camera.CFrame|CFrame` de la cámara y los
puntos de lanzamiento.


Este método devuelve el `Datatype.CFrame` real de la `Class.Camera` a
medida que se renderiza, incluyendo el impacto de VR (las transformaciones de la cabeza de VR no se aplican a la propiedad `Class.Camera.CFrame|CFrame`, por lo que es mejor
práctica usar `Class.Camera:GetRenderCFrame()|GetRenderCFrame()` para
obtener el "verdadero" `Datatype.CFrame` de la vista de un jugador).

Por ejemplo, al usar VR, la `Class.Camera` se renderiza realmente en el
siguiente `Datatype.CFrame`:

```lua
local UserInputService = game:GetService("UserInputService")

local camera = workspace.CurrentCamera

local headCFrame = UserInputService:GetUserCFrame(Enum.UserCFrame.Head)
headCFrame = headCFrame.Rotation + headCFrame.Position * camera.HeadScale
renderCFrame = camera.CFrame * headCFrame
```
El `Datatype.CFrame` de renderizado de la cámara solo se cambiará para tener en cuenta
la cabeza cuando la propiedad `Class.Camera.HeadLocked|HeadLocked` sea verdadera.


Camera:GetRenderCFrame

El `Datatype.CFrame` en el que se está renderizando la `Class.Camera`.


Devuelve el `Datatype.CFrame` real donde la `Class.Camera` está siendo
renderizada, teniendo en cuenta cualquier rotación aplicada y el impacto de los dispositivos de VR.


Este ejemplo, cuando se utiliza en un `Class.LocalScript`, recuperará el rollo actual
de la cámara en grados. Luego, si el ángulo de rollo de la cámara no es 20
grados, el ángulo de rollo de la cámara se establece en 20 grados.

Este método devuelve, en radianes, la rotación actual aplicada a la
`Class.Camera` usando `Class.Camera:SetRoll()|SetRoll()`. La rotación se define
como rotación alrededor del eje Z de la cámara.

Este método solo devuelve la rotación aplicada usando el
`Class.Camera:SetRoll()|SetRoll()` método. La rotación aplicada manualmente a la
propiedad `Class.Camera.CFrame|CFrame` no se tiene en cuenta. Para obtener la
rotación real de la `Class.Camera`, incluyendo la rotación aplicada manualmente, puedes usar el siguiente fragmento:


Camera:GetRoll

La rotación actual aplicada por `Class.Camera:SetRoll()|SetRoll()`, en
radianes.


Devuelve en radianes la rotación actual, o rotación alrededor del eje Z de la cámara,
aplicada a la `Class.Camera` usando
`Class.Camera:SetRoll()|SetRoll()`.


Este método está roto y no debe ser utilizado.

Este método devuelve la velocidad actual de inclinación de la `Class.Camera`.

La velocidad de inclinación de la `Class.Camera` describe la velocidad a la que la
`Class.Camera` está rotando alrededor de su `Class.Camera.Focus|Focus` alrededor del eje **X** de la cámara.


Camera:GetTiltSpeed

La velocidad a la que la `Class.Camera` está rotando alrededor de su
`Class.Camera.Focus|Focus` alrededor del eje **X** de la cámara.


Devuelve la velocidad actual de inclinación de la `Class.Camera`.


Este método tweens la `Class.Camera` de manera lineal hacia un nuevo
`Class.Camera.CFrame|CFrame` y `Class.Camera.Focus|Focus` durante un tiempo dado, por ejemplo:

```lua
local camera = workspace.CurrentCamera
camera.CameraType = Enum.CameraType.Scriptable

camera:Interpolate(
	CFrame.new(0, 10, 100),
	CFrame.new(0, 0, 100),
	5
)
```
A lo largo del tween, el `Class.Camera.CFrame|CFrame` de la cámara estará
orientado hacia el `Class.Camera.Focus|Focus` de la cámara.

Cuando el tween haya finalizado, el evento
`Class.Camera.InterpolationFinished|InterpolationFinished` de la cámara se
activará.

Si este método se llama mientras la `Class.Camera` ya está tweening, el
anterior tween se detendrá (sin activar
`Class.Camera.InterpolationFinished|InterpolationFinished`) y será reemplazado
por el nuevo tween.

Interpolate solo se puede usar si el actual
`Class.Camera.CameraType|CameraType` es `Scriptable`, independientemente de
si se están utilizando los scripts de cámara predeterminados. Si se usa con cualquier
otro `Class.Camera.CameraType|CameraType`, se lanzará un error.

Se recomienda usar `Class.TweenService` para tween la `Class.Camera`
en su lugar, ya que es más confiable y ofrece una variedad de estilos de easing. Consulta
abajo para un ejemplo:

```lua
local TweenService = game:GetService("TweenService")

local camera = workspace.CurrentCamera
camera.CameraType = Enum.CameraType.Scriptable

local tween = TweenService:Create(
	camera,
	TweenInfo.new(5, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
	{
		CFrame = CFrame.new(0, 10, 100),
		Focus = CFrame.new(0, 0, 100)
	}
)

tween:Play()
```


Camera:Interpolate

endPos

El `Datatype.CFrame` al que la `Class.Camera` debe tween.


endFocus

El `Datatype.CFrame` al que el `Class.Camera.Focus|Focus` de la cámara debe tween.


duration

Tweens la `Class.Camera` de manera lineal hacia un nuevo
`Class.Camera.CFrame|CFrame` y `Class.Camera.Focus|Focus` durante un tiempo dado.


Este método panea la `Class.Camera` alrededor del `Class.Camera.Focus|Focus`
en incrementos de 45 grados alrededor del eje **Y**.

La rotación se aplica a la propiedad `Class.Camera.CFrame|CFrame` de la cámara.

Este método panea la `Class.Camera` en incrementos de 45 grados, por ejemplo:

```lua
workspace.CurrentCamera:PanUnits(1) -- 45 grados
workspace.CurrentCamera:PanUnits(-2) -- -90 grados
```
PanUnits no requiere que el `Class.Camera.CameraType|CameraType` sea
`Scriptable`.


Camera:PanUnits

units

El número de incrementos de 45 grados por los cuales paneas la `Class.Camera`.


Panea la `Class.Camera` alrededor del `Class.Camera.Focus|Focus` en incrementos de 45 grados
alrededor del eje **Y**.


Este método crea un `Datatype.Ray` unitario desde una posición 2D en la pantalla
(definida en píxeles), teniendo en cuenta el desplazamiento de la GUI. El `Datatype.Ray`
se origina desde el equivalente `Datatype.Vector3` de la posición 2D en
el mundo a la profundidad dada (en studs) lejos de la `Class.Camera`.

Como este método reconoce el desplazamiento de la GUI, el desplazamiento aplicado a los elementos de la GUI
(como desde la barra superior) se tiene en cuenta. Esto significa que la
posición de pantalla especificada comenzará en la esquina superior izquierda debajo de la barra superior. Para un método idéntico que no tiene en cuenta el desplazamiento de la GUI, usa `Class.Camera:ViewportPointToRay()|ViewportPointToRay()`.

Como el `Datatype.Ray` creado es un rayo unitario, solo tiene una longitud de un stud. Para
crear un rayo más largo, puedes hacer lo siguiente:

```lua
local camera = workspace.CurrentCamera
local length = 500
local unitRay = camera:ScreenPointToRay(100, 100)
local extendedRay = Ray.new(unitRay.Origin, unitRay.Direction * length)
```
Este método solo funciona para la cámara actual de `Class.Workspace`. Otras
cámaras, como las que creas para un `Class.ViewportFrame`, tienen un
tamaño de viewport inicial de <Typography noWrap>`(1, 1)`</Typography> y solo se
actualizan después de que las establezcas en `Class.Workspace.CurrentCamera`. La
incompatibilidad en el tamaño del viewport hace que la cámara devuelva un rayo con un
`Datatype.Ray.Direction` incorrecto.


Camera:ScreenPointToRay

La posición en el eje **X**, en píxeles, del punto de pantalla en
el que se originará el `Datatype.Ray`. Esta posición tiene en cuenta el
desplazamiento de la GUI.


La posición en el eje **Y**, en píxeles, del punto de pantalla en
el que se originará el `Datatype.Ray`. Esta posición tiene en cuenta el
desplazamiento de la GUI.


depth

La profundidad desde la `Class.Camera`, en studs, desde la cual se desplazará el
origen del `Datatype.Ray`.


Un `Datatype.Ray` unitario, originado desde la equivalente
`Datatype.Vector3` posición del mundo de las coordenadas de pantalla dadas a
la profundidad dada lejos de la `Class.Camera`. Este rayo está orientado
en la dirección de la `Class.Camera`.


Crea un `Datatype.Ray` unitario desde una posición en la pantalla (en píxeles),
en una profundidad establecida desde la `Class.Camera` orientada en la dirección de la cámara. Tiene en cuenta el desplazamiento de la GUI.


Este método establece el `Enum.CameraPanMode` que será utilizado por la `Class.Camera`
en dispositivos móviles.

Cuando se utiliza el modo `EdgeBump` de `Enum.CameraPanMode`, el paneo por deslizamiento está
deshabilitado y se habilitan los controles de cámara de borde.

El modo SetCameraPan no tiene efecto en usuarios de Windows o Mac.


Camera:SetCameraPanMode

mode

El `Enum.CameraPanMode` para establecer en la `Class.Camera`.


Establece el `Enum.CameraPanMode` que será utilizado por la `Class.Camera` en dispositivos móviles.


Este método está desactualizado y ya no se considera una buena práctica.

Este método establece la rotación actual, en radianes, de la `Class.Camera`. La
rotación se aplica después de la `Class.Camera.CFrame|CFrame` y representa la
rotación alrededor del eje Z de la cámara.

Por ejemplo, lo siguiente invertiría la `Class.Camera`:

```lua
workspace.CurrentCamera:SetRoll(math.pi) -- math.pi radianes = 180 grados
```
SetRoll no tiene efecto en ninguna rotación aplicada usando la
propiedad `Class.Camera.CFrame|CFrame`. La rotación aplicada usando SetRoll no se
refleja en la propiedad `Class.Camera.CFrame|CFrame` pero se refleja en el
`Datatype.CFrame` devuelto
por `Class.Camera:GetRenderCFrame()|GetRenderCFrame()`.

Este método solo se puede usar cuando el `Class.Camera.CameraType|CameraType`
está establecido en `Scriptable`, independientemente de si se están utilizando los scripts de cámara predeterminados.
Si se usa con cualquier otro
`Class.Camera.CameraType|CameraType`, se dará una advertencia en la salida.

Cualquier rotación aplicada usando este método se perderá cuando el
`Class.Camera.CameraType|CameraType` cambie de `Scriptable`.

Para obtener la rotación establecida usando este método, usa
`Class.Camera:GetRoll()|GetRoll()`.

Como este método está desactualizado, se recomienda aplicar la rotación a la
`Class.Camera` usando la propiedad `Class.Camera.CFrame|CFrame`. Por
ejemplo:

```lua
local currentCFrame = workspace.CurrentCamera.CFrame
local rollCFrame = CFrame.Angles(0, 0, roll)
workspace.CurrentCamera.CFrame = currentCFrame * rollCFrame
```


Camera:SetRoll

rollAngle

El ángulo de rotación, en radianes, que se aplicará a la `Class.Camera`.


Establece la rotación actual aplicada alrededor del eje Z de la cámara.


Este método inclina la `Class.Camera` rotándola alrededor del
`Class.Camera.Focus|Focus` alrededor del eje **X** de la cámara por un múltiplo dado de 10 grados.

La rotación se aplica a la propiedad `Class.Camera.CFrame|CFrame` de la cámara y está restringida entre `-81.05` y `81.05` grados.


Camera:TiltUnits

El número de unidades de 10 grados por las cuales inclinas la `Class.Camera`.


Si la inclinación aplicada a la `Class.Camera` fue restringida.


Inclina la `Class.Camera` alrededor de su `Class.Camera.Focus|Focus` en incrementos de 10
grados alrededor del eje **X** de la cámara.


Este método crea un `Datatype.Ray` unitario desde una posición 2D en coordenadas de viewport seguras del dispositivo, definidas en píxeles. El rayo se origina desde el
`Datatype.Vector3` equivalente de la posición 2D en el mundo a la profundidad dada (en studs) lejos de la `Class.Camera`.

Como se ilustra a continuación, `(0, 0)` corresponde al punto superior izquierdo de la
barra superior de Roblox. Esto significa que la posición 2D de entrada **no** tiene en cuenta
el desplazamiento de `Enum.ScreenInsets|CoreUISafeInsets`, pero sí tiene en cuenta cualquier `Enum.ScreenInsets|DeviceSafeInsets`.

<img src="../../../assets/engine-api/classes/Camera/ViewportPointToRayOrigin.png" width="840" alt="Diagrama que muestra el origen del sistema de coordenadas del área segura del dispositivo en el viewport." />

Ten en cuenta que las instancias de UI utilizan un sistema de coordenadas diferente
(`Class.GuiObject.AbsolutePosition` utiliza el
`sistema de coordenadas del viewport de `Enum.ScreenInsets|CoreUISafeInsets` mientras que este
método utiliza el sistema de coordenadas del viewport de `Enum.ScreenInsets|DeviceSafeInsets`). Si deseas especificar la posición en coordenadas de la UI principal,
utiliza `Class.Camera:ScreenPointToRay()|ScreenPointToRay()`.

También ten en cuenta que este método solo funciona para la
cámara `Class.Workspace.CurrentCamera`. Otras cámaras, como las que
creas para un `Class.ViewportFrame`, tienen un tamaño de viewport inicial de
`(1, 1)` y solo se actualizan después de que las establezcas en
`Class.Workspace.CurrentCamera|CurrentCamera`. La incompatibilidad en el tamaño del viewport
hace que la cámara devuelva un rayo con un
`Datatype.Ray.Direction` incorrecto.

Este método se puede usar junto con la
propiedad `Class.Camera.ViewportSize|ViewportSize` para crear un rayo desde el
centro de la pantalla, por ejemplo:

```lua
local camera = workspace.CurrentCamera

local viewportPoint = camera.ViewportSize / 2
local unitRay = camera:ViewportPointToRay(viewportPoint.X, viewportPoint.Y, 0)
```
Como el `Datatype.Ray` creado es un rayo unitario, solo tiene una longitud de un stud. Para
crear un rayo más largo, puedes hacer lo siguiente:

```lua
local camera = workspace.CurrentCamera

local length = 500
local viewportPoint = camera.ViewportSize / 2
local unitRay = camera:ViewportPointToRay(viewportPoint.X, viewportPoint.Y, 0)
local extendedRay = Ray.new(unitRay.Origin, unitRay.Direction * length)
```


Camera:ViewportPointToRay

La posición en el eje **X**, en píxeles, del punto de viewport en
el que se originará el `Datatype.Ray`, en coordenadas del área segura del dispositivo.


La posición en el eje **Y**, en píxeles, del punto de viewport en
el que se originará el `Datatype.Ray`, en coordenadas del área segura del dispositivo.


Un `Datatype.Ray` unitario, originado desde la equivalente
`Datatype.Vector3` posición del mundo de las coordenadas de viewport dadas a
la profundidad dada lejos de la `Class.Camera`. Este rayo está orientado
en la dirección de la `Class.Camera`.


Crea un `Datatype.Ray` unitario desde una posición en el viewport (en píxeles),
en una profundidad dada desde la `Class.Camera`, orientada en la dirección de la cámara. No tiene en cuenta el desplazamiento de `Enum.ScreenInsets|CoreUISafeInsets`.


Este método devuelve la ubicación en pantalla y la profundidad de un `Datatype.Vector3`
`worldPoint` y si este punto está dentro de los límites de la pantalla.

Este método tiene en cuenta el desplazamiento actual de la GUI, como el espacio
ocupado por la barra superior, lo que significa que la posición 2D devuelta está en los
mismos términos que las posiciones de la GUI y se puede usar para colocar elementos de la GUI. Para un
método idéntico que ignora el desplazamiento de la GUI, consulta
`Class.Camera:WorldToViewportPoint()|WorldToViewportPoint()`.

```lua
local camera = workspace.CurrentCamera

local worldPoint = Vector3.new(0, 10, 0)
local vector, onScreen = camera:WorldToScreenPoint(worldPoint)

local screenPoint = Vector2.new(vector.X, vector.Y)
local depth = vector.Z
```
Ten en cuenta que este método no realiza ningún raycasting y el booleano
que indica si `worldPoint` está dentro de los límites de la pantalla será
`true` independientemente de si el punto está obstruido por
`Class.BasePart|BaseParts` o `Class.Terrain`.


Camera:WorldToScreenPoint

worldPoint

La posición del mundo `Datatype.Vector3`.


Una tupla que contiene, en orden:

- Un `Datatype.Vector3` cuyos componentes **X** y **Y** representan el
desplazamiento del `worldPoint` desde la esquina superior izquierda de la pantalla,
en píxeles. El componente **Z** del `Datatype.Vector3` representa la
profundidad del `worldPoint` desde la pantalla (en studs).

- Un booleano que indica si el `worldPoint` está dentro de los límites de la
pantalla.


Devuelve la ubicación en pantalla y la profundidad de un `Datatype.Vector3` `worldPoint`
y si este punto está dentro de los límites de la pantalla. Tiene en cuenta
el desplazamiento de la GUI.


Este método devuelve la ubicación en pantalla y la profundidad de un `Datatype.Vector3`
`worldPoint` y si este punto está dentro de los límites de la pantalla.

Este método no tiene en cuenta el desplazamiento actual de la GUI, como el
espacio ocupado por la barra superior, lo que significa que la posición 2D devuelta se
toma desde la esquina superior izquierda del viewport. A menos que estés usando
`Class.ScreenGui.IgnoreGuiInset`, esta posición no es apropiada para
colocar elementos de la GUI.

Para un método idéntico que tiene en cuenta el desplazamiento de la GUI, consulta
`Class.Camera:WorldToScreenPoint()|WorldToScreenPoint()`.

```lua
local camera = workspace.CurrentCamera

local worldPoint = Vector3.new(0, 10, 0)
local vector, onScreen = camera:WorldToViewportPoint(worldPoint)

local viewportPoint = Vector2.new(vector.X, vector.Y)
local depth = vector.Z
```
Ten en cuenta que este método no realiza ningún raycasting y el booleano
que indica si `worldPoint` está dentro de los límites de la pantalla será
`true` independientemente de si el punto está obstruido por
`Class.BasePart|BaseParts` o `Class.Terrain`.

##### Cámaras de ViewportFrame

Solo `Class.Workspace.CurrentCamera` tiene sus dimensiones internas de viewport
actualizadas por el motor en cada fotograma. Las cámaras utilizadas dentro de un
`Class.ViewportFrame` no reciben actualizaciones de viewport, por lo que los componentes X e Y
devueltos por este método estarán en el rango [0, 1] en lugar de
en píxeles. En la práctica, esto significa que los valores devueltos se pueden usar como
coordenadas de escala (por ejemplo,
`Datatype.UDim2|UDim2.fromScale(vector.X, vector.Y)`) para posicionar elementos de la GUI
relativos al ViewportFrame.


Camera:WorldToViewportPoint

Una tupla que contiene, en orden:

- Un `Datatype.Vector3` cuyos componentes **X** y **Y** representan el
desplazamiento del `worldPoint` desde la esquina superior izquierda del viewport,
en píxeles para `Class.Workspace.CurrentCamera`. Para cámaras dentro de un
`Class.ViewportFrame`, los valores están normalizados a [0, 1]. El
componente **Z** del `Datatype.Vector3` representa la profundidad del
`worldPoint` desde la pantalla (en studs).

- Un booleano que indica si el `worldPoint` está dentro de los límites de la
pantalla.


Devuelve la ubicación en pantalla y la profundidad de un `Datatype.Vector3` `worldPoint`
y si este punto está dentro de los límites de la pantalla. No
tiene en cuenta el desplazamiento de la GUI.


Demuestra `Class.Camera:ZoomToExtents()`.


Este método ajusta el `Class.Camera.CFrame|CFrame` para que una caja delimitadora especificada
sea completamente visible dentro del viewport de la cámara, sin
recortar ninguna parte de la caja.

La caja delimitadora se define por su centro y orientación
(`boundingBoxCFrame`) y su tamaño (`boundingBoxSize`).

Esto se puede usar para enfocar la cámara en un objeto o modelo 3D, como al
enmarcar contenido en un `Class.ViewportFrame`, tomar capturas de pantalla, o
transicionar suavemente la cámara para resaltar contenido específico.

El método tiene en cuenta automáticamente el campo de visión de la cámara y
la relación de aspecto del viewport para asegurar que toda la caja delimitadora quepa.


Camera:ZoomToExtents

boundingBoxCFrame

El `Datatype.CFrame` que representa el centro y la orientación de la
caja delimitadora que se ajustará al viewport.


boundingBoxSize

El tamaño `Datatype.Vector3` de la caja delimitadora que se ajustará al
viewport.


Ajusta el `Class.Camera.CFrame|CFrame` para que la caja delimitadora especificada
sea completamente visible dentro del viewport de la cámara.


Camera

`CameraSubject` acepta una variedad de `Class.Instance|Instances`. Los
scripts de cámara predeterminados responden de manera diferente a las configuraciones disponibles:

- Por defecto, los scripts de cámara siguen al `Class.Humanoid` del personaje local,
teniendo en cuenta el estado actual del humanoide y `Class.Humanoid.CameraOffset`.

- Cuando se establece en un `Class.BasePart`, los scripts de cámara siguen su posición,
con un desplazamiento vertical en el caso de `Class.VehicleSeat|VehicleSeats`.

`CameraSubject` no puede ser establecido en `nil`. Intentar hacerlo revertirá su
valor anterior.

Para restaurar `CameraSubject` a su valor predeterminado, configúralo en el `Class.Humanoid`
del personaje local:


Camera.CameraSubject

El `Class.Humanoid` o `Class.BasePart` que es el sujeto de la `Class.Camera`.


Los scripts de cámara predeterminados de Roblox tienen varios comportamientos integrados. Establecer
esta propiedad alterna entre los diversos comportamientos de `Enum.CameraType`.
Ten en cuenta que algunos tipos de cámara requieren un `Class.Camera.CameraSubject|CameraSubject` válido para funcionar correctamente.

Los scripts de cámara predeterminados no moverán ni actualizarán la cámara si
`CameraType` está establecido en `Enum.CameraType.Scriptable`. Para más información
sobre cómo posicionar y orientar la cámara manualmente, consulta
`Class.Camera.CFrame|CFrame`.

Para todas las configuraciones de `CameraType` **excepto** `Enum.CameraType.Scriptable`, la
propiedad `Class.Camera.CameraSubject|CameraSubject` representa el objeto
cuya posición se establece en el `Class.Camera.Focus|Focus` de la cámara.


Camera.CameraType

Especifica el `Enum.CameraType` que será leído por los scripts de cámara.


Esta propiedad es el `Datatype.CFrame` de la `Class.Camera`, definiendo su
posición y orientación en el mundo 3D. Ten en cuenta que algunas transformaciones,
como la rotación de la cabeza al usar dispositivos de VR, no se reflejan
en esta propiedad, por lo que deberías usar
`Class.Camera:GetRenderCFrame()|GetRenderCFrame()` para obtener el "verdadero"
`Datatype.CFrame` de la cámara.

Puedes mover la cámara configurando esta propiedad. Sin embargo, los scripts de
cámara predeterminados también la configuran, por lo que deberías:

- Establecer el `Class.Camera.CameraType|CameraType` de la cámara en
  `Enum.CameraType.Scriptable` para que los scripts de cámara predeterminados no
  actualicen el `Datatype.CFrame` de la cámara. Este método es el más simple y
  recomendado en la mayoría de los casos.

- Reemplazar completamente los scripts de cámara predeterminados con alternativas. Este
  enfoque solo se recomienda si no necesitas ninguna funcionalidad de cámara
  predeterminada.

La forma más intuitiva de posicionar y orientar la `Class.Camera` es usando el
constructor `Datatype.CFrame.lookAt()`. En el siguiente ejemplo, la `Class.Camera` está
posicionada en `Datatype.Vector3.new(0, 10, 0)` y está orientada para mirar hacia
`Datatype.Vector3.new(10, 0, 0)`.

```lua
local camera = workspace.CurrentCamera
camera.CameraType = Enum.CameraType.Scriptable

local pos = Vector3.new(0, 10, 0)
local lookAtPos = Vector3.new(10, 0, 0)

camera.CFrame = CFrame.lookAt(pos, lookAtPos)
```
Aunque la cámara puede ser colocada de la manera demostrada arriba, es posible que
quieras animarla para que se mueva suavemente de un `Datatype.CFrame` a otro. Para esto, puedes:

- Establecer la posición/orientación de la cámara en cada fotograma con
  `Class.RunService:BindToRenderStep()` y el método `Datatype.CFrame:Lerp()`.
- Crear y reproducir un `Class.Tween` que anime la posición/orientación
  de la cámara:

  
```lua
local Players = game:GetService("Players")
  local TweenService = game:GetService("TweenService")

  local camera = workspace.CurrentCamera
  camera.CameraType = Enum.CameraType.Scriptable

  local player = Players.LocalPlayer
  local character = player.Character
  if not character or character.Parent == nil then
  	character = player.CharacterAdded:Wait()
  end

  local pos = camera.CFrame * Vector3.new(0, 20, 0)
  local lookAtPos = character.PrimaryPart.Position
  local targetCFrame = CFrame.lookAt(pos, lookAtPos)

  local tween = TweenService:Create(camera, TweenInfo.new(2), {CFrame = targetCFrame})

  tween:Play()
```


Camera.CFrame

El `Datatype.CFrame` de la `Class.Camera`, definiendo su posición y
orientación en el mundo 3D.


La versión antigua de la propiedad `Class.Camera.CFrame|CFrame` que
funciona de manera idéntica a ella.

Este elemento debe ser utilizado en un `Class.LocalScript` para funcionar como
se espera en línea.


Camera.CoordinateFrame

Establece cuántos grados en la dirección diagonal (desde una esquina del
viewport hasta su esquina opuesta) puede ver la cámara. Consulta
`Class.Camera.FieldOfView|FieldOfView` para una explicación más general del
campo de visión.

Ten en cuenta que `DiagonalFieldOfView` representa el campo de visión que es
visible por la `Class.Camera` renderizando en el área de pantalla completa que puede
estar oculta por muescas o recortes de pantalla en algunos dispositivos. Consulta
`Class.Camera.ViewportSize|ViewportSize` para más información.


Camera.DiagonalFieldOfView

Establece el ángulo del campo de visión diagonal de la cámara.


La propiedad `FieldOfView` (FOV) establece cuántos grados en la dirección
vertical puede ver la cámara. Esta propiedad está limitada entre `1` y
`120` grados y por defecto es `70`. Campos de visión muy bajos o muy altos
no son recomendados ya que pueden desorientar a los jugadores.

Ten en cuenta que se aplica un escalado uniforme, lo que significa que el campo de
visión vertical y horizontal siempre están relacionados por la relación de aspecto de la pantalla.

Usos sugeridos para `FieldOfView` incluyen:

- Reducir el FOV para dar la impresión de magnificación, por ejemplo, al usar
  binoculares.
- Aumentar el FOV cuando el jugador está "corriendo" para dar la impresión de
  falta de control.

Ten en cuenta que `FieldOfView` representa el campo de visión que es visible por
la `Class.Camera` renderizando en el área de pantalla completa que puede ser
oculta por muescas o recortes de pantalla en algunos dispositivos. Consulta
`Class.Camera.ViewportSize|ViewportSize` para más información.


Camera.FieldOfView

Establece el ángulo del campo de visión vertical de la cámara.


El `Class.Camera.FieldOfView|FieldOfView` (FOV) de la cámara debe ser actualizado
para reflejar los cambios en `Class.Camera.ViewportSize|ViewportSize`. El valor de
`FieldOfViewMode` determina qué valor de FOV se mantendrá constante.

Por ejemplo, cuando esta propiedad está establecida en `Enum.FieldOfViewMode.Vertical`,
el FOV horizontal se actualiza cuando se redimensiona el viewport, pero el
FOV vertical se mantiene constante. Si esta propiedad está establecida en
`Enum.FieldOfViewMode.Diagonal`, tanto el FOV horizontal como el vertical pueden ser
cambiados para mantener constante el FOV diagonal.


Camera.FieldOfViewMode

Determina el valor de FOV de la `Class.Camera` que es invariante ante
cambios en el tamaño del viewport.


Ciertas operaciones gráficas que realiza el motor, como actualizar
iluminación, pueden llevar tiempo o esfuerzo computacional para completarse. La propiedad
`Focus` de la cámara le dice al motor qué área en el espacio 3D priorizar
al realizar tales operaciones. Por ejemplo, la iluminación dinámica de
objetos como `Class.PointLight|PointLights` puede no renderizarse a distancias
lejos del foco.

Los scripts de cámara predeterminados de Roblox establecen automáticamente `Focus` para seguir al
`Class.Camera.CameraSubject|CameraSubject` (generalmente un `Class.Humanoid`).
Sin embargo, `Focus` **no** se actualizará automáticamente cuando
`Class.Camera.CameraType|CameraType` esté establecido en
`Enum.CameraType.Scriptable` o cuando no se estén utilizando los scripts de cámara predeterminados. En estos casos, deberías actualizar `Focus` en cada fotograma, usando
el método `Class.RunService:BindToRenderStep()` en la prioridad
`Enum.RenderPriority.Camera`.

`Focus` no tiene ningún efecto sobre la posición u orientación de la cámara; consulta
`Class.Camera.CFrame|CFrame` para esto.


Camera.Focus

Establece el área en el espacio 3D que es priorizada por los sistemas gráficos de Roblox.


Camera.focus

Alterna si la cámara rastreará automáticamente el movimiento de la cabeza de un
jugador que utiliza un dispositivo de VR. Cuando es `true` (predeterminado), el motor combina
`Class.Camera.CFrame|CFrame` con el `Enum.UserCFrame` de la cabeza del usuario
para renderizar la vista del jugador con el seguimiento de la cabeza incluido. La vista será
renderizada en el siguiente `Datatype.CFrame`:

```lua
local UserInputService = game:GetService("UserInputService")

local camera = workspace.CurrentCamera

local headCFrame = UserInputService:GetUserCFrame(Enum.UserCFrame.Head)
headCFrame = headCFrame.Rotation + headCFrame.Position * camera.HeadScale

-- Esto será equivalente a Camera:GetRenderCFrame()
local renderCFrame = camera.CFrame * headCFrame
```
Se recomienda **no** desactivar esta propiedad por las siguientes
razones:

- Los jugadores pueden experimentar mareos si no se añade una solución equivalente de seguimiento de cabeza.
- El motor de Roblox realiza optimizaciones de latencia cuando `HeadLocked` es
  verdadero.

##### Ver También

- `Class.VRService:GetUserCFrame()` que se puede usar para obtener el
  `Datatype.CFrame` de la cabeza.
- `Class.VRService:RecenterUserHeadCFrame()` que se utiliza para recentrar la
  cabeza en la posición y orientación actuales del dispositivo de VR.
- El método `Class.Camera:GetRenderCFrame()|GetRenderCFrame()` que
  devuelve el `Class.Camera.CFrame|CFrame` combinado con el
  `Datatype.CFrame` de la cabeza del usuario.


Camera.HeadLocked

Alterna si la cámara rastreará automáticamente el movimiento de la cabeza de un
jugador que utiliza un dispositivo de VR.


`HeadScale` es la escala de la perspectiva del usuario del mundo al usar
VR.

El tamaño de 1 stud en VR es `0.3 metros / HeadScale`, lo que significa que valores más grandes
`HeadScale` equivalen a que el mundo se vea más pequeño desde la perspectiva del usuario al usar dispositivos de VR. Por ejemplo, una parte que mide 1 stud de altura
aparece tener 0.6 metros de altura para un jugador de VR con un `HeadScale` de `0.5`.

Esta propiedad es controlada automáticamente por
`Class.VRService.AutomaticScaling` para alinear la perspectiva del jugador con
el tamaño de su avatar. Si tienes la intención de controlar `HeadScale` tú mismo o
usar personajes personalizados, alterna `Class.VRService.AutomaticScaling` a
`Enum.VRScaling.Off`.

Esta propiedad no debe confundirse con `Class.Humanoid.HeadScale` que
es un `Class.NumberValue` parentado a un `Class.Humanoid` para controlar su
escalado.


Camera.HeadScale

Establece la escala de la perspectiva del usuario del mundo al usar VR.


La propiedad `MaxAxisFieldOfView` establece cuántos grados a lo largo del eje más largo
puede ver la cámara.

Cuando el eje más largo es el eje vertical, esta propiedad se comportará
similar a la propiedad `Class.Camera.FieldOfView|FieldOfView`. Este es
generalmente el caso cuando un dispositivo está en orientación vertical. En una
orientación horizontal, el eje más largo será el eje horizontal; en
este caso, la propiedad describe el campo de visión horizontal de la
`Class.Camera`.


Camera.MaxAxisFieldOfView

Establece el ángulo del campo de visión de la cámara a lo largo del eje más largo del viewport.


La propiedad `NearPlaneZ` describe cuán lejos está el plano de recorte cercano de la cámara,
en studs. El plano de recorte cercano es un plano geométrico que se sitúa frente al `Class.Camera.CFrame|CFrame` de la cámara. Cualquier cosa
entre este plano y la cámara no se renderizará, creando una vista cortada
al ver objetos a distancias muy cortas. El valor de `NearPlaneZ`
varía entre diferentes plataformas y actualmente siempre está entre `-0.1`
y `-0.5`.

<img src="/assets/engine-api/classes/Camera/NearPlaneZ.jpg" width="720" alt="Diagrama que muestra cómo el NearPlaneZ recorta (no renderiza) contenido 3D entre el plano y la cámara." />


Camera.NearPlaneZ

Describe el desplazamiento negativo **Z**, en studs, del plano de recorte cercano de la cámara.


Especifica qué aspecto de `Class.Camera.ViewportSize|ViewportSize` es
controlado por `Class.Camera.OrthographicSize|OrthographicSize`.

Por ejemplo, cuando esta propiedad está establecida en
`Enum.OrthographicMode.Vertical`, la proyección ortográfica se escala
para que la dimensión vertical abarque exactamente
`Class.Camera.OrthographicSize|OrthographicSize` studs, y la dimensión
horizontal abarque cuántos studs sean necesarios para coincidir.


Camera.OrthographicMode

Establece qué eje de pantalla se aplica `Class.Camera.OrthographicSize|OrthographicSize`.


`Class.Camera.OrthographicMode|OrthographicMode` elige la dimensión del
viewport que deseas controlar.
`Class.Camera.OrthographicSize|OrthographicSize` establece la extensión en studs
que abarca esa dimensión del viewport.

Por ejemplo, si `Class.Camera.OrthographicMode|OrthographicMode` está establecido en
`Enum.OrthographicMode.MaxAxis`, entonces la dimensión más grande del viewport
abarcará `Class.Camera.OrthographicSize|OrthographicSize` studs.


Camera.OrthographicSize

Establece la extensión en studs de la dimensión elegida por
`Class.Camera.OrthographicMode|OrthographicMode`.


Establecer en `Enum.ProjectionType.Perspective` (predeterminado) para usar una cámara de perspectiva,
donde las líneas paralelas en 3D convergen en la pantalla y los objetos se vuelven
más pequeños a medida que se alejan. Establecer en `Enum.ProjectionType.Orthographic` para usar
una cámara ortográfica, donde las líneas paralelas permanecen paralelas y los objetos son
del mismo tamaño a cualquier distancia. Esto es útil para cosas como juegos 2D,
juegos isométricos y minimapas.


Camera.ProjectionType

Elige entre cámaras de perspectiva y ortográficas.


`ViewportSize` devuelve las dimensiones del área segura del dispositivo en la
pantalla actual. Esta área es un rectángulo que incluye el área de la barra superior de Roblox
pero no incluye ninguna muesca o recortes de pantalla del dispositivo. Las unidades
de `ViewportSize` son unidades de desplazamiento de UI de Roblox que pueden ser diferentes de
los píxeles de pantalla nativos.

<img src="../../../assets/engine-api/classes/Camera/DeviceSafeAreaVsFullscreen.png" width="840" alt="Pantalla de dispositivo móvil con recorte mostrando el área segura del dispositivo." />

Como se mencionó anteriormente, `ViewportSize` no es igual al tamaño del área de pantalla completa en
displays con recortes o muescas. Para obtener el tamaño del área de pantalla completa en
todos los displays, puedes consultar la
propiedad `Class.ScreenGui.AbsoluteSize|AbsoluteSize` de un
`Class.ScreenGui` con `Class.ScreenGui.ScreenInsets|ScreenInsets` establecido en
`Enum.ScreenInsets.None|None`. Consulta `Enum.ScreenInsets` para más
información sobre cómo se definen las áreas de pantalla.

Finalmente, ten en cuenta que `ViewportSize` no es el tamaño real del viewport que
la cámara utiliza para renderizar (la cámara renderiza en el área de pantalla completa).
Además, las propiedades `Class.Camera.FieldOfView|FieldOfView` y
`Class.Camera.DiagonalFieldOfView|DiagonalFieldOfView` se basan en el área de pantalla completa,
no en `ViewportSize`.

##### Actualizaciones de Cámara

Solo la `Class.Camera` actualmente referida por
`Class.Workspace.CurrentCamera` tiene su `ViewportSize` actualizado en cada fotograma
durante el paso `Class.RunService.PreRender|PreRender`. El `ViewportSize`
de todas las demás cámaras en tu experiencia no se actualizará, incluyendo aquellas
utilizadas para `Class.ViewportFrame|ViewportFrames`.


Camera.ViewportSize

Las dimensiones del área segura del dispositivo en un cliente de Roblox.


El campo de visión y el tamaño ortográfico se especifican para un eje del
viewport, ya sea horizontal o vertical. Normalmente, el otro eje
se ajusta automáticamente para mantener los píxeles cuadrados. Esto te permite estirar
el otro eje para que los píxeles no sean cuadrados, por una relación de hasta 2:1.
Esto puede ser animado para hacer que la vista se sienta un poco incorrecta, como cuando
estás aturdido.

Esto funciona tanto para cámaras ortográficas como para perspectivas.


Camera.ViewStretch

Estira el eje de la vista que no está fijado por el actual
`Class.Camera.FieldOfViewMode|FieldOfViewMode` o
`Class.Camera.OrthographicMode|OrthographicMode`.


Esta propiedad alterna si se aplicará inclinación y rotación del
`Class.Camera.CFrame|CFrame` mientras el jugador está usando un dispositivo de VR.

Para prevenir mareos, el horizonte debe permanecer nivelado. Incluir inclinación y
rotación en la vista del jugador mientras usa un dispositivo de VR puede causar una desconexión
entre el espacio físico del jugador y el espacio virtual que están viendo. Cambiar la dirección
aparente hacia abajo puede hacer que los jugadores pierdan el equilibrio o experimenten mareos.

Por estas razones, generalmente se aconseja dejar esta propiedad desactivada, a menos que hayas
probado extensamente tu experiencia para estos efectos. Incluso con la inclinación y rotación habilitadas,
podrías querer asegurarte de que el jugador siempre tenga un marco de referencia estable, como el interior de un
vehículo o un suelo que pueda ayudar al jugador a anclarse en su espacio físico.


Camera.VRTiltAndRollEnabled

Alterna si se aplicará inclinación y rotación del
`Class.Camera.CFrame|CFrame` mientras el jugador está usando un dispositivo de VR.


Una clase que define una vista del mundo 3D.


Una `Class.PVInstance` es una clase abstracta que no se puede crear. Es la
base para todos los objetos que tienen una ubicación física en el mundo.

Este ejemplo de código es un script simple de teleportación que mueve tu personaje
10&nbsp;studs hacia adelante en la dirección en la que actualmente estás mirando cuando presionas
la <kbd>F</kbd> tecla. Lo hace obteniendo el pivot actual con
`Class.PVInstance:GetPivot()` y llamando a `PVInstance|PivotTo` para mover el
personaje hacia adelante.

Esta función obtiene el pivote de una `Class.PVInstance`. A menudo se
utiliza con `Class.PVInstance:PivotTo()` para mover un modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y por lo tanto ambos
poseen esta función.

PVInstance:GetPivot

El `Datatype.CFrame` en el espacio mundial del pivot de la instancia.


Obtiene el pivote de una `Class.PVInstance`.

Transforma la `Class.PVInstance` junto con todas sus
`Class.PVInstance|PVInstances` descendientes de modo que el pivote ahora se
ubique en el `Datatype.CFrame` especificado. Esta es la función principal que
se debe utilizar para mover `Class.Model|Models` mediante scripting.

`Class.BasePart|BaseParts` se mueven de esta manera transformando su
`Datatype.CFrame` por el desplazamiento necesario.
`Class.Model|Models` se mueven de esta manera transformando su
`Class.Model.WorldPivot` por el desplazamiento necesario.

Tenga en cuenta que por motivos de eficiencia, los eventos
`Class.Object.Changed` no se activan para `Class.BasePart.Position|Position` y
`Class.BasePart.Orientation|Orientation` de los `Class.BasePart|BaseParts`
movidos de esta manera; solo se activan para `Datatype.CFrame`.

Al llamar a `Class.PVInstance:PivotTo()|PivotTo` en `Class.Model|Models`,
los desplazamientos de las partes y modelos descendientes se almacenan en caché,
de modo que las llamadas subsecuentes a `Class.PVInstance:PivotTo()|PivotTo` en el mismo modelo
o no acumulan deriva de punto flotante entre las partes que componen el
modelo.

`Class.Model|Models` y `Class.BasePart|BaseParts` son ambos
`Class.PVInstance|PVInstances` ("Instancias de Velocidad de Posición") y por lo tanto ambos
poseen esta función.

PVInstance:PivotTo

targetCFrame

El `Datatype.CFrame` al que el pivote de la `Class.PVInstance` debe igualar
despues de moverlo.

Transforma la `Class.PVInstance` junto con todas sus
`Class.PVInstance|PVInstances` descendientes de modo que el pivote ahora se
ubique en el `Datatype.CFrame` especificado.

PVInstance

Propiedad solo para editores, mostrada en la ventana de Propiedades del Studio como **Posición
de Origen** y **Orientación de Origen** bajo **Transformar**. Su valor es
el `Datatype.CFrame` en el espacio mundial del pivot de la instancia; leerlo
devuelve el mismo `Datatype.CFrame` que `Class.PVInstance:GetPivot()`. No
tiene un valor almacenado propio y siempre refleja el pivot actual.

Establecerlo desde la ventana de Propiedades mueve toda la instancia para que su
pivot se sitúe en el nuevo `Datatype.CFrame`, muy parecido a
`Class.PVInstance:PivotTo()`. Editar a través de la ventana de Propiedades
desactiva temporalmente `Class.WeldConstraint|WeldConstraints` a otros
objetos para el movimiento; `PivotTo` no modifica las uniones.

No disponible para scripts; usa `Class.PVInstance:GetPivot()` y
`Class.PVInstance:PivotTo()` en tiempo de ejecución en su lugar.


PVInstance.Origin

Propiedad solo para editores que lee y establece el `Datatype.CFrame` mundial del
pivot de la `Class.PVInstance`, moviendo toda la instancia cuando se cambia
desde la ventana de Propiedades del Studio.


Propiedad solo para editores, mostrada en la ventana de Propiedades del Studio como **Posición
 del Pivot** y **Orientación del Pivot** bajo **Pivot**. Es el
`Datatype.CFrame` del pivot relativo al propio marco de la instancia.

Cambiarlo desde la ventana de Propiedades mueve el pivot relativo a la
instancia mientras deja la instancia en su lugar, a diferencia de `Origen`, que mueve
toda la instancia. Para un `Class.BasePart`, el desplazamiento predeterminado es el
`Datatype.CFrame` de identidad, por lo que el pivot coincide con el centro de la parte.
Para un `Class.Model`, esta propiedad aparece solo cuando el modelo tiene un
`Class.Model.PrimaryPart|PrimaryPart`; entonces refleja y edita el
`Class.BasePart.PivotOffset|PivotOffset` de esa parte, y
`Class.Model:GetPivot()` es un alias del pivot de la parte principal.

No disponible para scripts; los scripts leen y escriben el equivalente a través
de la clase concreta, como `Class.BasePart.PivotOffset`.


PVInstance.Pivot Offset

Propiedad solo para editores que muestra y edita el `Datatype.CFrame` del pivot
relativo a la instancia, moviendo solo el pivot y dejando la instancia
en su lugar.


Clase abstracta para todos los objetos que tienen una ubicación física en el mundo.

`Instance` es la clase base para todas las clases en la jerarquía de clases de Roblox
que pueden ser parte del árbol `Class.DataModel`.

No es posible crear objetos `Instance` raíz directamente, pero el constructor especial
`Datatype.Instance.new()` crea objetos a través de código, tomando el
nombre de la clase como parámetro y devolviendo el objeto creado.


Demuestra cómo detectar cambios en la ascendencia de una instancia al conectarse al
`Class.Instance.AncestryChanged` evento.

El Parent de ChangingPart se establece en diferentes valores con el tiempo. El padre de
la parte es el ancestro de la parte, por lo que el evento `Class.Instance.AncestryChanged`
se activará cada vez que cambie.

Se activa cuando esta instancia es reparentada o cuando cualquiera de sus ancestros es
reparentado.

Puedes usar este evento para rastrear la eliminación de una instancia en Studio,
suchas como la eliminación manual en el Explorador o a través de un plugin. Si necesitas
detectar cuando una instancia es destruida usando `Class.Instance:Destroy()`,
usa el evento `Class.Instance.Destroying` en su lugar.


Instance.AncestryChanged

child

La instancia cuya propiedad `Class.Instance.Parent|Parent` ha cambiado,
que puede ser esta instancia o un ancestro más distante, **no**
necesariamente la instancia a la que está conectado el manejador.


parent

Se activa cuando se cambia la propiedad `Class.Instance.Parent` de este objeto o de uno de
sus ancestros.


Este evento se activa cada vez que se cambia cualquier atributo en la instancia,
incluyendo cuando un atributo se establece en `nil`. El nombre del atributo cambiado
se pasa a la función conectada.

Por ejemplo, el siguiente fragmento de código conecta la función `attributeChanged()`
para que se active cada vez que uno de los atributos de la parte cambie:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "cambiado")
end

part.AttributeChanged:Connect(attributeChanged)
```
Véase también `Class.Instance:GetAttributeChangedSignal()` que devuelve un
evento que se activa cuando un atributo específico cambia.


Instance.AttributeChanged

attribute

El nombre del atributo que ha sido cambiado.


Se activa cada vez que se cambia un atributo en el `Class.Instance`.


Este fragmento imprime los nombres de los objetos a medida que se añaden al Espacio de Trabajo:

Se activa después de que un objeto es parentado a esta `Class.Instance`.

Nota, al usar este método en un cliente para detectar objetos creados por el
servidor, es necesario usar `Class.Instance:WaitForChild()` al
indexar los descendientes de estos objetos. Esto se debe a que el objeto y sus
descendientes no están garantizados para replicarse del servidor al cliente
simultáneamente. Por ejemplo:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Usa WaitForChild() ya que los descendientes pueden no haberse replicado aún
	local head = child:WaitForChild("Head")
end)
```
Nota, este evento solo opera para hijos inmediatos de la
`Class.Instance`. Para un evento que captura todos los descendientes, usa
`Class.Instance.DescendantAdded`.

Véase también `Class.Instance.ChildRemoved`.


Instance.ChildAdded

El `Class.Instance` que ha sido agregado.


Se activa después de que un objeto es parentado a esta `Class.Instance`.


Instance.childAdded

Este fragmento imprime los nombres de los objetos a medida que se eliminan del
Espacio de trabajo:

Se activa después de que un hijo es eliminado de esta `Class.Instance`.

Eliminado se refiere a cuando el padre de un objeto cambia de esta
`Class.Instance` a algo diferente de esta `Class.Instance`. Nota, este
evento también se activará cuando un hijo sea destruido (usando
`Class.Instance:Destroy()`) ya que la función de destrucción establece el padre de un objeto
como `nil`.

Este evento solo opera para hijos inmediatos de la `Class.Instance`.
Para un evento que captura todos los descendientes, usa
`Class.Instance.DescendantRemoving`.

Véase también `Class.Instance.ChildAdded`.


Instance.ChildRemoved

El `Class.Instance` que ha sido eliminado.


Se activa después de que un hijo es eliminado de esta `Class.Instance`.


Este siguiente ejemplo imprimirá el nombre de cualquier objeto que se agregue al
Espacio de trabajo:

Este evento se activa después de que un descendiente es agregado a la `Class.Instance`.

Como se activa para cada descendiente, parentar un objeto a la
`Class.Instance` activará el evento para este objeto y todos sus
descendientes individualmente.

Si solo te preocupas por los **hijos directos** de la
`Class.Instance`, usa `Class.Instance.ChildAdded` en su lugar.

Véase también `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Se activa después de que un descendiente es agregado a la `Class.Instance`.


Instance

`Instance` es la clase base para todas las clases en la jerarquía de clases de Roblox
que pueden ser parte del árbol `Class.DataModel`.


/reference/engine/classes/ViewportCamera.yaml

Resumen