This article describes the different kinds of geometry that you will find on Flux. Each geometry type has a unique primitive name. By understanding the primitives and their structure you will be able to create and manipulate geometry on Flux.

Types

We define some additional types to help write concise definitions of the contents of each primitive. The formal definition of the types and primitives is available as a json schema.
https://unpkg.com/flux-modelingjs@0.9.7/src/schema/flux-entity.js

1. <string> a JSON string
2. <number> a JSON number
3. <index> a zero-based unsigned integral number
4. <json> any JSON-like structure, not necessarily an object
5. <anything>... - zero or more such entries in array or object
6. <array[dimension...]:type> - JSON fixed array, with specified fixed dimension sizes and underlying type
   1. Examples:
   1. <array[3]:number> is a [ <number>, <number>, <number> ].
   2. <array[2, 2]:number> is a [ [ <number>, <number> ], [ <number>, <number> ] ]

?<anything> an optional object. Used to represent values that may or may not be present

<point>: <array[3]:number>

<xform>: <array[16]:number>

<id>: <string> Must be unique

<bool>: true or false

Primitives

Each of the primitives has common format that defines its type, extra attributes, and core attributes.
{ "primitive": <string>, ?"attributes": <json>,
...}
"primitive" property is used to distinguish entity types.
"attributes" is a set of custom user data, which are attached to entity and carried through operations. Structure of each attribute isn't specified and in fact arbitrary.
The following sections describe the properties for each primitive grouped by category.
Entities that have axis and reference use those vectors to orient the primitive. Reference vector represents the local x axis direction, axis represents z axis direction. If reference vector is not specified, a default of [1,0,0] or orthogonal to axis will be used. If axis vector is not specified, a default of [0,0,1] or orthogonal to reference will be used.

Solid Primitives

Solid primitives represent solid objects that have volume and well defined inside and outside. They are fully three dimensional.

block

"origin": <point>,"dimensions": <array[3]:number>,?"axis": <point>,?"reference": <point>
This is a solid box shape.

sphere

"origin": <point>,"radius": <number>
A nice round sphere.

mesh

"vertices": [ <point>...],"faces": [ [ <index>... ]...]
This is one of the catchall primitives. You can represent any triangle or polygon mesh. The polygons must be convex.

brep

"content": <string>,"format": <string>
A brep is a boundary representation for a shape. They are used to represent solid objects

Sheet Primitives

Sheet primitives are two dimensional surfaces that exist in three dimensional space.

surface

"uDegree": <index>,"vDegree": <index>,"uKnots": [ <number>... ], "vKnots": [ <number>... ], "controlPoints": [ [<point>... ], [<point>...], ... ], ?"weights": [ <number>... ]
This is a classical NURBS surface. It uses a set of control points to represent a smooth surface.
"controlPoints" is an array of NxM size. Presence of "weights" parameter means that surface is rational.
A nurbs surface must match the following rule to be valid.
Ku = N+Du+1
Kv = M+Dv+1
N - number of control points in u direction.
M - number of control points in v direction.
Du - degree in u direction.
Dv - degree in v direction.
Ku - number of knots in u direction.
Kv - number of knots in v direction.

Wire Primitives

Wire primitives are one dimensional curves that exist in three dimensional space.

line

"start": <point>,"end": <point>This is a simple line segment between two points.

polyline

"points": [ <point>... ]A collection of line segments that form a curve.

circle

"origin": <point>,"radius": <number>A round closed line.

ellipse

"origin": <point>,"majorRadius": <number>,"minorRadius": <number>,?"axis": <point>,?"reference": <point>A scaled circle.

curve

"degree": <index>,"knots": [ <number>... ], "controlPoints": [ <point>... ],?"weights": [ <number>... ]This is a smooth NURBS curve with control points that guide the shape.
Presence of "weights" parameter means that curve is rational.
A nurbs curve must match the following rule to be valid.
K = N+D+1
N - number of control points.
D - degree.
K - number of knots.

arc

"start": <point>,"end": <point>,"middle": <point>A subsection of a circle.

rectangle

"origin": <point>,"dimensions": <array[2]:number>,?"axis": <point>,?"reference": <point>A rectilinear outline.

polycurve

"curves": [ <wire>... ]
A polycurve is a collection of wire bodies.

Other

vector

"coords": <point>Vector has structure similar to point, but it represents a position and a direction from the origin.

point

"point": <point>A location in three dimensional space. Does not support orientation, use rectangle for that.

Upcoming

scene

"version": <string>
"elements": [<element>...]A collection of primitives that group and transform other primitives.

layer

"id":<string>,
?"label":<string>,
?"color":<array[3]:number>,
?"visible":<bool>,
"elements": [<id>...]
A layer is a collection of primitives that is used to control rendering.

assembly

"id":<string>
?"matrix":<xform>,
?"label":<string>,
"children":[<id>,...]
An assembly is a group of primitives that transform together.

instance

"id": <string>
?"matrix": <xform>,
?"bbox": <bounding-box>,
?"label":<string>,
"entity": <id>
A container with a transform and id that wraps another primitive. It can be used to make memory efficient references.

Examples

block
{
"origin":[0,0,0],
"dimensions":[1,2,3],
"primitive":"block"
}

sphere
{
"origin":[0,0,0],
"primitive":"sphere",
"radius":10
}

mesh
{
"vertices": [[-1,0,0],[0,1,2],[1,0,0],[0,-1,2]],
"faces":[[0,3,1],[1,3,2]],
"primitive":"mesh"
}

brep
Let's save that for another article.
surface
{
"controlPoints":[[[-8,8,5],[8,8,0]],[[-8,-8,0],[8,-8,5]]],
"primitive":"surface",
"uDegree":1,
"uKnots":[0,0,1,1],
"vDegree":1,
"vKnots":[0,0,1,1]
}

line
{
"end":[2,2,2],
"primitive":"line",
"start":[1,1,1]
}

polyline
{
"points":[[0,0,5],[1,0,5],[2,2,5],[0,1,5]],
"primitive":"polyline"
}

circle
{
"origin":[0,0,0],
"primitive":"circle",
"radius":10
}

ellipse
{
"axis":[1,1,1],
"majorRadius":4,
"minorRadius":1.1,
"origin":[1,1,1],
"primitive":"ellipse"
}

curve
{
"controlPoints":[[0,0,0],[1,0,0],[1,1,0],[0,1,0]],
"degree":3,
"knots":[0,0,0,1,2,3,3,3],
"primitive":"curve"
}

arc
{
"start":[1,0,0],
"middle":[0,1,0],
"end":[-1,0,0],
"primitive":"arc"
}

rectangle
{
"origin": [0,0,0],
"dimensions": [2,2],
"primitive": "rectangle"
}

polycurve
{
"curves":[
{"start":[0,0,0],"middle":[-5,-5,0],"end":[-10,0,0],"primitive":"arc"},
{"start":[0,0,0],"middle":[5,5,0],"end":[10,0,0],"primitive":"arc"}
],
"primitive":"polycurve"
}

vector
{
"coords": [2,2,0],
"primitive": "vector"
}

point
{
"point":[0.001,0.001,0],
"primitive":"point"
}