GeometryService

Restituisce una tabella di Constraints e Attachments che puoi scegliere di preservare, insieme ai rispettivi genitori.Iterare su questa tabella ti consente di decidere se riparare le restrizioni e gli allegati raccomandati ai loro rispettivi genitori.

Nota che il dizionario options può contenere quanto Seguendo:

• tolerance — La tolleranza di distanza, in relazione alla conservazione di Attachment tra l'allegato e il punto più vicino sulla superficie della parte originale rispetto al punto più vicino sulla superficie della parte risultante.Se la distanza risultante dopo l'operazione di modellazione solida è maggiore di questo valore, le Parent delle allegate e delle loro restrizioni saranno nil nella tabella di raccomandazione restituita.
• weldConstraintPreserve — Un valore enum A Enum.WeldConstraintPreserve che descrive come WeldConstraints vengono preservati nella tabella di raccomandazione risultante.
• dropAttachmentsWithoutConstraints — Boolean con predefinito di true . Se impostato su false , Attachments quelli che non hanno Constraints verranno preservati.

Parametri

Restituzioni

<th>Tipo</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><code>Allegato</code></td>

    <td><code>Class.Attachment</code></td>
  </tr>

  <tr>
    <td><code>Restrizione</code></td>

    <td><code>Classe.Constraint</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td><code>AttachmentParent</code></td>

    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td><code>RestrizioneParent</code></td>

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

<th>Tipo</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><code>Restrizione di saldatura</code></td>

    <td><code>Class.WeldConstraint</code></td>
  </tr>

  <tr>
    <td><code>WeldConstraintParent</code></td>

    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td><code>Parte di restrizione di saldatura0</code></td>

    <td><code>Class.BasePart</code></td>
  </tr>

  <tr>
    <td><code>Parte di restrizione di saldatura1</code></td>

    <td><code>Class.BasePart</code></td>
  </tr>
</tbody>

<th>Tipo</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><code>Nessuna restrizione di collisione</code></td>

    <td><code>Class.NoCollisionClause</code></td>
  </tr>

  <tr>
    <td><code>NoCollisionConstraintParent</code></td>

    <td><code>Class.BasePart</code> o <code>nil</code></td>
  </tr>

  <tr>
    <td><code>Nessuna restrizione di collisionePart0</code></td>

    <td><code>Class.BasePart</code></td>
  </tr>

  <tr>
    <td><code>NoCollisionConstraintPart1</code></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 intersecante della parte principale e di altre parti nell'vettorefornito.Sono supportati solo i primitivi Parts e PartOperations e non Terrain o MeshParts.Simile a Clone() , le parti restituite non hanno alcun set Parent .

Le seguenti proprietà dalla parte principale ( part ) vengono applicate al risultato PartOperations :

• Color , Material , MaterialVariant , Reflectance , Transparency
• CanCollide
• Anchored , Density , Elasticity , ElasticityWeight , Friction , FrictionWeight

Nella seguente comparazione delle immagini, IntersectAsync() è chiamato utilizzando il blocco viola e un'array che contiene il blocco blu.Il risultante PartOperation si risolve in una forma della geometria intersecante di entrambe le parti.

<figcaption>Parti separate</figcaption>

<figcaption>Risultante <code>Class.PartOperation</code> ></figcaption>

Notizie

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

  • Le parti di input non devono essere parentizzate alla scena, consentendo operazioni di sfondo.
  • Quando l'opzione SplitApart è impostata su true (predefinita), ogni corpo distinto verrà restituito nel proprio PartOperation .
  • Ognuna delle parti restituite è nello spazio di coordinate della parte principale.Questo 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.Innanzitutto, attualmente deve essere fatto con oggetti creati sul client.In secondo luogo, non esiste alcuna replicazione disponibile dal client al Server.

• Le parti originali rimangono intatte dopo un'operazione di successo.Nella maggior parte dei casi, dovresti genere il ritornato PartOperations alla stessa posizione della parte principale, quindi Destroy() tutte le parti originali.

• Per impostazione predefinita, i colori del viso del risultato 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 dovesse risultare in qualsiasi PartOperations con più di 20.000 triangoli, verranno semplificati a 20.000.Ciò comporterà un errore con il codice -14 .

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

• Se utilizzi questo metodo con un PartOperation come parte principale, puoi sostituire la geometria di un altro PartOperation tramite SubstituteGeometry() , rendendo più facile utilizzare la geometria dell'operazione ma mantenere le proprietà, gli attributi, i tag e i figli della parte principale come Attachments , Constraints , ParticleEmitters , oggetti leggeri e decorazioni.Questo approccio evita anche il potenziale "flicker" di sostituire completamente l'originale PartOperation con un altro.

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 meno la geometria occupata da altre parti nell'vettorefornito.Sono supportati solo i primitivi Parts e PartOperations e non Terrain o MeshParts.Simile a Clone() , le parti restituite non hanno alcun set Parent .

Le seguenti proprietà dalla parte principale ( part ) vengono applicate al risultato PartOperations :

• Color , Material , MaterialVariant , Reflectance , Transparency
• CanCollide
• Anchored , Density , Elasticity , ElasticityWeight , Friction , FrictionWeight

Nella seguente comparazione delle immagini, SubtractAsync() è chiamato utilizzando il cilindro blu e un'array che contiene il blocco viola.Il risultante PartOperation si risolve in una forma che omite la geometria del blocco da quella del cilindro.

<figcaption>Parti separate</figcaption>

<figcaption>Risultante <code>Class.PartOperation</code> ></figcaption>

Notizie

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

  • Le parti di input non devono essere parentizzate alla scena, consentendo operazioni di sfondo.
  • Quando l'opzione SplitApart è impostata su true (predefinita), ogni corpo distinto verrà restituito nel proprio PartOperation .
  • Ognuna delle parti restituite è nello spazio di coordinate della parte principale.Questo 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.Innanzitutto, attualmente deve essere fatto con oggetti creati sul client.In secondo luogo, non esiste alcuna replicazione disponibile dal client al Server.

• Le parti originali rimangono intatte dopo un'operazione di successo.Nella maggior parte dei casi, dovresti genere il ritornato PartOperations alla stessa posizione della parte principale, quindi Destroy() tutte le parti originali.

• Per impostazione predefinita, i colori del viso del risultato 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 dovesse risultare in qualsiasi PartOperations con più di 20.000 triangoli, verranno semplificati a 20.000.Ciò comporterà un errore con il codice -14 .

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

• Se utilizzi questo metodo con un PartOperation come parte principale, puoi sostituire la geometria di un altro PartOperation tramite SubstituteGeometry() , rendendo più facile utilizzare la geometria dell'operazione ma mantenere le proprietà, gli attributi, i tag e i figli della parte principale come Attachments , Constraints , ParticleEmitters , oggetti leggeri e decorazioni.Questo approccio evita anche il potenziale "flicker" di sostituire completamente l'originale PartOperation con un altro.

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 da altre parti nell'vettorefornito.Sono supportati solo i primitivi Parts e PartOperations e non Terrain o MeshParts.Simile a Clone() , le parti restituite non hanno alcun set Parent .

Le seguenti proprietà dalla parte principale ( part ) vengono applicate al risultato PartOperations :

• Color , Material , MaterialVariant , Reflectance , Transparency
• CanCollide
• Anchored , Density , Elasticity , ElasticityWeight , Friction , FrictionWeight

Nella seguente comparazione delle immagini, UnionAsync() è chiamato utilizzando il blocco blu e un'array che contiene il cilindro viola.Il risultante PartOperation si risolve in una forma della geometria combinata di entrambe le parti.

<figcaption>Parti separate</figcaption>

<figcaption>Risultante <code>Class.PartOperation</code> ></figcaption>

Notizie

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

  • Le parti di input non devono essere parentizzate alla scena, consentendo operazioni di sfondo.
  • Quando l'opzione SplitApart è impostata su true (predefinita), ogni corpo distinto verrà restituito nel proprio PartOperation .
  • Ognuna delle parti restituite è nello spazio di coordinate della parte principale.Questo 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.Innanzitutto, attualmente deve essere fatto con oggetti creati sul client.In secondo luogo, non esiste alcuna replicazione disponibile dal client al Server.

• Le parti originali rimangono intatte dopo un'operazione di successo.Nella maggior parte dei casi, dovresti genere il ritornato PartOperations alla stessa posizione della parte principale, quindi Destroy() tutte le parti originali.

• Per impostazione predefinita, i colori del risultante 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 dovesse risultare in qualsiasi PartOperations con più di 20.000 triangoli, verranno semplificati a 20.000.Ciò comporterà un errore con il codice -14 .

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

• Se utilizzi questo metodo con un PartOperation come parte principale, puoi sostituire la geometria di un altro PartOperation tramite SubstituteGeometry() , rendendo più facile utilizzare la geometria dell'operazione ma mantenere le proprietà, gli attributi, i tag e i figli della parte principale come Attachments , Constraints , ParticleEmitters , oggetti leggeri e decorazioni.Questo approccio evita anche il potenziale "flicker" di sostituire completamente l'originale PartOperation con un altro.

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