@threepipe/plugins-extra-importers 0.2.0 → 0.2.3
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/dist/dependencies.txt +1 -1
- package/dist/index.d.ts +72 -72
- package/dist/index.js +15185 -0
- package/dist/index.js.map +1 -0
- package/package.json +15 -4
- package/dist/index.mjs +0 -17
- package/dist/index.mjs.map +0 -1
package/dist/dependencies.txt
CHANGED
package/dist/index.d.ts
CHANGED
|
@@ -30,24 +30,24 @@ export declare class ColladaLoadPlugin extends BaseImporterPlugin {
|
|
|
30
30
|
static readonly PluginType = "ColladaLoadPlugin";
|
|
31
31
|
protected _importer: Importer<{
|
|
32
32
|
transform(res: Collada, _: AnyOptions): Scene;
|
|
33
|
-
load(url: string, onLoad: (collada: Collada) => void, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined, onError?: ((event: ErrorEvent) => void) | undefined): void;
|
|
34
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<Collada>;
|
|
35
33
|
parse(text: string, path: string): Collada;
|
|
36
34
|
crossOrigin: string;
|
|
37
35
|
withCredentials: boolean;
|
|
38
36
|
path: string;
|
|
39
37
|
resourcePath: string;
|
|
40
|
-
manager: import(
|
|
38
|
+
manager: import('threepipe').LoadingManager;
|
|
41
39
|
requestHeader: {
|
|
42
40
|
[header: string]: string;
|
|
43
41
|
};
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
42
|
+
load(url: string, onLoad: (data: Collada) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
43
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>;
|
|
44
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
45
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
46
|
+
setPath(path: string): /*elided*/ any;
|
|
47
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
48
48
|
setRequestHeader(requestHeader: {
|
|
49
49
|
[header: string]: string;
|
|
50
|
-
}): any;
|
|
50
|
+
}): /*elided*/ any;
|
|
51
51
|
}>;
|
|
52
52
|
}
|
|
53
53
|
/**
|
|
@@ -73,24 +73,24 @@ export declare class BVHLoadPlugin extends BaseImporterPlugin {
|
|
|
73
73
|
transform(res: BVH, _: AnyOptions): Object3D;
|
|
74
74
|
animateBonePositions: boolean;
|
|
75
75
|
animateBoneRotations: boolean;
|
|
76
|
-
load(url: string, onLoad: (bvh: BVH) => void, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined, onError?: ((event: ErrorEvent) => void) | undefined): void;
|
|
77
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<BVH>;
|
|
78
76
|
parse(text: string): BVH;
|
|
79
77
|
crossOrigin: string;
|
|
80
78
|
withCredentials: boolean;
|
|
81
79
|
path: string;
|
|
82
80
|
resourcePath: string;
|
|
83
|
-
manager: import(
|
|
81
|
+
manager: import('threepipe').LoadingManager;
|
|
84
82
|
requestHeader: {
|
|
85
83
|
[header: string]: string;
|
|
86
84
|
};
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
85
|
+
load(url: string, onLoad: (data: BVH) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
86
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BVH>;
|
|
87
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
88
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
89
|
+
setPath(path: string): /*elided*/ any;
|
|
90
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
91
91
|
setRequestHeader(requestHeader: {
|
|
92
92
|
[header: string]: string;
|
|
93
|
-
}): any;
|
|
93
|
+
}): /*elided*/ any;
|
|
94
94
|
}>;
|
|
95
95
|
}
|
|
96
96
|
/**
|
|
@@ -100,24 +100,24 @@ export declare class VOXLoadPlugin extends BaseImporterPlugin {
|
|
|
100
100
|
static readonly PluginType = "VOXLoadPlugin";
|
|
101
101
|
protected _importer: Importer<{
|
|
102
102
|
transform(chunks: Chunk[], _: AnyOptions): Object3D;
|
|
103
|
-
load(url: string, onLoad: (chunks: Chunk[]) => void, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined, onError?: ((event: ErrorEvent) => void) | undefined): void;
|
|
104
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<Chunk[]>;
|
|
105
103
|
parse(data: ArrayBuffer): object[];
|
|
106
104
|
crossOrigin: string;
|
|
107
105
|
withCredentials: boolean;
|
|
108
106
|
path: string;
|
|
109
107
|
resourcePath: string;
|
|
110
|
-
manager: import(
|
|
108
|
+
manager: import('threepipe').LoadingManager;
|
|
111
109
|
requestHeader: {
|
|
112
110
|
[header: string]: string;
|
|
113
111
|
};
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
112
|
+
load(url: string, onLoad: (data: Chunk[]) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
113
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
|
|
114
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
115
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
116
|
+
setPath(path: string): /*elided*/ any;
|
|
117
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
118
118
|
setRequestHeader(requestHeader: {
|
|
119
119
|
[header: string]: string;
|
|
120
|
-
}): any;
|
|
120
|
+
}): /*elided*/ any;
|
|
121
121
|
}>;
|
|
122
122
|
}
|
|
123
123
|
/**
|
|
@@ -127,24 +127,24 @@ export declare class MDDLoadPlugin extends BaseImporterPlugin {
|
|
|
127
127
|
static readonly PluginType = "MDDLoadPlugin";
|
|
128
128
|
protected _importer: Importer<{
|
|
129
129
|
transform(res: MDD, _: AnyOptions): Object3D;
|
|
130
|
-
load(url: string, onLoad: (result: MDD) => void, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined, onError?: ((event: ErrorEvent) => void) | undefined): void;
|
|
131
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<MDD>;
|
|
132
130
|
parse(data: ArrayBuffer): MDD;
|
|
133
131
|
crossOrigin: string;
|
|
134
132
|
withCredentials: boolean;
|
|
135
133
|
path: string;
|
|
136
134
|
resourcePath: string;
|
|
137
|
-
manager: import(
|
|
135
|
+
manager: import('threepipe').LoadingManager;
|
|
138
136
|
requestHeader: {
|
|
139
137
|
[header: string]: string;
|
|
140
138
|
};
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
139
|
+
load(url: string, onLoad: (data: MDD) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
140
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>;
|
|
141
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
142
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
143
|
+
setPath(path: string): /*elided*/ any;
|
|
144
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
145
145
|
setRequestHeader(requestHeader: {
|
|
146
146
|
[header: string]: string;
|
|
147
|
-
}): any;
|
|
147
|
+
}): /*elided*/ any;
|
|
148
148
|
}>;
|
|
149
149
|
}
|
|
150
150
|
/**
|
|
@@ -155,24 +155,24 @@ export declare class PCDLoadPlugin extends BaseImporterPlugin {
|
|
|
155
155
|
protected _importer: Importer<{
|
|
156
156
|
transform(points: Points, options: AnyOptions): any;
|
|
157
157
|
littleEndian: boolean;
|
|
158
|
-
|
|
159
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<Points<BufferGeometry<import("three").NormalBufferAttributes, import("three").Event, string>, import("threepipe").Material<import("three").Event, string> | import("threepipe").Material<import("three").Event, string>[]>>;
|
|
160
|
-
parse(data: string | ArrayBuffer): Points<BufferGeometry<import("three").NormalBufferAttributes, import("three").Event, string>, import("threepipe").Material<import("three").Event, string> | import("threepipe").Material<import("three").Event, string>[]>;
|
|
158
|
+
parse(data: ArrayBuffer | string): Points;
|
|
161
159
|
crossOrigin: string;
|
|
162
160
|
withCredentials: boolean;
|
|
163
161
|
path: string;
|
|
164
162
|
resourcePath: string;
|
|
165
|
-
manager: import(
|
|
163
|
+
manager: import('threepipe').LoadingManager;
|
|
166
164
|
requestHeader: {
|
|
167
165
|
[header: string]: string;
|
|
168
166
|
};
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
167
|
+
load(url: string, onLoad: (data: Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, import('threepipe').Material<import('./threepipe').MaterialEventMap> | import('threepipe').Material<import('./threepipe').MaterialEventMap>[]>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
168
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>, import('threepipe').Material<import('./threepipe').MaterialEventMap> | import('threepipe').Material<import('./threepipe').MaterialEventMap>[]>>;
|
|
169
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
170
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
171
|
+
setPath(path: string): /*elided*/ any;
|
|
172
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
173
173
|
setRequestHeader(requestHeader: {
|
|
174
174
|
[header: string]: string;
|
|
175
|
-
}): any;
|
|
175
|
+
}): /*elided*/ any;
|
|
176
176
|
}>;
|
|
177
177
|
}
|
|
178
178
|
/**
|
|
@@ -196,33 +196,33 @@ export declare class LDrawLoadPlugin extends BaseImporterPlugin {
|
|
|
196
196
|
static readonly PluginType = "LDrawLoadPlugin";
|
|
197
197
|
protected _importer: Importer<{
|
|
198
198
|
transform(res: Group, _: AnyOptions): any;
|
|
199
|
-
materials: import(
|
|
200
|
-
materialsLibrary: Record<string, import(
|
|
199
|
+
materials: import('threepipe').Material[];
|
|
200
|
+
materialsLibrary: Record<string, import('threepipe').Material>;
|
|
201
201
|
fileMap: Record<string, string>;
|
|
202
202
|
smoothNormals: boolean;
|
|
203
|
-
load(url: string, onLoad: (data: Group) => void, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined, onError?: ((event: ErrorEvent) => void) | undefined): void;
|
|
204
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<Group>;
|
|
205
203
|
preloadMaterials(url: string): Promise<void>;
|
|
206
204
|
setFileMap(fileMap: Record<string, string>): void;
|
|
207
|
-
setMaterials(materials: import(
|
|
205
|
+
setMaterials(materials: import('threepipe').Material[]): void;
|
|
208
206
|
parse(text: string, path: string, onLoad: (data: Group) => void): void;
|
|
209
|
-
addMaterial(material: import(
|
|
210
|
-
getMaterial(colourCode: string): import(
|
|
207
|
+
addMaterial(material: import('threepipe').Material): void;
|
|
208
|
+
getMaterial(colourCode: string): import('threepipe').Material | null;
|
|
211
209
|
crossOrigin: string;
|
|
212
210
|
withCredentials: boolean;
|
|
213
211
|
path: string;
|
|
214
212
|
resourcePath: string;
|
|
215
|
-
manager: import(
|
|
213
|
+
manager: import('threepipe').LoadingManager;
|
|
216
214
|
requestHeader: {
|
|
217
215
|
[header: string]: string;
|
|
218
216
|
};
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
217
|
+
load(url: string, onLoad: (data: Group<import('./threepipe').Object3DEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
218
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group<import('./threepipe').Object3DEventMap>>;
|
|
219
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
220
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
221
|
+
setPath(path: string): /*elided*/ any;
|
|
222
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
223
223
|
setRequestHeader(requestHeader: {
|
|
224
224
|
[header: string]: string;
|
|
225
|
-
}): any;
|
|
225
|
+
}): /*elided*/ any;
|
|
226
226
|
}>;
|
|
227
227
|
}
|
|
228
228
|
/**
|
|
@@ -232,24 +232,24 @@ export declare class VTKLoadPlugin extends BaseImporterPlugin {
|
|
|
232
232
|
static readonly PluginType = "VTKLoadPlugin";
|
|
233
233
|
protected _importer: Importer<{
|
|
234
234
|
transform(res: BufferGeometry, _: AnyOptions): Mesh | undefined;
|
|
235
|
-
|
|
236
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<BufferGeometry<import("three").NormalBufferAttributes, import("three").Event, string>>;
|
|
237
|
-
parse(data: string | ArrayBuffer, path: string): BufferGeometry<import("three").NormalBufferAttributes, import("three").Event, string>;
|
|
235
|
+
parse(data: ArrayBuffer | string, path: string): BufferGeometry;
|
|
238
236
|
crossOrigin: string;
|
|
239
237
|
withCredentials: boolean;
|
|
240
238
|
path: string;
|
|
241
239
|
resourcePath: string;
|
|
242
|
-
manager: import(
|
|
240
|
+
manager: import('threepipe').LoadingManager;
|
|
243
241
|
requestHeader: {
|
|
244
242
|
[header: string]: string;
|
|
245
243
|
};
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
244
|
+
load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
245
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
|
|
246
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
247
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
248
|
+
setPath(path: string): /*elided*/ any;
|
|
249
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
250
250
|
setRequestHeader(requestHeader: {
|
|
251
251
|
[header: string]: string;
|
|
252
|
-
}): any;
|
|
252
|
+
}): /*elided*/ any;
|
|
253
253
|
}>;
|
|
254
254
|
}
|
|
255
255
|
/**
|
|
@@ -259,24 +259,24 @@ export declare class XYZLoadPlugin extends BaseImporterPlugin {
|
|
|
259
259
|
static readonly PluginType = "XYZLoadPlugin";
|
|
260
260
|
protected _importer: Importer<{
|
|
261
261
|
transform(res: BufferGeometry, options: AnyOptions): Points | undefined;
|
|
262
|
-
|
|
263
|
-
loadAsync(url: string, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<BufferGeometry<import("three").NormalBufferAttributes, import("three").Event, string>>;
|
|
264
|
-
parse(data: string, onLoad: (geometry: BufferGeometry<import("three").NormalBufferAttributes, import("three").Event, string>) => void): object;
|
|
262
|
+
parse(data: string, onLoad: (geometry: BufferGeometry) => void): object;
|
|
265
263
|
crossOrigin: string;
|
|
266
264
|
withCredentials: boolean;
|
|
267
265
|
path: string;
|
|
268
266
|
resourcePath: string;
|
|
269
|
-
manager: import(
|
|
267
|
+
manager: import('threepipe').LoadingManager;
|
|
270
268
|
requestHeader: {
|
|
271
269
|
[header: string]: string;
|
|
272
270
|
};
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
271
|
+
load(url: string, onLoad: (data: BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>) => void, onProgress?: (event: ProgressEvent) => void, onError?: (err: unknown) => void): void;
|
|
272
|
+
loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry<import('./threepipe').NormalBufferAttributes, import('./threepipe').BufferGeometryEventMap>>;
|
|
273
|
+
setCrossOrigin(crossOrigin: string): /*elided*/ any;
|
|
274
|
+
setWithCredentials(value: boolean): /*elided*/ any;
|
|
275
|
+
setPath(path: string): /*elided*/ any;
|
|
276
|
+
setResourcePath(resourcePath: string): /*elided*/ any;
|
|
277
277
|
setRequestHeader(requestHeader: {
|
|
278
278
|
[header: string]: string;
|
|
279
|
-
}): any;
|
|
279
|
+
}): /*elided*/ any;
|
|
280
280
|
}>;
|
|
281
281
|
}
|
|
282
282
|
export declare const extraImportPlugins: readonly [typeof TDSLoadPlugin, typeof ThreeMFLoadPlugin, typeof ColladaLoadPlugin, typeof AMFLoadPlugin, typeof GCodeLoadPlugin, typeof BVHLoadPlugin, typeof VOXLoadPlugin, typeof MDDLoadPlugin, typeof PCDLoadPlugin, typeof TiltLoadPlugin, typeof VRMLLoadPlugin, typeof LDrawLoadPlugin, typeof VTKLoadPlugin, typeof XYZLoadPlugin];
|