Class ManifoldTransforms

Moving, turning, scaling, mirroring and warping Manifold solids. The kernel combines transforms lazily, so chaining them is cheap; angles are in degrees, and rotations turn about the origin, X first, then Y, then Z. Every method returns a new solid.

Index

Constructors

constructor

new ManifoldTransforms(): ManifoldTransforms
Returns ManifoldTransforms

matrix

transform

transform(
inputs: Bit.Inputs.Manifold.TransformDto<ManifoldPointer>,
): Promise<ManifoldPointer>
Applies a 4x4 matrix to a solid.

The matrix is column-major, 16 numbers with the translation at indexes 12 to 14; the kernel reads it as a 3x4 affine transform and ignores the last row.
Parameters
- inputs: Bit.Inputs.Manifold.TransformDto<ManifoldPointer>
  The solid and the matrix
Returns Promise<ManifoldPointer>
The transformed solid
Example
```
const moved = await bitbybit.manifold.manifold.transforms.transform({ manifold: cube, transform: matrix });
```
- Defined in bitbybit-docs.d.ts:39139

transforms

transforms(inputs: TransformsDto<ManifoldPointer>): Promise<ManifoldPointer>
Applies a list of 4x4 matrices to a solid one after another, first to last, and returns the final result.

An empty list throws an error.
Parameters
- inputs: TransformsDto<ManifoldPointer>
  The solid and the matrices
Returns Promise<ManifoldPointer>
The solid after all the matrices
Example
```
const placed = await bitbybit.manifold.manifold.transforms.transforms({ manifold: cube, transforms: [turn, move] });
```
- Defined in bitbybit-docs.d.ts:39155

multiple

translateByVectors

translateByVectors(
inputs: TranslateByVectorsDto<ManifoldPointer>,
): Promise<ManifoldPointer[]>
Makes one moved copy of a solid per vector, for laying out repeats.
Parameters
- inputs: TranslateByVectorsDto<ManifoldPointer>
  The solid and the vectors to move copies by
Returns Promise<ManifoldPointer[]>
One moved copy per vector, in the same order
Example
```
const row = await bitbybit.manifold.manifold.transforms.translateByVectors({ manifold: cube, vectors: [[0, 0, 0], [10, 0, 0], [20, 0, 0]] });
```
- Defined in bitbybit-docs.d.ts:39080

transforms

scale3D

scale3D(
inputs: Bit.Inputs.Manifold.Scale3DDto<ManifoldPointer>,
): Promise<ManifoldPointer>
Scales a solid by a separate factor along X, Y and Z, about the origin.
Parameters
- inputs: Bit.Inputs.Manifold.Scale3DDto<ManifoldPointer>
  The solid and the three factors
Returns Promise<ManifoldPointer>
The scaled solid
Example
```
const stretched = await bitbybit.manifold.manifold.transforms.scale3D({ manifold: cube, vector: [1, 2, 1] });
```
- Defined in bitbybit-docs.d.ts:39025

scale

scale(
inputs: Bit.Inputs.Manifold.Scale3DDto<ManifoldPointer>,
): Promise<ManifoldPointer>
Scales a solid by a factor per axis, about the origin; it takes the same inputs as scale3D, so use equal factors for a uniform scale.
Parameters
- inputs: Bit.Inputs.Manifold.Scale3DDto<ManifoldPointer>
  The solid and the three factors
Returns Promise<ManifoldPointer>
The scaled solid
Example
```
const bigger = await bitbybit.manifold.manifold.transforms.scale({ manifold: cube, vector: [2, 2, 2] });
```
- Defined in bitbybit-docs.d.ts:39039

mirror

mirror(
inputs: Bit.Inputs.Manifold.MirrorDto<ManifoldPointer>,
): Promise<ManifoldPointer>
Mirrors a solid across the plane through the origin with the given normal.

A zero-length normal gives an empty solid.
Parameters
- inputs: Bit.Inputs.Manifold.MirrorDto<ManifoldPointer>
  The solid and the normal of the mirror plane
Returns Promise<ManifoldPointer>
The mirrored solid
Example
```
const other = await bitbybit.manifold.manifold.transforms.mirror({ manifold: shape, normal: [1, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:39054

translate

translate(
inputs: Bit.Inputs.Manifold.TranslateDto<ManifoldPointer>,
): Promise<ManifoldPointer>
Moves a solid by a vector, in model units.
Parameters
- inputs: Bit.Inputs.Manifold.TranslateDto<ManifoldPointer>
  The solid and the vector to move it by
Returns Promise<ManifoldPointer>
The moved solid
Example
```
const moved = await bitbybit.manifold.manifold.transforms.translate({ manifold: cube, vector: [10, 0, 0] });
```
- Defined in bitbybit-docs.d.ts:39067

translateXYZ

translateXYZ(inputs: TranslateXYZDto<ManifoldPointer>): Promise<ManifoldPointer>
Moves a solid by separate distances along X, Y and Z, in model units.
Parameters
- inputs: TranslateXYZDto<ManifoldPointer>
  The solid and the three distances
Returns Promise<ManifoldPointer>
The moved solid
Example
```
const moved = await bitbybit.manifold.manifold.transforms.translateXYZ({ manifold: cube, x: 10, y: 0, z: 5 });
```
- Defined in bitbybit-docs.d.ts:39093

rotate

rotate(
inputs: Bit.Inputs.Manifold.RotateDto<ManifoldPointer>,
): Promise<ManifoldPointer>
Rotates a solid about the origin by Euler angles in degrees: first about X, then Y, then Z.

Multiples of 90 degrees are exact, with no rounding error.
Parameters
- inputs: Bit.Inputs.Manifold.RotateDto<ManifoldPointer>
  The solid and the three angles in degrees
Returns Promise<ManifoldPointer>
The rotated solid
Example
```
const turned = await bitbybit.manifold.manifold.transforms.rotate({ manifold: cube, vector: [0, 0, 45] });
```
- Defined in bitbybit-docs.d.ts:39108

rotateXYZ

rotateXYZ(inputs: RotateXYZDto<ManifoldPointer>): Promise<ManifoldPointer>
Rotates a solid about the origin by separate angles in degrees about X, then Y, then Z.

Multiples of 90 degrees are exact, with no rounding error.
Parameters
- inputs: RotateXYZDto<ManifoldPointer>
  The solid and the three angles in degrees
Returns Promise<ManifoldPointer>
The rotated solid
Example
```
const turned = await bitbybit.manifold.manifold.transforms.rotateXYZ({ manifold: cube, x: 0, y: 0, z: 45 });
```
- Defined in bitbybit-docs.d.ts:39123

warp

warp(inputs: ManifoldWarpDto<ManifoldPointer>): Promise<ManifoldPointer>
Moves every vertex of a solid with a function of your own that changes the vertex position in place, for bends, tapers and other free deformations.

The mesh connectivity stays the same and nothing checks that the result still makes sense, so a function that folds the surface through itself gives a broken solid.
Parameters
- inputs: ManifoldWarpDto<ManifoldPointer>
  The solid and the function that moves each vertex
Returns Promise<ManifoldPointer>
The warped solid
Example
```
const bent = await bitbybit.manifold.manifold.transforms.warp({
    manifold: cube,
    warpFunc: (vert) => { vert[0] += vert[2] * 0.2; },
});
```
- Defined in bitbybit-docs.d.ts:39175

Class ManifoldTransforms

Index

Constructors

matrix

multiple

transforms

Constructors

constructor

Returns ManifoldTransforms

matrix

transform

Parameters

Returns Promise<ManifoldPointer>

Example

transforms

Parameters

Returns Promise<ManifoldPointer>

Example

multiple

translateByVectors

Parameters

Returns Promise<ManifoldPointer[]>

Example

transforms

scale3D

Parameters

Returns Promise<ManifoldPointer>

Example

scale

Parameters

Returns Promise<ManifoldPointer>

Example

mirror

Parameters

Returns Promise<ManifoldPointer>

Example

translate

Parameters

Returns Promise<ManifoldPointer>

Example

translateXYZ

Parameters

Returns Promise<ManifoldPointer>

Example

rotate

Parameters

Returns Promise<ManifoldPointer>

Example

rotateXYZ

Parameters

Returns Promise<ManifoldPointer>

Example

warp

Parameters

Returns Promise<ManifoldPointer>

Example

Settings

On This Page