Camera

Visualizza obsoleti

*Questo contenuto è tradotto usando AI (Beta) e potrebbe contenere errori. Per visualizzare questa pagina in inglese, clicca qui.

Non Replicato

L'oggetto Fotocamera definisce una vista della 3D Mondo. In un'esperienza in esecuzione, ogni client ha il proprio Camera oggetto che risiede nella sua proprietà locale Workspace, accessibile attraverso la Proprietà2> Class.Area di lavoro.CurrentCamera2>.

Le proprietà della fotocamera più importanti sono:

  • Camera.CFrame che rappresenta la posizione e l'orientamento della Telecamera.

  • Camera.CameraType che viene letto dagli script della fotocamera dell'esperienza e determina il modo in cui la fotocamera dovrebbe aggiornare ogni frame.

  • Camera.CameraSubject che viene letto dagli script della fotocamera dell'esperienza e determinare quale oggetto la fotocamera dovrebbe Seguire.

  • Camera.FieldOfView che rappresenta l'estensione visibile del Mondoosservabile.

  • Camera.Focus che rappresenta il punto in cui la fotocamera guarda. È importante che questa proprietà sia Impostare, poiché alcune visualizzazioni saranno più dettagliate e si aggiornano più frequentemente a seconda di quanto sono vicine al punto focale.

Vedi Personalizzare la fotocamera per ulteriori informazioni su come regolare e personalizzare il comportamento della Telecamera.

Sommario

Proprietà

  • Lettura Parallela

    Il CFrame della Camera, che definisce la sua posizione e orientamento nel Mondo3D.

  • Lettura Parallela

    Il Humanoid o BasePart che è il Camera oggetto.

  • Lettura Parallela

    Specifica il Enum.CameraType che deve essere letto dagli script della fotocamera.

  • Non Replicato
    Lettura Parallela

    Imposta l'angolo della diagonale campo di vistadella Telecamera.

  • Lettura Parallela

    Imposta l'angolo del campo di vistaverticale della Telecamera.

  • Determina il valore FOV della Camera che è indefinito sotto le dimensioni della visuale.

  • Lettura Parallela

    Imposta l'area nello spazio 3D che è prioritaria ai sistemi grafici di Roblox.

  • Lettura Parallela

    Attiva/disattiva se la telecamera traccerà automaticamente la moto della testa di un giocatore utilizzando un DispositivoVR.

  • Lettura Parallela

    Imposta la scala della prospettiva dell'utente del mondo quando si usa VR.

  • Non Replicato
    Lettura Parallela

    Imposta l'angolo della visuale della Telecameralungo l'asse di visuale più lungo.

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    Descrive l'Dislocamentonegativo Z della Telecamera, in studs, vicino al Ritaglio.

  • Lettura Parallela

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

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    Le dimensioni della zona sicura del dispositivo su un client Roblox.

Metodi

  • GetPartsObscuringTarget(castPoints : Array,ignoreList : Instances):Instances

    Restituisce un array di BaseParts che stanno oscurando le linee di visione tra la Telecamerae i punti di fusione.

  • Restituisce il CFrame reale in cui viene visualizzato il Camera , calcolando l'impatto di qualsiasi dispositivo VR.

  • Restituisce in radian la ruota attuale, o la rotazione attorno all'asse Z della Telecamera, applicata all'Camera utilizzando Camera:SetRoll().

  • Scrivi Parallelo

    Crea un'unità Ray da una posizione sullo schermo (in pixel), in una profondità predeterminata dalla Camera orientata nella direzione della Telecamera. Conta per l'inserimento della GUI.

  • SetRoll(rollAngle : number):void

    Imposta la rotazione attuale applicata intorno all'asse Z della Telecamera.

  • Scrivi Parallelo

    Crea un'unità Ray da una posizione sulla visuale (in pixel), a una profondità specificata dalla Camera , orientata nella direzione della Telecamera. Non conta il CoreUISafeInsets inset.

  • Scrivi Parallelo

    Restituisce la posizione e la profondità dello schermo di un Datatype.Vector3``worldPoint e se questo punto è all'interno dei limiti dello schermo. Calcola l'inserimento della GUI.

  • Scrivi Parallelo

    Restituisce la posizione e la profondità dello schermo di un Datatype.Vector3``worldPoint e se questo punto è all'interno dei limiti dello schermo. Non conta il GUI inset.

  • ZoomToExtents(boundingBoxCFrame : CFrame,boundingBoxSize : Vector3):void

Proprietà

CFrame

Lettura Parallela

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

Lettura Parallela

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

CameraType

Lettura Parallela

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.

DiagonalFieldOfView

Non Replicato
Lettura Parallela

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.

FieldOfView

Lettura Parallela

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.

FieldOfViewMode

Lettura Parallela

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.

Focus

Lettura Parallela

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.

HeadLocked

Lettura Parallela

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

HeadScale

Lettura Parallela

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.

MaxAxisFieldOfView

Non Replicato
Lettura Parallela

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.

NearPlaneZ

Sola Lettura
Non Replicato
Lettura Parallela

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

Diagram showing how the NearPlaneZ clips (does not render) 3D content between the plane and the camera.

VRTiltAndRollEnabled

Lettura Parallela

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

Sola Lettura
Non Replicato
Lettura Parallela

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.

Mobile device screen with cutout showing device safe area.

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|

Metodi

GetPartsObscuringTarget

Instances

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

castPoints: Array

Un array di Vector3 posizioni di punti di cast.

ignoreList: Instances

Un array di Instances che dovrebbe essere ignorato, oltre a loro discendenti.


Restituzioni

Instances

Un array di BaseParts che oscura le linee di visione tra la TelecameraCamera.CFrame e il castPoints .

Campioni di codice

X-Ray Function

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

GetRenderCFrame

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

Il CFrame il Camera viene visualizzato in tempo reale.

GetRoll

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

Il roll attuale applicato da Camera:SetRoll() , in radian.

Campioni di codice

Camera:GetRoll

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

ScreenPointToRay

Scrivi Parallelo

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

La posizione sull'asse X, in pixel, del punto di schermo su cui si originano il Ray . Questa posizione corrisponde all'inserimento GUI.

La posizione sull'asse Y, in pixel, del punto di schermo su cui si originano il Ray . Questa posizione corrisponde all'inserimento GUI.

depth: number

La profondità dai Class.Camera , in studs, da cui offsettare l'origine del Ray .

Valore predefinito: 0

Restituzioni

Un'unità Ray , originating dalla posizione mondiale di Datatype.Vector3 dato nella profondità fornita dalla Vector3 . Questo ray è orientato nella direzione della Camera .

SetRoll

void

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

rollAngle: number

L'angolo di rotolamento, in radian, da applicare alla Camera .


Restituzioni

void

ViewportPointToRay

Scrivi Parallelo

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>

Diagram showing the origin of the device safe area viewport coordinate system.

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

La posizione sull'asse X in pixel del punto di visualizzazione in cui generare il Ray , nell'area di sicurezza del dispositivo.

La posizione sull'asse Y in pixel del punto di visualizzazione per cui generare il Ray , nell'area di sicurezza del dispositivo.

depth: number

La profondità dai Class.Camera , in studs, da cui offsettare l'origine del Ray .

Valore predefinito: 0

Restituzioni

Un'unità Ray , originating dalla posizione mondiale della vista corrispondente Vector3 , lontana dalla posizione Camera . Questo ray è orientato nella direzione della 1> Class.Camera1> .

WorldToScreenPoint

Scrivi Parallelo

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

worldPoint: Vector3

La posizione mondiale Vector3 .


Restituzioni

Un tuo che contiene, in ordine:

  • Un Vector3 il cui X e Y componenti rappresentano l'Offset del worldPoint dalla parte superiore sinistra della schermata, in pixel. Il Vector31> Z1> component rappresenta la profondità del 4> worldPoint4> dalla schermata (in studs).

  • Un bool che indica se il worldPoint è all'interno dei limiti dello schermo.

WorldToViewportPoint

Scrivi Parallelo

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

worldPoint: Vector3

La posizione mondiale Vector3 .


Restituzioni

Un tuo che contiene, in ordine:

  • Un Vector3 il cui X e Y componenti rappresentano l'Offset del 1> worldPoint1> dalla parte superiore sinistra del finestra, in pixel. Il 4> Datatype.Vector34> 7> Z7> componente rappresenta la profond

  • Un bool che indica se il worldPoint è all'interno dei limiti dello schermo.

ZoomToExtents

void

Parametri

boundingBoxCFrame: CFrame
boundingBoxSize: Vector3

Restituzioni

void

Eventi

InterpolationFinished

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.