Dit is een hoekstuk dat dezelfde eigenschappen heeft als een `Class.Part`.


CornerWedgePart

Een type `Class.BasePart` dat een hoekwigvorm heeft.


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

Dit codevoorbeeld stelt een deel in staat om geklikt te worden om de verankerde
eigenschap te wisselen. Wanneer gewisseld, wordt het visuele uiterlijk van het deel bijgewerkt (rood
betekent verankerd, geel betekent vrij).


De `Anchored` eigenschap bepaalt of het deel niet verplaatsbaar zal zijn door
fysica. Wanneer ingeschakeld, zal een deel nooit van positie veranderen door de zwaartekracht,
andere deelbotsingen, overlappen met andere delen, of andere fysica-gerelateerde oorzaken. Als gevolg hiervan zullen twee verankerde delen nooit de `Class.BasePart.Touched|Touched` gebeurtenis op elkaar activeren.

Een verankerd deel kan nog steeds worden verplaatst door zijn
`Class.BasePart.CFrame|CFrame` of `Class.BasePart.Position|Position` te veranderen, en
het kan nog steeds een niet-nul
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` en
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` hebben.

Ten slotte, als een niet-verankerd deel is verbonden met een verankerd deel via een
object zoals een `Class.Weld`, zal het ook als verankerd functioneren. Als zo'n verbinding
breekt, kan het deel weer door de fysica worden beïnvloed. Zie
[Assemblies](/physics/assemblies) voor meer details.

Netwerkbezit kan niet worden ingesteld op verankerde delen. Als de verankerde
status van een deel verandert op de server, zal het netwerkbezit van dat deel worden
beïnvloed.


BasePart.Anchored

Bepaalt of een deel niet verplaatsbaar is door de fysica.


De hoeksnelheidsvector van de assemblage van dit deel. Het is de snelheid van
verandering van oriëntatie in radialen per seconde.

De hoeksnelheid is hetzelfde op elk punt van de assemblage.

Het direct instellen van de snelheid kan leiden tot onrealistische beweging. Het gebruik van
`Class.Torque` of `Class.AngularVelocity` beperking heeft de voorkeur, of gebruik
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` als je een onmiddellijke verandering in snelheid wilt.

Als het deel [eigendom](/physics/network-ownership) is van de
server, moet deze eigenschap worden gewijzigd 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 deel eigendom is van een client via **automatische** eigendom, kan deze
eigenschap worden gewijzigd vanuit een clientscript **of** een serverscript; het wijzigen ervan vanuit een clientscript voor een server-eigendom deel heeft geen effect.


BasePart.AssemblyAngularVelocity

De hoeksnelheid van de assemblage van het deel.


Een positie berekend via de `Class.BasePart.Mass|Mass` en
`Class.BasePart.Position|Position` van alle delen in de assemblage.

Als de assemblage een verankerd deel heeft, zal het zwaartepunt van dat deel het
zwaartepunt van de assemblage zijn, en de assemblage zal een oneindige massa hebben.

Het kennen van het zwaartepunt kan helpen om de assemblage stabiel te houden. Een
kracht die op het zwaartepunt wordt toegepast, zal geen hoeksversnelling veroorzaken,
alleen lineaire. Een assemblage met een laag zwaartepunt zal beter in staat zijn
om rechtop te blijven onder invloed van de zwaartekracht.


BasePart.AssemblyCenterOfMass

Het zwaartepunt van de assemblage van het deel in wereldruimte.


De lineaire snelheid vector van de assemblage van dit deel. Het is de snelheid van
verandering in positie van
`Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` in studs per
seconde.

Als je de snelheid op een punt anders dan het zwaartepunt van de assemblage wilt weten, gebruik
`Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Het direct instellen van de snelheid kan leiden tot onrealistische beweging. Het gebruik van een
`Class.VectorForce` beperking heeft de voorkeur, of gebruik
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` als je een onmiddellijke
verandering in snelheid wilt.

Als het deel [eigendom](/physics/network-ownership) is van de
server, moet deze eigenschap worden gewijzigd 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 deel eigendom is van een client via **automatische** eigendom, kan deze
eigenschap worden gewijzigd vanuit een clientscript **of** een serverscript; het wijzigen ervan vanuit een clientscript voor een server-eigendom deel heeft geen effect.


BasePart.AssemblyLinearVelocity

De lineaire snelheid van de assemblage van het deel.


De som van de massa van alle `Class.BasePart|BaseParts` in de assemblage van dit deel. Delen die `Class.BasePart.Massless|Massless` zijn en niet de root van de assemblage zijn, zullen niet bijdragen aan de `AssemblyMass`.

Als de assemblage een verankerd deel heeft, wordt de massa van de assemblage als oneindig beschouwd. Beperkingen en andere fysieke interacties tussen niet-verankerde assemblages met een groot verschil in massa kunnen instabiliteit veroorzaken.


BasePart.AssemblyMass

De totale massa van de assemblage van het deel.


Deze eigenschap geeft het `Class.BasePart` aan dat automatisch is gekozen om
het rootdeel van de assemblage te vertegenwoordigen. Als het deel niet is gekoppeld aan de
`Class.Workspace`, zal deze eigenschap `nil` zijn.

Het rootdeel kan worden gewijzigd door de
`Class.BasePart.RootPriority|RootPriority` van de delen in de assemblage te wijzigen.

Delen die allemaal hetzelfde `AssemblyRootPart` delen, bevinden zich in dezelfde assemblage.

Voor meer informatie over rootdelen, zie
[Assemblies](/physics/assemblies).


BasePart.AssemblyRootPart

Een verwijzing naar het rootdeel van de assemblage.


`AudioCanCollide` bepaalt of het deel fysiek zal interageren
met audio-simulatie, vergelijkbaar met `Class.BasePart.CastShadow|CastShadow`
voor verlichting.

Wanneer uitgeschakeld, gaat audio door het deel heen; het wordt niet geblokkeerd of
weerspiegeld.


BasePart.AudioCanCollide

Bepaalt of het deel fysiek zal interageren met audio-simulatie,
vergelijkbaar met `Class.BasePart.CastShadow|CastShadow` voor verlichting.


Dit codevoorbeeld demonstreert hoe oppervlakte-eigenschappen kunnen worden ingesteld met alleen een
NormalId (Boven, Voor, enz.). Het schakelt de -SurfaceInput van een motor van NoInput,
Constant en Sin om te laten zien hoe elk werkt met behulp van de -ParamA en -ParamB-eigenschappen.


De `BackParamA` eigenschap is relevant wanneer de `Class.BasePart.BackSurface`
is ingesteld op Motor of SteppingMotor en `Class.BasePart.BackSurfaceInput`
is ingesteld op Sin. Het bepaalt de **amplitude** van de rotatiesnelheid van de motor.


BasePart.BackParamA

Bepaalt de eerste parameter voor het SurfaceType op de achterkant van een
deel.


De `BackParamB` eigenschap is relevant wanneer de `Class.BasePart.BackSurface`
is ingesteld op Motor of SteppingMotor en `Class.BasePart.BackSurfaceInput`
is ingesteld op Constant of Sin. Voor Constant,
bepaalt het de constante rotatiesnelheid van de motor. Voor Sin, bepaalt het de **frequentie** van de rotatiesnelheid van de motor.


BasePart.BackParamB

Bepaalt de tweede parameter voor het SurfaceType op de achterkant van een
deel.


De `BackSurface` eigenschap bepaalt het type oppervlak dat wordt gebruikt voor de
positieve **Z** richting van een deel. Wanneer de vlakken van twee delen naast elkaar
worden geplaatst, kunnen ze een verbinding tussen hen creëren.


BasePart.BackSurface

Bepaalt het type oppervlak voor de achterkant van een deel.


De `BackSurfaceInput` eigenschap bepaalt het soort invoer dat aan een
`Class.BasePart.BackSurface` van een deel wordt gegeven. Dit is alleen relevant voor Motor of
SteppingMotor SurfaceTypes. Deze eigenschap bepaalt hoe
`Class.BasePart.BackParamA` en `Class.BasePart.BackParamB` worden gebruikt. Voor
kortheid zullen deze eigenschappen worden aangeduid als ParamA en ParamB,
respectievelijk.

- Standaard is dit ingesteld op NoInput. Dit stopt de motor volledig.
- Voor Constant draait de motor met een constante snelheid gelijk aan
  `ParamB`.
- Voor Sin draait de motor met een snelheid gelijk aan
  `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. Zie
  `Class.Workspace.DistributedGameTime`.


BasePart.BackSurfaceInput

Bepaalt het soort invoer voor de achterkant van een deel.


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


/reference/engine/classes/CornerWedgePart.yaml