Reactive Bones

🦴 Secondary Motion Without Making Rigging the Hard Part

Reactive Bones is a complete bone-based secondary motion toolkit for Unity, built for hair, tails, ears, soft-body jiggle, straps, cables, tentacles, cloth strips, plants, accessories, and anything else that should react naturally to character and world movement.

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

Reactive Bones is designed around a visual, editor-first workflow. Set up motion, tune the feel, author collision, and optimize the result without needing to build a custom physics system around it.

🦴 Use Existing Bone Rigs

Already have bones for a ponytail, tail, ears, straps, 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.

Create layered reactive regions using dedicated paint modes:

• Hair
• Tail
• Jiggle

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 protects the existing renderer and original skeleton transform state, including imported armature pre-rotations.

🧩 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, and character parts that use their own matching or similarly structured skeletons.

⚙️ Reusable Physics Profiles

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

Tune:

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

Included starting presets cover common use cases such as:

• Light and heavy ponytails
• Long and short hair
• Animal tails
• Ears
• Antennas
• Soft-body motion
• Straps
• Hanging cables
• Tentacles
• Plant stems
• Cloth strips
• Cartoon-style jiggle

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

🛡️ Smart Collision Manager

Reactive Bones includes a dedicated Smart Collision Manager, keeping collision setup centralized and consistent.

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:

• Generate core Humanoid body collision
• 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.

⚠️ 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 Interaction

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

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

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

🌬️ Wind and Runtime Forces

Add movement beyond animation 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

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

🚀 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 jiggle bones for a mesh that never had them, or filling a scene with optimized secondary motion, Reactive Bones provides one complete workflow from authoring to runtime.

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