Cleanup: style, use braces for editors
[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
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,
316                                  FILE_TYPE_FOLDER | FILE_TYPE_ALEMBIC,
317                                  FILE_BLENDER,
318                                  FILE_SAVE,
319                                  WM_FILESEL_FILEPATH,
320                                  FILE_DEFAULTDISPLAY,
321                                  FILE_SORT_ALPHA);
322
323   RNA_def_int(ot->srna,
324               "start",
325               INT_MIN,
326               INT_MIN,
327               INT_MAX,
328               "Start Frame",
329               "Start frame of the export, use the default value to "
330               "take the start frame of the current scene",
331               INT_MIN,
332               INT_MAX);
333
334   RNA_def_int(ot->srna,
335               "end",
336               INT_MIN,
337               INT_MIN,
338               INT_MAX,
339               "End Frame",
340               "End frame of the export, use the default value to "
341               "take the end frame of the current scene",
342               INT_MIN,
343               INT_MAX);
344
345   RNA_def_int(ot->srna,
346               "xsamples",
347               1,
348               1,
349               128,
350               "Transform Samples",
351               "Number of times per frame transformations are sampled",
352               1,
353               128);
354
355   RNA_def_int(ot->srna,
356               "gsamples",
357               1,
358               1,
359               128,
360               "Geometry Samples",
361               "Number of times per frame object data are sampled",
362               1,
363               128);
364
365   RNA_def_float(ot->srna,
366                 "sh_open",
367                 0.0f,
368                 -1.0f,
369                 1.0f,
370                 "Shutter Open",
371                 "Time at which the shutter is open",
372                 -1.0f,
373                 1.0f);
374
375   RNA_def_float(ot->srna,
376                 "sh_close",
377                 1.0f,
378                 -1.0f,
379                 1.0f,
380                 "Shutter Close",
381                 "Time at which the shutter is closed",
382                 -1.0f,
383                 1.0f);
384
385   RNA_def_boolean(
386       ot->srna, "selected", 0, "Selected Objects Only", "Export only selected objects");
387
388   RNA_def_boolean(ot->srna,
389                   "renderable_only",
390                   1,
391                   "Renderable Objects Only",
392                   "Export only objects marked renderable in the outliner");
393
394   RNA_def_boolean(ot->srna,
395                   "visible_layers_only",
396                   0,
397                   "Visible Layers Only",
398                   "Export only objects in visible layers");
399
400   RNA_def_boolean(ot->srna,
401                   "flatten",
402                   0,
403                   "Flatten Hierarchy",
404                   "Do not preserve objects' parent/children relationship");
405
406   RNA_def_boolean(ot->srna, "uvs", 1, "UVs", "Export UVs");
407
408   RNA_def_boolean(ot->srna, "packuv", 1, "Pack UV Islands", "Export UVs with packed island");
409
410   RNA_def_boolean(ot->srna, "normals", 1, "Normals", "Export normals");
411
412   RNA_def_boolean(ot->srna, "vcolors", 0, "Vertex Colors", "Export vertex colors");
413
414   RNA_def_boolean(
415       ot->srna, "face_sets", 0, "Face Sets", "Export per face shading group assignments");
416
417   RNA_def_boolean(ot->srna,
418                   "subdiv_schema",
419                   0,
420                   "Use Subdivision Schema",
421                   "Export meshes using Alembic's subdivision schema");
422
423   RNA_def_boolean(
424       ot->srna, "apply_subdiv", 0, "Apply Subsurf", "Export subdivision surfaces as meshes");
425
426   RNA_def_boolean(ot->srna,
427                   "curves_as_mesh",
428                   false,
429                   "Curves as Mesh",
430                   "Export curves and NURBS surfaces as meshes");
431
432   RNA_def_enum(ot->srna,
433                "compression_type",
434                rna_enum_abc_compression_items,
435                ABC_ARCHIVE_OGAWA,
436                "Compression",
437                "");
438
439   RNA_def_float(
440       ot->srna,
441       "global_scale",
442       1.0f,
443       0.0001f,
444       1000.0f,
445       "Scale",
446       "Value by which to enlarge or shrink the objects with respect to the world's origin",
447       0.0001f,
448       1000.0f);
449
450   RNA_def_boolean(ot->srna,
451                   "triangulate",
452                   false,
453                   "Triangulate",
454                   "Export Polygons (Quads & NGons) as Triangles");
455
456   RNA_def_enum(ot->srna,
457                "quad_method",
458                rna_enum_modifier_triangulate_quad_method_items,
459                MOD_TRIANGULATE_QUAD_SHORTEDGE,
460                "Quad Method",
461                "Method for splitting the quads into triangles");
462
463   RNA_def_enum(ot->srna,
464                "ngon_method",
465                rna_enum_modifier_triangulate_quad_method_items,
466                MOD_TRIANGULATE_NGON_BEAUTY,
467                "Polygon Method",
468                "Method for splitting the polygons into triangles");
469
470   RNA_def_boolean(ot->srna,
471                   "export_hair",
472                   1,
473                   "Export Hair",
474                   "Exports hair particle systems as animated curves");
475   RNA_def_boolean(
476       ot->srna, "export_particles", 1, "Export Particles", "Exports non-hair particle systems");
477
478   RNA_def_boolean(
479       ot->srna,
480       "as_background_job",
481       false,
482       "Run as Background Job",
483       "Enable this to run the import in the background, disable to block Blender while importing. "
484       "This option is deprecated; EXECUTE this operator to run in the foreground, and INVOKE it "
485       "to run as a background job");
486
487   /* This dummy prop is used to check whether we need to init the start and
488    * end frame values to that of the scene's, otherwise they are reset at
489    * every change, draw update. */
490   RNA_def_boolean(ot->srna, "init_scene_frame_range", false, "", "");
491 }
492
493 /* ************************************************************************** */
494
495 /* TODO(kevin): check on de-duplicating all this with code in image_ops.c */
496
497 typedef struct CacheFrame {
498   struct CacheFrame *next, *prev;
499   int framenr;
500 } CacheFrame;
501
502 static int cmp_frame(const void *a, const void *b)
503 {
504   const CacheFrame *frame_a = a;
505   const CacheFrame *frame_b = b;
506
507   if (frame_a->framenr < frame_b->framenr) {
508     return -1;
509   }
510   if (frame_a->framenr > frame_b->framenr) {
511     return 1;
512   }
513   return 0;
514 }
515
516 static int get_sequence_len(char *filename, int *ofs)
517 {
518   int frame;
519   int numdigit;
520
521   if (!BLI_path_frame_get(filename, &frame, &numdigit)) {
522     return 1;
523   }
524
525   char path[FILE_MAX];
526   BLI_path_abs(filename, BKE_main_blendfile_path_from_global());
527   BLI_split_dir_part(filename, path, FILE_MAX);
528
529   if (path[0] == '\0') {
530     /* The filename had no path, so just use the blend file path. */
531     BLI_split_dir_part(BKE_main_blendfile_path_from_global(), path, FILE_MAX);
532   }
533
534   DIR *dir = opendir(path);
535   if (dir == NULL) {
536     fprintf(stderr,
537             "Error opening directory '%s': %s\n",
538             path,
539             errno ? strerror(errno) : "unknown error");
540     return -1;
541   }
542
543   const char *ext = ".abc";
544   const char *basename = BLI_path_basename(filename);
545   const int len = strlen(basename) - (numdigit + strlen(ext));
546
547   ListBase frames;
548   BLI_listbase_clear(&frames);
549
550   struct dirent *fname;
551   while ((fname = readdir(dir)) != NULL) {
552     /* do we have the right extension? */
553     if (!strstr(fname->d_name, ext)) {
554       continue;
555     }
556
557     if (!STREQLEN(basename, fname->d_name, len)) {
558       continue;
559     }
560
561     CacheFrame *cache_frame = MEM_callocN(sizeof(CacheFrame), "abc_frame");
562
563     BLI_path_frame_get(fname->d_name, &cache_frame->framenr, &numdigit);
564
565     BLI_addtail(&frames, cache_frame);
566   }
567
568   closedir(dir);
569
570   BLI_listbase_sort(&frames, cmp_frame);
571
572   CacheFrame *cache_frame = frames.first;
573
574   if (cache_frame) {
575     int frame_curr = cache_frame->framenr;
576     (*ofs) = frame_curr;
577
578     while (cache_frame && (cache_frame->framenr == frame_curr)) {
579       ++frame_curr;
580       cache_frame = cache_frame->next;
581     }
582
583     BLI_freelistN(&frames);
584
585     return frame_curr - (*ofs);
586   }
587
588   return 1;
589 }
590
591 /* ************************************************************************** */
592
593 static void ui_alembic_import_settings(uiLayout *layout, PointerRNA *imfptr)
594 {
595   uiLayout *box = uiLayoutBox(layout);
596   uiLayout *row = uiLayoutRow(box, false);
597   uiItemL(row, IFACE_("Manual Transform:"), ICON_NONE);
598
599   row = uiLayoutRow(box, false);
600   uiItemR(row, imfptr, "scale", 0, NULL, ICON_NONE);
601
602   box = uiLayoutBox(layout);
603   row = uiLayoutRow(box, false);
604   uiItemL(row, IFACE_("Options:"), ICON_NONE);
605
606   row = uiLayoutRow(box, false);
607   uiItemR(row, imfptr, "set_frame_range", 0, NULL, ICON_NONE);
608
609   row = uiLayoutRow(box, false);
610   uiItemR(row, imfptr, "is_sequence", 0, NULL, ICON_NONE);
611
612   row = uiLayoutRow(box, false);
613   uiItemR(row, imfptr, "validate_meshes", 0, NULL, ICON_NONE);
614 }
615
616 static void wm_alembic_import_draw(bContext *UNUSED(C), wmOperator *op)
617 {
618   PointerRNA ptr;
619
620   RNA_pointer_create(NULL, op->type->srna, op->properties, &ptr);
621   ui_alembic_import_settings(op->layout, &ptr);
622 }
623
624 /* op->invoke, opens fileselect if path property not set, otherwise executes */
625 static int wm_alembic_import_invoke(bContext *C, wmOperator *op, const wmEvent *event)
626 {
627   if (!RNA_struct_property_is_set(op->ptr, "as_background_job")) {
628     RNA_boolean_set(op->ptr, "as_background_job", true);
629   }
630   return WM_operator_filesel(C, op, event);
631 }
632
633 static int wm_alembic_import_exec(bContext *C, wmOperator *op)
634 {
635   if (!RNA_struct_property_is_set(op->ptr, "filepath")) {
636     BKE_report(op->reports, RPT_ERROR, "No filename given");
637     return OPERATOR_CANCELLED;
638   }
639
640   char filename[FILE_MAX];
641   RNA_string_get(op->ptr, "filepath", filename);
642
643   const float scale = RNA_float_get(op->ptr, "scale");
644   const bool is_sequence = RNA_boolean_get(op->ptr, "is_sequence");
645   const bool set_frame_range = RNA_boolean_get(op->ptr, "set_frame_range");
646   const bool validate_meshes = RNA_boolean_get(op->ptr, "validate_meshes");
647   const bool as_background_job = RNA_boolean_get(op->ptr, "as_background_job");
648
649   int offset = 0;
650   int sequence_len = 1;
651
652   if (is_sequence) {
653     sequence_len = get_sequence_len(filename, &offset);
654     if (sequence_len < 0) {
655       BKE_report(op->reports, RPT_ERROR, "Unable to determine ABC sequence length");
656       return OPERATOR_CANCELLED;
657     }
658   }
659
660   /* Switch out of edit mode to avoid being stuck in it (T54326). */
661   Object *obedit = CTX_data_edit_object(C);
662   if (obedit) {
663     ED_object_mode_toggle(C, OB_MODE_EDIT);
664   }
665
666   bool ok = ABC_import(C,
667                        filename,
668                        scale,
669                        is_sequence,
670                        set_frame_range,
671                        sequence_len,
672                        offset,
673                        validate_meshes,
674                        as_background_job);
675
676   return as_background_job || ok ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
677 }
678
679 void WM_OT_alembic_import(wmOperatorType *ot)
680 {
681   ot->name = "Import Alembic";
682   ot->description = "Load an Alembic archive";
683   ot->idname = "WM_OT_alembic_import";
684
685   ot->invoke = wm_alembic_import_invoke;
686   ot->exec = wm_alembic_import_exec;
687   ot->poll = WM_operator_winactive;
688   ot->ui = wm_alembic_import_draw;
689
690   WM_operator_properties_filesel(ot,
691                                  FILE_TYPE_FOLDER | FILE_TYPE_ALEMBIC,
692                                  FILE_BLENDER,
693                                  FILE_SAVE,
694                                  WM_FILESEL_FILEPATH,
695                                  FILE_DEFAULTDISPLAY,
696                                  FILE_SORT_ALPHA);
697
698   RNA_def_float(
699       ot->srna,
700       "scale",
701       1.0f,
702       0.0001f,
703       1000.0f,
704       "Scale",
705       "Value by which to enlarge or shrink the objects with respect to the world's origin",
706       0.0001f,
707       1000.0f);
708
709   RNA_def_boolean(
710       ot->srna,
711       "set_frame_range",
712       true,
713       "Set Frame Range",
714       "If checked, update scene's start and end frame to match those of the Alembic archive");
715
716   RNA_def_boolean(ot->srna,
717                   "validate_meshes",
718                   0,
719                   "Validate Meshes",
720                   "Check imported mesh objects for invalid data (slow)");
721
722   RNA_def_boolean(ot->srna,
723                   "is_sequence",
724                   false,
725                   "Is Sequence",
726                   "Set to true if the cache is split into separate files");
727
728   RNA_def_boolean(
729       ot->srna,
730       "as_background_job",
731       false,
732       "Run as Background Job",
733       "Enable this to run the export in the background, disable to block Blender while exporting. "
734       "This option is deprecated; EXECUTE this operator to run in the foreground, and INVOKE it "
735       "to run as a background job");
736 }
737
738 #endif