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

Deformable

Licensing

The Free, Standard and Developer licenses side by side, how to buy and manage them on the Licenses page, how to activate them in the Blender and Maya plugins and the C, Rust and Python SDKs, and the third-party software Deformable uses.

On this page

Deformable has three licenses. The Free license comes with every copy: the Blender and Maya plugins and the C, Rust and Python SDKs work forever without a key, up to 2,500 tetrahedrons per scene. The Standard license lifts the limit, with 1 device per seat, in the plugins and the SDKs. The Developer license is for one company that ships the engine inside one app, built with the C, Rust or Python SDK, to any number of users. The license check lives in the engine library that the plugins and every SDK load, and one activate call takes either kind of key.

Three licenses

Free license Standard license Developer license
Who Anyone 1 device per seat 1 company, 1 app, any number of users
Works in The Blender and Maya plugins, the C, Rust and Python SDKs The Blender and Maya plugins, the C, Rust and Python SDKs The C, Rust and Python SDKs only. The Blender and Maya plugins refuse it.
Limit 2,500 tetrahedrons per scene None None
Price $0 $99 per seat, one time $499 per app, with 12 months of updates and support. $99 per year to renew them.
Updates Every future version Every future version Every version released before your updates end
Use Your own work, personal and commercial. Not inside apps you give to others. Your own work, personal and commercial Inside the 1 app the key names
Account Not needed Needed to buy Needed for the trial and to buy
Key None tgdfp-xxxxx-xxxxx-xxxxx-xxxxx, checked online A long signed key that starts with tgdfp-, checked offline
Internet Never To activate, then at least once every 7 days Never
Before buying — Use the Free license A 30-day trial key, with no limit
Support This documentation Email Email, while your updates last
Refund — Within 14 days, on the Licenses page None. Try it first with the 30-day trial.
Status line Free license: up to 2,500 tetrahedrons per scene — Buy license Standard license Developer license: followed by your company’s name

To learn Deformable, or for scenes that fit in 2,500 tetrahedrons, use the Free license. To use Deformable without the limit yourself, in a plugin or in your own scripts and programs, take the Standard license. To ship the engine inside an app you give to others, take the Developer license. Prices are in US dollars. The payment page shows the price in your local currency, and you pay in it.

Free license

The Free license needs no account, no key and no internet. Install a plugin or an SDK and use it: every feature works, in every future version, forever. Nothing is sent anywhere, and Deformable writes no license file on your device.

Use it for your own work, personal or commercial, in the plugins or with the SDKs. To ship the engine inside an app that others use, you need a Developer license. The Deformable License Agreement holds the full terms.

The tetrahedron limit

Under the Free license, a scene simulates up to 2,500 tetrahedrons. Every object in it counts, floors included, but a disabled one, which takes no part in the simulation. The mesh tools and render surfaces have no limit.

  • Adding an object that does not fit fails with a message that names the count and the limit, such as Free license: this would simulate 3,120 tetrahedrons; the limit is 2,500 per scene. In an SDK, the object is not added, and a smaller one can still fit.
  • When a scene holds more than fits, for example after a license stopped, the objects that do not fit stay still (they are not simulated), in the order they were added, and the rest of the scene runs. They move again as soon as a license applies.
  • In the plugins, the objects that do not fit show the message, and a scene over the limit says how many tetrahedrons it simulates.

To stay under the limit, lower Target Face Count on the object’s Autocage, use a simpler cage, or simulate fewer objects. See Use fewer tetrahedrons.

Deformable also runs under the Free license whenever a license does not apply: a Standard license that needs to go online, and a Developer trial key that ended. Nothing ever refuses to run: the limit is the only difference.

Your account and the Licenses page

You buy and manage the Standard and the Developer license on the Licenses page of the Tangerina platform, platform.tangerina.io/licenses.

  1. Open platform.tangerina.io/licenses and click Create an account.
  2. Type your name, your email address and a password, and click Create account.
  3. Open the link in the email we send you, to confirm your address. You confirm it once, before you buy a license or start a trial.

The Licenses page starts with one card per product on sale, with its prices, a Buy button for each license, and a Start a free 30-day trial link until your account has had that product’s trial. Below it, two tables list your licenses, newest first, with a search box: Standard licenses and then Developer licenses. Each purchase and each Developer trial is a license of its own, with its own key. Click a license to open its page, which shows:

  • Its status and its current key, with a copy button. Previous keys lists the keys that came before it.
  • Devices, for a Standard license: the devices that use its seats, each with its name, its first activation and its last refresh.
  • Payments: the purchase, renewals and refunds.
  • Its actions: Buy Developer license (on a Developer trial), Renew updates, Replace key, Remove beside a device and Ask for refund, as each applies.

We email you when a license is ready or its updates are renewed, 3 days before a Developer trial ends, 30 days before a Developer license’s updates end, after a refund, and when a license is revoked. The emails link to the license’s page. They never hold the key: you copy it from the page.

Standard license

The Standard license covers the Blender plugin, the Maya plugin and the C, Rust and Python SDKs on one device per seat. One seat covers both plugins and every SDK on that device: there is no separate license for Maya. It is $99 per seat, one time, with no subscription. It is perpetual and covers every future version: every update is included.

In short: buy on the Licenses page, copy the key, activate it in a plugin or an SDK, and use Deformable. It works offline between renewals, which need the internet at least once every 7 days.

Pay $99 Copy the key Activate Standard license
Buy on the Licenses page, copy the key, and activate it in a plugin or an SDK.

Buy a Standard license

  1. Click Buy License in a plugin, or Buy beside Standard license on the Deformable card of the Licenses page. Sign in, or create an account first.
  2. Choose the number of seats, from 1 to 1,000: one per device. Click Continue to checkout.
  3. Pay on the payment page, $99 per seat. It shows the price in your local currency, and you get an invoice with the receipt.
  4. The license page opens and shows your key. It looks like tgdfp-xxxxx-xxxxx-xxxxx-xxxxx. Click the copy button.

A license of several seats has one key: paste the same key on every device. To add seats later, buy another Standard license; it has its own key.

Activate a Standard license

Activate the key in a plugin or from any SDK. One activation is enough for all of them on that device. The device must be online this one time.

In Blender:

  1. Open Edit > Preferences > Add-ons and expand Deformable.
  2. Paste your license key into the License Key field.
  3. Make sure the device is online, and click Activate.
  4. The plugin shows Standard license. The tetrahedron limit is gone.

In Maya:

  1. Choose Deformable Help > License…. The Deformable Preferences window opens.
  2. Paste your license key into the key field of its License section.
  3. Make sure the device is online, and click Activate.
  4. The window shows Standard license. The tetrahedron limit is gone.

From an SDK, call its activate function once with the key, as in The SDKs.

The key’s letter case does not matter, and spaces and line breaks in it are ignored.

One activation per device

On each device, your user account holds one activation. The plugins, your Python scripts and your own programs on that device all share it:

  • A license you activate in one plugin also licenses the other plugin and the SDKs on that device, and a license you activate from an SDK also licenses the plugins.
  • Deactivating in one of them deactivates it for all of them.
  • Reinstalling a plugin or an SDK keeps the license: it is kept in your user folder, outside the plugins and the SDKs.

Another user account on the same device keeps its own state, so it activates the key again. It uses the same seat.

Online and offline

A Standard license needs the internet to activate. After that it works offline, for up to 7 days at a time:

  • While Deformable runs on a device that is online, it renews the license by itself, a few times a day at most. You do not need to do anything. The Blender plugin also checks each time Blender starts, and the Maya plugin each time it loads in Maya’s window.
  • Each renewal lets the license run 7 days offline. When the device was offline for longer, Deformable shows Connect to the internet to renew your Standard license, and the Free license runs, with its limit, until the device is online again. Connect, and Deformable renews the license; in a plugin, click Check Now to renew it at once.
  • In Blender, Deformable follows Allow Online Access (Edit > Preferences > System > Network). While it is off, Deformable contacts nothing, the license runs as long as it runs offline, and the plugin preferences show Online access is off in Blender’s preferences (System > Network).
  • In Maya, the plugin contacts our licensing service whenever the license needs it. Maya has no setting that turns a plugin’s internet access off, so the Maya plugin has none either.
  • Deformable checks the device’s clock. If it is set back by more than an hour, the license is not trusted and the Free license runs, with Connect to the internet to renew your Standard license, until a renewal online succeeds. If the renewal finds the clock wrong, it says The clock of this device is wrong: set the correct time, then try again.

A device that is never online cannot activate a Standard license. For a device without internet, such as a machine on a closed network, use the Free license, or ship your app with a Developer license, which needs no internet.

Devices

A Standard license has as many seats as you bought, 1 device per seat. The license page lists the devices that use them, by the device’s name (its host name), with its First activation and its Last refresh, the last time it renewed the license. Activating the key again on the same device, such as after a reinstall, uses no new seat.

To move a seat to another device:

  1. On the old device, click Deactivate in a plugin’s license section, or call the SDK’s deactivate function. The license is forgotten on that device at once, even offline, and its seat is freed when the device is online. If it is offline, Deformable says Deactivated on this device, but its seat could not be freed: remove this device on the Licenses page: then do step 2.
  2. If the old device is dead, lost or offline, open the license’s page (Manage Licenses in a plugin), click Remove beside it, then Remove device. The seat is free at once. That device learns it at its next renewal, and stops within 7 days if it stays offline.
  3. On the new device, install a plugin or an SDK and activate it with the same key, as in Activate a Standard license.
Old device 1. Deactivate New device 2. Activate Same key
Deactivate the license on the old device first, then activate the same key on the new device.

When every seat is in use, activating says Every seat of this license is in use: remove a device on the Licenses page, or buy another license.

Replace a key

If your key leaked, such as in a public repository, open the license’s page and click Replace key. The license gets a new key, with the same seats, and the old key stops working. On each device that used the old key, click Deactivate (or call the SDK’s deactivate function), then activate the new key. A device that keeps the old key goes back to the Free license at its next renewal, with This license key was revoked.

Lost Standard license key

Sign in to the Licenses page, open the license, and copy its key. If you forgot your password, click Forgot your password? on the sign-in page.

Developer license

The Developer license lets one company ship the engine inside one app, built with the C, Rust or Python SDK, to any number of users. It is $499 per app, with 12 months of updates and support. After that, renewing the updates is $99 per year. Your app carries the key and turns it on each time it starts, offline. A second app needs a second Developer license.

The Developer license works in the SDKs only. The Blender and Maya plugins refuse a Developer key with the message Developer licenses work in the SDKs only: the plugins need a Standard license: to use the plugins without the limit, take a Standard license.

In short: start the 30-day trial on the Licenses page, activate its key in your app, buy the license, and put the full key in the trial key’s place.

Start trial Copy the key Activate Developer license
Activate the trial key in your app, then put the full key in its place after you buy.

Developer trial

  1. Sign in to the Licenses page, or create an account first.
  2. On the Deformable card, click Start a free 30-day trial.
  3. Type your company and the app you build, and click Start Developer trial.
  4. The license page opens and shows the trial key. Click the copy button.

The trial key works for 30 days, with every feature and no tetrahedron limit. It works in any program you build while it lasts: the app’s name is only shown. Use it the way you will use the full key, as in Activate a Developer license. It works offline: the key itself holds the day it ends. Each account has one Developer trial. To try for longer, email support@tangerina.io.

The status line counts the days down, from Developer trial: 30 days left to Developer trial: 1 day left. When the trial key ends, the status is Developer trial ended — Buy license, and a running program goes on under the Free license, with its limit. Activating the ended key at the next start fails with the same message, and the program runs under the Free license.

The trial key is for testing only: never ship it inside your app.

Buy a Developer license

  1. On the Licenses page, open your Developer trial and click Buy Developer license: the company and the app are filled in from the trial. Or click Buy beside Developer license on the Deformable card and type your company and the app you ship.
  2. Click Continue to checkout, and pay $499 on the payment page. It shows the price in your local currency, and you get an invoice with the receipt that names your company and your app. Each renewal gets one too.
  3. The license page opens and shows the full key. Click the copy button.

Buying from your trial keeps the same license, so its page holds the trial key, now replaced, and the full key. The form refuses a company and app that already have a license on your account, with You already have a license for this app. Renew it instead.: renew that license instead of buying a second one. When that license is your Developer trial, it says You have a Developer trial for this app. Buy it from its license page instead.: open the trial and buy from there, as in step 1. Another app is another license.

Activate a Developer license

Your app turns the key on itself, with the SDK’s activate call: the same call that activates a Standard key. The library tells the two apart by their shape: a Developer key is a long key in three parts, tgdfp-<payload hex>-<signature hex>. It checks the key offline, against the signature it carries, and never contacts the network, so the call’s timeout does not matter. Nothing is stored on the device: the key holds for that run of the program only. So:

  • Call activate with the key at every start of your app, as its first Deformable call, before any engine call and before status and refresh. Every scene then runs without the limit from the start, and your app never reads or renews a Standard license of its user’s device.
  • Keep the key inside your app, such as in its code, never in a file that its users read or edit, and never in a public place such as a public repository.
  • To move from the trial key to the full key, or to a renewed key, put the new key in the old key’s place. A running program keeps the first Developer key it activated: activating a different one fails with Another Developer license key is already set in this program, so the new key counts from the next start.
  • Once a Developer key is active, the program refuses a Standard key with This program uses a Developer license.

The code for each SDK is in The SDKs.

Updates and renewals

A full Developer key covers every version of Deformable released before its updates end, 12 months after you buy. Those versions keep working with the key forever, in your app and for all its users: the library compares its own release date with the key’s end of updates, never with today’s date, so an app you shipped never stops.

A version released after your updates end refuses the key with This Developer license covers versions released until followed by the date, — Renew updates. You see this on your own machine as soon as you update the SDK, before you ship anything with it.

To renew, open the license’s page and click Renew updates, and pay $99. The license gets a new key whose updates run 1 year past the old end, or 1 year from today if the old end has passed. Put the new key in your app when you move to a newer version. The old key keeps working for every version it covered. We email you 30 days before your updates end.

Renewals also keep your email support.

What users need

Nothing. On your users’ devices, your app needs no activation, no network, no seat and no end date. Deformable keeps no license state in their user folder and contacts no licensing service. The status line shows Developer license: followed by your company’s name.

The key covers the one app that you named when you bought it, with its updates, new versions and editions under the same name. Ship the engine library only inside that app, keep the key hidden in it, and never pass on the key. Ship the SDK only as the part your app needs to run, never as a way for others to build their own apps on the engine. The Deformable License Agreement holds the full terms.

Lost Developer license key

Sign in to the Licenses page, open the license, and copy its key.

Refunds and reversed payments

  • Standard license: within 14 days of purchase, open the license’s page and click Ask for refund. You get back what you paid, in the currency you paid in, and the key stops working at once. Each device learns it at its next renewal, within a few hours while it is online, and goes back to the Free license. A device that stays offline keeps the license until its 7 days offline run out.
  • Developer license and renewals: there is no refund, because the key works offline and cannot be taken back from an app that already shipped. Try the license first with the 30-day trial.
  • Both: if a payment is reversed, such as by a dispute with your bank, the license stops working. A Standard key stops at each device’s next renewal. A Developer key is refused by the versions of Deformable released after that, with This Developer license key was revoked.

Status lines

Each plugin shows the status line, the Blender plugin in its preferences and the Maya plugin in its Deformable Preferences window, and the SDKs give the same text as the license status’s message.

Status What it means
Free license: up to 2,500 tetrahedrons per scene — Buy license No license is active. Every feature works, up to 2,500 tetrahedrons per scene.
Standard license A Standard license key is active on this device. There is no limit.
Connect to the internet to renew your Standard license The Standard license went 7 days without a renewal, or the clock was set back. The Free license runs until it renews.
Developer trial: 30 days left A Developer trial key is active in this program. The number counts down each day, to Developer trial: 1 day left. There is no limit.
Developer trial ended — Buy license The Developer trial key ended. The Free license runs.
Developer license: followed by the company’s name A full Developer key is active in this program. There is no limit. A long company name is cut short to fit the line.

Status messages

Activating, deactivating, Check Now in the plugins and the SDKs’ refresh can also show these messages.

Standard messages

Message What to do
This is not a license key Copy the key again from the Licenses page. A Standard key looks like tgdfp-xxxxx-xxxxx-xxxxx-xxxxx.
This license key does not exist Check the key for typos, or copy it again from the Licenses page.
This license key is not for Deformable The key is for another Tangerina product. Use your Deformable key.
Every seat of this license is in use: remove a device on the Licenses page, or buy another license See Devices.
This license key was revoked The key was replaced, or its payment was reversed. Copy the current key from the Licenses page.
This license was refunded The license was refunded, so it no longer works. The Free license runs.
This device was removed from the license: activate the key again This device was removed on the Licenses page. Activate the key again, while a seat is free.
Deactivate the current license first A different key is already active here. Deactivate it before you activate another.
Deactivated on this device, but its seat could not be freed: remove this device on the Licenses page The device was offline. See Devices.
Could not reach the licensing service: check the internet connection Connect to the internet, and try again.
The licensing service did not answer: try again in a few minutes Our licensing service is busy or down. Try again later. A device with an active license keeps working meanwhile.
The licensing service’s answer did not verify The answer was not signed by our licensing service, as on a network that rewrites traffic. Try another network.
The licensing service could not read this request: update Deformable Install the newest version of the plugin or the SDK.
The clock of this device is wrong: set the correct time, then try again Correct the date and time of the device.
The license state could not be written in a folder Your user folder is full or read-only. Free space or fix its permissions, then try again.
Online access is off in this program, so the licensing service was not contacted The program turned online access off (in Blender, Allow Online Access; the Maya plugin never turns it off). Turn it on.
This program uses a Developer license The program already activated a Developer key, so it needs no Standard key.

Developer messages

Message What to do
This is not a license key Copy the whole key again from the Licenses page. A Developer key starts with tgdfp- and has three parts.
This license key is not valid The key is cut short, changed or not signed by us. Copy the whole key again from the Licenses page.
This license key needs a newer version of Deformable Update the SDK to the newest version.
This license key is not a Deformable Developer license The key is for another product. Use your Deformable key.
Developer licenses work in the SDKs only: the plugins need a Standard license A Developer key was given to the Blender or Maya plugin. Use a Standard license there.
This Developer license key was revoked Write to support@tangerina.io.
This Developer license covers versions released until a date — Renew updates This version of the SDK came out after your updates ended. Renew them, and put the new key in your app; or keep a version released before that date. See Updates and renewals.
Developer trial ended — Buy license The trial key ended. Buy the license on the Licenses page, or write to support@tangerina.io for a longer trial.
Another Developer license key is already set in this program The program activated a different Developer key earlier in this run. Activate one key only, and restart the program to use another.

Free license messages

Message What to do
Free license: this would simulate a count tetrahedrons; the limit is 2,500 per scene The object would take the scene past the limit, so it stays still: in an SDK the add call adds nothing, and in a plugin the object is not simulated. Use fewer tetrahedrons, or activate a license. See The tetrahedron limit.

Who does what

Step Standard license Developer license
Account, buying and keys The Licenses page: Buy on the Deformable card The Licenses page: Start a free 30-day trial and Buy on the Deformable card
Payment Our payment provider’s payment page, with an invoice Our payment provider’s payment page, with an invoice that names your company and app
Devices, replacing a key and refunds The Licenses page —
Activation and the check The engine library, online once and then at least every 7 days, in the plugins and in every SDK The engine library, offline, in every SDK

Privacy

Under the Free license and the Developer license, the engine library sends nothing. With a Standard license, it contacts our licensing service to activate, renew and deactivate. It sends the key and a device hash, the device’s name when it activates, and afterwards the id the service gave the device. The device hash is made on the device from its hardware id, and is useless outside Deformable. The device’s name is its host name, which the license page shows so you can tell your devices apart. We keep these with each activation and renewal time, and IP addresses for rate limits. The Deformable Privacy Notice holds the details.

The SDKs

The C, Rust and Python SDKs use the engine in your own app. All three licenses work in them: the Free license, with its limit; the Standard license, for your own work on your device, which the SDKs share with the plugins; and the Developer license, for an app you ship to others.

The Standard license belongs to the device where the engine runs. A program you build with an SDK and run on other devices, such as your colleagues’, a server or a render farm, runs under the Free license on each of them unless that device has its own seat. A seat activated inside a container that is thrown away stays taken until you remove it on the Licenses page. To ship the engine inside an app you give to others, you need a Developer license.

The C SDK zip comes from the download section of tangerina.io/deformable, the Rust crate from crates.io and the Python package from PyPI:

SDK How to get it
C The zip for your platform, from the C SDK tab. See C SDK.
Rust cargo add deformable. The first build downloads the engine library for your system. See Rust SDK.
Python pip install deformable. See Python SDK.

Each SDK has the same license calls:

Call What it does
status Reads the license state: the Developer license of this program when it activated one, otherwise the Free or Standard license of this device. It never goes online, so it is cheap to call often.
refresh Renews the Standard license when that is due. On a Standard license, call it when your program starts. Without a key, and under a Developer license, it contacts nothing.
activate Takes either kind of key. A Standard key is activated on this device and needs internet. A Developer key is checked offline and holds for this run of the program.
deactivate Forgets the Standard license on this device at once, even offline, and frees its seat when the device is online. Under a Developer license it contacts nothing and changes nothing.
set online access Keeps your program off the network when its user asked for that: nothing is sent, and the Standard license runs only as long as it runs offline.

With a Developer key active, status, refresh and deactivate return the Developer status and contact nothing. With a Standard key, activate, deactivate and refresh wait for our licensing service for at most the timeout you pass, 15 seconds by default. They are safe to call from any thread.

Activate checks the key itself first. A key in the wrong format, or a Developer key that is not valid, is refused before anything else, with its message, such as This is not a license key or This license key is not valid: the status DEFORMABLE_STATUS_INVALID_ARGUMENT in C, the kind ErrorKind::InvalidArgument in Rust, and in Python a DeformableError with the status INVALID_ARGUMENT (an empty or blank key, or one that holds a NUL character, raises ValueError instead). The same goes for a second Standard key while one is active, a second, different Developer key, and a Standard key in a program that uses a Developer license. It is not a license error, and the license state does not change.

The license errors are these. The error’s message is written to show the user as it is.

Error When
Tetrahedron limit exceeded Under the Free license, adding the object would take the scene past 2,500 tetrahedrons; a disabled object does not count. The error’s first index is the count the scene would simulate, the second the limit. The call that adds the object (add_object, or deformable_scene_add_object in C) adds nothing, and the scene goes on with the objects it holds. It is the only engine call the license can refuse.
License service unavailable Our licensing service could not be reached or did not answer, its answer did not verify, the device’s clock contradicts it, or online access is off.
License key rejected Our licensing service refused the Standard key: it does not exist, was revoked or refunded, is not for Deformable, every seat is in use, or this device was removed. Or the Developer key was refused: it was revoked, its trial ended, its updates ended before this version was released, or the program is Blender or Maya, where Developer licenses do not work.
License storage failed The license state could not be saved in your user folder. The message names the folder.

C

A Standard key, activated once on this device:

c
#include <stdio.h>

#include "deformable.h"

int main(void) {
    DeformableLicenseStatus status;
    if (deformable_license_activate("tgdfp-xxxxx-xxxxx-xxxxx-xxxxx", 15000, &status) != DEFORMABLE_STATUS_OK) {
        fprintf(stderr, "%s\n", deformable_last_error_message());
        return 1;
    }
    printf("%s\n", status.message);
    return 0;
}
text
Standard license

A Developer key, activated at every start of your app, as its first Deformable call. Put the whole key from the Licenses page in place of tgdfp-<payload>-<signature>:

c
#include <stdio.h>

#include "deformable.h"

static const char DEVELOPER_LICENSE_KEY[] = "tgdfp-<payload>-<signature>";

int main(void) {
    DeformableLicenseStatus status;
    if (deformable_license_activate(DEVELOPER_LICENSE_KEY, 15000, &status) != DEFORMABLE_STATUS_OK) {
        fprintf(stderr, "%s\n", deformable_last_error_message());
        return 1;
    }
    printf("%s\n", status.message);
    /* The app's engine calls come after this. */
    return 0;
}
text
Developer license: Acme Inc.

deformable_license_status reads the state, deformable_license_refresh renews it, deformable_license_deactivate frees the seat, and deformable_license_set_online_access(0) keeps the program off the network. The timeouts are in milliseconds. The license statuses are DEFORMABLE_STATUS_TETRAHEDRON_LIMIT_EXCEEDED (44) to DEFORMABLE_STATUS_LICENSE_STORAGE_FAILED (47). See Memory and errors.

Rust

A Standard key, activated once on this device:

rust
use deformable::license;

fn main() -> Result<(), deformable::Error> {
    let status = license::activate("tgdfp-xxxxx-xxxxx-xxxxx-xxxxx", license::DEFAULT_TIMEOUT)?;
    println!("{}", status.message);
    Ok(())
}
text
Standard license

A Developer key, activated at every start of your app, as its first Deformable call:

rust
use deformable::license;

const DEVELOPER_LICENSE_KEY: &str = "tgdfp-<payload>-<signature>";

fn main() -> Result<(), deformable::Error> {
    let status = license::activate(DEVELOPER_LICENSE_KEY, license::DEFAULT_TIMEOUT)?;
    println!("{}", status.message);
    // The app's engine calls come after this.
    Ok(())
}
text
Developer license: Acme Inc.

license::status() reads the state, license::refresh(timeout) renews it, license::deactivate(timeout) frees the seat, and license::set_online_access(false) keeps the program off the network. The license errors are the ErrorKind variants TetrahedronLimitExceeded, LicenseServiceUnavailable, LicenseKeyRejected and LicenseStorageFailed. See Errors and threads.

Python

A Standard key, activated once on this device:

python
import deformable

status = deformable.license.activate("tgdfp-xxxxx-xxxxx-xxxxx-xxxxx")
print(status.message)
text
Standard license

A Developer key, activated at every start of your app, as its first Deformable call:

python
import deformable

DEVELOPER_LICENSE_KEY = "tgdfp-<payload>-<signature>"

status = deformable.license.activate(DEVELOPER_LICENSE_KEY)
print(status.message)
# The app's engine calls come after this.
text
Developer license: Acme Inc.

deformable.license.status() reads the state, deformable.license.refresh() renews it, deformable.license.deactivate() frees the seat, and deformable.license.set_online_access(False) keeps the program off the network. Activate, refresh and deactivate take a timeout in seconds. A refused call raises deformable.LicenseError, a DeformableError, or its subclass TetrahedronLimitExceededError. See Types and errors.

Third-party software

The Tetrahedralize tool of the engine library, which fills a closed triangle mesh with tetrahedrons, is based on Netgen, the mesh generator by Joachim Schöberl, with parts by Johannes Gerstmayr. That part of the engine library is licensed under the GNU Lesser General Public License, version 2.1. The rest of the engine library is proprietary.

The notice and the license text are in THIRD_PARTY_NOTICES.txt, which comes with the Blender plugin’s .zip file, the deformable folder of the Maya plugin, the C SDK’s .zip file, the Rust crate and the Python package.