GeometryService

Renvoie une table de Constraints et Attachments que vous pouvez choisir de conserver, ainsi que leurs parents respectifs. L'itération sur cette table vous permet de décider si vous souhaitez repartir les contraintes et les accessoires recommandés de leurs parents respectifs.

Remarquez que la table options peut contenir une valeur tolerance (number) et/ou une valeur WeldConstraintPreserve ( 2> Enumerate.WeldConstraintPreserve2> ).

• tolerance – La tolérance de distance, en matière de Attachment préservation, entre la pièce et le point de contact le plus proche sur la surface de la pièce d'origine, vers le point de contact le plus proche sur la surface de la pièce de destination. Si la distance de résultat suivant l'opération de modélisation solide est supérieure à cette vale
• weldConstraintPreserve – Un ensemble de valeurs Enum.WeldConstraintPreserve décrivant comment WeldConstraints sont préservés dans la table de recommandation résultante.

Paramètres

Retours

<tbody>
  <tr>
    <td>Accessoire</td>
    <td><code>Class.Rotation</code></td>
  </tr>

  <tr>
    <td>Contrôle</td>
    <td><code>Class.Constraint</code></td>
  </tr>

  <tr>
    <td>Parent d'accessoire</td>
    <td><code>Class.BasePart</code> ou <code>zéro</code></td>
  </tr>

  <tr>
    <td>Parent de contrôle</td>
    <td><code>Class.BasePart</code> ou <code>zéro</code></td>
  </tr>
</tbody>

<tbody>
  <tr>
    <td>Contrôle de soudures</td>
    <td><code>Class.WeldConstraints</code></td>
  </tr>

  <tr>
    <td>Parent de contrôle de soudures</td>
    <td><code>Class.BasePart</code> ou <code>zéro</code></td>
  </tr>

  <tr>
    <td>Contrôle de soudures Part0</td>
    <td><code>Class.BasePart</code></td>
  </tr>

  <tr>
    <td>Contrôle de soudures1</td>
    <td><code>Class.BasePart</code></td>
  </tr>
</tbody>

<tbody>
  <tr>
    <td>Aucune contrainte de collision</td>
    <td><code>Class.NoCollisionConstraint</code></td>
  </tr>

  <tr>
    <td>Aucun parent de collision</td>
    <td><code>Class.BasePart</code> ou <code>zéro</code></td>
  </tr>

  <tr>
    <td>Partie de contrôle de collision infinie</td>
    <td><code>Class.BasePart</code></td>
  </tr>

  <tr>
    <td>Partie de contrôle de collision 1</td>
    <td><code>Class.BasePart</code></td>
  </tr>
</tbody>

local GeometryService = game:GetService("GeometryService")

local mainPart = workspace.PurpleBlock
local otherParts = {workspace.BlueBlock}

local options = {
	CollisionFidelity = Enum.CollisionFidelity.Default,
	RenderFidelity = Enum.RenderFidelity.Automatic,
	SplitApart = true
}

local constraintOptions = {
	tolerance = 0.1,
	weldConstraintPreserve = Enum.WeldConstraintPreserve.All
}

-- Perform subtract operation in pcall() since it's asyncronous
local success, newParts = pcall(function()
	return GeometryService:SubtractAsync(mainPart, otherParts, options)
end)

if success and newParts then
	-- Loop through resulting parts to reparent/reposition
	for _, newPart in pairs(newParts) do
		newPart.Parent = mainPart.Parent
		newPart.CFrame = mainPart.CFrame
		newPart.Anchored = mainPart.Anchored
	end

	-- Calculate constraints/attachments to either preserve or drop
	local recommendedTable = GeometryService:CalculateConstraintsToPreserve(mainPart, newParts, constraintOptions)

  -- Preserve constraints/attachments based on recommended table
	for _, item in pairs(recommendedTable) do
		if item.Attachment then
			item.Constraint.Parent = item.ConstraintParent
			item.Attachment.Parent = item.AttachmentParent
		elseif item.NoCollisionConstraint then
			local newNoCollision = Instance.new("NoCollisionConstraint")
			newNoCollision.Part0 = item.NoCollisionPart0
			newNoCollision.Part1 = item.NoCollisionPart1
			newNoCollision.Parent = item.NoCollisionParent
		elseif item.WeldConstraint then
			local newWeldConstraint = Instance.new("WeldConstraint")
			newWeldConstraint.Part0 = item.WeldConstraintPart0
			newWeldConstraint.Part1 = item.WeldConstraintPart1
			newWeldConstraint.Parent = item.WeldConstraintParent
		end
	end

	-- Destroy original parts
	mainPart.Parent = nil
	mainPart:Destroy()
	for _, otherPart in pairs(otherParts) do
		otherPart.Parent = nil
		otherPart:Destroy()
	end
end

Crée un ou plusieurs PartOperations à partir de la géométrie d'intersection de la partie principale et d'autres parties dans l'matricedonné. Seuls les Parts et

Les propriétés suivantes de la partie principale ( part ) s'appliquent à la partie résultante PartOperations :

• Class.BasePart.Color|Color , Material , MaterialVariant , 0> Class.BasePart.Reflectance|Reflectance0> , Color3>
• CanCollide
• Class.BasePart.Anchored|Anchored , Density , Elasticity , 0> Class.BasePart.ElasticityWeight|Elasticity0> , 3> Class.Base

Dans le comparateur d'image suivant, IntersectAsync() est appelé à l'aide du bloc violet et d'un tableau contenant le bloc bleu. Le résultat PartOperation résoudre en une forme de géométrie interceptant les deux parties.

<figcaption>Pièces séparées</figcaption>

<figcaption>Opération de classe de résultat <code>Class.PartOperation</code></figcaption>

Notes

• Par rapport à BasePart:IntersectAsync(), cette méthode diffère comme suivant :

  • Les parties d'entrée n'ont pas besoin d'être parentées à la scène, ce qui permet d'effectuer des opérations de fond.
  • Lorsque l'option SplitApart est réglée sur true (par défaut), chaque corps distinct sera renvoyé dans son propre PartOperation.
  • Chaque l'une des parties retournées est dans l'espace de coordonnée de la partie principale. Cela signifie que le (0, 0, 0) de n'importe quelle partie retournée n'est pas nécessairement au centre de son corps.
  • Il est possible d'appeler cette méthode sur le client, mais avec certaines limites. Tout d'abord, il doit actuellement être exécuté avec des objets créés sur le client. Deuxièmement, il n'y a pas de réplication disponible du client au serveur.

• Les parties d'origine restent intactes après un succès. Dans la plupart des cas, vous devriez parent le PartOperations retourné à la même place que la partie principale, puis Destroy() toutes les parties d'origine.

• Par défaut, les couleurs du visage de la partie résultante PartOperations sont empruntées à la propriété Color des parties d'origine, bien que vous puissiez activer leur propriété UsePartColor pour les modifier en couleur spécifique.

• Si une opération d'intersection entraînerait plus de 20 000 triangles, ils seront simplifiés en 20 000. Cela entraînera une erreur avec le code -14.

• Si la partie principale se déplace pendant la calcul de l'opération, vous pouvez configurer les parties résultantes dans le CFrame de la partie principale, car les parties retournées sont dans l'espace de coordonnée de la partie principale.

• Si vous utilisez cette méthode avec un PartOperation en tant que partie principale, vous pou

Paramètres

Retours

local GeometryService = game:GetService("GeometryService")

local mainPart = workspace.PurpleBlock
local otherParts = {workspace.BlueBlock}

local options = {
	CollisionFidelity = Enum.CollisionFidelity.Default,
	RenderFidelity = Enum.RenderFidelity.Automatic,
	SplitApart = true
}

-- Perform intersect operation in pcall() since it's asyncronous
local success, newParts = pcall(function()
	return GeometryService:IntersectAsync(mainPart, otherParts, options)
end)

if success and newParts then
	-- Loop through resulting parts to reparent/reposition
	for _, newPart in pairs(newParts) do
		newPart.Parent = mainPart.Parent
		newPart.CFrame = mainPart.CFrame
		newPart.Anchored = mainPart.Anchored
	end

	-- Destroy original parts
	mainPart.Parent = nil
	mainPart:Destroy()
	for _, otherPart in pairs(otherParts) do
		otherPart.Parent = nil
		otherPart:Destroy()
	end
end

Crée un ou plus PartOperations à partir de la partie principale minus la géométrie occupée par d'autres parties dans l'matricedonné. Seuls les Parts et

Les propriétés suivantes de la partie principale ( part ) s'appliquent à la partie résultante PartOperations :

• Class.BasePart.Color|Color , Material , MaterialVariant , 0> Class.BasePart.Reflectance|Reflectance0> , Color3>
• CanCollide
• Class.BasePart.Anchored|Anchored , Density , Elasticity , 0> Class.BasePart.ElasticityWeight|Elasticity0> , 3> Class.Base

Dans le comparatif d'image suivant, SubtractAsync() est appelé à l'aide du cône bleu et d'un tableau contenant le bloc violet. Le résultat PartOperation résoudre en une forme qui omets la géométrie du bloc de ce de la cylindre.

<figcaption>Pièces séparées</figcaption>

<figcaption>Opération de classe de résultat <code>Class.PartOperation</code></figcaption>

Notes

• Par rapport à BasePart:SubtractAsync(), cette méthode diffère comme suivant :

  • Les parties d'entrée n'ont pas besoin d'être parentées à la scène, ce qui permet d'effectuer des opérations de fond.
  • Lorsque l'option SplitApart est réglée sur true (par défaut), chaque corps distinct sera renvoyé dans son propre PartOperation.
  • Chaque l'une des parties retournées est dans l'espace de coordonnée de la partie principale. Cela signifie que le (0, 0, 0) de n'importe quelle partie retournée n'est pas nécessairement au centre de son corps.
  • Il est possible d'appeler cette méthode sur le client, mais avec certaines limites. Tout d'abord, il doit actuellement être exécuté avec des objets créés sur le client. Deuxièmement, il n'y a pas de réplication disponible du client au serveur.

• Les parties d'origine restent intactes après un succès. Dans la plupart des cas, vous devriez parent le PartOperations retourné à la même place que la partie principale, puis Destroy() toutes les parties d'origine.

• Par défaut, les couleurs du visage de la partie résultante PartOperations sont empruntées à la propriété Color des parties d'origine, bien que vous puissiez activer leur propriété UsePartColor pour les modifier en couleur spécifique.

• Si une soustraction entraînerait une opération PartOperations avec plus de 20 000 triangles, ils seront simplifiés en 20 000. Cela entraînera une erreur avec le code -14.

• Si la partie principale se déplace pendant la calcul de l'opération, vous pouvez configurer les parties résultantes dans le CFrame de la partie principale, car les parties retournées sont dans l'espace de coordonnée de la partie principale.

• Si vous utilisez cette méthode avec un PartOperation en tant que partie principale, vous pou

Paramètres

Retours

local GeometryService = game:GetService("GeometryService")

local mainPart = workspace.BlueCylinder
local otherParts = {workspace.PurpleBlock}

local options = {
	CollisionFidelity = Enum.CollisionFidelity.Default,
	RenderFidelity = Enum.RenderFidelity.Automatic,
	SplitApart = true
}

-- Perform subtract operation in pcall() since it's asyncronous
local success, newParts = pcall(function()
	return GeometryService:SubtractAsync(mainPart, otherParts, options)
end)

if success and newParts then
	-- Loop through resulting parts to reparent/reposition
	for _, newPart in pairs(newParts) do
		newPart.Parent = mainPart.Parent
		newPart.CFrame = mainPart.CFrame
		newPart.Anchored = mainPart.Anchored
	end

	-- Destroy original parts
	mainPart.Parent = nil
	mainPart:Destroy()
	for _, otherPart in pairs(otherParts) do
		otherPart.Parent = nil
		otherPart:Destroy()
	end
end

Crée une ou plusieurs PartOperations à partir de la partie principale plus la géométrie occupée par d'autres parties dans l'matricedonné. Seuls les Parts et Class.PartOperation

Les propriétés suivantes de la partie principale ( part ) s'appliquent à la partie résultante PartOperations :

• Class.BasePart.Color|Color , Material , MaterialVariant , 0> Class.BasePart.Reflectance|Reflectance0> , Color3>
• CanCollide
• Class.BasePart.Anchored|Anchored , Density , Elasticity , 0> Class.BasePart.ElasticityWeight|Elasticity0> , 3> Class.Base

Dans le comparateur d'image suivant, UnionAsync() est appelé à l'aide du bloc bleu et d'un tableau contenant le cylindre violet. Le résultat PartOperation résoudre en une forme de la géométrie combinée des deux parties.

<figcaption>Pièces séparées</figcaption>

<figcaption>Opération de classe de résultat <code>Class.PartOperation</code></figcaption>

Notes

• Par rapport à BasePart:UnionAsync(), cette méthode diffère comme suivant :

  • Les parties d'entrée n'ont pas besoin d'être parentées à la scène, ce qui permet d'effectuer des opérations de fond.
  • Lorsque l'option SplitApart est réglée sur true (par défaut), chaque corps distinct sera renvoyé dans son propre PartOperation.
  • Chaque l'une des parties retournées est dans l'espace de coordonnée de la partie principale. Cela signifie que le (0, 0, 0) de n'importe quelle partie retournée n'est pas nécessairement au centre de son corps.
  • Il est possible d'appeler cette méthode sur le client, mais avec certaines limites. Tout d'abord, il doit actuellement être exécuté avec des objets créés sur le client. Deuxièmement, il n'y a pas de réplication disponible du client au serveur.

• Les parties d'origine restent intactes après un succès. Dans la plupart des cas, vous devriez parent le PartOperations retourné à la même place que la partie principale, puis Destroy() toutes les parties d'origine.

• Par défaut, les couleurs de la résultante PartOperations sont empruntées à la propriété Color des parties d'origine, bien que vous puissiez activer leur propriété UsePartColor pour les modifier en couleur spécifique.

• Si une opération d'union entraînerait plus de 20 000 triangles, ils seront simplifiés en 20 000. Cela entraînera une erreur avec le code -14.

• Si la partie principale se déplace pendant la calcul de l'opération, vous pouvez configurer les parties résultantes dans le CFrame de la partie principale, car les parties retournées sont dans l'espace de coordonnée de la partie principale.

• Si vous utilisez cette méthode avec un PartOperation en tant que partie principale, vous pou

Paramètres

Retours

local GeometryService = game:GetService("GeometryService")

local mainPart = workspace.BlueBlock
local otherParts = {workspace.PurpleCylinder}

local options = {
	CollisionFidelity = Enum.CollisionFidelity.Default,
	RenderFidelity = Enum.RenderFidelity.Automatic,
	SplitApart = false
}

-- Perform union operation in pcall() since it's asyncronous
local success, newParts = pcall(function()
	return GeometryService:UnionAsync(mainPart, otherParts, options)
end)

if success and newParts then
	-- Loop through resulting parts to reparent/reposition
	for _, newPart in pairs(newParts) do
		newPart.Parent = mainPart.Parent
		newPart.CFrame = mainPart.CFrame
		newPart.Anchored = mainPart.Anchored
	end

	-- Destroy original parts
	mainPart.Parent = nil
	mainPart:Destroy()
	for _, otherPart in pairs(otherParts) do
		otherPart.Parent = nil
		otherPart:Destroy()
	end
end