`ViewportCamera` is a `Class.Camera` intended for cameras that you set up at
design time, such as a camera assigned to `Class.ViewportFrame.CurrentCamera`
or a `ThumbnailCamera` inside a `Class.Model`. It has the same properties,
methods, and events as `Class.Camera`, but unlike `Class.Camera` it
replicates, so it works as expected in Team Create and when replicated from
the server to clients.

Use a `Class.Camera` for the camera that renders the 3D world, accessible
through `Class.Workspace.CurrentCamera`. Use a `ViewportCamera` for any other
camera that you author and want saved with the place.

#### Autoupgrade Behavior

When you paste copied content containing a `Class.Camera` in Studio, any
`Class.Camera` is automatically converted into a `ViewportCamera` with the
same properties. This is to facilitate the common workflow of setting up a
camera by positioning the main workspace camera and then copy-pasting that
camera.


ViewportCamera

A `Class.Camera` that replicates and is saved as authored content, for use
with `Class.ViewportFrame|ViewportFrames` or as a ThumbnailCamera.


O objeto `Camera` define uma visão do mundo 3D. Em uma experiência em execução,
cada cliente tem seu próprio objeto `Camera` que reside no `Class.Workspace`
local desse cliente, acessível através da propriedade `Class.Workspace.CurrentCamera`.

As propriedades de câmera mais importantes são:

- `Class.Camera.CFrame|CFrame` que representa a posição e orientação
  da câmera.

- `Class.Camera.CameraType|CameraType` que é lido pelos scripts de
  câmera da experiência e determina como a câmera deve atualizar a cada quadro.

- `Class.Camera.CameraSubject|CameraSubject` que é lido pelos scripts de
  câmera da experiência e determina qual objeto a câmera deve seguir.

- `Class.Camera.FieldOfView|FieldOfView` que representa a extensão visível
  do mundo observável.

- `Class.Camera.Focus|Focus` que representa o ponto que a câmera está olhando.
  É importante que essa propriedade seja definida, pois certos visuais serão mais
  detalhados e atualizarão com mais frequência dependendo de quão próximos estão do
  ponto de foco.

Veja [Personalizando a Câmera](/workspace/camera) para mais
informações sobre como ajustar e personalizar o comportamento da câmera.

#### Armazenando Múltiplas Câmeras

Observe que ao mudar `Class.Workspace.CurrentCamera` para uma nova
`Class.Camera`, todas as outras `Class.Camera|Cameras` que descendem diretamente de
`Class.Workspace` serão destruídas. Se você precisar armazenar várias câmeras e
alternar entre elas sob demanda, é recomendável que você as armazene em uma
`Class.Folder` ou `Class.Model` sob `Class.Workspace`, dentro das quais elas
permanecerão mesmo quando `Class.Workspace.CurrentCamera|CurrentCamera` for
alterado.


Este evento é disparado quando a `Class.Camera` terminou de interpolar usando
o método `Class.Camera:Interpolate()`. Ele não será disparado se uma animação for
interrompida devido a `Class.Camera:Interpolate()` ser chamada novamente.

É aconselhável usar `Class.TweenService` para animar a `Class.Camera`
em vez disso, pois é mais confiável e fornece mais opções para estilos de easing.

Camera.InterpolationFinished

Disparado quando a `Class.Camera` terminou de interpolar
usando `Class.Camera:Interpolate()|Interpolate()`.

Este método é usado pelo `PopperCam` nos scripts de câmera padrão para garantir
que obstruções não fiquem entre a `Class.Camera` e seu sujeito.

Este método verificará todos os `Class.BasePart|BaseParts` e `Class.Terrain`
no `Class.Workspace` com as seguintes exceções:

- Qualquer `Class.Instance` especificado na `ignoreList` (incluindo seus
  descendentes) será ignorado
- `Class.BasePart|BaseParts` com `Class.BasePart.CanCollide` definido como falso
  são ignorados
- `Class.BasePart|BaseParts` com uma `Class.BasePart.Transparency` maior
  que 0.95 serão ignorados. Água `Class.Terrain` é ignorada.

Observe que, como este método requer uma `ignoreList` para ser executado, você deve passar uma
mesa vazia quando nenhuma for necessária.

Camera:GetLargestCutoffDistance

ignoreList

Um array de `Class.Instance|Instances` a serem ignorados. Descendentes desses
instâncias também serão ignorados.

A distância, em studs, que a `Class.Camera` precisa ser empurrada
em direção ao seu `Class.Camera.Focus|Focus` para garantir que não haja
obstruções entre o `Class.Camera.Focus|Focus` e
`Class.Camera.CFrame|CFrame` da `Class.Camera`.

Retorna quanto a `Class.Camera` precisa ser empurrada em direção ao seu
`Class.Camera.Focus|Focus` para garantir que não haja obstruções
entre o `Class.Camera.Focus|Focus` e `Class.Camera.CFrame|CFrame`.

Este método está quebrado e não deve ser usado.

Este método retorna a velocidade atual de pan da `Class.Camera`.

A velocidade de pan da `Class.Camera` descreve a velocidade com que a
`Class.Camera` está girando em torno de seu `Class.Camera.Focus|Focus` ao redor
do eixo **Y**.

Camera:GetPanSpeed

A velocidade com que a `Class.Camera` está girando em torno de seu
`Class.Camera.Focus|Focus` no eixo **Y**.

Retorna a velocidade atual de 'pan' da `Class.Camera`.

Este método retorna um array de `Class.BasePart|BaseParts` que estão
obstruindo as linhas de visão entre o `Class.Camera.CFrame|CFrame` da câmera e as
posições `Datatype.Vector3` no array `castPoints`. Qualquer `Class.Instance|Instances`
incluído na array `ignoreList` será ignorado, junto com seus descendentes.

O parâmetro `castPoints` é fornecido como um array de posições `Datatype.Vector3`.
Observe que o array de `Class.BasePart|BaseParts` retornado está em uma ordem arbitrária,
e nenhum dado adicional de raycast é fornecido. Se você precisar de dados como posição de impacto, material de impacto ou normal de superfície, você
deve optar pelo 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)
```
Se `Class.Terrain` obscurecer um ponto de lançamento, `Class.BasePart|BaseParts`
que estão obscurecendo o ponto de lançamento entre o `Class.Terrain` que está
obstruindo e o ponto de lançamento não serão retornados.

Camera:GetPartsObscuringTarget

castPoints

Um array de posições `Datatype.Vector3` dos pontos de lançamento.

Um array de `Class.Instance|Instances` que devem ser ignorados, junto
com seus descendentes.

Um array de `Class.BasePart|BaseParts` que obscurecem as linhas de visão
entre o `Class.Camera.CFrame|CFrame` da câmera e os
`castPoints`.

Retorna um array de `Class.BasePart|BaseParts` que estão obscurecendo as
linhas de visão entre o `Class.Camera.CFrame|CFrame` da câmera e os
pontos de lançamento.

Este método retorna o `Datatype.CFrame` real da `Class.Camera` como
ela é renderizada, incluindo o impacto do VR (as transformações da cabeça VR não são
aplicadas à propriedade `Class.Camera.CFrame|CFrame`, então é uma boa prática usar
`Class.Camera:GetRenderCFrame()|GetRenderCFrame()` para obter o "verdadeiro" `Datatype.CFrame`
da visão de um jogador).

Por exemplo, ao usar VR, a `Class.Camera` é realmente renderizada na seguinte `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
```
O `Datatype.CFrame` de renderização da câmera só será alterado para levar em conta
a cabeça quando a propriedade `Class.Camera.HeadLocked|HeadLocked` for verdadeira.

Camera:GetRenderCFrame

O `Datatype.CFrame` em que a `Class.Camera` está sendo renderizada.

Retorna o `Datatype.CFrame` real onde a `Class.Camera` está sendo
renderizada, levando em conta qualquer rotação aplicada e o impacto dos dispositivos VR.

Este exemplo, quando usado em um `Class.LocalScript`, irá recuperar a rotação atual
 da câmera em graus. Então, se o ângulo de rotação da câmera não for 20
graus, o ângulo de rotação da câmera é definido para 20 graus.


Este método retorna, em radianos, a rotação atual aplicada à
`Class.Camera` usando `Class.Camera:SetRoll()|SetRoll()`. A rotação é definida
como a rotação em torno do eixo Z da câmera.

Este método só retorna a rotação aplicada usando o
`Class.Camera:SetRoll()|SetRoll()` método. A rotação aplicada manualmente à
propriedade `Class.Camera.CFrame|CFrame` não é contabilizada. Para obter a
rotação real da `Class.Camera`, incluindo a rotação aplicada manualmente, você
pode usar o seguinte trecho:

Camera:GetRoll

A rotação atual aplicada por `Class.Camera:SetRoll()|SetRoll()`, em
radianos.

Retorna em radianos a rotação atual, ou rotação em torno do eixo Z da câmera,
aplicada à `Class.Camera` usando
`Class.Camera:SetRoll()|SetRoll()`.

Este método está quebrado e não deve ser usado.

Este método retorna a velocidade atual de inclinação da `Class.Camera`.

A velocidade de inclinação da `Class.Camera` descreve a velocidade com que a
`Class.Camera` está girando em torno de seu `Class.Camera.Focus|Focus` ao redor
 do eixo **X**.

Camera:GetTiltSpeed

A velocidade com que a `Class.Camera` está girando em torno de seu
`Class.Camera.Focus|Focus` ao redor do eixo **X**.

Retorna a velocidade atual de inclinação da `Class.Camera`.

Este método anima a `Class.Camera` de forma linear em direção a um novo
`Class.Camera.CFrame|CFrame` e `Class.Camera.Focus|Focus` ao longo de uma duração dada, por exemplo:

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

camera:Interpolate(
	CFrame.new(0, 10, 100),
	CFrame.new(0, 0, 100),
	5
)
```
Durante a animação, o `Class.Camera.CFrame|CFrame` da câmera será
orientado em direção ao `Class.Camera.Focus|Focus` da câmera.

Quando a animação for concluída, o evento
`Class.Camera.InterpolationFinished|InterpolationFinished` da câmera será
disparado.

Se este método for chamado enquanto a `Class.Camera` já estiver animando, a
animação anterior será interrompida (sem disparar
`Class.Camera.InterpolationFinished|InterpolationFinished`) e substituída pela nova animação.

Interpolate só pode ser usado se o atual
`Class.Camera.CameraType|CameraType` for `Scriptable`, independentemente de
os scripts de câmera padrão estarem sendo usados. Se for usado com qualquer
outro `Class.Camera.CameraType|CameraType`, um erro será gerado.

É aconselhável usar `Class.TweenService` para animar a `Class.Camera`
em vez disso, pois é mais confiável e oferece uma variedade de estilos de easing. Veja
abaixo um exemplo:

```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

O `Datatype.CFrame` para o qual a `Class.Camera` deve ser animada.

endFocus

O `Datatype.CFrame` para o `Class.Camera.Focus|Focus` da câmera para
animar.

duration

Anima a `Class.Camera` de forma linear em direção a um novo
`Class.Camera.CFrame|CFrame` e `Class.Camera.Focus|Focus` ao longo de uma duração dada.

Este método gira a `Class.Camera` em torno do `Class.Camera.Focus|Focus`
em incrementos de 45 graus ao redor do eixo **Y**.

A rotação é aplicada à propriedade `Class.Camera.CFrame|CFrame` da câmera.

Este método gira a `Class.Camera` em incrementos de 45 graus, por exemplo:

```lua
workspace.CurrentCamera:PanUnits(1) -- 45 graus
workspace.CurrentCamera:PanUnits(-2) -- -90 graus
```
PanUnits não requer que o `Class.Camera.CameraType|CameraType` seja
`Scriptable`.

Camera:PanUnits

units

O número de incrementos de 45 graus pelos quais girar a `Class.Camera`.

Gira a `Class.Camera` em torno do `Class.Camera.Focus|Focus` em incrementos de 45 graus
em torno do eixo **Y**.

Este método cria um `Datatype.Ray` unitário a partir de uma posição 2D na tela
(definida em pixels), levando em conta o recorte da GUI. O `Datatype.Ray`
origina-se do equivalente `Datatype.Vector3` da posição 2D no mundo na profundidade dada (em studs) longe da `Class.Camera`.

Como este método reconhece o recorte da GUI, o deslocamento aplicado aos elementos da GUI
(como da barra superior) é considerado. Isso significa que a posição da tela especificada começará no canto superior esquerdo abaixo da barra superior. Para um método idêntico que não considera o deslocamento da GUI, use `Class.Camera:ViewportPointToRay()|ViewportPointToRay()`.

Como o `Datatype.Ray` criado é um raio unitário, ele tem apenas um stud de comprimento. Para
criar um raio mais longo, você pode fazer o seguinte:

```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 só funciona para a câmera atual do `Class.Workspace`. Outras
câmeras, como aquelas que você cria para um `Class.ViewportFrame`, têm um
tamanho inicial de viewport de <Typography noWrap>`(1, 1)`</Typography> e só são
atualizadas após você defini-las como `Class.Workspace.CurrentCamera`. A
incompatibilidade no tamanho do viewport faz com que a câmera retorne um raio com uma
`Datatype.Ray.Direction` incorreta.

Camera:ScreenPointToRay

A posição no eixo **X**, em pixels, do ponto da tela a partir do qual
originar o `Datatype.Ray`. Esta posição considera o recorte da GUI.

A posição no eixo **Y**, em pixels, do ponto da tela a partir do qual
originar o `Datatype.Ray`. Esta posição considera o recorte da GUI.

depth

A profundidade a partir da `Class.Camera`, em studs, a partir da qual
offsetar a origem do `Datatype.Ray`.

Um `Datatype.Ray` unitário, originando-se da posição de mundo equivalente
`Datatype.Vector3` das coordenadas de tela dadas na profundidade dada longe da `Class.Camera`. Este raio está orientado
na direção da `Class.Camera`.

Cria um `Datatype.Ray` unitário a partir de uma posição na tela (em pixels),
em uma profundidade definida a partir da `Class.Camera` orientada na direção da câmera. Considera o recorte da GUI.

Este método define o `Enum.CameraPanMode` a ser usado pela `Class.Camera`
em dispositivos móveis.

Quando o modo `EdgeBump` do `Enum.CameraPanMode` é usado, o arrasto para girar é
desativado e os controles de câmera de borda são habilitados.

O modo SetCameraPan não tem efeito em usuários do Windows ou Mac.

Camera:SetCameraPanMode

mode

O `Enum.CameraPanMode` para definir a `Class.Camera`.

Define o `Enum.CameraPanMode` a ser usado pela `Class.Camera` em dispositivos móveis.

Este método está desatualizado e não é mais considerado uma boa prática.

Este método define a rotação atual, em radianos, da `Class.Camera`. A
rotação é aplicada após o `Class.Camera.CFrame|CFrame` e representa a
rotação em torno do eixo Z da câmera.

Por exemplo, o seguinte inverteria a `Class.Camera`:

```lua
workspace.CurrentCamera:SetRoll(math.pi) -- math.pi radianos = 180 graus
```
SetRoll não tem efeito sobre qualquer rotação aplicada usando a
propriedade `Class.Camera.CFrame|CFrame`. A rotação aplicada usando SetRoll não é
refletida na propriedade `Class.Camera.CFrame|CFrame`, mas é refletida no
`Datatype.CFrame` retornado
por`Class.Camera:GetRenderCFrame()|GetRenderCFrame()`.

Este método só pode ser usado quando o `Class.Camera.CameraType|CameraType`
está definido como `Scriptable`, independentemente de os scripts de câmera padrão
estarem sendo usados. Se for usado com qualquer outro
`Class.Camera.CameraType|CameraType`, um aviso será dado na saída.

Qualquer rotação aplicada usando este método será perdida quando o
`Class.Camera.CameraType|CameraType` for alterado de `Scriptable`.

Para obter a rotação definida usando este método, use
`Class.Camera:GetRoll()|GetRoll()`.

Como este método está desatualizado, é aconselhável aplicar a rotação à
`Class.Camera` usando a propriedade `Class.Camera.CFrame|CFrame`. Por
exemplo:

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

Camera:SetRoll

rollAngle

O ângulo de rotação, em radianos, a ser aplicado à `Class.Camera`.

Define a rotação atual aplicada em torno do eixo Z da câmera.

Este método inclina a `Class.Camera` girando-a em torno do
`Class.Camera.Focus|Focus` ao redor do eixo **X** da câmera por um múltiplo dado de 10 graus.

A rotação é aplicada à propriedade `Class.Camera.CFrame|CFrame` da câmera e é
constrangida entre `-81.05` e `81.05` graus.

Camera:TiltUnits

O número de unidades de 10 graus pelas quais inclinar a `Class.Camera`.

Se a inclinação da `Class.Camera` aplicada foi restringida.

Inclina a `Class.Camera` em torno de seu `Class.Camera.Focus|Focus` em incrementos de 10
graus ao redor do eixo **X** da câmera.

Este método cria um `Datatype.Ray` unitário a partir de uma posição 2D nas coordenadas de viewport do dispositivo, definidas em pixels. O raio origina-se do equivalente `Datatype.Vector3` da posição 2D no mundo na profundidade dada (em studs) longe da `Class.Camera`.

Como ilustrado abaixo, `(0, 0)` corresponde ao ponto superior esquerdo da
barra superior do Roblox. Isso significa que a posição 2D de entrada não considera o
recorte `Enum.ScreenInsets|CoreUISafeInsets`, mas considera qualquer `Enum.ScreenInsets|DeviceSafeInsets`.

<img src="../../../assets/engine-api/classes/Camera/ViewportPointToRayOrigin.png" width="840" alt="Diagrama mostrando a origem do sistema de coordenadas de viewport da área segura do dispositivo." />

Observe que instâncias de UI usam um sistema de coordenadas diferente
(`Class.GuiObject.AbsolutePosition` usa o sistema de coordenadas de viewport
`Enum.ScreenInsets|CoreUISafeInsets`, enquanto este método usa o sistema de coordenadas de viewport
`Enum.ScreenInsets|DeviceSafeInsets`). Se você gostaria de especificar a posição em coordenadas de UI principais,
pode usar `Class.Camera:ScreenPointToRay()|ScreenPointToRay()`.

Além disso, observe que este método só funciona para a câmera
`Class.Workspace.CurrentCamera`. Outras câmeras, como aquelas que você
cria para um `Class.ViewportFrame`, têm um tamanho inicial de viewport de
`(1, 1)` e só são atualizadas após você defini-las como
`Class.Workspace.CurrentCamera|CurrentCamera`. A incompatibilidade no tamanho do viewport
faz com que a câmera retorne um raio com uma `Datatype.Ray.Direction` incorreta.

Este método pode ser usado em conjunto com a propriedade
`Class.Camera.ViewportSize|ViewportSize` para criar um raio a partir do
centro da tela, por exemplo:

```lua
local camera = workspace.CurrentCamera

local viewportPoint = camera.ViewportSize / 2
local unitRay = camera:ViewportPointToRay(viewportPoint.X, viewportPoint.Y, 0)
```
Como o `Datatype.Ray` criado é um raio unitário, ele tem apenas um stud de comprimento. Para
criar um raio mais longo, você pode fazer o seguinte:

```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

A posição no eixo **X**, em pixels, do ponto de viewport a partir do qual
originar o `Datatype.Ray`, nas coordenadas da área segura do dispositivo.

A posição no eixo **Y**, em pixels, do ponto de viewport a partir do qual
originar o `Datatype.Ray`, nas coordenadas da área segura do dispositivo.

Um `Datatype.Ray` unitário, originando-se da posição de mundo equivalente
`Datatype.Vector3` das coordenadas de viewport dadas na profundidade dada longe da `Class.Camera`. Este raio está orientado
na direção da `Class.Camera`.

Cria um `Datatype.Ray` unitário a partir de uma posição no viewport (em pixels),
em uma profundidade dada a partir da `Class.Camera`, orientada na direção da câmera. Não considera o recorte `Enum.ScreenInsets|CoreUISafeInsets`.

Este método retorna a localização na tela e a profundidade de um `Datatype.Vector3`
`worldPoint` e se este ponto está dentro dos limites da tela.

Este método leva em conta o recorte da GUI atual, como o espaço
ocupado pela barra superior, o que significa que a posição 2D retornada está nos mesmos termos que as posições da GUI e pode ser usada para posicionar elementos da GUI. Para um
método idêntico que ignora o recorte da GUI, veja
`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
```
Observe que este método não realiza nenhum raycasting e o booleano
indicando se `worldPoint` está dentro dos limites da tela será
`true` independentemente de o ponto estar obscurecido por
`Class.BasePart|BaseParts` ou `Class.Terrain`.

Camera:WorldToScreenPoint

worldPoint

Uma tupla contendo, em ordem:

- Um `Datatype.Vector3` cujos componentes **X** e **Y** representam o
deslocamento do `worldPoint` a partir do canto superior esquerdo da tela,
em pixels. O componente **Z** do `Datatype.Vector3` representa a
profundidade do `worldPoint` a partir da tela (em studs).

- Um booleano indicando se o `worldPoint` está dentro dos limites da
  tela.

Retorna a localização na tela e a profundidade de um `Datatype.Vector3` `worldPoint`
e se este ponto está dentro dos limites da tela. Considera o recorte da GUI.

Este método retorna a localização na tela e a profundidade de um `Datatype.Vector3`
`worldPoint` e se este ponto está dentro dos limites da tela.

Este método não leva em conta o recorte da GUI atual, como o
espaço ocupado pela barra superior, o que significa que a posição 2D retornada é
retirada do canto superior esquerdo do viewport. A menos que você esteja usando
`Class.ScreenGui.IgnoreGuiInset`, esta posição não é apropriada para
posicionar elementos da GUI.

Para um método idêntico que considera o recorte da GUI, veja
`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
```
Observe que este método não realiza nenhum raycasting e o booleano
indicando se `worldPoint` está dentro dos limites da tela será
`true` independentemente de o ponto estar obscurecido por
`Class.BasePart|BaseParts` ou `Class.Terrain`.

##### Câmeras do ViewportFrame

Apenas `Class.Workspace.CurrentCamera` tem suas dimensões internas de viewport
atualizadas pelo motor a cada quadro. Câmeras usadas dentro de um
`Class.ViewportFrame` não recebem atualizações de viewport, então os componentes X e Y
retornados por este método estarão na faixa [0, 1] em vez de
em pixels. Na prática, isso significa que os valores retornados podem ser usados como
coordenadas de escala (por exemplo,
`Datatype.UDim2|UDim2.fromScale(vector.X, vector.Y)`) para posicionar elementos da GUI
relativos ao ViewportFrame.

Camera:WorldToViewportPoint

Uma tupla contendo, em ordem:

- Um `Datatype.Vector3` cujos componentes **X** e **Y** representam o
deslocamento do `worldPoint` a partir do canto superior esquerdo do viewport,
em pixels para `Class.Workspace.CurrentCamera`. Para câmeras dentro de um
`Class.ViewportFrame`, os valores são normalizados para [0, 1]. O
componente **Z** do `Datatype.Vector3` representa a profundidade do
`worldPoint` a partir da tela (em studs).

- Um booleano indicando se o `worldPoint` está dentro dos limites da
  tela.

Retorna a localização na tela e a profundidade de um `Datatype.Vector3` `worldPoint`
e se este ponto está dentro dos limites da tela. Não considera o recorte da GUI.

Demonstra `Class.Camera:ZoomToExtents()`.


Este método ajusta o `Class.Camera.CFrame|CFrame` para que uma caixa delimitadora especificada
esteja totalmente visível dentro do viewport da câmera, sem
cortar qualquer parte da caixa.

A caixa delimitadora é definida pelo seu centro e orientação
(`boundingBoxCFrame`) e seu tamanho (`boundingBoxSize`).

Isso pode ser usado para focar a câmera em um objeto ou modelo 3D, como ao
enquadrar conteúdo em um `Class.ViewportFrame`, tirar capturas de tela, ou
transicionar suavemente a câmera para destacar conteúdo específico.

O método leva automaticamente em conta o campo de visão da câmera e
proporção de aspecto do viewport para garantir que toda a caixa delimitadora se encaixe.

Camera:ZoomToExtents

boundingBoxCFrame

O `Datatype.CFrame` representando o centro e a orientação da
caixa delimitadora a ser ajustada no viewport.

boundingBoxSize

O `Datatype.Vector3` tamanho da caixa delimitadora a ser ajustada no
viewport.

Ajusta o `Class.Camera.CFrame|CFrame` para que a caixa delimitadora especificada
esteja totalmente visível dentro do viewport da câmera.

Camera

`CameraSubject` aceita uma variedade de `Class.Instance|Instances`. Os
scripts de câmera padrão respondem de maneira diferente às configurações disponíveis:

- Por padrão, os scripts de câmera seguem o `Class.Humanoid` do personagem local,
  considerando o estado atual do humanoide e `Class.Humanoid.CameraOffset`.

- Quando definido como um `Class.BasePart`, os scripts de câmera seguem sua posição,
  com um deslocamento vertical no caso de `Class.VehicleSeat|VehicleSeats`.

`CameraSubject` não pode ser definido como `nil`. Tentar fazê-lo reverterá para seu
valor anterior.

Para restaurar `CameraSubject` ao seu valor padrão, defina-o como o `Class.Humanoid`
do personagem local:

Camera.CameraSubject

O `Class.Humanoid` ou `Class.BasePart` que é o sujeito da `Class.Camera`.

Os scripts de câmera padrão do Roblox têm vários comportamentos embutidos. Definir
esta propriedade alterna entre os vários comportamentos de `Enum.CameraType`.
Observe que alguns tipos de câmera requerem um `Class.Camera.CameraSubject|CameraSubject` válido para funcionar corretamente.

Os scripts de câmera padrão não moverão ou atualizarão a câmera se
`CameraType` estiver definido como `Enum.CameraType.Scriptable`. Para mais informações
sobre como posicionar e orientar a câmera manualmente, veja
`Class.Camera.CFrame|CFrame`.

Para todas as configurações de `CameraType`, **exceto** `Enum.CameraType.Scriptable`, a
propriedade `Class.Camera.CameraSubject|CameraSubject` representa o objeto
cuja posição o `Class.Camera.Focus|Focus` da câmera está definido.

Camera.CameraType

Especifica o `Enum.CameraType` a ser lido pelos scripts de câmera.

Esta propriedade é o `Datatype.CFrame` da `Class.Camera`, definindo sua
posição e orientação no mundo 3D. Observe que algumas transformações,
such as the rotation of the head when using VR devices, are not reflected
in this property, so you should use
`Class.Camera:GetRenderCFrame()|GetRenderCFrame()` to obtain the "true"
`Datatype.CFrame` of the camera.

Você pode mover a câmera definindo esta propriedade. No entanto, os scripts de
câmera padrão também a definem, então você deve:

- Definir o `Class.Camera.CameraType|CameraType` da câmera para
  `Enum.CameraType.Scriptable` para que os scripts de câmera padrão não
  atualizem o `Datatype.CFrame` da câmera. Este método é o mais simples e
  recomendado na maioria dos casos.

- Substituir completamente os scripts de câmera padrão por alternativas. Esta
  abordagem é recomendada apenas se você não precisar de nenhuma funcionalidade de câmera padrão.

A maneira mais intuitiva de posicionar e orientar a `Class.Camera` é usando o
construtor `Datatype.CFrame.lookAt()`. No exemplo a seguir, a `Class.Camera` é
posicionada em `Datatype.Vector3.new(0, 10, 0)` e orientada para olhar em direção a
`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)
```
Embora a câmera possa ser colocada da maneira demonstrada acima, você
pode querer animá-la para se mover suavemente de um `Datatype.CFrame` para
outro. Para isso, você pode:

- Definir a posição/orientação da câmera a cada quadro com
  `Class.RunService:BindToRenderStep()` e o método `Datatype.CFrame:Lerp()`.
- Criar e reproduzir um `Class.Tween` que anima a posição/orientação
  da câmera:

  
```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

O `Datatype.CFrame` da `Class.Camera`, definindo sua posição e
orientação no mundo 3D.

A versão antiga da propriedade `Class.Camera.CFrame|CFrame` que
funciona de forma idêntica a ela.

Este item deve ser usado em um `Class.LocalScript` para funcionar como
esperado online.

Camera.CoordinateFrame

Define quantos graus na direção diagonal (de um canto do
viewport até o canto oposto) a câmera pode ver. Veja
`Class.Camera.FieldOfView|FieldOfView` para uma explicação mais geral do
campo de visão.

Observe que `DiagonalFieldOfView` representa o campo de visão que é
visível pela `Class.Camera` renderizando na área de tela cheia que pode
ser ocluída por recortes ou cortes de tela em alguns dispositivos. Veja
`Class.Camera.ViewportSize|ViewportSize` para mais informações.

Camera.DiagonalFieldOfView

Define o ângulo do campo de visão diagonal da câmera.

A propriedade `FieldOfView` (FOV) define quantos graus na direção vertical a
câmera pode ver. Esta propriedade é limitada entre `1` e `120` graus e
por padrão é `70`. Campos de visão muito baixos ou muito altos não são
recomendados, pois podem desorientar os jogadores.

Observe que a escala uniforme é aplicada, o que significa que o campo de
visão vertical e horizontal está sempre relacionado pela proporção de aspecto da tela.

Usos sugeridos para `FieldOfView` incluem:

- Reduzir o FOV para dar a impressão de magnificação, por exemplo, ao
  usar binóculos.
- Aumentar o FOV quando o jogador está "correndo" para dar a impressão de
  falta de controle.

Observe que `FieldOfView` representa o campo de visão que é visível pela
`Class.Camera` renderizando na área de tela cheia que pode ser
ocluída por recortes ou cortes de tela em alguns dispositivos. Veja
`Class.Camera.ViewportSize|ViewportSize` para mais informações.

Camera.FieldOfView

Define o ângulo do campo de visão vertical da câmera.

O `Class.Camera.FieldOfView|FieldOfView` (FOV) da câmera deve ser atualizado
para refletir as mudanças de `Class.Camera.ViewportSize|ViewportSize`. O valor de
`FieldOfViewMode` determina qual valor de FOV será mantido constante.

Por exemplo, quando esta propriedade é definida como `Enum.FieldOfViewMode.Vertical`,
o FOV horizontal é atualizado quando o viewport é redimensionado, mas o
FOV vertical é mantido constante. Se esta propriedade for definida como
`Enum.FieldOfViewMode.Diagonal`, tanto o FOV horizontal quanto o vertical podem ser
alterados para manter o FOV diagonal constante.

Camera.FieldOfViewMode

Determina o valor FOV da `Class.Camera` que é invariável sob
mudanças de tamanho de viewport.

Certas operações gráficas que o motor realiza, como atualizar
iluminação, podem levar tempo ou esforço computacional para serem concluídas. A
propriedade `Focus` da câmera informa ao motor qual área no espaço 3D priorizar
quando realiza tais operações. Por exemplo, a iluminação dinâmica de
objetos como `Class.PointLight|PointLights` pode não ser renderizada a distâncias
longas do foco.

Os scripts de câmera padrão do Roblox definem automaticamente `Focus` para seguir o
`Class.Camera.CameraSubject|CameraSubject` (geralmente um `Class.Humanoid`).
No entanto, `Focus` **não** será atualizado automaticamente quando
`Class.Camera.CameraType|CameraType` estiver definido como
`Enum.CameraType.Scriptable` ou quando os scripts de câmera padrão não estiverem
sendo usados. Nesses casos, você deve atualizar `Focus` a cada quadro, usando o
método `Class.RunService:BindToRenderStep()` na prioridade
`Enum.RenderPriority.Camera`.

`Focus` não tem influência sobre a posição ou orientação da câmera; veja
`Class.Camera.CFrame|CFrame` para isso.

Camera.Focus

Define a área no espaço 3D que é priorizada pelos sistemas gráficos
do Roblox.

Camera.focus

Alterna se a câmera irá rastrear automaticamente o movimento da cabeça de um
jogador usando um dispositivo VR. Quando `true` (padrão), o motor combina
`Class.Camera.CFrame|CFrame` com o `Enum.UserCFrame` da cabeça do usuário
para renderizar a visão do jogador com o rastreamento da cabeça considerado. A visão será
renderizada na seguinte `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

-- Isso será equivalente a Camera:GetRenderCFrame()
local renderCFrame = camera.CFrame * headCFrame
```
É recomendado **não** desativar esta propriedade pelos seguintes
motivos:

- Os jogadores podem experimentar enjoo se uma solução equivalente de rastreamento da cabeça
  não for adicionada.
- O motor Roblox realiza otimizações de latência quando `HeadLocked` é
  verdadeiro.

##### Veja Também

- `Class.VRService:GetUserCFrame()` que pode ser usado para obter o
  `Datatype.CFrame` da cabeça.
- `Class.VRService:RecenterUserHeadCFrame()` que é usado para recentrar a
  cabeça na posição e orientação atuais do dispositivo VR.
- O método `Class.Camera:GetRenderCFrame()|GetRenderCFrame()` que
  retorna o `Class.Camera.CFrame|CFrame` combinado com o
  `Datatype.CFrame` da cabeça do usuário.

Camera.HeadLocked

Alterna se a câmera irá rastrear automaticamente o movimento da cabeça de um
jogador usando um dispositivo VR.

`HeadScale` é a escala da perspectiva do usuário do mundo ao usar
VR.

O tamanho de 1 stud em VR é `0.3 metros / HeadScale`, o que significa que valores maiores
`HeadScale` equivalem a um mundo que parece menor da perspectiva do usuário ao usar
dispositivos VR. Por exemplo, uma parte que tem 1 stud de altura
parece ter 0.6 metros de altura para um jogador VR com um `HeadScale` de `0.5`.

Esta propriedade é controlada automaticamente por
`Class.VRService.AutomaticScaling` para alinhar a perspectiva do jogador com
o tamanho de seu avatar. Se você pretende controlar `HeadScale` você mesmo ou
usar personagens personalizados, altere `Class.VRService.AutomaticScaling` para
`Enum.VRScaling.Off`.

Esta propriedade não deve ser confundida com `Class.Humanoid.HeadScale` que
é um `Class.NumberValue` parentado a um `Class.Humanoid` para controlar sua
escala.

Camera.HeadScale

Define a escala da perspectiva do usuário do mundo ao usar VR.

A propriedade `MaxAxisFieldOfView` define quantos graus ao longo do maior
eixo do viewport a câmera pode ver.

Quando o maior eixo é o eixo vertical, esta propriedade se comportará
semelhante à propriedade `Class.Camera.FieldOfView|FieldOfView`. Este é
geralmente o caso quando um dispositivo está em orientação retrato. Em uma
orientação paisagem, o maior eixo será o eixo horizontal; neste caso, a
propriedade descreve o campo de visão horizontal da `Class.Camera`.

Camera.MaxAxisFieldOfView

Define o ângulo do campo de visão da câmera ao longo do maior eixo do viewport.

A propriedade `NearPlaneZ` descreve quão longe o plano de recorte próximo da câmera está, em studs. O plano de recorte próximo é um plano geométrico que fica na frente do `Class.Camera.CFrame|CFrame` da câmera. Qualquer coisa entre este plano e a câmera não será renderizada, criando uma visão cortada ao visualizar objetos a distâncias muito curtas. O valor de `NearPlaneZ`
vai variar entre diferentes plataformas e atualmente está sempre entre `-0.1`
e `-0.5`.

<img src="/assets/engine-api/classes/Camera/NearPlaneZ.jpg" width="720" alt="Diagrama mostrando como o NearPlaneZ corta (não renderiza) conteúdo 3D entre o plano e a câmera." />

Camera.NearPlaneZ

Descreve o deslocamento negativo **Z**, em studs, do plano de recorte próximo da câmera.

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

Por exemplo, quando esta propriedade é definida como
`Enum.OrthographicMode.Vertical`, a projeção ortográfica é escalada
para que a dimensão vertical abranja exatamente
`Class.Camera.OrthographicSize|OrthographicSize` studs, e a dimensão
horizontal abranja quantos studs forem necessários para corresponder.

Camera.OrthographicMode

Define qual eixo da tela `Class.Camera.OrthographicSize|OrthographicSize` é
aplicado.

`Class.Camera.OrthographicMode|OrthographicMode` escolhe a dimensão do
viewport que você deseja controlar.
`Class.Camera.OrthographicSize|OrthographicSize` define a extensão em studs
abrangida por essa dimensão do viewport.

Por exemplo, se `Class.Camera.OrthographicMode|OrthographicMode` for definido como
`Enum.OrthographicMode.MaxAxis`, então a dimensão maior do viewport
abrangerá `Class.Camera.OrthographicSize|OrthographicSize` studs.

Camera.OrthographicSize

Define a extensão em studs da dimensão escolhida por
`Class.Camera.OrthographicMode|OrthographicMode`.

Defina como `Enum.ProjectionType.Perspective` (padrão) para usar uma
câmera perspectiva, onde linhas paralelas em 3D convergem na tela e objetos
ficam menores à distância. Defina como `Enum.ProjectionType.Orthographic` para usar
uma câmera ortográfica, onde linhas paralelas permanecem paralelas e objetos têm
o mesmo tamanho a qualquer distância. Isso é útil para coisas como jogos 2D,
jogos isométricos e minimapas.

Camera.ProjectionType

Escolhe entre câmeras perspectiva e ortográfica.

`ViewportSize` retorna as dimensões da área segura do dispositivo na
tela atual. Esta área é um retângulo que inclui a área da barra superior do Roblox
mas não inclui quaisquer recortes ou entalhes do dispositivo. As unidades
de `ViewportSize` são unidades de deslocamento da UI do Roblox que podem ser diferentes
em relação aos pixels nativos da tela.

<img src="../../../assets/engine-api/classes/Camera/DeviceSafeAreaVsFullscreen.png" width="840" alt="Tela de dispositivo móvel com recorte mostrando a área segura do dispositivo." />

Como mencionado acima, `ViewportSize` não é igual ao tamanho da área em tela cheia em
displays com recortes ou entalhes. Para obter o tamanho da área em tela cheia em
todos os displays, você pode consultar a
propriedade `Class.ScreenGui.AbsoluteSize|AbsoluteSize` de um
`Class.ScreenGui` com `Class.ScreenGui.ScreenInsets|ScreenInsets` definido como
`Enum.ScreenInsets.None|None`. Veja `Enum.ScreenInsets` para mais
informações sobre como as áreas da tela são definidas.

Finalmente, note que `ViewportSize` não é o tamanho real do viewport que a
câmera usa para renderização (a câmera renderiza na área em tela cheia).
Além disso, as propriedades `Class.Camera.FieldOfView|FieldOfView` e
`Class.Camera.DiagonalFieldOfView|DiagonalFieldOfView` são
baseadas na área em tela cheia, não em `ViewportSize`.

##### Atualizações da Câmera

Apenas a `Class.Camera` atualmente referida por
`Class.Workspace.CurrentCamera` tem seu `ViewportSize` atualizado a cada quadro
durante a etapa `Class.RunService.PreRender|PreRender`. O `ViewportSize`
de todas as outras câmeras em sua experiência não será atualizado, incluindo aquelas
usadas para `Class.ViewportFrame|ViewportFrames`.

Camera.ViewportSize

As dimensões da área segura do dispositivo em um cliente Roblox.

O campo de visão e o tamanho ortográfico são especificados para um eixo do
viewport, seja horizontal ou vertical. Normalmente, o outro eixo
ajusta-se automaticamente para manter os pixels quadrados. Isso permite que você estique
o outro eixo para que os pixels não sejam quadrados, por uma razão de até 2:1.
Isso pode ser animado para fazer a visão parecer um pouco errada, como quando
está atordoado.

Isso funciona tanto para câmeras ortográficas quanto para perspectivas.

Camera.ViewStretch

Estica o eixo da visão que não está fixo pelo atual
`Class.Camera.FieldOfViewMode|FieldOfViewMode` ou
`Class.Camera.OrthographicMode|OrthographicMode`.

Esta propriedade alterna se deve aplicar inclinação e rotação da
propriedade `Class.Camera.CFrame|CFrame` enquanto o jogador está usando um dispositivo VR.

Para evitar enjoo, o horizonte deve permanecer nivelado. Inclinando e
rolando a visão do jogador enquanto usa um dispositivo VR pode causar uma desconexão
entre o espaço físico do jogador e o espaço virtual que ele está
visualizando. Alterar a direção aparente para baixo pode fazer com que os jogadores
percam o equilíbrio ou sintam tontura.

Por essas razões, geralmente é aconselhável deixar esta propriedade
desativada, a menos que você tenha testado extensivamente sua experiência para esses
efeitos. Mesmo com inclinação e rotação habilitadas, você pode querer garantir que o
jogador sempre tenha um quadro de referência estável, como o interior de um
veículo ou um chão que possa ajudar o jogador a se ancorar em seu
espaço físico.

Camera.VRTiltAndRollEnabled

Alterna se deve aplicar inclinação e rotação da
propriedade `Class.Camera.CFrame|CFrame` enquanto o jogador está usando um dispositivo VR.

Uma classe que define uma visão do mundo 3D.

Uma `Class.PVInstance` é uma classe abstrata que não pode ser criada. É a
base para todos os objetos que têm uma localização física no mundo.

Este exemplo de código é um script de teletransporte simples que move seu personagem
10&nbsp;studs para frente na direção que você está olhando quando você pressiona
a tecla <kbd>F</kbd>. Ele faz isso obtendo o pivô atual com
`Class.PVInstance:GetPivot()` e chamando `PVInstance|PivotTo` para mover o
personagem para frente.


Esta função obtém o pivô de uma `Class.PVInstance`. Isso é frequentemente utilizado
com `Class.PVInstance:PivotTo()` para mover um modelo.

`Class.Model|Models` e `Class.BasePart|BaseParts` são ambos
`Class.PVInstance|PVInstances` ("Instâncias de Velocidade de Posição") e assim ambos
possuem esta função.

PVInstance:GetPivot

O `Datatype.CFrame` no espaço mundial do pivot da instância.


Obtém o pivô de uma `Class.PVInstance`.

Transforma a `Class.PVInstance` junto com todos os seus descendentes
`Class.PVInstance|PVInstances` de modo que o pivô agora esteja localizado na
`Datatype.CFrame` especificada. Esta é a função principal que deve ser
usada para mover `Class.Model|Models` via script.

`Class.BasePart|BaseParts` são movidos dessa forma ao ter seu
`Datatype.CFrame` transformado pelo deslocamento necessário.
`Class.Model|Models` são movidos dessa forma ao ter seu
`Class.Model.WorldPivot` transformado pelo deslocamento necessário.

Note que, por questões de eficiência, eventos `Class.Object.Changed` não são
disparados para `Class.BasePart.Position|Position` e
`Class.BasePart.Orientation|Orientation` de `Class.BasePart|BaseParts`
movidos desta forma; eles são disparados apenas para `Datatype.CFrame`.

Ao chamar `Class.PVInstance:PivotTo()|PivotTo` em `Class.Model|Models`,
os deslocamentos das partes e modelos descendentes são armazenados em cache, de
modo que chamadas subsequentes a `Class.PVInstance:PivotTo()|PivotTo` no mesmo modelo
dnão acumulam deriva de ponto flutuante entre as partes que compõem o
modelo.

`Class.Model|Models` e `Class.BasePart|BaseParts` são ambos
`Class.PVInstance|PVInstances` ("Instâncias de Velocidade de Posição") e assim ambos
possuem esta função.

PVInstance:PivotTo

targetCFrame

O `Datatype.CFrame` que o pivô da `Class.PVInstance` deve igualar
depois de movê-lo.

Transforma a `Class.PVInstance` junto com todos os seus descendentes
`Class.PVInstance|PVInstances` de modo que o pivô agora esteja localizado na
`Datatype.CFrame` especificada.

PVInstance

Propriedade exclusiva do editor, exibida na janela de Propriedades do Studio como **Posição
Origem** e **Orientação Origem** sob **Transformar**. Seu valor é
o `Datatype.CFrame` no espaço mundial do pivot da instância; lê-lo
retorna o mesmo `Datatype.CFrame` que `Class.PVInstance:GetPivot()`. Ele
não possui valor armazenado próprio e sempre reflete o pivot atual.

Defini-lo a partir da janela de Propriedades move toda a instância para que seu
pivot fique na nova `Datatype.CFrame`, muito parecido com
`Class.PVInstance:PivotTo()`. Editar através da janela de Propriedades
desabilita temporariamente `Class.WeldConstraint|WeldConstraints` para outros
objetos durante o movimento; `PivotTo` não modifica juntas.

Não disponível para scripts; use `Class.PVInstance:GetPivot()` e
`Class.PVInstance:PivotTo()` em tempo de execução em vez disso.


PVInstance.Origin

Propriedade exclusiva do editor que lê e define o `Datatype.CFrame` mundial do
pivot do `Class.PVInstance`, movendo toda a instância quando alterado
na janela de Propriedades do Studio.


Propriedade exclusiva do editor, exibida na janela de Propriedades do Studio como **Posição
Pivot** e **Orientação Pivot** sob **Pivot**. É o
`Datatype.CFrame` do pivot relativo ao próprio quadro da instância.

Alterá-lo a partir da janela de Propriedades move o pivot em relação à
instância enquanto deixa a instância no lugar, ao contrário de `Origem`, que move
toda a instância. Para um `Class.BasePart`, o deslocamento padrão é o
`Datatype.CFrame` identidade, então o pivot coincide com o centro da parte.
Para um `Class.Model`, esta propriedade aparece apenas quando o modelo tem um
`Class.Model.PrimaryPart|PrimaryPart`; ela então reflete e edita o
`Class.BasePart.PivotOffset|PivotOffset` daquela parte, e
`Class.Model:GetPivot()` é um alias do pivot da parte primária.

Não disponível para scripts; scripts leem e escrevem o equivalente através
da classe concreta, como `Class.BasePart.PivotOffset`.


PVInstance.Pivot Offset

Propriedade exclusiva do editor que exibe e edita o `Datatype.CFrame` do pivot
relativo à instância, movendo apenas o pivot e deixando a instância
no lugar.


Classe abstrata para todos os objetos que têm uma localização física no mundo.

`Instance` é a classe base para todas as classes na hierarquia de classes do Roblox
que podem fazer parte da árvore `Class.DataModel`.

Não é possível criar objetos `Instance` raiz diretamente, mas o construtor especial
`Datatype.Instance.new()` cria objetos via código, recebendo o
nome da classe como parâmetro e retornando o objeto criado.

Demonstra como detectar mudanças na ancestralidade de uma instância conectando-se ao
`Class.Instance.AncestryChanged` evento.

O Parent do ChangingPart é definido para valores diferentes ao longo do tempo. O pai da
peça é o ancestral da peça, então o evento `Class.Instance.AncestryChanged`
será acionado sempre que mudar.

Dispara quando esta instância é reparentada ou quando qualquer um de seus ancestrais é
reparentado.

Você pode usar este evento para rastrear a exclusão de uma instância no Studio,
such as exclusão manual no Explorer ou através de um plugin. Se você precisar
detectar quando uma instância é destruída usando `Class.Instance:Destroy()`,
use o evento `Class.Instance.Destroying` em vez disso.

Instance.AncestryChanged

child

A instância cuja propriedade `Class.Instance.Parent|Parent` mudou,
que pode ser esta instância ou um ancestral mais distante, **não**
necessariamente a instância à qual o manipulador está conectado.

parent

Dispara quando a propriedade `Class.Instance.Parent` deste objeto ou de um de
seus ancestrais é alterada.

Este evento dispara sempre que qualquer atributo é alterado na instância,
incluindo quando um atributo é definido como `nil`. O nome do atributo alterado
é passado para a função conectada.

Por exemplo, o seguinte trecho de código conecta a função `attributeChanged()`
para disparar sempre que um dos atributos da parte muda:

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

local part = Workspace.Part

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

part.AttributeChanged:Connect(attributeChanged)
```
Veja também `Class.Instance:GetAttributeChangedSignal()` que retorna um
evento que dispara quando um atributo específico dado muda.

Instance.AttributeChanged

attribute

Dispara sempre que um atributo é alterado na `Class.Instance`.

Este trecho imprime os nomes dos objetos à medida que são adicionados ao Espaço de Trabalho:


Dispara após um objeto ser parentado a esta `Class.Instance`.

Nota, ao usar este método em um cliente para detectar objetos criados pelo
servidor, é necessário usar `Class.Instance:WaitForChild()` ao
indexar os descendentes desses objetos. Isso ocorre porque o objeto e seus
descendentes não são garantidos para replicar do servidor para o cliente
simultaneamente. Por exemplo:

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

Workspace.ChildAdded:Connect(function(child)
	-- Use WaitForChild() já que os descendentes podem não ter replicado ainda
	local head = child:WaitForChild("Head")
end)
```
Nota, este evento opera apenas para filhos imediatos da
`Class.Instance`. Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantAdded`.

Veja também `Class.Instance.ChildRemoved`.

Instance.ChildAdded

Dispara após um objeto ser parentado a esta `Class.Instance`.

Instance.childAdded

Este trecho imprime os nomes dos objetos à medida que são removidos do
Workspace:


Dispara após um filho ser removido desta `Class.Instance`.

Removido refere-se a quando o pai de um objeto é alterado de esta
`Class.Instance` para algo diferente desta `Class.Instance`. Nota, este
evento também será disparado quando um filho for destruído (usando
`Class.Instance:Destroy()`) uma vez que a função de destruição define o pai de um objeto
como `nil`.

Este evento opera apenas para filhos imediatos da `Class.Instance`.
Para um evento que captura todos os descendentes, use
`Class.Instance.DescendantRemoving`.

Veja também `Class.Instance.ChildAdded`.

Instance.ChildRemoved

Dispara após um filho ser removido desta `Class.Instance`.

Este exemplo a seguir imprimirá o nome de qualquer objeto que for adicionado ao
Espaço de Trabalho:

Este evento dispara após um descendente ser adicionado à `Class.Instance`.

Como ele dispara para cada descendente, parentar um objeto à
`Class.Instance` disparará o evento para este objeto e todos os seus
descendentes individualmente.

Se você está apenas preocupado com os **filhos diretos** da
`Class.Instance`, use `Class.Instance.ChildAdded` em vez disso.

Veja também `Class.Instance.DescendantRemoving`.

Instance.DescendantAdded

descendant

Dispara após um descendente ser adicionado à `Class.Instance`.

O seguinte exemplo imprime o nome de qualquer descendente enquanto está sendo removido
do Workspace:

Este evento dispara **imediatamente antes** que o pai `Class.Instance`
se altere de forma que uma instância **descendente** não será mais um
descendente. `Class.Instance:Destroy()|Destroy()` altera o `Class.Instance.Parent|Parent` de uma instância para `nil`, então chamar esse método em um
descendente do pai fará com que este evento dispare.

Como este evento dispara **antes** da remoção do descendente, o pai do
descendente permanecerá inalterado no momento em que este evento disparar. Se o
descendente também for um **filho direto** do pai, este evento disparará
antes de `Class.Instance.ChildRemoved`.

Se um descendente tiver filhos, este evento disparará com o descendente primeiro,
seguido por seus descendentes.

#### Aviso

Este evento dispara com o objeto descendente que está sendo removido.
Tentar definir o `Class.Instance.Parent|Parent` do descendente para
algo diferente falhará. Abaixo está um exemplo que demonstra isso:

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

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Não manipule o pai do descendente nesta função!
	-- Este evento dispara PORQUE o pai foi manipulado, e a mudança ainda não aconteceu
	-- Portanto, é problemático mudar o pai assim:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```
Veja também `Class.Instance.DescendantAdded|DescendantAdded`.

Instance.DescendantRemoving

O `Class.Instance` que está sendo removido.

Dispara imediatamente antes de um descendente da `Class.Instance` ser removido.

Instance

`Instance` é a classe base para todas as classes na hierarquia de classes do Roblox
que podem fazer parte da árvore `Class.DataModel`.

/reference/engine/classes/ViewportCamera.yaml

Resumo