Reactive Bones

🦴 Secondary Motion Without Making Rigging the Hard Part

Reactive Bones is an editor-first secondary motion and collision system for Unity, built for hair, tails, ears, soft motion, straps, cables, tentacles, cloth strips, plants, accessories, and anything else that should react naturally to animation, character movement, forces, and the world around it.

Use the bones your model already has, or generate entirely new reactive regions directly inside Unity with the included Reactive Rig Painter.

Reactive Bones is designed around a visual, production-friendly workflow. Set up motion, separate animation-driven response from world movement, add procedural sway and flicks, author character collision, interact with ordinary Unity Colliders, tune wind and forces, and optimize the final result without building a custom physics system around it.

🦴 Use Existing Bone Rigs

Already have bones for a ponytail, tail, ears, straps, cables, accessories, or another moving part?

The Setup Wizard discovers the hierarchy, handles branching chains, supports multiple independent roots, warns about common rig problems, and creates the Reactive Bone setup for you.

Virtual endpoints allow even simple or short hierarchies to produce natural tip motion without requiring additional visible bones.

🎨 Generate Reactive Rigs Inside Unity

Don’t have the bones you need?

The Reactive Rig Painter lets you paint the region of a Mesh Renderer or Skinned Mesh Renderer that should react, then automatically generates the required bones, skin weights, and Reactive Bone chains.

Choose the root and tip manually, or let Reactive Bones find them automatically.

Control generated bone count, root falloff, centerline smoothing, and weight smoothing. Mirror painted regions across the mesh, assign different Physics Profiles to each layer, and rebuild the rig whenever the recipe changes.

Generated rigs are non-destructive. Reactive Bones keeps the original source mesh available, writes generated output separately, and allows the original renderer to be restored.

Rig generation also preserves important renderer and skeleton state, including existing bounds context and imported armature transform orientation.

⚙️ Reusable Physics Profiles & Motion Shaping

Create reusable Physics Profiles and share them across any number of Reactive Bone chains.

Tune the core physical response with settings such as:

- Damping
- Elasticity
- Stiffness
- Inertia
- Gravity
- External force
- Collision radius
- Solver iterations
- Maximum displacement
- Update rate
- Root-to-tip response curves

Reactive Bones also includes dedicated character-motion shaping so every type of movement does not have to affect secondary motion in the same way.

Control:

- World motion response
- Animation/local motion response
- Velocity influence
- Acceleration shaping
- Maximum motion influence
- Vertical and jump response limiting
- Locomotion pulse
- Airborne motion flattening
- Motion limiting and smoothing

This makes it possible to create cleaner motion for character-mounted rigs while walking, running, jumping, falling, turning, or playing strong animations.

Profiles can then be customized to match your own characters, gameplay, and art style.

🌊 Procedural Sway & Flicks

Reactive Bones can add life even when the underlying character or object is mostly stationary.

Optional procedural motion includes:

- Sway for smooth repeating movement
- Flicks for irregular, less predictable impulses

Use procedural motion for tails, ears, hair, antennae, hanging objects, foliage, accessories, environmental props, and other reactive elements that benefit from subtle autonomous movement.

Procedural motion is blended into the same simulation, allowing it to work alongside stiffness, damping, collision, character movement, wind, and other forces.

🛡️ Smart Collision Manager

Reactive Bones includes a dedicated Smart Collision Manager for centralized character collision setup.

Automatically analyze a character and generate sparse collision coverage from:

- Transform hierarchies
- Skinned Mesh Renderer bone palettes
- Reactive Rig Painter-generated armatures

The planner can combine nearby bones into adaptive capsule coverage instead of blindly creating a collider on every Transform.

You can also:

- Create manual Sphere, Capsule, Box, and Plane volumes
- Lock hand-edited automatic colliders while replanning the rest
- Synchronize collision between connected character and modular armatures
- Tune collision radius across connected Reactive Bone chains
- Convert selected Unity Colliders when an analytical Reactive Bone volume is preferred

Reactive Bone Colliders support both Outside and Inside collision modes, allowing particles to remain outside normal obstacles or be contained within a volume.

🧍 Guided Humanoid Collider Builder

For humanoid characters, Reactive Bones includes a dedicated guided Humanoid Collider Builder.

Map the humanoid skeleton, configure body and limb sizing, preview generated Reactive Bone collision volumes, review the result, and generate coverage throughout the torso, head, arms, and legs.

The workflow is designed to make full-body character collision faster to set up and easier to review than manually authoring every volume one at a time.

Previously edited or locked collision volumes can be preserved while the remaining coverage is regenerated, and connected Reactive Bone chains can be synchronized with the resulting collision setup.

⚠️ When body colliders overlap or intersect a Reactive Bone rig, add the intersecting colliders to that rig’s excluded-collider list when appropriate. This prevents unwanted self-collision, jitter, and constraint instability.

🌍 Direct Unity Collider & Terrain Interaction

Reactive chains can interact directly with ordinary Unity Colliders through Unity Physics.

No Rigidbody or collider conversion is required for normal environment interaction.

Reactive Bones supports world collision with standard scene geometry, including Unity Terrain colliders.

Use layer filtering, trigger handling, self-collision rejection, friction, and configurable broadphase capacity to control which parts of the scene participate.

Depending on the needs of each setup, Reactive Bones can combine:

- Assigned character collision volumes
- World-visible Reactive Bone Colliders
- Ordinary Unity Colliders
- Terrain collision

This allows character rigs such as tails, hair, accessories, or hanging parts to react naturally to the environment without converting the entire scene into a proprietary collider format.

🧩 Modular Character Support

Reactive Bones supports characters built from multiple Skinned Mesh Renderers.

Additional renderers can use:

Shared Armature Weight Transfer

Transfer generated reactive influence to compatible character pieces that share the same skeleton.

Similar Armature Pose Link

Synchronize compatible but separate armatures while preserving their authored offsets. This is useful for modular hair, clothing, accessories, and character parts that use their own matching or similarly structured skeletons.

🌬️ Wind, Gusts & Runtime Forces

Add environmental movement with global or local wind.

Reactive Bone Wind Zones support:

- Global wind
- Spherical zones
- Box zones
- Strength
- Turbulence
- Frequency
- Spatial falloff
- Optional Physics Profile filtering
- Natural strength fluctuation for gusting wind

Wind strength can vary over time instead of behaving like a constant mechanical force, creating stronger gusts and quieter periods for more natural environmental motion.

Runtime scripts can also apply persistent forces or one-shot impulses directly to individual chains.

External forces can be configured for world-relative or character-local behavior depending on the effect you need.

🚀 Built for Runtime Use

Reactive Bones includes several systems designed to keep larger scenes practical:

- Distance-based reduced simulation rates
- Distance-based sleeping
- Offscreen reduced-rate and sleep modes
- Smooth sleep and wake blending
- Teleport detection and recovery
- Fixed-rate simulation
- Configurable solver substeps
- Adaptive fast-motion constraint passes
- Shared spatial broadphase for Reactive Bone Colliders
- Adaptive world simulation budgeting for large numbers of active chains
- Per-chain and global simulation controls

The central Reactive Bone World coordinates simulation, culling, collision discovery, wind, runtime statistics, and simulation budgeting.

🔍 Runtime Debugging

The included Runtime Debugger provides live visibility into the system while the game is running.

Inspect:

- Registered and active chains
- Sleeping and culled chains
- Particle counts
- Collider counts
- Contact counts
- Simulation timing
- Collision broadphase activity
- Adaptive simulation budgeting

Chains also provide optional Scene gizmos for:

- Bones
- Particles
- Collision radii
- Animated targets
- Velocities
- Contacts
- Virtual endpoints
- Bounds

📡 Optional Contact API

Projects that need gameplay reactions can enable contact generation and receive detailed Reactive Bone contact data from scripts.

Contacts expose information such as:

- Contact position
- Contact normal
- Penetration
- Relative speed
- Particle index
- The Reactive Bone Collider or Unity Collider involved

This makes Reactive Bones useful for more than visual motion when a project needs to respond directly to physical contact.

Whether you’re adding life to an existing tail rig, making hair collide with a character’s body, generating new reactive bones for a mesh that never had them, shaping clean character-driven motion, or filling a scene with optimized secondary physics, Reactive Bones provides one complete workflow from authoring to runtime.

🦴 Create the Rig. Tune the Motion. Add the Collision You Need. Ship It. 🚀