mirror of
https://github.com/xibyte/jsketcher
synced 2025-12-06 16:33:15 +01:00
639 lines
10 KiB
TypeScript
639 lines
10 KiB
TypeScript
import {BrepOutputData} from "./data/brepOutputData";
|
|
import {Handle} from "./data/handle";
|
|
import {Vec3} from "math/vec";
|
|
import {PrimitiveData} from "engine/data/primitiveData";
|
|
import {EdgeTessellation, FaceTessellation, Tessellation2D} from "engine/tessellation";
|
|
import {BrepInputData} from "engine/data/brepInputData";
|
|
import {Matrix3x4FlatData} from "math/matrix";
|
|
import {CurveData} from "engine/data/curveData";
|
|
|
|
export enum BooleanType {
|
|
UNION = 1,
|
|
SUBTRACT,
|
|
INTERSECT,
|
|
}
|
|
|
|
export interface OperationError {
|
|
error: boolean;
|
|
message?: string;
|
|
}
|
|
|
|
export type GenericResponse = OperationError | {
|
|
|
|
/**
|
|
* List of consumed objects
|
|
*/
|
|
consumed: Handle[];
|
|
|
|
/**
|
|
* List of create by the boolean operation objects
|
|
*/
|
|
created: BrepOutputData[];
|
|
}
|
|
|
|
export type SingleResponse = OperationError | BrepOutputData;
|
|
|
|
export interface EngineAPI_V1 {
|
|
|
|
/**
|
|
* Extrudes a set of 2d paths to 3d object along with the given direction
|
|
*/
|
|
extrude(params: {
|
|
|
|
/**
|
|
* Extrude direction
|
|
*/
|
|
vector: Vec3;
|
|
|
|
/**
|
|
* Sketch to be extruded. Can be thought as a set of wires in the occt terminology
|
|
*/
|
|
sketch: PrimitiveData[][];
|
|
|
|
/**
|
|
* Engine operation tolerance
|
|
*/
|
|
tolerance: number;
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
/**
|
|
* extruded object can be used as a boolean modifier on a given shell
|
|
*/
|
|
boolean: UnaryBooleanOptions;
|
|
|
|
}): SingleResponse;
|
|
|
|
|
|
/**
|
|
* Revolves a set of 2d paths to 3d object along with the given direction
|
|
*/
|
|
revolve(params: {
|
|
|
|
/**
|
|
* Rotation axis origin point or rotation pivot
|
|
*/
|
|
axisOrigin: Vec3;
|
|
|
|
/**
|
|
* Rotation axis direction around which the rotation is performed
|
|
*/
|
|
axisDir: Vec3,
|
|
|
|
/**
|
|
* Angle of rotation. In radians
|
|
*/
|
|
angle: number;
|
|
|
|
/**
|
|
* Primitive paths to be revolved
|
|
*/
|
|
sketch: PrimitiveData[][];
|
|
|
|
/**
|
|
* Engine operation tolerance
|
|
*/
|
|
tolerance: number;
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
/**
|
|
* extruded object can be used as a boolean modifier on a given shell
|
|
*/
|
|
boolean: UnaryBooleanOptions;
|
|
|
|
}): SingleResponse;
|
|
|
|
|
|
/**
|
|
* Loft operation through list of primitive paths. Doesn't support to be a boolean modifier in this version of the API
|
|
*/
|
|
loft(params: {
|
|
|
|
/**
|
|
* Primitive loops though which the loft object is created
|
|
*/
|
|
sections: PrimitiveData[][];
|
|
|
|
/**
|
|
* Engine operation tolerance
|
|
*/
|
|
tolerance: number;
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Split face by edge
|
|
*/
|
|
splitFace(params: {
|
|
|
|
/**
|
|
* Base shape containing face to split
|
|
*/
|
|
shape: Handle;
|
|
|
|
/**
|
|
* Face to split
|
|
*/
|
|
face: Handle;
|
|
|
|
/**
|
|
* Splitting edge
|
|
*/
|
|
edge: {
|
|
|
|
/**
|
|
* Curve definition
|
|
*/
|
|
curve: CurveData;
|
|
|
|
/**
|
|
* Optional bounds for the splitting curve. If uMin supplied uMax should be supplied as well
|
|
*/
|
|
uMin?: number;
|
|
|
|
/**
|
|
* Optional bounds for the splitting curve. If uMax supplied uMin should be supplied as well
|
|
*/
|
|
uMax?: number;
|
|
|
|
};
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Split a shape by plane
|
|
*/
|
|
splitByPlane(params: {
|
|
|
|
/**
|
|
* Base shape containing face to split
|
|
*/
|
|
shape: Handle;
|
|
|
|
/**
|
|
* Splitting plane
|
|
*/
|
|
plane: {
|
|
|
|
/**
|
|
* Plane's point
|
|
*/
|
|
point: Vec3;
|
|
|
|
/**
|
|
* Plane's normal
|
|
*/
|
|
dir: Vec3;
|
|
};
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Defeature a shape by removing faces
|
|
*/
|
|
defeatureFaces(params: {
|
|
|
|
/**
|
|
* Base shape containing faces to remove
|
|
*/
|
|
shape: Handle;
|
|
|
|
/**
|
|
* Faces to remove
|
|
*/
|
|
faces: Handle[];
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Lightweight loft operation returning only tessellation info. Meant to be used as a preview in wizards
|
|
*/
|
|
loftPreview(params: {
|
|
|
|
/**
|
|
* Primitive loops though which the loft object is created
|
|
*/
|
|
sections: PrimitiveData[][];
|
|
|
|
/**
|
|
* Engine operation tolerance
|
|
*/
|
|
tolerance: number;
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
|
|
}): Tessellation2D<Vec3>;
|
|
|
|
|
|
/**
|
|
* Creates a set of fillets on given edges
|
|
*/
|
|
fillet(params: {
|
|
|
|
/**
|
|
* Edges parent model
|
|
*/
|
|
solid: Handle,
|
|
|
|
/**
|
|
* List of edges on which the operation performes
|
|
*/
|
|
edges: {
|
|
|
|
edge: Handle;
|
|
|
|
/**
|
|
* thickness of the fillet from one edge to another
|
|
*/
|
|
thickness: number;
|
|
}[]
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
}): SingleResponse;
|
|
|
|
/**
|
|
* Generic boolean operation on given operands
|
|
*/
|
|
boolean(params: {
|
|
|
|
type: BooleanType;
|
|
|
|
operandsA: Handle[],
|
|
|
|
operandsB: Handle[],
|
|
|
|
/**
|
|
* Engine operation tolerance
|
|
*/
|
|
tolerance: number;
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
}): OperationError | {
|
|
result: BrepOutputData
|
|
};
|
|
|
|
|
|
/**
|
|
* Creates a box
|
|
*/
|
|
createBox(params: {
|
|
|
|
/**
|
|
* Coordinate system in which the box will be created.
|
|
*/
|
|
csys: CSysOptions,
|
|
|
|
/**
|
|
* width of the box
|
|
*/
|
|
dx: number;
|
|
|
|
/**
|
|
* height of the box
|
|
*/
|
|
dy: number;
|
|
|
|
/**
|
|
* depth of the box
|
|
*/
|
|
dz: number;
|
|
|
|
/**
|
|
* created object can be used as a boolean modifier on given models
|
|
*/
|
|
boolean: BooleanOptions
|
|
|
|
|
|
}): GenericResponse;
|
|
|
|
|
|
/**
|
|
* Creates a sphere
|
|
*/
|
|
createSphere(params: {
|
|
|
|
/**
|
|
* Coordinate system in which the sphere will be created.
|
|
*/
|
|
csys: CSysOptions,
|
|
|
|
/**
|
|
* radius of the sphere
|
|
*/
|
|
r: number;
|
|
|
|
/**
|
|
* created object can be used as a boolean modifier on given models
|
|
*/
|
|
boolean: BooleanOptions
|
|
|
|
}): GenericResponse;
|
|
|
|
|
|
/**
|
|
* Creates a cone
|
|
*/
|
|
createCone(params: {
|
|
|
|
/**
|
|
* Coordinate system in which the cone will be created.
|
|
*/
|
|
csys: CSysOptions,
|
|
|
|
/**
|
|
* radius of the cone
|
|
*/
|
|
r1: number;
|
|
|
|
/**
|
|
* frustum of the cone
|
|
*/
|
|
r2: number;
|
|
|
|
/**
|
|
* height of the cone
|
|
*/
|
|
h: number;
|
|
|
|
/**
|
|
* created object can be used as a boolean modifier on given models
|
|
*/
|
|
boolean: BooleanOptions
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Creates a cylinder
|
|
*/
|
|
createCylinder(params: {
|
|
|
|
/**
|
|
* Coordinate system in which the cylinder will be created.
|
|
*/
|
|
csys: CSysOptions,
|
|
|
|
/**
|
|
* radius of the cylinder
|
|
*/
|
|
r: number;
|
|
|
|
/**
|
|
* radius of the cylinder
|
|
*/
|
|
h: number,
|
|
|
|
/**
|
|
* created object can be used as a boolean modifier on given models
|
|
*/
|
|
boolean: BooleanOptions
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Creates a torus
|
|
*/
|
|
createTorus(params: {
|
|
|
|
/**
|
|
* Coordinate system in which the torus will be created.
|
|
*/
|
|
csys: CSysOptions,
|
|
|
|
/**
|
|
* main radius
|
|
*/
|
|
r1: number,
|
|
|
|
/**
|
|
* tube radius
|
|
*/
|
|
r2: number
|
|
|
|
/**
|
|
* created object can be used as a boolean modifier on given models
|
|
*/
|
|
boolean: BooleanOptions
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Imports a step file by its 'file reference'. The usage of this API is implementation specific. In webassembly environments
|
|
* the file should exists on the virtual file system before calling this API
|
|
*/
|
|
stepImport(params: {
|
|
|
|
/**
|
|
* File reference. The notion depends on the implementation. In webassmebly it can be a path to file on the virtual file
|
|
* system. On Server side environments it can be a URL
|
|
*/
|
|
file: string
|
|
|
|
}): GenericResponse;
|
|
|
|
/**
|
|
* Load arbitrary BREP data into the engine
|
|
* See example at @BrepInputData
|
|
*/
|
|
loadModel(brep: BrepInputData): BrepOutputData;
|
|
|
|
/**
|
|
* Load arbitrary BREP data into the engine.
|
|
*/
|
|
tessellate(request: {
|
|
|
|
/**
|
|
* Engine object reference
|
|
*/
|
|
model: Handle,
|
|
|
|
/**
|
|
* Tessellation detail parameter
|
|
*/
|
|
deflection: number;
|
|
|
|
}): {
|
|
|
|
faces: FaceTessellation[];
|
|
|
|
edges: EdgeTessellation[];
|
|
|
|
};
|
|
|
|
/**
|
|
* Applying transformation matrix
|
|
*/
|
|
transform(request: {
|
|
|
|
/**
|
|
* Engine object reference to transform
|
|
*/
|
|
model: Handle,
|
|
|
|
/**
|
|
* Transformation matrix represented as a flat array
|
|
*/
|
|
matrix: Matrix3x4FlatData;
|
|
|
|
}): BrepOutputData;
|
|
|
|
/**
|
|
* Sets the location for a model. Unlike the transform this method doesn't update the original geometry
|
|
* but virtually moves/rotates the model.
|
|
*/
|
|
setLocation(request: {
|
|
|
|
/**
|
|
* Engine object reference
|
|
*/
|
|
model: Handle,
|
|
|
|
/**
|
|
* Location matrix represented as a flat array
|
|
*/
|
|
matrix: Matrix3x4FlatData;
|
|
|
|
}): void;
|
|
|
|
/**
|
|
* Gets the location assign to the model
|
|
* @see setLocation method
|
|
*/
|
|
getLocation(request: {
|
|
|
|
/**
|
|
* Engine object reference
|
|
*/
|
|
model: Handle,
|
|
|
|
}): Matrix3x4FlatData;
|
|
|
|
/**
|
|
* Returns the model's data
|
|
*/
|
|
getModelData(request: {
|
|
|
|
/**
|
|
* Engine object reference
|
|
*/
|
|
model: Handle,
|
|
|
|
}): BrepOutputData;
|
|
|
|
/**
|
|
* Deletes a given model from memory
|
|
*/
|
|
dispose(request: {
|
|
|
|
/**
|
|
* Engine object reference
|
|
*/
|
|
model: Handle,
|
|
|
|
}): void;
|
|
|
|
}
|
|
|
|
export interface EngineSession {
|
|
|
|
load(): Handle;
|
|
|
|
dispose(): void;
|
|
|
|
}
|
|
|
|
|
|
export interface BooleanOptions {
|
|
|
|
type: BooleanType;
|
|
|
|
/**
|
|
* Array operand on which the boolean operation will be performed
|
|
*/
|
|
operands: Handle[];
|
|
|
|
/**
|
|
* Boolean operation tolerance. Since it's operation can be a complementary operation to some main operation
|
|
* we may control the tolerance separately for the boolean operation
|
|
*/
|
|
tolerance: number;
|
|
|
|
}
|
|
|
|
/**
|
|
* Unlike generic boolean options unary boolean options don't control the tolerance separately. The tolerance of
|
|
* the operation it's embedded into will be used
|
|
*/
|
|
export interface UnaryBooleanOptions {
|
|
|
|
type: BooleanType;
|
|
|
|
/**
|
|
* An operand on which the boolean operation will be performed
|
|
*/
|
|
operand: Handle;
|
|
}
|
|
|
|
/**
|
|
* A coordinate system parameters.
|
|
*/
|
|
export interface CSysOptions {
|
|
|
|
/**
|
|
* Origin(center) of the coordinate system
|
|
*/
|
|
origin: Vec3;
|
|
|
|
/**
|
|
* Z axis direction
|
|
*/
|
|
normal: Vec3;
|
|
|
|
/**
|
|
* X axis direction
|
|
*/
|
|
xDir: Vec3;
|
|
}
|
|
|