Camera

Questa proprietà è la CFrame del Camera, che definisce la sua posizione e orientamento nel Mondo3D.Si noti che alcune trasformazioni, come la rotazione della testa quando si utilizzano dispositivi VR, non sono riflesse in questa Proprietà, quindi si dovrebbe utilizzare GetRenderCFrame() per ottenere il "vero" CFrame della Telecamera.

Puoi spostare la fotocamera impostando questa Proprietà. Tuttavia, gli script della fotocamera predefinita lo impostano anche, quindi dovresti:

• Imposta la fotocamera CameraType a Enum.CameraType.Scriptable in modo che gli script della Telecamerapredefinita non aggiornino il CFrame della fotocamera.Questo metodo è più semplice e raccomandato nella maggior parte dei casi.

• Sostituisci completamente gli script della fotocamera predefinita con alternative.Questo approccio è raccomandato solo se non hai bisogno di alcuna funzionalità della fotocamera predefinita.

Il modo più intuitivo per posizionare e orientare il Camera è utilizzando il costruttore CFrame.lookAt().Nell'esempio seguente, il Camera è posizionato a Vector3.new(0, 10, 0) e è orientato a guardare verso 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)

Sebbene la fotocamera possa essere posizionata nel modo dimostrato sopra, potresti volerla animare per muoversi lisciamente da una a un'altra.Per questo, puoi:

• Imposta la posizione/orientamento della Telecameraad ogni frame con RunService:BindToRenderStep() e il metodo CFrame:Lerp().

• Crea e gioca a un Tween che anima la posizione/orientamento della Telecamera:

  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 accetta una varietà di Instances . Gli script della fotocamera predefinita rispondono in modo diverso alle impostazioni disponibili:

• Per impostazione predefinita, gli script della fotocamera seguono lo stato attuale del personaggio locale e dell'oido umanoide.

• Quando è impostata su un BasePart, gli script della fotocamera seguono la sua posizione, con uno spostamento verticale nel caso di VehicleSeats .

CameraSubject non può essere impostato su nil. Tentare di farlo lo riporterà al suo precedente valore.

Per ripristinare CameraSubject al suo valore predefinito, impostalo sul carattere locale 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

Gli script della fotocamera predefinita di Roblox hanno diversi comportamenti integrati.Impostare questa proprietà passa tra i diversi comportamenti Enum.CameraType.Si noti che alcuni tipi di fotocamera richiedono un valido CameraSubject per funzionare correttamente.

Gli script della fotocamera predefinita non si muovono o aggiornano la fotocamera se CameraType è impostato su Enum.CameraType.Scriptable .Per maggiori informazioni sul posizionamento e sull'orientamento della fotocamera manualmente, vedi CFrame .

Per tutte le impostazioni eccetto >, la proprietà rappresenta l'oggetto il cui posizionamento la Telecameraè impostata.

Imposta quante gradazioni nella direzione diagonale (da un angolo della vista all'angolo opposto) la fotocamera può vedere.Vedi FieldOfView per una spiegazione più generale del campo di visione.

Nota che DiagonalFieldOfView rappresenta il campo visivo che è visibile dal rendering Camera nella zona a schermo pieno che può essere occultata da notch o ritagli sullo schermo su alcuni dispositivi.Vedi ViewportSize per ulteriori informazioni.

La proprietà FieldOfView (FOV) imposta il numero di gradi nella direzione verticale in cui la fotocamera può vista.Questa proprietà è bloccata tra 1 e 120 gradi e predefinita a 70 .Campi di visione molto bassi o molto alti non sono raccomandati poiché possono essere disorientanti per i giocatori.

Si noti che viene applicata la ridimensionamento uniforme, il che significa che il campo visivo verticale e orizzontale è sempre correlato dalla proporzione dell'aspetto dello schermo.

Usi suggeriti per FieldOfView includono:

• Ridurre il FOV per dare l'impressione di ingrandimento, ad esempio quando si usano binocoli.
• Aumentare il FOV quando il giocatore "sprinta" per dare l'impressione di una mancanza di controllo.

Nota che FieldOfView rappresenta il campo visivo che è visibile dal rendering Camera nella zona a schermo pieno che può essere occultata da notch o ritagli sullo schermo su alcuni dispositivi.Vedi ViewportSize per ulteriori informazioni.

La Telecameradi FieldOfView (FOV) deve essere aggiornata per riflettere ViewportSize i cambiamenti.Il valore di FieldOfViewMode determina quale valore FOV verrà mantenuto costante.

Ad esempio, quando questa proprietà è impostata su Enum.FieldOfViewMode.Vertical , l'FOV orizzontale viene aggiornato quando il viewport viene ridimensionato, ma l'FOV verticale viene mantenuto costante.Se questa proprietà è impostata su Enum.FieldOfViewMode.Diagonal , sia il FOV orizzontale che verticale potrebbero essere modificati per mantenere costante l'FOV diagonale.

Alcune operazioni grafiche che l'engine esegue, come l'aggiornamento dell'illuminazione, possono richiedere tempo o sforzo computazionale per completare.La proprietà Focus della Telecameradice all'engine quale area nello spazio 3D prioritizzare durante l'esecuzione di tali operazioni.Ad esempio, l'illuminazione dinamica da oggetti come PointLights può non essere resa a distanze lontane dal focus.

Gli script della fotocamera predefinita di Roblox impostati automaticamente Focus a seguire il CameraSubject (di solito un Humanoid).Tuttavia, non aggiornerà automaticamente quando è impostato su o quando gli script della fotocamera predefinita non vengono utilizzati.In questi casi, dovresti aggiornare Focus ogni frame, utilizzando il metodo RunService:BindToRenderStep() alla priorità Enum.RenderPriority.Camera.

Focus non ha alcuna influenza sulla posizione o sull'orientamento della telecamera; vedi CFrame per questo.

Cambia se la fotocamera traccerà automaticamente il movimento della testa di un giocatore utilizzando un DispositivoVR.Quando true (predefinito), il motore combina CFrame con il Enum.UserCFrame della testa dell'utente per rendere la vista del Giocatorecon il tracciamento della testa fattoreggiato.La vista verrà resa alla seguente 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

-- Questo sarà equivalente a Camera:GetRenderCFrame()
local renderCFrame = camera.CFrame * headCFrame

Si consiglia di non disabilitare questa proprietà per i seguenti motivi:

• I giocatori possono sperimentare la malattia da movimento se non viene aggiunta una soluzione di tracciamento della testa equivalente.
• Il motore Roblox esegue ottimizzazioni di latenza quando HeadLocked è vero.

Vedi anche

• VRService:GetUserCFrame() che può essere utilizzato per ottenere il CFrame della testa.
• VRService:RecenterUserHeadCFrame() che viene utilizzato per riportare la testa alla posizione e all'orientamento attuale del DispositivoVR.
• Il metodo GetRenderCFrame() che restituisce il CFrame combinato con il CFrame della testa dell'utente.

HeadScale è la scala della prospettiva dell'utente sul mondo quando utilizza VR.

La dimensione di 1 stud in VR è 0.3 meters / HeadScale , il che significa che i valori più grandi di HeadScale corrispondono al mondo che appare più piccolo dalla prospettiva dell'utente quando si utilizzano dispositivi VR.Ad esempio, una parte alta 1 stud sembra essere alta 0,6 metri per un giocatore VR con un HeadScale di 0.5 .

Questa proprietà è controllata automaticamente da VRService.AutomaticScaling per allineare la prospettiva del Giocatorecon le dimensioni del loro Avatar.Se intendi controllare HeadScale te stesso o usare caratteri personalizzati, attiva VRService.AutomaticScaling a Enum.VRScaling.Off .

Questa proprietà non deve essere confusa con Humanoid.HeadScale che è un NumberValue genitori a un Humanoid per controllare la sua ridimensionamento.

La proprietà MaxAxisFieldOfView imposta il numero di gradi lungo l'asse della visuale più lunga in cui la fotocamera può vista.

Quando l'asse più lunga è l'asse verticale, questa proprietà si comporterà in modo simile alla ProprietàFieldOfView.Questo è generalmente il caso quando un dispositivo è in orientamento ritratto.In un'orientazione paesaggistica, l'asse più lunga sarà l'asse orizzontale; in questo caso, la proprietà descrive il campo visivo orizzontale del Camera .

La proprietà NearPlaneZ descrive quanto lontano è il piano di clip vicino alla Telecamera, in studs.L'aereo di clip vicino è un aereo geometrico che si trova di fronte alla Telecameradi CFrame .Tutto ciò che si trova tra questo piano e la fotocamera non verrà Renderizzare, creando una vista ritagliata quando si visualizzano oggetti a distanze molto brevi.Il valore di NearPlaneZ varia tra le diverse piattaforme e attualmente è sempre tra -0.1 e -0.5 .

Questa proprietà attiva/disattiva se applicare l'inclinazione e il rotolamento dalla proprietà CFrame mentre il giocatore utilizza un DispositivoVR.

Per prevenire la malattia da movimento, l'orizzonte dovrebbe rimanere Livello.Inclinare e ruotare la vista del Giocatorementre si utilizza un dispositivo VR può causare una disconnessione tra lo spazio fisico del Giocatoree lo spazio virtuale che sta guardando.Cambiare la direzione apparente verso il basso può causare ai giocatori di perdere l'equilibrio o di sperimentare vertigini.

Per questi motivi, è generalmente consigliabile lasciare questa proprietà disabilitata, a meno che tu non abbia testato a fondo la tua esperienza per questi effetti.Anche con la rotazione e il giro abilitati, potresti voler garantire che il giocatore abbia sempre un quadro di riferimento stabile, come l'interno di un veicolo o un pavimento che possa aiutare il giocatore a terra nel proprio Spaziofisico.

ViewportSize restituisce le dimensioni dell'area sicura del dispositivo sullo schermo attuale.Questa area è un rettangolo che include l'area della barra superiore di Roblox ma non include alcuna nota di dispositivo o tagli di schermo.Le unità di ViewportSize sono unità di spostamento dell'interfaccia utente Roblox che possono essere diverse dai pixel di visualizzazione nativi.

Come notato sopra, ViewportSize non è uguale alla dimensione dell'area a schermo pieno su display con tagli o nottolini.Per ottenere la dimensione completa dell'area su tutti gli schermi, puoi interrogare la proprietà AbsoluteSize di un ScreenGui con ScreenInsets impostata su None .Vedi Enum.ScreenInsets per maggiori informazioni su come sono definite le aree dello schermo.

Infine, nota che ViewportSize non è la dimensione effettiva del viewport che la fotocamera utilizza per il rendering (la fotocamera rende nell'area a tutta larghezza).Inoltre, le proprietà FieldOfView e DiagonalFieldOfView sono basate sull'area a schermo pieno, non su ViewportSize.

Aggiornamenti fotocamera

Solo il attualmente indicato da viene aggiornato ogni frame durante il passo .Il ViewportSize di tutte le altre telecamere nella tua esperienza non verrà aggiornato, incluse quelle utilizzate per ViewportFrames .

Questo metodo restituisce un array di BaseParts che oscura le linee di visione tra le posizioni CFrame e Vector3 della Telecameranell'vettorecastPoints.Qualsiasi Instances incluso nell'array ignoreList verrà ignorato, insieme ai loro discendenti.

Il parametro castPoints viene fornito come un array di Vector3 posizioni.Nota che l'array di BaseParts restituito è in un ordine arbitrario e non vengono forniti dati aggiuntivi di raycast.Se hai bisogno di dati come posizione colpo, materiale colpo o normale superficie, dovresti optare per il metodo 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 oscura un punto di cast, BaseParts oscurando il punto di cast tra il punto oscuro Terrain e il punto di cast non verrà restituito.

Parametri

Restituzioni

Questo metodo restituisce l'effettivo CFrame del Camera come viene visualizzato, incluso l'impatto di VR (le trasformazioni della testa di VR non sono applicate alla ProprietàCFrame , quindi è consigliabile utilizzare GetRenderCFrame() per ottenere il "vero" CFrame della vista di un Giocatore).

Ad esempio, quando si utilizza VR, il Camera è effettivamente renderingato al seguente 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

Il rendering della TelecameraCFrame verrà cambiato solo per tenere conto della testa quando la proprietà HeadLocked è vera.

Restituzioni

Questo metodo restituisce, in radiani, il rullo attuale applicato al Camera usando SetRoll() .Il rotolamento è definito come rotazione attorno all'asse Z della Telecamera.

Questo metodo restituisce solo il rotolo applicato utilizzando il metodo SetRoll().Roll manualmente applicato alla Telecameradi CFrame non viene conteggiato.Per ottenere il rotolo effettivo del Camera , incluso il rotolo applicato manualmente, puoi usare il seguente snippet:

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

Restituzioni

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

Questo metodo crea un'unità Ray da una posizione 2D sullo schermo (definita in pixel), tenendo conto dell'inserimento GUI.L'origine Ray proviene dall'equivalente Vector3 della posizione 2D nel mondo a una profondità data (in studs) lontana dal Camera .

Poiché questo metodo riconosce l'inserimento GUI, viene calcolato lo spostamento applicato agli elementi GUI (come dalla barra superiore)Questo significa che la posizione dello schermo specificata inizierà nell'angolo in alto a sinistra sotto la barra superiore.Per un metodo identico in altro modo che non tiene conto dello Dislocamentodella GUI, usa ViewportPointToRay() .

Poiché il Ray creato è un raggio unitario, è lungo solo uno stud. Per creare un raggio più lungo, puoi fare quanto Seguendo:

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)

Questo metodo funziona solo per la Telecameraattuale Workspace .Altre telecamere, come quelle che crei per un ViewportFrame , hanno una dimensione iniziale del campo visivo di (1, 1) e vengono aggiornate solo dopo averle impostate a Workspace.CurrentCamera .La non corrispondenza nella dimensione del viewport fa in modo che la fotocamera restituisca un raggio con un errore Ray.Direction .

Parametri

Restituzioni

Questo metodo è obsoleto e non è più considerato migliore pratica.

Questo metodo imposta il rullo attuale, in radianti, del Camera .Il rotolo viene applicato dopo il CFrame e rappresenta la rotazione attorno all'asse Z della Telecamera.

Ad esempio, quanto segue invertirebbe il Camera :

local Workspace = game:GetService("Workspace")

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

SetRoll non ha alcun effetto su qualsiasi rotolo applicato utilizzando la ProprietàCFrame.Il rullo applicato utilizzando SetRoll non si riflette nella proprietà CFrame ma si riflette nel CFrame restituito da GetRenderCFrame() .

Questo metodo può essere utilizzato solo quando il CameraType è impostato su Scriptable, indipendentemente dal fatto che gli script della fotocamera predefinita vengono utilizzati o meno.Se viene utilizzato con qualsiasi altro CameraType un avviso viene fornito nell'Output.

Qualsiasi rotolo applicato utilizzando questo metodo verrà perso quando il CameraType viene cambiato da Scriptable .

Per ottenere il set di rotazione utilizzando questo metodo usa GetRoll() .

Poiché questo metodo è obsoleto, ti viene consigliato di applicare invece il rullo al Camera utilizzando la ProprietàCFrame. Ad esempio:

local Workspace = game:GetService("Workspace")

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

Parametri

Restituzioni

Questo metodo crea un'unità Ray da una posizione 2D nella vista sicura del dispositivo, definita in pixel.Il raggio si origina dall'equivalente della posizione 2D nel mondo alla profondità data (in studs) lontano dall'>.

Come illustrato qui sotto, (0, 0) corrisponde al punto superiore a sinistra della barra superiore di Roblox.Questo significa che la posizione di input 2D non fa non conto per l'inserto CoreUISafeInsets, ma fa conto per qualsiasi DeviceSafeInsets.

Nota che le istanze dell'interfaccia utente utilizzano un diverso sistema di coordinate ( utilizza il sistema di coordinate del viewport mentre questo metodo utilizza il sistema di coordinate del viewport).Se desideri specificare la posizione nelle coordinate UI principali, usa ScreenPointToRay() .

Si noti inoltre che questo metodo funziona solo per la TelecameraWorkspace.CurrentCamera .Altre telecamere, come quelle che crei per un ViewportFrame , hanno una dimensione iniziale del campo visivo di (1, 1) e vengono aggiornate solo dopo averle impostate su CurrentCamera .La non corrispondenza nella dimensione del viewport fa in modo che la fotocamera restituisca un raggio con un errore Ray.Direction .

Questo metodo può essere utilizzato in combinazione con la proprietà ViewportSize per creare un raggio dal centro dello schermo, ad esempio:

local Workspace = game:GetService("Workspace")

local camera = Workspace.CurrentCamera

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

Poiché il Ray creato è un raggio unitario, è lungo solo uno stud. Per creare un raggio più lungo, puoi fare quanto Seguendo:

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)

Parametri

Restituzioni

Questo metodo restituisce la posizione e la profondità dello schermo di un Datatype.Vector3``worldPoint e se questo punto è all'interno dei confini dello schermo.

Questo metodo tiene conto dell'inserimento GUI attuale, come lo spazio occupato dalla barra superiore, in modo che la posizione 2D restituita sia nello stesso termine delle posizioni GUI e possa essere utilizzata per posizionare gli elementi GUI.Per un metodo identico in altro modo che ignora l'inserimento GUI, vedi 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

Nota che questo metodo non esegue alcun raycasting e il boolean che indica se worldPoint è all'interno dei confini dello schermo sarà true indipendentemente dal fatto che il punto sia oscurato da BaseParts o Terrain .

Parametri

Restituzioni

Questo metodo restituisce la posizione e la profondità dello schermo di un Datatype.Vector3``worldPoint e se questo punto è all'interno dei confini dello schermo.

Questo metodo non tiene conto dell'inserimento GUI attuale, come lo spazio occupato dalla barra superiore, il che significa che la posizione 2D restituita viene presa dall'angolo superiore sinistro della finestra.A meno che tu non stia usando ScreenGui.IgnoreGuiInset, questa posizione non è appropriata per posizionare gli elementi GUI.

Per un metodo identico in altro modo che comprende l'inserimento GUI, vedi 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

Nota che questo metodo non esegue alcun raycasting e il boolean che indica se worldPoint è all'interno dei confini dello schermo sarà true indipendentemente dal fatto che il punto sia oscurato da BaseParts o Terrain .

Parametri

Restituzioni

Parametri

Restituzioni

Questo evento si attiva quando il Camera ha finito di interpolare usando il metodo Camera:Interpolate().Non spunterà se un adolescente viene interrotto a causa di Camera:Interpolate() di essere chiamato di nuovo.

Si consiglia di utilizzare TweenService per animare il Camera invece, poiché è più affidabile e fornisce più opzioni per facilitare gli stili.