Uma **IntersectOperation** é o resultado de partes individuais que foram
interseccionadas em um único modelo sólido através da ferramenta **Intersect** de modelagem sólida do Studio, ou através de `Class.BasePart:IntersectAsync()`.

Veja [Modelagem Sólida](/parts/solid-modeling) para aprender mais sobre
as ferramentas e métodos de modelagem sólida do Studio.


IntersectOperation

Resultado de partes que foram interseccionadas em um único modelo sólido.


Uma classe abstrata da qual todas as partes baseadas em
[modelagem sólida](/parts/solid-modeling) herdam.


O seguinte exemplo substitui a geometria de uma `Class.PartOperation`
com a geometria de outra `Class.PartOperation`, e então remove
restrições/anexos que não devem ser preservados após a substituição.


Substitui a geometria deste `Class.PartOperation` pela geometria
de outro `Class.PartOperation`. Isso facilita a utilização da
geometria de uma operação de modelagem sólida como
`Class.GeometryService:UnionAsync()|UnionAsync()`,
`Class.GeometryService:SubtractAsync()|SubtractAsync()`, ou
`Class.GeometryService:IntersectAsync()|IntersectAsync()`, mas mantém
propriedades, atributos, tags e filhos da parte principal, como
`Class.Attachment|Attachments`, `Class.Constraint|Constraints`,
`Class.ParticleEmitter|ParticleEmitters`, objetos de luz, decals e mais.
Essa abordagem também contorna o potencial "flicker" de substituir completamente
o `Class.PartOperation` original por outro.

Observe que se você estiver chamando este método em um `Class.PartOperation` com
filhos `Class.Attachment|Attachments` ou `Class.Constraint|Constraints`,
você deve calcular as instâncias afetadas com
`Class.GeometryService:CalculateConstraintsToPreserve()|CalculateConstraintsToPreserve()`,
depois descartar aquelas cujo pai recomendado é `nil`.


PartOperation:SubstituteGeometry

source

O `Class.PartOperation` cuja geometria substituirá a geometria
deste `Class.PartOperation`.


Substitui a geometria deste `Class.PartOperation` pela geometria
de outro `Class.PartOperation`.


PartOperation

Esta propriedade determina o nível de detalhe que a parte modelada sólida
será exibida. Pode ser configurada para os valores possíveis do
`Enum.RenderFidelity` enum, exceto para
`Enum.RenderFidelity.Performance|Performance`.

O valor padrão é `Enum.RenderFidelity.Automatic|Automatic`, significando
que o detalhe da parte é baseado em sua distância da câmera, conforme descrito na
tabela a seguir.

<table>
    <thead>
        <tr>
            <th>Distância da Câmera</th>
            <th>Fidelidade de Renderização</th>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Menos de 250 studs</td>
            <td>Mais Alto</td>
        </tr>
        <tr>
            <td>250-500 studs</td>
            <td>Médio</td>
        </tr>
        <tr>
            <td>500 ou mais studs</td>
            <td>Mais Baixo</td>
        </tr>
    </tbody>
</table>


PartOperation.RenderFidelity

O nível de detalhe usado para renderizar a parte modelada sólida.


Esta propriedade representa um ângulo em graus para um valor de limite entre
normais de face em uma parte [modelada sólida](/parts/solid-modeling).
Se a diferença normal for menor que o valor, as normais serão ajustadas
para suavizar a diferença. Embora um valor entre 30 e 70 graus geralmente
produza um bom resultado, valores entre 90 e 180 não são recomendados, pois
podem causar um efeito de "sombreamento" em uniões com bordas afiadas.

Observe que o suavização não afeta as normais entre diferentes
materiais ou cores diferentes.


PartOperation.SmoothingAngle

Um ângulo em graus que afeta o sombreamento suave de uma parte modelada
sólida.


O número de polígonos neste modelo sólido.


PartOperation.TriangleCount

Define se o `Class.PartOperation` pode ser recolorido usando as
propriedades `Class.BasePart.Color` ou `Class.BasePart.BrickColor`. Quando
verdadeiro, toda a união será colorida de acordo com `Class.BasePart.Color|Color`
ou `Class.BasePart.BrickColor|BrickColor`. Quando falso, as partes na
união manterão suas cores originais de antes da operação de união
ser realizada.


PartOperation.UsePartColor

Define se o `Class.PartOperation` pode ser recolorido usando as propriedades
herdadas de cor.


Uma classe abstrata da qual todas as partes baseadas em modelagem sólida herdam.


TriangleMeshPart é uma classe intermediária abstrata da qual `Class.MeshPart`
e `Class.PartOperation` herdam. Foi criada para consolidar a
administração das propriedades de geometria física entre as duas subclasses. Ela
implementa o `Class.TriangleMeshPart.CollisionFidelity|CollisionFidelity` e
`Class.TriangleMeshPart.CollisionPrecision|CollisionPrecision` somente para leitura.


TriangleMeshPart

Esta propriedade determina como o modelo de colisão do
`Class.TriangleMeshPart` se relaciona com a geometria real da malha. Esta
propriedade não pode ser lida ou manipulada por scripts durante a execução.

Veja [aqui](/workspace/collisions#collision-fidelity) para uma
representação visual das várias opções.

TriangleMeshPart.CollisionFidelity

Determina o nível de detalhe que a física da parte seguirá em relação à sua malha.

Esta propriedade descreve a troca entre precisão e desempenho da
geometria de colisão da peça quando `Class.TriangleMeshPart.CollisionFidelity`
está definido como `Enum.CollisionFidelity.Tunable`. Um valor de `0` favorece
máximo desempenho com a malha de colisão mais simples, enquanto um valor de `1`
favorece máxima precisão com uma malha de colisão que se aproxima da malha
visual.


TriangleMeshPart.CollisionPrecision

Quantifica quão preciso ou performático é um `Enum.CollisionFidelity.Tunable`
geometria de colisão, de `0` a `1`.


Controla qual representação geométrica o motor físico usa quando
calcula forças e torques aerodinâmicos (fluido) para a peça. Por padrão,
este valor é `Enum.FluidFidelity.Automatic`, no qual o motor seleciona uma
representação em seu nome.

- `Enum.FluidFidelity.Automatic` — o motor escolhe a representação;
  atualmente, ele avalia forças fluidas contra a geometria de colisão da peça.
- `Enum.FluidFidelity.UseCollisionGeometry` — forças fluidas são avaliadas
  contra a geometria de colisão da peça, correspondendo à forma usada para
detecção de colisão.
- `Enum.FluidFidelity.UsePreciseGeometry` — forças fluidas são avaliadas
  contra a geometria de malha precisa da peça, produzindo forças mais
  precisas a um custo computacional mais alto.

Como esta propriedade tem segurança de gravação em nível de plugin, ela é
configurada no Studio em vez de ser atribuída por scripts em tempo de execução.

Esta configuração afeta uma peça apenas enquanto as forças fluidas estão ativas
para o lugar, o que é governado por `Class.Workspace.FluidForces` (um
valor `Enum.FluidForces` que por padrão é `Default`; configurá-lo como
`Experimental` ativa o modelo de força aerodinâmica). Quando as forças fluidas não
são aplicadas à peça, a fidelidade escolhida não tem efeito.


TriangleMeshPart.FluidFidelity

Determina a representação geométrica usada para calcular forças
e torques aerodinâmicos.


Esta propriedade somente leitura relata o tamanho da geometria da malha da peça
quando foi carregada, em largura, altura e profundidade em studs. Não é afetada
por redimensionar a peça através de `Class.BasePart.Size`, então dividir
`Class.BasePart.Size` por `MeshSize` fornece o fator de escala atualmente
aplicado à geometria visual e física da malha.


TriangleMeshPart.MeshSize

O tamanho original da geometria da malha fonte da peça, antes de qualquer
escalonamento aplicado através de `Class.BasePart.Size`.


Classe intermediária abstrata que gerencia propriedades de geometria física para
PartOperations e MeshParts.

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`, sendo as mais comuns `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` (além de
 `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 nas faces de um
  `Class.BasePart`, enquanto um `Class.Texture` aplica uma textura de imagem
  em azulejos nas faces. Veja [Textures and Decals](/parts/textures-decals).
- Um `Class.SurfaceGui` renderiza `Class.GuiObject|GuiObjects` na face de uma
  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` relativos à parte. Estes 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 parentados. 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 parentado 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

A outra parte que entrou em contato com esta parte.

Dispara no cliente local quando outra parte entra em contato com esta
parte.

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

BasePart.OutfitChanged

Dispara quando a aparência da parte muda devido a uma `Class.Shirt`.

Depreciado. Dispara no cliente local quando uma parte para de tocar outra
parte, sob condições semelhantes às de `Class.BasePart.TouchEnded`.
Este evento é o contraparte apenas do cliente para `Class.BasePart.TouchEnded`:
ele apenas notifica o cliente local que as duas partes se separaram,
 enquanto `Class.BasePart.TouchEnded` também envia dados para o servidor. Use
`Class.BasePart.TouchEnded` em vez disso.

BasePart.StoppedTouching

otherPart

A outra parte que parou de tocar a parte dada.

Dispara no cliente local quando uma parte para de tocar outra parte.

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


Este exemplo de código demonstra como conectar o evento `Class.BasePart.Touched`
de múltiplas 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ó dispara como resultado de movimento físico, então não
será disparado se a propriedade `Class.BasePart.CFrame|CFrame` for
alterada de 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 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 de movimento físico.

Dispara quando uma peça para de tocar outra peça sob condições semelhantes às
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 detecção.

BasePart.TouchEnded

A outra parte que parou de tocar esta parte.

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

Demonstra `Class.BasePart:AngularAccelerationToTorque()`.


Retorna o vetor de torque no espaço mundial que deve ser aplicado à
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 via
uma instância de `Class.Torque` ou `Class.BasePart:ApplyAngularImpulse()`.

O cálculo usa a equação de rotação de Euler onde _I_ é o tensor de inércia
do mundo da montagem, _α_ é 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, ele 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`
considera esses efeitos giroscópicos. Se omitido, esses efeitos giroscópicos
são omitidos do cálculo.

BasePart:AngularAccelerationToTorque

angAcceleration

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

angVelocity

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

Um `Datatype.Vector3` representando o torque no 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, opcionalmente levando em conta os efeitos giroscópicos.

Aplica um impulso de força angular instantâneo à montagem desta peça,
fazendo a montagem girar.

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ê deseja que uma força
seja aplicada instantaneamente, como uma explosão ou colisão.

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

BasePart:ApplyAngularImpulse

impulse

Um vetor de impulso angular a ser aplicado à montagem.

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

A força é aplicada no `Class.BasePart.AssemblyCenterOfMass|centro de massa` da
montagem, então 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ê deseja que uma força
seja aplicada instantaneamente, como uma explosão ou colisão.

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

BasePart:ApplyImpulse

Um vetor de impulso linear a ser aplicado à montagem.

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

Esta função aplica um impulso de força instantâneo à montagem desta peça, na
posição especificada no 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
querem que uma força seja aplicada instantaneamente, como uma explosão ou
colisão.

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

BasePart:ApplyImpulseAtPosition

Um vetor de impulso a ser aplicado à montagem.

position

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

Aplica um impulso à montagem na posição especificada.

Inscreve `callback` nos dados de contato que o motor de física
gera para esta parte enquanto detecta colisões. Uma vez por quadro, após
a simulação ter avançado, `callback` recebe um array de resumos
descrevendo cada área de contato na qual esta parte esteve envolvida durante esse
quadro. Cada resumo relata onde o contato ocorreu, em que direção estava
voltado e quão rápido as duas partes estavam se movendo uma em relação à outra naquele
ponto.

Este método é um mecanismo separado de `Class.BasePart.Touched`.

Lança um erro se `callback` for `nil`, ou se a parte não for um descendente
de `Class.Workspace`.

#### Campos de Resumo

Cada entrada no array passado para `callback` é uma tabela com as seguintes
chaves:

<table size="small">
<thead>
  <tr>
    <th>Chave</th>
    <th>Tipo</th>
    <th>Resumo</th>
  </tr>
</thead>
<tbody>
  <tr>
    <td><code>Time</code></td>
    <td><code>number</code></td>
    <td>Tempo de simulação, em segundos, do subpasso de física que produziu este resumo.</td>
  </tr>
  <tr>
    <td><code>Part0</code></td>
    <td><code>Class.BasePart</code></td>
    <td>A parte inscrita.</td>
  </tr>
  <tr>
    <td><code>Part1</code></td>
    <td><code>Class.BasePart</code></td>
    <td>A outra parte do par, que pode ser <code>Class.Terrain</code>.</td>
  </tr>
  <tr>
    <td><code>Point</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Ponto de contato no espaço mundial, médio entre os pontos na área de contato.</td>
  </tr>
  <tr>
    <td><code>Normal</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Normal de contato unitária para a área de contato, orientada em relação à parte inscrita.</td>
  </tr>
  <tr>
    <td><code>RelativeVelocity</code></td>
    <td><code>Datatype.Vector3</code></td>
    <td>Velocidade de <code>Part1</code> em relação a <code>Part0</code> no ponto de contato.</td>
  </tr>
  <tr>
    <td><code>Area</code></td>
    <td><code>number</code></td>
    <td>Área estimada da área de contato, em studs quadrados. <code>0</code> para uma área com menos de três pontos, como um contato de borda ou canto.</td>
  </tr>
</tbody>
</table>

`Normal` é orientada em relação à parte inscrita em vez de
qualquer parte que o motor listou primeiro, então se ambas as partes de um
par estão inscritas, cada inscrição recebe seu próprio resumo com
ela mesma como `Part0` e a normal invertida para corresponder.

`RelativeVelocity` é a velocidade de `Part1` em relação a `Part0`, então a
magnitude de sua projeção em `Normal` é a velocidade com que as duas
partes estão se aproximando ou se separando de frente, e o componente tangencial
a `Normal` descreve o contato deslizante e de raspagem.

#### Comportamento de Relato

- O registro de contato é habilitado apenas enquanto pelo menos uma inscrição existir
  em qualquer lugar no `Class.Workspace`, e o custo disso escala com o
  número de partes inscritas em vez do número total de
  colisões na cena.
- Contatos entre várias partes adormecidas não produzem resumos.
- Contatos de partes com `Class.BasePart.CanCollide` definido como `false` não
  produzem resumos.
- A física pode executar vários subpassos por quadro, então um par que permanece em
  contato através de vários deles produz até um resumo por área de contato por
  subpasso, todos entregues na mesma invocação de `callback`. Use `Time`
  para ordená-los.
- Geometria de colisão não convexa produz um resumo por par de cascas convexas em contato,
  e o contato com `Class.Terrain` é dividido ainda mais por
  normal de contato, então qualquer um pode gerar vários resumos para o mesmo par
  dentro de um subpasso.
- Nada é replicado. Cada cliente gera resumos para as
  colisões que possui. Veja
  [propriedade de rede](/physics/network-ownership).
- Destruir a parte desconecta suas inscrições.


BasePart:BindToCollisionSummaries

callback

Invocado com um array de tabelas de resumo, no máximo uma vez por quadro, se
a parte estiver envolvida em uma colisão.


Uma `Datatype.RBXScriptConnection` que encerra a inscrição quando
desconectada.


Inscreve-se em dados de contato detalhados por quadro para as colisões nas quais esta parte
está envolvida.


Quebra qualquer conexão de superfície com qualquer parte adjacente, incluindo
`Class.Weld` e outros `Class.JointInstance`.


BasePart:BreakJoints

BasePart:breakJoints

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


BasePart:CanCollideWith

A parte especificada sendo verificada para colisibilidade.


Retorna se as partes 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 parte.

O valor de retorno da função verifica se você pode chamar
`Class.BasePart:SetNetworkOwner()` ou
`Class.BasePart:SetNetworkOwnershipAuto()` sem encontrar um erro.
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 a razão.


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


Retorna o ponto mais próximo na superfície da parte para a posição dada no espaço mundial.
Se a posição fornecida estiver dentro da parte, ela é retornada
como está.

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


BasePart:GetClosestPointOnSurface

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


O ponto mais próximo na superfície da parte no espaço mundial.


Retorna o ponto mais próximo na superfície da parte para o ponto dado.


Retorna uma tabela de partes conectadas ao objeto por qualquer tipo de junta
rígida.

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

#### Juntas Rígidas

Quando uma junta conecta duas partes juntas `(Part0 → Part1)`, uma junta é
**rígida** se a física de `Part1` estiver completamente bloqueada 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 partes conectadas ao objeto por qualquer tipo de
`Class.JointInstance|junta`.


Um array de `Class.BasePart|BaseParts` conectados a esta parte por juntas
rígidas. Se `recursive` for verdadeiro, inclui todas as partes na montagem.


Retorna uma tabela de partes 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 igualar a massa da nova parte. A massa da parte é
impressa no final da declaraçã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 continua sendo suportada para
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 da rede desta parte, ou `nil`
em caso do servidor.


BasePart:GetNetworkOwner

O jogador atual que é o proprietário da rede desta parte, ou `nil` em
caso do servidor.


Retorna verdadeiro se o motor do jogo decidir automaticamente o proprietário da rede
para esta parte.


BasePart:GetNetworkOwnershipAuto

Se o motor do jogo decide automaticamente o proprietário da rede para
esta parte.


Retorna os objetos `Class.NoCollisionConstraint` habilitados atualmente
registrados para esta parte em seu mundo físico. Um
`Class.NoCollisionConstraint` desabilita colisões entre as duas partes específicas
que ele referencia, enquanto cada uma dessas partes ainda pode colidir com o
restante do mundo.

O array retornado está vazio se nenhuma restrição desse tipo estiver atualmente registrada
para esta parte. A ordem das restrições retornadas não é garantida.


BasePart:GetNoCollisionConstraints

Um array dos objetos `Class.NoCollisionConstraint` habilitados
atualmente registrados para esta parte em seu mundo físico.


Retorna os objetos `Class.NoCollisionConstraint` habilitados atualmente
registrados para esta parte em seu mundo físico.


Esta função costumava ser relevante quando a interpolação de compensação de lag da Roblox
para partes online era interna. A interpolação agora é
aplicada diretamente ao `Datatype.CFrame`.


BasePart:GetRenderCFrame

O `Datatype.CFrame` representando onde a parte está sendo renderizada,
que agora é equivalente ao `Class.BasePart.CFrame|CFrame` da parte.


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


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

Esta função é anterior à propriedade
`Class.BasePart.AssemblyRootPart|AssemblyRootPart`. Ela continua
sendo suportada para compatibilidade retroativa, mas você deve usar
`Class.BasePart.AssemblyRootPart|AssemblyRootPart` diretamente.


BasePart:GetRootPart

A parte base de uma montagem (uma coleção de partes conectadas
juntas).


Retorna a parte base de uma montagem de partes.


Retorna uma tabela de todas as partes que estão interagindo fisicamente com esta
parte. Se a parte em si tiver CanCollide definido como falso, então esta função
retorna uma tabela vazia, a menos que a parte tenha um
`Class.TouchTransmitter|TouchInterest` objeto parentado a ela (significando
que algo está conectado ao seu evento Touched). Partes que estão adjacentes, mas
não se intersectando, não são consideradas tocando. Esta função é anterior à
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 partes que se intersectam e podem colidir com esta parte.


Retorna uma tabela de todas as partes `Class.BasePart.CanCollide` verdadeiras que
intersectam com esta parte.


Retorna a velocidade linear da montagem da parte na posição dada
em relação a esta parte. Pode ser usado para identificar a velocidade linear de
partes em uma montagem além da parte raiz. Se a montagem não tiver
velocidade angular, então a velocidade linear será sempre a mesma para
cada posição.


BasePart:GetVelocityAtPosition

A posição no espaço mundial na qual calcular a velocidade linear da montagem.


Um `Datatype.Vector3` representando a velocidade linear da montagem
na posição especificada no espaço mundial.


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


Cria uma nova `Class.IntersectOperation` a partir da geometria intersectante da
parte e das 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 tem um
`Class.Instance.Parent|Parent` definido.

As seguintes propriedades da parte chamadora são aplicadas à
resultante `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`

#### Migração

É altamente recomendável usar o novo
`Class.GeometryService:IntersectAsync()` em vez deste método. Além de ter
melhor desempenho e mais recursos, o novo método difere da seguinte forma:

- 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` está 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 as da parte principal. Isso mantém os
  vértices da malha na mesma posição em relação ao objeto como antes da operação, mas também significa
  que o `(0, 0, 0)` de uma parte retornada não está necessariamente no centro de
  seu corpo.

#### 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 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 resultante
`Class.IntersectOperation`.


renderFidelity

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


Resultante `Class.IntersectOperation` com o nome padrão **Intersect**.


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


Retorna verdadeiro se o objeto estiver conectado a uma parte que o manterá no
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`,
todas as outras partes estão fixadas.


BasePart:IsGrounded

Se o objeto está conectado a uma parte que o manterá no lugar.


Retorna verdadeiro se o objeto estiver conectado a uma parte que o manterá no
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 possa fazer uma junta, ela criará uma junta com quaisquer
partes adjacentes.

Juntas serão criadas entre os lados e quaisquer superfícies planas em contato,
dependendo das superfícies dos lados.

- Superfícies suaves 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
  Desunir
- 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 Hinge e Motor criam instâncias de juntas `Class.Rotate` e `Class.RotateV`

Diferente de `Class.Model:MakeJoints()`, esta função requer um array de
partes como parâmetro. Este array é dado da seguinte forma:

```
part:MakeJoints({part1, part2, part3})
```
Juntas são quebradas se 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 essa razão, elas são
frequentemente usadas para fazer edifícios e outros modelos destrutíveis simples.


BasePart:MakeJoints

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


BasePart:makeJoints

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


BasePart:Resize

normalId

deltaAmount

Quanto crescer/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 que está recebendo a propriedade da rede da parte.


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


Permite que o motor do jogo decida dinamicamente quem lidará com a física da parte
(um dos clientes ou o servidor).


BasePart:SetNetworkOwnershipAuto

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 tem um
`Class.Instance.Parent|Parent` definido.

Observe 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á.

#### Migração

É altamente recomendável usar o novo
`Class.GeometryService:SubtractAsync()` em vez deste método. Além de ter
melhor desempenho e mais recursos, o novo método difere da seguinte forma:

- 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` está 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 as da parte principal. Isso mantém os
  vértices da malha na mesma posição em relação ao objeto como antes da operação, mas também significa
  que o `(0, 0, 0)` de uma parte retornada não está necessariamente no centro de
  seu corpo.


BasePart:SubtractAsync

Os objetos que participam da subtração.


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


Resultante `Class.UnionOperation` com o nome padrão **Union**.


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


Demonstra `Class.BasePart:TorqueToAngularAcceleration()`.


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

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

O cálculo usa:

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

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

Se a parte 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` leva em conta esses
efeitos giroscópicos. Se omitido (padrão é zero), o resultado negligencia
essa contribuição do resultado.


BasePart:TorqueToAngularAcceleration

torque

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


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


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


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


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 tem um
`Class.Instance.Parent|Parent` definido.

As seguintes propriedades da parte chamadora são aplicadas à
resultante `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`

#### Migração

É altamente recomendável usar o novo
`Class.GeometryService:UnionAsync()` em vez deste método. Além de ter
melhor desempenho e mais recursos, o novo método difere da seguinte forma:

- 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` está 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 as da parte principal. Isso mantém os
  vértices da malha na mesma posição em relação ao objeto como antes da operação, mas também significa
  que o `(0, 0, 0)` de uma parte retornada não está necessariamente no centro de
  seu corpo.

#### 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 mudar
  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.


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 de anexação. Quando alternada, a aparência visual da parte é atualizada
(vermelho significa anexado, amarelo significa livre).


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

Uma parte ancorada ainda pode ser movida alterando seu
`Class.BasePart.CFrame|CFrame` ou `Class.BasePart.Position|Position`, e
ela ainda pode ter uma
`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 através de um
objeto como um `Class.Weld`, ela também agirá como ancorada. Se tal junta
quebrar, a parte pode 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.

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

/reference/engine/classes/IntersectOperation.yaml