GenerationService
*Este contenido se traduce usando la IA (Beta) y puede contener errores. Para ver esta página en inglés, haz clic en aquí.
GenerationService es un servicio que permite a los desarrolladores generar objetos 3D a partir de indicaciones de texto utilizando el modelo de base de datos 3D Cube 3D de Roblox.
La generación de malla es un proceso de dos pasos:
- GenerateMeshAsync() inicia el proceso de generación de malla usando un mensaje de texto y otros parámetros requeridos.Devuelve un identificador único (ID de generación) que se puede utilizar para recuperar el resultado futuro.
- LoadGeneratedMeshAsync() carga la malla generada en la experiencia. La malla se devuelve como una MeshPart que contiene un EditableMesh.
Actualmente, GenerationService solo soporta el siguiente uso:
- GenerateMeshAsync() debe llamarse desde los scripts del servidor.
- LoadGeneratedMeshAsync() debe llamarse desde los scripts del cliente.
Como resultado, cuando una solicitud de generación de malla proviene de un cliente, el cliente debe enviar una señal al servidor para iniciar la generación.Una vez que el servidor determine que la generación está completa, debe notificar al cliente apropiado para que llame LoadGeneratedMeshAsync() y recupere la malla.Tenga en cuenta que debido a que la malla generada se carga con contenido de EditableMesh , solo en el cliente, no se replica a ningún otro cliente.
El siguiente código ilustra este patrón de diseño.Vea esta experiencia de demostración para un ejemplo más detallado.Haga clic en el botón ⋯ y Editar en Studio .
Muestras de código
Adds server-side functionality to handle mesh generation requests from clients.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local GenerationService = game:GetService("GenerationService")
-- Create a RemoteEvent for client-server communication
local meshGenerationEvent = Instance.new("RemoteEvent")
meshGenerationEvent.Name = "MeshGenerationEvent"
meshGenerationEvent.Parent = ReplicatedStorage
-- Event to send generation results back to clients
local generationResultEvent = Instance.new("RemoteEvent")
generationResultEvent.Name = "GenerationResultEvent"
generationResultEvent.Parent = ReplicatedStorage
-- Handle mesh generation requests from clients
meshGenerationEvent.OnServerEvent:Connect(function(player, prompt)
print("Generating mesh for player", player.Name, "with prompt:", prompt)
-- Generate the mesh on the server
local success, generationId, contextId = pcall(function()
return GenerationService:GenerateMeshAsync(
{["Prompt"] = prompt},
player,
{},
function(intermediateType, intermediateGenerationId, intermediateContextId)
-- Send intermediate result to the requesting client
generationResultEvent:FireClient(
player,
intermediateGenerationId,
true -- isIntermediate
)
end
)
end)
if success then
-- Send the final generation ID to the client
generationResultEvent:FireClient(player, generationId, false)
print("Successfully generated mesh with ID:", generationId)
else
-- Notify the client of failure
generationResultEvent:FireClient(player, nil, false)
warn("Failed to generate mesh:", generationId)
end
end)Adds client-side functionality to request mesh generation from the server and display the results.
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local GenerationService = game:GetService("GenerationService")
local Players = game:GetService("Players")
-- Connect to the RemoteEvents
local meshGenerationEvent = ReplicatedStorage:WaitForChild("MeshGenerationEvent")
local generationResultEvent = ReplicatedStorage:WaitForChild("GenerationResultEvent")
-- Local player
local player = Players.LocalPlayer
-- Store generated meshes
local generatedMeshes = {}
-- Function to request mesh generation
local function requestMeshGeneration(prompt)
print("Requesting mesh generation for prompt: " .. prompt)
meshGenerationEvent:FireServer(prompt)
end
-- Handle generation results from the server
generationResultEvent.OnClientEvent:Connect(function(generationId, isIntermediate)
if not generationId then
print("Generation failed")
return
end
print(isIntermediate and "Loading intermediate result..." or "Loading final result...")
local mesh = GenerationService:LoadGeneratedMeshAsync(generationId)
if mesh then
-- Clean up previous mesh if it exists
if generatedMeshes[isIntermediate and "intermediate" or "final"] then
generatedMeshes[isIntermediate and "intermediate" or "final"]:Destroy()
end
mesh.Parent = workspace
-- Position the mesh in front of the player
local character = player.Character
if character and character:FindFirstChild("HumanoidRootPart") then
local rootPart = character.HumanoidRootPart
mesh:PivotTo(rootPart.CFrame * CFrame.new(0, 0, -10))
end
-- Store the mesh for cleanup
generatedMeshes[isIntermediate and "intermediate" or "final"] = mesh
print(isIntermediate and "Loaded intermediate result" or "Loaded final result")
else
print("Failed to load mesh")
end
end)
-- Example usage
requestMeshGeneration("toy robot")Resumen
Métodos
- GenerateMeshAsync(inputs : Dictionary,player : Player,options : Dictionary,intermediateResultCallback : function?):Tuple
Inicia la generación de una nueva malla 3D a partir de un mensaje de texto y devuelve ID únicos utilizados para rastrear y recuperar el resultado.Una vez que la generación esté completa, use LoadGeneratedMeshAsync() para cargar y mostrar la malla generada.
Recupera y carga una malla generada por GenerationService:GenerateMeshAsync() usando el generationId proporcionado. La malla se devuelve como una MeshPart con contenido EditableMesh.
Propiedades
Métodos
GenerateMeshAsync
Inicia la generación de una nueva malla 3D a partir de un mensaje de texto y devuelve ID únicos utilizados para rastrear y recuperar el resultado.Puede recibir opcionalmente resultados intermedios, como la malla sin textura, proporcionando una función intermediateResultCallback.Una vez que la generación esté completa, use LoadGeneratedMeshAsync() para cargar y mostrar la malla generada.
Límites de tasa Hay un límite de velocidad de 5 generaciones por minuto por experiencia.Si superas este límite, se bloquean las solicitudes de generación adicionales hasta el siguiente minuto.
Códigos de error | Error | Descripción | Acción recomendada del desarrollador | | ------------------------ | ------------------------------------------------------------------------------------ | | Límite de velocidad excedido | Se ha superado el número máximo de generaciones de malla para el minuto.| Espere hasta que se restablezca el límite de velocidad. | | Fallo de moderación | La generación de malla fue etiquetada para la moderación.| Revisa y modifica el mensaje para asegurarte de que cumple con las directrices de moderación de Roblox.| | Error interno del servidor | Se produjo un problema inesperado en el servidor.| Vuelva a intentar la solicitud más tarde o verifique el estado del servidor para problemas.| | Límite de caracteres excedido | La longitud de la interfaz de entrada para esta solicitud de generación superó el límite.| Reducir el número de caracteres en la cadena Prompt del diccionario input. |
Parámetros
Un diccionario que contiene las solicitudes de generación de malla.Actualmente, la única clave admitida es la Prompt (cadena) que describe la malla para generar.
Opciones adicionales de generación. Actualmente, no se admiten opciones.
Una función de llamada que se activa con los resultados de generación intermedios. Útil para recuperar versiones de malla tempranas (por ejemplo, antes de que se apliquen las texturas).
Devuelve
Un túnel de ID de generación y de ID de contexto.
- ID de generación: un ID único devuelto para cada invocación de GenerateMeshAsync() .
- ID de contexto: No se usa actualmente.
Muestras de código
Simple example showing how to use GenerateMeshAsync() to generate a mesh from a prompt.
local generationId, contextId = GenerationService:GenerateMeshAsync({["Prompt"] = "toaster"}, player, {})Example showing how to use GenerateMeshAsync() with a callback for intermediate results.
local generationId, contextId = GenerationService:GenerateMeshAsync({["Prompt"] = prompt}, player, {}, function(intermediateType, generationId, contextId)
-- Add your logic here
end)Example showing how to handle errors when generating meshes with GenerateMeshAsync().
local success, generationIdOrError, contextId = pcall(function()
return GenerationService:GenerateMeshAsync(
{["Prompt"] = "robot toy"},
player,
{},
function(intermediateType, intermediateId, intermediateContextId)
-- Notify client about intermediate result
generationResultEvent:FireClient(player, intermediateId, true)
end
)
end)
-- Handle a specific error code
if generationIdOrError == "Rate limit exceeded" then
-- Wait for the rate limit to reset
elseif success then
-- Send the final generation ID to the client
generationResultEvent:FireClient(player, generationIdOrError, false)
endLoadGeneratedMeshAsync
Recupera y carga una malla generada por GenerationService:GenerateMeshAsync() usando el ID de generación proporcionado.La malla se devuelve como una MeshPart con contenido EditableMesh.Debido a que los modelos editables no se replican, el modelo cargado no se replica a ningún otro cliente y solo se puede cargar una vez por generationId .
Parámetros
El ID único devuelto por GenerateMeshAsync() . Identifica la malla para cargar.
Devuelve
La malla generada, devuelta como una MeshPart que contiene un EditableMesh .
Muestras de código
Example showing how to load a generated mesh using LoadGeneratedMeshAsync().
-- Take your generation ID generated on the server and load your generation
local mesh = GenerationService:LoadGeneratedMeshAsync(generationId)
mesh.Parent = workspace