Een **NegateOperation** is het resultaat van een onderdeel dat is genegateerd via
Studio's solide modellering **Negate**-tool.

Een genegateerd onderdeel wordt roze en doorschijnend als indicator van zijn staat. Als het
genegateerde onderdeel vervolgens wordt samengevoegd met een normaal onderdeel met behulp van de **Union**-tool,
worden de secties waar het genegateerde onderdeel het normale onderdeel overlapt, uitgesneden.

Let op dat je de negatie van een onderdeel kunt ongedaan maken door het genegateerde onderdeel te selecteren en
opnieuw op **Negate** te klikken.

Zie [Solid Modeling](/parts/solid-modeling) voor meer informatie over
Studio's solide modelleringstools en -methoden.


NegateOperation

Resultaat van een onderdeel dat is genegateerd voor gebruik in solide modellering.


Een abstracte klasse waarvan alle onderdelen die op
[solide modellering](/parts/solid-modeling) zijn gebaseerd, erven.


Het volgende voorbeeld vervangt de geometrie van één `Class.PartOperation`
met de geometrie van een andere `Class.PartOperation`, en verwijdert
constraints/attachments die niet bewaard moeten blijven na de substitutie.


Vervangt de geometrie van deze `Class.PartOperation` door de geometrie
van een andere `Class.PartOperation`. Dit maakt het gemakkelijker om de
geometrie van een solide modellering operatie zoals
`Class.GeometryService:UnionAsync()|UnionAsync()`,
`Class.GeometryService:SubtractAsync()|SubtractAsync()`, of
`Class.GeometryService:IntersectAsync()|IntersectAsync()` te gebruiken, maar behoudt
eigenschappen, attributen, tags en kinderen van het hoofdonderdeel zoals
`Class.Attachment|Attachments`, `Class.Constraint|Constraints`,
`Class.ParticleEmitter|ParticleEmitters`, lichtobjecten, decals, en meer.
Deze aanpak omzeilt ook de potentiële "flikkering" van het volledig
vervangen van de oorspronkelijke `Class.PartOperation` door een andere.

Let op dat als je deze methode aanroept op een `Class.PartOperation` met
kind `Class.Attachment|Attachments` of `Class.Constraint|Constraints`,
jij de aangetaste instanties moet berekenen met
`Class.GeometryService:CalculateConstraintsToPreserve()|CalculateConstraintsToPreserve()`,
verwijder dan die waarvan de aanbevolen ouder `nil` is.


PartOperation:SubstituteGeometry

source

De `Class.PartOperation` waarvan de geometrie de geometrie
van deze `Class.PartOperation` zal vervangen.


Vervangt de geometrie van deze `Class.PartOperation` door de geometrie
van een andere `Class.PartOperation`.


PartOperation

Deze eigenschap bepaalt het detailniveau waarop het solide gemodelleerde onderdeel
zal worden weergegeven. Het kan worden ingesteld op de mogelijke waarden van de
`Enum.RenderFidelity` enum, met uitzondering van
`Enum.RenderFidelity.Performance|Performance`.

De standaardwaarde is `Enum.RenderFidelity.Automatic|Automatic`, wat betekent
dat het detail van het onderdeel is gebaseerd op de afstand tot de camera, zoals uiteengezet in
de volgende tabel.

<table>
    <thead>
        <tr>
            <th>Afstand van de camera</th>
            <th>Render Fidelity</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td> Minder dan 250 studs</td>
            <td> Hoogste</td>
        </tr>
        <tr>
            <td> 250-500 studs</td>
            <td> Gemiddeld</td>
        </tr>
        <tr>
            <td> 500 of meer studs</td>
            <td> Laagste</td>
        </tr>
    </tbody>
</table>


PartOperation.RenderFidelity

Het detailniveau dat wordt gebruikt om het solide gemodelleerde onderdeel weer te geven.


Deze eigenschap vertegenwoordigt een hoek in graden voor een drempelwaarde tussen
vlaknormen op een [solide gemodelleerd](/parts/solid-modeling) onderdeel.
Als het normaalverschil kleiner is dan de waarde, worden de normen aangepast
die het verschil glad maken. Terwijl een waarde tussen 30 en 70 graden meestal
een goed resultaat oplevert, worden waarden tussen 90 en 180 niet aanbevolen, omdat
dit een "schaduweffect" kan veroorzaken op unies met scherpe randen.

Let op dat het gladmaken de normen tussen verschillende
materialen of verschillende kleuren niet beïnvloedt.


PartOperation.SmoothingAngle

Een hoek in graden die de gladde schaduw van een solide gemodelleerd
onderdeel beïnvloedt.


Het aantal polygonen in dit solide model.


PartOperation.TriangleCount

Stelt in of de `Class.PartOperation` opnieuw kan worden gekleurd met behulp van de
`Class.BasePart.Color` of `Class.BasePart.BrickColor` eigenschappen. Wanneer
waar, wordt de gehele unie gekleurd volgens `Class.BasePart.Color|Color`
of `Class.BasePart.BrickColor|BrickColor`. Wanneer onwaar, behouden de onderdelen in de
unie hun oorspronkelijke kleuren van vóór de ui-operatie
werd uitgevoerd.


PartOperation.UsePartColor

Stelt in of de `Class.PartOperation` opnieuw kan worden gekleurd met behulp van geërfde
kleureigenschappen.


Een abstracte klasse waarvan alle onderdelen die op solide modellering zijn gebaseerd, erven.


TriangleMeshPart is een abstracte tussenklasse waaruit `Class.MeshPart`
en `Class.PartOperation` erven. Het is gemaakt om het beheer van de
fysieke geometrie-eigenschappen tussen de twee subklassen te consolideren. Het
implementeert de alleen-lezen
`Class.TriangleMeshPart.CollisionFidelity|CollisionFidelity` en
`Class.TriangleMeshPart.CollisionPrecision|CollisionPrecision`.


TriangleMeshPart

Deze eigenschap bepaalt hoe het botsingsmodel van de
`Class.TriangleMeshPart` zich verhoudt tot de werkelijke geometrie van de mesh. Deze
eigenschap kan niet worden gelezen of gemanipuleerd door scripts tijdens runtime.

Zie [hier](/workspace/collisions#collision-fidelity) voor een
visuele weergave van de verschillende opties.


TriangleMeshPart.CollisionFidelity

Bepaalt het detailniveau waaraan de fysica van het onderdeel zich aan zijn mesh zal houden.


Deze eigenschap beschrijft de precisie-prestatie trade-off van de
botsingsgeometrie van het onderdeel wanneer `Class.TriangleMeshPart.CollisionFidelity`
is ingesteld op `Enum.CollisionFidelity.Tunable`. Een waarde van `0` geeft de voorkeur aan maximale
prestatie met de eenvoudigste botsingsmesh, terwijl een waarde van `1` de voorkeur geeft aan
maximale precisie met een botsingsmesh die nauw aansluit bij de visuele
mesh.


TriangleMeshPart.CollisionPrecision

Kwantificeert hoe precies of performant een `Enum.CollisionFidelity.Tunable`
botsingsgeometrie is, van `0` tot `1`.


Beheert welke geometrische representatie de fysica-engine gebruikt wanneer deze
aerodynamische (vloeistof) krachten en momenten voor het onderdeel berekent. Het is standaard
gesteld op `Enum.FluidFidelity.Automatic`, waarbij de engine een
representatie voor je kiest.

- `Enum.FluidFidelity.Automatic` — de engine kiest de representatie;
  deze evalueert momenteel vloeistofkrachten tegen de botsingsgeometrie van het onderdeel.
- `Enum.FluidFidelity.UseCollisionGeometry` — vloeistofkrachten worden geëvalueerd
  tegen de botsingsgeometrie van het onderdeel, die overeenkomt met de vorm die wordt gebruikt voor
  botsingsdetectie.
- `Enum.FluidFidelity.UsePreciseGeometry` — vloeistofkrachten worden geëvalueerd
  tegen de precieze mesh-geometrie van het onderdeel, wat nauwkeurigere krachten oplevert
  tegen een hogere rekentijd.

Omdat deze eigenschap plugin-niveau schrijfrechten heeft, wordt deze geconfigureerd in
Studio in plaats van toegewezen door runtime-scripts.

Deze instelling heeft alleen invloed op een onderdeel terwijl vloeistofkrachten actief zijn voor de
plaats, wat wordt beheerd door `Class.Workspace.FluidForces` (een
`Enum.FluidForces` waarde die standaard op `Default` staat; het instellen op
`Experimental` activeert het aerodynamische krachtmodel). Wanneer vloeistofkrachten
niet op het onderdeel worden toegepast, heeft de gekozen precisie geen effect.


TriangleMeshPart.FluidFidelity

Bepaalt de geometrische representatie die wordt gebruikt om aerodynamische krachten
en momenten te berekenen.


Deze alleen-lezen eigenschap rapporteert de grootte van de mesh-geometrie van het onderdeel toen
het werd geladen, als breedte, hoogte en diepte in studs. Het wordt niet beïnvloed door
het wijzigen van de grootte van het onderdeel via `Class.BasePart.Size`, dus het delen van
`Class.BasePart.Size` door `MeshSize` geeft de schaalfactor die momenteel
is toegepast op de visuele en fysieke geometrie van de mesh.


TriangleMeshPart.MeshSize

De oorspronkelijke grootte van de mesh-geometrie van het onderdeel, voordat enige schaling
is toegepast via `Class.BasePart.Size`.


Abstracte tussenklasse die fysieke geometrie-eigenschappen beheert voor
PartOperations en MeshParts.


Maakt een blauwe part en een rode doelpart. De blauwe part zal proberen om soepel
het rode doel te bereiken. Beweeg en roteer het doel om het gedrag te zien.
Het veranderen van de smoothTime zal resulteren in verschillende soepelheidsnelheden.


`Class.BasePart` is een abstracte basis klasse voor objecten in de wereld die renderen
en fysiek worden gesimuleerd terwijl ze in de `Class.Workspace` zijn. Er zijn verschillende
implementaties van `Class.BasePart`, de meest voorkomende zijn `Class.Part` en
`Class.MeshPart`. Andere zijn `Class.WedgePart`, `Class.SpawnLocation`, en
de singleton `Class.Terrain` object. Over het algemeen, wanneer documentatie verwijst naar
een "deel," zullen de meeste `Class.BasePart` implementaties werken en niet alleen
`Class.Part`.

Voor informatie over hoe `Class.BasePart|BaseParts` worden gegroepeerd in gesimuleerde
stijve lichamen, zie [Assemblies](/physics/assemblies).

Er zijn veel verschillende objecten die interageren met `Class.BasePart` (anders dan
`Class.Terrain`), inclusief:

- Verschillende `Class.BasePart|BaseParts` kunnen binnen een `Class.Model` worden gegroepeerd en
  tegelijkertijd worden verplaatst met `Class.PVInstance:PivotTo()`. Zie
  [Models](/parts/models).
- Een `Class.Decal` past een uitgerekte afbeeldingsstructuur toe op de vlakken van een
  `Class.BasePart`, terwijl een `Class.Texture` een getegelde afbeeldingsstructuur toepast op
  de vlakken. Zie [Textures and Decals](/parts/textures-decals).
- Een `Class.SurfaceGui` rendert `Class.GuiObject|GuiObjects` op het vlak van een
  deel. Zie
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` kunnen aan een `Class.BasePart` worden toegevoegd om
  `Datatype.CFrame|CFrames` ten opzichte van het deel te specificeren. Deze worden vaak gebruikt door
  fysieke `Class.Constraint` objecten zoals beschreven in
  [Mechanical Constraints](/physics/mechanical-constraints) en
  [Mover Constraints](/physics/mover-constraints).
- `Class.ParticleEmitter` objecten stoten deeltjes uniform uit in het volume van
  de `Class.BasePart` waaraan ze zijn gekoppeld. Zie
  [Particle Emitters](/effects/particle-emitters).
- Lichtobjecten zoals `Class.PointLight` stoten licht uit vanuit het midden van een
  `Class.BasePart` zoals geïllustreerd in
  [Light Sources](/effects/light-sources).
- Als het is gekoppeld aan een `Class.Tool` en de naam **Handle** heeft, kan een
  `Class.BasePart` worden vastgehouden door personages. Zie
  [In-Experience Tools](/players/tools).


Vuurd wanneer een ander onderdeel in contact komt met een ander object. Deze gebeurtenis
stuurt alleen gegevens naar de client die deze op de hoogte stelt dat twee onderdelen zijn gebotst,
terwijl `Class.BasePart.Touched` gegevens naar de server stuurt.


BasePart.LocalSimulationTouched

part

Het andere onderdeel dat in contact kwam met dit onderdeel.


Vuurd op de lokale client wanneer een ander onderdeel in contact komt met dit
onderdeel.


Vuurd als het uiterlijk van het onderdeel wordt beïnvloed door de `Class.Shirt` klasse.


BasePart.OutfitChanged

Vuurd wanneer het uiterlijk van het onderdeel verandert door een `Class.Shirt`.


Verouderd. Vuurd op de lokale client wanneer een onderdeel stopt met het aanraken van een ander
onderdeel, onder omstandigheden die vergelijkbaar zijn met die van `Class.BasePart.TouchEnded`.
Deze gebeurtenis is de client-only tegenhanger van `Class.BasePart.TouchEnded`:
het stelt alleen de lokale client op de hoogte dat de twee onderdelen zijn gescheiden,
terwijl `Class.BasePart.TouchEnded` ook gegevens naar de server stuurt. Gebruik
`Class.BasePart.TouchEnded` in plaats daarvan.


BasePart.StoppedTouching

otherPart

Het andere onderdeel dat stopte met het aanraken van het gegeven onderdeel.


Vuurd op de lokale client wanneer een onderdeel stopt met het aanraken van een ander onderdeel.


Dit codevoorbeeld maakt een BillboardGui op een onderdeel dat het aantal
onderdelen weergeeft dat momenteel ermee in contact is.


Dit codevoorbeeld toont aan hoe je de `Class.BasePart.Touched`
evenement van meerdere onderdelen in een `Class.Model` met één functie kunt verbinden.


De **Touched** gebeurtenis vuurt wanneer een onderdeel in contact komt met een ander
onderdeel. Bijvoorbeeld, als **PartA** tegen **PartB** botst, dan
`Class.BasePart.Touched|PartA.Touched` vuurt met **PartB**, en
`Class.BasePart.Touched|PartB.Touched` vuurt met **PartA**.

Deze gebeurtenis vuurt alleen als gevolg van fysieke beweging, dus het zal niet
vuren als de `Class.BasePart.CFrame|CFrame` eigenschap is veranderd zodat
het onderdeel een ander onderdeel overlapt. Dit betekent ook dat ten minste een van de
onderdelen die betrokken zijn **niet** `Class.BasePart.Anchored|Anchored` moet zijn op het
moment van de botsing.

Deze gebeurtenis werkt samen met
`Class.Workspace.TouchesUseCollisionGroups` om te specificeren of
[botsingsgroepen](/workspace/collisions#collision-filtering)
worden erkend voor detectie.


BasePart.Touched

Het andere onderdeel dat in contact kwam met het gegeven onderdeel.


Vuurd wanneer een onderdeel een ander onderdeel aanraakt als gevolg van fysieke beweging.


Vuurd wanneer een onderdeel stopt met het aanraken van een ander onderdeel onder vergelijkbare omstandigheden als
bij `Class.BasePart.Touched`.

Deze gebeurtenis werkt samen met
`Class.Workspace.TouchesUseCollisionGroups` om te specificeren of
[botsingsgroepen](/workspace/collisions#collision-filtering)
worden erkend voor detectie.


BasePart.TouchEnded

Het andere onderdeel dat stopte met het aanraken van dit onderdeel.


Vuurd wanneer een onderdeel stopt met het aanraken van een ander onderdeel als gevolg van fysieke
beweging.


Demonstrates `Class.BasePart:AngularAccelerationToTorque()`.


Geeft de wereldruimte koppelvector terug die op de assemblage van het onderdeel moet worden toegepast om de opgegeven hoeksversnelling te bereiken. Dit resultaat kan worden gebruikt om het koppel te bepalen dat moet worden toegepast via een `Class.Torque`-instantie of `Class.BasePart:ApplyAngularImpulse()`.

De berekening gebruikt de rotatievergelijking van Euler waarbij _I_ de wereldruimte inertietensor van de assemblage is, _α_ de gewenste hoeksversnelling is, en _ω_ de hoeksnelheid is.

_τ = I · α + ω × (I · ω)_

Als het onderdeel geen afstammeling is van `Class.Workspace`, retourneert deze methode een vector van oneindigheid. Als de assemblage is verankerd, retourneert deze ook een vector van oneindigheid.

#### Gyroscopische Effecten

Wanneer een draaiende assemblage een asymmetrische inertietensor heeft, wordt het koppel dat nodig is om een opgegeven hoeksversnelling te bereiken, vergroot door de veranderende oriëntatie van het lichaam. De optionele `angVelocity`-parameter houdt rekening met deze gyroscopische effecten. Als weggelaten, worden deze gyroscopische effecten weggelaten uit de berekening.


BasePart:AngularAccelerationToTorque

angAcceleration

De gewenste hoeksversnelling vector in wereldruimte.


angVelocity

De huidige hoeksnelheid van de assemblage in wereldruimte. Standaard is dit `(0, 0, 0)`. Geef de hoeksnelheid van de assemblage op om rekening te houden met gyroscopische effecten.


Een `Datatype.Vector3` die het wereldruimte koppel vertegenwoordigt dat nodig is om de opgegeven hoeksversnelling te produceren.


Geeft het koppel terug dat nodig is om een gegeven hoeksversnelling op de assemblage van dit onderdeel te bereiken, met optionele rekening houdend met gyroscopische effecten.


Past een instantane hoeks krachtimpuls toe op de assemblage van dit onderdeel, waardoor de assemblage gaat draaien.

De resulterende hoeksnelheid van de impuls is afhankelijk van de `Class.BasePart.AssemblyMass|massa` van de assemblage. Dus een hogere impuls is nodig om zwaardere assemblages te verplaatsen. Impulsen zijn nuttig voor gevallen waarin je een kracht onmiddellijk wilt toepassen, zoals een explosie of botsing.

Als het onderdeel [eigendom](/physics/network-ownership) is van de server, moet deze functie worden aangeroepen vanuit een server `Class.Script` (niet vanuit een `Class.LocalScript` of een `Class.Script` met
`Class.BaseScript.RunContext|RunContext` ingesteld op `Enum.RunContext.Client`).
Als het onderdeel eigendom is van een client via **automatische** eigendom, kan deze functie worden aangeroepen vanuit zowel een clientscript **als** een serverscript; het aanroepen vanuit een clientscript voor een server-eigendom onderdeel heeft geen effect.


BasePart:ApplyAngularImpulse

impulse

Een hoeksimpuls vector die op de assemblage moet worden toegepast.


Pas een hoeksimpuls toe op de assemblage.


Deze functie past een instantane krachtimpuls toe op de assemblage van dit onderdeel.

De kracht wordt toegepast op het `Class.BasePart.AssemblyCenterOfMass|centrum van massa` van de assemblage, zodat de resulterende beweging alleen lineair zal zijn.

De resulterende snelheid van de impuls is afhankelijk van de `Class.BasePart.AssemblyMass|massa` van de assemblage. Dus een hogere impuls is nodig om zwaardere assemblages te verplaatsen. Impulsen zijn nuttig voor gevallen waarin je een kracht onmiddellijk wilt toepassen, zoals een explosie of botsing.

Als het onderdeel [eigendom](/physics/network-ownership) is van de server, moet deze functie worden aangeroepen vanuit een server `Class.Script` (niet vanuit een `Class.LocalScript` of een `Class.Script` met
`Class.BaseScript.RunContext|RunContext` ingesteld op `Enum.RunContext.Client`).
Als het onderdeel eigendom is van een client via **automatische** eigendom, kan deze functie worden aangeroepen vanuit zowel een clientscript **als** een serverscript; het aanroepen vanuit een clientscript voor een server-eigendom onderdeel heeft geen effect.


BasePart:ApplyImpulse

Een lineaire impuls vector die op de assemblage moet worden toegepast.


Pas een impuls toe op de assemblage op het `Class.BasePart.AssemblyCenterOfMass|centrum van massa` van de assemblage.


Deze functie past een instantane krachtimpuls toe op de assemblage van dit onderdeel, op de opgegeven positie in wereldruimte.

Als de positie niet op het `Class.BasePart.AssemblyCenterOfMass|centrum van massa` van de assemblage ligt, zal de impuls een positionele en roterende beweging veroorzaken.

De resulterende snelheid van de impuls is afhankelijk van de `Class.BasePart.AssemblyMass|massa` van de assemblage. Dus een hogere impuls is nodig om zwaardere assemblages te verplaatsen. Impulsen zijn nuttig voor gevallen waarin ontwikkelaars een kracht onmiddellijk willen toepassen, zoals een explosie of botsing.

Als het onderdeel [eigendom](/physics/network-ownership) is van de server, moet deze functie worden aangeroepen vanuit een server `Class.Script` (niet vanuit een `Class.LocalScript` of een `Class.Script` met
`Class.BaseScript.RunContext|RunContext` ingesteld op `Enum.RunContext.Client`).
Als het onderdeel eigendom is van een client via **automatische** eigendom, kan deze functie worden aangeroepen vanuit zowel een clientscript **als** een serverscript; het aanroepen vanuit een clientscript voor een server-eigendom onderdeel heeft geen effect.


BasePart:ApplyImpulseAtPosition

Een impuls vector die op de assemblage moet worden toegepast.


position

De positie, in wereldruimte, waar de impuls moet worden toegepast.


Pas een impuls toe op de assemblage op een specifieke positie.


Abonneert `callback` op de contactgegevens die de fysica-engine genereert voor dit onderdeel tijdens het detecteren van botsingen. Een keer per frame, nadat de simulatie is gestapt, ontvangt `callback` een array van samenvattingen die elke contactpatch beschrijven waarbij dit onderdeel betrokken was tijdens dat frame. Elke samenvatting rapporteert waar het contact plaatsvond, welke richting het opging, en hoe snel de twee onderdelen ten opzichte van elkaar bewogen op dat moment.

Deze methode is een apart mechanisme van `Class.BasePart.Touched`.

Geeft een foutmelding als `callback` `nil` is, of als het onderdeel geen afstammeling is van `Class.Workspace`.

#### Samenvattingsvelden

Elke invoer in de array die aan `callback` wordt doorgegeven, is een tabel met de volgende sleutels:

<table size="small">
<thead>
  <tr>
    <th>Sleutel</th>
    <th>Type</th>
    <th>Samenvatting</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>Tijd</code></td>
    <td><code>nummer</code></td>
    <td>Simulatietijd, in seconden, van de fysica substap die deze samenvatting heeft geproduceerd.</td>
  </tr>
  <tr>
    <td><code>Part0</code></td>
    <td><code>Class.BasePart</code></td>
    <td>Het geabonneerde onderdeel.</td>
  </tr>
  <tr>
    <td><code>Part1</code></td>
    <td><code>Class.BasePart</code></td>
    <td>Het andere onderdeel in het paar, dat <code>Class.Terrain</code> kan zijn.</td>
  </tr>
  <tr>
    <td><code>Punt</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Contactpunt in wereldruimte, gemiddeld over de punten in de patch.</td>
  </tr>
  <tr>
    <td><code>Normaal</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Eenheidscontactnormaal voor de patch, georiënteerd ten opzichte van het geabonneerde onderdeel.</td>
  </tr>
  <tr>
    <td><code>RelatieveSnelheid</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Snelheid van <code>Part1</code> ten opzichte van <code>Part0</code> op het contactpunt.</td>
  </tr>
  <tr>
    <td><code>Oppervlakte</code></td>
    <td><code>nummer</code></td>
    <td>Geschatte oppervlakte van de contactpatch, in vierkante studs. <code>0</code> voor een patch van minder dan drie punten, zoals een rand of hoekcontact.</td>
  </tr>
</tbody>
</table>

`Normaal` is georiënteerd ten opzichte van het geabonneerde onderdeel in plaats van ten opzichte van welk onderdeel de engine toevallig als eerste opsomde, dus als beide onderdelen van een paar zijn geabonneerd, ontvangt elke abonnement zijn eigen samenvatting met zichzelf als `Part0` en de normaal omgekeerd om overeen te komen.

`RelatieveSnelheid` is de snelheid van `Part1` ten opzichte van `Part0`, dus de grootte van de projectie op `Normaal` is de snelheid waarmee de twee onderdelen recht op elkaar afkomen of zich van elkaar verwijderen, en de component die tangentiëel is aan `Normaal` beschrijft glijdend en glijdend contact.

#### Rapportagegedrag

- Contactregistratie is alleen ingeschakeld zolang er ten minste één abonnement bestaat
  ergens in de `Class.Workspace`, en de kosten ervan schalen met het aantal geabonneerde onderdelen in plaats van met het totale aantal
  botsingen in de scène.
- Contacten tussen meerdere slapende onderdelen produceren geen samenvattingen.
- Contacten van onderdelen met `Class.BasePart.CanCollide` ingesteld op `false` produceren geen samenvattingen.
- Fysica kan verschillende substappen per frame uitvoeren, dus een paar dat in contact blijft over verschillende substappen produceert tot één samenvatting per patch per substap, allemaal geleverd in dezelfde aanroep van `callback`. Gebruik `Tijd`
  om ze te ordenen.
- Niet-convexe botsingsgeometrie produceert één samenvatting per paar van aangrenzende
  convexe hulls, en contact met `Class.Terrain` wordt verder gesplitst door
  contactnormaal, zodat een van beide verschillende samenvattingen voor hetzelfde paar kan opleveren
  binnen één substap.
- Niets wordt gerepliceerd. Elke client genereert samenvattingen voor de
  botsingen die hij bezit. Zie
  [netwerk eigendom](/physics/network-ownership).
- Het vernietigen van het onderdeel verbreekt zijn abonnementen.


BasePart:BindToCollisionSummaries

callback

Wordt aangeroepen met een array van samenvattingstabellen, maximaal één keer per frame, als
toestand het onderdeel betrokken was bij een botsing.


Een `Datatype.RBXScriptConnection` die de abonnement beëindigt wanneer deze wordt losgekoppeld.


Abonneert zich op gedetailleerde per-frame contactgegevens voor de botsingen waarbij dit onderdeel betrokken is.


Breekt elke oppervlakteverbinding met een aangrenzend onderdeel, inclusief
`Class.Weld` en andere `Class.JointInstance`.


BasePart:BreakJoints

BasePart:breakJoints

Geeft terug of de onderdelen met elkaar kunnen botsen of niet. Deze
functie houdt rekening met de botsingsgroepen van de twee onderdelen. Deze
functie zal een foutmelding geven als het opgegeven onderdeel geen BasePart is.


BasePart:CanCollideWith

Het opgegeven onderdeel dat wordt gecontroleerd op botsbaarheid.


Of de onderdelen met elkaar kunnen botsen.


Geeft terug of de onderdelen met elkaar kunnen botsen.


Dit voorbeeld controleert of het netwerkbezit van de eerste
`BasePart` genaamd _Part_ in de `Workspace` kan worden ingesteld.


De CanSetNetworkOwnership-functie controleert of je het netwerk eigendom van een onderdeel kunt instellen.

De retourwaarde van de functie verifieert of je `Class.BasePart:SetNetworkOwner()` of
`Class.BasePart:SetNetworkOwnershipAuto()` kunt aanroepen zonder een foutmelding te krijgen.
Het retourneert true als je het netwerk eigendom kunt wijzigen/lezen, of retourneert false en de reden waarom je dat niet kunt, als een string.


BasePart:CanSetNetworkOwnership

Of je het netwerk eigendom kunt wijzigen of lezen en de reden.


Controleert of je het netwerk eigendom van een onderdeel kunt instellen.


Geeft het dichtstbijzijnde punt op het oppervlak van het onderdeel terug naar de opgegeven wereldruimte
positie. Als de opgegeven positie zich binnen het onderdeel bevindt, wordt deze
zoals deze is geretourneerd.

Voor `Class.MeshPart` en `Class.PartOperation` instanties respecteert deze methode
de `Enum.CollisionFidelity` waarde van het onderdeel. Retourwaarden kunnen
verschillen afhankelijk van of de mesh wordt behandeld als een doos, een hull, of een
complexere vorm.


BasePart:GetClosestPointOnSurface

Het wereldruimte punt waarvoor het dichtstbijzijnde oppervlakpunt moet worden gevonden.


Het dichtstbijzijnde punt op het oppervlak van het onderdeel in wereldruimte.


Geeft het dichtstbijzijnde punt op het oppervlak van het onderdeel terug naar het opgegeven punt.


Geeft een tabel terug van onderdelen die met het object zijn verbonden door een soort rigide
verbinding.

Als `recursive` waar is, zal deze functie alle onderdelen in de
assemblage die rigide verbonden zijn met de BasePart retourneren.

#### Rigide Verbindingen

Wanneer een verbinding twee onderdelen met elkaar verbindt `(Part0 → Part1)`, is een verbinding **rigide** als de fysica van `Part1` volledig is vergrendeld door `Part0`.
Dit geldt alleen voor de volgende verbindingstypen:

- `Class.Weld`
- `Class.Snap`
- `Class.ManualWeld`
- `Class.Motor`
- `Class.Motor6D`
- `Class.WeldConstraint`


BasePart:GetConnectedParts

recursive

Een tabel van onderdelen die met het object zijn verbonden door een soort
`Class.JointInstance|verbinding`.


Een array van `Class.BasePart|BaseParts` die met dit onderdeel zijn verbonden door rigide
verbindingen. Als `recursive` waar is, omvat het alle onderdelen in de assemblage.


Geeft een tabel terug van onderdelen die met het object zijn verbonden door een soort rigide
verbinding.


Geeft een array terug van alle `Class.JointInstance|Joints` en
`Class.Constraint|Constraints` die met dit onderdeel zijn verbonden en actief zijn in
de simulatie.

Een joint of constraint wordt alleen actief zodra beide onderdelen die het
verbinden zich binnen dezelfde gesimuleerde container bevinden, zoals
`Class.Workspace` of een `Class.WorldModel`. Als een van de verbonden onderdelen
buiten die container is — bijvoorbeeld, geparent aan
`Class.ServerStorage`, of in een andere `Class.WorldModel` — wordt de joint
niet geactiveerd. **GetJoints()** omvat die joint niet op een van beide onderdelen,
ook al bestaat de joint-instantie nog steeds in het datamodel.


BasePart:GetJoints

Een array van alle `Class.JointInstance|Joints` en
`Class.Constraint|Constraints` die met het onderdeel zijn verbonden en actief zijn
in de simulatie.


Geeft alle Joints of Constraints terug die met dit onderdeel zijn verbonden en actief zijn
in de simulatie.


Dit voorbeeld maakt een nieuw onderdeel, myPart, in de Workspace van het spel, met
afmetingen 4x6x4 studs. Het onderdeel is ook verankerd.

Vervolgens wordt myMass ingesteld op de massa van het nieuwe onderdeel. De massa van het onderdeel wordt
afgedrukt aan het einde van de print-instructie:

> De massa van mijn onderdeel is ...


**GetMass** geeft de waarde van de alleen-lezen `Class.BasePart.Mass|Mass`
eigenschap terug.

Deze functie is ouder dan de Mass-eigenschap. Het blijft ondersteund voor
achterwaartse compatibiliteit; je moet de Mass-eigenschap direct gebruiken.


BasePart:GetMass

Geeft de waarde van de `Class.BasePart.Mass|Mass` eigenschap terug.


BasePart:getMass

Geeft de huidige speler terug die de netwerk eigenaar van dit onderdeel is, of `nil`
in het geval van de server.


BasePart:GetNetworkOwner

De huidige speler die de netwerk eigenaar van dit onderdeel is, of `nil` in
het geval van de server.


Geeft true terug als de game-engine automatisch de netwerk eigenaar voor dit onderdeel beslist.


BasePart:GetNetworkOwnershipAuto

Of de game-engine automatisch de netwerk eigenaar voor dit onderdeel beslist.


Geeft de ingeschakelde `Class.NoCollisionConstraint` objecten terug die momenteel
zijn geregistreerd voor dit onderdeel in zijn fysica-wereld. Een
`Class.NoCollisionConstraint` schakelt botsingen uit tussen de twee specifieke
onderdelen waarnaar het verwijst, terwijl elk van die onderdelen nog steeds met de
rest van de wereld kan botsen.

De geretourneerde array is leeg als er momenteel geen dergelijke beperking is geregistreerd
voor dit onderdeel. De volgorde van de geretourneerde beperkingen is niet gegarandeerd.


BasePart:GetNoCollisionConstraints

Een array van de ingeschakelde `Class.NoCollisionConstraint` objecten
momenteel geregistreerd voor dit onderdeel in zijn fysica-wereld.


Geeft de ingeschakelde `Class.NoCollisionConstraint` objecten terug die momenteel
zijn geregistreerd voor dit onderdeel in zijn fysica-wereld.


Deze functie was relevant toen de lag-compensatie-interpolatie van onderdelen online intern was. De interpolatie wordt nu
toegepast op de `Datatype.CFrame` direct.


BasePart:GetRenderCFrame

De `Datatype.CFrame` die vertegenwoordigt waar het onderdeel wordt gerenderd,
wat nu gelijk is aan de `Class.BasePart.CFrame|CFrame` van het onderdeel.


OBSOLETE. Geeft een CFrame terug die beschrijft waar het onderdeel wordt gerenderd.


Geeft het basis onderdeel van een assemblage terug. Bij het verplaatsen van een assemblage van onderdelen
met behulp van een `Datatype.CFrame`. is het belangrijk om dit basis onderdeel te verplaatsen (dit
zal alle andere onderdelen die eraan zijn verbonden dienovereenkomstig verplaatsen). Meer informatie
is beschikbaar in het [Assemblies](/physics/assemblies) artikel.

Deze functie is ouder dan de
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` eigenschap. Het blijft
ondersteund voor achterwaartse compatibiliteit, maar je moet de
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` direct gebruiken.


BasePart:GetRootPart

Het basis onderdeel van een assemblage (een verzameling van onderdelen die met elkaar zijn verbonden).


Geeft het basis onderdeel van een assemblage van onderdelen terug.


Geeft een tabel terug van alle onderdelen die fysiek interageren met dit
onderdeel. Als het onderdeel zelf CanCollide op false heeft staan, retourneert deze functie
een lege tabel, tenzij het onderdeel een
`Class.TouchTransmitter|TouchInterest` object heeft dat eraan is geparent (wat betekent
dat er iets is verbonden met de Touched gebeurtenis). Onderdelen die aangrenzend zijn maar
niet intersecteren worden niet als aanrakend beschouwd. Deze functie is ouder dan de
`Class.WorldRoot:GetPartsInPart()` functie, die meer
flexibiliteit biedt en de speciale `Class.TouchTransmitter|TouchInterest`
regels die hierboven zijn beschreven, vermijdt. Gebruik in plaats daarvan `Class.WorldRoot:GetPartsInPart()`.


BasePart:GetTouchingParts

Een tabel van alle onderdelen die intersecteren en met dit onderdeel kunnen botsen.


Geeft een tabel terug van alle `Class.BasePart.CanCollide` true onderdelen die
intersecteren met dit onderdeel.


Geeft de lineaire snelheid van de assemblage van het onderdeel op de gegeven positie
terwijl het zich ten opzichte van dit onderdeel bevindt. Het kan worden gebruikt om de lineaire snelheid van
onderdelen in een assemblage te identificeren, anders dan het root onderdeel. Als de assemblage geen
hoeksnelheid heeft, zal de lineaire snelheid altijd hetzelfde zijn voor
every positie.


BasePart:GetVelocityAtPosition

De wereldruimte positie waarop de lineaire snelheid van de assemblage moet worden berekend.


Een `Datatype.Vector3` die de lineaire snelheid van de assemblage
op de opgegeven wereldruimte positie vertegenwoordigt.


Geeft de lineaire snelheid van de assemblage van het onderdeel op de gegeven positie
ten opzichte van dit onderdeel terug.


Maakt een nieuwe `Class.IntersectOperation` aan van de intersecterende geometrie van
toepassing en de andere onderdelen in de gegeven array. Alleen `Class.Part|Parts`
worden ondersteund, niet `Class.Terrain` of `Class.MeshPart|MeshParts`. Vergelijkbaar met `Class.Instance:Clone()|Clone()`, heeft het geretourneerde object geen set
`Class.Instance.Parent|Parent`.

De volgende eigenschappen van het oproepende onderdeel worden toegepast op de
resulterende `Class.IntersectOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

#### Migratie

Het wordt ten zeerste aanbevolen om de nieuwere
`Class.GeometryService:IntersectAsync()` in plaats van deze methode te gebruiken. Naast betere prestaties en meer functies, verschilt de nieuwe methode als volgt:

- De output is een array van instanties in plaats van een enkele instantie.
- De invoeronderdelen hoeven niet aan de scène te zijn geparent, waardoor achtergrondbewerkingen mogelijk zijn.
- Wanneer de `SplitApart` optie is ingesteld op `true` (standaard), wordt elk afzonderlijk
  lichaam in zijn eigen `Class.PartOperation` geretourneerd.
- Alle geretourneerde onderdelen bevinden zich in de coördinatenruimte van het hoofdonderdeel, zodat
  hun `Class.PVInstance.Origin` posities hetzelfde zijn als die van het hoofdonderdeel. Dit houdt de vertices van de mesh in dezelfde positie
  ten opzichte van het object als voor de bewerking, maar het betekent ook dat
  de `(0, 0, 0)` van een geretourneerd onderdeel niet noodzakelijkerwijs in het midden van
  zijn lichaam is.

#### Opmerkingen

- De oorspronkelijke onderdelen blijven intact na een succesvolle intersect
  operatie. In de meeste gevallen moet je `Class.Instance.Destroy|Destroy()`
  alle oorspronkelijke onderdelen en het geretourneerde
  `Class.IntersectOperation` naar dezelfde plaats als het oproepende
  `Class.BasePart`.
- Standaard worden de gezichtskleuren van de resulterende intersectie geleend
  van de `Class.BasePart.Color|Color` eigenschap van de oorspronkelijke onderdelen. Om
  de hele intersectie naar een specifieke kleur te veranderen, stel je de
  `Class.PartOperation.UsePartColor|UsePartColor` eigenschap in op `true`.
- Als een intersectieoperatie zou resulteren in een onderdeel met meer dan 20.000
  driehoeken, wordt deze vereenvoudigd tot 20.000 driehoeken.


BasePart:IntersectAsync

parts

De objecten die deelnemen aan de intersectie.


collisionfidelity

De `Enum.CollisionFidelity` waarde voor de resulterende
`Class.IntersectOperation`.


renderFidelity

De `Enum.RenderFidelity` waarde van de resulterende
`Class.PartOperation`.


Resulterende `Class.IntersectOperation` met de standaardnaam **Intersect**.


Maakt een nieuwe `Class.IntersectOperation` aan van de overlappende geometrie van
toepassing en de andere onderdelen in de gegeven array.


Geeft true terug als het object is verbonden met een onderdeel dat het op zijn plaats houdt (bijv. een `Class.BasePart.Anchored|Anchored` onderdeel), anders retourneert het false. In een assemblage die een `Class.BasePart.Anchored|Anchored` onderdeel heeft, is elk ander onderdeel verankerd.


BasePart:IsGrounded

Of het object is verbonden met een onderdeel dat het op zijn plaats houdt.


Geeft true terug als het object is verbonden met een onderdeel dat het op zijn plaats houdt (bijv. een `Class.BasePart.Anchored|Anchored` onderdeel), anders retourneert het false.


Maakt een verbinding aan op elke zijde van de `Class.BasePart|Part` die een
`Enum.SurfaceType` heeft die een verbinding kan maken, het zal een verbinding maken met alle aangrenzende onderdelen.

Verbinden worden gemaakt tussen de zijden en alle vlakke aangrenzende oppervlakken,
afhankelijk van de oppervlakken van de zijden.

- Gladde oppervlakken zullen geen verbindingen maken
- Lijmoppervlakken zullen een `Class.Glue` verbinding maken
- Lasverbinding zal een `Class.Weld` verbinding maken met elk oppervlak, behalve voor
  Unjoinable
- Studs, Inlet, of Universeel zullen elk een `Class.Snap` verbinding maken met
  een van de andere twee oppervlakken (bijv. Studs met Inlet en
  Universeel)
- Scharnier- en motoroppervlakken creëren `Class.Rotate` en `Class.RotateV` verbinding
  instanties

In tegenstelling tot `Class.Model:MakeJoints()`, vereist deze functie een array van
onderdelen als parameter. Deze array wordt als volgt gegeven:

```
part:MakeJoints({part1, part2, part3})
```
Verbinden worden gebroken als er voldoende kracht op wordt uitgeoefend door een
`Class.Explosion`, tenzij een `Class.ForceField` object is geparent aan de
`Class.BasePart` of voorouder `Class.Model`. Om deze reden worden ze vaak gebruikt om eenvoudige vernietigbare gebouwen en andere modellen te maken.


BasePart:MakeJoints

Maakt een verbinding aan op elke zijde van het object die een oppervlakte-ID heeft die een verbinding kan maken.


BasePart:makeJoints

Verandert de grootte van een object net zoals het gebruik van de Studio resize-tool.


BasePart:Resize

normalId

deltaAmount

Hoeveel te groeien/krimpen aan de opgegeven zijde.


BasePart:resize

Stelt de opgegeven speler in als netwerk eigenaar voor dit en alle verbonden onderdelen.
Wanneer playerInstance `nil` is, zal de server de eigenaar zijn in plaats van een
speler.


BasePart:SetNetworkOwner

playerInstance

De speler die netwerk eigendom van het onderdeel krijgt.


Stelt de opgegeven speler in als netwerk eigenaar voor dit en alle verbonden onderdelen.


Laat de game-engine dynamisch beslissen wie de fysica van het onderdeel zal afhandelen
(een van de clients of de server).


BasePart:SetNetworkOwnershipAuto

Maakt een nieuwe `Class.UnionOperation` aan van het onderdeel, minus de geometrie
bezet door de onderdelen in de gegeven array. Alleen `Class.Part|Parts` zijn
ondersteund, niet `Class.Terrain` of `Class.MeshPart|MeshParts`. Vergelijkbaar met
`Class.Instance:Clone()|Clone()`, heeft het geretourneerde object geen set
`Class.Instance.Parent|Parent`.

Let op dat de resulterende unie niet leeg kan zijn door aftrekken. Als de
bewerking zou resulteren in volledig lege geometrie, zal deze mislukken.

#### Migratie

Het wordt ten zeerste aanbevolen om de nieuwere
`Class.GeometryService:SubtractAsync()` in plaats van deze methode te gebruiken. Naast betere prestaties en meer functies, verschilt de nieuwe methode als volgt:

- De output is een array van instanties in plaats van een enkele instantie.
- De invoeronderdelen hoeven niet aan de scène te zijn geparent, waardoor achtergrondbewerkingen mogelijk zijn.
- Wanneer de `SplitApart` optie is ingesteld op `true` (standaard), wordt elk afzonderlijk
  lichaam in zijn eigen `Class.PartOperation` geretourneerd.
- Alle geretourneerde onderdelen bevinden zich in de coördinatenruimte van het hoofdonderdeel, zodat
  hun `Class.PVInstance.Origin` posities hetzelfde zijn als die van het hoofdonderdeel. Dit houdt de vertices van de mesh in dezelfde positie
  ten opzichte van het object als voor de bewerking, maar het betekent ook dat
  de `(0, 0, 0)` van een geretourneerd onderdeel niet noodzakelijkerwijs in het midden van
  zijn lichaam is.


BasePart:SubtractAsync

De objecten die deelnemen aan de aftrekking.


De `Enum.CollisionFidelity` waarde voor de resulterende
`Class.UnionOperation`.


Resulterende `Class.UnionOperation` met de standaardnaam **Union**.


Maakt een nieuwe `Class.UnionOperation` aan van het onderdeel, minus de geometrie
bezet door de onderdelen in de gegeven array.


Toont `Class.BasePart:TorqueToAngularAcceleration()` aan.


Geeft de wereldruimte hoeksversnelling terug die zou resulteren uit
het toepassen van het opgegeven koppel op de assemblage van het onderdeel, met optionele rekening houdend
met gyroscopische effecten.

Dit is de inverse van `Class.BasePart:AngularAccelerationToTorque()`. Het
is nuttig voor het voorspellen hoe een assemblage zal reageren op een toegepast
koppel.

De berekening gebruikt:

**α = I⁻¹ · (τ − ω × (I · ω))**

waarbij **I** de wereldruimte inertietensor van de assemblage is, **τ** het
toegepaste koppel is, en **ω** de hoeksnelheid is.

Als het onderdeel geen afstammeling is van `Class.Workspace`, retourneert het `(0, 0, 0)`.
Als de assemblage is verankerd, retourneert het `(0, 0, 0)`.

#### Gyroscopische Effecten

Wanneer een draaiende assemblage een asymmetrische inertietensor heeft, hangt de
versnelling die resulteert uit een toegepast koppel ook af van de huidige
hoeksnelheid. De `angVelocity` parameter houdt rekening met deze
gyroscopische effecten. Als weggelaten (standaard op nul), negeert het resultaat
bijdrage van dit resultaat.


BasePart:TorqueToAngularAcceleration

torque

De koppelvector die op de assemblage in wereldruimte is toegepast.


De huidige hoeksnelheid van de assemblage in wereldruimte. Standaard
is dit `(0, 0, 0)`. Geef de hoeksnelheid van de assemblage op om rekening te houden met
gyroscopische effecten.


Een `Datatype.Vector3` die de resulterende hoeksversnelling
in wereldruimte vertegenwoordigt.


Geeft de hoeksversnelling terug die zou resulteren uit het toepassen van een gegeven
koppel op de assemblage van dit onderdeel, met optionele rekening houdend met gyroscopische
effecten.


Maakt een nieuwe `Class.UnionOperation` aan van het onderdeel, plus de geometrie
bezet door de onderdelen in de gegeven array. Alleen `Class.Part|Parts` zijn
ondersteund, niet `Class.Terrain` of `Class.MeshPart|MeshParts`. Vergelijkbaar met
`Class.Instance:Clone()|Clone()`, heeft het geretourneerde object geen set
`Class.Instance.Parent|Parent`.

De volgende eigenschappen van het oproepende onderdeel worden toegepast op de
resulterende `Class.UnionOperation`:

- `Class.BasePart.Color|Color`, `Class.BasePart.Material|Material`,
  `Class.BasePart.MaterialVariant|MaterialVariant`,
  `Class.BasePart.Reflectance|Reflectance`,
  `Class.BasePart.Transparency|Transparency`
- `Class.BasePart.CanCollide|CanCollide`
- `Class.BasePart.Anchored|Anchored`, `Class.BasePart.Density|Density`,
  `Class.BasePart.Elasticity|Elasticity`,
  `Class.BasePart.ElasticityWeight|ElasticityWeight`,
  `Class.BasePart.Friction|Friction`,
  `Class.BasePart.FrictionWeight|FrictionWeight`

#### Migratie

Het wordt ten zeerste aanbevolen om de nieuwere
`Class.GeometryService:UnionAsync()` in plaats van deze methode te gebruiken. Naast betere prestaties en meer functies, verschilt de nieuwe methode als volgt:

- De output is een array van instanties in plaats van een enkele instantie.
- De invoeronderdelen hoeven niet aan de scène te zijn geparent, waardoor achtergrondbewerkingen mogelijk zijn.
- Wanneer de `SplitApart` optie is ingesteld op `true` (standaard), wordt elk afzonderlijk
  lichaam in zijn eigen `Class.PartOperation` geretourneerd.
- Alle geretourneerde onderdelen bevinden zich in de coördinatenruimte van het hoofdonderdeel, zodat
  hun `Class.PVInstance.Origin` posities hetzelfde zijn als die van het hoofdonderdeel. Dit houdt de vertices van de mesh in dezelfde positie
  ten opzichte van het object als voor de bewerking, maar het betekent ook dat
  de `(0, 0, 0)` van een geretourneerd onderdeel niet noodzakelijkerwijs in het midden van
  zijn lichaam is.

#### Opmerkingen

- De oorspronkelijke onderdelen blijven intact na een succesvolle unie operatie.
  In de meeste gevallen moet je `Class.Instance.Destroy|Destroy()` al deze
  oorspronkelijke onderdelen en het geretourneerde `Class.UnionOperation` naar dezelfde plaats als het oproepende
  `Class.BasePart`.
- Standaard respecteert de resulterende unie de
  `Class.BasePart.Color|Color` eigenschap van elk van zijn onderdelen. Om
  de hele unie naar een specifieke kleur te veranderen, stel je de
  `Class.PartOperation.UsePartColor|UsePartColor` eigenschap in op `true`.
- Als een unie operatie zou resulteren in een onderdeel met meer dan 20.000
  driehoeken, wordt deze vereenvoudigd tot 20.000 driehoeken.


BasePart:UnionAsync

De objecten die deelnemen aan de unie met het oproepende onderdeel.


Maakt een nieuwe `Class.UnionOperation` aan van het onderdeel, plus de geometrie
bezet door de onderdelen in de gegeven array.


BasePart

De abstracte basis klasse voor objecten in de wereld die fysiek interageren.


/reference/engine/classes/NegateOperation.yaml