> ## Documentation Index
> Fetch the complete documentation index at: https://rust-co.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Clothing

> Commands, exports and events for temporary clothing, gun belts/holsters, pants tuck, sleeves, collars and radial menus.

Quick Clothing is for **temporary gameplay changes**: take a hat off, hide holsters, remove a gun belt, roll sleeves, tuck pants into boots, remove a coat and put it back later.

It is deliberately separate from the saved appearance. A radial menu should not rewrite the character's wardrobe every time the player takes one item off.

## Available visibility categories

```text theme={"dark"}
hat
hairaccessories
mask
eyewear
neckwear
shirt
vest
coat
gloves
gauntlets
bracelets
rings
pants
boots
chaps
spats
gunbelt
belt
holsters
loadout
suspenders
```

The category name is semantic. For example:

* `hat` groups hats, hat accessories, hatbands and headwear;
* `neckwear` groups neckwear, neckties, neckerchiefs and necklaces;
* `gunbelt` groups gun belts and gun-belt accessories;
* `holsters` groups left/right/center/crossdraw/knife/quiver holster components;
* `coat` groups open/closed coats and coat accessories.

## Available transforms

Quick Clothing also exposes transforms that change a supported MP wearable state instead of hiding the garment:

| Transform    | Values                 |
| ------------ | ---------------------- |
| `sleeves`    | `rolled`, `full`       |
| `collar`     | `open`, `closed`       |
| `pants_tuck` | `tucked` or clear/base |

RCO resolves the real wearable state exposed by the current garment. Your integration should not hardcode RDR2 wearable-state hashes.

## Built-in commands

Every visibility category above has a command with the same name:

```text theme={"dark"}
/hat /hairaccessories /mask /eyewear /neckwear
/shirt /vest /coat /gloves /gauntlets /bracelets /rings
/pants /boots /chaps /spats
/gunbelt /belt /holsters /loadout /suspenders
```

Transforms/aliases:

```text theme={"dark"}
/sleeves
/collar
/tuck
/tuckpants
/closedcoat
```

For a basic radial menu, calling a command is valid:

```lua theme={"dark"}
ExecuteCommand('holsters')
```

For programmatic integrations, prefer exports because you get a success value and failure reason.

## Client exports

### Generic visibility

```lua theme={"dark"}
local ok, reason = exports['rco-appearance']:ToggleClothing('hat')
local ok, reason = exports['rco-appearance']:ToggleClothing('holsters')
local ok, reason = exports['rco-appearance']:SetClothingVisible('coat', false)
```

### Sleeves and collar

```lua theme={"dark"}
local ok, reason = exports['rco-appearance']:ToggleSleeves()
local ok, reason = exports['rco-appearance']:SetSleeves('rolled')

local ok, reason = exports['rco-appearance']:ToggleCollar()
local ok, reason = exports['rco-appearance']:SetCollar('open')
```

### Pants tuck

```lua theme={"dark"}
local ok, reason = exports['rco-appearance']:TogglePantsTuck()
local ok, reason = exports['rco-appearance']:SetPantsTucked(true)
local ok, reason = exports['rco-appearance']:SetPantsTucked(false)
```

`false` clears the temporary tuck transform and restores the base garment state.

### Named radial helpers

```lua theme={"dark"}
local ok, reason = exports['rco-appearance']:ToggleGunBelt()
local ok, reason = exports['rco-appearance']:ToggleClosedCoat()
```

`ToggleGunBelt()` is a convenience alias for `ToggleClothing('gunbelt')`.

Gun holsters do not need a separate hardcoded helper; use:

```lua theme={"dark"}
exports['rco-appearance']:ToggleClothing('holsters')
```

`ToggleClosedCoat()` toggles the logical `coat` group. RCO handles the coat/closed-coat/accessory composition behind that group.

### State helpers

```lua theme={"dark"}
local ok, reason = exports['rco-appearance']:ResetClothingToggles()
local state = exports['rco-appearance']:GetClothingToggleState()
local visible = exports['rco-appearance']:IsClothingVisible('hat')
```

## Local client events

If your radial/menu system is event-based:

```lua theme={"dark"}
TriggerEvent('rco-appearance:client:ToggleClothing', 'hat')
TriggerEvent('rco-appearance:client:SetClothingVisible', 'holsters', false)

TriggerEvent('rco-appearance:client:ToggleSleeves')
TriggerEvent('rco-appearance:client:SetSleeves', 'rolled')

TriggerEvent('rco-appearance:client:ToggleCollar')
TriggerEvent('rco-appearance:client:SetCollar', 'open')

TriggerEvent('rco-appearance:client:TogglePantsTuck')
TriggerEvent('rco-appearance:client:SetPantsTucked', true)

TriggerEvent('rco-appearance:client:ToggleGunBelt')
TriggerEvent('rco-appearance:client:ToggleClosedCoat')
TriggerEvent('rco-appearance:client:ResetClothingToggles')
```

These are **local client events** (`AddEventHandler`), not network events.

## Server exports

Server-side resources such as medical/job systems can change the same semantic state without inventing their own client protocol:

```lua theme={"dark"}
local state = exports['rco-appearance']:GetPlayerClothingToggleState(source)

local ok, reason = exports['rco-appearance']:SetPlayerClothingVisible(source, 'hat', false)
local ok, reason = exports['rco-appearance']:TogglePlayerClothing(source, 'holsters')
local ok, reason = exports['rco-appearance']:SetPlayerClothingTransform(source, 'sleeves', 'rolled')
local ok, reason = exports['rco-appearance']:SetPlayerClothingTransform(source, 'pants_tuck', 'tucked')
local ok, reason = exports['rco-appearance']:ResetPlayerClothingToggles(source)
```

## Clothing animations

Where a safe native animation exists, Quick Clothing plays a short contextual gesture before applying the visual change. The animation is presentation only: composition validation and the final clothing mutation remain RCO-controlled.

If the animation dictionary cannot load, the clothing state is not allowed to corrupt the saved appearance just to force the animation.

## Why some combinations are blocked

Quick Clothing is intentionally conservative. If removing one item would expose an invalid body composition, RCO returns a reason instead of forcing the change.

Common reasons include:

```text theme={"dark"}
invalid_category
invalid_argument
invalid_transform
no_component
blocked_by_apron
blocked_by_boots
blocked_by_cape
blocked_by_chaps
blocked_by_cloak
blocked_by_coat
blocked_by_dress
blocked_by_gauntlets
blocked_by_heavy_coat
blocked_by_knickers
blocked_by_overalls
blocked_by_poncho
blocked_by_shawl
blocked_by_skirt
blocked_by_spats
blocked_by_spurs
blocked_by_stockings
blocked_by_suspenders
blocked_by_unionsuit
blocked_by_vest
requires_boots
unsupported
unsupported_npc_clothing
unknown_body_state
unsupported_alpha_transition
editor_open
dead
busy
apply_failed
rollback_failed
```

Treat the reason as a normal rejected action, not as a crash condition.

## NPC clothing behavior

NPC clothing needs stricter rules because some meshes carry body-alpha requirements that do not behave like normal MP shop items.

RCO allows safe accessory-style toggles through the NPC pipeline, but structural NPC categories are intentionally protected:

```text theme={"dark"}
shirt
vest
coat
pants
boots
chaps
```

If removing one of those NPC garments could leave the torso/legs invisible, Quick Clothing refuses the action instead of guessing a body state.

Sleeves, collar and pants-tuck transforms are also MP wearable-state features. RCO does not invent those transforms for an NPC mesh that does not expose the same semantics.

## Editor, wardrobe and `/reloadskin`

Quick Clothing state is semantic and temporary.

When the player opens Creator, a tailor, barber or wardrobe, RCO works from the **real base appearance**, not a snapshot contaminated by temporarily hidden clothing. After the editor closes, compatible toggles are revalidated and reapplied.

Example:

```text theme={"dark"}
Player hides hat
  ↓
Opens tailor and buys a different hat
  ↓
Saves
  ↓
Quick Clothing state still says "hat hidden"
  ↓
New hat remains hidden until the player toggles it back on
```

If the new garment no longer supports a previous transform such as rolled sleeves, only that invalid transform is cleared.

## OneSync behavior

Quick Clothing replicates a small **semantic state**, not full appearance snapshots or clothing hashes:

```lua theme={"dark"}
{
    hidden = {
        hat = true,
        holsters = true,
        gunbelt = true,
    },
    transforms = {
        sleeves = 'rolled',
        pants_tuck = 'tucked',
    }
}
```

The server deduplicates equivalent state and protects the client network entry point from machine-speed event floods. Internal server exports are not artificially throttled like an untrusted client NetEvent.

## Need the whole character undressed?

Quick Clothing is category-based. For a medical/bathing/prison flow that needs to remove clothing as a whole, use:

```lua theme={"dark"}
exports['rco-appearance']:Undress()
exports['rco-appearance']:Dress()
```

See [API & events](/rco-appearance/exports#dress-undress).