Camera

Cette propriété est la CFrame de la Camera, définissant sa position et son orientation dans le monde 3D. Notez que certaines transformations, telles que la rotation de la tête lors de l'utilisation de dispositifs VR, ne sont pas réflétées dans cette propriété, vous devriez donc utiliser Class.caméra:Get

Vous pouvez déplacer la caméra en définissant cette propriété. Cependant, les scripts de caméra par défaut la définissent également, donc vous devriez soit :

• Set the camera Camera.CameraType to Enum.CameraType.Scriptable so that the default camera scripts will not update the caméra's CFrame . This method is simplest and recommended in most cases.

• Remplacez complètement les scripts de caméra par défaut par des alternatives. Cette approche n'est recommandée que si vous n'avez pas besoin de toute la fonctionnalité de la caméra par défaut.

La façon la plus intuitive de placer et d'orienter le Camera est d'utiliser le CFrame.lookAt() constructeur. Dans l'exemple suivant, le Camera est positionné à 2>Datatype.Vector3.new(0, 10, 0)2> et

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)

Bien que la caméra puisse être placée de la manière montrée ci-dessus, vous voudrez peut-être l'animer pour qu'elle se déplace facilement d'un CFrame à l'autre. Pour ce faire, vous pouvez soit :

• Définissez la position/orientation de la caméra à chaque frame avec RunService:BindToRenderStep() et la méthode CFrame:Lerp().

• Créer et jouer un Tween qui animera la position/orientation de la caméra :

  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 accepte une variété de Instances . Les scripts de caméra par défaut répondent différemment aux paramètres disponibles :

• Par défaut, les scripts de la caméra suivent le Humanoid du personnage local, en prenant en compte l'état actuel du personnage et le Humanoid.CameraOffset.

• Lorsqu'il est réglé sur un <a href="/reference/engine/dataspace-class.md">Class.BasePart</a>, les scripts de caméra suivent sa position, avec un décalage vertical dans le cas de <a href="/reference/engine/dataspace-class.md">Class.VehicleSeat|VehicleSeats</a>.

CameraSubject ne peut pas être réglé sur nil . Essayer de le faire le rétablira à sa valeur précédente.

Pour restaurer CameraSubject à sa valeur par défaut, définissez-le sur le personnage local 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

Les scripts de caméra Roblox par défaut ont plusieurs comportements intégrés. En configurant cette propriété, vous activez plusieurs comportements de Enum.CameraType . Notez que certains types de caméra nécessitent un Camera.CameraSubject valide pour fonctionner correctement.

Les scripts de caméra par défaut ne déplaceront pas ou ne mettront pas à jour la caméra si CameraType est réglé sur Enum.CameraType.Scriptable. Pour plus d'informations sur le positionnement et l'orientation de la caméra manuellement, voir Camera.CFrame .

Pour tous les Type de caméra paramètres sauf Enum.CameraType.Scriptable , la propriété 1> Class.Camera.CameraSubject|CameraSubject1> représente l'objet dont la position le capteur de la caméra est réglé sur.

Définit le nombre de degrés dans la direction diagonale (du coin d'une vue à son coin opposé) que la caméra peut voir. Voir FieldOfView pour une explication plus générale de la zone de vision.

Notez que DiagonalFieldOfView représente le champ de vision qui est visible par le rendu Camera dans la zone d'affichage complète qui peut être occludée par des goujons ou des coupes d'écran sur certains appareils. Voir Class. Camera.ViewportSize|ViewportSize pour plus d'informations.

La propriété FieldOfView détermine le nombre de degrés dans la direction verticale que la caméra peut voir. Cette propriété est calquée entre 1 et 120 degrés et se défaut à 70. Les champs de vue très bas ou très élevés ne sont pas recommandés car ils peuvent être désorientants pour les joueurs.

Notez que le redimensionnement uniforme est appliqué, ce qui signifie que le champ de vision vertical et horizontal sont toujours liés par le ratio d'aspect de l'écran.

Les utilisations suggérées pour FieldOfView (FOV) incluent :

• Réduction de FOV pour donner l'impression de magnification, par exemple lors de l'utilisation de binoculaires.
• Augmenter le champ de vision lorsque le joueur est « sprinting » pour donner l'impression d'un manque de contrôle.

Remarquez que FieldOfView représente le champ de vision qui est visible par le rendu Camera dans la zone d'affichage complète qui peut être occludée par des goujons ou des coupes d'écran sur certains appareils. Voir Class.Camera. ViewportSize|ViewportSize pour plus d'informations.

Le champ de vision de la caméra (FOV) doit être mis à jour pour refléter les ViewportSize changements. La valeur de FieldOfViewMode détermine lequel des valeurs de FOV seront gardées constantes.

Par exemple, lorsque cette propriété est réglée sur Enum.FieldOfViewMode.Vertical, le champ de vision horizontal est mis à jour lorsque la fenêtre est redimensionnée, mais le champ de vision vertical est conservé constant. Si cette propriété est réglée sur Enum.FieldOfViewMode.Diagonal, les deux champs de vision horizontaux et verticaux peuvent être modifiés pour garder le champ de vision vertical constant.

Certaines opérations graphiques que le moteur effectue, telles que la mise à jour des luminaires, peuvent prendre du temps ou des efforts computationnels pour se terminer. La propriété Focus de la caméra indique au moteur quelle zone dans l'espace 3D prioriser lors de l'exécution de ces opérations. Par exemple, la lumière dynamique des objets tels que PointLights peut ne pas rendre à des distances loin du focus.

Les scripts de caméra par défaut de Roblox définissent automatiquement Focus pour

Concentration n'a aucun effet sur la position ou l'orientation de la caméra ; voir Camera.CFrame pour cela.

Bascule si la caméra suivra automatiquement la tête du joueur en utilisant un appareil VR. Lorsque true (par défaut), le moteur combine Camera.CFrame avec le Enum.UserCFrame de la tête du joueur pour rendre la vue du joueur avec la tête suivie en facteur. La vue sera rendue au suiv

local UserInputService = game:GetService("UserInputService")

local camera = workspace.CurrentCamera

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

-- Ceci sera équivalent à Camera:GetRenderCFrame()
local renderCFrame = camera.CFrame * headCFrame

Il est recommandé de ne pas désactiver cette propriété pour les raisons suivantes :

• Les joueurs peuvent ressentir la maladie des mouvements si une solution de suivi de tête équivalente n'est pas ajoutée.
• Le moteur Roblox effectue des optimisations de latence lorsque Verrouillage de tête est vrai.

Voir aussi

• VRService:GetUserCFrame() qui peut être utilisé pour obtenir le CFrame de la tête.
• VRService:RecenterUserHeadCFrame() qui est utilisé pour recentrer la tête à la position et à l'orientation actuelles de l'appareil VR.
• La fonction Camera:GetRenderCFrame() qui renvoie le Camera.CFrame combiné avec le CFrame de la tête de l'utilisateur.

HeadScale est la mise à l'échelle de la perspective de l'utilisateur du monde lors de l'utilisation de VR.

La taille de 1 stud dans VR est 0.3 meters / HeadScale, ce qui signifie que de plus grandes valeurs HeadScale valent pour le monde de l'utilisateur de la perspective de l'utilisateur lors de l'utilisation de dispositifs VR. Par exemple, une partie qui est de 1 hauteur de stud semble être de 0.6 hauteur de métre pour un joueur VR avec un HeadScale de 0.5

Cette propriété est automatiquement contrôlée par VRService.AutomaticScaling pour ajuster la perspective du joueur avec la taille de son avatar. Si vous voulez contrôler HeadScale vous-même ou utiliser des personnages personnalisés, basculez VRService.AutomaticScaling à 1> enum.VRScaling.Off1>.

Cette propriété ne doit pas être confondue avec Humanoid.HeadScale qui est un NumberValue parenté à un Humanoid pour contrôler son escalage.

La propriété MaxAxisFieldOfView détermine le nombre de degrés le long de l'axe de vue le plus long.

Lorsque l'axe le plus long est l'axe vertical, cette propriété se comportera comme la propriété FieldOfView. Ceci est généralement le cas lorsqu'un appareil est dans une orientation portrait. Dans une orientation paysage, l'axe le plus long sera l'axe horizontal ; dans ce cas, la propriété décrit le champ de vue horizontal de la Camera.

La propriété NearPlaneZ décrit à quelle distance le plan de caméra est-il près de l'avion de capture, en studs. Le plan de caméra est un plan géométrique qui se trouve devant le plan Class.Camera.CFrame de la caméra. Tout ce qui se trouve entre ce plan et la caméra ne sera pas rendu, ce qui crée une vue coupée lors de la visualisation d

Cette propriété bascule entre l'application de la inclination et du défilement à partir de la propriété Camera.CFrame pendant que le joueur utilise un appareil VR.

Pour éviter la maladie des mouvements, l'horizon doit rester niveau. Tilting et rouler la vue du joueur tout en utilisant un appareil VR peut entraîner une déconnectivité entre l'espace physique du joueur et l'espace virtuel qu'ils affichent. Changer la direction apparente vers le bas peut entraîner la perte de l'équilibre ou l'expérience de la détresse.

Pour ces raisons, il est généralement conseillé de laisser cette propriété désactivée, à moins que vous n'ayez testé minutieusement votre expérience pour ces effets. Même avec le mode de défilement et de rotation activé, vous voudrez peut-être toujours vous assurer que le joueur a toujours une référence stable, comme l'intérieur d'un véhicule ou d'un sol qui peut aider le joueur à se sentir dans leur espace physique.

ViewportSize renvoie les dimensions de la zone de sécurité de l'appareil sur l'écran actuel. Cette zone est un rectangle qui inclut la zone de la barre supérieure Roblox mais n'inclut pas de coins d'appareil ou de coupes d'écran. Les unités de ViewportSize sont des unités d'offset de l'interface utilisateur Roblox qui peu

Comme indiqué ci-dessus, ViewportSize n'est pas égal à la taille de la zone d'affichage avec des coupes ou des encoches. Pour obtenir

Enfin, notez que ViewportSize n'est pas la taille de fenêtre réelle que la caméra utilise pour le rendu (la caméra rendu dans la zone de jeu complet). De plus, les propriétés Camera.FieldOfView et Camera.DiagonalFieldOfView sont basées sur la zone

Mises à jour de la caméra

Seul le Camera actuellement référencé par Class.Workspace. CurrentCamera a son ViewportSize mis à jour chaque cadre pendant la étape de 1> Class.RunService.PreRender|Pre

Cette méthode renvoie un tableau de BaseParts qui sont des obstacles aux lignes de vue entre le Camera.CFrame et Vector3 positions dans l'1> castPoints1> matrice. Tous les 4> Class.

Le paramètre castPoints est donné comme un tableau de Vector3 positions. Notez que le tableau de BaseParts renvoyé est dans un ordre arbitraire et que les données supplémentaires de raycast ne sont pas fournies. Si vous avez besoin de données telles que la position d'impact, le matériau d'impact ou

local camera = workspace.CurrentCamera

local castPoints = {
	Vector3.new(0, 10, 0),
	Vector3.new(0, 15, 0)
}
local ignoreList = {}

local partsObscuringTarget = camera:GetPartsObscuringTarget(castPoints, ignoreList)

Si Terrain obscure un point de cast, BaseParts obscure le point de cast entre l'obscuring Terrain et l'obscuring ne sera pas renvoyé.

Paramètres

Retours

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

Cette fonction renvoie le CFrame réel de la Camera comme il est rendu, y compris l'impact de VR (les transformations de tête VR ne sont pas appliquées à la propriété Camera.CFrame, donc il est préférable d'utiliser 1> Class.Camera

Par exemple, lors de l'utilisation de VR, le Camera est en fait rendu au suivant 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

Le rendu de la caméra CFrame ne sera modifié que pour tenir compte de la tête lorsque la propriété Camera.HeadLocked est vraie.

Retours

Cette fonction renvoie, en radians, le rouleau actuel appliqué à la Camera en utilisant Camera:SetRoll(). Le rouleau est défini comme une rotation autour de l'axe Z de la caméra.

Cette fonction ne renvoie que le roulement appliqué à l'aide de la fonction Camera:SetRoll(). Le roulement manuellement appliqué à la caméra est non pris en compte. Pour obtenir le roulement actuel de la caméra, y compris le roulement manuellement appliqué, vous pouvez utiliser le snippet suivant :

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

Retours

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

Cette fonction crée une unité Ray à partir d'une position 2D sur l'écran (définie dans les pixels), en comptant l'insertion de l'interface graphique. L'Ray d'origine provient de la valeur équivalente de la position 2D dans le monde à la profondeur donnée (dans les studs) loin de la Class.Camera</

Comme cette fonction reconnaît l'insérat GUI, l'Offset appliqué aux éléments GUI (tels que depuis la barre supérieure) est pris en compte. Cela signifie que la position d'écran spécifiée commencera dans le coin supérieur gauche de l'écran en dessous de la barre supérieure. Pour une fonction identique autre qui ne prend pas en compte l'décentrageGUI, utilisez Camera:ViewportPointToRay() .

Comme l'unité Ray créée est un rayon d'unité, il est seulement d'une longueur de stud. Pour créer un rayon plus long, vous pouvez faire les suivre:

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

Cette fonction ne fonctionne que pour la caméra de l'espace de travail actuel. D'autres caméras, telles que celles que vous créez pour un ViewportFrame, ont une taille de fenêtre d'entrée (1, 1) et ne sont mis à jour qu'après avoir configuré le paramètre Workspace.CurrentCamera . Le désaccord

Paramètres

Retours

Cette fonction est obsolète et n'est plus considérée comme une meilleure pratique.

Cette fonction définie le roulement actuel, en radians, de la Camera. Le roulement est appliqué après le Camera.CFrame et représente la rotation autour de l'axe Z de la caméra.

Par exemple, le suivant inverserait le Camera :

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

SetRoll n'a aucun effet sur tout le roulement appliqué en utilisant la propriété Camera.CFrame. Le roulement appliqué en utilisant SetRoll n'est pas reflété dans la propriété Camera.CFrame mais est reflété dans la propriété CFrame retournée par 1> Class.Camera:GetRenderCFrame()1>.

Cette fonction ne peut être utilisée que lorsque le Camera.CameraType est défini sur « Scriptable » », indépendamment du fait que les scripts de caméra par défaut sont utilisés ou non. Si elle est utilisée avec tout autre Class.Camera.CameraType, un avertissement est donné dans la sortie.

Toute rotation appliquée à l'aide de cette fonction sera perdue lorsque le Camera.CameraType est changé de 'Scriptable' .

Pour obtenir le jeu de roulis à l'aide de cette fonction, utilisez Camera:GetRoll() .

Puisque cette fonction est obsolète, vous êtes conseillé d'appliquer le roulement à la Camera en utilisant la propriété Camera.CFrame. Par exemple :

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

Paramètres

Retours

Cette fonction crée une unité Ray à partir d'une position 2D dans la fenêtre de vue de l'appareil, définie dans les pixels. Le rayon vient de l'équivalent 2D de la position dans le monde à la profondeur (en studs) donnée Vector3 .

Comme illustré ci-dessous, (0, 0) correspond au point supérieur gauche de la barre supérieure Roblox. Cela signifie que la position 2D d'entrée ne fait pas compte de la position CoreUISafeInsets mais il fait compte de toute la position 1> Entrée dans l'enceinte1> .

Remarquez que les instances de l'interface utilisateur utilisent un système de coordonnée différent ( GuiObject.AbsolutePosition utilise le système de coordonnée de vue CoreUISafeInsets lorsque cette fonction utilise le système de coordonnée de vue DeviceSafeInsets). Si vous souhaitez sp

Notez également que cette fonction ne fonctionne que pour la caméra Class.Workspace. CurrentCamera. D'autres caméras, telles que celles que vous créez pour une caméra ViewportFrame, ont une taille de fenêtre d'entrée (1, 1) et ne sont mis à jour qu

Cette fonction peut être utilisée conjointement avec la propriété ViewportSize pour créer un rayon du centre de l'écran, par exemple :

local Workspace = game:GetService("Workspace")

local camera = Workspace.CurrentCamera

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

Comme l'unité Ray créée est un rayon d'unité, il est seulement d'une longueur de stud. Pour créer un rayon plus long, vous pouvez faire les suivre:

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)

Paramètres

Retours

Cette fonction renvoie l'emplacement et la profondeur de l'écran d'un Datatype.Vector3``worldPoint et si ce point est dans les limites de l'écran.

Cette fonction tient compte de l'emplacement actuel de l'interface graphique, comme l'espace occupé par la barre supérieure, ce qui signifie que la position 2D renvoyée est dans le même terme que les positions de l'interface graphique et peut être utilisée pour placer les éléments de l'interface graphique. Pour une autre fonction identique qui ignore l'emplacement de l'interface graphique, voir 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

Remarquez que cette fonction ne effectue aucun raycasting et le boolé indiquant si worldPoint est dans les limites de l'écran sera true indépendamment de si le point est couvert par BaseParts ou 1> Class.Terrain1>.

Paramètres

Retours

Cette fonction renvoie l'emplacement et la profondeur de l'écran d'un Datatype.Vector3``worldPoint et si ce point est dans les limites de l'écran.

Cette fonction ne tient pas compte de l'emplacement actuel de l'interface graphique, comme l'espace occupé par la barre supérieure, ce qui signifie que la position 2D renvoyée est prise à partir du coin supérieur gauche de la fenêtre de jeu. À moins que vous n'utilisiez ScreenGui.IgnoreGuiInset, cette position n'est pas appropriée pour placer les éléments de l'interface graphique.

Pour une fonction identique autrement, qui représente l'emplacement de l'interface graphique, voir 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

Remarquez que cette fonction ne effectue aucun raycasting et le boolé indiquant si worldPoint est dans les limites de l'écran sera true indépendamment de si le point est couvert par BaseParts ou 1> Class.Terrain1>.

Paramètres

Retours

Paramètres

Retours

Cet événement se déclenche lorsque le Camera a terminé l'interpolation à l'aide de la fonction Camera:Interpolate().

Cet événement ne se déclenchera pas si un tween est interrompu en raison de la réactivation de Camera:Interpolate() .

Vous êtes conseillé d'utiliser TweenService pour animer le Camera à la place, car il est plus fiable et fournit plus d'options pour soulager les styles.