Camera

Questa proprietà è la CFrame della TelecameraCamera, che definisce la sua posizione e orientamento nel Mondo3D. Nota che alcune trasformazioni, come la rotazione della testa quando si usa VR dispositivi, non sono riflettute in questa Proprietà, quindi si dovrebbe usare Class.Camera:GetRenderCFrame()

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

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

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

Il modo più intuitivo per posizionare e orientare il Camera è utilizzando il costruttore CFrame.lookAt(). Nel seguente esempio, il Camera è posizionato a 2> Datatype.Vector3.new(0, 10, 0)

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)

Alcuni potrebbero dire che la fotocamera può essere posizionata nel modo mostrato sopra, ma potresti voler animarlo per passare da un CFrame all'altro. Per questo, puoi:

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

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

  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()

CameraSubject accetta una varietà di Instances . Gli script della fotocamera predefiniti rispondono in modo diverso alle impostazioni disponibili:

• Per impostazione predefinita, gli script della fotocamera seguono il personaggio locale Humanoid , facendo in modo che il personaggio in stato attuale e Humanoid.CameraOffset .

• Quando impostato su un BasePart, gli script della fotocamera seguono la sua posizione, con un offset verticale nel caso di VehicleSeats .

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

Per ripristinare CameraSubject al suo valore predefinito, impostalo sul personaggio locale Humanoid :

local Players = game:GetService("Players")

local localPlayer = Players.LocalPlayer

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

Gli script della fotocamera Roblox predefiniti hanno diversi comportamenti incorporati. Impostando questa proprietà attiva/disattiva tra i diversi comportamenti Enum.CameraType . Nota che alcuni tipi di telecamere richiedono un valido Camera.CameraSubject per funzionare correttamente.

Gli script della fotocamera predefiniti non si muoveranno o aggiorneranno la fotocamera se CameraType è impostato su Enum.CameraType.Scriptable . Per ulteriori informazioni sulla posizione e orientamento della fotocamera manualmente, vedi Camera.CFrame .

Per tutti CameraType impostazioni tranne Enum.CameraType.Scriptable , la proprietà 1> Class.Camera.CameraSubject|CameraSubject1> rappresenta l'oggetto cui la Telecameradel tuo 4> Class.Camera.Focus4> è impostato.

Imposta quanti gradi nella direzione diagonale (da un angolo alla sua estremità opposta) la fotocamera può vista. Vedi FieldOfView per una spiegazione più generale della linea di vista.

Nota che DiagonalFieldOfView rappresenta il campo di visione che è visibile dalla Camera in area di visualizzazione completa che potrebbe essere occlusa da notch o tagli di schermo su alcuni dispositivi. Vedi Class. Camera.ViewportSize|ViewportSize per ulteriori informazioni.

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

Nota che lo scaling dell'uniforme è forzato, il che significa che il campo di visione verticale e orizzontale sono sempre correlati dal rapporto di aspetto della schermata.

Usi consigliati per FieldOfView (FOV) includono:

• Riduzione della FOV per dare l'impressione di ingrandimento, ad esempio quando si usa il binocolo.
• Aumentare il FOV quando il giocatore è "sprinting" per dare l'impressione di una mancanza di controllo.

Nota che FieldOfView rappresenta il campo di visione che è visibile dalla rendering di Camera nella zona di visualizzazione completa che potrebbe essere occlusa da notch o tagli sullo schermo su alcuni dispositivi. Vedi Class.Camera. ViewportSize|ViewportSize per ulteriori informazioni.

Il campo di visione della Telecamera(FOV) deve essere aggiornato per riflettere le modifiche ViewportSize. Il valore di FieldOfViewMode determina quale valore di FOV mantenere costante.

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

Alcune operazioni grafiche che il motore esegue, come l'aggiornamento degli illuminanti, possono richiedere tempo o sforzi算ici per completarli. La proprietà Focus della Telecameraindica al motore quale area nello spazio 3D priorizzare quando si eseguono tali operazioni. Ad esempio, la luce dinamica da oggetti come PointLights potrebbe non essere visualizzata a distanza dalla fotocamera.

Gli script della fotocamera predefiniti di Roblox impostano automaticamente Focus</

Focus non ha alcun effetto sulla posizione o sull'orientamento della Telecamera; vedi Camera.CFrame per questo.

Attiva/disattiva la tracciatura automatiche della testa di un giocatore utilizzando un DispositivoVR. Quando true (predefinito), il motore combina Camera.CFrame con il Enum.UserCFrame della testa del giocatore per rendere la visuale del Giocatorecon la tracciatura della testa fattori in. La visuale sarà visual

local UserInputService = game:GetService("UserInputService")

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 sindrome del 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 recenter la testa nella posizione e nell'orientamento attuale del DispositivoVR.
• La funzione Camera:GetRenderCFrame() che restituisce il Camera.CFrame combinato con il CFrame della testa dell'utente.

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

Il diametro di 1 stud in VR è 0.3 meters / HeadScale , il che significa che valori più grandi di HeadScale valgono per il mondo quando si guarda più piccolo dalla prospettiva dell'utente quando si utilizzano dispositivi VR. Ad esempio, una parte che misura 1 piedi alto sembra essere 0.6 piedi alto per un giocatore VR con una HeadScale di 0

Questa proprietà è controllata automaticamente da VRService.AutomaticScaling per allineare la prospettiva del Giocatorecon la dimensione del loro Avatar. Se intenzionate controllare HeadScale da solo o utilizzare personaggi personalizzati, attiva VRService.AutomaticScaling a 2> Amount.VRScaling.Off2> .

Questa proprietà non dovrebbe essere confusa con Humanoid.HeadScale che è un NumberValue padre di un Humanoid per controllare la sua escaling.

La proprietà MaxAxisFieldOfView imposta il numero di gradi lungo l'asse più lungo della visuale.

Quando l'asse più lungo è l'asse verticale, questa proprietà si comporta in modo simile alla ProprietàFieldOfView. Questo è generalmente il caso quando un dispositivo è in una orientazione a forma di ritratto. In una orientazione a forma di paesaggio, l'asse più lungo sarà l'asse orizzontale; in questo caso, la proprietà descrive il campo di visuale orizzontale della Camera.

La proprietà NearPlaneZ descrive la distanza in cui si trova il piano vicino alla clip della Telecamera, in studs. Il piano vicino alla clip della Telecameraè un piano geometrico che si trova di fronte all'Camera.CFrame della fotocamera. Tutto ciò che è tra questo piano e la fotocamera non Renderizzare, cre

Questa proprietà attiva/disattiva la applicazione della inclinazione e del rullaggio dalla proprietà Camera.CFrame mentre il giocatore usa un DispositivoVR.

Per prevenire la malattia delle mosse, l'orizzonte dovrebbe rimanere Livello. Tilting e rollando la vista del Giocatorementre si usa un dispositivo VR può causare un disconnect tra lo spazio fisico del Giocatoree lo spazio virtuale che stanno visualizzando. Cambiare la direzione apparente verso il basso può causare danni o persi.

Per queste ragioni, è generalmente consigliato lasciare questa proprietà disabilitata, a meno che tu non abbia testato estensivamente la tua esperienza per questi effetti. Anche con la disabilitazione delle mosse abilitata, potresti voler assicurarti che il giocatore abbia sempre una referenza stabile, come l'interno di un veicolo o un pavimento che può aiutare il giocatore a posizionarsi nello Spaziofisico.

ViewportSize restituisce le dimensioni dell'area sicura del dispositivo sullo schermo corrente. Questa area è un rettangolo che include l'area della barra superiore Roblox ma non include alcuna notch o tagli dello schermo. Le unità di ViewportSize sono unità di pixelizzazione Roblox che possono essere diverse dalle pixelizzazioni native.

Come notato sopra, ViewportSize non è uguale alla dimensione completa della vista sui display con tagli o cunee. Per ottenere la dimensione

Infine, nota che ViewportSize non è la dimensione di visualizzazione effettiva che la fotocamera usa per il rendering (la fotocamera rende nella zona di visualizzazione completa). Inoltre, le proprietà Camera.FieldOfView e Camera.DiagonalFieldOfView

Aggiornamenti della fotocamera

Solo il Camera attualmente riferito da Class.Workspace. CurrentCamera ha il suo ViewportSize aggiornato in ogni frame durante la fase 1> Class.RunService.PreRender|

Questo metodo restituisce un array di BaseParts che sono oscurare le linee di visione tra il Telecamera's Camera.CFrame e Vector3 posizioni nell'vettore1> castPoints1> . Tutti 4> Class

Il parametro castPoints viene fornito come un'arrangione di Vector3 posizioni. Nota che l'arrangione fornita dal metodo BaseParts restituisce un ordine arbitrario e non viene fornito alcun dato raycast aggiuntivo. Se hai bisogno di dati come la posizione di colpo, il materiale di base o la

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 oscura il punto di cast tra l'oscuramento Terrain e l'oscuramento.

Parametri

Restituzioni

local Workspace = game:GetService("Workspace")

local camera = Workspace.CurrentCamera

local function XRay(castPoints, ignoreList)
	ignoreList = ignoreList or {}
	local parts = camera:GetPartsObscuringTarget(castPoints, ignoreList)

	for _, part in parts do
		part.LocalTransparencyModifier = 0.75
		for _, child in pairs(part:GetChildren()) do
			if child:IsA("Decal") or child:IsA("Texture") then
				child.LocalTransparencyModifier = 0.75
			end
		end
	end
end

XRay({ Vector3.new() })

Questa funzione restituisce il CFrame reale della Camera come viene vista, tra cui l'impatto della VR (le trasformazioni della testa VR non sono applicate alla ProprietàCamera.CFrame , quindi è meglio usare 2> Class.Camera

Ad esempio, quando si utilizza VR, il Camera viene effettivamente visualizzato al seguente CFrame :

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

Il render della TelecameraCFrame sarà modificato solo per tenere conto della testa quando la proprietà Camera.HeadLocked è vera.

Restituzioni

Questa funzione restituisce, in radian, il rullo attuale applicato alla Camera utilizzando Camera:SetRoll() . Il rullo è definito come rotazione attorno all'asse Z della Telecamera.

Questa funzione restituisce solo il rullo applicato utilizzando la funzione Camera:SetRoll() . Il rullo manualmente applicato alla Telecameranon è considerato. Per ottenere il rullo reale della Camera.CFrame , incluso il rullo manualmente applicato, puoi utilizzare il seguente snippet:

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

Questa funzione crea un'unità Ray da una posizione 2D sulla schermata (definita in pixel), facendo conto della posizione GUI. L'Ray originates from the Vector3 equivalent of the 2D position in the world at the given depth (in studs) away from the 1> Class.Camera1>

Poiché questa funzione riconosce l'inserimento della GUI, l'Offset applicato alle elementi GUI (ad esempio dalla barra superiore) viene conteggiato. Ciò significa che la posizione dello schermo specificata inizierà nell'angolo in alto a sinistra sotto la barra superiore. Per un'altra funzione identica che non contegga l'Dislocamentodella GUI, usa Camera:ViewportPointToRay() .

Come il Ray creato è un raggio di unità, è solo di uno stud lungo. Per creare un raggio più lungo, puoi fare quanto Seguendo:

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

Questa funzione funziona solo per la TelecameraWorkspace attuale. Le altre telecamere, come quelle che crei per un ViewportFrame , hanno una dimensione iniziale della visuale (1, 1) e vengono aggiornate solo dopo averle impostate su Workspace.CurrentCamera . Il problema nella dimensione della visuale provoca che

Parametri

Restituzioni

Questa funzione è obsoleta e non è più considerata migliore pratica.

Questa funzione imposta il rullo attuale, in radian, della Camera . Il rullo viene applicato dopo il Camera.CFrame e rappresenta la rotazione intorno all'asse Z della Telecamera.

Ad esempio, il seguente invertirebbe il Camera :

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

SetRoll non ha effetto su nessun rullo applicato utilizzando la proprietà Camera.CFrame. Il rullo applicato utilizzando SetRoll non è riflettibile nella proprietà Camera.CFrame ma è riflettibile nella proprietà CFrame restituita da 1> Class.Camera:GetRenderCFrame()1> .

Questa funzione può essere utilizzata solo quando il Camera.CameraType è impostato su 'Scriptabile', indipendentemente dal fatto che gli script della fotocamera predefiniti siano in uso. Se viene utilizzato con qualsiasi altro Camera.CameraType viene mostrato un avviso nell'Output.

Qualsiasi rullo applicato utilizzando questa funzione verrà perso quando il Camera.CameraType è cambiato da Scriptable .

Per ottenere il set di rotolamento usando questa funzione usa Camera:GetRoll() .

Poiché questa funzione è obsoleta, ti consiglio di applicare invece la rotolazione alla Camera utilizzando la ProprietàCamera.CFrame. Ad esempio:

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

Parametri

Restituzioni

Questa funzione crea un'unità Ray da una posizione 2D nella visuale sicura del dispositivo, definita in pixel. Il raggio viene originato dal Vector3 equivalente della posizione 2D nel mondo alla distanza (in studs) dal Camera .

Come mostrato di seguito, (0, 0) corrisponde al punto in alto a sinistra della barra superiore Roblox. Ciò significa che la posizione 2D di input non non conta per il CoreUISafeInsets inset, ma conta per qualsiasi 1> Enumerate.ScreenInsets|DeviceSafeInsets1>

Nota che le istanze UI utilizzano un diverso sistema di coordinate ( GuiObject.AbsolutePosition usa il sistema di posizione CoreUISafeInsets mentre questa funzione usa il sistema di posizione DeviceSafeInsets . Se desideri specificare la posizione in core UI coordinate, usa

Nota anche che questa funzione funziona solo per la Class.Workspace. CurrentCamera Telecamera. Altre telecamere, come quelle che crei per una ViewportFrame , hanno un'iniziale dimensione di visualizzazione di (1, 1) e vengono aggiornate

Questa funzione può essere utilizzata in conjunction con la proprietà ViewportSize per creare un ray 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)

Come il Ray creato è un raggio di unità, è solo di uno stud lungo. 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

Questa funzione restituisce la posizione e la profondità dello schermo di un Datatype.Vector3``worldPoint e se questo punto è all'interno dei limiti dello schermo.

Questa funzione tiene conto dell'attuale inserzione GUI, come lo spazio occupato dalla barra superiore, il che significa che la posizione 2D restituita è nello stesso termine delle posizioni GUI e può essere utilizzata per posizionare gli elementi GUI. Per un'altra funzione identica che ignora l'inserzione GUI, vedi Camera:WorldToViewportPoint() .

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 questa funzione non esegue alcun raycasting e il booleano che indica se worldPoint è all'interno dei limiti dello schermo sarà true indipendentemente dal fatto che il punto sia oscurato da BaseParts o 1> Class.Terrain1> .

Parametri

Restituzioni

Questa funzione restituisce la posizione e la profondità dello schermo di un Datatype.Vector3``worldPoint e se questo punto è all'interno dei limiti dello schermo.

Questa funzione non tiene conto dell'attuale inserzione GUI, come lo spazio occupato dalla barra superiore, il che significa che la posizione 2D restituita viene dal topo sinistro della finestra. A meno che tu non stia usando ScreenGui.IgnoreGuiInset, questa posizione non è adatta per posizionare gli elementi GUI.

Per un'altra funzione identica che conta per l'inserimento della GUI, vedi Camera:WorldToScreenPoint() .

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 questa funzione non esegue alcun raycasting e il booleano che indica se worldPoint è all'interno dei limiti dello schermo sarà true indipendentemente dal fatto che il punto sia oscurato da BaseParts o 1> Class.Terrain1> .

Parametri

Restituzioni

Parametri

Restituzioni

Questo evento si attiva quando il Camera ha finito di interpolare usando la funzione Camera:Interpolate().

Questo evento non si attivera' se un tween viene interrotto a causa di Camera:Interpolate() che viene chiamato di nuovo.

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