Detectores de arrasto 3D

A instância facilita e incentiva a interação com objetos 3D em uma experiência, como abrir portas e gavetas, deslizar uma parte ao redor, agarrar e jogar uma bola de boliche, puxar e atirar uma slingshot e muito mais.As principais características incluem:

• Coloque um DragDetector sob qualquer BasePart ou Model para torná-lo arrastável através de todas as entradas (mouse, toque, controle / controle de jogoe VR), sem uma única linha de código.

• Escolha entre vários estilos de arrastamento , defina como o objeto reage à movimentação e aplique opcionalmente limites de eixo ou movimento .

• Scripts podem responder à manipulação de objetos arrastados para dirigir a interface de usuário ou tomar decisões lógicas, como ajustar o nível de luz em uma sala com base em um dimmer de parede deslizante.

• Jogadores podem manipular peças ou modelos ancorados e eles permanecerão exatamente onde você os colocou após o lançamento.

• DragDetectors trabalhar no Studio enquanto você estiver não usando as ferramentas Selecionar , Mover , Escala ou Girar , tornando mais fácil testar e ajustar objetos arrastáveis enquanto estiver editando.

Tornar objetos arrastáveis

Para tornar qualquer parte ou modelo arrastável, simplesmente adicione um DragDetector como Descendentedireto.

1. Na janela Explorer, passe o mouse sobre o Part, MeshPart ou Model e clique no botão ⊕. Um menu contextual é exibido.

2. Do menu, insira um Detector de Dragão .

   

3. Por padrão, o objeto agora será arrastável no plano de superfície, mas você pode personalizá-lo , definir como ele responde a movimentos e aplicar opcionalmente limites de eixo ou movimento .

Personalizar detectores de arrastamento

Estilo de arrastar

DragDetectors mapear o movimento do cursor para linhas virtuais e planos para calcular a movimentação 3D proposta.Através da propriedade DragStyle, você pode escolher entre diferentes mapeamentos para atender às suas necessidades.Por exemplo, TranslatePlane produz tradução em um avião virtual, enquanto RotateAxis produz rotação sobre um eixo virtual.

Direção de arrastamento

Por padrão, movimento 3D e o mapa associado DragStyle para o espaço mundial.No entanto, você pode querer alterar o ReferenceInstance , Orientation ou Axis , por exemplo, ao construir detectores de arrasto em modelos com peças ajustáveis .

Resposta ao movimento

A propriedade ResponseStyle especifica como um objeto responde à proposta de moção, dependendo de se o objeto é Anchored ou não.

Limites de eixo e movimento

Por padrão, não há limites para a movimentação 3D além das restrições inerentes do DragStyle.Se necessário, você pode aplicar limites mínimos e máximos tanto à tradução quanto à rotação.Observe, no entanto, que essas não são restrições , elas apenas impedem as tentativas do detector de arrastamento de gerar movimento para permanecer dentro dos limites.

Arrastar permissões

A permissão de jogadores para interagir com uma determinada instância de detector de arrasto pode ser especificada pela propriedade PermissionPolicy.Isso é definido como Enum.DragDetectorPermissionPolicy.Everybody por padrão e também pode ser alterado para suportar controles de permissão programados, como mostrado no exemplo de código.

Detector de Dragão - Permissão de Dragão Programada
local dragDetector = script.Parent.DragDetector
dragDetector.PermissionPolicy = Enum.DragDetectorPermissionPolicy.Scriptable

dragDetector:SetPermissionPolicyFunction(function(player, part)
	if player and player:GetAttribute("IsInTurn") then
		return true
	elseif part and not part:GetAttribute("IsDraggable") then
		return false
	else
		return true
	end
end)

Resposta de física

Suponha que o estilo de resposta de um arrastador seja definido como Estilo Físico e que ele seja aplicado a um Objetonão ancorado, esse objeto será movido por forças de restrição que tentam levá-lo à posição/orientação dada pela proposta de movimento.Você pode personalizar ainda mais a resposta física através das seguintes propriedades:

A entrada de modificador

Alguns DragStyle permitem que os usuários mantenham pressionada uma tecla/botão modificadora para manipular o objeto arrastado de diferentes maneiras.Por padrão, o modificador é LeftControl no PC, ButtonR1 no controle / controle de jogoou ButtonL2 no VR.Você pode personalizar esses modificadores através das propriedades KeyboardModeSwitchKeyCode, GamepadModeSwitchKeyCode ou VRSwitchKeyCode da instância do detector de arrastamento.

Replicação

Quando a propriedade RunLocally falsa é verdadeira, o cliente interpreta toda a entrada para produzir dados que envia ao servidor para executar o arrastamento.Neste modo, todos os sinais de evento personalizados e funções registradas devem estar no servidor Scripts.

Quando a propriedade RunLocally é verdadeira, nenhum evento é replicado para o servidor.Todos os sinais de evento personalizados e funções registradas devem estar no cliente LocalScripts e você deve usar eventos remotos para propagar as alterações necessárias ao servidor.

Respostas de script ao clicar e arrastar

Através de sinais de evento , alterações de propriedade, Scriptable estilo de arrastamento de propriedade e funções personalizadas, os scripts podem responder à manipulação de objetos arrastados para conduzir a UI ou tomar decisões lógicas, como ajustar o nível de luz em uma sala com base em um interruptor de parede deslizante.

Sinais de evento

Através dos seguintes sinais de evento, você pode detectar quando um usuário começa, continua e termina arrastando um Objeto.

Detector de Dragão - Sinais de Evento
local dragDetector = script.Parent.DragDetector

local highlight = Instance.new("Highlight")
highlight.Enabled = false
highlight.Parent = script.Parent

dragDetector.DragStart:Connect(function()
	highlight.Enabled = true
end)

dragDetector.DragContinue:Connect(function()

end)

dragDetector.DragEnd:Connect(function()
	highlight.Enabled = false
end)

Mudanças na janela de arrastamento

Além de sinais de evento, você pode monitorar as alterações no detector DragFrame.

Detector de Dragão - Mudanças de Frame de Dragão
local dragDetector = script.Parent.DragDetector

dragDetector:GetPropertyChangedSignal("DragFrame"):Connect(function()
	local currentDragTranslation = dragDetector.DragFrame.Position
	print(currentDragTranslation)
end)

Estilo de arrastamento programado

Se você definir um detector de DragStyle para Scriptável , você pode fornecer sua própria função que recebe um Ray e retorna um espaço mundial CFrame .O detector moverá o movimento para que o objeto arrastado vá para essa localização/orientação personalizada.

Detector de Dragão - Estilo de Dragão Programado
local Workspace = game:GetService("Workspace")

local dragDetector = script.Parent.DragDetector
dragDetector.DragStyle = Enum.DragDetectorDragStyle.Scriptable

local cachedHitPoint = Vector3.zero
local cachedHitNormal = Vector3.yAxis

local function followTheCursor(cursorRay)
	-- Excluir objeto arrastado da detecção de raycast
	local raycastParams = RaycastParams.new()
	raycastParams.FilterDescendantsInstances = {dragDetector.Parent}
	raycastParams.FilterType = Enum.RaycastFilterType.Exclude

	local hitPoint = Vector3.zero
	local hitNormal = Vector3.yAxis

	local raycastResult = Workspace:Raycast(cursorRay.Origin, cursorRay.Direction, raycastParams)
	if raycastResult then
		hitPoint = raycastResult.Position
		hitNormal = raycastResult.Normal.Unit
	else
		hitPoint = cachedHitPoint
		hitNormal = cachedHitNormal
	end

	cachedHitPoint = hitPoint
	cachedHitNormal = hitNormal

	local lookDir1 = hitNormal:Cross(Vector3.xAxis)
	local lookDir2 = hitNormal:Cross(Vector3.yAxis)
	local lookDir = if lookDir1.Magnitude > lookDir2.Magnitude then lookDir1.Unit else lookDir2.Unit
	return CFrame.lookAt(hitPoint, hitPoint + lookDir, hitNormal)
end

dragDetector:SetDragStyleFunction(followTheCursor)

Função de restrição personalizada

Detectores arrastáveis não têm regras de movimento integradas sobre redes e encaixe, mas você pode registrar funções de restrição personalizadas para editar a função do detector DragFrame.Por exemplo, você pode manter a movimentação em uma grade arredondando as posições para múltiplos do incremento da grade ou simular um jogo de xadrez com regras de movimento legais para cada peça.

Detector de Dragão - Função de restrição personalizada
local dragDetector = script.Parent.DragDetector
local startPartPosition = nil

local SNAP_INCREMENT = 4

dragDetector.DragStart:Connect(function()
	startPartPosition = script.Parent.Position
end)

dragDetector.DragEnd:Connect(function()
	startPartPosition = nil
end)

local function snapToWorldGrid(proposedMotion)
	if startPartPosition == nil then
		return proposedMotion
	end
	local snapIncrement = SNAP_INCREMENT // 1
	if snapIncrement < 1 then
		return proposedMotion
	end
	local newWorldPosition = startPartPosition + proposedMotion.Position
	local roundedX = ((newWorldPosition.X / snapIncrement + 0.5) // 1) * snapIncrement
	local roundedY = ((newWorldPosition.Y / snapIncrement + 0.5) // 1) * snapIncrement
	local roundedZ = ((newWorldPosition.Z / snapIncrement + 0.5) // 1) * snapIncrement
	local newRoundedWorldPosition = Vector3.new(roundedX, roundedY, roundedZ)
	return proposedMotion.Rotation + (newRoundedWorldPosition - startPartPosition)
end

local connection = dragDetector:AddConstraintFunction(2, snapToWorldGrid)
-- When applicable, remove the constraint function by invoking connection:Disconnect()

Exemplo de uso

Objetos físicos não ancorados

Uma implementação básica de detectores de arrasto é um jogo de equilíbrio de torre em que os jogadores devem remover cuidadosamente peças e tentar manter a torre de pé.Na seguinte estrutura de torre, cada peça tem um filho DragDetector com um padrão DragStyle de TranslatePlane para que os jogadores possam puxar as peças para fora, mas não para cima ou para baixo.

Modelos ancorados com peças ajustáveis

Você pode facilmente criar e compartilhar modelos que são principalmente ancorados, mas que têm uma ou mais partes/modelos filhos que os jogadores podem arrastar.Por exemplo, a seguinte mesa tem duas gavetas que os jogadores podem abrir para inspecionar o que há dentro.

Arraste detectores e restrições

Você pode combinar detectores de arrastamento com Constraints, por exemplo, um boneco de marionete.Na configuração a seguir, os controles são ancorados, as partes do corpo não são ancoradas e as restrições mantêm a marionete unida.Mover as alças com o TranslateViewPlane faz a marionete dançar, e as partes do corpo individuais também podem ser movidas com detectores de arrasto, enquanto o modelo mantém sua integridade.

Interfaces de usuário 3D

As interfaces de usuário 3D são facilmente alcançáveis através de detectores de arrastamento, como ajustar a brilho de um SpotLight com base em um dimmer de interruptor deslizante.Você também pode detectar os eixos X e Z individualmente para controlar dois aspectos diferentes de uma interface de usuário 3D, como o Size, Speed e Color de um ParticleEmitter.

Detector de Dragar - Interface de Usuário 3D
local model = script.Parent
local slider = model.SliderPart
local originPart = model.OriginPart
local emitter = script.Parent.EmitterPart.ParticleEmitter

local dragDetector = slider.DragDetector
dragDetector.ReferenceInstance = originPart
dragDetector.MinDragTranslation = Vector3.zero
dragDetector.MaxDragTranslation = Vector3.new(10, 0, 10)

local dragRangeX = dragDetector.MaxDragTranslation.X - dragDetector.MinDragTranslation.X
local dragRangeZ = dragDetector.MaxDragTranslation.Z - dragDetector.MinDragTranslation.Z

local MIN_PARTICLE_SIZE = 1
local MAX_PARTICLE_SIZE = 1.5
local MIN_PARTICLE_SPEED = 2.5
local MAX_PARTICLE_SPEED = 5
local COLOR1 = Color3.fromRGB(255, 150, 0)
local COLOR2 = Color3.fromRGB(255, 0, 50)

local function updateParticles(emitter)
	local dragFactorX = (dragDetector.DragFrame.Position.X - dragDetector.MinDragTranslation.X) / dragRangeX
	local dragFactorZ = (dragDetector.DragFrame.Position.Z - dragDetector.MinDragTranslation.Z) / dragRangeZ

	-- Ajuste o tamanho e a velocidade das partículas com base no fator de detecção de arrasto X
	emitter.Size = NumberSequence.new{
		NumberSequenceKeypoint.new(0, 0),
		NumberSequenceKeypoint.new(0.1, MIN_PARTICLE_SIZE + ((MAX_PARTICLE_SIZE - MIN_PARTICLE_SIZE) * dragFactorX)),
		NumberSequenceKeypoint.new(1, 0)
	}
	local speed = MIN_PARTICLE_SPEED + ((MAX_PARTICLE_SPEED - MIN_PARTICLE_SPEED) * dragFactorX)
	emitter.Speed = NumberRange.new(speed, speed * 1.2)
	-- Ajustar cor de partícula com base no fator Z do detector de arrasto
	local color = COLOR2:Lerp(COLOR1, dragFactorZ)
	emitter.Color = ColorSequence.new{
		ColorSequenceKeypoint.new(0, color),
		ColorSequenceKeypoint.new(1, color)
	}
end

dragDetector:GetPropertyChangedSignal("DragFrame"):Connect(function()
	updateParticles(emitter)
end)