Generación de modelos

A través de mensajes de texto y esquemas predefinidos, tú (y los jugadores en el juego) pueden generar tanto activos 3D estáticos como modelos totalmente funcionales como vehículos que conducen, aviones que vuelan y armas que disparan. Esta guía demuestra cómo usar GenerateModelAsync() como parte de una experiencia creativa dinámica impulsada por los jugadores.

Visión general

GenerateModelAsync() permite la generación de geometrías de múltiples mallas con las siguientes ventajas:

• El esquema proporcionado define cómo se dividirá la geometría generada en partes.
• Cualquier objeto generado en el juego se replicará y será visible para todos los jugadores, lo que les permitirá construir juntos en tiempo real.
• Las mallas generadas son de mayor fidelidad, con mejores formas, siluetas, más detalle y menos artefactos. Las texturas generadas son más coherentes y detalladas, con menos grano y una iluminación horneada menos pronunciada.
• Los tiempos de generación tienen una menor latencia, lo que permite una creación más rápida y sensible en los juegos.
• Tú e incluso los jugadores durante el tiempo del juego pueden especificar cajas delimitadoras para sugerir el tamaño y las proporciones del modelo generado.
• Un recuento de triángulos máximo opcional mantiene los objetos generados en buen rendimiento para tu juego.

Generación basada en esquemas

Para crear objetos articulados y funcionales, la geometría generada debe separarse en múltiples MeshParts. Por ejemplo, para crear un coche conductor con ruedas que giran y se dirigen, se necesitan al menos cinco MeshParts: uno para el cuerpo del coche y cuatro para cada una de las ruedas del coche. GenerateModelAsync() logra esto a través de un esquema que enumera las partes a generar, como se muestra en el siguiente fragmento de código:

Script en ServerScriptService
local GenerationService = game:GetService("GenerationService")
local Workspace = game:GetService("Workspace")

-- Configurar entradas para la geometría generada
local inputs = {
	TextPrompt = "coche dragón verde con 4 ruedas"
}
-- Establecer el esquema al chasis de cinco modelos predefinido
local schema = {
	PredefinedSchema = "Car5"
}

-- Hacer la llamada para generar el modelo
local success, result, metadata = pcall(function()
	return GenerationService:GenerateModelAsync(inputs, schema)
end)
if success then
	-- Escalar el modelo al tamaño objetivo y posicionarlo cerca del centro del mundo
	local targetSize = 16
	local modelSize = result:GetExtentsSize()
	local scaleFactor = targetSize / math.max(modelSize.X, modelSize.Y, modelSize.Z)
	result:ScaleTo(scaleFactor)
	result:PivotTo(CFrame.new(0, result:GetExtentsSize().Y / 2, -40))

	-- Anclar todas las partes para que las mallas no se desmoronen
	for _, descendant in result:GetDescendants() do
		if descendant:IsA("BasePart") then
			descendant.Anchored = true
		end
	end

	-- Nombrar el modelo y parentearlo al espacio de trabajo
	result.Name = "GeneraciónCocheDragónBásico"
	result.Parent = Workspace
else
	warn(result)
end

La siguiente imagen muestra la salida esperada y su construcción tal como aparece en la jerarquía de Explorer:

Scripts re-dirigibles

En Roblox, comportamientos abarca típicamente los scripts, adjuntos, restricciones, y otros tipos de instancia adjuntos a geometrías texturizadas estáticas para hacerlas funcionales. Dado que GenerateModelAsync() genera una amplia gama de geometrías sobre la marcha, los scripts re-dirigibles deben estar adjuntos para adaptar automáticamente los comportamientos a la funcionalidad esperada.

Por ejemplo, considera un juego donde los jugadores pueden hacer sus propios coches conducibles. GenerateModelAsync() toma el mensaje del jugador y genera cinco mallas distintas (cuerpo y cuatro ruedas) a través del esquema Car5 esquema. Luego, un script re-dirigible preestablecido adapta su comportamiento de conducción al tamaño y forma del modelo para asegurar que el coche sea conducible y que sus ruedas giren de manera realista.

Para probar scripts re-dirigibles:

1. Descarga el Behaviors.rbxm archivo.

2. En la jerarquía de Explorer de Studio, haz clic derecho en ReplicatedStorage, selecciona Insertar ⟩ Importar Modelo de Roblox, y elige el archivo descargado. El modelo se descomprimirá en varias carpetas.

   

3. Copia y pega uno de los siguientes fragmentos de código en un Script del servidor dentro de ServerScriptService, dependiendo del tipo de objeto que te gustaría generar.

   CocheAvión

   Este ejemplo genera un coche funcional con freno, impulso de nitro, efectos visuales y de audio, y un velocímetro en pantalla.

   Script en ServerScriptService
   local GenerationService = game:GetService("GenerationService")
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local Workspace = game:GetService("Workspace")
   
   -- Configurar entradas para la geometría generada
   local inputs = {
   	TextPrompt = "coche dragón verde con 4 ruedas"
   }
   -- Establecer el esquema al chasis de cinco modelos predefinido
   local schema = {
   	PredefinedSchema = "Car5"
   }
   
   -- Hacer la llamada para generar el modelo
   local success, result, metadata = pcall(function()
   	return GenerationService:GenerateModelAsync(inputs, schema)
   end)
   if success then
   	-- Escalar el modelo al tamaño objetivo
   	local targetSize = 16
   	local modelSize = result:GetExtentsSize()
   	local scaleFactor = targetSize / math.max(modelSize.X, modelSize.Y, modelSize.Z)
   	result:ScaleTo(scaleFactor)
   
   	-- Cargar el módulo "makeFunctional" para "CarBehavior"
   	local makeFunctional = require(ReplicatedStorage.Behaviors.CarBehavior.makeFunctional)
   
   	-- Referenciar partes del coche por nombres garantizados a través del esquema "Car5"
   	local body = result:FindFirstChild("cuerpo")
   	local frontLeftWheel = result:FindFirstChild("rueda delantera izquierda")
   	local frontRightWheel = result:FindFirstChild("rueda delantera derecha")
   	local rearLeftWheel = result:FindFirstChild("rueda trasera izquierda")
   	local rearRightWheel = result:FindFirstChild("rueda trasera derecha")
   
   	-- Establecer parámetros de configuración del comportamiento
   	local config = {
   		seatPosition = "dentro",
   		invisibleWhenSeated = false
   	}
   
   	-- Adjuntar comportamiento a través del script "makeFunctional"
   	local functionalModel = makeFunctional(result, frontLeftWheel, frontRightWheel, rearLeftWheel, rearRightWheel, body, config)
   
   	-- Posicionar el modelo cerca del centro del mundo
   	functionalModel:PivotTo(CFrame.new(0, functionalModel:GetExtentsSize().Y / 2, -40))
   	functionalModel.Name = "GeneraciónCocheDragónBásico"
   	functionalModel.Parent = Workspace
   else
   	warn(result)
   end

   Para probar otros modelos generados con scripts re-dirigibles en el esquema Car5, cambia el valor de la cadena TextPrompt en la línea 7 y vuelve a probar. Las ideas incluyen:

   • "coche deportivo amarillo con un alerón"
   • "coche murciélago púrpura con 4 ruedas"
   • "camión monstruo gigante con techo puntiagudo"