Um tipo de `Class.BasePart` que tem uma forma de cunha. WedgeParts são ótimos para
construir rampas por causa de sua superfície inclinada. Eles podem até ser girados
sobre sua inclinação para que possam ser usados em um ângulo para fazer uma rampa
triangular. WedgeParts podem ser ajustados para qualquer tamanho que um tijolo
normal pode, de modo que possam ser alinhados com o restante do seu trabalho de
construção. WedgeParts, quando usados um ao lado do outro em ângulos diferentes,
também podem fazer ótimas rampas curvadas sem a necessidade de CFrame também.


WedgePart

Um tipo de `Class.BasePart` que tem uma forma de cunha.


A classe FormFactorPart é uma classe abstrata. Ela herda da
`Class.BasePart` e adiciona a propriedade `Class.FormFactorPart.FormFactor`
 às classes que dela herdam.


FormFactorPart

Isso costumava especificar uma restrição de grade do tamanho da parte. Não faz mais
nada.


FormFactorPart.FormFactor

Determina como uma parte age quando redimensionada e os valores que seu tamanho
pode assumir.


FormFactorPart.formFactor

A classe FormFactorPart é uma classe abstrata. Ela herda da classe BasePart
 e adiciona a propriedade FormFactor às classes que dela herdam.


Cria uma peça azul e uma peça alvo vermelha. A peça azul tentará suavemente
atingir a peça alvo vermelha. Mova e rotacione o alvo para ver o comportamento.
Mudar o smoothTime resultará em diferentes velocidades de suavização.


`Class.BasePart` é uma classe base abstrata para objetos no mundo que renderizam
 e são simulados fisicamente enquanto estão no `Class.Workspace`. Existem várias
 implementações de `Class.BasePart`, as mais comuns sendo `Class.Part` e
 `Class.MeshPart`. Outras incluem `Class.WedgePart`, `Class.SpawnLocation` e
 o objeto singleton `Class.Terrain`. Geralmente, quando a documentação se refere a
 um "parte", a maioria das implementações de `Class.BasePart` funcionará e não apenas
 `Class.Part`.

Para informações sobre como `Class.BasePart|BaseParts` são agrupados em corpos
 rígidos simulados, veja [Assemblies](/physics/assemblies).

Existem muitos objetos diferentes que interagem com `Class.BasePart` (exceto
 `Class.Terrain`), incluindo:

- Várias `Class.BasePart|BaseParts` podem ser agrupadas dentro de um `Class.Model` e
  movidas ao mesmo tempo usando `Class.PVInstance:PivotTo()`. Veja
  [Models](/parts/models).
- Um `Class.Decal` aplica uma textura de imagem esticada às faces de um
  `Class.BasePart`, enquanto um `Class.Texture` aplica uma textura de imagem
  em ladrilho às faces. Veja [Textures and Decals](/parts/textures-decals).
- Um `Class.SurfaceGui` renderiza `Class.GuiObject|GuiObjects` na face de um
  parte. Veja
  [In-Experience UI Containers](/ui/in-experience-containers).
- `Class.Attachment|Attachments` podem ser adicionados a um `Class.BasePart` para especificar
  `Datatype.CFrame|CFrames` em relação à parte. Esses são frequentemente usados por
  objetos físicos `Class.Constraint`, conforme descrito em
  [Mechanical Constraints](/physics/mechanical-constraints) e
  [Mover Constraints](/physics/mover-constraints).
- Objetos `Class.ParticleEmitter` emitem partículas uniformemente no volume do
  `Class.BasePart` ao qual estão conectados. Veja
  [Particle Emitters](/effects/particle-emitters).
- Objetos de luz como `Class.PointLight` emitem luz do centro de um
  `Class.BasePart`, como ilustrado em
  [Light Sources](/effects/light-sources).
- Se conectado a um `Class.Tool` e dado o nome **Handle**, um
  `Class.BasePart` pode ser segurado por personagens. Veja
  [In-Experience Tools](/players/tools).

Disparado quando outra peça entra em contato com outro objeto. Este evento
apenas envia dados ao cliente notificando que duas peças colidiram,
 enquanto `Class.BasePart.Touched` envia dados ao servidor.

BasePart.LocalSimulationTouched

part

Disparado se a aparência da peça for afetada pela classe `Class.Shirt`.

BasePart.OutfitChanged

BasePart.StoppedTouching

otherPart

Este exemplo de código cria um BillboardGui em uma parte que exibe o número de
partes que atualmente estão em contato com ela.

Este exemplo de código demonstra como conectar o evento `Class.BasePart.Touched`
de várias partes em um `Class.Model` a uma função.


O evento **Touched** dispara quando uma peça entra em contato com outra
peça. Por exemplo, se **PartA** colidir com **PartB**, então
`Class.BasePart.Touched|PartA.Touched` dispara com **PartB**, e
`Class.BasePart.Touched|PartB.Touched` dispara com **PartA**.

Este evento só disparará como resultado do movimento físico, assim não disparará
se a propriedade `Class.BasePart.CFrame|CFrame` foi alterada de tal forma que
 a peça se sobreponha a outra peça. Isso também significa que pelo menos uma das
 peças envolvidas deve **não** estar `Class.BasePart.Anchored|Anchored` no
 momento da colisão.

Este evento funciona em conjunto com
`Class.Workspace.TouchesUseCollisionGroups` para especificar se
[grupos de colisão](/workspace/collisions#collision-filtering)
são reconhecidos para a detecção.

BasePart.Touched

A outra peça que entrou em contato com a peça dada.

Dispara quando uma peça toca outra peça como resultado do movimento físico.

Dispara quando uma peça para de tocar outra peça em condições similares à
quelas de `Class.BasePart.Touched`.

Este evento funciona em conjunto com
`Class.Workspace.TouchesUseCollisionGroups` para especificar se
[grupos de colisão](/workspace/collisions#collision-filtering)
são reconhecidos para a detecção.

BasePart.TouchEnded

Dispara quando uma peça para de tocar outra peça como resultado do movimento físico.

Retorna o vetor de torque em espaço mundial que deve ser aplicado na montagem da
peça para alcançar a aceleração angular especificada. Este resultado pode ser
usado para determinar o torque que deve ser aplicado através de uma
instância `Class.Torque` ou `Class.BasePart:ApplyAngularImpulse()`.

O cálculo utiliza a equação de rotação de Euler onde _I_ é o tensor de inércia
da montagem no espaço mundial, _α_ é a aceleração angular desejada e
_ω_ é a velocidade angular.

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

Se a peça não for um descendente de `Class.Workspace`, este método retorna
um vetor de infinito. Se a montagem estiver ancorada, também retorna um
vetor de infinito.

#### Efeitos Giroscópicos

Quando uma montagem giratória tem um tensor de inércia assimétrico, o torque
necessário para alcançar uma aceleração angular especificada é aumentado devido
a orientação em mudança do corpo. O parâmetro opcional `angVelocity`
contabiliza esses efeitos giroscópicos. Se omitido, esses efeitos giroscópicos
são omitidos do cálculo.

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

-- Computa o torque necessário para alcançar a aceleração desejada
local torque = part:AngularAccelerationToTorque(desiredAcceleration, angularVelocity)
```

BasePart:AngularAccelerationToTorque

angAcceleration

O vetor de aceleração angular desejada em espaço mundial.

angVelocity

A velocidade angular atual da montagem em espaço mundial. Por padrão
é igual a `(0, 0, 0)`. Forneça a velocidade angular da montagem para levar em
conta efeitos giroscópicos.

Um `Datatype.Vector3` representando o torque em espaço mundial necessário para
produzir a aceleração angular especificada.

Retorna o torque necessário para alcançar uma determinada aceleração angular na
montagem desta peça, contabilizando opcionalmente efeitos giroscópicos.

Aplica um impulso de força angular instantânea na montagem desta peça, fazendo
com que a montagem gire.

A velocidade angular resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
da montagem. Portanto, um impulso maior é necessário para mover montagens
mais massivas. Impulsos são úteis para casos em que você quer que uma força
seja aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for [possessa](/physics/network-ownership) pelo
servidor, essa função deve ser chamada de um `Class.Script`
does servidor (não de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a peça for possessa por um cliente através da propriedade **automática**,
a função pode ser chamada de um script de cliente **ou** um script de servidor;
chamá-la de um script de cliente para uma peça possessa pelo servidor não terá
nenhum efeito.

BasePart:ApplyAngularImpulse

impulse

Um vetor de impulso angular a ser aplicado na montagem.

Esta função aplica um impulso de força instantânea na montagem desta peça.

A força é aplicada no `Class.BasePart.AssemblyCenterOfMass|centro de massa` da montagem,
portanto o movimento resultante será apenas linear.

A velocidade resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
da montagem. Portanto, um impulso maior é necessário para mover montagens
mais massivas. Impulsos são úteis para casos em que você quer que uma força
seja aplicada instantaneamente, como uma explosão ou colisão.

Se a peça for [possessa](/physics/network-ownership) pelo
servidor, essa função deve ser chamada de um `Class.Script`
does servidor (não de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a peça for possessa por um cliente através da propriedade **automática**,
a função pode ser chamada de um script de cliente **ou** um script de servidor;
chamá-la de um script de cliente para uma peça possessa pelo servidor não terá
nenhum efeito.

BasePart:ApplyImpulse

Um vetor de impulso linear a ser aplicado na montagem.

Aplica um impulso na montagem no `Class.BasePart.AssemblyCenterOfMass|centro de massa`
da montagem.

Esta função aplica um impulso de força instantânea na montagem desta peça, na
posição especificada em espaço mundial.

Se a posição não estiver no `Class.BasePart.AssemblyCenterOfMass|centro de massa`
da montagem, o impulso causará um movimento posicional e rotacional.

A velocidade resultante do impulso depende da `Class.BasePart.AssemblyMass|massa`
da montagem. Portanto, um impulso maior é necessário para mover montagens
mais massivas. Impulsos são úteis para casos em que os desenvolvedores
queiram que uma força seja aplicada instantaneamente, como uma explosão ou
colisão.

Se a peça for [possessa](/physics/network-ownership) pelo
servidor, essa função deve ser chamada de um `Class.Script`
does servidor (não de um `Class.LocalScript` ou de um `Class.Script` com
`Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
Se a peça for possessa por um cliente através da propriedade **automática**,
a função pode ser chamada de um script de cliente **ou** um script de servidor;
chamá-la de um script de cliente para uma peça possessa pelo servidor não terá
nenhum efeito.

BasePart:ApplyImpulseAtPosition

Um vetor de impulso a ser aplicado na montagem.

position

A posição, em espaço mundial, para aplicar o impulso.

Aplica um impulso na montagem em uma posição especificada.

Desfaz qualquer conexão de superfície com qualquer peça adjacente, incluindo
`Class.Weld` e outras `Class.JointInstance`.

BasePart:BreakJoints

BasePart:breakJoints

Retorna se as peças podem colidir entre si ou não. Esta
função leva em conta os grupos de colisão das duas peças. Esta
função gerará um erro se a peça especificada não for um BasePart.

BasePart:CanCollideWith

A peça especificada sendo verificada quanto à possibilidade de colisão.

Retorna se as peças podem colidir entre si.

Este exemplo verifica se a propriedade de rede da primeira
`BasePart` chamada _Part_ no `Workspace` pode ser definida.

A função CanSetNetworkOwnership verifica se você pode definir a propriedade de rede de uma peça.

O valor de retorno da função verifica se você pode ou não chamar
`Class.BasePart:SetNetworkOwner()` ou
`Class.BasePart:SetNetworkOwnershipAuto()` sem encontrar um erro.
Ela retorna verdadeiro se você pode modificar/ler a propriedade de rede, ou retorna
falso e a razão pela qual você não pode, como uma string.

BasePart:CanSetNetworkOwnership

Se você pode modificar ou ler a propriedade de rede e o motivo.

Verifica se você pode definir a propriedade de rede de uma peça.

Retorna o ponto mais próximo na superfície da peça à posição dada em
espaço mundial. Se a posição fornecida estiver dentro da peça, ela será retornada
como está.

Para instâncias `Class.MeshPart` e `Class.PartOperation`, este método
respeita o valor de `Enum.CollisionFidelity` da peça. Os valores de retorno podem
diferençar dependendo se a malha está sendo tratada como uma caixa, um casco, ou uma
forma mais complexa.

BasePart:GetClosestPointOnSurface

O ponto em espaço mundial para encontrar o ponto mais próximo da superfície.

O ponto mais próximo na superfície da peça em espaço mundial.

Retorna o ponto mais próximo na superfície da peça ao ponto dado.

Retorna uma tabela de peças conectadas ao objeto por qualquer tipo de junta
rígida.

Se `recursive` for verdadeiro, essa função retornará todas as peças na
montagem rigidamente conectadas ao BasePart.

#### Juntas Rígidas

Quando uma junta conecta duas peças `(Part0 → Part1)`, uma junta é
**rígida** se a física de `Part1` estiver completamente travada por `Part0`.
Isso se aplica apenas aos seguintes tipos de juntas:

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

BasePart:GetConnectedParts

recursive

Uma tabela de peças conectadas ao objeto por qualquer tipo de
`Class.JointInstance|junta`.

Retorna uma tabela de peças conectadas ao objeto por qualquer tipo de junta
rígida.

Retorna todas as Juntas ou Restrições que estão conectadas a esta Parte.

BasePart:GetJoints

Um array de todas as Juntas ou Restrições conectadas à Parte.

Este exemplo cria uma nova parte, myPart, no Workspace do jogo, com
dimensões 4x6x4 studs. A parte também está ancorada.

Então, myMass é definido para ser igual à massa da nova parte. A massa da parte é
impressa ao final da instrução de impressão:

> A massa da minha parte é ...

**GetMass** retorna o valor da propriedade somente leitura `Class.BasePart.Mass|Mass`
.

Esta função é anterior à propriedade Mass. Ela permanece suportada por
compatibilidade retroativa; você deve usar a propriedade Mass diretamente.

BasePart:GetMass

Retorna o valor da propriedade `Class.BasePart.Mass|Mass`.

BasePart:getMass

Retorna o jogador atual que é o proprietário de rede desta peça, ou `nil`
caso do servidor.

BasePart:GetNetworkOwner

O jogador atual que é o proprietário de rede desta peça, ou `nil` no
caso do servidor.

Retorna verdadeiro se o motor do jogo decide automaticamente o proprietário de rede
para esta peça.

BasePart:GetNetworkOwnershipAuto

Se o motor do jogo decide automaticamente o proprietário de rede para
esta peça.

BasePart:GetNoCollisionConstraints

Esta função costumava ser relevante quando a interpolação compensatória de
atraso do Roblox era interna. A interpolação agora é aplicada ao `Datatype.CFrame`
 diretamente.

BasePart:GetRenderCFrame

OBSOLETO. Retorna um CFrame descrevendo onde a peça está sendo renderizada.

Retorna a peça base de uma montagem. Ao mover uma montagem de peças
usando um `Datatype.CFrame`. é importante mover esta peça base (isso
moverá todas as outras peças conectadas a ela de acordo). Mais informações
estão disponíveis no artigo [Assemblies](/physics/assemblies).

Esta função precede a propriedade `Class.BasePart.AssemblyRootPart|AssemblyRootPart`.
Ela permanece suportada para compatibilidade retroativa, mas você deve usar
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` diretamente.

BasePart:GetRootPart

A peça base de uma montagem (uma coleção de peças conectadas
juntas).

Retorna a peça base de uma montagem de peças.

Retorna uma tabela de todas as peças que estão interagindo fisicamente com esta
peça. Se a própria peça tiver CanCollide definido como falso, esta função
retornará uma tabela vazia, a menos que a peça tenha um
d objeto `Class.TouchTransmitter|TouchInterest` parente (significa que
algo está conectado ao seu evento Touched). Peças que estão adjacentes mas
não se intersectam não são consideradas tocando. Esta função precede a
função `Class.WorldRoot:GetPartsInPart()`, que fornece mais
flexibilidade e evita as regras especiais de `Class.TouchTransmitter|TouchInterest`
 descritas acima. Use `Class.WorldRoot:GetPartsInPart()` em vez disso.

BasePart:GetTouchingParts

Uma tabela de todas as peças que se intersectam e podem colidir com esta peça.

Retorna uma tabela de todos os `Class.BasePart.CanCollide` verdadeiros que
intersectam com esta peça.

Retorna a velocidade linear da montagem da peça na posição dada
em relação a esta peça. Pode ser usado para identificar a velocidade linear de
peças em uma montagem que não seja a peça raiz. Se a montagem não tiver
velocidade angular, então a velocidade linear sempre será a mesma para
uma posição qualquer.

BasePart:GetVelocityAtPosition

Retorna a velocidade linear da montagem da peça na posição dada
em relação a esta peça.

Cria uma nova `Class.IntersectOperation` a partir da geometria que se intersecta
da parte e outras partes no array dado. Apenas `Class.Part|Parts`
 são suportados, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
 `Class.Instance:Clone()|Clone()`, o objeto retornado não possui um
`Class.Instance.Parent|Parent` configurado.

As seguintes propriedades da parte chamadora são aplicadas ao
`Class.IntersectOperation` resultante:

- `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`

Na comparação de imagens a seguir,
`Class.BasePart:IntersectAsync()|IntersectAsync()` é chamada no bloco roxo
usando uma tabela que contém o bloco azul. A operação `Class.IntersectOperation`
resulta em uma forma da geometria que se intersecta das duas partes.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Intersect.jpg"
width="720" alt="Duas partes de blocos sobrepondo" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Intersect-Result.jpg"
width="720" alt="Partes intersectadas em um novo modelo sólido" />
<figcaption>Resultado <code>Class.IntersectOperation</code></figcaption>
</figure>

#### Notas

- As partes originais permanecem intactas após uma operação de interseção bem-sucedida.
 Na maioria dos casos, você deve `Class.Instance.Destroy|Destroy()` todas as
 partes originais e parentar a `Class.IntersectOperation` retornada ao mesmo lugar
do que a `Class.BasePart` chamadora.
- Por padrão, as cores das faces da interseção resultante são emprestadas da
  propriedade `Class.BasePart.Color|Color` das partes originais. Para
  mudar toda a interseção para uma cor específica, defina sua
  propriedade `Class.PartOperation.UsePartColor|UsePartColor` como `true`.
- Se uma operação de interseção resultar em uma parte com mais de 20.000
  triângulos, ela será simplificada para 20.000 triângulos.

BasePart:IntersectAsync

parts

Os objetos que participam da interseção.

collisionfidelity

O valor de `Enum.CollisionFidelity` para o resulting
`Class.IntersectOperation`.

renderFidelity

O valor de `Enum.RenderFidelity` do resulting
`Class.PartOperation`.

Resultado de `Class.IntersectOperation` com o nome padrão **Intersect**.

Nota: É altamente recomendável usar a nova
`Class.GeometryService:IntersectAsync` em vez desta função. Além de ter
melhor desempenho e mais recursos, a nova função difere da seguinte maneira:

- A saída é um array de instâncias em vez de uma única instância.
- As partes de entrada não precisam estar parentadas à cena, permitindo
  operações em segundo plano.
- Quando a opção `SplitApart` é definida como `true` (padrão), cada corpo distinto
  será retornado em sua própria `Class.PartOperation`.
- Todas as partes retornadas estão no espaço de coordenadas da parte principal, então
  suas posições `Class.PVInstance.Origin` são as mesmas que a da parte principal.
 Isso mantém os vértices da malha na mesma posição em relação ao objeto
 que antes da operação, mas isso também significa que o `(0, 0, 0)` de uma parte
 retornada não está necessariamente no centro de seu corpo.

  Cria uma nova `Class.IntersectOperation` a partir da geometria sobreposta
  da parte e outras partes no array dado.

Retorna verdadeiro se o objeto estiver conectado a uma peça que o segurará em
um lugar (por exemplo, uma parte `Class.BasePart.Anchored|Anchored`), caso contrário, retorna
falso. Em uma montagem que tem uma parte `Class.BasePart.Anchored|Anchored`,
toda outra parte está aterrada.

BasePart:IsGrounded

Se o objeto está conectado a uma peça que o segurará em um lugar.

Retorna verdadeiro se o objeto estiver conectado a uma peça que o segurará em
um lugar (por exemplo, uma parte `Class.BasePart.Anchored|Anchored`), caso contrário, retorna
falso.

Cria uma junta em qualquer lado da `Class.BasePart|Part` que tenha um
`Enum.SurfaceType` que pode fazer uma junta, criará uma junta com qualquer
peças adjacentes.

As juntas serão criadas entre os lados e quaisquer superfícies planas que estão
tocando, dependendo das superfícies dos lados.

- Superfícies lisas não criarão juntas
- Superfícies adesivas criarão uma junta `Class.Glue`
- Soldas criarão uma junta `Class.Weld` com qualquer superfície exceto por
  NãoJuntável
- Studs, Inlet ou Universal criarão cada um uma junta `Class.Snap` com
  qualquer uma das outras duas superfícies (por exemplo, Studs com Inlet e
  Universal)
- Superfícies de Dobradiça e Motor criam instâncias de juntas `Class.Rotate` e
  `Class.RotateV`

Diferentemente de `Class.Model:MakeJoints()`, esta função requer um array de
peças como parâmetro. Este array é fornecido da seguinte maneira:

```
part:MakeJoints({part1, part2, part3})
```
As juntas são quebradas se uma força suficiente for aplicada a elas devido a uma
`Class.Explosion`, a menos que um objeto `Class.ForceField` esteja parentado à
`Class.BasePart` ou ao ancestral `Class.Model`. Por esse motivo, elas são
frequentemente usadas para fazer edifícios destrutíveis simples e outros modelos.

BasePart:MakeJoints

Cria uma junta em qualquer lado do objeto que tenha um ID de superfície que pode
fazer uma junta.

BasePart:makeJoints

Muda o tamanho de um objeto exatamente como usar a ferramenta de redimensionamento do Studio.

BasePart:Resize

normalId

deltaAmount

Quanto aumentar/reduzir no lado especificado.

BasePart:resize

Define o jogador dado como proprietário da rede para esta e todas as partes conectadas.
Quando playerInstance é `nil`, o servidor será o proprietário em vez de um
jogador.

BasePart:SetNetworkOwner

playerInstance

O jogador a quem é dada a propriedade de rede da peça.

Define o jogador dado como proprietário da rede para esta e todas as partes conectadas.

Deixa o motor do jogo decidir dinamicamente quem lidará com a física da peça
(um dos clientes ou o servidor).

BasePart:SetNetworkOwnershipAuto

Este exemplo demonstra como subtrair parte(s) de outra
`Class.BasePart` para formar uma `Class.UnionOperation` negada.

Cria uma nova `Class.UnionOperation` a partir da parte, menos a geometria
ocupada pelas partes no array dado. Apenas `Class.Part|Parts` são
 suportados, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
 `Class.Instance:Clone()|Clone()`, o objeto retornado não possui um
`Class.Instance.Parent|Parent` configurado.

Nota que a união resultante não pode estar vazia devido a subtrações. Se a
operação resultar em uma geometria completamente vazia, ela falhará.

Na comparação de imagens a seguir,
`Class.BasePart:SubtractAsync()|SubtractAsync()` é chamada no cilindro azul
usando uma tabela que contém o bloco roxo. A operação `Class.UnionOperation`
resulta em uma forma que omite a geometria do bloco daquela do cilindro.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Subtract.jpg"
width="720" alt="Bloco longo sobrepondo um cilindro" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Negate-Result.jpg" width="720"
alt="Parte do bloco subtraído do cilindro" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>

BasePart:SubtractAsync

Os objetos que participam da subtração.

O valor de `Enum.CollisionFidelity` para o resulting
`Class.UnionOperation`.

Resultado de `Class.UnionOperation` com o nome padrão **Union**.

Nota: É altamente recomendável usar a nova
`Class.GeometryService:UnionAsync` em vez desta função. Além de ter
melhor desempenho e mais recursos, a nova função difere da seguinte maneira:

- A saída é um array de instâncias em vez de uma única instância.
- As partes de entrada não precisam estar parentadas à cena, permitindo
  operações em segundo plano.
- Quando a opção `SplitApart` é definida como `true` (padrão), cada corpo distinto
  será retornado em sua própria `Class.PartOperation`.
- Todas as partes retornadas estão no espaço de coordenadas da parte principal, então
  suas posições `Class.PVInstance.Origin` são as mesmas que a da parte principal.
 Isso mantém os vértices da malha na mesma posição em relação ao objeto
 que antes da operação, mas isso também significa que o `(0, 0, 0)` de uma parte
 retornada não está necessariamente no centro de seu corpo.

  Cria uma nova `Class.UnionOperation` a partir da parte, menos a geometria
  ocupada pelas partes no array dado.

Retorna a aceleração angular em espaço mundial que resultaria da
aplicação do torque especificado à montagem da peça, levando em conta
opcionalmente efeitos giroscópicos.

Isso é o inverso de `Class.BasePart:AngularAccelerationToTorque()`. É
útil para prever como uma montagem responderá a um torque aplicado.

O cálculo utiliza:

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

onde **I** é o tensor de inércia no espaço mundial da montagem, **τ** é o
torque aplicado, e **ω** é a velocidade angular.

Se a peça não for um descendente de `Class.Workspace`, retorna `(0, 0, 0)`.
Se a montagem estiver ancorada, retorna `(0, 0, 0)`.

#### Efeitos Giroscópicos

Quando uma montagem giratória tem um tensor de inércia assimétrico, a
aceleração resultante de um torque aplicado também depende da velocidade
angular atual. O parâmetro `angVelocity` contabiliza esses
efeitos giroscópicos. Se omitido (padrão é zero), o resultado ignora
essa contribuição do resultado.

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

-- Prever a aceleração angular deste torque
local angAccel = part:TorqueToAngularAcceleration(appliedTorque, angularVelocity)
```

BasePart:TorqueToAngularAcceleration

torque

O vetor de torque aplicado à montagem em espaço mundial.

A velocidade angular atual da montagem em espaço mundial. Por padrão
é igual a `(0, 0, 0)`. Forneça a velocidade angular da montagem para contabilizar
os efeitos giroscópicos.

Um `Datatype.Vector3` representando a aceleração angular resultante
em espaço mundial.

Retorna a aceleração angular que resultaria da aplicação de um dado
torque à montagem desta peça, contabilizando opcionalmente os efeitos giroscópicos.

Este exemplo demonstra como combinar a geometria de uma `Class.BasePart`
com a geometria de outra(s) parte(s) para formar uma `Class.UnionOperation`.

Cria uma nova `Class.UnionOperation` a partir da parte, mais a geometria
ocupada pelas partes no array dado. Apenas `Class.Part|Parts` são
 suportados, não `Class.Terrain` ou `Class.MeshPart|MeshParts`. Semelhante a
 `Class.Instance:Clone()|Clone()`, o objeto retornado não possui um
`Class.Instance.Parent|Parent` configurado.

As seguintes propriedades da parte chamadora são aplicadas ao
`Class.UnionOperation` resultante:

- `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`

Na comparação de imagens a seguir,
`Class.BasePart:UnionAsync()|UnionAsync()` é chamada no bloco azul
usando uma tabela que contém o cilindro roxo. A operação `Class.UnionOperation`
resulta em uma forma da geometria combinada das duas partes.

<figure>
<img src="../../../assets/modeling/solid-modeling/Separate-Parts-To-Union.jpg"
width="720" alt="Partes de bloco e cilindro sobrepondo" />
<figcaption>Partes separadas</figcaption>
</figure>
<figure>
<img src="../../../assets/modeling/solid-modeling/Union-Result.jpg" width="720"
alt="Partes unidas em uma única união sólida" />
<figcaption>Resultado <code>Class.UnionOperation</code></figcaption>
</figure>

#### Notas

- As partes originais permanecem intactas após uma operação de união bem-sucedida.
  Na maioria dos casos, você deve `Class.Instance.Destroy|Destroy()` todas as
  partes originais e parentar a `Class.UnionOperation` retornada ao mesmo lugar
  que a `Class.BasePart` chamadora.
- Por padrão, a união resultante respeita a
  `Class.BasePart.Color|Color` de cada uma de suas partes. Para mudo
  toda a união para uma cor específica, defina sua
  propriedade `Class.PartOperation.UsePartColor|UsePartColor` como `true`.
- Se uma operação de união resultar em uma parte com mais de 20.000
  triângulos, ela será simplificada para 20.000 triângulos.

BasePart:UnionAsync

Os objetos que participam da união com a parte chamadora.

Nota: É altamente recomendável usar a nova
`Class.GeometryService:UnionAsync` em vez desta função. Além de ter
melhor desempenho e mais recursos, a nova função difere da seguinte maneira:

- A saída é um array de instâncias em vez de uma única instância.
- As partes de entrada não precisam estar parentadas à cena, permitindo
  operações em segundo plano.
- Quando a opção `SplitApart` é definida como `true` (padrão), cada corpo distinto
  será retornado em sua própria `Class.PartOperation`.
- Todas as partes retornadas estão no espaço de coordenadas da parte principal, então
  suas posições `Class.PVInstance.Origin` são as mesmas que a da parte principal.
 Isso mantém os vértices da malha na mesma posição em relação ao objeto
 que antes da operação, mas isso também significa que o `(0, 0, 0)` de uma parte
 retornada não está necessariamente no centro de seu corpo.

        Cria uma nova `Class.UnionOperation` a partir da parte, mais a geometria

  ocupada pelas partes no array dado.

BasePart

Este exemplo de código permitirá que uma parte seja clicada para alternar sua propriedade ancorada.
Ao ser alternada, a aparência visual da parte é atualizada (vermelho
significa ancorada, amarelo significa livre).


A propriedade `Anchored` determina se a parte será imutável por
 física. Quando ativada, uma parte nunca mudará de posição devido à gravidade,
 colisões de outras partes, sobreposição com outras partes, ou qualquer outra
 causa relacionada à física. Como resultado, duas partes ancoradas nunca ativarão
o evento `Class.BasePart.Touched|Touched` uma na outra.

Uma parte ancorada ainda pode ser movida mudando seu
 `Class.BasePart.CFrame|CFrame` ou `Class.BasePart.Position|Position`, e
 ainda pode ter um
 `Class.BasePart.AssemblyLinearVelocity|AssemblyLinearVelocity` e
 `Class.BasePart.AssemblyAngularVelocity|AssemblyAngularVelocity` diferentes de zero.

Finalmente, se uma parte não ancorada estiver unida a uma parte ancorada por
 meio de um objeto como um `Class.Weld`, esta também agirá como ancorada. Se tal
 junta se quebrar, a parte poderá ser afetada pela física novamente. Veja
 [Assemblies](/physics/assemblies) para mais detalhes.

A propriedade de propriedade de rede não pode ser definida em partes ancoradas. Se o
 status de ancoragem de uma parte mudar no servidor, a propriedade de rede dessa parte será
 afetada.

BasePart.Anchored

Determina se uma parte é imutável pela física.

O vetor de velocidade angular do conjunto desta parte. É a taxa de
 mudança da orientação em radianos por segundo.

A velocidade angular é a mesma em todos os pontos do conjunto.

Definir a velocidade diretamente pode levar a movimentos irreais. Usar
 `Class.Torque` ou `Class.AngularVelocity` como restrição é preferido, ou use
 `Class.BasePart:ApplyAngularImpulse()|ApplyAngularImpulse()` se você quiser
 alteração instantânea na velocidade.

Se a parte for [possuída](/physics/network-ownership) pelo
 servidor, esta propriedade deve ser alterada a partir de um `Class.Script`
 do servidor (não a partir de um `Class.LocalScript` ou um `Class.Script` com
 `Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
 Se a parte for possuída por um cliente através de **autonomia**,
 esta propriedade pode ser alterada a partir de um script de cliente **ou** um script
 do servidor; alterá-la a partir de um script de cliente para uma parte possuída pelo servidor não
 terá efeito.

BasePart.AssemblyAngularVelocity

A velocidade angular do conjunto da parte.

Uma posição calculada através da `Class.BasePart.Mass|Mass` e
 `Class.BasePart.Position|Position` de todas as partes no conjunto.

Se o conjunto tiver uma parte ancorada, o centro de massa dessa parte será o
 centro de massa do conjunto, e o conjunto terá massa infinita.

Conhecer o centro de massa pode ajudar o conjunto a manter a estabilidade. Uma
 força aplicada ao centro de massa não causará aceleração angular,
 apenas linear. Um conjunto com um baixo centro de massa terá uma melhor
 estabilidade sob o efeito da gravidade.

BasePart.AssemblyCenterOfMass

O centro de massa do conjunto da parte no espaço mundial.

O vetor de velocidade linear deste conjunto de parte. É a taxa de
 mudança na posição do
 `Class.BasePart.AssemblyCenterOfMass|AssemblyCenterOfMass` em studs por
 segundo.

Se você quiser saber a velocidade em um ponto diferente do centro de massa do conjunto,
 use
 `Class.BasePart:GetVelocityAtPosition()|GetVelocityAtPosition()`.

Definir a velocidade diretamente pode levar a movimentos irreais. Usar uma
 `Class.VectorForce` como restrição é preferido, ou use
 `Class.BasePart:ApplyImpulse()|ApplyImpulse()` se você quiser alteração
 instantânea na velocidade.

Se a parte for [possuída](/physics/network-ownership)
 pelo servidor, esta propriedade deve ser alterada a partir de um `Class.Script`
 do servidor (não a partir de um `Class.LocalScript` ou um `Class.Script` com
 `Class.BaseScript.RunContext|RunContext` definido como `Enum.RunContext.Client`).
 Se a parte for possuída por um cliente através de **autonomia**, esta
 propriedade pode ser alterada a partir de um script de cliente **ou** de um script
 do servidor; alterá-la a partir de um script de cliente para uma parte possuída pelo servidor não
 terá efeito.

BasePart.AssemblyLinearVelocity

A velocidade linear do conjunto da parte.

A soma da massa de todas as `Class.BasePart|BaseParts` neste conjunto de
 parte. Partes que são `Class.BasePart.Massless|Massless` e não são a
 parte raiz do conjunto não contribuirão para a `AssemblyMass`.

Se o conjunto tiver uma parte ancorada, a massa do conjunto é considerada
 infinita. Restrições e outras interações físicas entre conjuntos não ancorados
 com uma grande diferença de massa podem causar instabilidades.

BasePart.AssemblyMass

Esta propriedade indica o `Class.BasePart` escolhido automaticamente para
 representar a parte raiz do conjunto. Se a parte não estiver conectada ao
 `Class.Workspace`, esta propriedade será `nil`.

A parte raiz pode ser mudada alterando o
 `Class.BasePart.RootPriority|RootPriority` das partes no conjunto.

Partes que compartilham o mesmo `AssemblyRootPart` estão no mesmo conjunto.

Para mais informações sobre partes raiz, veja
 [Assemblies](/physics/assemblies).

BasePart.AssemblyRootPart

Uma referência à parte raiz do conjunto.

`AudioCanCollide` determina se a parte interagirá fisicamente
 com a simulação de áudio, similar ao `Class.BasePart.CastShadow|CastShadow`
 para iluminação.

Quando desativado, o áudio passa através da parte; não é
 ocluído ou refletido.

BasePart.AudioCanCollide

Determina se a parte interagirá fisicamente com a simulação de áudio,
 similar ao `Class.BasePart.CastShadow|CastShadow` para
 iluminação.

Este exemplo de código demonstra como as propriedades de superfície podem ser definidas usando apenas um
NormalId (Cima, Frente, etc). Ele altera a -SurfaceInput de um motor de NoInput,
Constante e Sin para mostrar como cada um funciona usando as propriedades -ParamA e -ParamB.

A propriedade `BackParamA` é relevante quando a
 `Class.BasePart.BackSurface` de uma parte está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BackSurfaceInput` está configurada como Sin. Isso
 determina a **amplitude** da velocidade rotacional do motor.

BasePart.BackParamA

Determina o primeiro parâmetro para o SurfaceType na face traseira de uma
 parte.

A propriedade `BackParamB` é relevante quando a
 `Class.BasePart.BackSurface` de uma parte está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BackSurfaceInput` está configurada como Constant ou Sin. Para Constant,
 determina a velocidade rotacional constante do motor. Para Sin, determina a
 **frequência** da velocidade rotacional do motor.

BasePart.BackParamB

Determina o segundo parâmetro para o SurfaceType na face traseira de uma
 parte.

A propriedade `BackSurface` determina o tipo de superfície usada para o
 direcional **Z** positivo de uma parte. Quando as faces de duas partes estão
 colocadas uma ao lado da outra, podem criar uma junta entre elas.

BasePart.BackSurface

Determina o tipo de superfície para a face traseira de uma parte.

A propriedade `BackSurfaceInput` determina o tipo de entrada fornecida a uma
 superfície `Class.BasePart.BackSurface`. Isso é relevante apenas para Motor ou
 SteppingMotor SurfaceTypes. Esta propriedade determina como
 `Class.BasePart.BackParamA` e `Class.BasePart.BackParamB` são usadas. Para
 brevidade, essas propriedades serão referidas como ParamA e ParamB,
 respectivamente.

- Por padrão, isso é definido como NoInput. Isso para o motor completamente.
- Para Constant, o motor gira a uma velocidade constante igual a
  `ParamB`.
- Para Sin, o motor gira a uma velocidade igual a
  `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. Veja
  `Class.Workspace.DistributedGameTime`.

BasePart.BackSurfaceInput

Determina o tipo de entrada para a face traseira de uma parte.

A propriedade `BottomParamA` é relevante quando a parte
 `Class.BasePart.BottomSurface` está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BottomSurfaceInput` está configurada como Sin. Isso
 determina a **amplitude** da velocidade rotacional do motor.

BasePart.BottomParamA

Determina o primeiro parâmetro para o SurfaceType na face inferior de uma
 parte.

A propriedade `BottomParamB` é relevante quando a parte
 `Class.BasePart.BottomSurface` está configurada como Motor ou
 SteppingMotor e `Class.BasePart.BottomSurfaceInput` está configurada como Constant ou Sin. Para
 Constant, determina a velocidade rotacional constante do motor. Para Sin, determina a
 **frequência** da velocidade rotacional do motor.

BasePart.BottomParamB

Determina o segundo parâmetro para o SurfaceType na face inferior de uma
 parte.

A propriedade `BottomSurface` determina o tipo de superfície usada para o
 direcional **Y** negativo de uma parte. Quando as faces de duas partes estão
 colocadas uma ao lado da outra, podem criar uma junta entre elas.

BasePart.BottomSurface

Determina o tipo de superfície para a face inferior de uma parte.

A propriedade `BottomSurfaceInput` determina o tipo de entrada fornecida a
 uma superfície `Class.BasePart.BottomSurface`. Isso é relevante apenas para Motor
 ou SteppingMotor SurfaceTypes. Esta propriedade determina como
 `Class.BasePart.BottomParamA` e `Class.BasePart.BottomParamB` são usadas.
 Para brevidade, essas propriedades serão referidas como ParamA e ParamB,
 respectivamente.

- Por padrão, isso é definido como NoInput. Isso para o motor completamente.
- Para Constant, o motor gira a uma velocidade constante igual a
  `ParamB`.
- Para Sin, o motor gira a uma velocidade igual a
  `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. Veja
  `Class.Workspace.DistributedGameTime`.

BasePart.BottomSurfaceInput

Determina o tipo de entrada para a face inferior de uma parte.

Esta propriedade determina a cor de uma parte. Se a parte tiver um
 `Class.BasePart.Material|Material`, isso também determina a cor usada
 ao renderizar a textura do material. Para mais controle sobre a cor, a
 propriedade `Class.BasePart.Color|Color` pode ser usada e esta propriedade será
 usada em relação ao `BrickColor` mais próximo.

Outras propriedades visuais de uma parte são determinadas por
 `Class.BasePart.Transparency|Transparency` e
 `Class.BasePart.Reflectance|Reflectance`.

BasePart.BrickColor

BasePart.brickColor

A classe base abstrata para objetos que interagem fisicamente no mundo.