GenerationService
*Ta zawartość została przetłumaczona przy użyciu narzędzi AI (w wersji beta) i może zawierać błędy. Aby wyświetlić tę stronę w języku angielskim, kliknij tutaj.
GenerationService jest usługą, która pozwala programistom generować obiekty 3D z poleceń tekstowych za pomocą modelu podstawy Cube 3D Roblox.
Generacja siatki jest procesem dwuetapowym:
- GenerateMeshAsync() rozpoczyna proces generowania siatki za pomocą polecenia tekstowego i innych wymaganych parametrów.Zwraca unikalny identyfikator (ID generacji), który można użyć do odzyskania przyszłego wyniku.
- LoadGeneratedMeshAsync() ładowuje generowaną siatkę do doświadczenia. Siatka jest zwracana jako MeshPart zawierająca EditableMesh.
Obecnie GenerationService wspiera tylko następujące użycie:
- GenerateMeshAsync() musi być wywołane z krypty na serwerze.
- LoadGeneratedMeshAsync() musi być wywołane z kodów klienta.
W wynik, gdy wniosek o generację siatki pochodzi od klienta, klient musi wysłać sygnał na serwer, aby zainicjować generację.Gdy serwer stwierdzi, że generacja jest zakończona, powinien powiadomić odpowiedniego klienta o wezwaniu LoadGeneratedMeshAsync() i odzyskaniu siatki.Zauważ, że ponieważ generowana siatka jest wczytywana z zawartością EditableMesh i tylko na klientzie, nie jest replikowana do innych klientów.
Poniższy kod ilustruje ten wzór projektowy.Zobacz to demo doświadczenia dla bardziej szczegółowego przykładu.Kliknij przycisk ⋯ i Edytuj w Studio .
Przykłady kodu
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")
Podsumowanie
Metody
- GenerateMeshAsync(inputs : Dictionary,player : Player,options : Dictionary,intermediateResultCallback : function?):Tuple
Rozpoczyna generację nowej sieci 3D z polecenia tekstowego i zwraca unikalne identyfikatory używane do śledzenia i odzyskiwania wyniku.Po zakończeniu generacji użyj LoadGeneratedMeshAsync(), aby załadować i wyświetlić wygenerowaną siatkę.
Odzyskuje i ładowuje siatkę wygenerowaną przez GenerationService:GenerateMeshAsync() za pomocą dostarczonego generationId . Siatka jest zwracana jako MeshPart z zawartością EditableMesh.
Właściwości
Metody
GenerateMeshAsync
Rozpoczyna generację nowej sieci 3D z polecenia tekstowego i zwraca unikalne identyfikatory używane do śledzenia i odzyskiwania wyniku.Możesz opcjonalnie otrzymywać wyniki pośrednie, takie jak nierozbudowana siatka, poprzez dostarczenie funkcji intermediateResultCallback.Po zakończeniu generacji użyj LoadGeneratedMeshAsync(), aby załadować i wyświetlić wygenerowaną siatkę.
Ograniczenia stawki Istnieje ograniczenie prędkości 5 generacji na minutę na doświadczenie.Jeśli przekroczysz ten limit, kolejne prośby o generację są blokowane do następnej minuty.
Kody błędów | Błąd | Opis | Zalecane działanie programisty | | ------------------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | | Przekroczono limit stawki | Maksymalna liczba generacji siatki została przekroczona za minutę.| Poczekaj, aż limit stawki zostanie zresetowany. | | Porażka moderacji | Generacja siatki została oznaczona do moderacji.| Przeglądaj i modyfikuj monit o upewnienie się, że przestrzega wytycznych moderacyjnych Roblox.| | Błąd wewnętrzny serwera | Wystąpił nieoczekiwany problem na serwerze.| Spróbuj ponownie złożyć żądanie później lub sprawdź stan serwera pod kątem problemów.| | Ograniczono limit znaków | Długość polecenia wejściowego dla tej generacji żądania przekroczyła limit.| Zmniejsz liczbę znaków w Prompt ciągu znaków z input słownika. |
Parametry
Słownik zawierający komunikaty o generowaniu siatki.Obecnie jedynym wspieranym kluczem jest Prompt (ciąg) opisujący sieć do generowania.
Opcje dodatkowego generowania. Obecnie nie są wspierane żadne opcje.
Funkcja powrotna uruchomiona z wynikami generacji pośredniej. Przydatna do odzyskiwania wczesnych wersji siatki (np. przed zastosowaniem tekstur).
Zwroty
Tupla identyfikatora generacji i identyfikatora kontekstu.
- ID generacji: unikalny identyfikator zwracany za każde wezwanie GenerateMeshAsync() .
- ID kontekstu: Obecnie nie używane.
Przykłady kodu
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
Przeszukuje i ładowuje siatkę wygenerowaną przez GenerationService:GenerateMeshAsync() za pomocą podanego ID generacji.Mesza zostaje zwrócona jako MeshPart z zawartością EditableMesh.Ponieważ edytowane siatki nie są replikowane, wczytana siatka nie jest replikowana do żadnych innych klientów i może być wczytywana tylko raz na generationId .
Parametry
Unikalny identyfikator zwrotony przez GenerateMeshAsync() . Identyfikuje siatkę do wczytywać.
Zwroty
Generowana siatka, zwrócona jako MeshPart zawierająca EditableMesh .
Przykłady kodu
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