Model
*Este contenido se traduce usando la IA (Beta) y puede contener errores. Para ver esta página en inglés, haz clic en aquí.
Los modelos son objetos contenedores, lo que significa que agrupan objetos juntos.Se utilizan mejor para contener colecciones de BaseParts y tienen una serie de funciones que extienden su funcionalidad.
Los modelos están destinados a representar grupos geométricos .Si tu agrupación no tiene interpretación geométrica, por ejemplo, una colección de Scripts , utiliza un Folder en su lugar.
Los modelos cuyas partes constituyentes se unen con bisagras (para que puedan moverse o destruirse a través de simulación de física) generalmente tienen un conjunto PrimaryPart , ya que especifica qué parte dentro del modelo seguirá la bisagra y la caja de contención como el modelo se mueve.Los modelos estáticos que se quedan en un lugar no se benefician de tener un conjunto de partes primarias.
Los modelos tienen un amplio rango de aplicaciones, incluidos los personajes de jugadores de Roblox.También tienen una serie de comportamientos únicos que es importante tener en cuenta:
- Cuando un Humanoid y un Part llamado Cabeza estén patrocinados bajo un modelo, una interfaz de nombre/salud aparecerá sobre el modelo; véase Nombre/visualización de salud del personaje para detalles.
- Si la posición de una parte en el eje Y golpea el valor Workspace.FallenPartsDestroyHeight , y fue el último objeto dentro de un Model, el modelo también se destruirá.
- Cuando se usa en un lugar con Workspace.StreamingEnabled establecido en verdad, el valor de ModelStreamingMode controla varios comportamientos alrededor de cómo se replica y/o elimina el modelo y cualquier descendiente de los clientes.Además, el valor de LevelOfDetail afecta el rendimiento de la renderización del modelo.
Al igual que con todos los tipos Instance tipos, el hecho de que un padre Model se replica a un cliente no garantiza que todos sus hijos se replican.Esto es particularmente importante si estas instancias se están accediendo por código que se ejecuta en el cliente, como en un LocalScript .El uso de ModelStreamingMode con valores como Atomic puede garantizar que todo el modelo y todos sus descendientes estén presentes si el modelo padre existe en el cliente, o puedes usar WaitForChild() cuando no se desee la atomización.
Muestras de código
The following sample includes a basic function that takes a table of objects and parents them into a new Model, returning that Model.
local function groupObjects(objectTable)
local model = Instance.new("Model")
for _, object in pairs(objectTable) do
object.Parent = model
end
return model
end
local objects = {
Instance.new("Part"),
Instance.new("Part"),
}
groupObjects(objects)Resumen
Propiedades
Establece el nivel de detalle en el modelo para experiencias con transmisión de instancias habilitada.
Controla el comportamiento de transmisión de modelos en Models.
La parte principal de la Model , o nil si no se configura explícitamente.
Propiedad solo del editor utilizada para escalar el modelo alrededor de su pivote. Establecer esta propiedad moverá la escala como si se llamara Model/ScaleTo a ella.
Determina dónde se encuentra el eje de un que no tenga un conjunto establecido.
Métodos
Establece este modelo para ser persistente para el jugador especificado. ModelStreamingMode debe establecerse en PersistentPerPlayer para que el comportamiento se cambie como resultado de la adición.
Devuelve una descripción de un volumen que contiene todas las partes de un modelo.
Devuelve el tamaño de la caja de contención más pequeña que contiene todo el BaseParts en el Model, alineada con el Model.PrimaryPart si se establece.
Devuelve todos los objetos Player que este objeto de modelo es persistente para.El comportamiento varía según si este método se llama desde un Script o un LocalScript.
Devuelve la escala canónica del modelo, que se establece por defecto en 1 para los modelos recién creados y cambiará a medida que se escala a través de Model/ScaleTo.
Mueve el PrimaryPart a la posición dada. Si no se ha especificado una parte principal, se usará la parte raíz del modelo.
Hace que este modelo ya no sea persistente para el jugador especificado. ModelStreamingMode debe establecerse en PersistentPerPlayer para que el comportamiento se cambie como resultado de la eliminación.
Establece el factor de escala del modelo, ajustando el tamaño y la ubicación de todas las Instancias descendientes para que tengan ese factor de escala en relación con sus tamaños y ubicaciones iniciales cuando el factor de escala era 1.
Cambia un Model por el desplazamiento dado Vector3, preservando la orientación del modelo.Si otro BasePart o Terrain ya existe en la nueva posición, entonces el Model se superpondrá al objeto dicho.
Obtiene el pivote de un PVInstance .
Transforma el PVInstance junto con todos sus descendientes PVInstances de tal manera que el pivote ahora se encuentra en el punto especificado CFrame.
Propiedades
LevelOfDetail
Establece el nivel de detalle en el modelo para experiencias con transmisión de instancias habilitada.
Cuando se establece en StreamingMesh , una malla de "impostor" de resolución más baja (malla gruesa que se envuelve alrededor de todas las partes hijas del modelo) se renderiza fuera del radio de transmisión.
Cuando se establece en Disabled o Automatic, las mallas de resolución más baja no se mostrarán.
ModelStreamingMode
Controla cómo se transmiten Models dentro y fuera cuando se habilita el streaming de instancias streaming.El comportamiento depende del enum seleccionado.No tiene efecto cuando el streaming no está habilitado.
Esta propiedad solo debe cambiarse en Studio a través de la ventana Propiedades cuando se habilita el streaming, o en Scripts , pero nunca en LocalScripts (hacerlo puede resultar en un comportamiento no definido).
PrimaryPart
Apunta a la parte principal del Model.La parte principal es la BasePart que actúa como referencia física para el eje del modelo.Es decir, cuando las partes dentro del modelo se mueven debido a la simulación física o a otros medios, el pivote se moverá sincronizado con la parte principal.
Tenga en cuenta que Models no tienen PrimaryPart establecido por defecto.Si estás creando un modelo que debe ser actuado por la física, deberás establecer manualmente esta propiedad en Studio o dentro de un script.Si la parte principal no está configurada , el pivote se mantendrá en la misma ubicación en el espacio mundial, incluso si se mueven partes dentro del modelo.
Tenga en cuenta también que al establecer esta propiedad, debe ser un BasePart que sea un descendiente del modelo.Si intentas establecer a un que no sea un descendiente del modelo, se establecerá a esa parte, pero se restablecerá a no durante el siguiente paso de simulación — este es el comportamiento legado para soportar scripts que asumen que pueden establecer temporalmente la parte principal en un que no sea un descendiente del modelo.
La regla general para los modelos es que:
- Los modelos cuyas partes se unen a través de juntas físicas como WeldConstraints o Motor6Ds deberían tener una parte principal asignada.Por ejemplo, los modelos de personajes de Roblox tienen su Model.PrimaryPart configurado por defecto al HumanoidRootPart .
- Los modelos estáticos (normalmente Anchored ) que se quedan en un lugar a menos que un script los mueva explícitamente no requieren un Model.PrimaryPart y tienden a no beneficiarse de tener un conjunto.
Muestras de código
This code sample creates and throws a dice model, then outputs whether it landed with the blue side facing up. If Model.PrimaryPart was not set, the pivot / bounding box of the dice would rotate, as the parts inside of it are physically simulated during the roll.
-- Create a dice model with two halves and attach them together
local diceModel = Instance.new("Model")
diceModel.Name = "ChanceCube"
local diceTop = Instance.new("Part")
diceTop.Size = Vector3.new(4, 2, 4)
diceTop.Position = Vector3.new(0, 1, 0)
diceTop.Color = Color3.new(0, 0, 1)
diceTop.Parent = diceModel
local diceBottom = diceTop:Clone()
diceBottom.Position = Vector3.new(0, -1, 0)
diceBottom.Color = Color3.new(1, 0, 0)
diceBottom.Parent = diceModel
local weld = Instance.new("WeldConstraint")
weld.Part0 = diceTop
weld.Part1 = diceBottom
weld.Parent = diceModel
-- Put the dice up in the air above the workspace origin (does not require a primary part)
diceModel.Parent = workspace
diceModel:PivotTo(CFrame.new(0, 10, 0))
-- Assign the primary part before physical simulation
-- Without this line, the script will always output the same thing and the bounding box of the model will not change orientation
diceModel.PrimaryPart = diceTop
-- Wait a bit before rolling the dice (let it settle onto the floor)
for i = 5, 1, -1 do
print("Rolling dice in...", i)
task.wait(1)
end
diceTop:ApplyAngularImpulse(Vector3.new(15000, 1000, 5000))
diceTop:ApplyImpulse(Vector3.new(0, 3000, 0))
task.wait(1)
-- Wait for the roll to complete
while diceTop.AssemblyLinearVelocity.Magnitude > 0.1 or diceTop.AssemblyAngularVelocity.Magnitude > 0.1 do
task.wait()
end
-- Get the dice orientation, impacted by the primary part
local orientation = diceModel:GetBoundingBox()
if orientation.YVector.Y > 0.5 then
print("It's the boy!")
else
print("It's his mother!")
endScale
Establecer esta propiedad en la ventana de propiedades escalará el modelo como si se hubiera llamado a Model/ScaleTo, escalando todas las instancias descendientes en el modelo, como materiales, imágenes y la geometría 3D de las piezas, para que el modelo tenga el factor de escala especificado en relación con su tamaño original.
Esta propiedad solo está disponible en Studio y lanzará un error si se usa en un Script o LocalScript . Model/ScaleTo y Model/GetScale deben usarse desde los scripts.
WorldPivot
Esta propiedad determina dónde se encuentra el eje de un que no tiene un conjunto no establecido.Si el Model hace tiene un PrimaryPart , el pivote de la Model es igual al pivote de esa parte principal en lugar de eso, y esta propiedad WorldPivot se ignora.
Para un nuevo creado Model , su pivote se tratará como el centro de la caja de contención de sus contenidos hasta que se establezca la propiedad primera vez de su Model.WorldPivot.Una vez que el eje mundial se configura por primera vez, es imposible restaurar este comportamiento inicial.
Con mayor frecuencia, mover el modelo con las herramientas de Studio o con funciones de movimiento de modelos como PVInstance:PivotTo() y Model:MoveTo() , establecerá el punto de pivote del mundo y así terminará este nuevo comportamiento del modelo.
El propósito de este comportamiento es permitir que el código Luau obtenga un pivote sensato simplemente creando un nuevo modelo y asignando objetos a él, evitando la necesidad de establecer explícitamente Model.WorldPivot.
Muestras de código
This code sample shows a custom function for resetting the pivot of a model back to the center of that model's bounding box.
local function resetPivot(model)
local boundsCFrame = model:GetBoundingBox()
if model.PrimaryPart then
model.PrimaryPart.PivotOffset = model.PrimaryPart.CFrame:ToObjectSpace(boundsCFrame)
else
model.WorldPivot = boundsCFrame
end
end
resetPivot(script.Parent)Métodos
AddPersistentPlayer
Establece este modelo para que sea persistente para el jugador especificado.Los modelos persistentes se mantienen presentes para el jugador independientemente de la configuración o las condiciones de transmisión.
ModelStreamingMode debe establecerse en PersistentPerPlayer para que el comportamiento se cambie como resultado de la adición.
Parámetros
Devuelve
GetBoundingBox
Esta función devuelve una descripción de un volumen que contiene todos los BasePart hijos dentro de un Model .La orientación del volumen se basa en la orientación del PrimaryPart , y coincide con la caja de selección renderizada en Studio cuando se selecciona el modelo.Al reflejar el comportamiento de Terrain:FillBlock() , devuelve un CFrame que representa el centro de esa caja de contención y un Vector3 que representa su tamaño.
Si no hay PrimaryPart para el modelo, la caja de contención se alineará con los ejes del mundo.
Devuelve
GetExtentsSize
Devuelve el tamaño de la caja de contención más pequeña que contiene todo el BaseParts en el Model.Si Model.PrimaryPart existe, la caja de contención se alineará con esa parte.Si una parte principal no se ha establecido, la función elegirá una parte en el modelo para alinear la caja de contención.Como la selección de esta parte no es determinista, se recomienda establecer un Model.PrimaryPart para obtener resultados consistentes con esta función.
Tenga en cuenta que esta función solo devuelve el tamaño de la caja de contención más pequeña y el desarrollador debe emplear su propio método para obtener la posición de la caja de contención.
Devuelve
Muestras de código
The code sample below demonstrates how Model.GetExtentsSize can be used to get the size of the bounding box containing the parts.
local model = Instance.new("Model")
model.Parent = workspace
local RNG = Random.new()
for _ = 1, 5 do
local part = Instance.new("Part")
part.Anchored = true
part.Size = Vector3.new(RNG:NextNumber(0.05, 5), RNG:NextNumber(0.05, 5), RNG:NextNumber(0.05, 5))
part.Parent = model
end
print(model:GetExtentsSize())GetPersistentPlayers
Cuando este método se llama desde un Script , devuelve todos los objetos Player persistentes para los que este modelo es persistente.Cuando se llama desde un LocalScript , este método solo comprueba si este modelo es persistente para el LocalPlayer .
Devuelve
Una tabla con todos los objetos Player que este objeto de modelo es persistente para.
GetScale
Los modelos contienen un factor de escala canónica persistente, que comienza en 1 para los modelos recién creados y cambia a medida que el modelo se escala llamando Model/ScaleTo.Esta función devuelve el factor de escala canónico actual del modelo.
El factor de escala actual no tiene directamente impacto en el tamaño de las instancias bajo el modelo.Se usa para fines de autoría de contenido y programación para recordar cómo se ha escalado el modelo en relación con su tamaño original.
Dentro de una sesión determinada, el modelo almacenará la información precisa de tamaño original de las Instancias descendientes después de la primera llamada Model/ScaleTo .Esto significa que llamar seguido de te devolverá exactamente la configuración original del modelo sin deriva de punto flotante.Evitar el desplazamiento de punto flotante es la motivación para tener una función de escala a en lugar de una función de escala por .
El factor de escala tiene un impacto en el comportamiento del motor de una manera: el factor de escala de un modelo se aplicará a los desplazamientos conjuntos de animations jugados en un AnimationController bajo ese modelo, para que las animaciones animadas se reproducen correctamente incluso cuando se escalan.
Devuelve
El factor de escala canónico actual del modelo.
Muestras de código
This code sample demonstrates substituting in a replacement for all the copies of a tree model using PivotTo and ScaleTo. The pivot and scale of the models are used as a reference ensuring that the relative sizes and locations of the replacement models match those of the originals.
local CollectionService = game:GetService("CollectionService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
-- Find all the models with the tag we want to replace
local items = CollectionService:GetTagged("Tree")
local newModel = ReplicatedStorage.FancyTreeReplacementModel
for _, item in items do
-- Make the new item and scale / position it where the old one was
local newItem = newModel:Clone()
newItem:ScaleTo(item:GetScale())
newItem:PivotTo(item:GetPivot())
-- Add the same tag to the replacement
CollectionService:AddTag(newItem, "Tree")
-- Delete the old item and parent the new one
newItem.Parent = item.Parent
item:Destroy()
endMoveTo
Mueve el PrimaryPart a la posición dada.Si no se ha especificado una parte principal, se usará la parte raíz del modelo, pero la parte raíz no es determinista y se recomienda que siempre establezca una parte principal al usar MoveTo() .
Si hay alguna obstrucción donde el modelo debe ser movido, como Terrain o otro BaseParts, el modelo se moverá verticalmente hacia arriba hasta que no haya nada en el camino.Si este comportamiento no es deseado, PVInstance:PivotTo() debe usarse en su lugar.
Tenga en cuenta que la rotación no se preserva al mover un modelo con MoveTo() .Se recomienda usar TranslateBy() o PVInstance:PivotTo() si la rotación actual del modelo debe preservarse.
Parámetros
Devuelve
Muestras de código
This sample demonstrates how Model:MoveTo avoids collisions.
A simple two part Model is created, and its PrimaryPart is set. An large obstruction part is placed next to it.
After 5 seconds Model:MoveTo is used to direct the model to move inside the obstruction part. However, as MoveTo will not move a model inside of an obstruction the Model is moved up on the Y axis and placed above the obstruction.
local START_POSITION = Vector3.new(-20, 10, 0)
local END_POSITION = Vector3.new(0, 10, 0)
local model = Instance.new("Model")
model.Parent = workspace
local part1 = Instance.new("Part")
part1.Size = Vector3.new(4, 4, 4)
part1.Position = START_POSITION
part1.Anchored = true
part1.BrickColor = BrickColor.new("Bright yellow")
part1.Parent = model
local part2 = Instance.new("Part")
part2.Size = Vector3.new(2, 2, 2)
part2.Position = START_POSITION + Vector3.new(0, 3, 0)
part2.Anchored = true
part2.BrickColor = BrickColor.new("Bright blue")
part2.Parent = model
model.PrimaryPart = part1
model.Parent = workspace
local obstruction = Instance.new("Part")
obstruction.Name = "Obstruction"
obstruction.Size = Vector3.new(10, 10, 10)
obstruction.Position = Vector3.new(0, 10, 0)
obstruction.Anchored = true
obstruction.BrickColor = BrickColor.new("Bright green")
obstruction.Parent = workspace
task.wait(3)
model:MoveTo(END_POSITION)RemovePersistentPlayer
Hace que este modelo ya no sea persistente para el jugador especificado.Esto no garantiza que el modelo se elimine inmediatamente para el jugador; después de llamar este método, el modelo se tratará como Atomic para ese jugador y permanecerá presente mientras esté dentro del radio de transmisión objetivo.
ModelStreamingMode debe establecerse en PersistentPerPlayer para que el comportamiento se cambie como resultado de la eliminación.
Parámetros
Devuelve
ScaleTo
Los modelos contienen un factor de escala canónica persistente, que comienza en 1 para los modelos recién creados.Esta función escala el modelo, alrededor de la ubicación de pivote, en relación con cómo se vería con un factor de escala de 1.Para lograr esto, hace dos cosas:
- Establece el factor de escala actual del modelo al valor especificado
- Redimensiona y reposiciona todas las Instancias descendientes de acuerdo
La escalada de ubicaciones se realiza alrededor de la ubicación pivote.
Todas las propiedades "geométricas" de las Instancias descendientes se escalarán.Eso obviamente incluye los tamaños de las piezas, pero aquí hay algunos otros ejemplos de propiedades que se escalan:
- La longitud de las juntas como WeldConstraints , y Class.Rope|Ropes
- Velocidades y fuerzas físicas como Hinge.MaxServoTorque
- Propiedades visuales como tamaños de emisores de partículas
- Otras propiedades de longitud como Sound.RollOffMinDistance
Parámetros
Devuelve
TranslateBy
Cambia un Model por el desplazamiento dado Vector3, preservando la orientación del modelo.Si otro BasePart o Terrain ya existe en la nueva posición, entonces el Model se superpondrá al objeto dicho.
La traducción se aplica en el espacio mundial en lugar del espacio de objetos, lo que significa que incluso si las partes del modelo se orientan de manera diferente, aún se moverá a lo largo del eje estándar.
Parámetros
Devuelve
Muestras de código
This sample demonstrates how Model:TranslateBy ignores collisions and respects the orientation of the model.
A simple two part Model is created, rotated 45 degrees on the Y axis, and its PrimaryPart is set. An large obstruction part is placed next to it.
After 5 seconds Model:TranslateBy is used to direct the model to move inside the obstruction part. The model will move inside of the obstruction and maintain it's current orientation.
local START_POSITION = Vector3.new(-20, 10, 0)
local END_POSITION = Vector3.new(0, 10, 0)
local model = Instance.new("Model")
local part1 = Instance.new("Part")
part1.Size = Vector3.new(4, 4, 4)
part1.CFrame = CFrame.new(START_POSITION) * CFrame.Angles(0, math.rad(45), 0)
part1.Anchored = true
part1.BrickColor = BrickColor.new("Bright yellow")
part1.Parent = model
local part2 = Instance.new("Part")
part2.Size = Vector3.new(2, 2, 2)
part2.CFrame = part1.CFrame * CFrame.new(0, 3, 0)
part2.Anchored = true
part2.BrickColor = BrickColor.new("Bright blue")
part2.Parent = model
model.PrimaryPart = part1
model.Parent = workspace
local obstruction = Instance.new("Part")
obstruction.Name = "Obstruction"
obstruction.Size = Vector3.new(10, 10, 10)
obstruction.Position = Vector3.new(0, 10, 0)
obstruction.Transparency = 0.5
obstruction.Anchored = true
obstruction.BrickColor = BrickColor.new("Bright green")
obstruction.Parent = workspace
task.wait(3)
-- use TranslateBy to shift the model into the obstruction
model:TranslateBy(END_POSITION - START_POSITION)