# three-tween-path

> Uses tweenjs to create a Catmull-Rom curve to move a 3d object along. Can be used to pause between several paths.

Latest version **1.5.1** (published 2021-07-01) · MIT license · 0 weekly downloads

## Install

```sh
npm install three-tween-path
pnpm add three-tween-path
yarn add three-tween-path
bun add three-tween-path
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.5.1 |
| Published | 2021-07-01 |
| First published | 2021-06-13 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 2 |
| Unpacked size | 12.2 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 3 |
| Author | Luca Mueller |
| Maintainers | reignjs |
| Keywords | three-tween-path, three, tween, path, reignjs |

## Links

- npm: https://www.npmjs.com/package/three-tween-path
- Repository: https://github.com/REIGNjs/three-tween-path
- Homepage: https://github.com/REIGNjs/three-tween-path#readme
- Issues: https://github.com/REIGNjs/three-tween-path/issues
- npm.io page: https://npm.io/package/three-tween-path

## Dependencies (2)

- [three](https://npm.io/package/three.md) ^0.129.0
- [@tweenjs/tween.js](https://npm.io/package/@tweenjs/tween.js.md) ^18.6.4

## Alternatives

- [base64url](https://npm.io/package/base64url.md) — 6.1M weekly downloads
- [get-installed-path](https://npm.io/package/get-installed-path.md) — 502.9K weekly downloads
- [@uppy/url](https://npm.io/package/@uppy/url.md) — 185.8K weekly downloads
- [@d3fc/d3fc-shape](https://npm.io/package/@d3fc/d3fc-shape.md) — 16.2K weekly downloads
- [localizer](https://npm.io/package/localizer.md) — 226 weekly downloads

## Recent versions

- 1.5.1 (latest) — 2021-07-01
- 1.5.0 — 2021-06-13
- 1.1.0 — 2021-06-13
- 1.0.0 — 2021-06-13

## README

# Three Tween Path

This module uses TweenJs to create a smooth path (Catmull-Rom) through the given path data (includes vertices, duration and delay between segments).

Install using npm:
```shell
npm i three-tween-path
```

## Usage
Import the module and your path data
```js
import * as THREE from "three";
import TWEEN from "@tweenjs/tween.js";

import * as TweenRoute from "three-tween-path";
import { samplePath } from './samplePath';
```

Create a MultiTween with a given 3d object and the path data
```js
let myTween = TweenRoute.MultiTweenPath(my3dObject, samplePath);
myTween.start();
```

Run the TweenJs update function to keep your tween updated
```js
const animate = () => {
  requestAnimationFrame(animate);
  renderer.render(scene, camera);
  
  //update tween
  TWEEN.update();
};
```

### Callbacks
Use callbacks according to the implementation in tweenjs. A callback can be implemented like this:
```js
const onSegmentStart = () => {
  //could be used to start a running animation or something similar
  console.log("Segment start!");
}

const onSegmentEnd = () => {
  //could stop the running animation and return to an idle animation
  console.log("Segment end!");
}

let sampleTween = TweenRoute.MultiTweenPath(cone, samplePath, onSegmentStart, onSegmentEnd);
sampleTween.start();
```
One callback is run at the beginning of the segment and the other at the end of a segment. Use this to halt any animations or run different kind of tasks.

## Path Data
The path data necessary for the module is in the following structure:
```js
const pathData = [
    {
        path: [
            {x: -40, y: 30, z: -17},
            {x: -43, y: 29, z: -16},
            {x: -42, y: 29, z: -15} //copy to next path for consistency
        ],
        delay: 2000,
        duration: 5000
    },
    {
        path: [
            {x: -42, y: 29, z: -15}, //be sure to include the last vector of the previous path
            {x: -41, y: 29.25, z: -15},
            {x: -18, y: 28, z: -3}
        ],
        delay: 2000,
        duration: 10000
    },
    {
        path: [
            {x: -18, y: 28, z: -3},
            {x: -16.5, y: 28, z: -5},
            {x: -6, y: 28, z: -6}
        ],
        delay: 1000,
        duration: 8000
    }
]
```
Always include the last vertices of the previous path in the subsequent path to avoid choppy transitions.
The duration and delay parameters are measured in milliseconds.

## Example
Clone the repository and run
```shell
npm i
npm start
```
The example is available under localhost:3000
![image](https://user-images.githubusercontent.com/64702286/121824172-76870980-ccaa-11eb-8b84-d53faf893dcf.png)

---
_Source: https://npm.io/package/three-tween-path · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._
