GenerationService

Veraltete anzeigen

*Dieser Inhalt wurde mit KI (Beta) übersetzt und kann Fehler enthalten. Um diese Seite auf Englisch zu sehen, klicke hier.

Nicht erstellbar
Dienst

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:

  1. 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.
  2. 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:

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.

Server-side mesh generation

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.

Client-side mesh generation

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

Eigenschaften

Methoden

GenerateMeshAsync

Angehalten

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

inputs: Dictionary

Ein Wörterbuch mit den Mesh-Generierungsaufforderungen.Derzeit ist der einzige unterstützte Schlüssel der Prompt (String), die die zu generierende Mesh beschreibt.

Standardwert: ""
player: Player

Die Player Anfrage, die Generierung anzufordern.

Standardwert: ""
options: Dictionary

Zusätzliche Generationsoptionen. Derzeit werden keine Optionen unterstützt.

Standardwert: ""
intermediateResultCallback: function

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).

Standardwert: ""

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.

Basic usage

local generationId, contextId = GenerationService:GenerateMeshAsync({["Prompt"] = "toaster"}, player, {})

Example showing how to use GenerateMeshAsync() with a callback for intermediate results.

Intermediate results callback

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().

Server-side generation with error handling

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

Angehalten

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

generationId: string

Die eindeutige ID, die von GenerateMeshAsync() zurückgegeben wird. Identifiziert das Netz, das geladen werden soll.

Standardwert: ""

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().

LoadGeneratedMeshAsync - Load generated mesh

-- Take your generation ID generated on the server and load your generation
local mesh = GenerationService:LoadGeneratedMeshAsync(generationId)
mesh.Parent = workspace

Ereignisse