Camera

Essa propriedade é a CFrame do Camera, definindo sua posição e orientação no mundo 3D.Observe que algumas transformações, como a rotação da cabeça ao usar dispositivos VR, não são refletidas nesta propriedade, então você deve usar GetRenderCFrame() para obter o "verdadeiro" CFrame da Câmera.

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

• Defina a câmera CameraType para Enum.CameraType.Scriptable para que os scripts de câmera padrão não atualizem o CFrame da Câmera.Este método é o mais simples e recomendado na maioria dos casos.

• Substitua completamente os scripts de câmera padrão por alternativas.Essa abordagem só é recomendada se você não precisar de nenhuma funcionalidade padrão da câmera.

A maneira mais intuitiva de posicionar e orientar o Camera é usando o construtor CFrame.lookAt().No seguinte exemplo, o Camera está posicionado em Vector3.new(0, 10, 0) e está orientado para olhar para Vector3.new(10, 0, 0) .

local Workspace = game:GetService("Workspace")

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

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

Workspace.CurrentCamera.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 CFrame.Para isso, você pode:

• Defina a posição/orientação da Câmeraem cada quadro com RunService:BindToRenderStep() e o método CFrame:Lerp().

• Crie e jogue um Tween que anime a posição/orientação da Câmera:

  local Players = game:GetService("Players")
  local TweenService = game:GetService("TweenService")
  local Workspace = game:GetService("Workspace")
  
  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()

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

• Por padrão, os scripts da câmera seguem o estado atual do personagem local e do humanoide.

• Quando definido para um BasePart, os scripts da câmera seguem sua posição, com um deslocamento vertical no caso de VehicleSeats .

CameraSubject não pode ser definido como nil. Tentar fazer isso irá revertê-lo ao seu valor anterior.

Para restaurar CameraSubject ao seu valor padrão, defina-o para o caractere local Humanoid:

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

local localPlayer = Players.LocalPlayer
local camera = Workspace.CurrentCamera

local function resetCameraSubject()
	if camera and localPlayer.Character then
		local humanoid = localPlayer.Character:FindFirstChildWhichIsA("Humanoid")
		if humanoid then
			camera.CameraSubject = humanoid
		end
	end
end

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

Os scripts de câmera padrão não moverão ou atualizarão a câmera se for definido como .Para mais informações sobre posicionamento e orientação da câmera manualmente, veja CFrame .

Para todas as configurações settings exceto , a propriedade representa o objeto cuja posição a Câmeraestá definida.

Define quantos graus na direção diagonal (de um canto da janela de visualização para o canto oposto) a câmera pode ver.Veja FieldOfView.

Observe que DiagonalFieldOfView representa o campo de visão que é visível pelo renderização Camera na área completa da tela que pode ser ocultada por notas ou cortes de tela em alguns dispositivos.Veja ViewportSize para mais informações.

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

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

Uso sugerido para FieldOfView inclui:

• Reduzir 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 uma falta de controle.

Observe que FieldOfView representa o campo de visão que é visível pelo renderização Camera na área completa da tela que pode ser ocultada por notas ou cortes de tela em alguns dispositivos.Veja ViewportSize para mais informações.

O campo de visão da Câmera(FOV) deve ser atualizado para refletir mudanças.O valor de FieldOfViewMode determina qual valor de FOV será mantido constante.

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

Certas operações gráficas que o motor realiza, como atualizar iluminação, pode levar tempo ou esforço de computação para concluir.A propriedade da CâmeraFocus diz ao motor qual área no espaço 3D deve ser priorizada ao executar tais operações.Por exemplo, iluminação dinâmica de objetos como PointLights pode não renderizar a distâncias longe do foco.

Os scripts de câmera padrão do Roblox definem automaticamente Focus para seguir o CameraSubject (geralmente um Humanoid).No entanto, não será atualizado automaticamente quando for definido como 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 RunService:BindToRenderStep() na prioridade Enum.RenderPriority.Camera.

Focus não tem nada a ver com a posição ou orientação da câmera; veja CFrame para isso.

Alterna se a câmera vai automaticamente rastrear o movimento da cabeça de um jogador usando um dispositivo VR.Quando true (padrão), o motor combina CFrame com o Enum.UserCFrame da cabeça do usuário para renderizar a visão do jogador com rastreamento de cabeça fatorado.A visualização será renderizada na seguinte CFrame :

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

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

Recomenda-se não desativar esta propriedade pelos seguintes motivos:

• Jogadores podem experimentar enjoar de movimento se uma solução de rastreamento de cabeça equivalente não for adicionada.
• O motor do Roblox realiza otimizações de latência quando HeadLocked é verdadeiro.

Veja também

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

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

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

Essa propriedade é controlada automaticamente por 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, ative VRService.AutomaticScaling para Enum.VRScaling.Off .

Essa propriedade não deve ser confundida com Humanoid.HeadScale que é um NumberValue parente de um Humanoid para controlar sua escala.

A propriedade MaxAxisFieldOfView define quantos graus ao longo do eixo de janela de visualização mais longo a câmera pode ver.

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

A propriedade NearPlaneZ descreve o quão longe está o plano de clipe próximo da Câmera, em studs.O plano de corteamento próximo é um plano geométrico que fica à frente do da Câmera.Qualquer coisa entre este avião e a câmera não renderizará, criando uma visão de corte ao visualizar objetos a uma distância muito curta.O valor de varia entre diferentes plataformas e está atualmente sempre entre e .

Essa propriedade alterna se deve aplicar inclinação e rotação a partir da propriedade CFrame enquanto o jogador está usando um dispositivo VR.

Para prevenir a doença de movimento, o horizonte deve permanecer nível.Inclinar e rolar 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á vendo.Mudar a direção aparente de baixo para cima pode fazer com que os jogadores percam o equilíbrio ou experimentem tontura.

Por essas razões, geralmente é aconselhável deixar essa propriedade desativada, a menos que você tenha testado extensivamente sua experiência para esses efeitos.Mesmo com a inclinação e a rotação ativadas, 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 estabelecer em seu espaço físico.

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 nenhum notch de dispositivo ou cortes de tela.As unidades de ViewportSize são unidades de deslocamento da interface do usuário Roblox que podem ser diferentes dos pixels de exibição nativos.

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

Por fim, note que ViewportSize não é o tamanho de janela de visualização real que a câmera usa para renderizar (a câmera renderiza na área de tela cheia).Além disso, as propriedades FieldOfView e DiagonalFieldOfView são baseadas na área de tela cheia, não na ViewportSize.

Atualizações de câmera

Apenas o atualmente referido por tem seu atualizado a cada quadro durante o passo .O ViewportSize de todas as outras câmeras em sua experiência não será atualizado, incluindo as usadas para ViewportFrames .

Este método retorna um array de BaseParts que estão obscurecendo as linhas de visão entre as posições CFrame e Vector3 da Câmerano matriz / listacastPoints.Qualquer Instances incluído no array ignoreList será ignorado, juntamente com seus descendentes.

O parâmetro castPoints é dado como um array de Vector3 posições.Observe que o array de BaseParts retornado está em uma ordem arbitrária e nenhum dado de raycast adicional é fornecido.Se você precisar de dados como posição de acerto, material de acerto ou normal de superfície, você deve optar pelo método WorldRoot:Raycast().

local Workspace = game:GetService("Workspace")

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 Terrain obscurecer um ponto de lançamento, BaseParts obscuringir o ponto de lançamento entre o obscurecimento Terrain e o ponto de lançamento não será retornado.

Parâmetros

Devolução

Este método retorna o real CFrame da Camera como é renderizado, incluindo o impacto da VR (as transformações da cabeça da VR não são aplicadas à propriedade CFrame , então é melhor prática usar GetRenderCFrame() para obter o "verdadeiro" CFrame da visão de um jogador).

Por exemplo, ao usar VR, o Camera é realmente renderizado no seguinte CFrame :

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

local camera = Workspace.CurrentCamera

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

O render da CâmeraCFrame só será alterado para contar a cabeça quando a propriedade HeadLocked for verdadeira.

Devolução

Este método retorna, em radianos, o rolo atual aplicado ao Camera usando SetRoll().Rola é definida como rotação em torno do eixo Z da Câmera.

Este método retorna apenas rolos aplicados usando o método SetRoll().Rolo aplicado manualmente à CâmeraCFrame não é contado.Para obter o rolo real do Camera, incluindo o rolo aplicado manualmente, você pode usar o seguinte trecho:

local Workspace = game:GetService("Workspace")

local function getActualRoll()
	local camera = Workspace.CurrentCamera

	local trueUp = Vector3.new(0, 1, 0)
	local cameraUp = camera:GetRenderCFrame().upVector

	return math.acos(trueUp:Dot(cameraUp))
end

Devolução

local currentRoll = math.deg(workspace.CurrentCamera:GetRoll()) -- Gets the current roll of the camera in degrees.

if currentRoll ~= 20 then
	workspace.CurrentCamera:SetRoll(math.rad(20)) -- If the camera isn't at 20 degrees roll, the roll is set to 20 degrees.
end

Este método cria uma unidade Ray a partir de uma posição de 2D na tela (definida em pixels), contabilizando a inserção da GUI.O Ray tem origem no Vector3 equivalente da posição 2D no mundo na profundidade dada (em studs) longe do Camera .

Como este método reconhece a inserção da GUI, o deslocamento aplicado aos elementos da GUI (como da barra superior) é contabilizado.Isso significa que a posição da tela especificada começará no canto superior esquerdo abaixo da barra superior.Para um método de outra forma idêntico que não leva em conta o deslocamento da GUI, use ViewportPointToRay().

Como o Ray criado é um raio de unidade, ele é apenas um estudo longo. Para criar um raio mais longo, você pode fazer o seguindo:

local Workspace = game:GetService("Workspace")

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âmeraatual Workspace .Outras câmeras, como aquelas que você cria para um ViewportFrame , têm um tamanho inicial de janela de visualização de (1, 1) e são atualizadas somente após você definir elas para Workspace.CurrentCamera .A discrepância no tamanho da janela de visualização faz com que a câmera retorne um raio com um erro de Ray.Direction.

Parâmetros

Devolução

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

Este método define o rolo atual, em radianos, do Camera.O rolo é aplicado após o CFrame e representa a rotação em torno do eixo Z da Câmera.

Por exemplo, o seguinte inverteria o Camera :

local Workspace = game:GetService("Workspace")

Workspace.CurrentCamera:SetRoll(math.pi) -- math.pi radians = 180 degrees

SetRoll não tem efeito em qualquer rolagem aplicada usando a propriedade CFrame.O rolo aplicado usando SetRoll não é refletido na propriedade CFrame mas é refletido na propriedade CFrame retornada por GetRenderCFrame().

Este método só pode ser usado quando o CameraType é definido como Scriptable, independentemente de se os scripts de câmera padrão estão sendo usados.Se for usado com qualquer outro CameraType uma advertência é dada na saída.

Qualquer rolagem aplicada usando este método será perdida quando o CameraType for alterado de Scriptable.

Para obter o conjunto de rolos usando este método, use GetRoll().

Como este método está desatualizado, você é aconselhado a aplicar rolagem ao Camera usando a propriedade CFrame. Por exemplo:

local Workspace = game:GetService("Workspace")

local currentCFrame = Workspace.CurrentCamera.CFrame
local rollCFrame = CFrame.Angles(0, 0, roll)
Workspace.CurrentCamera.CFrame = currentCFrame * rollCFrame

Parâmetros

Devolução

Este método cria uma unidade Ray a partir de uma posição de 2D na janela segura de visualização do dispositivo, definida em pixels.O raio se origina do equivalente da posição 2D no mundo na profundidade dada (em studs) longe do .

Como ilustrado abaixo, (0, 0) corresponde ao ponto superior esquerdo da barra superior do Roblox.Isso significa que a posição de entrada de 2D não não conta para o CoreUISafeInsets inseto, mas conta por qualquer DeviceSafeInsets .

Observe que as instâncias de UI usam um sistema de coordenadas diferente ( usa o sistema de coordenadas do painel de visualização enquanto este método usa o sistema de coordenadas do painel de visualização).Se você quiser especificar a posição nas coordenadas de UI do núcleo, use ScreenPointToRay().

Observe também que este método só funciona para a CâmeraWorkspace.CurrentCamera .Outras câmeras, como as que você cria para um ViewportFrame , têm um tamanho inicial de janela de visualização de (1, 1) e são atualizadas somente após você definir elas para CurrentCamera .A discrepância no tamanho da janela de visualização faz com que a câmera retorne um raio com um erro de Ray.Direction .

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

local Workspace = game:GetService("Workspace")

local camera = Workspace.CurrentCamera

local viewportPoint = camera.ViewportSize / 2
local unitRay = camera:ViewportPointToRay(viewportPoint.X, viewportPoint.Y, 0)

Como o Ray criado é um raio de unidade, ele é apenas um estudo longo. Para criar um raio mais longo, você pode fazer o seguindo:

local Workspace = game:GetService("Workspace")

local camera = Workspace.CurrentCamera

local length = 500
local unitRay = camera:ScreenPointToRay(100, 100)
local extendedRay = Ray.new(unitRay.Origin, unitRay.Direction * length)

Parâmetros

Devolução

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

Este método leva em consideração o inserção de GUI atual, como o espaço ocupado pela barra superior, significando que a posição 2D retornada está no mesmo termo que as posições de GUI e pode ser usada para colocar elementos de GUI.Para um método de outra forma idêntico que ignora a inserção da GUI, veja WorldToViewportPoint() .

local Workspace = game:GetService("Workspace")

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 lançamento de raio e o booleano que indica se worldPoint está dentro dos limites da tela será true independentemente de se o ponto está obstruído por BaseParts ou Terrain .

Parâmetros

Devolução

Este método retorna a localização da 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 consideração a inserção de GUI atual, como o espaço ocupado pela barra superior, significando que a posição 2D retornada é retirada do canto superior esquerdo da janela de visualização.A menos que você esteja usando ScreenGui.IgnoreGuiInset, essa posição não é apropriada para colocar elementos de GUI.

Para um método de outra forma idêntico que representa a inserção da GUI, veja WorldToScreenPoint() .

local Workspace = game:GetService("Workspace")

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 lançamento de raio e o booleano que indica se worldPoint está dentro dos limites da tela será true independentemente de se o ponto está obstruído por BaseParts ou Terrain .

Parâmetros

Devolução

Parâmetros

Devolução

Este evento dispara quando o Camera acabou de interpolar usando o método Camera:Interpolate().Não disparará se um pré-adolescente for interrompido devido a Camera:Interpolate() ser chamado novamente.

Você é aconselhado a usar TweenService para animar o Camera em vez disso, pois é mais confiável e oferece mais opções para facilitar os estilos.