> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-pt/wearables-e-emotes/wearables/spring-bones.md).

# Spring Bones

Adicione física dinâmica a wearables com Spring Bones

### O que são Spring Bones?

Spring bones (também conhecidos como jiggle bones ou physics bones) são bones extra adicionados a um wearable que se movem dinamicamente em resposta ao movimento do avatar e à gravidade, em vez de serem controlados por animation clips. Dão vida a elementos como hair, earrings, capes, belts, ponytails e outros acessórios pendurados, fazendo com que balancem, saltem e assentem de forma natural à medida que o avatar anda, corre ou roda.

Spring bones são **não** parte da armature base do avatar. São bones adicionais que adiciona à skeleton base do avatar no Blender (ou em qualquer software 3D), e o respetivo comportamento físico é configurado no Builder após o upload.

Esta implementação segue o [padrão VRM Spring Bone](https://vrm.dev/en/vrm1/springbone/), uma convenção amplamente adotada para física de avatar em formatos como VRM e MMD.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-155bf4c615cd79a1c25c1289fbc36565c913499b%2F01_spring_bones_workflow.png?alt=media\&token=74749646-204b-4014-829f-44f0807dd0f3)

### Como os Spring Bones Funcionam

Um **spring chain** é uma sequência de bones que simula física em conjunto e deve ter pelo menos dois bones: o spring bone propriamente dito e um end bone. Um único spring bone por si só não produzirá qualquer movimento — a simulação precisa da cabeça do spring bone para conduzir a física e a cabeça do end bone definirá o ponto final geométrico. Chains mais longas (3+ bones) terão movimentos mais suaves e naturais, ideais para cabelos longos ou capes.

1. **Spring bone parent** — O primeiro bone da chain. É ele que possui a configuração física (stiffness, gravity, drag, etc.). É identificado por ter `springbone` em qualquer parte do nome do bone (sem distinção entre maiúsculas e minúsculas).
2. **Child spring bone** — É o child do bone anterior na hierarchy. Herda os parâmetros físicos do seu parent e forma a chain.
3. **Spring bone end** — O último bone da chain. Define o ponto final geométrico da chain, mas não é afetado pela simulação e não deforma quaisquer meshes.

A chain, ou hierarchy, para spring bones deve ser **linear**, o que significa que cada bone só pode ter um child. Bones com dois ou mais children podem ter um comportamento inesperado.

![Uma spring chain boa e linear.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-647d9bf916f9848eb8e59c0ac59ebc2fe07deaea%2FSpring_Chain.png?alt=media\&token=3c8a9ade-932c-45d0-8ff2-039557f86601)

![Bones com 2 ou mais children terão um comportamento inesperado.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-f824360b21f0e1fc92a1a337479f35a08f7f694f%2FForked_Chain.png?alt=media\&token=4a822ce2-d7d3-45a8-84a2-6f2f1860d158)

### A Hierarchy

Para que os spring bones funcionem bem, têm de estar parented a um dos bones originais do avatar. Para cabelos e earrings, por exemplo, o bone no topo da hierarchy deve ser parented a ***Avatar\_Head***. Para scarves, parentear a chain para o ***Avatar\_Neck*** é uma boa ideia. Para skirts, talvez ***Avatar\_Hips*** ou ***Avatar\_LeftUpLeg/Avatar\_RightUpLeg*** possa resolver.

É importante notar como a estrutura desta hierarchy funciona.

* *Hair\_springBone\_1* (spring bone parent): este é o bone no topo da chain, tem configuração física
* *Hair\_springBone\_2* (child spring bone): este é o child do bone anterior na hierarchy e herda a configuração.
* *Hair\_springBone\_end* (spring bone end): é o último bone da chain e serve apenas como endpoint.

### Convenção de Nomenclatura

Todos os spring bones **devem** conter a substring `springbone` (sem distinção entre maiúsculas e minúsculas) no nome. A substring pode aparecer em qualquer posição:

* *SpringBone\_hair\_left*
* *hair\_springbone\_l*
* *springbone\_earring.R*

Para manter o seu workflow organizado, recomenda-se usar este formato: **BodyPart/WearableName\_springBone**

Exemplos: *Hair\_springBone\_1*, *Earring\_springBone.L* etc… Sinta-se à vontade para usar o formato que melhor lhe convier, desde que siga a convenção de nomenclatura do Blender (ou do seu software preferido) para esquerda e direita.

{% hint style="warning" %}
Atenção!

Os spring bones não funcionarão sem `springbone` no nome do bone. Tem de ser usado, mesmo para o end bone.
{% endhint %}

### Limites

Cada wearable deve manter-se dentro dos seguintes limites de spring bones:

* Máximo **6** de spring chains por wearable
* Máximo **12** total de spring bones (soma de todos os bones em todas as chains)
* Profundidade máxima de chain de **6** bones

## Criando Spring Bones no Blender

Spring bones são bones adicionais que cria no Blender para a armature base do avatar. Os parâmetros físicos são configurados depois no Builder — por agora, só precisa definir a hierarchy dos bones.

Para criar um novo bone, selecione a avatar Armature e, em **Edit Mode**, certifique-se de que o cursor está onde quer que o bone seja criado e pressione **Shift+A**. Outra forma de o fazer é duplicando um bone existente ao pressionar **Shift+D**. Assim que tiver o primeiro bone da chain, pressione **E** para o extrudar e criar o resto da chain.

![Pressione Shift+A para criar um bone onde o cursor está.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a7353847fead3ecb60e9dbc49d9449e914e0efca%2FCreate_Bones.gif?alt=media\&token=227762de-59e9-4338-a33d-9e7dcb905ce7)

É importante notar que uma spring chain não precisa de estar conectada ao skeleton parent, por isso pode colocá-la em qualquer lugar na mesh. No entanto, a spring chain **tem** de estar conectada; não pode deslocar nenhum dos spring bones.

Depois de criar os bones, renomeie-os seguindo a convenção de nomenclatura mencionada acima e certifique-se de fazer o parent da chain ao bone correto. Linhas pontilhadas mostrarão o parent da chain. Se não houver, isso significa que a chain não tem parent. Em **Edit Mode**, selecione primeiro o child, depois selecione o parent e pressione **Ctrl+P** > **Keep Offset**.

![Faça o parenting dos bones selecionando primeiro o child, depois o parent e pressionando Ctrl+P.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-6c10f20fb0392fe39a125e59e1202e638b24ef71%2FParenting_Bones.gif?alt=media\&token=70d36a45-74a1-4910-9a8a-b89830a85caa)

Para renomear um bone, selecione-o em Edit Mode ou Pose Mode, vá para o separador Bone Properties e renomeie-o de acordo com a convenção de nomenclatura. Faça isto para todos os bones da chain.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-acb6f900f22bcf0cf7c7af4df54410f62607497c%2FRename_Bones.png?alt=media\&token=5e094657-611f-4592-aad6-b4ef11c367c2)

{% hint style="info" %}
Dica!

Para garantir que o bone está colocado corretamente, selecione a mesh em **Object Mode** e, em **Edit Mode**, selecione os vertices na área onde quer colocar o bone (pode ser um loop ou um grupo de vertices) > pressione **Shift+S** > **Cursor to Selected.**

Volte para **Object Mode**, selecione a armature > vá para **Edit Mode** > selecione o bone desejado > **Shift+S** > **Selection to cursor**.
{% endhint %}

![Use Shift+S para posicionar o bone no local correto da mesh.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-c3a786c4bfe1487f0312dd69ca6492ea660fa310%2FCreate_Bones2.gif?alt=media\&token=d5df5786-0152-4211-9157-e13ec73e3b63)

### Skinning da Mesh

Skinning é o processo de vincular a mesh à armature, para que se movam em conjunto. Para isso, definimos quanta influência (weight) cada bone terá sobre os vertices. Quanto mais weight, mais o bone deformará a mesh. Para fazer isso, vá para **Object Mode**, selecione primeiro a mesh, pressione **Shift** e selecione a armature, pressione **Ctrl+P**. Há duas formas de o fazer: ou selecione **With Empty Groups** ou **With Automatic Weights**.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a2b003483ddbc0d4f75ed73ad0d18cfd9db5e154%2FParenting_Mesh.gif?alt=media\&token=a8d0b687-09a3-49d4-9f63-16819ed8e49f)

#### With Automatic Weights

Como o nome indica, com este método o Blender tentará definir os skin weights automaticamente, criando vertex groups para cada bone na armature e atribuindo a cada um weights automáticos. Pode funcionar em alguns casos, mas também pode exigir alguns ajustes. Pode verificar os grupos criados clicando no **Data** aba.

Se souber com certeza que não vai precisar de que certos bones afetem a mesh, pode simplesmente clicar no **ícone de cadeado** para bloquear os grupos que quiser, clique no menu dropdown e **Delete All Unlocked Groups** para os remover do objecto. Por exemplo, se estiver a trabalhar num hair, ter grupos para feet e hands não faz sentido. Nesse caso, elimine tudo o que não for a head ou os spring bones, como no exemplo abaixo. Certifique-se também de eliminar o grupo para o end bone da spring chain.

![A eliminar vertex groups.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-6f81dc7daa452a13d7d0dc82235ebefa5f457fad%2FDeleting_Groups.gif?alt=media\&token=019d06ea-14b0-42b0-8be5-8d392c9b5262)

#### With Empty Groups

Neste método, o Blender criará todos os vertex groups para cada bone na armature, mas terão um weight de zero por defeito. Terá de atribuir manualmente os weights em Edit Mode ou pintá-los em Weight Paint. Isto dá-lhe mais controlo sobre o que é afetado por cada grupo e pode ser especialmente útil para hard surfaces ou objectos que precisam de ser totalmente atribuídos a um certo grupo. Em qualquer caso, depois de atribuir os weights, terá de os testar em Pose Mode e depois ajustá-los em Weight Paint.

![Parenting com empty groups.](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-ff94e0142f6a4926a619e5fe99cec63c8ca9a1c4%2FEmpty_Groups_Compressed.gif?alt=media\&token=62edd91e-0c6b-4480-a0c2-39958edd4e69)

#### Pintar Weights

Para testar a mesh com skinning, selecione a armature e vá para **Pose Mode**, defina um keyframe, depois rode os bones para criar outra pose e defina outro keyframe. Assim pode verificar como a mesh se está a deformar com o movimento. Depois de definir as poses, volte para **Object Mode**, selecione a mesh e vá para **Weight Paint**.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-527c8bb63094ba652a3fb1d5352e93a74488708c%2FSetting_Poses_Compressed.gif?alt=media\&token=f43fb889-f1a2-4784-a521-14292691e0ca)

Em **Weight Paint**, no separador Tools encontrará diferentes brushes para ajustar os skin weights. Selecione o Vertex Group que quer editar (se estiverem bloqueados, basta desbloqueá-los para poder editar a influência) e use o brush para adicionar ou remover influência. Preto significa influência zero, enquanto vermelho significa que esse grupo influencia completamente a mesh. Ativar o wireframe em **Overlays** tornará mais fácil ver o que está a pintar.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-c27ffa783f5617d5f0808b2dd6a42abf154b212a%2FWeight_Paint_Compressed.gif?alt=media\&token=9e29dffe-b68f-4d66-979a-1559ddf6e558)

Use os brushes add, subtract ou smooth para obter o resultado desejado. Teste também diferentes poses extremas para ver como a mesh se está a deformar e se não há vertices deixados sem weights. Se estiver satisfeito com o resultado, está na hora de o exportar!

### Exportação

Antes de exportar, certifique-se de apagar qualquer animation clip criado ao testar as poses. Vá para Pose Mode, selecione todos os bones pressionando **Um** e pressione **Ctrl+R**, depois **Ctrl+S** e, por fim, **Ctrl+G** para apagar quaisquer transforms na sua armature. Depois volte ao object mode, mude o Display Mode de View Layer para Blender File, expanda Actions e clique com o botão direito e apague o ficheiro de animação.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-c58ca65a7d3cb67af9da18772399df3285da1506%2FDelete_Action.gif?alt=media\&token=f21d765c-2c40-4ae2-b6fd-ed1f18bac33d)

Se tiver outros objectos na sua scene, como a avatar mesh, desative a visibilidade clicando no ícone do olho no Outliner. Depois, vá para **File** > **Export** > **gltf 2.0 (.glb, .gltf)**. Nas definições de exportação, expanda Include e em **Limit to** ative **Visible Objects**. Clique em Export e está pronto para carregar o seu ficheiro para o Builder!

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-f2b0d6c5f3c5b785a902bf9bb4128611ce7f0cae%2FExport_Settings.png?alt=media\&token=9b43598b-9a6f-4593-93ef-25e26f701ac8)

## Configurar Spring Bones no Builder

Depois de carregar um wearable que contenha `springbone`-named bones, o Builder deteta-os automaticamente e mostra o **Spring Bones** painel de configuração.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-d87462e1ac78ef9158a3291eeb44cb49fb2e979e%2F03_spring_bones_panel.png?alt=media\&token=76283801-febb-4291-8071-67bd4c7696fa)

A partir deste painel pode configurar os parâmetros físicos de cada spring root bone. A pré-visualização do avatar no Builder refletirá imediatamente as suas alterações, para que possa ajustar o comportamento em tempo real.

{% hint style="info" %}
Não pode adicionar novos spring bones a partir do Builder. Os bones já têm de existir no `.glb` ficheiro com a convenção de nomenclatura correta. O Builder apenas lhe permite configurar os parâmetros físicos dos spring bones detetados.
{% endhint %}

### Referência de parâmetros

#### Força de rigidez

|                  |       |
| ---------------- | ----- |
| **Intervalo**    | 0 a 4 |
| **Predefinição** | `2.0` |

Controla o quão fortemente o bone tenta regressar à sua pose de repouso. Esta é a força de recuperação — pense nela como a "rigidez" da mola.

* **0**: O bone não regressará de todo ao repouso — ficará apenas pendurado, mole, sob a gravidade.
* **Valores baixos** (por exemplo, 0–1): O bone fica solto e caído, balançando livremente. Bom para cabelo longo e fluido ou acessórios pendurados leves.
* **Valores altos** (por exemplo, 3–4): O bone é rígido, mantém-se perto da sua posição original e volta rapidamente ao lugar. Bom para cabelo curto ou acessórios rígidos.

#### Força da gravidade

|                  |       |
| ---------------- | ----- |
| **Intervalo**    | 0 a 2 |
| **Predefinição** | `0`   |

Controla a magnitude da força da gravidade que puxa o bone em cada frame.

* **0**: Sem efeito de gravidade — o bone é afetado apenas pela inércia do movimento e pela rigidez.
* **Valores baixos** (por exemplo, 0.3–0.8): puxão gravitacional subtil, bom para a maioria dos acessórios.
* **Valores altos** (por exemplo, 1.5–2.0): puxão gravitacional forte, fazendo o bone cair bastante.

#### Direção da gravidade

|                  |                                  |
| ---------------- | -------------------------------- |
| **Formato**      | vetor X, Y, Z                    |
| **Predefinição** | `X: 0, Y: -1, Z: 0` (para baixo) |

Define a direção da força da gravidade no world space. Por defeito, a gravidade puxa para baixo (Y = -1), simulando a gravidade natural.

| X  | Y  | Z  | Efeito                                       |
| -- | -- | -- | -------------------------------------------- |
| 0  | -1 | 0  | Para baixo (gravidade natural, predefinição) |
| 0  | 1  | 0  | Para cima (efeito flutuante/sobrenatural)    |
| 1  | 0  | 0  | Para a esquerda                              |
| -1 | 0  | 0  | Para a direita                               |
| 0  | 0  | 1  | Para a frente                                |
| 0  | 0  | -1 | Para trás                                    |

Pode combinar eixos (por exemplo, `X: 0.5, Y: -0.5, Z: 0`) para direções diagonais. Isto é útil para simular efeitos semelhantes a vento ou criar um aspeto flutuante para personagens sobrenaturais.

#### Força de arrasto

|                  |       |
| ---------------- | ----- |
| **Intervalo**    | 0 – 1 |
| **Predefinição** | `0.5` |

Controla a rapidez com que o bone perde impulso e se estabiliza. Pense nisso como resistência do ar ou amortecimento.

* **Valores baixos** (por exemplo, 0–0.2): o bone balança livremente durante muito tempo antes de se estabilizar, como um pêndulo com pouco atrito.
* **Valores altos** (por exemplo, 0.7–1.0): o bone estabiliza quase instantaneamente após o movimento, dando uma sensação pesada ou amortecida.
* **1**: O bone mal se move — desaceleração máxima.

#### Centro (Opcional)

|                  |                         |
| ---------------- | ----------------------- |
| **Formato**      | Nome do bone (dropdown) |
| **Predefinição** | Nenhum                  |

um bone de referência opcional usado para calcular o movimento do spring bone em relação a um ponto no avatar, em vez de em relação ao espaço mundial. Isto impede que a spring chain balance excessivamente quando o avatar se move (a andar, a correr).

**Sem um bone central**, os springs calculam a inércia no espaço mundial — cada passo que o avatar dá faz com que os bones reajam como se o mundo inteiro se tivesse movido, resultando em balanço exagerado durante a locomoção.

**Com um bone central**, a simulação usa o espaço desse bone como referencial, por isso apenas os *locais* movimentos do avatar (rodar a cabeça, dobrar o corpo) desencadeiam a reação do spring.

Escolha o bone central com base em onde o wearable está localizado no corpo:

| Localização do wearable                            | Bone central recomendado |
| -------------------------------------------------- | ------------------------ |
| Cabeça (hair, earrings, tiaras)                    | `Avatar_Head`            |
| Parte superior do corpo (capes, necklaces)         | `Avatar_Spine`           |
| Parte inferior do corpo (belts, skirt accessories) | `Avatar_Hips`            |

{% hint style="warning" %}
O bone central **não deve** fazer parte de qualquer spring chain. Deve ser um bone da armature base do avatar.
{% endhint %}

## Casos de uso comuns e valores recomendados

Estes são pontos de partida sugeridos. Ajuste ao seu gosto usando a pré-visualização em tempo real do Builder.

| Caso de uso                   | Rigidez   | Força da gravidade | Dir. da gravidade | Arrasto   | Centro         | Notas                                                           |
| ----------------------------- | --------- | ------------------ | ----------------- | --------- | -------------- | --------------------------------------------------------------- |
| Cabelo longo / rabo de cavalo | 1.0 – 2.0 | 0.3 – 0.8          | 0, -1, 0          | 0.3 – 0.5 | `Avatar_Head`  | Mais bones na chain = movimento mais suave                      |
| Cabelo curto                  | 3.0 – 4.0 | 0 – 0.3            | 0, -1, 0          | 0.4 – 0.6 | `Avatar_Head`  | Maior rigidez mantém o hair junto à cabeça                      |
| Earrings                      | 0.5 – 1.5 | 0.5 – 1.0          | 0, -1, 0          | 0.4 – 0.6 | `Avatar_Head`  | Chain curta (2–3 bones), rigidez mais baixa para ficar a pender |
| Cape / cloak                  | 1.0 – 2.0 | 0.5 – 1.0          | 0, -1, 0          | 0.3 – 0.5 | `Avatar_Spine` | Várias chains paralelas para dar largura                        |
| Belt / hanging ornament       | 1.5 – 2.5 | 0.3 – 0.8          | 0, -1, 0          | 0.5 – 0.7 | `Avatar_Hips`  | Arrasto mais alto para itens mais pesados                       |
| Efeito flutuante / fantasma   | 1.0 – 2.0 | 0.5 – 1.0          | 0, 1, 0           | 0.3 – 0.5 | `Avatar_Spine` | Gravidade para cima para um aspeto sobrenatural                 |

## Limitações

Tenha em mente as seguintes limitações ao trabalhar com spring bones:

* **Sem colliders**: os spring bones não colidem com o corpo do avatar nem com outros bones. As chains podem atravessar a mesh do corpo em poses extremas. Versões futuras poderão adicionar suporte a colliders.
* **Sem interações entre wearables**: as spring chains de cada wearable são independentes. Chains de wearables diferentes não se afetam entre si.
* **Sem vento global**: não existe força de vento ao nível da scene. Pode aproximar um efeito de vento por wearable ajustando a `gravityDir` para uma direção diagonal.
* **Desempenho em avatares remotos**: a simulação de spring bone é desativada para avatares que estão longe do jogador local para poupar desempenho. Os avatares próximos mostrarão a física dos spring bones normalmente.
* **Compatibilidade com clientes alternativos**: wearables com spring bones são compatíveis com versões anteriores em clientes alternativos e em versões mais antigas do Explorer, mas os elementos dos spring bones permanecerão estáticos. Em alguns casos, pode haver pequenos problemas visuais.

## Referência técnica

A física dos spring bones usa dois artefactos separados que funcionam em conjunto:

1. **O `.glb` ficheiro** carrega apenas os nomes dos bones (com o `springbone` token) e a respetiva hierarquia. Nenhum parâmetro físico é guardado no ficheiro do modelo.
2. **Os metadados do item do wearable** (`wearable.data.springBones`) carrega todos os parâmetros físicos em JSON.

Quando configura os parâmetros no Builder, eles são guardados nos metadados do item do wearable — o `.glb` ficheiro nunca é modificado pelas edições dos parâmetros.

Não precisa de interagir diretamente com este formato — o Builder trata da leitura e escrita. Esta secção é fornecida para referência.

### `.glb` Hierarquia de nós (exemplo)

O ficheiro do modelo contém apenas os nomes dos bones e as relações parent-child:

```json
{
  "asset": {"version": "2.0"},
  "nodes": [
    {"name": "Avatar_Head", "children": [1, 2]},
    {"name": "SpringBone_earring_r", "children": [3]},
    {"name": "SpringBone_hair_left", "children": [4]},
    {"name": "springbone_earring_r_tip"},
    {"name": "SpringBone_hair_left_tip"}
  ]
}
```

### Metadados do item (`wearable.data.springBones`)

Os parâmetros físicos são guardados nos metadados do wearable, indexados pelo hash de conteúdo do GLB:

```json
{
  "version": 1,
  "models": {
    "bafkreialsvt77jvpy673cnugp5ggnxfaalfncufweayuk3jbxskh3pelkm": {
      "SpringBone_earring_r": {
        "stiffness": 0.5,
        "gravityPower": 1.0,
        "gravityDir": [0, -1, 0],
        "drag": 0.6,
        "isRoot": true,
        "center": "Avatar_Hips"
      },
      "SpringBone_hair_left": {
        "stiffness": 2.0,
        "gravityPower": 0.8,
        "gravityDir": [0, -1, 0],
        "drag": 0.4,
        "isRoot": true
      }
    }
  }
}
```

* `models` é indexado pelo hash de conteúdo do GLB. Wearables cujas representações masculina e feminina partilham o mesmo `.glb` têm uma única entrada.
* Cada entrada de bone usa o nome exato do nó do `.glb` (sensível a maiúsculas/minúsculas).
* Bones de ponta (por exemplo, `springbone_earring_r_tip`) não precisam de uma entrada de metadados — servem apenas como pontos finais geométricos.

### Parâmetros de metadados

| Parâmetro      | Tipo    | Predefinição | Descrição                                                                                    |
| -------------- | ------- | ------------ | -------------------------------------------------------------------------------------------- |
| `stiffness`    | float   | `2.0`        | Força de restauração em direção à pose de repouso. Intervalo: 0–4.                           |
| `gravityPower` | float   | `0`          | Magnitude da força da gravidade. Intervalo: 0–2.                                             |
| `gravityDir`   | vec3    | `[0, -1, 0]` | Direção da gravidade no espaço global.                                                       |
| `drag`         | float   | `0.5`        | Fator de amortecimento / desaceleração. Intervalo: 0–1.                                      |
| `isRoot`       | boolean | —            | Indica se este nó é a raiz de uma cadeia de spring. É necessário ser `true` para root bones. |
| `center`       | string  | —            | Opcional. Nome de um bone de referência para o cálculo de inércia relativa.                  |


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-pt/wearables-e-emotes/wearables/spring-bones.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.