Camera

Cette propriété est la CFrame du 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 d'appareils VR, ne sont pas reflétées dans cette propriété, vous devez donc utiliser GetRenderCFrame() pour obtenir le "vrai" CFrame de la caméra.

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, vous devez donc soit :

• Définissez la caméra CameraType à Enum.CameraType.Scriptable afin que les scripts de caméra par défaut n'actualisent pas le CFrame de la caméra.Cette méthode est la plus simple et recommandée dans la plupart des cas.

• 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 fonctionnalités de caméra par défaut.

La façon la plus intuitive de positionner et d'orienter le Camera est d'utiliser le constructeur CFrame.lookAt().Dans l'exemple suivant, le Camera est positionné à Vector3.new(0, 10, 0) et est orienté vers 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)

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

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

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

  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 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 de la caractéristique locale, en tenant compte de l'état actuel de l'humanoïde et de Humanoid.CameraOffset.

• Lorsqu'elle est définie à un BasePart, les scripts de la caméra suivent sa position, avec un décalage vertical dans le cas de VehicleSeats .

CameraSubject ne peut pas être défini sur nil. Tenter de le faire le révertira à sa valeur précédente.

Pour restaurer CameraSubject à sa valeur par défaut, définissez-la à la valeur du caractère local Humanoid :

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

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

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

Les scripts de caméra par défaut de Roblox ont plusieurs comportements intégrés.Définir cette propriété bascule entre les différents comportements Enum.CameraType.Notez que certains types de caméra nécessitent un CameraSubject pour fonctionner correctement.

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

Pour toutes les paramètres excepté , la propriété représente l'objet dont la position est définie par la caméra .

Définit le nombre de degrés dans la direction diagonale (de l'un des coins de la fenêtre à son coin opposé) que la caméra peut voir.Voir FieldOfView pour une explication plus générale du champ de vision.

Notez que DiagonalFieldOfView représente le champ de vision qui est visible par le Camera rendu dans la zone plein écran qui peut être occulté par des notches ou des découpes d'écran sur certains appareils.Voir ViewportSize pour plus d'informations.

La propriété FieldOfView (FOV) définit le nombre de degrés dans la direction verticale que la caméra peut voir.Cette propriété est comprise entre 1 et 120 degrés et est définie par défaut à 70 .Les champs de vision très bas ou très élevés ne sont pas recommandés car ils peuvent être déorientants pour les joueurs.

Notez que l'échelle uniforme est appliquée, ce qui signifie que le champ de vision vertical et horizontal est toujours lié par la proportionnalité de l'écran.

Les utilisations suggérées pour FieldOfView incluent :

• Réduire le FOV pour donner l'impression de magnification, par exemple lors de l'utilisation de binocules.
• Augmentation de la FOV lorsque le joueur "cours" pour donner l'impression d'un manque de contrôle.

Notez que FieldOfView représente le champ de vision qui est visible par le Camera rendu dans la zone plein écran qui peut être occulté par des notches ou des découpes d'écran sur certains appareils.Voir ViewportSize pour plus d'informations.

La caméra de FieldOfView (FOV) doit être mise à jour pour refléter ViewportSize les modifications.La valeur de FieldOfViewMode détermine la valeur FOV qui sera maintenue constante.

Par exemple, lorsque cette propriété est définie à Enum.FieldOfViewMode.Vertical, le FOV horizontal est mis à jour lorsque la fenêtre est redimensionnée, mais le FOV vertical est maintenu constant.Si cette propriété est définie à Enum.FieldOfViewMode.Diagonal, la FOV horizontale et verticale pourraient être modifiées pour maintenir la FOV diagonale constante.

Certaines opérations graphiques que le moteur effectue, telles que la mise à jour de l'éclairage, peuvent prendre du temps ou des efforts de calcul pour être terminées.La propriété de la caméra Focus indique à l'Engine quelle zone dans l'espace 3D prioriser lors de l'exécution de telles opérations.Par exemple, l'éclairage dynamique d'objets tels que PointLights peut ne pas s'afficher à des distances éloignées du focus.

Les scripts de caméra par défaut de Roblox définissent automatiquement Focus à suivre le CameraSubject (généralement un Humanoid).Cependant, ne sera pas mis à jour automatiquement lorsque est réglé sur ou lorsque les scripts de caméra par défaut ne sont pas utilisés.Dans ces cas, vous devez mettre à jour chaque cadre, en utilisant la méthode à la priorité .

Focus n'a pas d'incidence sur la position ou l'orientation de la caméra ; voir CFrame pour cela.

Active si la caméra suit automatiquement le mouvement de la tête d'un joueur en utilisant un appareil VR.Lorsque true (par défaut), le moteur combine CFrame avec le Enum.UserCFrame de la tête de l'utilisateur pour rendre la vue du joueur avec un suivi de la tête facteur.La vue sera rendue à la suite du CFrame suivant :

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

-- Cela 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 souffrir du mal des transports s'une solution de suivi de tête équivalente n'est pas ajoutée.
• Le moteur Roblox effectue des optimisations de latence lorsque HeadLocked 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 méthode GetRenderCFrame() qui renvoie le CFrame combiné avec le CFrame de la tête de l'utilisateur.

HeadScale est la taille de la perspective de l'utilisateur du monde lors de l'utilisation de VR.

La taille de 1 étude en VR est de 0.3 meters / HeadScale , ce qui signifie que des valeurs plus grandes HeadScale équivalent à un monde qui paraît plus petit du point de vue de l'utilisateur lors de l'utilisation de dispositifs VR.Par exemple, une partie qui mesure 1 pièce de hauteur semble avoir une hauteur de 0,6 mètre pour un joueur VR avec un HeadScale de 0.5 .

Cette propriété est automatiquement contrôlée par VRService.AutomaticScaling pour aligner la perspective du joueur avec la taille de son avatar.Si vous prévoyez de contrôler vous-même HeadScale ou d'utiliser des personnages personnalisés, activez VRService.AutomaticScaling à Enum.VRScaling.Off .

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

La propriété MaxAxisFieldOfView définit le nombre de degrés le long de l'axe de vision le plus long que la caméra peut voir.

Lorsque l'axe le plus long est l'axe vertical, cette propriété se comportera de manière similaire à la propriété FieldOfView.C'est généralement le cas lorsqu'un appareil est dans une orientation paysage.Dans une orientation paysage, l'axe le plus long sera l'axe horizontal ; dans ce cas, la propriété décrit le champ de vision horizontal du Camera .

La propriété NearPlaneZ décrit à quelle distance se trouve le plan de coupe proche de la caméra, en studs.L'avion de découpe proche est un plan géométrique qui se trouve devant le plan de la caméra CFrame.Tout ce qui se trouve entre cet avion et la caméra ne sera pas rendu, créant une vue d'ensemble lors de la visualisation d'objets à très courte distance.La valeur de NearPlaneZ varie sur différentes plates-formes et est actuellement toujours entre -0.1 et -0.5.

Cette propriété bascule si elle doit appliquer la rotation et le roulis à partir de la propriété CFrame lorsque le joueur utilise un appareil VR.

Pour éviter la maladie du mouvement, l'horizon devrait rester niveau.Incliner et rouler la vue du joueur tout en utilisant un appareil VR peut provoquer une déconnexion entre l'espace physique du joueur et l'espace virtuel qu'il regarde.Changer la direction apparente vers le bas peut faire perdre l'équilibre aux joueurs ou les rendre vertigineux.

Pour ces raisons, il est généralement conseillé de laisser cette propriété désactivée, à moins que vous n'ayez testé extensément votre expérience pour ces effets.Même avec la rotation et le roulis activés, vous voudrez peut-être vous assurer que le joueur ait toujours un cadre de référence stable, comme l'intérieur d'un véhicule ou un plancher qui peut aider le joueur à s'ancrer dans son espace physique.

ViewportSize renvoie les dimensions de la zone de sécurité du dispositif sur l'écran actuel.Cette zone est un rectangle qui inclut la zone de barre supérieure Roblox mais n'inclut aucune rainure d'appareil ou découpe d'écran.Les unités de ViewportSize sont des unités de décalage de l'interface utilisateur Roblox qui peuvent être différentes des pixels d'affichage natifs.

Comme noté ci-dessus, ViewportSize n'est pas égal à la taille de la zone plein écran sur les affichages avec des découpes ou des rainures.Pour obtenir la taille de la zone plein écran sur tous les écrans, vous pouvez demander la propriété AbsoluteSize de un ScreenGui avec ScreenInsets définie sur None .Voir Enum.ScreenInsets pour plus d'informations sur la façon dont les zones d'écran sont définies.

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

Mises à jour de la caméra

Seule la Camera actuellement mentionnée par Workspace.CurrentCamera a son ViewportSize mis à jour à chaque cadre pendant l'étape PreRender.Le ViewportSize de toutes les autres caméras de votre expérience ne sera pas mis à jour, y compris celles utilisées pour ViewportFrames.

Cette méthode renvoie un tableau de BaseParts qui obscurcissent les lignes de vision entre les positions CFrame et Vector3 de la caméra dans le tableau castPoints.Tout Instances inclus dans l'matriceignoreList sera ignoré, ainsi que ses descendants.

Le paramètre castPoints est donné en tant qu'array de Vector3 positions.Notez que l'arrêt de l'array de BaseParts retourné est dans un ordre arbitraire, et aucune donnée de lancer de rayon supplémentaire n'est fournie.Si vous avez besoin de données telles que la position de frappe, le matériau de frappe ou la normale de surface, vous devriez opter pour la méthode 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)

Si Terrain obscurcit un point de lancement, BaseParts obscuring le point de lancement entre le point d'obscurité Terrain et le point de lancement ne sera pas renvoyé.

Paramètres

Retours

Cette méthode renvoie le véritable CFrame du Camera tel qu'il est rendu, y compris l'impact de VR (les transformations de tête de VR ne sont pas appliquées à la propriété CFrame , il est donc préférable d'utiliser GetRenderCFrame() pour obtenir le "vrai" CFrame de la voird'un joueur).

Par exemple, lors de l'utilisation de VR, le Camera est réellement rendu à la suite de 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

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

Retours

Cette méthode renvoie, en radians, le roulement actuel appliqué au Camera en utilisant SetRoll() .Le roulement est défini comme une rotation autour de l'axe Z de la caméra.

Cette méthode ne renvoie que le roule appliqué en utilisant la méthode SetRoll().Le roulement appliqué manuellement à la caméra CFrame n'est pas pris en compte.Pour obtenir le roulement réel du Camera , y compris le roulement appliqué manuellement, vous pouvez utiliser le snippet suivant :

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

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 méthode crée une unité Ray à partir d'une position 2D sur l'écran (définie en pixels), tenant compte de l'insertion de l'interface graphique.L'origine provient de l'équivalent de la position 2D dans le monde à la profondeur donnée (en studs) à l'écart du .

Comme cette méthode reconnaît l'insertion de l'interface graphique, l'écart appliqué aux éléments de l'interface graphique (tels que de 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 en dessous de la barre supérieure.Pour une méthode autrement identique qui ne tient pas compte de l'décentragede la GUI, utilisez ViewportPointToRay() .

Comme le Ray créé est un rayon d'unité, il n'est que d'une longueur de stud. Pour créer un rayon plus long, vous pouvez faire ce qui 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)

Cette méthode ne fonctionne que pour la caméra actuelle Workspace.D'autres caméras, telles que celles que vous créez pour un ViewportFrame , ont une taille de fenêtre initiale de (1, 1) et ne sont mises à jour qu'après les avoir configurées à Workspace.CurrentCamera .Le désaccord dans la taille de la fenêtre provoque le retour de la caméra d'un rayon avec un rayon incorrect Ray.Direction .

Paramètres

Retours

Cette méthode est obsolète et n'est plus considérée comme la meilleure pratique.

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

Par exemple, ce qui suit inverserait le Camera :

local Workspace = game:GetService("Workspace")

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

SetRoll n'a aucun effet sur tout roulement appliqué en utilisant la propriété CFrame.Le roulement appliqué en utilisant SetRoll n'est pas reflété dans la propriété CFrame mais est reflété dans la propriété CFrame renvoyée par GetRenderCFrame().

Cette méthode ne peut être utilisée que lorsque le CameraType est réglé sur Scriptable, indépendamment du fait que les scripts de caméra par défaut soient utilisés ou non.Si elle est utilisée avec toute autre CameraType avertissement est donné dans la sortie.

Tout roulement appliqué en utilisant cette méthode sera perdu lorsque le CameraType est modifié de Scriptable.

Pour obtenir le jeu de roulis en utilisant cette méthode, utilisez GetRoll() .

Comme cette méthode est obsolète, il vous est conseillé d'appliquer plutôt le roulement à la Camera en utilisant la propriété CFrame. Par exemple :

local Workspace = game:GetService("Workspace")

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

Paramètres

Retours

Cette méthode crée une unité Ray à partir d'une position 2D dans la fenêtre de vue sûre du périphérique, définie en pixels.Le rayon provient de l'équivalent de la position 2D dans le monde à la profondeur donnée (en studs) à distance du .

Comme illustré ci-dessous, (0, 0) correspond au point supérieur gauche de la barre supérieure Roblox.Cela signifie que la position d'entrée 2D ne tient pas compte du insérat, mais elle tient compte de tout .

Notez que les instances d'interface utilisent un système de coordonnées différent (GuiObject.AbsolutePosition utilise le système de coordonnées de la fenêtre CoreUISafeInsets alors que cette méthode utilise le système de coordonnées de la fenêtre DeviceSafeInsets).Si vous souhaitez spécifier la position dans les coordonnées de l'interface utilisateur principale, veuillez utiliser ScreenPointToRay() .

Notez également que cette méthode ne fonctionne que pour la caméra Workspace.CurrentCamera.D'autres caméras, telles que celles que vous créez pour un ViewportFrame , ont une taille de fenêtre initiale de (1, 1) et ne sont mises à jour qu'après que vous les ayez réglées sur CurrentCamera .Le désaccord dans la taille de la fenêtre provoque le retour de la caméra d'un rayon avec un incorrect Ray.Direction .

Cette méthode peut être utilisée en conjonction avec la propriété ViewportSize pour créer un rayon depuis le 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 le Ray créé est un rayon d'unité, il n'est que d'une longueur de stud. Pour créer un rayon plus long, vous pouvez faire ce qui 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 méthode renvoie l'emplacement et la profondeur de l'écran d'un Datatype.Vector3``worldPoint et si ce point se trouve dans les limites de l'écran.

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

Notez que cette méthode ne effectue aucun lancer de rayons et le booléen indiquant si worldPoint est dans les limites de l'écran sera true indépendamment du fait que le point soit obstrué par BaseParts ou Terrain .

Paramètres

Retours

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

Cette méthode ne tient pas compte de l'insertion de l'interface graphique actuelle, comme l'espace occupé par la barre supérieure, ce qui signifie que la position 2D retourné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 des éléments GUI.

Pour une méthode autrement identique qui compte pour l'insertion de l'interface graphique, voir 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

Notez que cette méthode ne effectue aucun lancer de rayons et le booléen indiquant si worldPoint est dans les limites de l'écran sera true indépendamment du fait que le point soit obstrué par BaseParts ou Terrain .

Paramètres

Retours

Paramètres

Retours

Cet événement se déclenche lorsque le Camera a terminé l'interpolation à l'aide de la méthode Camera:Interpolate().Il ne tirera pas si un adolescent est interrompu en raison de Camera:Interpolate() étant appelé à nouveau.

Il vous est conseillé d'utiliser TweenService pour animer le Camera à la place, car il est plus fiable et fournit plus d'options pour faciliter les styles.