RunService

A função BindToRenderStep() vincula uma função personalizada a ser chamada em um momento específico durante o passo de renderização.Existem três argumentos principais: name , priority e o que function chamar.

Como está ligado ao processo de renderização do cliente, BindToRenderStep() só pode ser chamado no cliente.

Qual o nome

O parâmetro name é uma etiqueta para o vinculo e pode ser usado com RunService:UnbindFromRenderStep() se o vinculo não for mais necessário.

local RunService = game:GetService("RunService")

local function functionToBind() end

-- Vincule a função acima ao vinculo chamado "tempBinding"
RunService:BindToRenderStep("tempBinding", 1, functionToBind)
-- Desvincule a função vinculada a "tempBinding"
RunService:UnbindFromRenderStep("tempBinding")

Prioridade

O priority da vinculação é um integral; determina quando durante o passo de renderização chamar a função personalizada.Quanto menor esse número, mais cedo a função personalizada será chamada.Se duas vinculações tiverem a mesma prioridade, o Motor do Roblox escolherá aleatoriamente uma para executar primeiro.Os scripts de controle padrão do Roblox são executados com essas prioridades específicas:

• Entrada do Jogador: 100
• Controles de câmera: 200 Para conveniência; o Enum.RenderPriority enum pode ser usado para determinar o valor inteiro para definir um vinculo.Por exemplo, para fazer um direito de vinculação antes da atualização padrão da câmera, simplesmente subtraia 1 do nível de prioridade da câmera.

Ao usar Enum.RenderPriority, lembre-se de usar .Value no final do enum desejado. RunService:BindToRenderStep() não funcionará se apenas o enum for usado por conta possuir.

local RunService = game:GetService("RunService")

local function beforeCamera(delta)
	-- Código aqui será executado antes do script de câmera padrão do Roblox
end

RunService:BindToRenderStep("Before camera", Enum.RenderPriority.Camera.Value - 1, beforeCamera)

Função personalizada e tempo Delta

O último argumento ( function ) é a função personalizada para chamar.Essa função será passada um parâmetro chamado deltaTime que mostra quanto tempo passou entre o início do passo de renderização anterior e o início do passo de renderização atual.

Todas as atualizações de renderização esperarão até que o código no passo de renderização termine.Certifique-se de que qualquer código chamado por BindToRenderStep() execute rapidamente e eficientemente; se o código demorar muito, os visuais da experiência serão desajeitados.

Parâmetros

Devolução

local RunService = game:GetService("RunService")

-- How fast the frame ought to move
local SPEED = 2

local frame = script.Parent
frame.AnchorPoint = Vector2.new(0.5, 0.5)

-- A simple parametric equation of a circle
-- centered at (0.5, 0.5) with radius (0.5)
local function circle(t)
	return 0.5 + math.cos(t) * 0.5, 0.5 + math.sin(t) * 0.5
end

-- Keep track of the current time
local currentTime = 0
local function onRenderStep(deltaTime)
	-- Update the current time
	currentTime = currentTime + deltaTime * SPEED
	-- ...and the frame's position
	local x, y = circle(currentTime)
	frame.Position = UDim2.new(x, 0, y, 0)
end

-- This is just a visual effect, so use the "Last" priority
RunService:BindToRenderStep("FrameCircle", Enum.RenderPriority.Last.Value, onRenderStep)
--RunService.RenderStepped:Connect(onRenderStep) -- Also works, but not recommended

local RunService = game:GetService("RunService")

local function checkDelta(deltaTime)
	print("Time since last render step:", deltaTime)
end

RunService:BindToRenderStep("Check delta", Enum.RenderPriority.First.Value, checkDelta)

local RunService = game:GetService("RunService")

-- Step 1: Declare the function and a name
local NAME = "Print Hello"
local function printHello()
	print("Hello")
end

-- Step 2: Bind the function
RunService:BindToRenderStep(NAME, Enum.RenderPriority.First.Value, printHello)

-- Step 3: Unbind the function
RunService:UnbindFromRenderStep(NAME)

Se o código que invocou este método estiver sendo executado em um contexto de cliente (em um LocalScript , em um ModuleScript necessário por um LocalScript , ou em um Script com RunContext definido para Enum.RunContext.Client ), este método retornará true .Em todos os outros casos, este método retornará false .

Se este método retornar true, o ambiente atual pode acessar recursos exclusivos do cliente, como RunService.PreRender ou Players.LocalPlayer.

Devolução

Este método retorna se o ambiente atual está no modo "editar", por exemplo, no Studio quando a experiência não está em execução.

IsEdit() retornará o inverso de IsRunning(), exceto quando a simulação foi pausada, no qual ambos os métodos retornarão false .

Devolução

Este método retorna se o botão Correr foi pressionado para executar a simulação no Studio.Ele continuará a retornar true se a simulação foi pausada usando o botão Pause ; no entanto, uma vez que foi interrompida usando o botão Parar , ela voltará a retornar false .

Observe que o Studio entra apenas no modo "executar" quando o botão Correr é pressionado, não o botão Jogar .Observe também que este método retornará false se a simulação foi iniciada usando RunService:Run() em vez do botão Executar .

Devolução

Retorna se a experiência está atualmente em execução, o que significa que a simulação foi executada usando os botões Executar ou Jogar .

IsRunning() sempre retornará o inverso de IsEdit() exceto quando a simulação foi pausada, no qual ambos os métodos retornarão false .

Devolução

Este método retorna se o ambiente atual está rodando no servidor.Se o código que invocou este método estiver sendo executado em um contexto de servidor (em um Script com RunContext definido para Enum.RunContext.Server ou Enum.RunContext.Legacy , ou em um ModuleScript exigido por um Script ), este método retornará true .Em todos os outros casos, este método retornará false .

Se essa função retornar verdadeiro, então o ambiente atual pode acessar recursos exclusivos do servidor como ServerStorage ou ServerScriptService.

Devolução

Este método retorna se o ambiente atual está rodando no Studio. Ele pode ser usado para embalar código que deve ser executado apenas ao testar no Studio.

Devolução

Este método põe em pausa a simulação da experiência se ela estiver em andamento, suspendendo a física e os scripts.A simulação pode ser iniciada usando Run() ou o botão Executar no Studio; quando a simulação é pausada, IsRunning() retornará false .

Devolução

Este método executa a simulação da experiência (física e scripts).Quando a simulação estiver em execução, IsRunning() retornará true .No entanto, IsRunMode() retornará apenas true se a simulação foi iniciada usando o botão Executar no Studio.

Devolução

Este método interrompe a simulação da experiência se ela estiver em andamento.Quando a simulação é interrompida, IsRunning() retornará false e IsEdit() retornará true .

Em contraste com o botão Pare no Studio, chamar este método não restaurará a experiência ao estado em que estava antes da simulação ser executar.Isso significa que quaisquer alterações feitas à experiência pela simulação de física e scripts persistirão depois que a simulação terminar.

Devolução

Dado um nome de uma função enviada para BindToRenderStep(), este método desvinculará a função de ser chamada durante PreRender .Isso é usado para desvincular funções ligadas quando elas não forem mais necessárias ou quando não precisam mais disparar todos os passos.

Se não houver função vinculada pelo nome dado, este método não toma nenhuma ação e continua sem causar um erro.

Parâmetros

Devolução

O evento Heartbeat ocorre a cada quadro, após a simulação de física ter concluído.O argumento deltaTime indica o tempo que decorreu desde o quadro anterior.

Este evento é quando a maioria dos scripts executarexecutada.Ocorre no final de cada quadro e também é quando quaisquer scripts de espera são executados, como os agendados com a biblioteca task.Heartbeat é comumente usado para tarefas periódicas, como atualizar sistemas principais de jogos como regeneração de saúde.

Após este passo, o motor envia atualizações de propriedade e eventos ao servidor ou aos clientes que são recebidos mais tarde como parte do passo de recepção de replicação .

Parâmetros

O evento PostSimulation ocorre a cada quadro, após a simulação de física ter concluído.O argumento deltaTimeSim indica o tempo que o quadro atual passou a simulação de física, sem levar em conta o atraso de física.

Este evento é útil para fazer ajustes finais no resultado da simulação. Após esta fase, o motor ativa o evento Heartbeat.

Parâmetros

O evento PreAnimation ocorre a cada quadro, antes da simulação de física, mas após o renderizamento.O argumento deltaTimeSim indica o tempo que o quadro atual tem passado animações.

Este evento é útil para modificar objetos de animação, como ajustar sua velocidade ou prioridade.Uma vez que o evento PreAnimation completado, o motor procede a executar essas animações, atualizando as transformações conjuntas que serão usadas mais tarde para atualizar objetos durante a simulação de física.

Depois que as animações forem concluídas, o motor ativa o evento PreSimulation.

Parâmetros

O evento PreRender ( substituição para RenderStepped ) dispara a cada quadro, antes que o quadro seja renderizado.O argumento deltaTimeRender indica o tempo que decorreu desde o quadro anterior.

Este evento permite que você execute código e atualize o mundo antes que ele seja desenhado na tela de um jogador.Isso é útil para ajustes de última hora, como mudar as posições dos objetos, atualizar animações ou preparar efeitos visuais, mas deve ser usado com moderação, pois o motor não pode começar a renderizar o quadro até que o código em execução neste evento tenha terminado de executar.

Como PreRender é do lado do cliente, só pode ser usado em um LocalScript , em um ModuleScript exigido por um LocalScript ou em um Script com RunContext definido para Enum.RunContext.Client.

Após a fase PreRender seguinte, a fase de simulação começa com o evento PreAnimation.

Parâmetros

O evento PreSimulation ( substituição para Stepped ) dispara a cada quadro, antes da simulação de física.O argumento deltaTimeSim indica o tempo em que o quadro atual irá executar a simulação de física, sem levar em conta o atraso de física.

Este evento é útil para ajustar propriedades como velocidade ou forças logo antes de serem aplicadas como parte da simulação.A simulação então é executada, potencialmente várias vezes, pois o solucionador de física é executado com uma frequência maior do que outros sistemas de motor.Uma vez que isso é concluído, o evento PostSimulation é disparado.

Parâmetros

Dispara a cada quadro, antes que o quadro seja renderizado.

Nota de migração

Este evento foi substituído por PreRender que deve ser usado para novo trabalho.

Parâmetros

Dispara todos os quadros, antes da simulação de física.

Nota de migração

Este evento foi substituído por PreSimulation que deve ser usado para novo trabalho.

Parâmetros