You are viewing the documentation for Deformable v0.5.0, an older version. Read the latest, v0.9.0

Deformable

Overview

What the Tangerina Deformable engine is, what it does, the ways to use it and what it needs.

On this page

Tangerina Deformable is a simulation engine for solid objects that bend, dent and break. It uses the finite element method on tetrahedral meshes, and it runs in games and in plugins for DCC (Digital Content Creation) tools: Blender and Maya. It follows Parker and O’Brien, “Real-Time Deformation and Fracture in a Game Environment” (SCA 2009).

Your mesh Tetrahedrons Simulation
The engine fills your mesh with tetrahedrons and simulates them, so the object can bend, dent and break.

Today there are three ways to use the engine:

  • In Blender, through the Blender plugin. You build and play simulations with geometry nodes, modifiers and menu actions.
  • In Maya, through the Maya plugin. You build and play simulations with Maya nodes, the Deformable menus and the Deformable shelf.
  • In your own application, through the C, Rust and Python SDKs.

The plugins and the SDKs run the same engine, libdeformable, so they give the same results. The ideas they all share are in the Engine guide, starting with How the engine works.

Features

Simulation

  • Elastic objects. Objects deform under load and spring back. Each substep is an implicit solve, so stiff materials stay stable.
  • Plastic objects. Objects can keep a dent or a bend after the load is gone.
  • Fracture. Objects crack and break where the stress is too high, after O’Brien and Hodgins, “Graphical Modeling and Animation of Brittle Fracture” (SIGGRAPH 1999). The pieces then move and collide on their own.
  • Collision. Objects collide with each other and with themselves. Fast objects are also checked along their path within each step.
  • Friction and glue. Objects slide or stick by their friction. Glue holds objects together.
  • Sleep and wake. Objects that come to rest on a support go to sleep and cost little. An impact wakes them again.
  • Control. Drive vertices along an animated path, add forces, change materials during a simulation, and give parts of an object their own material with material regions.
  • Material presets. 43 ready-made materials, from sponge, foam, jelly and rubber through wood, brick, concrete, stone and glass to steel and lead.
  • Repeatable results. The same inputs give exactly the same result on every run and for any number of CPU threads, on the same build.

Mesh tools

The mesh tools turn your meshes into simulation input:

Tool What it does
tetrahedralize Fills a closed mesh with tetrahedrons. Density regions make the tetrahedrons smaller where you need detail.
triangulate Splits polygon meshes into well-shaped triangles under an area and angle limit.
extrude Makes a thin shell of tetrahedrons from a triangle mesh, for thin objects such as sheets and panels.
span_layers Fills with tetrahedrons the space between two triangle meshes that have the same triangles.
autocage Builds a closed cage around any mesh, ready for tetrahedralize.
splinters_from_image Turns a line drawing into a splinter cage: one cell per region of the drawing.
verify_surface Checks a mesh for non-closed boundaries, degenerate faces, self-intersections and other problems before you simulate it.
meshes_intersect Tells whether two tetrahedral meshes overlap.

Render surfaces

embed_surface attaches your detailed render mesh to the simulated tetrahedrons. The render mesh follows the simulation every frame and keeps its UVs, normals and materials. When an object breaks, new inner faces appear on the cracks. With a splinter cage, the object breaks into the shapes of the splinter cells, such as bricks, tiles or glass shards.

Render mesh New inner faces
Your render mesh follows the simulated tetrahedrons, and new inner faces appear on the cracks when the object breaks.

What is in the box

  • The Blender plugin. It adds Deformable nodes to the geometry node editor, Deformable modifiers, and an Object > Deformable menu with actions to create, edit, simulate and bake objects. See Blender plugin.
  • The Maya plugin. It adds Deformable node types, a Deformable menu set and a Deformable shelf with actions to create, edit, simulate and bake objects. See Maya plugin.
  • The C SDK. A zip per platform with libdeformable, as a shared and a static library, one C99 header, deformable.h, and a CMake package. See C SDK.
  • The Rust SDK. The crate deformable: a safe Rust API over libdeformable, the library of the C SDK, with no other crates. See Rust SDK.
  • The Python SDK. The package deformable: pure Python over libdeformable, with no third-party dependencies. Its wheel for each platform carries the library. See Python SDK.
  • The splinter library. Ready-made splinter patterns: 19 line drawings (bricks, paving stones, tiles, parquet, wood, cobblestone, mosaic, broken glass and more) and 14 splinter cages (brick walls, cobblestone, rubble, dirt, glass, wood and wood floors). Each plugin’s zip carries them, and each plugin lists them in its splinter menus.

Everything is in the download section of tangerina.io/deformable, one tab per part:

Tab What you get
Blender plugin The zip for your platform, such as deformable-blender-v0.1.0-macos-arm64.zip.
Maya plugin The zip for your platform, such as deformable-maya-v0.1.0-macos-arm64.zip.
C SDK The zip for your platform, such as deformable-c-v0.1.0-macos-arm64.zip.
Rust SDK The install command: cargo add deformable. The first build downloads the engine library.
Python SDK The install command: pip install deformable.

The newest release comes first; every earlier release stays listed below it with its own zips.

Licensing says which license covers which part.

Requirements

Part Needs
Blender plugin Blender 5.2 or later
Maya plugin Maya 2027. On a Mac, run Maya natively on Apple silicon, not under Rosetta.
C SDK A C99 compiler. make or CMake 3.18 or later is optional.
Rust SDK Rust 1.85 or later. The first build downloads the engine library with curl.
Python SDK Python 3.9 or later. On Linux, glibc 2.28 or later.

Every part runs on macOS (Apple silicon), Linux x64 and Windows x64.

Deformable has three licenses:

  • Free license. Every part works without a key, forever, up to 2,500 tetrahedrons per scene. It needs no account and no internet, and nothing is sent. It is for your own work, personal or commercial.
  • Standalone license. $99 per seat, one time, perpetual, with every future version and email support. It lifts the limit, with 1 device per seat, in the plugins and every SDK alike. It needs the internet to activate, then works offline and renews by itself online, at least once every 7 days.
  • Application license. $499 per app, with 12 months of updates and support, then $99 per year to renew them. It is for a company that ships the engine inside one app, built with the C, Rust or Python SDK: its key works offline, its users need nothing, and the plugins refuse it. Every version released before the updates end keeps working with it forever. A free 30-day trial comes first.

You buy and manage the Standalone and Application licenses on the Licenses page. See Licensing.

Where to go next

  • Licensing: the Free, Standalone and Application licenses, and how to buy and activate them.
  • Support: how to get help and how to report a bug.
  • Engine: the ideas the plugins and the SDKs share.
  • Blender plugin: install the plugin and run your first simulation.
  • Maya plugin: install the plugin and run your first simulation.
  • C SDK: use the engine from C or C++.
  • Rust SDK: use the engine from Rust.
  • Python SDK: use the engine from Python.

To download Deformable, go to tangerina.io/deformable. To compare the licenses, see the pricing on tangerina.io/deformable. To buy one, or to start an Application trial, go to the Licenses page.