Erstellung von Makeup im Erlebnis

Sie können ein Erlebnis veröffentlichen, das es Spielern ermöglicht, Makeup-Assets in Echtzeit zu erstellen, anzupassen und zu kaufen, zusätzlich zur Erstellung von Avatar-Körpern im Erlebnis. Beim Kauf werden Makeup-Assets direkt im Roblox-Inventar des Spielers gespeichert.

Erlebnisbesitzer, die die Erstellung von Makeup im Erlebnis implementieren, profitieren von Marktplatzprovisionen als Verleger des Makeup-Assets, während der Spieler, der es erstellt, der Ersteller des Assets ist.

So implementieren Sie die Erstellung von Makeup im Erlebnis

Verwenden Sie die folgenden Anweisungen und Code-Referenzen, um Spieler dazu aufzufordern, Makeup-Assets auf dem Kopf ihres Avatars zu malen, zusammenzustellen und zu kaufen.

Bevor Sie beginnen, machen Sie sich mit Folgendem vertraut:

• Avatar-Erstellungstoken — Erlebnisse, die die Erstellung von Makeup unterstützen, benötigen mindestens ein Erstellungstoken, dessen Erstellungstyp mit dem Typ des Makeup-Assets übereinstimmt, das Sie erstellen möchten.
• API-Klassen

  • AvatarCreationService — Verwaltet die Aufforderung zur Erstellung von Avatar-Assets und deren Validierung.
  • EditableImage — Verwaltet die Erstellung und Manipulation von Texturen zur Laufzeit.
  • EditableMesh — Verwaltet die Manipulation der Mesh-Geometrie zur Laufzeit.
  • WrapDeformer — Verwaltet die Manipulation der unsichtbaren äußeren Käfiggeometrie zur Laufzeit, die es Avatar-Charakteren ermöglicht, 3D-Kleidung und -Zubehör anzulegen, einschließlich geschichteter Augenbrauen- und Wimpern-Meshes.
  • WrapTarget — Stellt die Bindung zwischen einem Käfig-Mesh und einem Ziel-Mesh dar und ermöglicht die Umwandlung des Texturraums zwischen beiden.
  • WrapTextureTransfer — Erleichtert das Wickeln eines Decals, einschließlich eines Makeup-Decals, um ein übergeordnetes Mesh basierend auf seinem WrapTarget.

Wählen Sie einen Einzel-Asset- oder Multi-Asset-Flow

Die Erstellung von Makeup unterstützt zwei Aufforderungen, abhängig davon, ob Sie ein Makeup-Asset erstellen oder mehrere Schichten zu einem Outfit zusammenstellen:

• AvatarCreationService:PromptCreateAvatarAssetAsync() — Erstellt ein einzelnes, individuell erstelltes Makeup-Asset. Übergeben Sie einen der fünf unterstützten Enum.AvatarAssetType-Werte: FaceMakeup, LipMakeup oder EyeMakeup für eine bemalte Textur, oder EyebrowAccessory oder EyelashAccessory für ein geschichtetes Mesh-Zubehör. Der Erstellungstyp des Tokens muss mit dem assetType übereinstimmen, den Sie übergeben.
• AvatarCreationService:PromptCreateMakeupAsync() — Komponiert zwei oder mehr Makeup-Schichten zu einem einzigen käuflichen Outfit. Jede Schicht liefert ihr eigenes Erstellungstoken und Enum.AvatarAssetType, plus eine Sortierreihenfolge für die Komposition, und das gesamte Outfit teilt sich eine Kopf-Farbe. Wenn Sie nur ein Makeup-Asset erstellen müssen, verwenden Sie stattdessen PromptCreateAvatarAssetAsync() — PromptCreateMakeupAsync() erfordert mindestens zwei Einträge.

PromptCreateMakeupAsync() nimmt eine Liste von Makeup-Asset-Einträgen, wobei jeder Eintrag Folgendes umfasst:

• Eine Erstellungstoken-ID für diese Schicht.
• Die Instanz, aus der das Asset erstellt werden soll.
• Den AvatarAssetType der Schicht als Enum.AvatarAssetType.
• Eine Sortierreihenfolge, die die Komposition steuert, wenn mehrere Schichten überlappen.

Es gibt ein Enum.PromptCreateMakeupResult für das Outfit als Ganzes (Success, PartialSuccess, CreationFailure, PermissionDenied, Timeout, NoUserInput oder UnknownFailure), plus ein Ergebnis pro Asset, damit Sie erkennen können, welche einzelnen Schichten erfolgreich waren, wenn das Gesamtergebnis PartialSuccess ist.

Generieren Sie ein Avatar-Erstellungstoken

Jeder Makeup-Asset-Typ benötigt sein eigenes Avatar-Erstellungstoken, dessen Erstellungstyp mit dem Enum.AvatarAssetType übereinstimmt, den Sie an PromptCreateAvatarAssetAsync() übergeben, oder mit dem Asset-Typ jeder Schicht übereinstimmt, wenn Sie PromptCreateMakeupAsync() verwenden. Generieren Sie die erforderlichen Tokens, bevor Sie die Einträge für die Einreichung erstellen, und kopieren Sie dann jede Token-ID für die serverseitige Aufforderung.

Die folgenden Schritte verwenden das projizierte Malen auf dem Kopf des Spielers als Hauptweg. Wenn Sie stattdessen einen Autorenkopf oder ein anderes, im Besitz des Erlebnisses befindliches Mesh in seinem nativen UV-Raum malen, folgen Sie Bewege eine Textur zwischen Käfigraum und Zielraum, und schließen Sie sich dann dem Hauptweg bei Erstellen Sie das Decal und reichen Sie es zur Erstellung ein an.

Malen Sie eine Makeup-Textur auf den Kopf des Spielers

Im Gegensatz zum Malen auf einem völlig neuen Asset können Sie in der Regel kein EditableMesh direkt vom Kopf des lokalen Spielers ablesen, um darauf zu malen — das Kopf-Mesh unterliegt dem gleichen Berechtigungsmodell wie andere vom Spieler besessene Instanzen. Die Ausnahme ist, wenn das Erlebnis das Kopf-Mesh besitzt (zum Beispiel ein im Besitz des Erlebnisses befindlicher NPC oder ein Körper, den das Erlebnis selbst erstellt hat); in diesem Fall können Sie EditableMesh direkt verwenden, genau wie Sie es für die Erstellung von Avatar-Körpern tun würden. Andernfalls bereiten Sie ein WrapTextureTransfer vor und verwenden Sie es als Projektionsziel beim Zeichnen:

1. Rufen Sie WrapTextureTransfer:PrepareProjectionMeshDataAsync() auf, um die Projektions-Mesh-Daten für den Kopf des Spielers vorzubereiten und zwischenzuspeichern. Dies muss abgeschlossen sein, bevor Sie irgendwelche projizierten Zeichnungs- oder Abtastaufrufe gegen diesen Transfer machen. Wenn sich das zugrunde liegende Kopf-Mesh ändert, bereiten Sie das WrapTextureTransfer erneut vor, bevor Sie mit dem Malen fortfahren.
2. Übergeben Sie das vorbereitete WrapTextureTransfer als Projektionsquelle an DrawImageProjected() oder SampleImageProjected(). Diese Methoden akzeptieren ein WrapTextureTransfer als Alternative zu einem EditableMesh, sodass Sie direkt gegen die tatsächliche Kopfform des Spielers malen können, anstatt gegen ein generisches Mesh.

local AssetService = game:GetService("AssetService")

-- Übergeben Sie ein WrapTextureTransfer, das Sie bereits für den Kopf des Spielers erstellt haben.
local function paintMakeupLayer(textureTransfer: WrapTextureTransfer, brushConfig, projectionParams)
	local success, err = pcall(function()
		textureTransfer:PrepareProjectionMeshDataAsync()
	end)
	if not success then
		warn("Fehler beim Vorbereiten der Projektions-Mesh-Daten:", err)
		return
	end

	local makeupTexture = AssetService:CreateEditableImage()
	if not makeupTexture then
		warn("Nicht genügend bearbeitbarer Speicher, um eine Makeup-Textur zu erstellen")
		return
	end

	makeupTexture:DrawImageProjected(textureTransfer, projectionParams, brushConfig)
	return makeupTexture
end

Bewege eine Textur zwischen Käfigraum und Zielraum

Das Malen direkt auf einem vom Spieler besessenen Kopf durch ein vorbereitetes WrapTextureTransfer, wie in Malen Sie eine Makeup-Textur auf den Kopf des Spielers beschrieben, beginnt nicht im Ziel-UV-Raum des Kopf-Meshs — der Projektionspfad funktioniert die ganze Zeit im gemeinsamen Käfig-UV-Layout, sodass das Ergebnis bereits eine Käfigraum-Textur ist, die bereit zur Einreichung ist.

Die Umwandlung zwischen Käfig und Ziel ist stattdessen wichtig, wenn Sie mit einem Autorenkopf oder einem im Besitz des Erlebnisses befindlichen Mesh arbeiten, das Sie direkt in seinem eigenen nativen Ziel-UV-Raum malen können:

• WrapTarget:CreateTextureInTargetSpaceAsync() — Ordnet eine wiederverwendbare Käfigraum-Textur dem Ziel-UV-Layout dieses Meshs als EditableImage zu, die Sie bearbeiten können.
• WrapTarget:CreateTextureInCageSpaceAsync() — Ordnet die bearbeitete Zielraum-Textur zurück auf den Käfig-UV-Raum als EditableImage, die Sie hochladen können.

Verwenden Sie CreateTextureInTargetSpaceAsync(), um eine wiederverwendbare Käfigraum-Makeup-Textur in den Zielraum dieses Meshs zum Bearbeiten zu bringen, und verwenden Sie dann CreateTextureInCageSpaceAsync(), um das bearbeitete Ergebnis zurück in den Käfigraum zu konvertieren, bevor Sie es als Makeup-Asset einreichen.

Für Makeup sollten Sie die Umwandlung im Käfigraum auf den Makeup-Bereich beschränken, anstatt auf den gesamten Käfig. Rufen Sie AvatarCreationService:GetValidationRules() auf und lesen Sie MakeupRules.WrapTextureTransferUVBounds, das MinBound und MaxBound als Vector2-Werte bereitstellt. Übergeben Sie diese an CreateTextureInCageSpaceAsync() als MinUVBounds und MaxUVBounds. Ohne diese Optionen leitet die Methode die Grenzen vom gesamten Käfig ab, anstatt den Makeup-Bereich zu verwenden. Jede Grenze muss endlich sein, und das Maximum muss auf beiden Achsen größer als das Minimum sein.

local AvatarCreationService = game:GetService("AvatarCreationService")

local validationRules = AvatarCreationService:GetValidationRules()
local makeupBounds = validationRules.MakeupRules.WrapTextureTransferUVBounds

local cageSpaceTexture = wrapTarget:CreateTextureInCageSpaceAsync(targetSpaceTexture, {
	MinUVBounds = makeupBounds.MinBound,
	MaxUVBounds = makeupBounds.MaxBound,
})

Erstellen Sie das Decal und reichen Sie es zur Erstellung ein

Gesicht-, Lippen- und Augen-Makeup sind bemalte Texturen, während Augenbrauen und Wimpern individuell erstellte geschichtete Mesh-Zubehörteile sind, genau wie andere 3D-Kleidung und -Zubehör. Erstellen Sie die Einträge für die Einreichung jeder Schicht entsprechend:

• Für eine fertige Käfigraum-Makeup-Textur als EditableImage wickeln Sie sie in ein Decal mit AssetService:CreateDecalAsync(), und parenten Sie das WrapTextureTransfer, das Sie zum Malen verwendet haben, zu diesem Decal.
• Für eine Augenbrauen- oder Wimpernschicht verwenden Sie die direkt erstellte Accessory-Instanz.

Kombinieren Sie die resultierende Instanz mit der passenden Token-ID aus Generieren Sie ein Avatar-Erstellungstoken, ihrem Asset-Typ und ihrer Schichtreihenfolge. Das folgende Beispiel nimmt diese Einträge, egal welcher Art, und wählt automatisch die richtige API: AvatarCreationService:PromptCreateAvatarAssetAsync() für einen einzelnen Eintrag oder AvatarCreationService:PromptCreateMakeupAsync() beim Komponieren von zwei oder mehr Schichten zu einem Outfit.

Beide Aufforderungen zeigen dem Spieler einen letzten Bestätigungsbildschirm, bevor das Asset zur Erstellung und Moderation eingereicht wird.

local AssetService = game:GetService("AssetService")
local AvatarCreationService = game:GetService("AvatarCreationService")

type MakeupEntry = {
	tokenId: string,
	instance: Instance,
	assetType: Enum.AvatarAssetType,
	sortOrder: number,
}

-- Gesicht-, Lippen- und Augen-Makeup: wickeln Sie die fertige Textur in ein Decal und parenten Sie das
-- WrapTextureTransfer, das zum Malen verwendet wurde, als einziges Kind des Decals.
local function createMakeupTextureEntry(
	tokenId: string,
	texture: EditableImage,
	textureTransfer: WrapTextureTransfer,
	assetType: Enum.AvatarAssetType,
	sortOrder: number
): MakeupEntry
	local decal = AssetService:CreateDecalAsync({
		TextureContent = Content.fromObject(texture),
	})
	decal.Face = Enum.NormalId.Front
	textureTransfer.Parent = decal

	return {
		tokenId = tokenId,
		instance = decal,
		assetType = assetType,
		sortOrder = sortOrder,
	}
end

-- Augenbrauen und Wimpern: übergeben Sie das direkt erstellte geschichtete Mesh-Zubehör.
local function createMakeupAccessoryEntry(
	tokenId: string,
	accessory: Accessory,
	assetType: Enum.AvatarAssetType,
	sortOrder: number
): MakeupEntry
	return {
		tokenId = tokenId,
		instance = accessory,
		assetType = assetType,
		sortOrder = sortOrder,
	}
end

local function submitMakeupEntries(entries: {MakeupEntry}, player: Player, headColor: Color3?)
	local assetEntries = {}
	for _, entry in entries do
		table.insert(assetEntries, {
			TokenId = entry.tokenId,
			Instance = entry.instance,
			AvatarAssetType = entry.assetType,
			SortOrder = entry.sortOrder,
		})
	end

	if #assetEntries == 1 then
		local entry = assetEntries[1]
		local success, result, assetIdOrErrorMessage = pcall(function()
			return AvatarCreationService:PromptCreateAvatarAssetAsync(
				entry.TokenId,
				player,
				entry.Instance,
				entry.AvatarAssetType
			)
		end)

		if success and result == Enum.PromptCreateAssetResult.Success then
			print("Erfolgreich hochgeladen mit AssetId:", assetIdOrErrorMessage)
		else
			print("Erstellung des Makeup-Assets war nicht erfolgreich:", assetIdOrErrorMessage)
		end
	else
		local success, result, perAssetResults = pcall(function()
			return AvatarCreationService:PromptCreateMakeupAsync(player, assetEntries, headColor)
		end)

		if success and result == Enum.PromptCreateMakeupResult.Success then
			print("Makeup-Outfit erfolgreich erstellt")
		else
			print("Ergebnis der Erstellung des Makeup-Outfits:", result, perAssetResults)
		end
	end
end

Moderation behandeln

Nachdem ein Makeup-Asset erstellt wurde, durchläuft es eine Moderation, bevor es sicher im Erlebnis verwendet werden kann.

• Hören Sie auf AvatarAssetModerationCompleted, um zu erfahren, wann ein einzelnes Makeup-Asset, das mit PromptCreateAvatarAssetAsync() erstellt wurde, die Moderation abgeschlossen hat.
• Für ein mehrschichtiges Outfit, das mit PromptCreateMakeupAsync() erstellt wurde, wird AvatarAssetModerationCompleted weiterhin einmal für jedes einzelne Makeup-Asset im Outfit ausgelöst, und AvatarOutfitModerationCompleted wird zusätzlich einmal für das gesamte Outfit ausgelöst. Hören Sie auf beide: Verwenden Sie das Ereignis pro Asset, wenn Sie das Moderationsergebnis einer bestimmten Schicht wissen müssen, und das Outfit-Ereignis, um zu erfahren, wann der gesamte Look sicher im Erlebnis verwendet werden kann.