A SkateboardPlatform can be used to create a skateboard. When characters get
on a skateboard, they are stuck to it until they press the escape key. Until
then, the character uses skateboard animations and travels faster than a
walking character.


SkateboardPlatform.Equipped

humanoid

The `Class.Humanoid` associated with the character equipping the
skateboard.


skateboardController

SkateboardPlatform.equipped

Fired when the SkateboardPlatform's
`Class.SkateboardPlatform.ControllingHumanoid` changes the force being
used on the SkateboardPlatform.


SkateboardPlatform.MoveStateChanged

newState

oldState

Fired whenever the skateboard is unequipped.


SkateboardPlatform.Unequipped

The `Class.Humanoid` associated with the character that unequipped the
skateboard.


SkateboardPlatform.unequipped

Adds ''impulseWorld'' to the SkateboardPlatform's
`Class.BasePart.Velocity`.


SkateboardPlatform:ApplySpecificImpulse

impulseWorld

SkateboardPlatform

The SkateboardPlatform's active SkateboardController.


SkateboardPlatform.Controller

The `Class.Humanoid` that is controlling the SkateboardPlatform.


SkateboardPlatform.ControllingHumanoid

The direction of movement, tied to the keys A and D. Must be 1 (right), 0
(straight), or -1 (left). Will refresh back to 0 unless constantly set.


SkateboardPlatform.Steer

If true, wheels won't roll without user input.


SkateboardPlatform.StickyWheels

The direction of movement, tied to the keys W and S. Must be an integer 1
(forward), 0 (null), or -1 (reverse). Will refresh back to 0 unless
constantly set.


SkateboardPlatform.Throttle

The script below spawns a new `Part` instance and sets several of the part's
properties.

Most notably, the script sets the `Class.Part.Shape` property to
`Enum.PartType.Ball`. It also names the part _JurassicPart_, anchors it, makes
it a child of _Workspace_, and sets its color to white.


The Part object is a type of `Class.BasePart`. It comes in five different
primitive shapes: Ball, Block, Cylinder, Wedge, and CornerWedge.


Part

The Shape property sets the overall shape of the object to one of a
predetermined list of built-in shapes.

The `Enum.PartType` enum controls the shape value, and has five possible
shapes:

| Shape/Value | Description                             |
| ----------- | --------------------------------------- |
| Ball        | A spherical shape.                      |
| Block       | A block shape.                          |
| Cylinder    | A cylinder shape.                       |
| Wedge       | A wedge shape with a slope on one side. |
| CornerWedge | A wedge shape with slopes on two sides. |

`Class.MeshPart` and [solid modeling](/parts/solid-modeling)
can be used to obtain completely custom part shapes.

Collisions between balls, blocks, and wedges, and corner wedges are exact,
whereas collisions between terrain, cylinders, TriangleMeshes, and other
geometry types are approximations. This means that the ball shape can be
useful to create stable colliders for car wheels.


Part.Shape

A common type of `Class.BasePart` that comes in different primitive shapes.


The FormFactorPart class is an abstract class. It inherits from the
`Class.BasePart` class and adds the `Class.FormFactorPart.FormFactor` property
to classes that inherit from it.


FormFactorPart

This used to specify a grid constraint of the part's size. No longer does
anything.


FormFactorPart.FormFactor

Determines how a part acts when resized and the values that which its size
can take.


FormFactorPart.formFactor

The FormFactorPart class is an abstract class. It inherits from the BasePart
class and adds the FormFactor property to classes that inherit from it.


Creates a blue part and red target Part. The blue part will try to smoothly
reach the red target part. Move and rotate the target to see the behavior.
Changing the smoothTime will result in different smoothing speed.


`Class.BasePart` is an abstract base class for in-world objects that render
and are physically simulated while in the `Class.Workspace`. There are several
implementations of `Class.BasePart`, the most common being `Class.Part` and
`Class.MeshPart`. Others include `Class.WedgePart`, `Class.SpawnLocation`, and
the singleton `Class.Terrain` object. Generally, when documentation refers to
a "part," most `Class.BasePart` implementations will work and not just
`Class.Part`.

For information on how `Class.BasePart|BaseParts` are grouped into simulated
rigid bodies, see [Assemblies](/physics/assemblies).

There are many different objects that interact with `Class.BasePart` (other
than `Class.Terrain`), including:

- Several `Class.BasePart|BaseParts` may be grouped within a `Class.Model` and
  moved at the same time using `Class.PVInstance:PivotTo()`. See
  [Models](/parts/models).
- A `Class.Decal` applies a stretched image texture to the faces of a
  `Class.BasePart`, while a `Class.Texture` applies a tiled image texture to
  the faces. See [Textures and Decals](/parts/textures-decals).
- A `Class.SurfaceGui` renders `Class.GuiObject|GuiObjects` on the face of a
  part. See
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` can be added to a `Class.BasePart` to specify
  `Datatype.CFrame|CFrames` relative to the part. These are often used by
  physical `Class.Constraint` objects as outlined in
  [Mechanical Constraints](/physics/mechanical-constraints) and
  [Mover Constraints](/physics/mover-constraints).
- `Class.ParticleEmitter` objects emit particles uniformly in the volume of
  the `Class.BasePart` to which they are parented. See
  [Particle Emitters](/effects/particle-emitters).
- Light objects like `Class.PointLight` emit light from the center of a
  `Class.BasePart` as illustrated in
  [Light Sources](/effects/light-sources).
- If parented to a `Class.Tool` and given the name **Handle**, a
  `Class.BasePart` can be held by characters. See
  [In-Experience Tools](/players/tools).


Fired when another part comes in contact with another object. This event
only sends data to the client notifying it that two parts have collided,
whereas `Class.BasePart.Touched` sends data to the server.


BasePart.LocalSimulationTouched

part

Fired if the part's appearance is affected by the `Class.Shirt` class.


BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

This code sample creates a BillboardGui on a part that displays the number of
parts presently touching it.


This code sample demonstrates how to connect the `Class.BasePart.Touched`
event of multiple parts in a `Class.Model` to one function.


The **Touched** event fires when a part comes in contact with another
part. For instance, if **PartA** bumps into **PartB**, then
`Class.BasePart.Touched|PartA.Touched` fires with **PartB**, and
`Class.BasePart.Touched|PartB.Touched` fires with **PartA**.

This event only fires as a result of physical movement, so it will not
fire if the `Class.BasePart.CFrame|CFrame` property was changed such that
the part overlaps another part. This also means that at least one of the
parts involved must **not** be `Class.BasePart.Anchored|Anchored` at the
time of the collision.

This event works in conjunction with
`Class.Workspace.TouchesUseCollisionGroups` to specify whether
[collision groups](/workspace/collisions#collision-filtering)
are acknowledged for detection.


BasePart.Touched

The other part that came in contact with the given part.


Fires when a part touches another part as a result of physical movement.


Fires when a part stops touching another part under similar conditions to
those of `Class.BasePart.Touched`.

This event works in conjunction with
`Class.Workspace.TouchesUseCollisionGroups` to specify whether
[collision groups](/workspace/collisions#collision-filtering)
are acknowledged for detection.


BasePart.TouchEnded

Fires when a part stops touching another part as a result of physical
movement.


Returns the world-space torque vector that must be applied to the part's
assembly to achieve the specified angular acceleration. This result can be
used to determine the torque that should be applied via a `Class.Torque`
instance or `Class.BasePart:ApplyAngularImpulse()`.

The calculation uses Euler's rotation equation where _I_ is the assembly's
world-space inertia tensor, _α_ is the desired angular acceleration, and
_ω_ is the angular velocity.

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

If the part is not a descendant of `Class.Workspace`, this method returns
a vector of infinity. If the assembly is anchored, it similarly returns a
vector of infinity.

#### Gyroscopic Effects

When a spinning assembly has an asymmetric inertia tensor, the torque
required to achieve a specified angular acceerlation is augmented due to
the changing orientation of the body. The optional `angVelocity` parameter
accounts for these gyroscopic effects. If omitted, these gyroscopic
effects are omitted from the calculation.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local desiredAcceleration = Vector3.new(0, 10, 0)

-- Compute the torque needed to achieve the desired acceleration
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```


BasePart:AngularAccelerationToTorque

angAcceleration

The desired angular acceleration vector in world space.


angVelocity

The current angular velocity of the assembly in world space. Defaults
to `(0, 0, 0)`. Supply the assembly's angular velocity to account for
gyroscopic effects.


A `Datatype.Vector3` representing the world-space torque required to
produce the specified angular acceleration.


Returns the torque needed to achieve a given angular acceleration on this
part's assembly, optionally accounting for gyroscopic effects.


Applies an instant angular force impulse to this part's assembly, causing
the assembly to spin.

The resulting angular velocity from the impulse relies on the assembly's
`Class.BasePart.AssemblyMass|mass`. So a higher impulse is required to
move more massive assemblies. Impulses are useful for cases where you want
a force applied instantly, such as an explosion or collision.

If the part is [owned](/physics/network-ownership) by the
server, this function must be called from a server `Class.Script` (not
from a `Class.LocalScript` or a `Class.Script` with
`Class.BaseScript.RunContext|RunContext` set to `Enum.RunContext.Client`).
If the part is owned by a client through **automatic** ownership, this
function can be called from either a client script **or** a server script;
calling it from a client script for a server-owned part will have no
effect.


BasePart:ApplyAngularImpulse

impulse

An angular impulse vector to be applied to the assembly.


Apply an angular impulse to the assembly.


This function applies an instant force impulse to this part's assembly.

The force is applied at the assembly's
`Class.BasePart.AssemblyCenterOfMass|center of mass`, so the resulting
movement will only be linear.

The resulting velocity from the impulse relies on the assembly's
`Class.BasePart.AssemblyMass|mass`. So a higher impulse is required to
move more massive assemblies. Impulses are useful for cases where you want
a force applied instantly, such as an explosion or collision.

If the part is [owned](/physics/network-ownership) by the
server, this function must be called from a server `Class.Script` (not
from a `Class.LocalScript` or a `Class.Script` with
`Class.BaseScript.RunContext|RunContext` set to `Enum.RunContext.Client`).
If the part is owned by a client through **automatic** ownership, this
function can be called from either a client script **or** a server script;
calling it from a client script for a server-owned part will have no
effect.


BasePart:ApplyImpulse

A linear impulse vector to be applied to the assembly.


Apply an impulse to the assembly at the assembly's
`Class.BasePart.AssemblyCenterOfMass|center of mass`.


This function applies an instant force impulse to this part's assembly, at
the specified position in world space.

If the position is not at the assembly's
`Class.BasePart.AssemblyCenterOfMass|center of mass`, the impulse will
cause a positional and rotational movement.

The resulting velocity from the impulse relies on the assembly's
`Class.BasePart.AssemblyMass|mass`. So a higher impulse is required to
move more massive assemblies. Impulses are useful for cases where
developers want a force applied instantly, such as an explosion or
collision.

If the part is [owned](/physics/network-ownership) by the
server, this function must be called from a server `Class.Script` (not
from a `Class.LocalScript` or a `Class.Script` with
`Class.BaseScript.RunContext|RunContext` set to `Enum.RunContext.Client`).
If the part is owned by a client through **automatic** ownership, this
function can be called from either a client script **or** a server script;
calling it from a client script for a server-owned part will have no
effect.


BasePart:ApplyImpulseAtPosition

An impulse vector to be applied to the assembly.


position

The position, in world space, to apply the impulse.


Apply an impulse to the assembly at specified position.


Breaks any surface connection with any adjacent part, including
`Class.Weld` and other `Class.JointInstance`.


BasePart:BreakJoints

BasePart:breakJoints

Returns whether the parts can collide with each other or not. This
function takes into account the collision groups of the two parts. This
function will error if the specified part is not a BasePart.


BasePart:CanCollideWith

The specified part being checked for collidability.


Whether the parts can collide with each other.


Returns whether the parts can collide with each other.


This example checks whether or not the network ownership of the first
`BasePart` named _Part_ in the `Workspace` can be set.


The CanSetNetworkOwnership function checks whether you can set a part's
network ownership.

The function's return value verifies whether or not you can call
`Class.BasePart:SetNetworkOwner()` or
`Class.BasePart:SetNetworkOwnershipAuto()` without encountering an error.
It returns true if you can modify/read the network ownership, or returns
false and the reason you can't, as a string.


BasePart:CanSetNetworkOwnership

Whether you can modify or read the network ownership and the reason.


Checks whether you can set a part's network ownership.


Returns the closest point on the part's surface to the given world-space
position. If the provided position is inside the part, it is returned
as-is.

For `Class.MeshPart` and `Class.PartOperation` instances, this method
respects the part's `Enum.CollisionFidelity` value. Return values can
differ based on whether the mesh is being treated as a box, a hull, or a
more complex shape.


BasePart:GetClosestPointOnSurface

The world-space point to find the closest surface point to.


The closest point on the part's surface in world space.


Returns the closest point on the part's surface to the given point.


Returns a table of parts connected to the object by any kind of rigid
joint.

If `recursive` is true this function will return all of the parts in the
assembly rigidly connected to the BasePart.

#### Rigid Joints

When a joint connects two parts together `(Part0 → Part1)`, a joint is
**rigid** if the physics of `Part1` are completely locked down by `Part0`.
This only applies to the following joint types:

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


BasePart:GetConnectedParts

recursive

A table of parts connected to the object by any kind of
`Class.JointInstance|joint`.


Returns a table of parts connected to the object by any kind of rigid
joint.


Return all Joints or Constraints that is connected to this Part.


BasePart:GetJoints

An array of all Joints or Constraints connected to the Part.


This example creates a new part, myPart, in the game's Workspace, with
dimensions 4x6x4 studs. The part is also anchored.

Then, myMass is set to equal the mass of the new part. The mass of the part is
printed at the end of the print statement:

> My part's mass is ...


**GetMass** returns the value of the read-only `Class.BasePart.Mass|Mass`
property.

This function predates the Mass property. It remains supported for
backward-compatibility; you should use the Mass property directly.


BasePart:GetMass

Returns the value of the `Class.BasePart.Mass|Mass` property.


BasePart:getMass

Returns the current player who is the network owner of this part, or `nil`
in case of the server.


BasePart:GetNetworkOwner

The current player who is the network owner of this part, or `nil` in
case of the server.


Returns true if the game engine automatically decides the network owner
for this part.


BasePart:GetNetworkOwnershipAuto

Whether the game engine automatically decides the network owner for
this part.


BasePart:GetNoCollisionConstraints

This function used to be relevant when Roblox's lag-compensating
interpolation of parts online was internal. The interpolation is now
applied to the `Datatype.CFrame` directly.


BasePart:GetRenderCFrame

OBSOLETE. Returns a CFrame describing where the part is being rendered at.


Returns the base part of an assembly. When moving an assembly of parts
using a `Datatype.CFrame`. it is important to move this base part (this
will move all other parts connected to it accordingly). More information
is available in the [Assemblies](/physics/assemblies) article.

This function predates the
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` property. It remains
supported for backwards compatibility, but you should use
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` directly.


BasePart:GetRootPart

The base part of an assembly (a collection of parts connected
together).


Returns the base part of an assembly of parts.


Returns a table of all parts that are physically interacting with this
part. If the part itself has CanCollide set to false, then this function
returns an empty table unless the part has a
`Class.TouchTransmitter|TouchInterest` object parented to it (meaning
something is connected to its Touched event). Parts that are adjacent but
not intersecting are not considered touching. This function predates the
`Class.WorldRoot:GetPartsInPart()` function, which provides more
flexibility and avoids the special `Class.TouchTransmitter|TouchInterest`
rules described above. Use `Class.WorldRoot:GetPartsInPart()` instead.


BasePart:GetTouchingParts

A table of all parts that intersect and can collide with this part.


Returns a table of all `Class.BasePart.CanCollide` true parts that
intersect with this part.


Returns the linear velocity of the part's assembly at the given position
relative to this part. It can be used to identify the linear velocity of
parts in an assembly other than the root part. If the assembly has no
angular velocity, than the linear velocity will always be the same for
every position.


BasePart:GetVelocityAtPosition

Returns the linear velocity of the part's assembly at the given position
relative to this part.


Creates a new `Class.IntersectOperation` from the intersecting geometry of
the part and the other parts in the given array. Only `Class.Part|Parts`
are supported, not `Class.Terrain` or `Class.MeshPart|MeshParts`. Similar
to `Class.Instance:Clone()|Clone()`, the returned object has no set
`Class.Instance.Parent|Parent`.

The following properties from the calling part are applied to the
resulting `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`

In the following image comparison,
`Class.BasePart:IntersectAsync()|IntersectAsync()` is called on the purple
block using a table containing the blue block. The resulting
`Class.IntersectOperation` resolves into a shape of the intersecting
geometry of both parts.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Two block parts overlapping" />
<figcaption>Separate parts</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="Parts intersected into a new solid model" />
<figcaption>Resulting <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Notes

- The original parts remain intact following a successful intersect
  operation. In most cases, you should `Class.Instance.Destroy|Destroy()`
  all of the original parts and parent the returned
  `Class.IntersectOperation` to the same place as the calling
  `Class.BasePart`.
- By default, the face colors of the resulting intersection are borrowed
  from the `Class.BasePart.Color|Color` property of the original parts. To
  change the entire intersection to a specific color, set its
  `Class.PartOperation.UsePartColor|UsePartColor` property to `true`.
- If an intersect operation would result in a part with more than 20,000
  triangles, it will be simplified to 20,000 triangles.


BasePart:IntersectAsync

parts

The objects taking part in the intersection.


collisionfidelity

The `Enum.CollisionFidelity` value for the resulting
`Class.IntersectOperation`.


renderFidelity

The `Enum.RenderFidelity` value of the resulting
`Class.PartOperation`.


Resulting `Class.IntersectOperation` with default name **Intersect**.


Note: It is highly recommended to use the newer
`Class.GeometryService:IntersectAsync` instead of this function. As well
as having better performance and more features, the new function differs
as follows:

- The output is an array of instances rather than a single instance.
- The input parts do not need to be parented to the scene, allowing for
  background operations.
- When the `SplitApart` option is set to `true` (default), each distinct
  body will be returned in its own `Class.PartOperation`.
- All the returned parts are in the coordinate space of the main part, so
  their `Class.PVInstance.Origin` positions are the same as the main
  part's. This keeps the vertices of the mesh in the same position
  relative to the object as before the operation, but it does also mean
  the `(0, 0, 0)` of a returned part is not necessarily at the center of
  its body.

  Creates a new `Class.IntersectOperation` from the overlapping geometry
  of the part and the other parts in the given array.


Returns true if the object is connected to a part that will hold it in
place (eg an `Class.BasePart.Anchored|Anchored` part), otherwise returns
false. In an assembly that has an `Class.BasePart.Anchored|Anchored` part,
every other part is grounded.


BasePart:IsGrounded

Whether the object is connected to a part that will hold it in place.


Returns true if the object is connected to a part that will hold it in
place (eg an `Class.BasePart.Anchored|Anchored` part), otherwise returns
false.


Creates a joint on any side of the `Class.BasePart|Part` that has a
`Enum.SurfaceType` that can make a joint it will create a joint with any
adjacent parts.

Joints will be created between the sides and any planar touching surfaces,
depending on the sides' surfaces.

- Smooth surfaces will not create joints
- Glue surfaces will create a `Class.Glue` joint
- Weld will create a `Class.Weld` joint with any surface except for
  Unjoinable
- Studs, Inlet, or Universal will each create a `Class.Snap` joint with
  either of other the other two surfaces (e.g. Studs with Inlet and
  Universal)
- Hinge and Motor surfaces create `Class.Rotate` and `Class.RotateV` joint
  instances

Unlike `Class.Model:MakeJoints()`, this function requires an array of
parts as a parameter. This array is given as follows:

```
part:MakeJoints({part1, part2, part3})
```

Joints are broken if enough force is applied to them due to an
`Class.Explosion`, unless a `Class.ForceField` object is parented to the
`Class.BasePart` or ancestor `Class.Model`. For this reason, they are
often used to make simple destructible buildings and other models.


BasePart:MakeJoints

Creates a joint on any side of the object that has a surface ID that can
make a joint.


BasePart:makeJoints

Changes the size of an object just like using the Studio resize tool.


BasePart:Resize

normalId

deltaAmount

How much to grow/shrink on the specified side.


BasePart:resize

Sets the given player as network owner for this and all connected parts.
When playerInstance is `nil`, the server will be the owner instead of a
player.


BasePart:SetNetworkOwner

playerInstance

The player being given network ownership of the part.


Sets the given player as network owner for this and all connected parts.


Lets the game engine dynamically decide who will handle the part's physics
(one of the clients or the server).


BasePart:SetNetworkOwnershipAuto

This example demonstrates how to subtract part(s) from another
`Class.BasePart` to form a negated `Class.UnionOperation`.


Creates a new `Class.UnionOperation` from the part, minus the geometry
occupied by the parts in the given array. Only `Class.Part|Parts` are
supported, not `Class.Terrain` or `Class.MeshPart|MeshParts`. Similar to
`Class.Instance:Clone()|Clone()`, the returned object has no set
`Class.Instance.Parent|Parent`.

Note that the resulting union cannot be empty due to subtractions. If the
operation would result in completely empty geometry, it will fail.

In the following image comparison,
`Class.BasePart:SubtractAsync()|SubtractAsync()` is called on the blue
cylinder using a table containing the purple block. The resulting
`Class.UnionOperation` resolves into a shape that omits the block's
geometry from that of the cylinder.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Longer block overlapping a cylinder" />
<figcaption>Separate parts</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Block part subtracted from cylinder" />
<figcaption>Resulting <code>Class.UnionOperation</code></figcaption>
</figure>


BasePart:SubtractAsync

The objects taking part in the subtraction.


The `Enum.CollisionFidelity` value for the resulting
`Class.UnionOperation`.


Resulting `Class.UnionOperation` with default name **Union**.


Note: It is highly recommended to use the newer
`Class.GeometryService:UnionAsync` instead of this function. As well as
having better performance and more features, the new function differs as
follows:

- The output is an array of instances rather than a single instance.
- The input parts do not need to be parented to the scene, allowing for
  background operations.
- When the `SplitApart` option is set to `true` (default), each distinct
  body will be returned in its own `Class.PartOperation`.
- All the returned parts are in the coordinate space of the main part, so
  their `Class.PVInstance.Origin` positions are the same as the main
  part's. This keeps the vertices of the mesh in the same position
  relative to the object as before the operation, but it does also mean
  the `(0, 0, 0)` of a returned part is not necessarily at the center of
  its body.

  Creates a new `Class.UnionOperation` from the part, minus the geometry
  occupied by the parts in the given array.


Returns the world-space angular acceleration that would result from
applying the specified torque to the part's assembly, optionally taking
into account gyroscopic effects.

This is the inverse of `Class.BasePart:AngularAccelerationToTorque()`. It
is useful for predicting how an assembly will respond to an applied
torque.

The calculation uses:

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

where **I** is the assembly's world-space inertia tensor, **τ** is the
applied torque, and **ω** is the angular velocity.

If the part is not a descendant of `Class.Workspace`, returns `(0, 0, 0)`.
If the assembly is anchored, returns `(0, 0, 0)`.

#### Gyroscopic Effects

When a spinning assembly has an asymmetric inertia tensor, the
acceleration resulting from an applied torque also depends on the current
angular velocity. The `angVelocity` parameter accounts for these
gyroscopic effects. If omitted (defaults to zero), the result neglects
this contribution from the result.

```lua
local part = workspace.Part
local angularVelocity = part.AssemblyAngularVelocity
local appliedTorque = Vector3.new(0, 100, 0)

-- Predict the angular acceleration from this torque
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```


BasePart:TorqueToAngularAcceleration

torque

The torque vector applied to the assembly in world space.


A `Datatype.Vector3` representing the resulting angular acceleration
in world space.


Returns the angular acceleration that would result from applying a given
torque to this part's assembly, optionally accounting for gyroscopic
effects.


This example demonstrates how to combine the geometry of one `Class.BasePart`
with the geometry of other part(s) to form a `Class.UnionOperation`.


Creates a new `Class.UnionOperation` from the part, plus the geometry
occupied by the parts in the given array. Only `Class.Part|Parts` are
supported, not `Class.Terrain` or `Class.MeshPart|MeshParts`. Similar to
`Class.Instance:Clone()|Clone()`, the returned object has no set
`Class.Instance.Parent|Parent`.

The following properties from the calling part are applied to the
resulting `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`

In the following image comparison,
`Class.BasePart:UnionAsync()|UnionAsync()` is called on the blue block
using a table containing the purple cylinder. The resulting
`Class.UnionOperation` resolves into a shape of the combined geometry of
both parts.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Block and cylinder parts overlapping" />
<figcaption>Separate parts</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Parts joined together into a single solid union" />
<figcaption>Resulting <code>Class.UnionOperation</code></figcaption>
</figure>

#### Notes

- The original parts remain intact following a successful union operation.
  In most cases, you should `Class.Instance.Destroy|Destroy()` all of the
  original parts and parent the returned `Class.UnionOperation` to the
  same place as the calling `Class.BasePart`.
- By default, the resulting union respects the
  `Class.BasePart.Color|Color` property of each of its parts. To change
  the entire union to a specific color, set its
  `Class.PartOperation.UsePartColor|UsePartColor` property to `true`.
- If a union operation would result in a part with more than 20,000
  triangles, it will be simplified to 20,000 triangles.


BasePart:UnionAsync

The objects taking part in the union with the calling part.


Note: It is highly recommended to use the newer
`Class.GeometryService:UnionAsync` instead of this function. As well as
having better performance and more features, the new function differs as
follows:

- The output is an array of instances rather than a single instance.
- The input parts do not need to be parented to the scene, allowing for
  background operations.
- When the `SplitApart` option is set to `true` (default), each distinct
  body will be returned in its own `Class.PartOperation`.
- All the returned parts are in the coordinate space of the main part, so
  their `Class.PVInstance.Origin` positions are the same as the main
  part's. This keeps the vertices of the mesh in the same position
  relative to the object as before the operation, but it does also mean
  the `(0, 0, 0)` of a returned part is not necessarily at the center of
  its body.

        Creates a new `Class.UnionOperation` from the part, plus the geometry

  occupied by the parts in the given array.


BasePart

This code sample will allow a part to be clicked to toggle its anchored
property. When toggled, the visual appearance of the part is updated (red
means anchored, yellow means free).


The `Anchored` property determines whether the part will be immovable by
physics. When enabled, a part will never change position due to gravity,
other part collisions, overlapping other parts, or any other
physics-related causes. As a result, two anchored parts will never fire
the `Class.BasePart.Touched|Touched` event on each other.

An anchored part may still be moved by changing its
`Class.BasePart.CFrame|CFrame` or `Class.BasePart.Position|Position`, and
it still may have a nonzero
`Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` and
`Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity`.

Finally, if an unanchored part is joined with an anchored part through an
object like a `Class.Weld`, it too will act anchored. If such a joint
breaks, the part may be affected by physics again. See
[Assemblies](/physics/assemblies) for more details.

Network ownership cannot be set on anchored parts. If a part's anchored
status changes on the server, the network ownership of that part will be
affected.


BasePart.Anchored

Determines whether a part is immovable by physics.


The angular velocity vector of this part's assembly. It's the rate of
change of orientation in radians per second.

Angular velocity is the same at every point of the assembly.

Setting the velocity directly may lead to unrealistic motion. Using
`Class.Torque` or `Class.AngularVelocity` constraint is preferred, or use
`Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` if you want
instantaneous change in velocity.

If the part is [owned](/physics/network-ownership) by the
server, this property must be changed from a server `Class.Script` (not
from a `Class.LocalScript` or a `Class.Script` with
`Class.BaseScript.RunContext|RunContext` set to `Enum.RunContext.Client`).
If the part is owned by a client through **automatic** ownership, this
property can be changed from either a client script **or** a server
script; changing it from a client script for a server-owned part will have
no effect.


BasePart.AssemblyAngularVelocity

The angular velocity of the part's assembly.


A position calculated via the `Class.BasePart.Mass|Mass` and
`Class.BasePart.Position|Position` of all the parts in the assembly.

If the assembly has an anchored part, that part's center of mass will be
the assembly's center of mass, and the assembly will have infinite mass.

Knowing the center of mass can help the assembly maintain stability. A
force applied to the center of mass will not cause angular acceleration,
only linear. An assembly with a low center of mass will have a better time
staying upright under the effect of gravity.


BasePart.AssemblyCenterOfMass

The center of mass of the part's assembly in world space.


The linear velocity vector of this part's assembly. It's the rate of
change in position of
`Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` in studs per
second.

If you want to know the velocity at a point other than the assembly's
center of mass, use
`Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Setting the velocity directly may lead to unrealistic motion. Using a
`Class.VectorForce` constraint is preferred, or use
`Class.BasePart:ApplyImpulse()|ApplyImpulse()` if you want instantaneous
change in velocity.

If the part is [owned](/physics/network-ownership) by the
server, this property must be changed from a server `Class.Script` (not
from a `Class.LocalScript` or a `Class.Script` with
`Class.BaseScript.RunContext|RunContext` set to `Enum.RunContext.Client`).
If the part is owned by a client through **automatic** ownership, this
property can be changed from either a client script **or** a server
script; changing it from a client script for a server-owned part will have
no effect.


BasePart.AssemblyLinearVelocity

The linear velocity of the part's assembly.


The sum of the mass of all the `Class.BasePart|BaseParts` in this part's
assembly. Parts that are `Class.BasePart.Massless|Massless` and are not
the assembly's root part will not contribute to the `AssemblyMass`.

If the assembly has an anchored part, the assembly's mass is considered
infinite. Constraints and other physical interactions between unanchored
assemblies with a large difference in mass may cause instabilities.


BasePart.AssemblyMass

This property indicates the `Class.BasePart` automatically chosen to
represent the assembly's root part. If the part is not parented to the
`Class.Workspace`, this property will be `nil`.

The root part can be changed by changing the
`Class.BasePart.RootPriority|RootPriority` of the parts in the assembly.

Parts that all share the same `AssemblyRootPart` are in the same assembly.

For more information on root parts, see
[Assemblies](/physics/assemblies).


BasePart.AssemblyRootPart

A reference to the root part of the assembly.


The abstract base class for in-world objects that physically interact.


/reference/engine/classes/SkateboardPlatform.yaml