figureone 0.15.10 → 1.0.0

package/types/js/figure/geometries/lines/lines.d.ts

@@ -0,0 +1,31 @@
+import { Line } from '../../../tools/geometry/Line';
+import { Point } from '../../../tools/geometry/Point';
+import type { TypeDash } from '../../../tools/types';
+import type { TypeArrowHead } from '../arrow';
+import type { OBJ_Arrow } from '../../FigurePrimitives/FigurePrimitiveTypes2D';
+declare function lineSegmentsToPoints(lineSegments: Array<Array<Line>>, linePrimitives: boolean, borderIs: ("negative" | "positive" | "line" | Array<Array<Point>>) | undefined, corner: 'auto' | 'fill' | 'none', close: boolean): [Array<Point>, Array<Array<Point>>];
+declare function joinLinesInPoint(line1: Line, lineNext: Line, corner: 'fill' | 'auto' | 'none'): void;
+declare function joinLinesInTangent(mid: Line, midNext: Line, outside: Line, outsideNext: Line, corner: 'fill' | 'auto' | 'none'): void;
+declare function makePolyLine(pointsIn: Array<Point>, width: number | undefined, close: boolean | undefined, widthIsIn: "mid" | "outside" | "inside" | "positive" | "negative" | number | undefined, cornerStyle: 'auto' | 'none' | 'radius' | 'fill', cornerSize?: number, cornerSides?: number, minAutoCornerAngle?: number, dash?: TypeDash, linePrimitives?: boolean, lineNum?: number, borderIs?: 'positive' | 'negative' | 'line' | Array<Array<Point>>, touchBorderBuffer?: number, arrowIn?: null | TypeArrowHead | {
+    start: OBJ_Arrow | TypeArrowHead;
+    end: OBJ_Arrow | TypeArrowHead;
+} & OBJ_Arrow, precision?: number): [Array<Point>, Array<Array<Point>>, Array<Array<Point>>];
+declare function makePolyLineCorners(pointsIn: Array<Point>, width: number | undefined, close: boolean | undefined, cornerLength: number, widthIs: "mid" | "outside" | "inside" | "positive" | "negative" | undefined, cornerStyle: 'auto' | 'none' | 'radius' | 'fill', cornerSize: number, cornerSides: number, minAutoCornerAngle?: number, linePrimitives?: boolean, lineNum?: number, drawBorderBuffer?: number): (Point[] | Point[][])[];
+declare function addArrows(arrowIn: {
+    start?: {
+        head: TypeArrowHead;
+        length: number;
+        width: number;
+        barb: number;
+        tailWidth: number;
+    };
+    end?: {
+        head: TypeArrowHead;
+        length: number;
+        width: number;
+        barb: number;
+        tailWidth: number;
+    };
+} | null | undefined, startArrowIn: [Point, Point], endArrowIn: [Point, Point], existingTriangles: Array<Point>, existingBorder: Array<Array<Point>>, existingTouchBorder: Array<Array<Point>>, drawBorderBuffer: number, lineWidth: number, onLine: boolean): [Point[], Point[][], Point[][]];
+declare function makeFastPolyLine(pointsIn: Array<Point>, width: number, close: boolean): any[][];
+export { joinLinesInPoint, lineSegmentsToPoints, joinLinesInTangent, makePolyLine, makePolyLineCorners, addArrows, makeFastPolyLine, };

package/types/js/figure/geometries/polygon/polygon.d.ts

@@ -0,0 +1,12 @@
+import { Point } from '../../../tools/g2';
+declare function getPolygonPoints(options: {
+    radius: number;
+    innerRadius?: number;
+    rotation: number;
+    offset: Point;
+    sides: number;
+    sidesToDraw: number;
+    direction: 1 | -1;
+}): Array<Point>;
+declare function getTrisFillPolygon(center: Point, border: Array<Point>, sides: number, sidesToDraw: number): Array<Point>;
+export { getPolygonPoints, getTrisFillPolygon, };

package/types/js/figure/geometries/rectangle.d.ts

@@ -0,0 +1,19 @@
+import { Point } from '../../tools/g2';
+declare function getRectangleBorder(options: {
+    width: number;
+    height: number;
+    xAlign: 'left' | 'center' | 'right' | number;
+    yAlign: 'bottom' | 'middle' | 'top' | number;
+    corner: {
+        radius: number;
+        sides: number;
+    };
+    line?: {
+        widthIs: 'inside' | 'outside' | 'positive' | 'negative' | 'mid' | number;
+        width: number;
+    };
+    drawBorderBuffer: number | Array<Array<Point>>;
+    offset: Point;
+}): Point[];
+declare function rectangleBorderToTris(border: Array<Point>): Point[];
+export { getRectangleBorder, rectangleBorderToTris, };

package/types/js/figure/geometries/triangle.d.ts

@@ -0,0 +1,27 @@
+import { Point } from '../../tools/g2';
+import type { TypeParsablePoint } from '../../tools/g2';
+declare function getTriangleDirection(points: Array<Point>): 1 | -1;
+export type OBJ_Triangle_Defined = {
+    width: number;
+    height: number;
+    top: 'left' | 'right' | 'center';
+    points?: Array<TypeParsablePoint>;
+    SSS?: [number, number, number];
+    ASA?: [number, number, number];
+    AAS?: [number, number, number];
+    SAS?: [number, number, number];
+    direction: 1 | -1;
+    xAlign: 'left' | 'center' | 'right' | number | 'a1' | 'a2' | 'a3' | 's1' | 's2' | 's3' | 'centroid' | 'points';
+    yAlign: 'bottom' | 'middle' | 'top' | number | 'a1' | 'a2' | 'a3' | 's1' | 's2' | 's3' | 'centroid' | 'points';
+    rotation: number | 's1' | 's2' | 's3' | {
+        side?: 's1' | 's2' | 's3';
+        angle?: number;
+    };
+    line?: {
+        widthIs: 'inside' | 'outside' | 'positive' | 'negative' | 'mid';
+        width: number;
+    };
+    drawBorderBuffer: number | Array<Array<TypeParsablePoint>>;
+};
+declare function getTriangleBorder(options: OBJ_Triangle_Defined): Point[];
+export { getTriangleBorder, getTriangleDirection, };

package/types/js/figure/webgl/Atlas.d.ts

@@ -0,0 +1,42 @@
+import FontManager from '../FontManager';
+import { FigureFont } from '../DrawingObjects/TextObject/TextObject';
+import { NotificationManager } from '../../tools/tools';
+import type { TypeColor } from '../../tools/types';
+import type Scene from '../../tools/geometry/scene';
+import type WebGLInstance from './webgl';
+export type OBJ_AtlasMap = {
+    [char: string]: {
+        width: number;
+        ascent: number;
+        descent: number;
+        offsetX: number;
+        offsetY: number;
+    };
+};
+export type OBJ_Atlas = {
+    font?: FigureFont;
+    loadColor?: TypeColor;
+    scene?: Scene;
+    maxCount?: number;
+    timeout?: number;
+    map?: OBJ_AtlasMap;
+};
+export default class Atlas {
+    webgl: WebGLInstance;
+    font: FigureFont;
+    fontSize: number;
+    src: HTMLImageElement | string;
+    fontID: string;
+    dimension: number;
+    loaded: boolean;
+    scene: Scene;
+    canvas: HTMLCanvasElement;
+    fontManager: FontManager;
+    notifications: NotificationManager;
+    map: OBJ_AtlasMap;
+    constructor(webgl: WebGLInstance, options: OBJ_Atlas);
+    srcLoaded(): void;
+    fontLoaded(): void;
+    recreate(): void;
+    createAtlas(scene?: Scene): void;
+}

package/types/js/figure/webgl/shaders.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Options used to compose vertex shader source code.
+ *
+ * Shader source code can be automatically composed for different vertex
+ * dimension (2D vs 3D), coloring and lighting options.
+ *
+ * Composed source code uses specific attribute, uniform and varying names.
+ * Attributes will need to be defined by the user in the `attributes` property
+ * of {@link OBJ_GenericGL}.
+ *
+ * Attributes:
+ * - `vec2 a_vertex`: used to define vertex positions when `dimension = 2`.
+ * - `vec4 a_vertex`: used to define vertex positions when `dimension = 3` -
+ *   Note, for this case an attribute size of only 3 is needed as the fourth
+ *   coordinate (w in the homogenous coordinate system) is automatically filled
+ *   with a 1.
+ * - `vec4 a_color`: used to define the color of a vertex when `color = 'vertex'`
+ * - `vec2 a_texcoord`: used to define the texture coordinates to map the
+ *   vertex to when `color = 'texture'`
+ * - `vec3 a_normal`: used to define the normal vector for a vertex used when
+ *   `light = 'point'` or `light = 'directional'`
+ *
+ *
+ * Uniforms will be defined and updated by FigureOne based on the color and
+ * transform of the primitive, and the scene being used to draw the primitive.
+ * Thus, the uniform variables listed below for are for informational purposes
+ * only.
+ *
+ * Uniforms:
+ * - `mat4 u_worldViewProjectionMatrix`: transfomration matrix that cascades
+ *   projection, camera position, and any additional transformation of the shape
+ * - `float u_z`: define a specific z for all vertices when `dimension = 2`
+ * - `u_worldInverseTranspose`: transpose of inverse world matrix needed for
+ *   to correctly transform normal vectors. Used when `light = 'point'` or
+ *   `light = 'directional'`
+ * - `vec3 u_lightWorldPosition`: defines the position of a point source light
+ *    used when `light = 'point'`
+ * - `mat4 u_worldMatrix`: defines the world matrix transform that orients the
+ *   point source light relative to the shape used when `light = 'point'`.
+ *
+ * Varyings are passed from the vertex shader to the fragement shader. They are
+ * listed here in case the user wants to customize one shader, while relying on
+ * composition for the other. All varying expected by the composed shader will
+ * need to be defined in the custom shader.
+ *
+ * - `vec2 v_texcoord`: pass texture coordinates to fragment shader used when
+ *   `color = 'texture'`
+ * - `vec4 v_color`: pass vertex specific color to fragment shader used when
+ *   `color = 'vertex'`
+ * - `vec3 v_normal`: pass normals (transformed with `u_worldInverseTranspose`)
+ *    to fragment shader used when `light = 'directional'` or `light = 'point'`
+ * - `vec3 v_vertexToLight`: pass vector between point source light and vertex
+ *    to fragment shader used when `light = 'point'`
+ *
+ * @property {2 | 3} [dimension] (`2`)
+ * @property {'vertex' | 'uniform' | 'texture'} [color] (`uniform`)
+ * @property {'point' | 'directional' | null} [light] (`null`)
+ * @interface
+ * @group Shaders
+ */
+export type OBJ_VertexShader = {
+    light?: 'point' | 'directional' | null;
+    color?: 'vertex' | 'uniform' | 'texture';
+    dimension?: 2 | 3;
+};
+/**
+ * A vertex shader can be defined with either:
+ * - `{ src: string, vars: Array<string> }`: a shader source code string and a
+ *   list of attributes and uniforms
+ * - `string`: an identifier to a built-in shader
+ * - {@link OBJ_VertexShader} `| Array<string | number | boolean>`: composing
+ *   options for a composable shader
+ * @group Shaders
+ */
+export type TypeVertexShader = string | {
+    src: string;
+    vars?: Array<string>;
+} | Array<string | number | boolean> | OBJ_VertexShader;
+/**
+ * Options used to compose fragment shader source code.
+ *
+ * Shader source code can be automatically composed for different coloring and
+ * lighting options.
+ *
+ * Composed source code uses specific uniform and varying names.
+ *
+ * Uniforms will be defined and updated by FigureOne based on the color and
+ * transform of the primitive, and the scene being used to draw the primitive.
+ * Thus, the uniform variables listed below for are for informational purposes
+ * only.
+ *
+ * Uniforms:
+ * - `vec4 u_color`: global color for all vertices used all times. When
+ *   `color = 'texture'` or `color = 'vertex'`, only the alpha channel of
+ *   `u_color` is used.
+ * - `sampler2D u_texture`: texture used when `color = 'texture'`.
+ * - `vec3 u_directionalLight`: world space position of directional light
+ *   source used when `light = 'directional'`
+ * - `float u_ambientLight`: ambient light used when `light = 'directional'` or
+ *   `light = 'point'`.
+ *
+ * Varyings are passed from the vertex shader to the fragement shader. They are
+ * listed here in case the user wants to customize one shader, while relying on
+ * composition for the other.
+ *
+ * - `vec2 v_texcoord`: texture coordinates from vertex shader used when
+ *   `color = 'texture'`
+ * - `vec4 v_color`: vertex specific color from vertex shader used when
+ *   `color = 'vertex'`
+ * - `vec3 v_normal`: normals from vertex shader used when
+ *   `light = 'directional'` or `light = 'point'`
+ * - `vec3 v_vertexToLight`: vector between point source light and vertex
+ *    from vertex shader used when `light = 'point'`
+ *
+ * @property {2 | 3} [dimension] (`2`)
+ * @property {'vertex' | 'uniform' | 'texture'} [color] (`uniform`)
+ * @property {'point' | 'directional' | null} [light] (`null`)
+ * @interface
+ * @group Shaders
+ */
+export type OBJ_FragmentShader = {
+    light?: 'point' | 'directional' | null;
+    color?: 'vertex' | 'uniform' | 'texture';
+};
+/**
+ * A fragment shader can be defined with either:
+ * - `{ src: string, vars: Array<string> }`: a shader source code string and a
+ *   list of attributes and uniforms
+ * - `string`: an identifier to a built-in shader
+ * - {@link OBJ_VertexShader} `| Array<string | number | boolean>`: composing
+ *   options for a composable shader
+ * @group Shaders
+ */
+export type TypeFragmentShader = string | {
+    src: string;
+    vars?: Array<string>;
+} | Array<string | number | boolean> | OBJ_FragmentShader;
+declare const getShaders: (vName?: TypeVertexShader, fName?: TypeFragmentShader) => {
+    vertexSource: string;
+    fragmentSource: string;
+    vars: string[];
+};
+export default getShaders;

package/types/js/figure/webgl/target.d.ts

@@ -0,0 +1,9 @@
+import type WebGLInstance from './webgl';
+export default class TargetTexture {
+    fb: WebGLFramebuffer | null;
+    webgl: WebGLInstance;
+    target: WebGLTexture | null;
+    depthBuffer: WebGLRenderbuffer | null;
+    constructor(webgl: WebGLInstance);
+    setFramebufferAttachmentSizes(width: number, height: number): void;
+}

package/types/js/figure/webgl/webgl.d.ts

@@ -0,0 +1,54 @@
+import type { TypeFragmentShader, TypeVertexShader } from './shaders';
+import TargetTexture from './target';
+import FontManager from '../FontManager';
+import { FunctionMap } from '../../tools/FunctionMap';
+import Atlas from './Atlas';
+import type { TypeColor } from '../../tools/types';
+import type { OBJ_Atlas } from './Atlas';
+declare class WebGLInstance {
+    gl: WebGLRenderingContext;
+    program: WebGLProgram;
+    lastUsedProgram: WebGLProgram | null;
+    textures: {
+        [name: string]: {
+            glTexture: WebGLTexture;
+            index: number;
+            state: 'loading' | 'loaded';
+            onLoad: Array<((b: boolean, n: number) => void) | string>;
+        };
+    };
+    atlases: {
+        [atlasId: string]: Atlas;
+    };
+    programs: Array<{
+        vars: Array<string>;
+        vertexShader: {
+            src: string;
+            hash: number;
+        };
+        fragmentShader: {
+            src: string;
+            hash: number;
+        };
+        locations: Record<string, any>;
+        program: WebGLProgram;
+    }>;
+    targetTexture: null | TargetTexture;
+    fnMap: FunctionMap;
+    fontManager: FontManager;
+    addTexture(id: string, data: string | HTMLImageElement | HTMLCanvasElement, loadColor?: TypeColor, repeat?: boolean, onLoad?: null | string | ((b: boolean, n: number) => void), force?: boolean): number;
+    getAtlas(options: OBJ_Atlas): Atlas;
+    recreateAtlases(): void;
+    deleteTexture(id: string): void;
+    contextLost(): void;
+    setTextureData(id: string, image: Record<string, any> | TypeColor, // image data
+    repeat?: boolean): boolean;
+    onLoad(id: string): void;
+    cancel(id: string): void;
+    getProgram(vertexShader: TypeVertexShader, fragmentShader: TypeFragmentShader): number;
+    useProgram(programIndex: number): Record<string, any>;
+    constructor(canvas: HTMLCanvasElement, backgroundColor: Array<number>);
+    init(gl: WebGLRenderingContext): void;
+    resize(): void;
+}
+export default WebGLInstance;

package/types/js/tools/FunctionMap.d.ts

@@ -0,0 +1,69 @@
+declare class GeneralFunctionMap {
+    map: {
+        [id: string]: {
+            fn: Function;
+        };
+    };
+    constructor();
+    add(id: string, fn: Function): void;
+    exec(idOrFn: string | Function | null, ...args: any[]): any;
+    execOnMaps(idOrFn: string | Function | null, mapsIn: Array<Record<string, any>>, ...args: any[]): any;
+}
+declare class GlobalFunctionMap extends GeneralFunctionMap {
+    static instance: GlobalFunctionMap;
+    constructor();
+}
+/**
+ * Function Map
+ *
+ * In FigureOne {@link Recorder}, state is saved in stringified javascript
+ * objects. When the state includes a function (like a trigger method in an
+ * animation for example) then that function is referenced in the state object
+ * as a unique string id.
+ *
+ * When a geometry is loaded, functions that will be captured in state objects
+ * need to be added to a function map. Both {@link Figure} and
+ * {@link FigureElement} have attached function maps as the property `fnMap`.
+ * Therefore, the method is added to either the figure or element function map,
+ * with an associated unique string id, and that string id is used when the
+ * function is used. For example as defined callbacks, triggerAnimationStep and
+ * customAnimationStep callbacks, or recorder slide definitions (`entryState`,
+ * `steadyState`, `leaveState`, `exec`, `execDelta`).
+ *
+ * The funciton map has:
+ * - A map of functions
+ * - A link to a global map of functions (a singleton)
+ * - The ability to execute a function within the map
+ *
+ * @property {FunctionMap} global global function map
+ * @property {Object} map local function map where keys are unique identifiers
+ * and values are the associated functions
+ *
+ * @example
+ * // Add a console function to a FunctionMap and execute it with a parameter
+ * figure.fnMap.add('toConsole', s => console.log(s));
+ * figure.fnMap.exec('toConsole', 'hello');
+ * @group Interactive Video
+ */
+declare class FunctionMap extends GeneralFunctionMap {
+    global: GlobalFunctionMap;
+    constructor();
+    /**
+     * Execute function with arguments.
+     *
+     * @param {string | Function | null} idOrFn If `string`, then a function
+     * in the local map or global map will be executed (local map takes
+     * precedence). If `Function`, then the
+     * function will be exectuted. If `null`, then nothing will happen.
+     * @param {any} ...args arguments to pass to function.
+     */
+    exec(idOrFn: string | Function | null, ...args: any[]): any;
+    execOnMaps(idOrFn: string | Function | null, mapsIn: Array<Record<string, any>>, ...args: any[]): any;
+    /**
+     * Add a function to the map.
+     * @param {string} id unique identifier
+     * @param {Function} fn function to add
+     */
+    add(id: string, fn: Function): void;
+}
+export { FunctionMap, GlobalFunctionMap };

package/types/js/tools/color.d.ts

@@ -0,0 +1,11 @@
+import getCSSColors from './getCssColors';
+import type { TypeColor } from './types';
+declare function RGBToArray(color: string): Array<number>;
+declare function HexToArray(color: string): Array<number>;
+declare function cssColorToArray(cssColorString: string): Array<number> | null;
+declare function colorToInt(color: TypeColor): number[];
+declare function colorArrayToRGBA(color: TypeColor): string;
+declare function colorArrayToRGB(color: TypeColor): string;
+declare function areColorsSame(color1: TypeColor, color2: TypeColor, precision?: number): boolean;
+declare function areColorsWithinDelta(color1: TypeColor, color2: TypeColor, delta?: number): boolean;
+export { RGBToArray, HexToArray, cssColorToArray, colorArrayToRGB, colorArrayToRGBA, getCSSColors, areColorsSame, areColorsWithinDelta, colorToInt, };

package/types/js/tools/colorNames.d.ts

@@ -0,0 +1,2 @@
+declare function colorNames(): Record<string, string>;
+export default colorNames;

package/types/js/tools/d2/polygon.d.ts

@@ -0,0 +1,60 @@
+import { Point } from '../geometry/Point';
+import type { TypeParsablePoint } from '../geometry/Point';
+import type { Type3DMatrix } from '../m3';
+import type { TypeParsableTransform } from '../geometry/Transform';
+/**
+ * @property {TypeParsablePoint} [center] center position of the polygon
+ * @property {number} [radius] distance from center to polygon corner (`1`)
+ * @property {number} [sides] number of polygon sides (`4`)
+ * @property {number} [rotation] rotation offset for first polygon corner (`0`)
+ * @property {1 | -1} [direction] angular direction of corners - 1 is CCW in the
+ * XY plane (`1`)
+ * (`[0,, 0, 0]`)
+ * @property {Type3DMatrix | TypeParsableTransform} [transform] transform
+ * to apply to polygon
+ * @property {2 | 3} [tris] if defined, return an array of numbers representing
+ * the interlaced x/y/z components of points that define triangles that can draw
+ * the polygon. `2` returns just x/y components and `3` returns x/y/z
+ * components.
+ * @group Misc Geometry Creation
+ */
+export interface OBJ_PolygonPoints {
+    center?: TypeParsablePoint;
+    radius?: number;
+    sides?: number;
+    rotation?: number;
+    direction?: 1 | -1;
+    tris?: 2 | 3;
+    transform?: Type3DMatrix | TypeParsableTransform;
+    close?: boolean;
+}
+/**
+ * @property {number} [innerRadius] distance from center to inside polygon
+ * corner
+ *
+ * @extends OBJ_PolygonPoints
+ * @group Misc Geometry Creation
+ */
+export interface OBJ_PolygonLinePoints extends OBJ_PolygonPoints {
+    innerRadius?: number;
+}
+/**
+ * Create points a regular polygon.
+ *
+ * Can return either:
+ * - Array<{@link Point}> - corners of a polygon
+ * - Array<`number`> - interlaced points of triangles used to a polygon fill
+ * @group Geometry Creation
+ */
+declare function polygon(options: OBJ_PolygonPoints): Point[] | number[];
+/**
+ * Create a solid regular polygon line.
+ *
+ * Can return either:
+ * - Array<{@link Point}> - [inner corner 0, outer corner 0, inner corner 1,
+ *   outer corner 1, inner corner 2...]
+ * - Array<`number`> - interlaced points of triangles used to draw a polygon line
+ * @group Geometry Creation
+ */
+declare function polygonLine(options: OBJ_PolygonLinePoints): Point[] | number[];
+export { polygon, polygonLine, };

package/types/js/tools/d3/cone.d.ts

@@ -0,0 +1,57 @@
+import type { TypeParsableLine } from '../geometry/Line';
+import type { TypeParsableTransform } from '../geometry/Transform';
+import type { Point } from '../geometry/Point';
+/**
+ * Cone options object.
+ *
+ * By default, a cone with its base at the origin and its tip along the x axis
+ * will be created.
+ *
+ * @property {number} [sides] number of sides (`10`)
+ * @property {number} [radius] radius of cone base
+ * @property {'curve' | 'flat'} [normals] `flat` normals will make light
+ * shading across a face cone constant. `curve` will gradiate the shading. Use
+ * `curve` to make a surface look more round with fewer number of sides.
+ * (`flat`)
+ * @property {TypeParsableLine} [line] line that can position and
+ * orient the cone. First point of line is cone base center, and second point
+ * is cone tip.
+ * @property {number} [length] length of the cone along the x axis if
+ * `line` isn't defined (`1`)
+ * @property {number} [rotation] rotation of base - this is only noticable for
+ * small numbers of sides (`0`)
+ * @property {TypeParsableTransform} [transform] transform to apply to all
+ * points of cube
+ * @property {boolean} [lines] if `true` then points representing
+ * the edes of the faces will be returned. If `false`, then points
+ * representing two triangles per face and an
+ * associated normal for each point will be returned.
+ * @interface
+ * @group Misc Geometry Creation
+ */
+export type OBJ_ConePoints = {
+    sides?: number;
+    radius?: number;
+    normals?: 'curve' | 'flat';
+    line?: TypeParsableLine;
+    length?: number;
+    rotation?: number;
+    transform?: TypeParsableTransform;
+    lines?: boolean;
+};
+/**
+ * Return points of a cone.
+ *
+ * The points can either represent the triangles that make up each face, or
+ * represent the start and end points lines that are the edges of each face of
+ * the cone.
+ *
+ * If the points represent triangles, then a second array of normal vectors
+ * for each point will be available.
+ *
+ * @property {OBJ_CubePoints} options cone options
+ * @return {[Array<Point>, Array<Point>]} an array of points and normals. If
+ * the points represent lines, then the array of normals will be empty.
+ * @group Geometry Creation
+ */
+export default function cone(options: OBJ_ConePoints): [Point[]] | [Point[], Point[]];

package/types/js/tools/d3/cube.d.ts

@@ -0,0 +1,26 @@
+import type { TypeParsablePoint, Point } from '../geometry/Point';
+import type { TypeParsableTransform } from '../geometry/Transform';
+/**
+ * Cube options object.
+ *
+ * By default, a cube will be constructed around the origin, with the xyz axes
+ * being normal to the cube faces.
+ *
+ * @property {number} [side] side length (`1`)
+ * @property {TypeParsablePoint} [center] center point (`[0, 0]`)
+ * @property {TypeParsableTransform} [transform] transform to apply to all
+ * points of cube
+ * @property {boolean} [lines] if `true` then points representing
+ * the 12 edges of the cube will be returned. If `false`, then points
+ * representing two triangles per face (12 triangles, 36 points) and an
+ * associated normal for each point will be returned. (`false`)
+ * @interface
+ * @group Misc Geometry Creation
+ */
+export type OBJ_CubePoints = {
+    side?: number;
+    center?: TypeParsablePoint;
+    transform?: TypeParsableTransform;
+    lines?: boolean;
+};
+export default function cube(options: OBJ_CubePoints): [Point[]] | [Point[], Point[]];

package/types/js/tools/d3/cylinder.d.ts

@@ -0,0 +1,45 @@
+import type { TypeParsableLine } from '../geometry/Line';
+import type { TypeParsableTransform } from '../geometry/Transform';
+import type { Point } from '../geometry/Point';
+/**
+ * Cylinder options object.
+ *
+ * By default, a cylinder along the x axis will be created.
+ *
+ * @property {number} [sides] number of cylinder sides (`10`)
+ * @property {number} [radius] radius of cylinder (`1`)
+ * @property {'curve' | 'flat'} [normals] `flat` normals will make
+ * shading (from light source) across a face cone constant.
+ * `curve` will gradiate the shading. Use `curve` to make a surface look more
+ * round with fewer number of sides. (`flat`)
+ * @property {TypeParsableLine} [line] line that can position and
+ * orient the cylinder. First point of line is cylinder base center, and second
+ * point is the top center.
+ * @property {number} [length] length of the cylinder if `line` isn't
+ * defined (`1`)
+ * @property {boolean | 1 | 2} [ends] `true` fills both ends of the cylinder.
+ * `false` does not fill ends. `1` fills only the first end. `2` fills only the
+ * the second end. (`true`)
+ * @property {number} [rotation] rotation of base - this is only noticable for
+ * small numbers of sides (`0`)
+ * @property {TypeParsableTransform} [transform] transform to apply to all
+ * points of cube
+ * @property {boolean} [lines] if `true` then points representing
+ * the edes of the faces will be returned. If `false`, then points
+ * representing two triangles per face and an
+ * associated normal for each point will be returned.
+ * @interface
+ * @group Misc Geometry Creation
+ */
+export type OBJ_CylinderPoints = {
+    sides?: number;
+    radius?: number;
+    normals?: 'curve' | 'flat';
+    line?: TypeParsableLine;
+    length?: number;
+    ends?: boolean | 1 | 2;
+    rotation?: number;
+    transform?: TypeParsableTransform;
+    lines?: boolean;
+};
+export default function cylinder(options: OBJ_CylinderPoints): [Point[]] | [Point[], Point[]];