GenerationService
*Dieser Inhalt wurde mit KI (Beta) übersetzt und kann Fehler enthalten. Um diese Seite auf Englisch zu sehen, klicke hier.
GenerationService ist ein Service, der es Entwicklern ermöglicht, 3D-Objekte aus Textaufforderungen zu generieren, die die 3D-Foundationmodell von Roblox verwenden Cube 3D.
Mesh-Generierung ist ein zweistufiger Prozess:
- GenerateMeshAsync() startet den Meshing-Generierungsprozess mit einem Textprompt und anderen erforderlichen Parametern.Es gibt eine eindeutige Kennung (Generations-ID) zurück, die zum Abrufen der zukünftigen Ergebnisse verwendet werden kann.
- LoadGeneratedMeshAsync() lädt das generierte Netz in das Erlebnis ein. Das Netz wird als MeshPart zurückgegeben, das einen EditableMesh enthält.
Derzeit unterstützt GenerationService nur die folgende Nutzung:
- GenerateMeshAsync() muss von server-skripten aufgerufen werden.
- LoadGeneratedMeshAsync() muss von client-skripten aufgerufen werden.
Als Ergebnis muss ein Client, von dem eine Mesh-Generierungsanfrage ausgeht, ein Signal an den Server senden, um die Generierung zu initiieren.Sobald der Server feststellt, dass die Generation abgeschlossen ist, sollte er den entsprechenden Client benachrichtigen, LoadGeneratedMeshAsync() anzurufen und das Netz abzurufen.Beachten Sie, dass das generierte Netz mit EditableMesh Inhalten geladen wird und nur auf dem Client und nicht auf anderen Clients repliziert wird.
Der folgende Code illustriert dieses Designmuster.Siehe diese Demo-Erfahrung für ein detaillierteres Beispiel.Klicken Sie auf die Schaltfläche ⋯ und Im Studio bearbeiten .
Code-Beispiele
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")
Zusammenfassung
Methoden
- GenerateMeshAsync(inputs : Dictionary,player : Player,options : Dictionary,intermediateResultCallback : function?):Tuple
Startet die Erzeugung eines neuen 3D-Gitternetzes aus einem Textprompt und gibt einzigartige IDs zurück, die zum Verfolgen und Abrufen des Ergebnisses verwendet werden.Nachdem die Generation abgeschlossen ist, verwende LoadGeneratedMeshAsync(), um das Meshzu laden und anzuzeigen.
Ruft und lädt ein Netzwerk ab, das von GenerationService:GenerateMeshAsync() mit dem bereitgestellten generationId erzeugt wurde. Das Netzwerk wird als MeshPart mit EditableMesh Inhalt zurückgegeben.
Eigenschaften
Methoden
GenerateMeshAsync
Startet die Erzeugung eines neuen 3D-Gitternetzes aus einem Textprompt und gibt einzigartige IDs zurück, die zum Verfolgen und Abrufen des Ergebnisses verwendet werden.Du kannst optional mittlere Ergebnisse wie das unstrukturierte Mesherhalten, indem du eine intermediateResultCallback-Funktion bereitstellst.Nachdem die Generation abgeschlossen ist, verwende LoadGeneratedMeshAsync(), um das Meshzu laden und anzuzeigen.
Begrenzungen der Rate Es gibt ein Tempolimit von 5 Generationen pro Minute pro Erlebnis.Wenn du dieses Limit überschreitest, werden weitere Generierungsanfragen bis zur nächsten Minute blockiert.
Fehlercodes | Fehler | Beschreibung | Empfohlene Entwickleraktion | | ------------------------ | ------------------------------------------------------------------------------------ | | Rate limit exceeded | Die maximale Anzahl von Mesh-Generationen wurde für die Minute überschritten.| Warten Sie, bis das Ratelimit zurückgesetzt wird. | | Moderationsfehler | Die Netzgeneration wurde für die Moderation markiert.| Überprüfen und modifizieren Sie die Eingabe, um sicherzustellen, dass sie den Moderationsrichtlinien von Roblox entspricht.| | Interner Serverfehler | Es ist ein unerwartetes Problem auf dem Server aufgetreten.| Versuchen Sie die Anfrage später erneut oder überprüfen Sie den Serverstatus auf Probleme.| | Zeichenlimit überschritten | Die Eingabefrist für diese Generationsanforderung hat das Limit überschritten.| Reduziere die Anzahl der Zeichen in der Prompt Zeichenkette des input Wörterbuchs. |
Parameter
Ein Wörterbuch mit den Mesh-Generierungsaufforderungen.Derzeit ist der einzige unterstützte Schlüssel der Prompt (String), die die zu generierende Mesh beschreibt.
Zusätzliche Generationsoptionen. Derzeit werden keine Optionen unterstützt.
Eine Rückruffunktion, die mit vorläufigen Generationsergebnissen ausgelöst wird. Nützlich für das Abrufen früher Netzversionen (z. B. bevor Texturen angewendet werden).
Rückgaben
Eine Tuplizität von Generations-ID und Kontext-ID.
- Generations-ID: Eine eindeutige ID wird für jede Anrufung von GenerateMeshAsync() zurückgegeben.
- Kontext-ID: Derzeit nicht verwendet.
Code-Beispiele
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)
end
LoadGeneratedMeshAsync
Ruft und lädt ein Netz ab, das von GenerationService:GenerateMeshAsync() mit der angegebenen GenerationId erzeugt wurde.Das Netz wird als MeshPart mit EditableMesh Inhalt zurückgegeben.Da bearbeitbare Meshes nicht repliziert werden, wird das geladene Netz nicht auf andere Clients repliziert und kann nur einmal pro generationId geladen werden.
Parameter
Die eindeutige ID, die von GenerateMeshAsync() zurückgegeben wird. Identifiziert das Netz, das geladen werden soll.
Rückgaben
Das Mesh, das als MeshPart zurückgegeben wird, das ein EditableMesh enthält.
Code-Beispiele
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