Detectores de拖 3D

La instancia DragDetector facilita y promueve la interacción con objetos 3D en una experiencia, como abrir puertas y cajones, deslizar una parte alrededor, agarrar y lanzar una bola de boliche, agarrar y disparar una darda y mucho más. Las características clave incluyen:

• Coloca un DragDetector debajo de cualquier BasePart o Model para hacer que sea arrastrable a través de todos los elementos (ratón, toque, controlador para juegoy VR), todos sin una línea de código.

• Elige entre varios estilos de <a href=\"#draw\">agarrar</a>, define cómo responde el objeto <a href=\"#draw\">a la movilidad</a> y, opcionalmente, aplica <a href=\"#draw\">límites de eje o movimiento</a>.

• Los scripts pueden responder a la manipulación de objetos arrastrados para conducir la interfaz de usuario o tomar decisiones lógicas, como ajustar el nivel de luz en una habitación basado en un dimmer de pared deslizante.

• Los jugadores pueden manipular partes o modelos anclados y se mantendrán exactamente donde los pusiste al lanzar.

• Class.DragDetector|DragDetectors funciona en Studio mientras estás no usando las herramientas de Seleccionar , 0>Mover0>, 3>Escala3> o DragDetectors6>, lo que facilita probar y ajustar objetos arrastrables mientras estás editando.

Haciendo Objetos Dragables

Para hacer que cualquier parte o modelo arrastrable, simplemente agregue un DragDetector como descendiente directo.

1. En la ventana Explorador, pasa el cursor sobre el Part, MeshPart o 1> Class.Model1> y haz clic en el botón ⊕. Se muestra un menú contextual.

2. Del menú, inserta un DragDetector .

   

3. Por defecto, el objeto ahora será arrastrable en el plano de tierra, pero puedes personalizar su DragStyle , definir cómo responde a la movilidad y, opcionalmente, aplicar límites de eje o de movimiento.

Personalización de los detectores de drag

Estilo de arrastre

DragDetectors muévete el cursor del mapa a líneas y aviones virtuales para calcular la propuesta 3D. A través de la propiedad DragStyle, puedes elegir de diferentes mapas para satisfacer tus necesidades. Por ejemplo, TranslatePlane produce traducción en un plano virtual, mientras que

Dirección de arrastre

Por defecto, la movilidad 3D y el mapa asociado DragStyle a espacio mundial. Sin embargo, puede que desee cambiar la ReferenceInstance , Orientation o 1> Class

Respuesta a la acción

La propiedad ResponseStyle especifica cómo responde un objeto a la propuesta de movimiento, dependiendo de si el objeto es Anchored o no.

Límites de eje y movimiento

Por defecto, no hay límites para el movimiento 3D más allá de las limitaciones inherentes del DragStyle. Si es necesario, puede aplicar los límites mínimo y máximo a ambas las traducciones y rotaciones. Tenga en cuenta, sin embargo, que estos no son bloqueos ; simplemente impiden que el detector de drag genere movimiento para mantenerse dentro de los límites.

Permiso de arrastre

La autorización de los jugadores para interactuar con una determinada instancia de detector de arrastre se puede especificar por la propiedad PermissionPolicy. Esto se establece por defecto como Enum.DragDetectorPermissionPolicy.Everybody y se puede cambiar para apoyar los controles de permiso basados en scripts como se muestra en el ejemplo de código.

DragDetector - Permiso de arrastre escrito
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)

Respuesta de física

Suponga que el estilo de respuesta de un dragger está configurado como Físico y se aplica a un objeto no anclado, ese objeto se moverá a través de las fuerzas de restricción que intentan llevarlo a la posición/orientación propuesta. Puede personalizar el objeto físico a través de las siguientes propiedades:

Entrada de Modificador

Replicación

Cuando la propiedad RunLocally es falsa (por defecto), el cliente interpreta todo el ingreso para producir los datos que envía al servidor para realizar el drag. En este modo, todos los señales de evento personalizadas y funciones registradas deben estar en el servidor Scripts .

Cuando la propiedad RunLocally es cierta, no se replican eventos al servidor. Todas las señales de eventos personalizadas y las funciones registradas deben estar en el cliente LocalScripts y deben usar eventos remotos para propagar las necesarias cambios al servidor.

Programar respuestas para hacer clic y arrastrar

A través de señales de eventos , propiedad cambios, Scriptable estilo de arrastre, y personalizaciones, los scripts pueden responder a la manipulación de objetos arrastrados para conducir la interfaz de usuario o tomar decisiones lógicas, como ajustar el nivel de luz en una habitación basado en un interruptor de pared deslizante.

Señales de eventos

A través de las siguientes señales de eventos, puede detectar cuando un usuario comienza, continúa y termina arrastrando un objeto.

DragDetector - Señales de eventos
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)

Mover cambios de marco

Además de los señales de eventos, puedes monitorear los cambios en el detector DragFrame directamente.

DragDetector - Cambios de DragFrame
local dragDetector = script.Parent.DragDetector

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

Estilo de arrastreado con script

Si estableces el DragStyle de un detector en Scriptable , puedes proporcionar tu propia función que toma un Ray y devuelve un espacio de mundo 1> Datatype.CFrame1> . El detector moverá el movimiento para que el objeto拖ado vaya a esa ubicación personalizada/orientación.

DragDetector - Estilo de arrastre codificado
local dragDetector = script.Parent.DragDetector
dragDetector.DragStyle = Enum.DragDetectorDragStyle.Scriptable

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

local function followTheCursor(cursorRay)
	-- Excluir el objeto arrastrado de la detección 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)

Función de límite personalizado

Los detectores de arrastre no tienen reglas de movimiento integradas sobre rejillas y ajustes, pero puede registrar funciones de restricción personalizadas para editar el detector's DragFrame antes de que se aplique. Por ejemplo, puede mantener el movimiento en una rejilla alrededor de posiciones para multiplicar el incremento de la rejilla, o simular un juego de chess con reglas de movimiento legales para cada pieza.

DragDetector - Función de restricción 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 = math.floor(SNAP_INCREMENT)
	if snapIncrement < 1 then
		return proposedMotion
	end
	local newWorldPosition = startPartPosition + proposedMotion.Position
	local roundedX = math.floor(newWorldPosition.X / snapIncrement + 0.5) * snapIncrement
	local roundedY = math.floor(newWorldPosition.Y / snapIncrement + 0.5) * snapIncrement
	local roundedZ = math.floor(newWorldPosition.Z / snapIncrement + 0.5) * 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()

Ejemplo de uso

Objetos físicos sin anclar

Una implementación básica de los detectores de drag es un juego de equilibrio de torre en el que los jugadores deben eliminar cuidadosamente las piezas y tratar de mantener la torre erguida. En la siguiente estructura de torre, cada pieza tiene un hijo DragDetector con un estilo de drag predeterminado DragStyle de TranslatePlane para

Modelos anclados con partes ajustables

Puede crear y compartir fácilmente modelos que están anclados principalmente, pero que tienen una o más partes/modelos hijos que los jugadores pueden arrastrar. Por ejemplo, la siguiente escritorio tiene dos cajones que los jugadores pueden abrir para inspeccionar qué hay dentro.

Arrastrar Detectores y Con restricciones

Puede combinar los detectores de arrastre con Constraints, por ejemplo, una marioneta. En la siguiente configuración, las manijas de control están ancladas, las partes del cuerpo no están ancladas y los límites mantienen la marioneta juntos. Mover las manijas con el TranslateViewPlane

Interfaces de usuario 3D

Las interfaces de usuario 3D se pueden fácilmente lograr a través de los detectores de arrastre, como ajustar el brillo de un Class.SpotLight basado en un dimmer de interruptor desliz

DragDetector - Interfaz de usuario 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

	-- Ajustar el tamaño de partículas y la velocidad según el multiplicador de X del detector de arrastre
	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 el color de la partícula según el multiplicador de Z del detector de arrastre
	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)