GenerationService

Pokaż przestarzałe

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

Brak możliwości tworzenia
Usługa

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:

  1. 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.
  2. LoadGeneratedMeshAsync() ładowuje generowaną siatkę do doświadczenia. Siatka jest zwracana jako MeshPart zawierająca EditableMesh.

Obecnie GenerationService wspiera tylko następujące użycie:

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.

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

Podsumowanie

Metody

Właściwości

Metody

GenerateMeshAsync

Wynik

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

inputs: Dictionary

Słownik zawierający komunikaty o generowaniu siatki.Obecnie jedynym wspieranym kluczem jest Prompt (ciąg) opisujący sieć do generowania.

Wartość domyślna: ""
player: Player

Żądanie Player wymagające generacji.

Wartość domyślna: ""
options: Dictionary

Opcje dodatkowego generowania. Obecnie nie są wspierane żadne opcje.

Wartość domyślna: ""
intermediateResultCallback: function

Funkcja powrotna uruchomiona z wynikami generacji pośredniej. Przydatna do odzyskiwania wczesnych wersji siatki (np. przed zastosowaniem tekstur).

Wartość domyślna: ""

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.

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

Wynik

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

generationId: string

Unikalny identyfikator zwrotony przez GenerateMeshAsync() . Identyfikuje siatkę do wczytywać.

Wartość domyślna: ""

Zwroty

Generowana siatka, zwrócona jako MeshPart zawierająca EditableMesh .

Przykłady kodu

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

Zdarzenia