`Class.MeshPart` is een vorm van `Class.BasePart` die een fysiek
gesimuleerde aangepaste mesh bevat. In tegenstelling tot andere mesh-klassen, zoals
`Class.SpecialMesh` en `Class.BlockMesh`, zijn ze niet als kind geparent aan een
`Class.BasePart`, maar gedragen ze zich als een `Class.BasePart` op zichzelf.

De mesh en textuur van een `Class.MeshPart` worden bepaald door de
`Class.MeshPart.MeshId|MeshId` en `Class.MeshPart.TextureID|TextureID`
properties. Voor meer informatie, zie [Meshes](/parts/meshes).


Overschrijft de `Class.MeshPart.MeshContent|MeshContent`,
`Class.MeshPart.TextureContent|TextureContent`, en botsingsgeometrie
properties van deze `Class.MeshPart` vanuit de gegeven bron `meshPart`.

De meeste van deze eigenschappen zijn alleen-lezen en kunnen niet rechtstreeks worden gewijzigd tijdens
runtime. Om
`Class.MeshPart.MeshContent|MeshContent` en fysica-data in sync te houden, moeten ze
samen worden bijgewerkt.

Kopieert de volgende eigenschappen:

- `Class.MeshPart.MeshContent` (impliciet bijwerken
  `Class.MeshPart.MeshId|MeshId`)
- `Class.MeshPart.TextureContent` (impliciet bijwerken
  `Class.MeshPart.TextureID|TextureID`)
- `Class.MeshPart.RenderFidelity`
- `Class.MeshPart.CollisionFidelity` (met eventuele interne botsings
  geometrie)
- `Class.MeshPart.FluidFidelity` (met eventuele interne aero geometrie)
- `Class.MeshPart.MeshSize`


MeshPart:ApplyMesh

meshPart

De bron `Class.MeshPart` waarvan de
`Class.MeshPart.MeshContent|MeshContent`,
`Class.MeshPart.TextureContent|TextureContent`, en botsingsgeometrie
(samen met `Class.MeshPart.RenderFidelity|RenderFidelity`,
`Class.MeshPart.CollisionFidelity|CollisionFidelity`,
`Class.MeshPart.FluidFidelity|FluidFidelity`, en
`Class.MeshPart.MeshSize|MeshSize`) op dit onderdeel worden gekopieerd. Het
object moet een `Class.MeshPart` zijn, anders gooit de aanroep een fout.


Overschrijft de `Class.MeshPart.MeshContent|MeshContent`,
`Class.MeshPart.TextureContent|TextureContent`, en botsingsgeometrie
properties van deze `Class.MeshPart` vanuit de gegeven bron `meshPart`.


MeshPart

Deze eigenschap bepaalt of beide zijden van polygonen in de
mesh moeten worden gerenderd. Dit is nuttig voor meshes die typisch zijn gemodelleerd als "kaarten", zoals
bladeren, haar of stof.


MeshPart.DoubleSided

Bepaalt of beide zijden van polygonen in de mesh moeten worden gerenderd.


Verouderde legacy-eigenschap die is gekoppeld aan de interne
`Class.MeshPart.JointOffset|JointOffset` van een `Class.MeshPart`. Het wordt beheerd door de engine en
kan niet door scripts worden ingesteld. Gebruik het niet in nieuw werk.


MeshPart.HasJointOffset

Verouderde legacy-vlag die is gekoppeld aan de `Class.MeshPart.JointOffset|JointOffset` van het onderdeel.


Geeft aan of de momenteel toegepaste mesh op de `Class.MeshPart`
skin-data (bot- en gewrichtsdata) bevat, zoals een mesh die is gemaakt met een
armatuur voor skeletdeformatie.

Standaard is `false`. De engine stelt dit automatisch in wanneer een mesh wordt
geladen (`true` wanneer de meshdata gewrichten bevat), zodat scripts het niet kunnen instellen.


MeshPart.HasSkinnedMesh

Geeft aan of de momenteel toegepaste mesh op de `Class.MeshPart`
skin-data (bot- en gewrichtsdata) bevat.


Verouderd. Een `Datatype.Vector3` offset die ooit werd gebruikt om de gewrichten van een geskinnde
mesh te positioneren. Standaard is `0, 0, 0` en wordt gereset telkens wanneer een nieuwe mesh wordt
toegepast op het onderdeel. Kan niet door scripts worden ingesteld; gebruik het niet in nieuw werk.


MeshPart.JointOffset

Verouderd. Een offset die ooit werd gebruikt om de gewrichten van een geskinnde mesh te positioneren.


De mesh die wordt weergegeven op de `Class.MeshPart`. Ondersteunt
[asset-URI's](/projects/assets#asset-uris) en
`Class.EditableMesh` objecten.

Let op dat deze eigenschap niet rechtstreeks door scripts kan worden gewijzigd, aangezien de
botsingsgeometrie van de mesh niet in realtime kan worden herberekend. Zie
`Class.AssetService:CreateMeshPartAsync()` als een methode om een nieuwe
`Class.MeshPart` te maken van een gegeven `Datatype.Content` met een gespecificeerde
`Class.MeshPart.CollisionFidelity|CollisionFidelity`.
`Class.MeshPart:ApplyMesh()` kan worden gebruikt om de
`Class.MeshPart.MeshContent|MeshContent`,
`Class.MeshPart.TextureContent|TextureContent`, en botsingsgeometrie van
een bestaande `Class.MeshPart` te overschrijven.


MeshPart.MeshContent

De mesh die wordt weergegeven op de `Class.MeshPart`. Ondersteunt
[asset-URI's](/projects/assets#asset-uris) en
`Class.EditableMesh` objecten.


De [asset-URI's](/projects/assets#asset-uris) van de mesh
 die wordt weergegeven op de `Class.MeshPart`. Leest en schrijft naar
`Class.MeshPart.MeshContent|MeshContent`.

Let op dat deze eigenschap niet rechtstreeks door scripts kan worden gewijzigd, aangezien de
botsingsgeometrie van de mesh niet in realtime kan worden herberekend. Zie
`Class.AssetService:CreateMeshPartAsync()` als een methode om een nieuwe
`Class.MeshPart` te maken van een gegeven `Datatype.Content` met een gespecificeerde
`Class.MeshPart.CollisionFidelity|CollisionFidelity`.
`Class.MeshPart:ApplyMesh()` kan worden gebruikt om de
`Class.MeshPart.MeshContent|MeshContent`,
`Class.MeshPart.TextureContent|TextureContent`, en botsingsgeometrie van
een bestaande `Class.MeshPart` te overschrijven.


MeshPart.MeshId

De [asset-URI's](/projects/assets#asset-uris) van de mesh
 die wordt weergegeven op de `Class.MeshPart`. Leest en schrijft naar
`Class.MeshPart.MeshContent|MeshContent`.


Deze eigenschap bepaalt het detailniveau waarop de `Class.MeshPart`
wordt weergegeven. Het kan worden ingesteld op de mogelijke waarden van de
`Enum.RenderFidelity` enum.

De standaardwaarde is `Enum.RenderFidelity.Automatic|Automatic`, wat betekent
dat het detail van de mesh 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>
            <th>Voorbeeld</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td> Minder dan 250 studs</td>
            <td> Hoogste</td>
            <td><img src="../../../assets/modeling/meshes/Render-Fidelity-High.jpg" width="200" /></td>
        </tr>
        <tr>
            <td> 250-500 studs</td>
            <td> Medium</td>
            <td><img src="../../../assets/modeling/meshes/Render-Fidelity-Medium.jpg" width="200" /></td>
        </tr>
        <tr>
            <td> 500 of meer studs</td>
            <td> Laagste</td>
            <td><img src="../../../assets/modeling/meshes/Render-Fidelity-Low.jpg" width="200" /></td>
        </tr>
    </tbody>
</table>


MeshPart.RenderFidelity

Het detailniveau dat wordt gebruikt om de `Class.MeshPart` te renderen.


De textuur die is toegepast op de `Class.MeshPart`. Ondersteunt
[asset-URI's](/projects/assets#asset-uris) en
`Class.EditableImage` objecten.

Wanneer deze eigenschap is ingesteld op `Datatype.Content.none`, wordt er geen textuur toegepast
op de mesh.

```
local Workspace = game:GetService("Workspace")

local meshPart = Workspace.MeshPart
meshPart.TextureContent = Content.none  -- Geen textuur
```
Let op dat de `Class.MeshPart.MeshContent|MeshContent` eigenschap niet kan worden
rechtstreeks gewijzigd tijdens runtime, maar de textuur kan dat wel.

##### Een Mesh-Textuur Wijzigen

Met de `Class.MeshPart.TextureContent|TextureContent` eigenschap kan de
textuur van een mesh worden gewijzigd zonder de mesh opnieuw te hoeven uploaden. Om
dit te doen, kan een nieuwe afbeelding worden geüpload naar Roblox met de gewenste textuur.
Het originele textuurafbeeldingsbestand kan worden verkregen door de mesh
te exporteren met de optie **Export Selection** in Studio. Het afbeeldingsbestand wordt
opgeslagen naast het geëxporteerde `.obj`-bestand.

De nieuwe textuur kan vervolgens naar Roblox worden geüpload als een decal en zijn
[asset-URI](/projects/assets#asset-uris) kan op de mesh worden toegepast met behulp van de `Class.MeshPart.TextureContent|TextureContent` of
`Class.MeshPart.TextureID|TextureID` eigenschap.

`Class.MeshPart.TextureContent|TextureContent` kan ook worden ingesteld om te verwijzen naar een
`Class.EditableImage` die nog niet is gepubliceerd.

```
local AssetService = game:GetService("AssetService")
local Workspace = game:GetService("Workspace")

local meshPart = Workspace.MeshPart

local editableImage = AssetService:CreateEditableImageAsync(meshPart.TextureContent)
meshPart.TextureContent = Content.fromObject(editableImage)  -- Live updates
```
Wanneer `Class.MeshPart.TextureContent|TextureContent` verwijst naar een
`Class.EditableImage`, wordt de textuur live bijgewerkt met eventuele bewerkingen aan de
`Class.EditableImage` object.

##### Een Geweven Mesh Maken

Een mesh kan alleen worden geweven als de mesh UV-gemapped is, wat verwijst naar
de praktijk van het projecteren van een textuurmap op een mesh. Dit kan niet worden gedaan
met Roblox Studio en moet worden gedaan met een externe 3D-modelleringsapplicatie zoals
[Blender](https://www.blender.org/).


MeshPart.TextureContent

De textuur die is toegepast op de `Class.MeshPart`. Ondersteunt
[asset-URI's](/projects/assets#asset-uris) en
`Class.EditableImage` objecten.


De textuur die is toegepast op de `Class.MeshPart`. Leest en schrijft naar
`Class.MeshPart.TextureContent|TextureContent`.

Wanneer deze eigenschap is ingesteld op een lege string, wordt er geen textuur toegepast
op de mesh.

```
local Workspace = game:GetService("Workspace")

local meshPart = Workspace.MeshPart
meshPart.TextureID = ""  -- Geen textuur
```
Let op dat de `Class.MeshPart.MeshId` eigenschap niet kan worden gewijzigd tijdens
runtime, maar de textuur kan dat wel. Zie
`Class.MeshPart.TextureContent|TextureContent` voor details.


MeshPart.TextureID

De textuur die is toegepast op de `Class.MeshPart`. Leest en schrijft naar
`Class.MeshPart.TextureContent|TextureContent`.


Een vorm van `Class.BasePart` die een fysiek gesimuleerde aangepaste mesh bevat.


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.


BasePart

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