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