GeometryService

Restituisce una tabella di Constraints e Attachments che potresti scegliere di conservare, insieme ai loro rispettivi genitori. L'iterazione su questa tabella ti consente di decidere se conservare le restrizioni e gli accessori raccomandati ai loro rispettivi genitori.

Nota che la tabella options può contenere un valore tolerance (number) e/o un valore WeldConstraintPreserve ( 1> Enumerate.WeldConstraintPreserve1> ).

• tolerance – La tolleranza di distanza, in termini di conservazione di Attachment tra l'attacco e il punto più vicino sulla superficie della parte originale contro la superficie della parte risultante. Se la distanza risultante dopo l'operazione di modellazione solida è maggiore di questo valore, il Class.Instance.Parent|Parent</
• weldConstraintPreserve – Un valore Enum.WeldConstraintPreserve che descrive come WeldConstraints sono preservati nella tabella di raccomandazione risultante.

Parametri

Restituzioni

<tbody>
  <tr>
    <td>Accessorio</td>
    <td><code>Class.Execution</code></td>
  </tr>

  <tr>
    <td>Con限</td>
    <td><code>Class.Constraint</code></td>
  </tr>

  <tr>
    <td>Parent dell'allegato</td>
    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td>Parent di Constraint</td>
    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>
</tbody>

<tbody>
  <tr>
    <td>Con vincolo</td>
    <td><code>Class.WeldConstraint</code></td>
  </tr>

  <tr>
    <td>Parent di saldatura</td>
    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td>Parte di costruzione</td>
    <td><code>Class.BasePart</code></td>
  </tr>

  <tr>
    <td>Parte di costruzione1</td>
    <td><code>Class.BasePart</code></td>
  </tr>
</tbody>

<tbody>
  <tr>
    <td>Nessun limite di collisioni</td>
    <td><code>Class.NoCollisionConstraint</code></td>
  </tr>

  <tr>
    <td>Nessun limite di collisioni</td>
    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td>Nessuna restrizione di collisione</td>
    <td><code>Class.BasePart</code></td>
  </tr>

  <tr>
    <td>Nessuna restrizione di collisioneParte1</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,
	dropAttachmentsWithoutConstraints = false
}

-- 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.Attachment.Parent = item.AttachmentParent
			if item.Constraint then
				item.Constraint.Parent = item.ConstraintParent
			end
		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

Crea uno o più PartOperations dalla geometria intersezione della parte principale e di altre parti nell' vettorespecificato. Sono supportati solo Parts e Class.PartOperation|

Le seguenti proprietà dalla parte principale ( part ) sono applicate al risultato 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.

Nel seguente confronto di immagini, IntersectAsync() viene chiamato utilizzando il blocco viola e un'area contenente il blocco blu. Il risultato PartOperation risolve in una forma della geometria di intersezione delle due parti.

<figcaption>Parti separate</figcaption>

Risultato  Class.PartOperation ]]

Note

• Rispetto a BasePart:IntersectAsync() , questo metodo differisce come segue:

  • Le parti di input non sono necessarie per essere parented alla scena, consentendo operazioni di sfondo.
  • Quando l'opzione SplitApart è impostata su true (per impostazione predefinita), ogni corpo distinto verrà restituito nel suo proprio PartOperation .
  • Ognuna delle parti restituite è nello spazio di coordinamento della parte principale. Ciò significa che il (0,0,0) di qualsiasi parte restituita non è necessariamente al centro del suo corpo.
  • È possibile chiamare questo metodo sul client, ma con alcune limitazioni. In primo luogo, deve essere eseguito con oggetti creati sul client. In secondo luogo, non è disponibile alcuna replicazione dal client al Server.

• Le parti originarie rimangono intatte dopo un'operazione di successo. In most casi, dovresti genitori il PartOperations restituito allo stesso posto della parte principale, quindi Destroy() tutte le parti originali.

• Per impostazione predefinita, i colori del viso dei risultati PartOperations sono presi in prestito dalla proprietà Color delle parti originali, anche se puoi abilitare la loro proprietà UsePartColor per cambiarli in un colore specifico.

• Se un'operazione di intersezione avesse risultato in più di PartOperations con più di 20.000 triangoli, sarebbero stati semplicati a 20.000. Ciò avrebbe risultato in un errore con il codice -14 .

• Se la parte principale si muove durante il calcolo dell'operazione, puoi impostare le parti risultanti nello stesso spazio di coordinate della parte principale, poiché le parti restituite sono nello stesso spazio di coordinate della parte principale.

• Se si utilizza questo metodo con un PartOperation come parte principale, si può sostituire la ge

Parametri

Restituzioni

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

Crea uno o più PartOperations dalla parte principale minus la geometria occupata da altre parti nell' vettorespecificato. Sono supportati solo Parts e Class.PartOperation|Part

Le seguenti proprietà dalla parte principale ( part ) sono applicate al risultato 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.

Nel seguente confronto di immagini, SubtractAsync() viene chiamato utilizzando il cilindro blu e un'area contenente il blocco viola. Il risultato PartOperation risolve in una forma che omette la geometria del blocco da quella del cilindro.

<figcaption>Parti separate</figcaption>

Risultato  Class.PartOperation ]]

Note

• Rispetto a BasePart:SubtractAsync() , questo metodo differisce come segue:

  • Le parti di input non sono necessarie per essere parented alla scena, consentendo operazioni di sfondo.
  • Quando l'opzione SplitApart è impostata su true (per impostazione predefinita), ogni corpo distinto verrà restituito nel suo proprio PartOperation .
  • Ognuna delle parti restituite è nello spazio di coordinamento della parte principale. Ciò significa che il (0,0,0) di qualsiasi parte restituita non è necessariamente al centro del suo corpo.
  • È possibile chiamare questo metodo sul client, ma con alcune limitazioni. In primo luogo, deve essere eseguito con oggetti creati sul client. In secondo luogo, non è disponibile alcuna replicazione dal client al Server.

• Le parti originarie rimangono intatte dopo un'operazione di successo. In most casi, dovresti genitori il PartOperations restituito allo stesso posto della parte principale, quindi Destroy() tutte le parti originali.

• Per impostazione predefinita, i colori del viso dei risultati PartOperations sono presi in prestito dalla proprietà Color delle parti originali, anche se puoi abilitare la loro proprietà UsePartColor per cambiarli in un colore specifico.

• Se un'operazione di sottrazione avesse risultato in qualsiasi PartOperations con più di 20.000 triangoli, saranno semplicizzati in 20.000. Ciò risulterà in un errore con il codice -14 .

• Se la parte principale si muove durante il calcolo dell'operazione, puoi impostare le parti risultanti nello stesso spazio di coordinate della parte principale, poiché le parti restituite sono nello stesso spazio di coordinate della parte principale.

• Se si utilizza questo metodo con un PartOperation come parte principale, si può sostituire la ge

Parametri

Restituzioni

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

Crea uno o più PartOperations dalla parte principale più la geometria occupata dalle altre parti nell' vettorespecificato. Sono supportati solo Parts e Class.PartOperation|PartOperations

Le seguenti proprietà dalla parte principale ( part ) sono applicate al risultato 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.

Nel seguente confronto di immagini, UnionAsync() viene chiamato utilizzando il blocco blu e un'area contenente il cilindro viola. Il risultato PartOperation risolve in una forma della geometria combinata delle due parti.

<figcaption>Parti separate</figcaption>

Risultato  Class.PartOperation ]]

Note

• Rispetto a BasePart:UnionAsync() , questo metodo differisce come segue:

  • Le parti di input non sono necessarie per essere parented alla scena, consentendo operazioni di sfondo.
  • Quando l'opzione SplitApart è impostata su true (per impostazione predefinita), ogni corpo distinto verrà restituito nel suo proprio PartOperation .
  • Ognuna delle parti restituite è nello spazio di coordinamento della parte principale. Ciò significa che il (0,0,0) di qualsiasi parte restituita non è necessariamente al centro del suo corpo.
  • È possibile chiamare questo metodo sul client, ma con alcune limitazioni. In primo luogo, deve essere eseguito con oggetti creati sul client. In secondo luogo, non è disponibile alcuna replicazione dal client al Server.

• Le parti originarie rimangono intatte dopo un'operazione di successo. In most casi, dovresti genitori il PartOperations restituito allo stesso posto della parte principale, quindi Destroy() tutte le parti originali.

• Per impostazione predefinita, i colori dei risultati PartOperations sono presi in prestito dalla proprietà Color delle parti originali, anche se puoi abilitare la loro proprietà UsePartColor per cambiarli in un colore specifico.

• Se un'operazione di unione avesse risultato in qualsiasi PartOperations con più di 20.000 triangoli, sarebbero stati semplicati a 20.000. Ciò avrebbe risultato in un errore con il codice -14 .

• Se la parte principale si muove durante il calcolo dell'operazione, puoi impostare le parti risultanti nello stesso spazio di coordinate della parte principale, poiché le parti restituite sono nello stesso spazio di coordinate della parte principale.

• Se si utilizza questo metodo con un PartOperation come parte principale, si può sostituire la ge

Parametri

Restituzioni

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