Cleanup: remove redundant, invalid info from headers
[blender.git] / source / blender / editors / io / io_alembic.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software  Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2016 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file blender/editors/io/io_alembic.c
21  *  \ingroup editor/io
22  */
23
24 #ifdef WITH_ALEMBIC
25
26 /* needed for directory lookup */
27 #ifndef WIN32
28 #  include <dirent.h>
29 #else
30 #  include "BLI_winstuff.h"
31 #endif
32
33 #include <string.h>
34 #include <errno.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "DNA_mesh_types.h"
39 #include "DNA_modifier_types.h"
40 #include "DNA_object_types.h"
41 #include "DNA_scene_types.h"
42 #include "DNA_space_types.h"
43
44 #include "BKE_context.h"
45 #include "BKE_global.h"
46 #include "BKE_main.h"
47 #include "BKE_report.h"
48
49 #include "BLI_listbase.h"
50 #include "BLI_math_vector.h"
51 #include "BLI_path_util.h"
52 #include "BLI_string.h"
53 #include "BLI_utildefines.h"
54
55 #include "BLT_translation.h"
56
57 #include "RNA_access.h"
58 #include "RNA_define.h"
59 #include "RNA_enum_types.h"
60
61 #include "ED_object.h"
62
63 #include "UI_interface.h"
64 #include "UI_resources.h"
65
66 #include "WM_api.h"
67 #include "WM_types.h"
68
69 #include "io_alembic.h"
70
71 #include "ABC_alembic.h"
72
73 static int wm_alembic_export_invoke(bContext *C, wmOperator *op, const wmEvent *event)
74 {
75         if (!RNA_struct_property_is_set(op->ptr, "as_background_job")) {
76                 RNA_boolean_set(op->ptr, "as_background_job", true);
77         }
78
79         RNA_boolean_set(op->ptr, "init_scene_frame_range", true);
80
81         if (!RNA_struct_property_is_set(op->ptr, "filepath")) {
82                 Main *bmain = CTX_data_main(C);
83                 char filepath[FILE_MAX];
84
85                 if (BKE_main_blendfile_path(bmain)[0] == '\0') {
86                         BLI_strncpy(filepath, "untitled", sizeof(filepath));
87                 }
88                 else {
89                         BLI_strncpy(filepath, BKE_main_blendfile_path(bmain), sizeof(filepath));
90                 }
91
92                 BLI_path_extension_replace(filepath, sizeof(filepath), ".abc");
93                 RNA_string_set(op->ptr, "filepath", filepath);
94         }
95
96         WM_event_add_fileselect(C, op);
97
98         return OPERATOR_RUNNING_MODAL;
99
100         UNUSED_VARS(event);
101 }
102
103 static int wm_alembic_export_exec(bContext *C, wmOperator *op)
104 {
105         if (!RNA_struct_property_is_set(op->ptr, "filepath")) {
106                 BKE_report(op->reports, RPT_ERROR, "No filename given");
107                 return OPERATOR_CANCELLED;
108         }
109
110         char filename[FILE_MAX];
111         RNA_string_get(op->ptr, "filepath", filename);
112
113         struct AlembicExportParams params = {
114             .frame_start = RNA_int_get(op->ptr, "start"),
115             .frame_end = RNA_int_get(op->ptr, "end"),
116
117             .frame_samples_xform = RNA_int_get(op->ptr, "xsamples"),
118             .frame_samples_shape = RNA_int_get(op->ptr, "gsamples"),
119
120             .shutter_open = RNA_float_get(op->ptr, "sh_open"),
121             .shutter_close = RNA_float_get(op->ptr, "sh_close"),
122
123             .selected_only = RNA_boolean_get(op->ptr, "selected"),
124             .uvs = RNA_boolean_get(op->ptr, "uvs"),
125             .normals = RNA_boolean_get(op->ptr, "normals"),
126             .vcolors = RNA_boolean_get(op->ptr, "vcolors"),
127             .apply_subdiv = RNA_boolean_get(op->ptr, "apply_subdiv"),
128             .curves_as_mesh = RNA_boolean_get(op->ptr, "curves_as_mesh"),
129             .flatten_hierarchy = RNA_boolean_get(op->ptr, "flatten"),
130             .visible_layers_only = RNA_boolean_get(op->ptr, "visible_layers_only"),
131             .renderable_only = RNA_boolean_get(op->ptr, "renderable_only"),
132             .face_sets = RNA_boolean_get(op->ptr, "face_sets"),
133             .use_subdiv_schema = RNA_boolean_get(op->ptr, "subdiv_schema"),
134             .export_hair = RNA_boolean_get(op->ptr, "export_hair"),
135             .export_particles = RNA_boolean_get(op->ptr, "export_particles"),
136             .compression_type = RNA_enum_get(op->ptr, "compression_type"),
137             .packuv = RNA_boolean_get(op->ptr, "packuv"),
138             .triangulate = RNA_boolean_get(op->ptr, "triangulate"),
139             .quad_method = RNA_enum_get(op->ptr, "quad_method"),
140             .ngon_method = RNA_enum_get(op->ptr, "ngon_method"),
141
142             .global_scale = RNA_float_get(op->ptr, "global_scale"),
143         };
144
145         /* Take some defaults from the scene, if not specified explicitly. */
146         Scene *scene = CTX_data_scene(C);
147         if (params.frame_start == INT_MIN) {
148                 params.frame_start = SFRA;
149         }
150         if (params.frame_end == INT_MIN) {
151                 params.frame_end = EFRA;
152         }
153
154         const bool as_background_job = RNA_boolean_get(op->ptr, "as_background_job");
155         bool ok = ABC_export(scene, C, filename, &params, as_background_job);
156
157         return as_background_job || ok ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
158 }
159
160 static void ui_alembic_export_settings(uiLayout *layout, PointerRNA *imfptr)
161 {
162         uiLayout *box;
163         uiLayout *row;
164         uiLayout *col;
165
166 #ifdef WITH_ALEMBIC_HDF5
167         box = uiLayoutBox(layout);
168         row = uiLayoutRow(box, false);
169         uiItemL(row, IFACE_("Archive Options:"), ICON_NONE);
170
171         row = uiLayoutRow(box, false);
172         uiItemR(row, imfptr, "compression_type", 0, NULL, ICON_NONE);
173 #endif
174
175         box = uiLayoutBox(layout);
176         row = uiLayoutRow(box, false);
177         uiItemL(row, IFACE_("Manual Transform:"), ICON_NONE);
178
179         row = uiLayoutRow(box, false);
180         uiItemR(row, imfptr, "global_scale", 0, NULL, ICON_NONE);
181
182         /* Scene Options */
183         box = uiLayoutBox(layout);
184         row = uiLayoutRow(box, false);
185         uiItemL(row, IFACE_("Scene Options:"), ICON_SCENE_DATA);
186
187         row = uiLayoutRow(box, false);
188         uiItemR(row, imfptr, "start", 0, NULL, ICON_NONE);
189
190         row = uiLayoutRow(box, false);
191         uiItemR(row, imfptr, "end", 0, NULL, ICON_NONE);
192
193         row = uiLayoutRow(box, false);
194         uiItemR(row, imfptr, "xsamples", 0, NULL, ICON_NONE);
195
196         row = uiLayoutRow(box, false);
197         uiItemR(row, imfptr, "gsamples", 0, NULL, ICON_NONE);
198
199         row = uiLayoutRow(box, false);
200         uiItemR(row, imfptr, "sh_open", 0, NULL, ICON_NONE);
201
202         row = uiLayoutRow(box, false);
203         uiItemR(row, imfptr, "sh_close", 0, NULL, ICON_NONE);
204
205         row = uiLayoutRow(box, false);
206         uiItemR(row, imfptr, "selected", 0, NULL, ICON_NONE);
207
208         row = uiLayoutRow(box, false);
209         uiItemR(row, imfptr, "renderable_only", 0, NULL, ICON_NONE);
210
211         row = uiLayoutRow(box, false);
212         uiItemR(row, imfptr, "visible_layers_only", 0, NULL, ICON_NONE);
213
214         row = uiLayoutRow(box, false);
215         uiItemR(row, imfptr, "flatten", 0, NULL, ICON_NONE);
216
217         /* Object Data */
218         box = uiLayoutBox(layout);
219         row = uiLayoutRow(box, false);
220         uiItemL(row, IFACE_("Object Options:"), ICON_OBJECT_DATA);
221
222         row = uiLayoutRow(box, false);
223         uiItemR(row, imfptr, "uvs", 0, NULL, ICON_NONE);
224
225         row = uiLayoutRow(box, false);
226         uiItemR(row, imfptr, "packuv", 0, NULL, ICON_NONE);
227         uiLayoutSetEnabled(row, RNA_boolean_get(imfptr, "uvs"));
228
229         row = uiLayoutRow(box, false);
230         uiItemR(row, imfptr, "normals", 0, NULL, ICON_NONE);
231
232         row = uiLayoutRow(box, false);
233         uiItemR(row, imfptr, "vcolors", 0, NULL, ICON_NONE);
234
235         row = uiLayoutRow(box, false);
236         uiItemR(row, imfptr, "face_sets", 0, NULL, ICON_NONE);
237
238         row = uiLayoutRow(box, false);
239         uiItemR(row, imfptr, "subdiv_schema", 0, NULL, ICON_NONE);
240
241         row = uiLayoutRow(box, false);
242         uiItemR(row, imfptr, "apply_subdiv", 0, NULL, ICON_NONE);
243
244         row = uiLayoutRow(box, false);
245         uiItemR(row, imfptr, "curves_as_mesh", 0, NULL, ICON_NONE);
246
247         row = uiLayoutRow(box, false);
248         uiItemR(row, imfptr, "triangulate", 0, NULL, ICON_NONE);
249
250         const bool triangulate = RNA_boolean_get(imfptr, "triangulate");
251
252         row = uiLayoutRow(box, false);
253         uiLayoutSetEnabled(row, triangulate);
254         uiItemR(row, imfptr, "quad_method", 0, NULL, ICON_NONE);
255
256         row = uiLayoutRow(box, false);
257         uiLayoutSetEnabled(row, triangulate);
258         uiItemR(row, imfptr, "ngon_method", 0, NULL, ICON_NONE);
259
260         /* Object Data */
261         box = uiLayoutBox(layout);
262         row = uiLayoutRow(box, false);
263         uiItemL(row, IFACE_("Particle Systems:"), ICON_PARTICLE_DATA);
264
265         col = uiLayoutColumn(box, true);
266         uiItemR(col, imfptr, "export_hair", 0, NULL, ICON_NONE);
267         uiItemR(col, imfptr, "export_particles", 0, NULL, ICON_NONE);
268 }
269
270 static void wm_alembic_export_draw(bContext *C, wmOperator *op)
271 {
272         PointerRNA ptr;
273
274         RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
275
276         /* Conveniently set start and end frame to match the scene's frame range. */
277         Scene *scene = CTX_data_scene(C);
278
279         if (scene != NULL && RNA_boolean_get(&ptr, "init_scene_frame_range")) {
280                 RNA_int_set(&ptr, "start", SFRA);
281                 RNA_int_set(&ptr, "end", EFRA);
282
283                 RNA_boolean_set(&ptr, "init_scene_frame_range", false);
284         }
285
286         ui_alembic_export_settings(op->layout, &ptr);
287 }
288
289 static bool wm_alembic_export_check(bContext *UNUSED(C), wmOperator *op)
290 {
291         char filepath[FILE_MAX];
292         RNA_string_get(op->ptr, "filepath", filepath);
293
294         if (!BLI_path_extension_check(filepath, ".abc")) {
295                 BLI_path_extension_ensure(filepath, FILE_MAX, ".abc");
296                 RNA_string_set(op->ptr, "filepath", filepath);
297                 return true;
298         }
299
300         return false;
301 }
302
303 void WM_OT_alembic_export(wmOperatorType *ot)
304 {
305         ot->name = "Export Alembic";
306         ot->description = "Export current scene in an Alembic archive";
307         ot->idname = "WM_OT_alembic_export";
308
309         ot->invoke = wm_alembic_export_invoke;
310         ot->exec = wm_alembic_export_exec;
311         ot->poll = WM_operator_winactive;
312         ot->ui = wm_alembic_export_draw;
313         ot->check = wm_alembic_export_check;
314
315         WM_operator_properties_filesel(ot, FILE_TYPE_FOLDER | FILE_TYPE_ALEMBIC,
316                                        FILE_BLENDER, FILE_SAVE, WM_FILESEL_FILEPATH,
317                                        FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
318
319         RNA_def_int(ot->srna, "start", INT_MIN, INT_MIN, INT_MAX,
320                     "Start Frame",
321                     "Start frame of the export, use the default value to "
322                     "take the start frame of the current scene",
323                     INT_MIN, INT_MAX);
324
325         RNA_def_int(ot->srna, "end", INT_MIN, INT_MIN, INT_MAX,
326                     "End Frame",
327                     "End frame of the export, use the default value to "
328                     "take the end frame of the current scene",
329                     INT_MIN, INT_MAX);
330
331         RNA_def_int(ot->srna, "xsamples", 1, 1, 128,
332                     "Transform Samples", "Number of times per frame transformations are sampled", 1, 128);
333
334         RNA_def_int(ot->srna, "gsamples", 1, 1, 128,
335                     "Geometry Samples", "Number of times per frame object data are sampled", 1, 128);
336
337         RNA_def_float(ot->srna, "sh_open", 0.0f, -1.0f, 1.0f,
338                       "Shutter Open", "Time at which the shutter is open", -1.0f, 1.0f);
339
340         RNA_def_float(ot->srna, "sh_close", 1.0f, -1.0f, 1.0f,
341                       "Shutter Close", "Time at which the shutter is closed", -1.0f, 1.0f);
342
343         RNA_def_boolean(ot->srna, "selected", 0,
344                         "Selected Objects Only", "Export only selected objects");
345
346         RNA_def_boolean(ot->srna, "renderable_only", 1,
347                         "Renderable Objects Only",
348                         "Export only objects marked renderable in the outliner");
349
350         RNA_def_boolean(ot->srna, "visible_layers_only", 0,
351                         "Visible Layers Only", "Export only objects in visible layers");
352
353         RNA_def_boolean(ot->srna, "flatten", 0,
354                         "Flatten Hierarchy",
355                         "Do not preserve objects' parent/children relationship");
356
357         RNA_def_boolean(ot->srna, "uvs", 1, "UVs", "Export UVs");
358
359         RNA_def_boolean(ot->srna, "packuv", 1, "Pack UV Islands",
360                         "Export UVs with packed island");
361
362         RNA_def_boolean(ot->srna, "normals", 1, "Normals", "Export normals");
363
364         RNA_def_boolean(ot->srna, "vcolors", 0, "Vertex Colors", "Export vertex colors");
365
366         RNA_def_boolean(ot->srna, "face_sets", 0, "Face Sets", "Export per face shading group assignments");
367
368         RNA_def_boolean(ot->srna, "subdiv_schema", 0,
369                         "Use Subdivision Schema",
370                         "Export meshes using Alembic's subdivision schema");
371
372         RNA_def_boolean(ot->srna, "apply_subdiv", 0,
373                         "Apply Subsurf", "Export subdivision surfaces as meshes");
374
375         RNA_def_boolean(ot->srna, "curves_as_mesh", false,
376                         "Curves as Mesh", "Export curves and NURBS surfaces as meshes");
377
378         RNA_def_enum(ot->srna, "compression_type", rna_enum_abc_compression_items,
379                      ABC_ARCHIVE_OGAWA, "Compression", "");
380
381         RNA_def_float(ot->srna, "global_scale", 1.0f, 0.0001f, 1000.0f, "Scale",
382                       "Value by which to enlarge or shrink the objects with respect to the world's origin",
383                       0.0001f, 1000.0f);
384
385         RNA_def_boolean(ot->srna, "triangulate", false, "Triangulate",
386                         "Export Polygons (Quads & NGons) as Triangles");
387
388         RNA_def_enum(ot->srna, "quad_method", rna_enum_modifier_triangulate_quad_method_items,
389                      MOD_TRIANGULATE_QUAD_SHORTEDGE, "Quad Method", "Method for splitting the quads into triangles");
390
391         RNA_def_enum(ot->srna, "ngon_method", rna_enum_modifier_triangulate_quad_method_items,
392                      MOD_TRIANGULATE_NGON_BEAUTY, "Polygon Method", "Method for splitting the polygons into triangles");
393
394         RNA_def_boolean(ot->srna, "export_hair", 1, "Export Hair", "Exports hair particle systems as animated curves");
395         RNA_def_boolean(ot->srna, "export_particles", 1, "Export Particles", "Exports non-hair particle systems");
396
397         RNA_def_boolean(ot->srna, "as_background_job", false, "Run as Background Job",
398                         "Enable this to run the import in the background, disable to block Blender while importing. "
399                         "This option is deprecated; EXECUTE this operator to run in the foreground, and INVOKE it "
400                         "to run as a background job");
401
402         /* This dummy prop is used to check whether we need to init the start and
403          * end frame values to that of the scene's, otherwise they are reset at
404          * every change, draw update. */
405         RNA_def_boolean(ot->srna, "init_scene_frame_range", false, "", "");
406 }
407
408 /* ************************************************************************** */
409
410 /* TODO(kevin): check on de-duplicating all this with code in image_ops.c */
411
412 typedef struct CacheFrame {
413         struct CacheFrame *next, *prev;
414         int framenr;
415 } CacheFrame;
416
417 static int cmp_frame(const void *a, const void *b)
418 {
419         const CacheFrame *frame_a = a;
420         const CacheFrame *frame_b = b;
421
422         if (frame_a->framenr < frame_b->framenr) return -1;
423         if (frame_a->framenr > frame_b->framenr) return 1;
424         return 0;
425 }
426
427 static int get_sequence_len(char *filename, int *ofs)
428 {
429         int frame;
430         int numdigit;
431
432         if (!BLI_path_frame_get(filename, &frame, &numdigit)) {
433                 return 1;
434         }
435
436         char path[FILE_MAX];
437         BLI_path_abs(filename, BKE_main_blendfile_path_from_global());
438         BLI_split_dir_part(filename, path, FILE_MAX);
439
440         if (path[0] == '\0') {
441                 /* The filename had no path, so just use the blend file path. */
442                 BLI_split_dir_part(BKE_main_blendfile_path_from_global(), path, FILE_MAX);
443         }
444
445         DIR *dir = opendir(path);
446         if (dir == NULL) {
447                 fprintf(stderr, "Error opening directory '%s': %s\n",
448                         path, errno ? strerror(errno) : "unknown error");
449                 return -1;
450         }
451
452         const char *ext = ".abc";
453         const char *basename = BLI_path_basename(filename);
454         const int len = strlen(basename) - (numdigit + strlen(ext));
455
456         ListBase frames;
457         BLI_listbase_clear(&frames);
458
459         struct dirent *fname;
460         while ((fname = readdir(dir)) != NULL) {
461                 /* do we have the right extension? */
462                 if (!strstr(fname->d_name, ext)) {
463                         continue;
464                 }
465
466                 if (!STREQLEN(basename, fname->d_name, len)) {
467                         continue;
468                 }
469
470                 CacheFrame *cache_frame = MEM_callocN(sizeof(CacheFrame), "abc_frame");
471
472                 BLI_path_frame_get(fname->d_name, &cache_frame->framenr, &numdigit);
473
474                 BLI_addtail(&frames, cache_frame);
475         }
476
477         closedir(dir);
478
479         BLI_listbase_sort(&frames, cmp_frame);
480
481         CacheFrame *cache_frame = frames.first;
482
483         if (cache_frame) {
484                 int frame_curr = cache_frame->framenr;
485                 (*ofs) = frame_curr;
486
487                 while (cache_frame && (cache_frame->framenr == frame_curr)) {
488                         ++frame_curr;
489                         cache_frame = cache_frame->next;
490                 }
491
492                 BLI_freelistN(&frames);
493
494                 return frame_curr - (*ofs);
495         }
496
497         return 1;
498 }
499
500 /* ************************************************************************** */
501
502 static void ui_alembic_import_settings(uiLayout *layout, PointerRNA *imfptr)
503 {
504         uiLayout *box = uiLayoutBox(layout);
505         uiLayout *row = uiLayoutRow(box, false);
506         uiItemL(row, IFACE_("Manual Transform:"), ICON_NONE);
507
508         row = uiLayoutRow(box, false);
509         uiItemR(row, imfptr, "scale", 0, NULL, ICON_NONE);
510
511         box = uiLayoutBox(layout);
512         row = uiLayoutRow(box, false);
513         uiItemL(row, IFACE_("Options:"), ICON_NONE);
514
515         row = uiLayoutRow(box, false);
516         uiItemR(row, imfptr, "set_frame_range", 0, NULL, ICON_NONE);
517
518         row = uiLayoutRow(box, false);
519         uiItemR(row, imfptr, "is_sequence", 0, NULL, ICON_NONE);
520
521         row = uiLayoutRow(box, false);
522         uiItemR(row, imfptr, "validate_meshes", 0, NULL, ICON_NONE);
523 }
524
525 static void wm_alembic_import_draw(bContext *UNUSED(C), wmOperator *op)
526 {
527         PointerRNA ptr;
528
529         RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
530         ui_alembic_import_settings(op->layout, &ptr);
531 }
532
533
534 /* op->invoke, opens fileselect if path property not set, otherwise executes */
535 static int wm_alembic_import_invoke(bContext *C, wmOperator *op, const wmEvent *event)
536 {
537         if (!RNA_struct_property_is_set(op->ptr, "as_background_job")) {
538                 RNA_boolean_set(op->ptr, "as_background_job", true);
539         }
540         return WM_operator_filesel(C, op, event);
541 }
542
543
544 static int wm_alembic_import_exec(bContext *C, wmOperator *op)
545 {
546         if (!RNA_struct_property_is_set(op->ptr, "filepath")) {
547                 BKE_report(op->reports, RPT_ERROR, "No filename given");
548                 return OPERATOR_CANCELLED;
549         }
550
551         char filename[FILE_MAX];
552         RNA_string_get(op->ptr, "filepath", filename);
553
554         const float scale = RNA_float_get(op->ptr, "scale");
555         const bool is_sequence = RNA_boolean_get(op->ptr, "is_sequence");
556         const bool set_frame_range = RNA_boolean_get(op->ptr, "set_frame_range");
557         const bool validate_meshes = RNA_boolean_get(op->ptr, "validate_meshes");
558         const bool as_background_job = RNA_boolean_get(op->ptr, "as_background_job");
559
560         int offset = 0;
561         int sequence_len = 1;
562
563         if (is_sequence) {
564                 sequence_len = get_sequence_len(filename, &offset);
565                 if (sequence_len < 0) {
566                         BKE_report(op->reports, RPT_ERROR, "Unable to determine ABC sequence length");
567                         return OPERATOR_CANCELLED;
568                 }
569         }
570
571         /* Switch out of edit mode to avoid being stuck in it (T54326). */
572         Object *obedit = CTX_data_edit_object(C);
573         if (obedit) {
574                 ED_object_mode_toggle(C, OB_MODE_EDIT);
575         }
576
577         bool ok = ABC_import(C, filename, scale, is_sequence, set_frame_range,
578                              sequence_len, offset, validate_meshes,
579                              as_background_job);
580
581         return as_background_job || ok ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
582 }
583
584 void WM_OT_alembic_import(wmOperatorType *ot)
585 {
586         ot->name = "Import Alembic";
587         ot->description = "Load an Alembic archive";
588         ot->idname = "WM_OT_alembic_import";
589
590         ot->invoke = wm_alembic_import_invoke;
591         ot->exec = wm_alembic_import_exec;
592         ot->poll = WM_operator_winactive;
593         ot->ui = wm_alembic_import_draw;
594
595         WM_operator_properties_filesel(ot, FILE_TYPE_FOLDER | FILE_TYPE_ALEMBIC,
596                                        FILE_BLENDER, FILE_SAVE, WM_FILESEL_FILEPATH,
597                                        FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
598
599         RNA_def_float(ot->srna, "scale", 1.0f, 0.0001f, 1000.0f, "Scale",
600                       "Value by which to enlarge or shrink the objects with respect to the world's origin",
601                       0.0001f, 1000.0f);
602
603         RNA_def_boolean(ot->srna, "set_frame_range", true,
604                         "Set Frame Range",
605                         "If checked, update scene's start and end frame to match those of the Alembic archive");
606
607         RNA_def_boolean(ot->srna, "validate_meshes", 0,
608                         "Validate Meshes", "Check imported mesh objects for invalid data (slow)");
609
610         RNA_def_boolean(ot->srna, "is_sequence", false, "Is Sequence",
611                         "Set to true if the cache is split into separate files");
612
613         RNA_def_boolean(ot->srna, "as_background_job", false, "Run as Background Job",
614                         "Enable this to run the export in the background, disable to block Blender while exporting. "
615                         "This option is deprecated; EXECUTE this operator to run in the foreground, and INVOKE it "
616                         "to run as a background job");
617 }
618
619 #endif