Bitwise AND operation of two integers (`a & b`)

Returns the boolean intersection of two meshes (`a & b`)

Bitwise OR operation of two integers (`a | b`)

Returns the boolean union of two meshes (`a | b`)

Raises an error if `condition` is false, optionally including `message` in the error

Converts a value to a float

Converts a value to an int

Returns the length/magnitude of a Vec3

Returns the length/magnitude of a Vec2

Returns the number of unicode characters in a string

Returns the number of elements in a sequence. This will fully evaluate the sequence. Calling this with an infinite sequence will result in the program hanging or crashing.

Prints all provided args and kwargs to the console

Renders a mesh to the scene

Renders a light to the scene

Renders a sequence of entities to the scene. The sequence can contain a heterogeneous mix of meshes, lights, and paths (`Seq<Vec3>`). Each entity will be rendered separately.

Converts a value to a string. For simple types like numbers and booleans, this performs the basic conversion as you'd expect. For more complicated or internal types like meshes, lights, sequences, etc., the format is not defined and may change at a later time.

Creates a Vec2 given x, y

Creates a Vec2 with both components set to `value`

Creates a Vec3 given x, y, z

Creates a Vec3 from a Vec2 and a z component

Creates a Vec3 from an x component and a Vec2

Creates a Vec3 with all components set to `value`

Calls `fn` with no arguments, returning its return value

Calls `fn` with the provided arguments, returning its return value

Composes all arguments, returning a callable like `|x| arg1(arg2(arg3(x)))`

Composes a sequence of callables, returning a callable like `|x| callables[0](callables[1](...callables[n](x)))`

Creates an ambient light. Note: This will not do anything until it is added to the scene via `render`

Creates a directional light. Note: This will not do anything until it is added to the scene via `render`

Logical AND operation of two booleans

Inverts the boolean value (logical NOT)

Logical OR operation of two booleans

Logical XOR operation of two booleans

Absolute Value

Absolute Value

Component-wise absolute value of a Vec3

Component-wise absolute value of a Vec2

Returns the arccosine of a numeric value

Returns a Vec3 with the arccosine of each component

Returns a Vec2 with the arccosine of each component

Adds two Vec3s component-wise

a + b

a + b

a + b

Combines two meshes into one mesh containing all geometry from both inputs. This does NOT perform a boolean union; for that, use the `union` function or the `|` operator.

Translates the given mesh by a Vec3 offset

Adds a numeric value to each component of a Vec3

Adds two Vec2s component-wise

Adds a numeric value to each component of a Vec2

Concatenates two strings

Returns the arcsine of a numeric value

Returns a Vec3 with the arcsine of each component

Returns a Vec2 with the arcsine of each component

Returns the arctangent of a numeric value

Returns a Vec3 with the arctangent of each component

Returns a Vec2 with the arctangent of each component

Returns the arctangent of `y / x`, using the signs of both arguments to determine the correct quadrant.

Returns the arctangent of `y / x` for a Vec2, using the signs of both components to determine the correct quadrant.

Rounds a numeric value up to the nearest integer

Rounds each component of a Vec3 up to the nearest integer

Rounds each component of a Vec2 up to the nearest integer

Clamps a value between min and max

Clamps a value between min and max

Clamps each component of a Vec3 between min and max

Clamps each component of a Vec2 between min and max

Cosine

Returns a Vec3 with the cosine of each component

Returns a Vec2 with the cosine of each component

Returns the hyperbolic cosine of a numeric value

Returns a Vec3 with the hyperbolic cosine of each component

Returns a Vec2 with the hyperbolic cosine of each component

Converts degrees to radians

`sqrt((a.x - b.x)^2 + (a.y - b.y)^2 + (a.z - b.z)^2)`

`sqrt((a.x - b.x)^2 + (a.y - b.y)^2`

Returns the component-wise division of two Vec3 values

Divides each element of a Vec3 by a scalar

a / b

a / b

Divides two integers a / b and returns a float. The integers are converted to floats before division. If you need true integer division, use the `mod` function or `%` operator instead.

Returns the component-wise division of two `Vec2`s

Divides each component of a Vec2 by a scalar

`a == b`

`a == b`

`a == b`

`a == b`

`a == b`

`a == b`

Returns the exponential of a numeric value

Returns a Vec3 with the exponential of each component

Returns a Vec2 with the exponential of each component

If the provided float is NaN, non-infinite, or subnormal, returns 0.0. Otherwise, returns the float unchanged.

For each component of the Vec3, if it is NaN, non-infinite, or subnormal, returns 0.0. Otherwise, returns the component unchanged.

For each component of the Vec2, if it is NaN, non-infinite, or subnormal, returns 0.0. Otherwise, returns the component unchanged.

Rounds a numeric value down to the nearest integer

Rounds each component of a Vec3 down to the nearest integer

Rounds each component of a Vec2 down to the nearest integer

Returns the fractional part of a numeric value

Returns a Vec3 with the fractional part of each component

Returns a Vec2 with the fractional part of each component

`a > b`

`a > b`

`a >= b`

`a >= b`

Linearly interpolates between two Vec3 values `a` and `b` by a factor `t`

Linearly interpolates between two numeric values `a` and `b` by a factor `t`

Same as `smoothstep` but with simple linear interpolation instead of Hermite interpolation. It returns 0 if `x < edge0`, 1 if `x > edge1`, and a linear interpolation between 0 and 1 for values of `x` between `edge0` and `edge1`.

Returns the natural logarithm of a numeric value

Returns a Vec3 with the natural logarithm of each component

Returns a Vec2 with the natural logarithm of each component

Returns the base-10 logarithm of a numeric value

Returns a Vec3 with the base-10 logarithm of each component

Returns a Vec2 with the base-10 logarithm of each component

Returns the base-2 logarithm of a numeric value

Returns a Vec3 with the base-2 logarithm of each component

Returns a Vec2 with the base-2 logarithm of each component

TODO: this is currently broken

Orients a mesh to look at a target point. This replaces any currently applied rotation. There's a good chance this implementation is broken too...

`a < b`

`a < b`

`a <= b`

`a <= b`

Returns the minimum of the provided arguments

Returns maximum of the provided arguments

Component-wise maximum of two Vec3s

Component-wise maximum of two Vec2s

Returns the minimum of the provided arguments

Returns minimum of the provided arguments

Component-wise minimum of two Vec3s

Component-wise minimum of two Vec2s

a % b

Floating point modulus (`a % b`)

Returns the component-wise product of two Vec3 values

Multiplied each element of a Vec3 by a scalar

a * b

a * b

a * b

Uniformly scales a mesh by a scalar factor

Scales `mesh` by `factor` along each axis

Returns the component-wise product of two Vec2 values

Multiplied each element of a Vec2 by a scalar

Negates an integer

Negates a float

Negates each component of a Vec3

Inverts a boolean (logical NOT)

Negates each component of a Vec2

`a != b`

`a != b`

`a != b`

`a != b`

`a != b`

`a != b`

Returns a normalized Vec3 (length 1) in the same direction as the input vector

Returns a normalized Vec2 (length 1) in the same direction as the input vector

Passes through the input unchanged (implementation detail of the unary `+` operator)

Passes through the input unchanged (implementation detail of the unary `+` operator)

Passes through the input unchanged (implementation detail of the unary `+` operator)

`Returns `base` raised to the power of `exponent``

Returns a Vec3 with each component raised to the power of `exponent`

Returns a Vec3 with each component raised to the power of `exponent`

Converts radians to degrees

Rounds a numeric value to the nearest integer

Rounds each component of a Vec3 to the nearest integer

Rounds each component of a Vec2 to the nearest integer

Returns -1, 0, or 1 depending on the sign of the input. For infinity, NaN, etc, the behavior is undefined.

Returns -1, 0, or 1 depending on the sign of the input

Returns -1, 0, or 1 depending on the sign of the input element-wise

Returns -1, 0, or 1 depending on the sign of the input element-wise

Returns the sine of a numeric value

Returns the sine of each component of a Vec3

Returns the hyperbolic sine of a numeric value

Returns a Vec3 with the hyperbolic sine of each component

Returns a Vec2 with the hyperbolic sine of each component

Works the same as `smoothstep` in GLSL. It returns 0 if `x < edge0`, 1 if `x > edge1`, and a smooth Hermite interpolation between 0 and 1 for values of `x` between `edge0` and `edge1`.

Square Root

Component-wise square root of a Vec3

Component-wise square root of a Vec2

Component-wise subtraction of two Vec3s

a -b

a - b

a - b

Returns the boolean difference of two meshes (`a - b`). This is equivalent to the `difference` function.

Translates the mesh by (`-offset`)

Subtracts a numeric value from each component of a Vec3

Subtracts two Vec2s component-wise

Subtracts a numeric value from each component of a Vec2

Tangent

Returns the tangent of each component of a Vec3

Returns a Vec2 with the tangent of each component

Returns the hyperbolic tangent of a numeric value

Returns a Vec3 with the hyperbolic tangent of each component

Returns a Vec2 with the hyperbolic tangent of each component

Truncates a numeric value to its integer part

Truncates each component of a Vec3 to its integer part

Truncates each component of a Vec2 to its integer part

Computes an alpha-wrap of a mesh. This is kind of like a concave version of a convex hull. This function is guaranteed to produce watertight/2-manifold outputs. For more details, see here: https://doc.cgal.org/latest/Alpha_wrap_3/index.html

Computes an alpha-wrap of a sequence of points. This is kind of like a concave version of a convex hull. This function is guaranteed to produce watertight/2-manifold outputs. For more details, see here: https://doc.cgal.org/latest/Alpha_wrap_3/index.html

Applies rotation, translation, and scale transforms to the vertices of a mesh, resetting the transforms to identity

Creates a rectangular prism mesh with the specified width, height, and depth

Creates a box using a uniform or vector size

Splits a mesh into its connected components, returning a sequence of meshes where each mesh is a connected component of the input mesh. The sequence of connected components is sorted by vertex count from highest to lowest. This is NOT lazy; the connected components are computed at the time this function is called.

Computes the convex hull of a sequence of points, returning a mesh representing the convex hull

Computes the convex hull of a mesh, returning a mesh representing the convex hull. This will apply all transforms on the mesh, and the returned mesh will have an identity transform.

Generates a cylinder mesh

Remeshes a mesh using a Delaunay refinement of a restricted Delaunay triangulation. TODO improve docs once we understand the behavior of this function better. See the docs for the underlying CGAL function for more details: https://doc.cgal.org/latest/Polygon_mesh_processing/index.html - Section 2.1.2 Remeshing

Returns the boolean difference of two meshes (`a - b`)

Returns the boolean difference of a sequence of meshes (`meshes[0] - meshes[1] - ...`)

Extrudes a mesh in the direction of `up` by displacing each vertex along that direction. This is designed to be used with 2D meshes; using it on meshes with volume or thickness will probably not work.

Extrudes a pipe along a sequence of points. The radius can be constant or vary along the path using a callable.

Builds a fan of triangles from a sequence of points, filling the area inside them. One triangle will be built for each pair of adjacent points in the path, connecting them to the center point.

Flips the normals of a mesh, returning a new mesh with inverted normals. This actually flips the winding order of the mesh's triangles under the hood and re-computes normals based off that.

Generates a flat grid mesh in the XZ plane centered at the origin with the specified size and number of subdivisions.

Generates an icosphere mesh

Returns the boolean intersection of two meshes (`a & b`)

Returns the boolean intersection of a sequence of meshes (`meshes[0] & meshes[1] & ...`)

Returns true if the two meshes intersect, false otherwise

Casts a ray from `ray_origin` in `ray_direction` and checks if it intersects `mesh` within `max_distance` (or any distance if `max_distance` is `nil`)

Remeshes a mesh to have more uniform edge lengths, targeting the specified edge length. See the docs for the underlying CGAL function for more details: https://doc.cgal.org/5.6.3/Polygon_mesh_processing/index.html - Section 2.1.2 Remeshing

Combines a sequence of meshes into one mesh containing all geometry from the inputs. This does NOT perform a boolean union; for that, use the `union` function or the `|` operator to create a union over a sequence of meshes.

Joins a sequence of strings into a single string, inserting the `separator` between each element

Creates a mesh from a sequence of vertices and indices

Creates an empty mesh with no vertices or indices. This can be useful as the initial value for `fold` or and other situations like that.

Moves the mesh so that its origin is at the center of its geometry (averge of all its vertices), returning a new mesh. This will actually modify the vertex positions and preserve any existing transforms.

Distributes a specified number of points uniformly across the surface of a mesh returned as a sequence. If `cb` is Nil or not provided, a sequence of vec3 positions will be returned. If `cb` is provided, the sequence will consist of the return values from calling `cb(pos, normal)` for each sampled point. This is lazy; the points will not be generated until the sequence is consumed.

Remeshes a mesh by identifying planar regions and simplifying them into a simpler set of triangles. This is useful for optimizing meshes produced by a variety of other built-in methods that tend to produce a lot of small triangles in flat areas. See the docs for the underlying CGAL function for more details: https://doc.cgal.org/5.6.3/Polygon_mesh_processing/index.html - Section 2.1.2 Remeshing

Rotates a mesh using a Vec3 of Euler angles (radians)

Rotates a mesh using individual Euler angle components in radians

Rotates a light using a Vec3 of Euler angles (radians)

Rotates a light using individual Euler angle components in radians

Generates a mesh or sequence of meshes by sampling a 3D grid defined by `dims`. For each voxel in the grid, the provided callback will be called with the voxel's coordinate. If the callback returns 0, false, or nil, the voxel will be left empty. If it returns true or any non-zero integer, the voxel will be filled. Values > 1 will use material `n - 1` from the `materials` argument. A separate mesh will be generated for each unique material used. The generated meshes are guaranteed to be 2-manifold/watertight, meaning that they can be further processed by other builtins like `smooth`, `simplify`, CSG (`union`/`intersect`/etc.).

Scales a mesh by separate factors along each axis

Scales a mesh

Sets the default material for all meshes that do not have a specific material set

Sets the material for a mesh

Sets the sharp angle threshold for computing auto-smooth-shaded normals (specified in degrees). If the angle between two adjacent faces is greater than this angle, the edge will be considered sharp.

Simplifies a mesh, reducing the number of vertices. Maintains manifold-ness.

Smooths a mesh using the specified algorithm (defaults to catmullclark). More iterations result in a smoother mesh.

Splits a mesh by a plane, returning a sequence containing two meshes: the part in front of the plane and the part behind the plane. This will apply all transforms on the mesh, and the returned meshes will have an identity transform.

Generates a Stanford bunny mesh, a well-known 3D model often used in computer graphics as a test object. This mesh IS manifold, so it can be used with functions that require a manifold mesh such as mesh boolean ops, `trace_geodesic_path`, and others.

Stitches together a sequence of contours into a single mesh. The contours should be closed loops.

Subdivides a mesh by a plane, splitting all edges and faces that intersect the plane.

Subdivides a mesh by a sequence of planes, splitting all edges and faces that intersect any of the planes. This is more efficient than repeatedly subdividing by a single plane multiple times.

Tessellates a mesh, splitting edges to achieve a target edge length.

Generates a 2D path representing the given text string, triangulates it into a mesh, and optionally extrudes it into 3D. The generated mesh lies in the XZ plane, with Y being the up direction.

Traces a geodesic path across the surface of a mesh, following a sequence of 2D points. The mesh must be manifold. Returns a `Seq<Vec3>` of points on the surface of the mesh that were visited during the walk.

Translates a mesh or light

Translates a mesh or light

Returns the boolean union of two meshes (`a | b`)

Returns the boolean union of a sequence of meshes (`meshes[0] | meshes[1] | ...`)

Generates a Utah teapot mesh, a well-known 3D model often used in computer graphics as a test object. Note that the teapot is NOT manifold, so it cannot be used with functions that require a manifold mesh such as mesh boolean ops, `trace_geodesic_path`, and others.

Returns a sequence of all vertices in a mesh in an arbitrary order

Applies a warp function to each vertex of the mesh, returning a new mesh with each vertex transformed by `fn`.

Generates a sequence of `count` evenly-spaced points along a cubic Bezier curve defined by four control points

Generates a sequence of points defining a Lissajous knot path

Generates a sequence of points defining a superellipse, or rounded rectangle. Returns a sequence of `point_count` `Vec2` points

Generates a sequence of points defining a torus knot path

Samples 3D curl noise at a given position using default parameters

Samples 3D curl noise at a given position using the specified parameters

Samples 2D curl noise at a given position using default parameters

Samples 2D curl noise at a given position using the specified parameters

Samples 3D fractal Brownian motion (FBM) at a given position using default parameters

Samples 3D fractal Brownian motion (FBM) at a given position using the specified parameters

Samples 2D fractal Brownian motion (FBM) at a given position using default parameters

Samples 2D fractal Brownian motion (FBM) at a given position using the specified parameters

Samples 1D fractal Brownian motion (FBM) at a given position using default parameters

Samples 1D fractal Brownian motion (FBM) at a given position using the specified parameters