@bitbybit-dev/jscad 0.19.0-alpha.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +63 -0
- package/babel.config.cjs +14 -0
- package/babel.config.d.cts +5 -0
- package/index.d.ts +1 -0
- package/index.js +4 -0
- package/jscad-generated.d.ts +1 -0
- package/jscad-generated.js +27486 -0
- package/lib/api/inputs/base-inputs.d.ts +38 -0
- package/lib/api/inputs/base-inputs.js +1 -0
- package/lib/api/inputs/index.d.ts +2 -0
- package/lib/api/inputs/index.js +2 -0
- package/lib/api/inputs/inputs.d.ts +2 -0
- package/lib/api/inputs/inputs.js +2 -0
- package/lib/api/inputs/jscad-inputs.d.ts +1646 -0
- package/lib/api/inputs/jscad-inputs.js +2137 -0
- package/lib/api/jscad-service.d.ts +51 -0
- package/lib/api/jscad-service.js +139 -0
- package/lib/api/services/index.d.ts +8 -0
- package/lib/api/services/index.js +8 -0
- package/lib/api/services/jscad-booleans.d.ts +17 -0
- package/lib/api/services/jscad-booleans.js +34 -0
- package/lib/api/services/jscad-colors.d.ts +11 -0
- package/lib/api/services/jscad-colors.js +14 -0
- package/lib/api/services/jscad-expansions.d.ts +12 -0
- package/lib/api/services/jscad-expansions.js +34 -0
- package/lib/api/services/jscad-extrusions.d.ts +18 -0
- package/lib/api/services/jscad-extrusions.js +44 -0
- package/lib/api/services/jscad-hulls.d.ts +12 -0
- package/lib/api/services/jscad-hulls.js +15 -0
- package/lib/api/services/jscad-path.d.ts +23 -0
- package/lib/api/services/jscad-path.js +64 -0
- package/lib/api/services/jscad-polygon.d.ts +25 -0
- package/lib/api/services/jscad-polygon.js +69 -0
- package/lib/api/services/jscad-shapes.d.ts +32 -0
- package/lib/api/services/jscad-shapes.js +182 -0
- package/lib/api/services/jscad-text.d.ts +14 -0
- package/lib/api/services/jscad-text.js +68 -0
- package/lib/index.d.ts +2 -0
- package/lib/index.js +2 -0
- package/package.json +99 -0
|
@@ -0,0 +1,1646 @@
|
|
|
1
|
+
import { Base } from "./base-inputs";
|
|
2
|
+
export declare namespace JSCAD {
|
|
3
|
+
type JSCADEntity = any;
|
|
4
|
+
class PolylinePropertiesDto {
|
|
5
|
+
/**
|
|
6
|
+
* Provide options without default values
|
|
7
|
+
*/
|
|
8
|
+
constructor(points?: Base.Point3[], isClosed?: boolean);
|
|
9
|
+
/**
|
|
10
|
+
* Points of the polyline
|
|
11
|
+
*/
|
|
12
|
+
points: Base.Point3[];
|
|
13
|
+
/**
|
|
14
|
+
* Can contain is closed information
|
|
15
|
+
*/
|
|
16
|
+
isClosed?: boolean;
|
|
17
|
+
/**
|
|
18
|
+
* Can contain color information
|
|
19
|
+
*/
|
|
20
|
+
color?: string | number[];
|
|
21
|
+
}
|
|
22
|
+
enum solidCornerTypeEnum {
|
|
23
|
+
/**
|
|
24
|
+
* Edges will meet at a corner
|
|
25
|
+
*/
|
|
26
|
+
edge = "edge",
|
|
27
|
+
/**
|
|
28
|
+
* Edges will be rounded on the corner
|
|
29
|
+
*/
|
|
30
|
+
round = "round",
|
|
31
|
+
/**
|
|
32
|
+
* Edges will be chamfered on the corner
|
|
33
|
+
*/
|
|
34
|
+
chamfer = "chamfer"
|
|
35
|
+
}
|
|
36
|
+
enum jscadTextAlignEnum {
|
|
37
|
+
/**
|
|
38
|
+
* Aligns text to the left
|
|
39
|
+
*/
|
|
40
|
+
left = "left",
|
|
41
|
+
/**
|
|
42
|
+
* Aligns text to the center
|
|
43
|
+
*/
|
|
44
|
+
center = "center",
|
|
45
|
+
/**
|
|
46
|
+
* Aligns text to the right
|
|
47
|
+
*/
|
|
48
|
+
right = "right"
|
|
49
|
+
}
|
|
50
|
+
class DrawSolidMeshDto<T> {
|
|
51
|
+
/**
|
|
52
|
+
* Provide options without default values
|
|
53
|
+
*/
|
|
54
|
+
constructor(mesh?: JSCADEntity, opacity?: number, colours?: string | string[], updatable?: boolean, hidden?: boolean, jscadMesh?: T);
|
|
55
|
+
/**
|
|
56
|
+
* Solid Jscad mesh
|
|
57
|
+
*/
|
|
58
|
+
mesh: JSCADEntity;
|
|
59
|
+
/**
|
|
60
|
+
* Value between 0 and 1
|
|
61
|
+
* @default 1
|
|
62
|
+
* @minimum 0
|
|
63
|
+
* @maximum 1
|
|
64
|
+
* @step 0.1
|
|
65
|
+
*/
|
|
66
|
+
opacity: number;
|
|
67
|
+
/**
|
|
68
|
+
* Hex colour string
|
|
69
|
+
* @default #444444
|
|
70
|
+
*/
|
|
71
|
+
colours: string | string[];
|
|
72
|
+
/**
|
|
73
|
+
* Indicates wether this solid will be transformed in time
|
|
74
|
+
* @default false
|
|
75
|
+
*/
|
|
76
|
+
updatable: boolean;
|
|
77
|
+
/**
|
|
78
|
+
* Hidden
|
|
79
|
+
* @default false
|
|
80
|
+
*/
|
|
81
|
+
hidden: boolean;
|
|
82
|
+
/**
|
|
83
|
+
* Solid mesh variable in case it already exists and needs updating
|
|
84
|
+
* @default undefined
|
|
85
|
+
* @optional true
|
|
86
|
+
* @ignore true
|
|
87
|
+
*/
|
|
88
|
+
jscadMesh?: T;
|
|
89
|
+
}
|
|
90
|
+
class DrawSolidMeshesDto<T> {
|
|
91
|
+
/**
|
|
92
|
+
* Provide options without default values
|
|
93
|
+
*/
|
|
94
|
+
constructor(meshes?: JSCADEntity[], opacity?: number, colours?: string | string[], updatable?: boolean, hidden?: boolean, jscadMesh?: T);
|
|
95
|
+
/**
|
|
96
|
+
* Solid Jscad meshes
|
|
97
|
+
* @default undefined
|
|
98
|
+
* @optional true
|
|
99
|
+
*/
|
|
100
|
+
meshes: JSCADEntity[];
|
|
101
|
+
/**
|
|
102
|
+
* Value between 0 and 1
|
|
103
|
+
* @default 1
|
|
104
|
+
* @minimum 0
|
|
105
|
+
* @maximum 1
|
|
106
|
+
* @step 0.1
|
|
107
|
+
*/
|
|
108
|
+
opacity: number;
|
|
109
|
+
/**
|
|
110
|
+
* Hex colour string
|
|
111
|
+
* @default #444444
|
|
112
|
+
*/
|
|
113
|
+
colours: string | string[];
|
|
114
|
+
/**
|
|
115
|
+
* Indicates wether this solid will be transformed in time
|
|
116
|
+
* @default false
|
|
117
|
+
*/
|
|
118
|
+
updatable: boolean;
|
|
119
|
+
/**
|
|
120
|
+
* Should be hidden
|
|
121
|
+
* @default false
|
|
122
|
+
*/
|
|
123
|
+
hidden: boolean;
|
|
124
|
+
/**
|
|
125
|
+
* Solid mesh variable in case it already exists and needs updating
|
|
126
|
+
* @default undefined
|
|
127
|
+
* @optional true
|
|
128
|
+
* @ignore true
|
|
129
|
+
*/
|
|
130
|
+
jscadMesh?: T;
|
|
131
|
+
}
|
|
132
|
+
class DrawPathDto<T> {
|
|
133
|
+
/**
|
|
134
|
+
* Provide options without default values
|
|
135
|
+
*/
|
|
136
|
+
constructor(path?: JSCADEntity, colour?: string, opacity?: number, width?: number, updatable?: boolean, pathMesh?: T);
|
|
137
|
+
/**
|
|
138
|
+
* 2D Path to draw
|
|
139
|
+
* @default undefined
|
|
140
|
+
*/
|
|
141
|
+
path: JSCADEntity;
|
|
142
|
+
/**
|
|
143
|
+
* Colour of the path
|
|
144
|
+
* @default #444444
|
|
145
|
+
*/
|
|
146
|
+
colour: string;
|
|
147
|
+
/**
|
|
148
|
+
* Opacity of the path
|
|
149
|
+
* @default 1
|
|
150
|
+
* @minimum 0
|
|
151
|
+
* @maximum 1
|
|
152
|
+
* @step 0.1
|
|
153
|
+
*/
|
|
154
|
+
opacity: number;
|
|
155
|
+
/**
|
|
156
|
+
* Width of the path
|
|
157
|
+
* @default 10
|
|
158
|
+
* @minimum 0
|
|
159
|
+
* @maximum Infinity
|
|
160
|
+
* @step 1
|
|
161
|
+
*/
|
|
162
|
+
width: number;
|
|
163
|
+
/**
|
|
164
|
+
* Indicates wether the path will change in time
|
|
165
|
+
* @default false
|
|
166
|
+
*/
|
|
167
|
+
updatable: boolean;
|
|
168
|
+
/**
|
|
169
|
+
* Path mesh variable that will be updated if updatable property is set to true
|
|
170
|
+
* @default undefined
|
|
171
|
+
* @optional true
|
|
172
|
+
* @ignore true
|
|
173
|
+
*/
|
|
174
|
+
pathMesh?: T;
|
|
175
|
+
}
|
|
176
|
+
class TransformSolidsDto {
|
|
177
|
+
constructor(meshes?: JSCADEntity[], transformation?: Base.TransformMatrixes);
|
|
178
|
+
/**
|
|
179
|
+
* Solids to be transformed
|
|
180
|
+
* @default undefined
|
|
181
|
+
*/
|
|
182
|
+
meshes: JSCADEntity[];
|
|
183
|
+
/**
|
|
184
|
+
* Transformation matrix or a list of transformation matrixes
|
|
185
|
+
* @default undefined
|
|
186
|
+
*/
|
|
187
|
+
transformation: Base.TransformMatrixes;
|
|
188
|
+
}
|
|
189
|
+
class TransformSolidDto {
|
|
190
|
+
constructor(mesh?: JSCADEntity, transformation?: Base.TransformMatrixes);
|
|
191
|
+
/**
|
|
192
|
+
* Solid to be transformed
|
|
193
|
+
* @default undefined
|
|
194
|
+
*/
|
|
195
|
+
mesh: JSCADEntity;
|
|
196
|
+
/**
|
|
197
|
+
* Transformation matrix or a list of transformation matrixes
|
|
198
|
+
* @default undefined
|
|
199
|
+
*/
|
|
200
|
+
transformation: Base.TransformMatrixes;
|
|
201
|
+
}
|
|
202
|
+
class DownloadSolidDto {
|
|
203
|
+
constructor(mesh?: JSCADEntity, fileName?: string);
|
|
204
|
+
/**
|
|
205
|
+
* Solid to be downloaded
|
|
206
|
+
* @default undefined
|
|
207
|
+
*/
|
|
208
|
+
mesh: JSCADEntity;
|
|
209
|
+
/**
|
|
210
|
+
* File name
|
|
211
|
+
* @default undefined
|
|
212
|
+
*/
|
|
213
|
+
fileName: string;
|
|
214
|
+
}
|
|
215
|
+
class DownloadGeometryDto {
|
|
216
|
+
constructor(geometry?: JSCADEntity | JSCADEntity[], fileName?: string, options?: any);
|
|
217
|
+
/**
|
|
218
|
+
* Solid or path to be downloaded, also supports multiple geometries in array
|
|
219
|
+
* @default undefined
|
|
220
|
+
*/
|
|
221
|
+
geometry: JSCADEntity | JSCADEntity[];
|
|
222
|
+
/**
|
|
223
|
+
* File name
|
|
224
|
+
* @default jscad-geometry
|
|
225
|
+
*/
|
|
226
|
+
fileName: string;
|
|
227
|
+
/**
|
|
228
|
+
* Options
|
|
229
|
+
* @default undefined
|
|
230
|
+
* @optional true
|
|
231
|
+
*/
|
|
232
|
+
options: any;
|
|
233
|
+
}
|
|
234
|
+
class DownloadSolidsDto {
|
|
235
|
+
constructor(meshes?: JSCADEntity[], fileName?: string);
|
|
236
|
+
/**
|
|
237
|
+
* Solids to be downloaded
|
|
238
|
+
* @default undefined
|
|
239
|
+
*/
|
|
240
|
+
meshes: JSCADEntity[];
|
|
241
|
+
/**
|
|
242
|
+
* File name
|
|
243
|
+
* @default undefined
|
|
244
|
+
*/
|
|
245
|
+
fileName: string;
|
|
246
|
+
}
|
|
247
|
+
class ColorizeDto {
|
|
248
|
+
constructor(geometry?: JSCADEntity, color?: string);
|
|
249
|
+
/**
|
|
250
|
+
* Solid to be colorized
|
|
251
|
+
* @default undefined
|
|
252
|
+
*/
|
|
253
|
+
geometry: JSCADEntity | JSCADEntity[];
|
|
254
|
+
/**
|
|
255
|
+
* Hex color string
|
|
256
|
+
* @default #0000ff
|
|
257
|
+
*/
|
|
258
|
+
color: string;
|
|
259
|
+
}
|
|
260
|
+
class BooleanObjectsDto {
|
|
261
|
+
constructor(meshes?: JSCADEntity[]);
|
|
262
|
+
/**
|
|
263
|
+
* Contains solid Jscad mesh objects that will be used to perform boolean operation
|
|
264
|
+
* @default undefined
|
|
265
|
+
*/
|
|
266
|
+
meshes: JSCADEntity[];
|
|
267
|
+
}
|
|
268
|
+
class BooleanTwoObjectsDto {
|
|
269
|
+
constructor(first?: JSCADEntity, second?: JSCADEntity);
|
|
270
|
+
/**
|
|
271
|
+
* Contains Jscad Solid
|
|
272
|
+
* @default undefined
|
|
273
|
+
*/
|
|
274
|
+
first: JSCADEntity;
|
|
275
|
+
/**
|
|
276
|
+
* Contains Jscad Solid
|
|
277
|
+
* @default undefined
|
|
278
|
+
*/
|
|
279
|
+
second: JSCADEntity;
|
|
280
|
+
}
|
|
281
|
+
class BooleanObjectsFromDto {
|
|
282
|
+
constructor(from?: JSCADEntity, meshes?: JSCADEntity[]);
|
|
283
|
+
/**
|
|
284
|
+
* Contains Jscad Solid
|
|
285
|
+
* @default undefined
|
|
286
|
+
*/
|
|
287
|
+
from: JSCADEntity;
|
|
288
|
+
/**
|
|
289
|
+
* Contains Jscad Solid
|
|
290
|
+
* @default undefined
|
|
291
|
+
*/
|
|
292
|
+
meshes: JSCADEntity[];
|
|
293
|
+
}
|
|
294
|
+
class ExpansionDto {
|
|
295
|
+
constructor(geometry?: JSCADEntity, delta?: number, corners?: solidCornerTypeEnum, segments?: number);
|
|
296
|
+
/**
|
|
297
|
+
* Can contain various Jscad entities from Solid category
|
|
298
|
+
* @default undefined
|
|
299
|
+
*/
|
|
300
|
+
geometry: JSCADEntity;
|
|
301
|
+
/**
|
|
302
|
+
* Delta (+/-) of expansion
|
|
303
|
+
* @default 0.1
|
|
304
|
+
* @minimum -Infinity
|
|
305
|
+
* @maximum Infinity
|
|
306
|
+
* @step 0.1
|
|
307
|
+
*/
|
|
308
|
+
delta: number;
|
|
309
|
+
/**
|
|
310
|
+
* Type of corner to create during of expansion; edge, chamfer, round
|
|
311
|
+
* @default edge
|
|
312
|
+
*/
|
|
313
|
+
corners: solidCornerTypeEnum;
|
|
314
|
+
/**
|
|
315
|
+
* Integer number of segments when creating round corners
|
|
316
|
+
* @default 24
|
|
317
|
+
* @minimum 0
|
|
318
|
+
* @maximum Infinity
|
|
319
|
+
* @step 1
|
|
320
|
+
*/
|
|
321
|
+
segments: number;
|
|
322
|
+
}
|
|
323
|
+
class OffsetDto {
|
|
324
|
+
constructor(geometry?: JSCADEntity, delta?: number, corners?: solidCornerTypeEnum, segments?: number);
|
|
325
|
+
/**
|
|
326
|
+
* Can contain various Jscad entities from Solid category
|
|
327
|
+
* @default undefined
|
|
328
|
+
*/
|
|
329
|
+
geometry: JSCADEntity;
|
|
330
|
+
/**
|
|
331
|
+
* Delta (+/-) of offset
|
|
332
|
+
* @default 0.1
|
|
333
|
+
* @minimum -Infinity
|
|
334
|
+
* @maximum Infinity
|
|
335
|
+
* @step 0.1
|
|
336
|
+
*/
|
|
337
|
+
delta: number;
|
|
338
|
+
/**
|
|
339
|
+
* Type of corner to create during the offset; edge, chamfer, round.
|
|
340
|
+
* @default edge
|
|
341
|
+
*/
|
|
342
|
+
corners: solidCornerTypeEnum;
|
|
343
|
+
/**
|
|
344
|
+
* Integer number of segments when creating round corners
|
|
345
|
+
* @default 24
|
|
346
|
+
* @minimum 0
|
|
347
|
+
* @maximum Infinity
|
|
348
|
+
* @step 1
|
|
349
|
+
*/
|
|
350
|
+
segments: number;
|
|
351
|
+
}
|
|
352
|
+
class ExtrudeLinearDto {
|
|
353
|
+
constructor(geometry?: JSCADEntity, height?: number, twistAngle?: number, twistSteps?: number);
|
|
354
|
+
/**
|
|
355
|
+
* Geometry to extrude
|
|
356
|
+
* @default undefined
|
|
357
|
+
*/
|
|
358
|
+
geometry: JSCADEntity;
|
|
359
|
+
/**
|
|
360
|
+
* Height of linear extrude
|
|
361
|
+
* @default 1
|
|
362
|
+
* @minimum -Infinity
|
|
363
|
+
* @maximum Infinity
|
|
364
|
+
* @step 0.1
|
|
365
|
+
*/
|
|
366
|
+
height: number;
|
|
367
|
+
/**
|
|
368
|
+
* Twist angle in degrees
|
|
369
|
+
* @default 90
|
|
370
|
+
* @minimum -Infinity
|
|
371
|
+
* @maximum Infinity
|
|
372
|
+
* @step 1
|
|
373
|
+
*/
|
|
374
|
+
twistAngle: number;
|
|
375
|
+
/**
|
|
376
|
+
* Number of twist steps
|
|
377
|
+
* @default 15
|
|
378
|
+
* @minimum 0
|
|
379
|
+
* @maximum Infinity
|
|
380
|
+
* @step 1
|
|
381
|
+
*/
|
|
382
|
+
twistSteps: number;
|
|
383
|
+
}
|
|
384
|
+
class HullDto {
|
|
385
|
+
constructor(meshes?: JSCADEntity[]);
|
|
386
|
+
/**
|
|
387
|
+
* Geometries to use in hull
|
|
388
|
+
* @default undefined
|
|
389
|
+
*/
|
|
390
|
+
meshes: JSCADEntity[];
|
|
391
|
+
}
|
|
392
|
+
class ExtrudeRectangularDto {
|
|
393
|
+
constructor(geometry?: JSCADEntity, height?: number, size?: number);
|
|
394
|
+
/**
|
|
395
|
+
* Geometry to extrude
|
|
396
|
+
* @default undefined
|
|
397
|
+
*/
|
|
398
|
+
geometry: JSCADEntity;
|
|
399
|
+
/**
|
|
400
|
+
* Height of linear extrude
|
|
401
|
+
* @default 1
|
|
402
|
+
* @minimum 0
|
|
403
|
+
* @maximum Infinity
|
|
404
|
+
* @step 0.1
|
|
405
|
+
*/
|
|
406
|
+
height: number;
|
|
407
|
+
/**
|
|
408
|
+
* Size of the rectangle
|
|
409
|
+
* @default 1
|
|
410
|
+
* @minimum 0
|
|
411
|
+
* @maximum Infinity
|
|
412
|
+
* @step 0.1
|
|
413
|
+
*/
|
|
414
|
+
size: number;
|
|
415
|
+
}
|
|
416
|
+
class ExtrudeRectangularPointsDto {
|
|
417
|
+
constructor(points?: Base.Point3[], height?: number, size?: number);
|
|
418
|
+
/**
|
|
419
|
+
* Points for a path
|
|
420
|
+
* @default undefined
|
|
421
|
+
*/
|
|
422
|
+
points: Base.Point3[];
|
|
423
|
+
/**
|
|
424
|
+
* Height of linear extrude
|
|
425
|
+
* @default 1
|
|
426
|
+
* @minimum 0
|
|
427
|
+
* @maximum Infinity
|
|
428
|
+
* @step 0.1
|
|
429
|
+
*/
|
|
430
|
+
height: number;
|
|
431
|
+
/**
|
|
432
|
+
* Size of the rectangle
|
|
433
|
+
* @default 1
|
|
434
|
+
* @minimum 0
|
|
435
|
+
* @maximum Infinity
|
|
436
|
+
* @step 0.1
|
|
437
|
+
*/
|
|
438
|
+
size: number;
|
|
439
|
+
}
|
|
440
|
+
class ExtrudeRotateDto {
|
|
441
|
+
constructor(polygon?: JSCADEntity, angle?: number, startAngle?: number, segments?: number);
|
|
442
|
+
/**
|
|
443
|
+
* Polygon to extrude
|
|
444
|
+
* @default undefined
|
|
445
|
+
*/
|
|
446
|
+
polygon: JSCADEntity;
|
|
447
|
+
/**
|
|
448
|
+
* Angle in degrees
|
|
449
|
+
* @default 90
|
|
450
|
+
* @minimum -Infinity
|
|
451
|
+
* @maximum Infinity
|
|
452
|
+
* @step 1
|
|
453
|
+
*/
|
|
454
|
+
angle: number;
|
|
455
|
+
/**
|
|
456
|
+
* Start angle in degrees
|
|
457
|
+
* @default 0
|
|
458
|
+
* @minimum -Infinity
|
|
459
|
+
* @maximum Infinity
|
|
460
|
+
* @step 1
|
|
461
|
+
*/
|
|
462
|
+
startAngle: number;
|
|
463
|
+
/**
|
|
464
|
+
* Number of segments
|
|
465
|
+
* @default 24
|
|
466
|
+
* @minimum 0
|
|
467
|
+
* @maximum Infinity
|
|
468
|
+
* @step 1
|
|
469
|
+
*/
|
|
470
|
+
segments: number;
|
|
471
|
+
}
|
|
472
|
+
class PolylineDto {
|
|
473
|
+
constructor(polyline?: PolylinePropertiesDto);
|
|
474
|
+
/**
|
|
475
|
+
* Polyline with points
|
|
476
|
+
*/
|
|
477
|
+
polyline: PolylinePropertiesDto;
|
|
478
|
+
}
|
|
479
|
+
class CurveDto {
|
|
480
|
+
constructor(curve?: any);
|
|
481
|
+
/**
|
|
482
|
+
* Nurbs curve
|
|
483
|
+
*/
|
|
484
|
+
curve: any;
|
|
485
|
+
}
|
|
486
|
+
class PointsDto {
|
|
487
|
+
constructor(points?: Base.Point3[]);
|
|
488
|
+
/**
|
|
489
|
+
* Points
|
|
490
|
+
*/
|
|
491
|
+
points: Base.Point3[];
|
|
492
|
+
}
|
|
493
|
+
class PathDto {
|
|
494
|
+
constructor(path?: JSCADEntity);
|
|
495
|
+
/**
|
|
496
|
+
* 2D path
|
|
497
|
+
* @default undefined
|
|
498
|
+
*/
|
|
499
|
+
path: JSCADEntity;
|
|
500
|
+
}
|
|
501
|
+
class PathFromPointsDto {
|
|
502
|
+
constructor(points?: Base.Point2[], closed?: boolean);
|
|
503
|
+
/**
|
|
504
|
+
* Points through which to create a path
|
|
505
|
+
* @default undefined
|
|
506
|
+
*/
|
|
507
|
+
points: Base.Point2[];
|
|
508
|
+
/**
|
|
509
|
+
* Indicates wether we want to create a closed path
|
|
510
|
+
* @default false
|
|
511
|
+
*/
|
|
512
|
+
closed: boolean;
|
|
513
|
+
}
|
|
514
|
+
class PathsFromPointsDto {
|
|
515
|
+
constructor(pointsLists?: Base.Point3[][] | Base.Point2[][]);
|
|
516
|
+
/**
|
|
517
|
+
* Points
|
|
518
|
+
* @default undefined
|
|
519
|
+
*/
|
|
520
|
+
pointsLists: Base.Point3[][] | Base.Point2[][];
|
|
521
|
+
}
|
|
522
|
+
class PathFromPolylineDto {
|
|
523
|
+
constructor(polyline?: PolylinePropertiesDto, closed?: boolean);
|
|
524
|
+
/**
|
|
525
|
+
* Polyline
|
|
526
|
+
* @default undefined
|
|
527
|
+
*/
|
|
528
|
+
polyline: PolylinePropertiesDto;
|
|
529
|
+
/**
|
|
530
|
+
* Indicates wether we want to create a closed path
|
|
531
|
+
* @default false
|
|
532
|
+
*/
|
|
533
|
+
closed: boolean;
|
|
534
|
+
}
|
|
535
|
+
class PathAppendCurveDto {
|
|
536
|
+
constructor(curve?: JSCADEntity, path?: JSCADEntity);
|
|
537
|
+
/**
|
|
538
|
+
* Verb Nurbs curve
|
|
539
|
+
* @default undefined
|
|
540
|
+
*/
|
|
541
|
+
curve: JSCADEntity;
|
|
542
|
+
/**
|
|
543
|
+
* Path to append the curve to
|
|
544
|
+
* @default undefined
|
|
545
|
+
*/
|
|
546
|
+
path: JSCADEntity;
|
|
547
|
+
}
|
|
548
|
+
class PathAppendPointsDto {
|
|
549
|
+
constructor(points?: Base.Point2[], path?: JSCADEntity);
|
|
550
|
+
/**
|
|
551
|
+
* Points to append
|
|
552
|
+
* @default undefined
|
|
553
|
+
*/
|
|
554
|
+
points: Base.Point2[];
|
|
555
|
+
/**
|
|
556
|
+
* Path to append the points to
|
|
557
|
+
* @default undefined
|
|
558
|
+
*/
|
|
559
|
+
path: JSCADEntity;
|
|
560
|
+
}
|
|
561
|
+
class PathAppendPolylineDto {
|
|
562
|
+
constructor(polyline?: PolylinePropertiesDto, path?: JSCADEntity);
|
|
563
|
+
/**
|
|
564
|
+
* Polyline to append
|
|
565
|
+
* @default undefined
|
|
566
|
+
*/
|
|
567
|
+
polyline: PolylinePropertiesDto;
|
|
568
|
+
/**
|
|
569
|
+
* Path to append the polyline to
|
|
570
|
+
* @default undefined
|
|
571
|
+
*/
|
|
572
|
+
path: JSCADEntity;
|
|
573
|
+
}
|
|
574
|
+
class PathAppendArcDto {
|
|
575
|
+
constructor(path?: JSCADEntity, endPoint?: Base.Point2, xAxisRotation?: number, clockwise?: boolean, large?: boolean, segments?: number, radiusX?: number, radiusY?: number);
|
|
576
|
+
/**
|
|
577
|
+
* Path to append the arc to
|
|
578
|
+
* @default undefined
|
|
579
|
+
*/
|
|
580
|
+
path: JSCADEntity;
|
|
581
|
+
/**
|
|
582
|
+
* End point of an arc
|
|
583
|
+
* @default [1, 1]
|
|
584
|
+
*/
|
|
585
|
+
endPoint: Base.Point2;
|
|
586
|
+
/**
|
|
587
|
+
* Rotation (degrees) of the X axis of the arc with respect to the X axis of the coordinate system
|
|
588
|
+
* @default 90
|
|
589
|
+
* @minimum -Infinity
|
|
590
|
+
* @maximum Infinity
|
|
591
|
+
* @step 1
|
|
592
|
+
*/
|
|
593
|
+
xAxisRotation: number;
|
|
594
|
+
/**
|
|
595
|
+
* Draw an arc clockwise with respect to the center point
|
|
596
|
+
* @default true
|
|
597
|
+
*/
|
|
598
|
+
clockwise: boolean;
|
|
599
|
+
/**
|
|
600
|
+
* Draw an arc longer than PI radians
|
|
601
|
+
* @default false
|
|
602
|
+
*/
|
|
603
|
+
large: boolean;
|
|
604
|
+
/**
|
|
605
|
+
* Number of segments for the arc
|
|
606
|
+
* @default 24
|
|
607
|
+
* @minimum 0
|
|
608
|
+
* @maximum Infinity
|
|
609
|
+
* @step 1
|
|
610
|
+
*/
|
|
611
|
+
segments: number;
|
|
612
|
+
/**
|
|
613
|
+
* X radius of an arc
|
|
614
|
+
* @default 1
|
|
615
|
+
* @minimum -Infinity
|
|
616
|
+
* @maximum Infinity
|
|
617
|
+
* @step 0.1
|
|
618
|
+
*/
|
|
619
|
+
radiusX: number;
|
|
620
|
+
/**
|
|
621
|
+
* Y radius of an arc
|
|
622
|
+
* @default 1
|
|
623
|
+
* @minimum -Infinity
|
|
624
|
+
* @maximum Infinity
|
|
625
|
+
* @step 0.1
|
|
626
|
+
*/
|
|
627
|
+
radiusY: number;
|
|
628
|
+
}
|
|
629
|
+
class CircleDto {
|
|
630
|
+
constructor(center?: Base.Point2, radius?: number, segments?: number);
|
|
631
|
+
/**
|
|
632
|
+
* Center of the circle
|
|
633
|
+
* @default [0, 0]
|
|
634
|
+
*/
|
|
635
|
+
center: Base.Point2;
|
|
636
|
+
/**
|
|
637
|
+
* Radius of the circle
|
|
638
|
+
* @default 1
|
|
639
|
+
* @minimum -Infinity
|
|
640
|
+
* @maximum Infinity
|
|
641
|
+
* @step 0.1
|
|
642
|
+
*/
|
|
643
|
+
radius: number;
|
|
644
|
+
/**
|
|
645
|
+
* Segment number
|
|
646
|
+
* @default 24
|
|
647
|
+
* @minimum 0
|
|
648
|
+
* @maximum Infinity
|
|
649
|
+
* @step 1
|
|
650
|
+
*/
|
|
651
|
+
segments: number;
|
|
652
|
+
}
|
|
653
|
+
class EllipseDto {
|
|
654
|
+
constructor(center?: Base.Point2, radius?: Base.Point2, segments?: number);
|
|
655
|
+
/**
|
|
656
|
+
* Center of the circle
|
|
657
|
+
* @default [0, 0]
|
|
658
|
+
*/
|
|
659
|
+
center: Base.Point2;
|
|
660
|
+
/**
|
|
661
|
+
* Radius of the circle in [x, y] form
|
|
662
|
+
* @default [1, 2]
|
|
663
|
+
*/
|
|
664
|
+
radius: Base.Point2;
|
|
665
|
+
/**
|
|
666
|
+
* Segment number
|
|
667
|
+
* @default 24
|
|
668
|
+
* @minimum 0
|
|
669
|
+
* @maximum Infinity
|
|
670
|
+
* @step 1
|
|
671
|
+
*/
|
|
672
|
+
segments: number;
|
|
673
|
+
}
|
|
674
|
+
class SquareDto {
|
|
675
|
+
constructor(center?: Base.Point2, size?: number);
|
|
676
|
+
/**
|
|
677
|
+
* Center of the 2D square
|
|
678
|
+
* @default [0, 0]
|
|
679
|
+
*/
|
|
680
|
+
center: Base.Point2;
|
|
681
|
+
/**
|
|
682
|
+
* Size of the square
|
|
683
|
+
* @default 1
|
|
684
|
+
* @minimum -Infinity
|
|
685
|
+
* @maximum Infinity
|
|
686
|
+
* @step 0.1
|
|
687
|
+
*/
|
|
688
|
+
size: number;
|
|
689
|
+
}
|
|
690
|
+
class RectangleDto {
|
|
691
|
+
constructor(center?: Base.Point2, width?: number, length?: number);
|
|
692
|
+
/**
|
|
693
|
+
* Center of the 2D rectangle
|
|
694
|
+
* @default [0, 0]
|
|
695
|
+
*/
|
|
696
|
+
center: Base.Point2;
|
|
697
|
+
/**
|
|
698
|
+
* Width of the rectangle
|
|
699
|
+
* @default 1
|
|
700
|
+
* @minimum -Infinity
|
|
701
|
+
* @maximum Infinity
|
|
702
|
+
* @step 0.1
|
|
703
|
+
*/
|
|
704
|
+
width: number;
|
|
705
|
+
/**
|
|
706
|
+
* Length of the rectangle
|
|
707
|
+
* @default 1
|
|
708
|
+
* @minimum -Infinity
|
|
709
|
+
* @maximum Infinity
|
|
710
|
+
* @step 0.1
|
|
711
|
+
*/
|
|
712
|
+
length: number;
|
|
713
|
+
}
|
|
714
|
+
class RoundedRectangleDto {
|
|
715
|
+
constructor(center?: Base.Point2, roundRadius?: number, segments?: number, width?: number, length?: number);
|
|
716
|
+
/**
|
|
717
|
+
* Center of the 2D rectangle
|
|
718
|
+
* @default [0, 0]
|
|
719
|
+
*/
|
|
720
|
+
center: Base.Point2;
|
|
721
|
+
/**
|
|
722
|
+
* The radius to round the rectangle edge
|
|
723
|
+
* @default 0.2
|
|
724
|
+
* @minimum -Infinity
|
|
725
|
+
* @maximum Infinity
|
|
726
|
+
* @step 0.1
|
|
727
|
+
*/
|
|
728
|
+
roundRadius: number;
|
|
729
|
+
/**
|
|
730
|
+
* Number of segments for corners
|
|
731
|
+
* @default 24
|
|
732
|
+
* @minimum 0
|
|
733
|
+
* @maximum Infinity
|
|
734
|
+
* @step 1
|
|
735
|
+
*/
|
|
736
|
+
segments: number;
|
|
737
|
+
/**
|
|
738
|
+
* Width of the rectangle
|
|
739
|
+
* @default 1
|
|
740
|
+
* @minimum -Infinity
|
|
741
|
+
* @maximum Infinity
|
|
742
|
+
* @step 0.1
|
|
743
|
+
*/
|
|
744
|
+
width: number;
|
|
745
|
+
/**
|
|
746
|
+
* Length of the rectangle
|
|
747
|
+
* @default 1
|
|
748
|
+
* @minimum -Infinity
|
|
749
|
+
* @maximum Infinity
|
|
750
|
+
* @step 0.1
|
|
751
|
+
*/
|
|
752
|
+
length: number;
|
|
753
|
+
}
|
|
754
|
+
class StarDto {
|
|
755
|
+
constructor(center?: Base.Point2, vertices?: number, density?: number, outerRadius?: number, innerRadius?: number, startAngle?: number);
|
|
756
|
+
/**
|
|
757
|
+
* Center of the 2D star
|
|
758
|
+
* @default [0, 0]
|
|
759
|
+
*/
|
|
760
|
+
center: Base.Point2;
|
|
761
|
+
/**
|
|
762
|
+
* Number of vertices on the star
|
|
763
|
+
* @default 10
|
|
764
|
+
* @minimum 0
|
|
765
|
+
* @maximum Infinity
|
|
766
|
+
* @step 1
|
|
767
|
+
*/
|
|
768
|
+
vertices: number;
|
|
769
|
+
/**
|
|
770
|
+
* Density of the star
|
|
771
|
+
* @default 1
|
|
772
|
+
* @minimum 0
|
|
773
|
+
* @maximum Infinity
|
|
774
|
+
* @step 0.1
|
|
775
|
+
*/
|
|
776
|
+
density: number;
|
|
777
|
+
/**
|
|
778
|
+
* Outer radius of the star
|
|
779
|
+
* @default 2
|
|
780
|
+
* @minimum 0
|
|
781
|
+
* @maximum Infinity
|
|
782
|
+
* @step 0.1
|
|
783
|
+
*/
|
|
784
|
+
outerRadius: number;
|
|
785
|
+
/**
|
|
786
|
+
* Inner radius of the star
|
|
787
|
+
* @default 1
|
|
788
|
+
* @minimum 0
|
|
789
|
+
* @maximum Infinity
|
|
790
|
+
* @step 0.1
|
|
791
|
+
*/
|
|
792
|
+
innerRadius: number;
|
|
793
|
+
/**
|
|
794
|
+
* Starting angle for first vertice, in degrees
|
|
795
|
+
* @default 0
|
|
796
|
+
* @minimum -Infinity
|
|
797
|
+
* @maximum Infinity
|
|
798
|
+
* @step 1
|
|
799
|
+
*/
|
|
800
|
+
startAngle: number;
|
|
801
|
+
}
|
|
802
|
+
class CubeDto {
|
|
803
|
+
constructor(center?: Base.Point3, size?: number);
|
|
804
|
+
/**
|
|
805
|
+
* Center coordinates of the cube
|
|
806
|
+
* @default [0, 0, 0]
|
|
807
|
+
*/
|
|
808
|
+
center: Base.Point3;
|
|
809
|
+
/**
|
|
810
|
+
* Size of the cube
|
|
811
|
+
* @default 1
|
|
812
|
+
* @minimum -Infinity
|
|
813
|
+
* @maximum Infinity
|
|
814
|
+
* @step 0.1
|
|
815
|
+
*/
|
|
816
|
+
size: number;
|
|
817
|
+
}
|
|
818
|
+
class CubeCentersDto {
|
|
819
|
+
constructor(centers?: Base.Point3[], size?: number);
|
|
820
|
+
/**
|
|
821
|
+
* Center coordinates of the cubes
|
|
822
|
+
* @default undefined
|
|
823
|
+
*/
|
|
824
|
+
centers: Base.Point3[];
|
|
825
|
+
/**
|
|
826
|
+
* Size of the cube
|
|
827
|
+
* @default 1
|
|
828
|
+
* @minimum 0
|
|
829
|
+
* @maximum Infinity
|
|
830
|
+
* @step 0.1
|
|
831
|
+
*/
|
|
832
|
+
size: number;
|
|
833
|
+
}
|
|
834
|
+
class CuboidDto {
|
|
835
|
+
constructor(center?: Base.Point3, width?: number, length?: number, height?: number);
|
|
836
|
+
/**
|
|
837
|
+
* Center coordinates of the cubod
|
|
838
|
+
* @default [0, 0, 0]
|
|
839
|
+
*/
|
|
840
|
+
center: Base.Point3;
|
|
841
|
+
/**
|
|
842
|
+
* Width of the cuboid
|
|
843
|
+
* @default 1
|
|
844
|
+
* @minimum 0
|
|
845
|
+
* @maximum Infinity
|
|
846
|
+
* @step 0.1
|
|
847
|
+
*/
|
|
848
|
+
width: number;
|
|
849
|
+
/**
|
|
850
|
+
* Length of the cuboid
|
|
851
|
+
* @default 1
|
|
852
|
+
* @minimum 0
|
|
853
|
+
* @maximum Infinity
|
|
854
|
+
* @step 0.1
|
|
855
|
+
*/
|
|
856
|
+
length: number;
|
|
857
|
+
/**
|
|
858
|
+
* Height of the cuboid
|
|
859
|
+
* @default 1
|
|
860
|
+
* @minimum 0
|
|
861
|
+
* @maximum Infinity
|
|
862
|
+
* @step 0.1
|
|
863
|
+
*/
|
|
864
|
+
height: number;
|
|
865
|
+
}
|
|
866
|
+
class CuboidCentersDto {
|
|
867
|
+
constructor(centers?: Base.Point3[], width?: number, length?: number, height?: number);
|
|
868
|
+
/**
|
|
869
|
+
* Center coordinates of the cuboids
|
|
870
|
+
* @default undefined
|
|
871
|
+
*/
|
|
872
|
+
centers: Base.Point3[];
|
|
873
|
+
/**
|
|
874
|
+
* Width of the cuboids
|
|
875
|
+
* @default 1
|
|
876
|
+
* @minimum 0
|
|
877
|
+
* @maximum Infinity
|
|
878
|
+
* @step 0.1
|
|
879
|
+
*/
|
|
880
|
+
width: number;
|
|
881
|
+
/**
|
|
882
|
+
* Length of the cuboids
|
|
883
|
+
* @default 1
|
|
884
|
+
* @minimum 0
|
|
885
|
+
* @maximum Infinity
|
|
886
|
+
* @step 0.1
|
|
887
|
+
*/
|
|
888
|
+
length: number;
|
|
889
|
+
/**
|
|
890
|
+
* Height of the cuboids
|
|
891
|
+
* @default 1
|
|
892
|
+
* @minimum 0
|
|
893
|
+
* @maximum Infinity
|
|
894
|
+
* @step 0.1
|
|
895
|
+
*/
|
|
896
|
+
height: number;
|
|
897
|
+
}
|
|
898
|
+
class RoundedCuboidDto {
|
|
899
|
+
constructor(center?: Base.Point3, roundRadius?: number, width?: number, length?: number, height?: number, segments?: number);
|
|
900
|
+
/**
|
|
901
|
+
* Center coordinates of the cubod
|
|
902
|
+
* @default [0, 0, 0]
|
|
903
|
+
*/
|
|
904
|
+
center: Base.Point3;
|
|
905
|
+
/**
|
|
906
|
+
* Radius for rounding edges
|
|
907
|
+
* @default 0.1
|
|
908
|
+
* @minimum 0
|
|
909
|
+
* @maximum Infinity
|
|
910
|
+
* @step 0.1
|
|
911
|
+
*/
|
|
912
|
+
roundRadius: number;
|
|
913
|
+
/**
|
|
914
|
+
* Width of the cuboid
|
|
915
|
+
* @default 1
|
|
916
|
+
* @minimum 0
|
|
917
|
+
* @maximum Infinity
|
|
918
|
+
* @step 0.1
|
|
919
|
+
*/
|
|
920
|
+
width: number;
|
|
921
|
+
/**
|
|
922
|
+
* Length of the cuboid
|
|
923
|
+
* @default 1
|
|
924
|
+
* @minimum 0
|
|
925
|
+
* @maximum Infinity
|
|
926
|
+
* @step 0.1
|
|
927
|
+
*/
|
|
928
|
+
length: number;
|
|
929
|
+
/**
|
|
930
|
+
* Height of the cuboid
|
|
931
|
+
* @default 1
|
|
932
|
+
* @minimum 0
|
|
933
|
+
* @maximum Infinity
|
|
934
|
+
* @step 0.1
|
|
935
|
+
*/
|
|
936
|
+
height: number;
|
|
937
|
+
/**
|
|
938
|
+
* Segments of rounded edges
|
|
939
|
+
* @default 24
|
|
940
|
+
* @minimum 0
|
|
941
|
+
* @maximum Infinity
|
|
942
|
+
* @step 1
|
|
943
|
+
*/
|
|
944
|
+
segments: number;
|
|
945
|
+
}
|
|
946
|
+
class RoundedCuboidCentersDto {
|
|
947
|
+
constructor(centers?: Base.Point3[], roundRadius?: number, width?: number, length?: number, height?: number, segments?: number);
|
|
948
|
+
/**
|
|
949
|
+
* Center coordinates of the cuboids
|
|
950
|
+
* @default undefined
|
|
951
|
+
*/
|
|
952
|
+
centers: Base.Point3[];
|
|
953
|
+
/**
|
|
954
|
+
* Radius for rounding edges
|
|
955
|
+
* @default 0.1
|
|
956
|
+
* @minimum 0
|
|
957
|
+
* @maximum Infinity
|
|
958
|
+
* @step 0.1
|
|
959
|
+
*/
|
|
960
|
+
roundRadius: number;
|
|
961
|
+
/**
|
|
962
|
+
* Width of the cuboids
|
|
963
|
+
* @default 1
|
|
964
|
+
* @minimum 0
|
|
965
|
+
* @maximum Infinity
|
|
966
|
+
* @step 0.1
|
|
967
|
+
*/
|
|
968
|
+
width: number;
|
|
969
|
+
/**
|
|
970
|
+
* Length of the cuboids
|
|
971
|
+
* @default 1
|
|
972
|
+
* @minimum 0
|
|
973
|
+
* @maximum Infinity
|
|
974
|
+
* @step 0.1
|
|
975
|
+
*/
|
|
976
|
+
length: number;
|
|
977
|
+
/**
|
|
978
|
+
* Height of the cuboids
|
|
979
|
+
* @default 1
|
|
980
|
+
* @minimum 0
|
|
981
|
+
* @maximum Infinity
|
|
982
|
+
* @step 0.1
|
|
983
|
+
*/
|
|
984
|
+
height: number;
|
|
985
|
+
/**
|
|
986
|
+
* Segments of rounded edges
|
|
987
|
+
* @default 24
|
|
988
|
+
* @minimum 0
|
|
989
|
+
* @maximum Infinity
|
|
990
|
+
* @step 1
|
|
991
|
+
*/
|
|
992
|
+
segments: number;
|
|
993
|
+
}
|
|
994
|
+
class CylidnerEllipticDto {
|
|
995
|
+
constructor(center?: Base.Point3, height?: number, startRadius?: Base.Point2, endRadius?: Base.Point2, segments?: number);
|
|
996
|
+
/**
|
|
997
|
+
* Center of the cylinder
|
|
998
|
+
* @default [0, 0, 0]
|
|
999
|
+
*/
|
|
1000
|
+
center: Base.Point3;
|
|
1001
|
+
/**
|
|
1002
|
+
* Height of the cylinder
|
|
1003
|
+
* @default 1
|
|
1004
|
+
* @minimum 0
|
|
1005
|
+
* @maximum Infinity
|
|
1006
|
+
* @step 0.1
|
|
1007
|
+
*/
|
|
1008
|
+
height: number;
|
|
1009
|
+
/**
|
|
1010
|
+
* Start radius on X and Y directions
|
|
1011
|
+
* @default [1, 2]
|
|
1012
|
+
*/
|
|
1013
|
+
startRadius: Base.Vector2;
|
|
1014
|
+
/**
|
|
1015
|
+
* End radius on X and Y directions
|
|
1016
|
+
* @default [2, 3]
|
|
1017
|
+
*/
|
|
1018
|
+
endRadius: Base.Vector2;
|
|
1019
|
+
/**
|
|
1020
|
+
* Subdivision segments
|
|
1021
|
+
* @default 24
|
|
1022
|
+
* @minimum 0
|
|
1023
|
+
* @maximum Infinity
|
|
1024
|
+
* @step 1
|
|
1025
|
+
*/
|
|
1026
|
+
segments: number;
|
|
1027
|
+
}
|
|
1028
|
+
class CylidnerCentersEllipticDto {
|
|
1029
|
+
constructor(centers?: Base.Point3[], height?: number, startRadius?: Base.Point2, endRadius?: Base.Point2, segments?: number);
|
|
1030
|
+
/**
|
|
1031
|
+
* Centers of the cylinders
|
|
1032
|
+
* @default undefined
|
|
1033
|
+
*/
|
|
1034
|
+
centers: Base.Point3[];
|
|
1035
|
+
/**
|
|
1036
|
+
* Height of the cylinders
|
|
1037
|
+
* @default 1
|
|
1038
|
+
* @minimum 0
|
|
1039
|
+
* @maximum Infinity
|
|
1040
|
+
* @step 0.1
|
|
1041
|
+
*/
|
|
1042
|
+
height: number;
|
|
1043
|
+
/**
|
|
1044
|
+
* Start radius on X and Y directions
|
|
1045
|
+
* @default [1, 2]
|
|
1046
|
+
*/
|
|
1047
|
+
startRadius: Base.Point2;
|
|
1048
|
+
/**
|
|
1049
|
+
* End radius on X and Y directions
|
|
1050
|
+
* @default [2, 3]
|
|
1051
|
+
*/
|
|
1052
|
+
endRadius: Base.Point2;
|
|
1053
|
+
/**
|
|
1054
|
+
* Subdivision segments
|
|
1055
|
+
* @default 24
|
|
1056
|
+
* @minimum 0
|
|
1057
|
+
* @maximum Infinity
|
|
1058
|
+
* @step 1
|
|
1059
|
+
*/
|
|
1060
|
+
segments: number;
|
|
1061
|
+
}
|
|
1062
|
+
class CylidnerDto {
|
|
1063
|
+
constructor(center?: Base.Point3, height?: number, radius?: number, segments?: number);
|
|
1064
|
+
/**
|
|
1065
|
+
* Center of the cylinder
|
|
1066
|
+
* @default [0, 0, 0]
|
|
1067
|
+
*/
|
|
1068
|
+
center: Base.Point3;
|
|
1069
|
+
/**
|
|
1070
|
+
* Height of the cylinder
|
|
1071
|
+
* @default 1
|
|
1072
|
+
* @minimum 0
|
|
1073
|
+
* @maximum Infinity
|
|
1074
|
+
* @step 0.1
|
|
1075
|
+
*/
|
|
1076
|
+
height: number;
|
|
1077
|
+
/**
|
|
1078
|
+
* Radius of the cylinder
|
|
1079
|
+
* @default 1
|
|
1080
|
+
* @minimum 0
|
|
1081
|
+
* @maximum Infinity
|
|
1082
|
+
* @step 0.1
|
|
1083
|
+
*/
|
|
1084
|
+
radius: number;
|
|
1085
|
+
/**
|
|
1086
|
+
* Subdivision segments
|
|
1087
|
+
* @default 24
|
|
1088
|
+
* @minimum 0
|
|
1089
|
+
* @maximum Infinity
|
|
1090
|
+
* @step 1
|
|
1091
|
+
*/
|
|
1092
|
+
segments: number;
|
|
1093
|
+
}
|
|
1094
|
+
class RoundedCylidnerDto {
|
|
1095
|
+
constructor(center?: Base.Point3, roundRadius?: number, height?: number, radius?: number, segments?: number);
|
|
1096
|
+
/**
|
|
1097
|
+
* Center of the cylinder
|
|
1098
|
+
* @default [0, 0, 0]
|
|
1099
|
+
*/
|
|
1100
|
+
center: Base.Point3;
|
|
1101
|
+
/**
|
|
1102
|
+
* Rounding radius
|
|
1103
|
+
* @default 0.1
|
|
1104
|
+
* @minimum 0
|
|
1105
|
+
* @maximum Infinity
|
|
1106
|
+
* @step 0.1
|
|
1107
|
+
*/
|
|
1108
|
+
roundRadius: number;
|
|
1109
|
+
/**
|
|
1110
|
+
* Height of the cylinder
|
|
1111
|
+
* @default 1
|
|
1112
|
+
* @minimum 0
|
|
1113
|
+
* @maximum Infinity
|
|
1114
|
+
* @step 0.1
|
|
1115
|
+
*/
|
|
1116
|
+
height: number;
|
|
1117
|
+
/**
|
|
1118
|
+
* Radius of the cylinder
|
|
1119
|
+
* @default 1
|
|
1120
|
+
* @minimum 0
|
|
1121
|
+
* @maximum Infinity
|
|
1122
|
+
* @step 0.1
|
|
1123
|
+
*/
|
|
1124
|
+
radius: number;
|
|
1125
|
+
/**
|
|
1126
|
+
* Segment number
|
|
1127
|
+
* @default 24
|
|
1128
|
+
* @minimum 0
|
|
1129
|
+
* @maximum Infinity
|
|
1130
|
+
* @step 1
|
|
1131
|
+
*/
|
|
1132
|
+
segments: number;
|
|
1133
|
+
}
|
|
1134
|
+
class EllipsoidDto {
|
|
1135
|
+
constructor(center?: Base.Point3, radius?: Base.Point3, segments?: number);
|
|
1136
|
+
/**
|
|
1137
|
+
* Center coordinates
|
|
1138
|
+
* @default [0, 0, 0]
|
|
1139
|
+
*/
|
|
1140
|
+
center: Base.Point3;
|
|
1141
|
+
/**
|
|
1142
|
+
* Radius of the ellipsoid in [x, y, z] form
|
|
1143
|
+
* @default [1, 2, 3]
|
|
1144
|
+
*/
|
|
1145
|
+
radius: Base.Point3;
|
|
1146
|
+
/**
|
|
1147
|
+
* Segment count for ellipsoid
|
|
1148
|
+
* @default 24
|
|
1149
|
+
* @minimum 0
|
|
1150
|
+
* @maximum Infinity
|
|
1151
|
+
* @step 1
|
|
1152
|
+
*/
|
|
1153
|
+
segments: number;
|
|
1154
|
+
}
|
|
1155
|
+
class EllipsoidCentersDto {
|
|
1156
|
+
constructor(centers?: Base.Point3[], radius?: Base.Point3, segments?: number);
|
|
1157
|
+
/**
|
|
1158
|
+
* Center coordinates
|
|
1159
|
+
* @default undefined
|
|
1160
|
+
*/
|
|
1161
|
+
centers: Base.Point3[];
|
|
1162
|
+
/**
|
|
1163
|
+
* Radius of the ellipsoid in [x, y, z] form
|
|
1164
|
+
* @default [1, 2, 3]
|
|
1165
|
+
*/
|
|
1166
|
+
radius: Base.Point3;
|
|
1167
|
+
/**
|
|
1168
|
+
* Segment count for ellipsoid
|
|
1169
|
+
* @default 24
|
|
1170
|
+
* @minimum 0
|
|
1171
|
+
* @maximum Infinity
|
|
1172
|
+
* @step 1
|
|
1173
|
+
*/
|
|
1174
|
+
segments: number;
|
|
1175
|
+
}
|
|
1176
|
+
class GeodesicSphereDto {
|
|
1177
|
+
constructor(center?: Base.Point3, radius?: number, frequency?: number);
|
|
1178
|
+
/**
|
|
1179
|
+
* Center coordinate of the geodesic sphere
|
|
1180
|
+
* @default [0, 0, 0]
|
|
1181
|
+
*/
|
|
1182
|
+
center: Base.Point3;
|
|
1183
|
+
/**
|
|
1184
|
+
* Radius of the sphere
|
|
1185
|
+
* @default 1
|
|
1186
|
+
* @minimum 0
|
|
1187
|
+
* @maximum Infinity
|
|
1188
|
+
* @step 0.1
|
|
1189
|
+
*/
|
|
1190
|
+
radius: number;
|
|
1191
|
+
/**
|
|
1192
|
+
* Subdivision count
|
|
1193
|
+
* @default 12
|
|
1194
|
+
* @minimum 0
|
|
1195
|
+
* @maximum Infinity
|
|
1196
|
+
* @step 1
|
|
1197
|
+
*/
|
|
1198
|
+
frequency: number;
|
|
1199
|
+
}
|
|
1200
|
+
class GeodesicSphereCentersDto {
|
|
1201
|
+
constructor(centers?: Base.Point3[], radius?: number, frequency?: number);
|
|
1202
|
+
/**
|
|
1203
|
+
* Center coordinates of the geodesic spheres
|
|
1204
|
+
* @default undefined
|
|
1205
|
+
*/
|
|
1206
|
+
centers: Base.Point3[];
|
|
1207
|
+
/**
|
|
1208
|
+
* Radius of the sphere
|
|
1209
|
+
* @default 1
|
|
1210
|
+
* @minimum 0
|
|
1211
|
+
* @maximum Infinity
|
|
1212
|
+
* @step 0.1
|
|
1213
|
+
*/
|
|
1214
|
+
radius: number;
|
|
1215
|
+
/**
|
|
1216
|
+
* Subdivision count
|
|
1217
|
+
* @default 12
|
|
1218
|
+
* @minimum 0
|
|
1219
|
+
* @maximum Infinity
|
|
1220
|
+
* @step 0.1
|
|
1221
|
+
*/
|
|
1222
|
+
frequency: number;
|
|
1223
|
+
}
|
|
1224
|
+
class CylidnerCentersDto {
|
|
1225
|
+
constructor(centers?: Base.Point3[], height?: number, radius?: number, segments?: number);
|
|
1226
|
+
/**
|
|
1227
|
+
* Centers of the cylinders
|
|
1228
|
+
* @default undefined
|
|
1229
|
+
*/
|
|
1230
|
+
centers: Base.Point3[];
|
|
1231
|
+
/**
|
|
1232
|
+
* Height of the cylinders
|
|
1233
|
+
* @default 1
|
|
1234
|
+
* @minimum 0
|
|
1235
|
+
* @maximum Infinity
|
|
1236
|
+
* @step 0.1
|
|
1237
|
+
*/
|
|
1238
|
+
height: number;
|
|
1239
|
+
/**
|
|
1240
|
+
* Radius of the cylinders
|
|
1241
|
+
* @default 1
|
|
1242
|
+
* @minimum 0
|
|
1243
|
+
* @maximum Infinity
|
|
1244
|
+
* @step 0.1
|
|
1245
|
+
*/
|
|
1246
|
+
radius: number;
|
|
1247
|
+
/**
|
|
1248
|
+
* Subdivision segments
|
|
1249
|
+
* @default 24
|
|
1250
|
+
* @minimum 0
|
|
1251
|
+
* @maximum Infinity
|
|
1252
|
+
* @step 1
|
|
1253
|
+
*/
|
|
1254
|
+
segments: number;
|
|
1255
|
+
}
|
|
1256
|
+
class RoundedCylidnerCentersDto {
|
|
1257
|
+
constructor(centers?: Base.Point3[], roundRadius?: number, height?: number, radius?: number, segments?: number);
|
|
1258
|
+
/**
|
|
1259
|
+
* Centers of the cylinders
|
|
1260
|
+
* @default undefined
|
|
1261
|
+
*/
|
|
1262
|
+
centers: Base.Point3[];
|
|
1263
|
+
/**
|
|
1264
|
+
* Rounding radius
|
|
1265
|
+
* @default 0.1
|
|
1266
|
+
* @minimum 0
|
|
1267
|
+
* @maximum Infinity
|
|
1268
|
+
* @step 0.1
|
|
1269
|
+
*/
|
|
1270
|
+
roundRadius: number;
|
|
1271
|
+
/**
|
|
1272
|
+
* Height of the cylinders
|
|
1273
|
+
* @default 1
|
|
1274
|
+
* @minimum 0
|
|
1275
|
+
* @maximum Infinity
|
|
1276
|
+
* @step 0.1
|
|
1277
|
+
*/
|
|
1278
|
+
height: number;
|
|
1279
|
+
/**
|
|
1280
|
+
* Radius of the cylinders
|
|
1281
|
+
* @default 1
|
|
1282
|
+
* @minimum 0
|
|
1283
|
+
* @maximum Infinity
|
|
1284
|
+
* @step 0.1
|
|
1285
|
+
*/
|
|
1286
|
+
radius: number;
|
|
1287
|
+
/**
|
|
1288
|
+
* Segment number
|
|
1289
|
+
* @default 24
|
|
1290
|
+
* @minimum 0
|
|
1291
|
+
* @maximum Infinity
|
|
1292
|
+
* @step 1
|
|
1293
|
+
*/
|
|
1294
|
+
segments: number;
|
|
1295
|
+
}
|
|
1296
|
+
class SphereDto {
|
|
1297
|
+
constructor(center?: Base.Point3, radius?: number, segments?: number);
|
|
1298
|
+
/**
|
|
1299
|
+
* Center point of the sphere
|
|
1300
|
+
* @default [0, 0, 0]
|
|
1301
|
+
*/
|
|
1302
|
+
center: Base.Point3;
|
|
1303
|
+
/**
|
|
1304
|
+
* Radius of the sphere
|
|
1305
|
+
* @default 1
|
|
1306
|
+
* @minimum 0
|
|
1307
|
+
* @maximum Infinity
|
|
1308
|
+
* @step 0.1
|
|
1309
|
+
*/
|
|
1310
|
+
radius: number;
|
|
1311
|
+
/**
|
|
1312
|
+
* Segment count
|
|
1313
|
+
* @default 24
|
|
1314
|
+
* @minimum 0
|
|
1315
|
+
* @maximum Infinity
|
|
1316
|
+
* @step 1
|
|
1317
|
+
*/
|
|
1318
|
+
segments: number;
|
|
1319
|
+
}
|
|
1320
|
+
class SphereCentersDto {
|
|
1321
|
+
constructor(centers?: Base.Point3[], radius?: number, segments?: number);
|
|
1322
|
+
/**
|
|
1323
|
+
* Center points of the spheres
|
|
1324
|
+
* @default undefined
|
|
1325
|
+
*/
|
|
1326
|
+
centers: Base.Point3[];
|
|
1327
|
+
/**
|
|
1328
|
+
* Radius of the spheres
|
|
1329
|
+
* @default 1
|
|
1330
|
+
* @minimum 0
|
|
1331
|
+
* @maximum Infinity
|
|
1332
|
+
* @step 0.1
|
|
1333
|
+
*/
|
|
1334
|
+
radius: number;
|
|
1335
|
+
/**
|
|
1336
|
+
* Segment count
|
|
1337
|
+
* @default 24
|
|
1338
|
+
* @minimum 0
|
|
1339
|
+
* @maximum Infinity
|
|
1340
|
+
* @step 1
|
|
1341
|
+
*/
|
|
1342
|
+
segments: number;
|
|
1343
|
+
}
|
|
1344
|
+
class TorusDto {
|
|
1345
|
+
constructor(center?: Base.Point3, innerRadius?: number, outerRadius?: number, innerSegments?: number, outerSegments?: number, innerRotation?: number, outerRotation?: number, startAngle?: number);
|
|
1346
|
+
/**
|
|
1347
|
+
* Center coordinate
|
|
1348
|
+
* @default [0, 0, 0]
|
|
1349
|
+
*/
|
|
1350
|
+
center: Base.Point3;
|
|
1351
|
+
/**
|
|
1352
|
+
* Inner radius
|
|
1353
|
+
* @default 1
|
|
1354
|
+
* @minimum 0
|
|
1355
|
+
* @maximum Infinity
|
|
1356
|
+
* @step 0.1
|
|
1357
|
+
*/
|
|
1358
|
+
innerRadius: number;
|
|
1359
|
+
/**
|
|
1360
|
+
* Outer radius
|
|
1361
|
+
* @default 2
|
|
1362
|
+
* @minimum 0
|
|
1363
|
+
* @maximum Infinity
|
|
1364
|
+
* @step 0.1
|
|
1365
|
+
*/
|
|
1366
|
+
outerRadius: number;
|
|
1367
|
+
/**
|
|
1368
|
+
* Number of inner segments
|
|
1369
|
+
* @default 24
|
|
1370
|
+
* @minimum 0
|
|
1371
|
+
* @maximum Infinity
|
|
1372
|
+
* @step 1
|
|
1373
|
+
*/
|
|
1374
|
+
innerSegments: number;
|
|
1375
|
+
/**
|
|
1376
|
+
* Number of outer segments
|
|
1377
|
+
* @default 24
|
|
1378
|
+
* @minimum 0
|
|
1379
|
+
* @maximum Infinity
|
|
1380
|
+
* @step 1
|
|
1381
|
+
*/
|
|
1382
|
+
outerSegments: number;
|
|
1383
|
+
/**
|
|
1384
|
+
* Inner rotation in degrees
|
|
1385
|
+
* @default 0
|
|
1386
|
+
* @minimum -Infinity
|
|
1387
|
+
* @maximum Infinity
|
|
1388
|
+
* @step 1
|
|
1389
|
+
*/
|
|
1390
|
+
innerRotation: number;
|
|
1391
|
+
/**
|
|
1392
|
+
* Outer rotation in degrees
|
|
1393
|
+
* @default 360
|
|
1394
|
+
* @minimum -Infinity
|
|
1395
|
+
* @maximum Infinity
|
|
1396
|
+
* @step 1
|
|
1397
|
+
*/
|
|
1398
|
+
outerRotation: number;
|
|
1399
|
+
/**
|
|
1400
|
+
* Start angle in degrees
|
|
1401
|
+
* @default 0
|
|
1402
|
+
* @minimum -Infinity
|
|
1403
|
+
* @maximum Infinity
|
|
1404
|
+
* @step 1
|
|
1405
|
+
*/
|
|
1406
|
+
startAngle: number;
|
|
1407
|
+
}
|
|
1408
|
+
class TextDto {
|
|
1409
|
+
constructor(text?: string, segments?: number, xOffset?: number, yOffset?: number, height?: number, lineSpacing?: number, letterSpacing?: number, align?: jscadTextAlignEnum, extrudeOffset?: number);
|
|
1410
|
+
/**
|
|
1411
|
+
* Text to write
|
|
1412
|
+
* @default Hello World
|
|
1413
|
+
*/
|
|
1414
|
+
text: string;
|
|
1415
|
+
/**
|
|
1416
|
+
* Number of segments
|
|
1417
|
+
* @default 24
|
|
1418
|
+
* @minimum 0
|
|
1419
|
+
* @maximum Infinity
|
|
1420
|
+
* @step 1
|
|
1421
|
+
*/
|
|
1422
|
+
segments: number;
|
|
1423
|
+
/**
|
|
1424
|
+
* X offset of the text
|
|
1425
|
+
* @default 0
|
|
1426
|
+
* @minimum -Infinity
|
|
1427
|
+
* @maximum Infinity
|
|
1428
|
+
* @step 0.1
|
|
1429
|
+
*/
|
|
1430
|
+
xOffset: number;
|
|
1431
|
+
/**
|
|
1432
|
+
* Y offset of the text
|
|
1433
|
+
* @default 0
|
|
1434
|
+
* @minimum -Infinity
|
|
1435
|
+
* @maximum Infinity
|
|
1436
|
+
* @step 0.1
|
|
1437
|
+
*/
|
|
1438
|
+
yOffset: number;
|
|
1439
|
+
/**
|
|
1440
|
+
* Height of the text
|
|
1441
|
+
* @default 1
|
|
1442
|
+
* @minimum 0
|
|
1443
|
+
* @maximum Infinity
|
|
1444
|
+
* @step 0.1
|
|
1445
|
+
*/
|
|
1446
|
+
height: number;
|
|
1447
|
+
/**
|
|
1448
|
+
* Space between lines
|
|
1449
|
+
* @default 1.4
|
|
1450
|
+
* @minimum -Infinity
|
|
1451
|
+
* @maximum Infinity
|
|
1452
|
+
* @step 0.1
|
|
1453
|
+
*/
|
|
1454
|
+
lineSpacing: number;
|
|
1455
|
+
/**
|
|
1456
|
+
* Space between letters
|
|
1457
|
+
* @default 1
|
|
1458
|
+
* @minimum -Infinity
|
|
1459
|
+
* @maximum Infinity
|
|
1460
|
+
* @step 0.1
|
|
1461
|
+
*/
|
|
1462
|
+
letterSpacing: number;
|
|
1463
|
+
/**
|
|
1464
|
+
* Align between left, center, right
|
|
1465
|
+
* @default center
|
|
1466
|
+
*/
|
|
1467
|
+
align: jscadTextAlignEnum;
|
|
1468
|
+
/**
|
|
1469
|
+
* Offset the extrusion
|
|
1470
|
+
* @default 0
|
|
1471
|
+
* @minimum -Infinity
|
|
1472
|
+
* @maximum Infinity
|
|
1473
|
+
* @step 0.1
|
|
1474
|
+
*/
|
|
1475
|
+
extrudeOffset: number;
|
|
1476
|
+
}
|
|
1477
|
+
class CylinderTextDto {
|
|
1478
|
+
constructor(text?: string, extrusionHeight?: number, extrusionSize?: number, segments?: number, xOffset?: number, yOffset?: number, height?: number, lineSpacing?: number, letterSpacing?: number, align?: jscadTextAlignEnum, extrudeOffset?: number);
|
|
1479
|
+
/**
|
|
1480
|
+
* Text to write
|
|
1481
|
+
* @default Hello World
|
|
1482
|
+
*/
|
|
1483
|
+
text: string;
|
|
1484
|
+
/**
|
|
1485
|
+
* Height of the cylinder
|
|
1486
|
+
* @default 0.5
|
|
1487
|
+
* @minimum 0
|
|
1488
|
+
* @maximum Infinity
|
|
1489
|
+
* @step 0.1
|
|
1490
|
+
*/
|
|
1491
|
+
extrusionHeight: number;
|
|
1492
|
+
/**
|
|
1493
|
+
* Radius of the cylinder
|
|
1494
|
+
* @default 0.1
|
|
1495
|
+
* @minimum 0
|
|
1496
|
+
* @maximum Infinity
|
|
1497
|
+
* @step 0.1
|
|
1498
|
+
*/
|
|
1499
|
+
extrusionSize: number;
|
|
1500
|
+
/**
|
|
1501
|
+
* Segment subdivision for cylinder
|
|
1502
|
+
* @default 24
|
|
1503
|
+
* @minimum 0
|
|
1504
|
+
* @maximum Infinity
|
|
1505
|
+
* @step 1
|
|
1506
|
+
*/
|
|
1507
|
+
segments: number;
|
|
1508
|
+
/**
|
|
1509
|
+
* X offset of the text
|
|
1510
|
+
* @default 0
|
|
1511
|
+
* @minimum -Infinity
|
|
1512
|
+
* @maximum Infinity
|
|
1513
|
+
* @step 0.1
|
|
1514
|
+
*/
|
|
1515
|
+
xOffset: number;
|
|
1516
|
+
/**
|
|
1517
|
+
* Y offset of the text
|
|
1518
|
+
* @default 0
|
|
1519
|
+
* @minimum -Infinity
|
|
1520
|
+
* @maximum Infinity
|
|
1521
|
+
* @step 0.1
|
|
1522
|
+
*/
|
|
1523
|
+
yOffset: number;
|
|
1524
|
+
/**
|
|
1525
|
+
* Height of the text
|
|
1526
|
+
* @default 1
|
|
1527
|
+
* @minimum 0
|
|
1528
|
+
* @maximum Infinity
|
|
1529
|
+
* @step 0.1
|
|
1530
|
+
*/
|
|
1531
|
+
height: number;
|
|
1532
|
+
/**
|
|
1533
|
+
* Space between lines
|
|
1534
|
+
* @default 1.4
|
|
1535
|
+
* @minimum -Infinity
|
|
1536
|
+
* @maximum Infinity
|
|
1537
|
+
* @step 0.1
|
|
1538
|
+
*/
|
|
1539
|
+
lineSpacing: number;
|
|
1540
|
+
/**
|
|
1541
|
+
* Space between letters
|
|
1542
|
+
* @default 1
|
|
1543
|
+
* @minimum -Infinity
|
|
1544
|
+
* @maximum Infinity
|
|
1545
|
+
* @step 0.1
|
|
1546
|
+
*/
|
|
1547
|
+
letterSpacing: number;
|
|
1548
|
+
/**
|
|
1549
|
+
* Align between left, center, right
|
|
1550
|
+
* @default center
|
|
1551
|
+
*/
|
|
1552
|
+
align: jscadTextAlignEnum;
|
|
1553
|
+
/**
|
|
1554
|
+
* Offset the extrusion
|
|
1555
|
+
* @default 0
|
|
1556
|
+
* @minimum -Infinity
|
|
1557
|
+
* @maximum Infinity
|
|
1558
|
+
* @step 0.1
|
|
1559
|
+
*/
|
|
1560
|
+
extrudeOffset: number;
|
|
1561
|
+
}
|
|
1562
|
+
class SphereTextDto {
|
|
1563
|
+
constructor(text?: string, radius?: number, segments?: number, xOffset?: number, yOffset?: number, height?: number, lineSpacing?: number, letterSpacing?: number, align?: jscadTextAlignEnum, extrudeOffset?: number);
|
|
1564
|
+
/**
|
|
1565
|
+
* Text to write
|
|
1566
|
+
* @default Hello World
|
|
1567
|
+
*/
|
|
1568
|
+
text: string;
|
|
1569
|
+
/**
|
|
1570
|
+
* Radius of the spheres
|
|
1571
|
+
* @default 0.1
|
|
1572
|
+
* @minimum 0
|
|
1573
|
+
* @maximum Infinity
|
|
1574
|
+
* @step 0.1
|
|
1575
|
+
*/
|
|
1576
|
+
radius: number;
|
|
1577
|
+
/**
|
|
1578
|
+
* Segment subdivision for sphere
|
|
1579
|
+
* @default 24
|
|
1580
|
+
* @minimum 0
|
|
1581
|
+
* @maximum Infinity
|
|
1582
|
+
* @step 1
|
|
1583
|
+
*/
|
|
1584
|
+
segments: number;
|
|
1585
|
+
/**
|
|
1586
|
+
* X offset of the text
|
|
1587
|
+
* @default 0
|
|
1588
|
+
* @minimum -Infinity
|
|
1589
|
+
* @maximum Infinity
|
|
1590
|
+
* @step 0.1
|
|
1591
|
+
*/
|
|
1592
|
+
xOffset: number;
|
|
1593
|
+
/**
|
|
1594
|
+
* Y offset of the text
|
|
1595
|
+
* @default 0
|
|
1596
|
+
* @minimum -Infinity
|
|
1597
|
+
* @maximum Infinity
|
|
1598
|
+
* @step 0.1
|
|
1599
|
+
*/
|
|
1600
|
+
yOffset: number;
|
|
1601
|
+
/**
|
|
1602
|
+
* Height of the text
|
|
1603
|
+
* @default 1
|
|
1604
|
+
* @minimum 0
|
|
1605
|
+
* @maximum Infinity
|
|
1606
|
+
* @step 0.1
|
|
1607
|
+
*/
|
|
1608
|
+
height: number;
|
|
1609
|
+
/**
|
|
1610
|
+
* Space between lines
|
|
1611
|
+
* @default 1.4
|
|
1612
|
+
* @minimum -Infinity
|
|
1613
|
+
* @maximum Infinity
|
|
1614
|
+
* @step 0.1
|
|
1615
|
+
*/
|
|
1616
|
+
lineSpacing: number;
|
|
1617
|
+
/**
|
|
1618
|
+
* Space between letters
|
|
1619
|
+
* @default 1
|
|
1620
|
+
* @minimum -Infinity
|
|
1621
|
+
* @maximum Infinity
|
|
1622
|
+
* @step 0.1
|
|
1623
|
+
*/
|
|
1624
|
+
letterSpacing: number;
|
|
1625
|
+
/**
|
|
1626
|
+
* Align between left, center, right
|
|
1627
|
+
* @default center
|
|
1628
|
+
*/
|
|
1629
|
+
align: jscadTextAlignEnum;
|
|
1630
|
+
/**
|
|
1631
|
+
* Offset the extrusion
|
|
1632
|
+
* @default 0
|
|
1633
|
+
* @minimum -Infinity
|
|
1634
|
+
* @maximum Infinity
|
|
1635
|
+
* @step 0.1
|
|
1636
|
+
*/
|
|
1637
|
+
extrudeOffset: number;
|
|
1638
|
+
}
|
|
1639
|
+
class FromPolygonPoints {
|
|
1640
|
+
constructor(polygonPoints?: Base.Point3[][]);
|
|
1641
|
+
/**
|
|
1642
|
+
* Points describing polygons
|
|
1643
|
+
*/
|
|
1644
|
+
polygonPoints?: Base.Point3[][];
|
|
1645
|
+
}
|
|
1646
|
+
}
|