Génération de modèles

Grâce aux invites textuelles et aux schémas prédéfinis, vous (et les joueurs en jeu) pouvez générer à la fois des actifs 3D statiques et des modèles entièrement fonctionnels tels que des véhicules qui roulent, des avions qui volent et des armes qui tirent. Ce guide démontre comment utiliser GenerateModelAsync() dans le cadre d'une expérience créative dynamique et axée sur les joueurs.

Aperçu

GenerateModelAsync() permet la génération de géométries multi-maillages avec les avantages suivants :

• Le schéma fourni définit comment la géométrie générée sera découpée en parties.
• Tout objet généré en jeu sera répliqué et visible par tous les joueurs, leur permettant de construire ensemble en temps réel.
• Les maillages générés sont d'une fidélité supérieure avec de meilleures formes globales, silhouettes, plus de détails et moins d'artefacts. Les textures générées sont plus cohérentes et détaillées, avec moins de granulosité et un éclairage incorporé moins prononcé.
• Les temps de génération ont une latence inférieure, permettant une création plus rapide et plus réactive dans les jeux.
• Vous et même les joueurs pendant le temps de jeu pouvez spécifier des boîtes englobantes pour suggérer la taille et les proportions du modèle généré.
• Un nombre maximum de triangles optionnel garde les objets générés performants pour votre jeu.

Génération basée sur des schémas

Pour créer des objets articulés et fonctionnels, la géométrie générée doit être séparée en plusieurs MeshParts. Par exemple, pour créer une voiture roulante avec des roues qui tournent et qui dirigent, au moins cinq MeshParts sont nécessaires : un pour le corps de la voiture et quatre pour chacune des roues de la voiture. GenerateModelAsync() réalise cela à travers un schéma qui répertorie les pièces à générer, comme le montre l'extrait de code suivant :

Script dans ServerScriptService
local GenerationService = game:GetService("GenerationService")
local Workspace = game:GetService("Workspace")

-- Configurer les entrées pour la géométrie générée
local inputs = {
	TextPrompt = "voiture de dragon verte avec 4 roues"
}
-- Définir le schéma au châssis de voiture prédéfini de cinq modèles
local schema = {
	PredefinedSchema = "Car5"
}

-- Appeler pour générer le modèle
local success, result, metadata = pcall(function()
	return GenerationService:GenerateModelAsync(inputs, schema)
end)
if success then
	-- Échelle du modèle à la taille cible et position proche du centre du monde
	local targetSize = 16
	local modelSize = result:GetExtentsSize()
	local scaleFactor = targetSize / math.max(modelSize.X, modelSize.Y, modelSize.Z)
	result:ScaleTo(scaleFactor)
	result:PivotTo(CFrame.new(0, result:GetExtentsSize().Y / 2, -40))

	-- Ancrer toutes les pièces afin que les maillages ne s'effondrent pas
	for _, descendant in result:GetDescendants() do
		if descendant:IsA("BasePart") then
			descendant.Anchored = true
		end
	end

	-- Nommer le modèle et le parenté au workspace
	result.Name = "GénérationDeVoitureDragonBasique"
	result.Parent = Workspace
else
	warn(result)
end

L'image suivante montre la sortie attendue et sa construction telle qu'elle apparaît dans la hiérarchie de l'Explorateur :

Scripts reconfigurables

Dans Roblox, comportements englobe généralement les scripts, attachements, contraintes et autres types d'instance attachés à des géométries texturées statiques pour les rendre fonctionnelles. Étant donné que GenerateModelAsync() génère une large gamme de géométries à la volée, des scripts reconfigurables doivent être attachés pour adapter automatiquement les comportements à la fonctionnalité attendue.

Par exemple, considérons un jeu où les joueurs peuvent créer leurs propres voitures roulantes. GenerateModelAsync() prend l'invite du joueur et génère cinq maillages distincts (corps et quatre roues) via le schéma Car5 schéma. Ensuite, un script reconfigurable prédéfini adapte son comportement de conduite à la taille et à la forme du modèle pour s'assurer que la voiture soit roulante et que ses roues tournent de manière réaliste.

Pour tester des scripts reconfigurables :

1. Téléchargez le Behaviors.rbxm fichier.

2. Dans la hiérarchie de l'Explorateur de Studio, faites un clic droit sur ReplicatedStorage, sélectionnez Insérer ⟩ Importer Modèle Roblox, et choisissez le fichier téléchargé. Le modèle se décompresse en plusieurs dossiers.

   

3. Copiez et collez l'un des extraits de code suivants dans un Script serveur dans ServerScriptService, en fonction du type d'objet que vous souhaitez générer.

   VoitureAvion

   Cet exemple génère une voiture fonctionnelle avec un frein, un boost nitro, des effets audio et visuels, et un compteur de vitesse à l'écran.

   Script dans ServerScriptService
   local GenerationService = game:GetService("GenerationService")
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local Workspace = game:GetService("Workspace")
   
   -- Configurer les entrées pour la géométrie générée
   local inputs = {
   	TextPrompt = "voiture de dragon verte avec 4 roues"
   }
   -- Définir le schéma au châssis de voiture prédéfini de cinq modèles
   local schema = {
   	PredefinedSchema = "Car5"
   }
   
   -- Appeler pour générer le modèle
   local success, result, metadata = pcall(function()
   	return GenerationService:GenerateModelAsync(inputs, schema)
   end)
   if success then
   	-- Échelle du modèle à la taille cible
   	local targetSize = 16
   	local modelSize = result:GetExtentsSize()
   	local scaleFactor = targetSize / math.max(modelSize.X, modelSize.Y, modelSize.Z)
   	result:ScaleTo(scaleFactor)
   
   	-- Charger le module "makeFunctional" pour "CarBehavior"
   	local makeFunctional = require(ReplicatedStorage.Behaviors.CarBehavior.makeFunctional)
   
   	-- Référencer les pièces de la voiture par noms garantis par le schéma "Car5"
   	local body = result:FindFirstChild("corps")
   	local frontLeftWheel = result:FindFirstChild("roue avant gauche")
   	local frontRightWheel = result:FindFirstChild("roue avant droite")
   	local rearLeftWheel = result:FindFirstChild("roue arrière gauche")
   	local rearRightWheel = result:FindFirstChild("roue arrière droite")
   
   	-- Configurer les paramètres de configuration comportementale
   	local config = {
   		seatPosition = "dedans",
   		invisibleWhenSeated = false
   	}
   
   	-- Attacher le comportement via le script "makeFunctional"
   	local functionalModel = makeFunctional(result, frontLeftWheel, frontRightWheel, rearLeftWheel, rearRightWheel, body, config)
   
   	-- Positionner le modèle près du centre du monde
   	functionalModel:PivotTo(CFrame.new(0, functionalModel:GetExtentsSize().Y / 2, -40))
   	functionalModel.Name = "GénérationDeVoitureDragonBasique"
   	functionalModel.Parent = Workspace
   else
   	warn(result)
   end

   Pour tester d'autres modèles générés avec des scripts reconfigurables dans le schéma Car5, changez la valeur de chaîne TextPrompt à la ligne 7 et testez à nouveau. Les idées incluent :

   • "voiture de sport jaune avec un aileron"
   • "voiture de chauve-souris violette avec 4 roues"
   • "monstre truck géant avec un toit épineux"