Merge branch 'blender-v2.81-release'
[blender.git] / source / blender / makesrna / intern / rna_image.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
17 /** \file
18  * \ingroup RNA
19  */
20
21 #include <stdlib.h>
22
23 #include "DNA_image_types.h"
24 #include "DNA_node_types.h"
25 #include "DNA_scene_types.h"
26
27 #include "BLI_utildefines.h"
28
29 #include "BKE_image.h"
30
31 #include "DEG_depsgraph.h"
32 #include "DEG_depsgraph_build.h"
33
34 #include "RNA_access.h"
35 #include "RNA_define.h"
36 #include "RNA_enum_types.h"
37
38 #include "rna_internal.h"
39
40 #include "WM_types.h"
41 #include "WM_api.h"
42
43 const EnumPropertyItem rna_enum_image_generated_type_items[] = {
44     {IMA_GENTYPE_BLANK, "BLANK", 0, "Blank", "Generate a blank image"},
45     {IMA_GENTYPE_GRID, "UV_GRID", 0, "UV Grid", "Generated grid to test UV mappings"},
46     {IMA_GENTYPE_GRID_COLOR,
47      "COLOR_GRID",
48      0,
49      "Color Grid",
50      "Generated improved UV grid to test UV mappings"},
51     {0, NULL, 0, NULL, NULL},
52 };
53
54 static const EnumPropertyItem image_source_items[] = {
55     {IMA_SRC_FILE, "FILE", 0, "Single Image", "Single image file"},
56     {IMA_SRC_SEQUENCE, "SEQUENCE", 0, "Image Sequence", "Multiple image files, as a sequence"},
57     {IMA_SRC_MOVIE, "MOVIE", 0, "Movie", "Movie file"},
58     {IMA_SRC_GENERATED, "GENERATED", 0, "Generated", "Generated image"},
59     {IMA_SRC_VIEWER, "VIEWER", 0, "Viewer", "Compositing node viewer"},
60     {0, NULL, 0, NULL, NULL},
61 };
62
63 #ifdef RNA_RUNTIME
64
65 #  include "BLI_math_base.h"
66
67 #  include "BKE_global.h"
68
69 #  include "GPU_draw.h"
70 #  include "GPU_texture.h"
71
72 #  include "IMB_imbuf.h"
73 #  include "IMB_imbuf_types.h"
74
75 #  include "ED_node.h"
76
77 static bool rna_Image_is_stereo_3d_get(PointerRNA *ptr)
78 {
79   return BKE_image_is_stereo((Image *)ptr->data);
80 }
81
82 static bool rna_Image_is_multiview_get(PointerRNA *ptr)
83 {
84   return BKE_image_is_multiview((Image *)ptr->data);
85 }
86
87 static bool rna_Image_dirty_get(PointerRNA *ptr)
88 {
89   return BKE_image_is_dirty((Image *)ptr->data);
90 }
91
92 static void rna_Image_source_set(PointerRNA *ptr, int value)
93 {
94   Image *ima = (Image *)ptr->owner_id;
95
96   if (value != ima->source) {
97     ima->source = value;
98     BLI_assert(BKE_id_is_in_global_main(&ima->id));
99     BKE_image_signal(G_MAIN, ima, NULL, IMA_SIGNAL_SRC_CHANGE);
100     DEG_id_tag_update(&ima->id, 0);
101     DEG_id_tag_update(&ima->id, ID_RECALC_EDITORS);
102     DEG_relations_tag_update(G_MAIN);
103   }
104 }
105
106 static void rna_Image_reload_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
107 {
108   Image *ima = (Image *)ptr->owner_id;
109   BKE_image_signal(bmain, ima, NULL, IMA_SIGNAL_RELOAD);
110   WM_main_add_notifier(NC_IMAGE | NA_EDITED, &ima->id);
111   DEG_id_tag_update(&ima->id, 0);
112   DEG_id_tag_update(&ima->id, ID_RECALC_EDITORS);
113 }
114
115 static void rna_Image_generated_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
116 {
117   Image *ima = (Image *)ptr->owner_id;
118   BKE_image_signal(bmain, ima, NULL, IMA_SIGNAL_FREE);
119 }
120
121 static void rna_Image_colormanage_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
122 {
123   Image *ima = (Image *)ptr->owner_id;
124   BKE_image_signal(bmain, ima, NULL, IMA_SIGNAL_COLORMANAGE);
125   DEG_id_tag_update(&ima->id, 0);
126   DEG_id_tag_update(&ima->id, ID_RECALC_EDITORS);
127   WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
128   WM_main_add_notifier(NC_IMAGE | NA_EDITED, &ima->id);
129 }
130
131 static void rna_Image_views_format_update(Main *bmain, Scene *scene, PointerRNA *ptr)
132 {
133   Image *ima = (Image *)ptr->owner_id;
134   ImBuf *ibuf;
135   void *lock;
136
137   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
138
139   if (ibuf) {
140     ImageUser iuser = {NULL};
141     iuser.scene = scene;
142     BKE_image_signal(bmain, ima, &iuser, IMA_SIGNAL_FREE);
143   }
144
145   BKE_image_release_ibuf(ima, ibuf, lock);
146 }
147
148 static void rna_ImageUser_update(Main *bmain, Scene *scene, PointerRNA *ptr)
149 {
150   ImageUser *iuser = ptr->data;
151   ID *id = ptr->owner_id;
152
153   BKE_image_user_frame_calc(NULL, iuser, scene->r.cfra);
154
155   if (id) {
156     if (GS(id->name) == ID_NT) {
157       /* Special update for nodetrees to find parent datablock. */
158       ED_node_tag_update_nodetree(bmain, (bNodeTree *)id, NULL);
159     }
160     else {
161       /* Update material or texture for render preview. */
162       DEG_id_tag_update(id, 0);
163       DEG_id_tag_update(id, ID_RECALC_EDITORS);
164     }
165   }
166 }
167
168 static void rna_ImageUser_relations_update(Main *bmain, Scene *scene, PointerRNA *ptr)
169 {
170   rna_ImageUser_update(bmain, scene, ptr);
171   DEG_relations_tag_update(bmain);
172 }
173
174 static char *rna_ImageUser_path(PointerRNA *ptr)
175 {
176   if (ptr->owner_id) {
177     /* ImageUser *iuser = ptr->data; */
178
179     switch (GS(ptr->owner_id->name)) {
180       case ID_OB:
181       case ID_TE: {
182         return BLI_strdup("image_user");
183       }
184       case ID_NT: {
185         return rna_Node_ImageUser_path(ptr);
186       }
187       default:
188         break;
189     }
190   }
191
192   return BLI_strdup("");
193 }
194
195 static const EnumPropertyItem *rna_Image_source_itemf(bContext *UNUSED(C),
196                                                       PointerRNA *ptr,
197                                                       PropertyRNA *UNUSED(prop),
198                                                       bool *r_free)
199 {
200   Image *ima = (Image *)ptr->data;
201   EnumPropertyItem *item = NULL;
202   int totitem = 0;
203
204   if (ima->source == IMA_SRC_VIEWER) {
205     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_VIEWER);
206   }
207   else {
208     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_FILE);
209     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_SEQUENCE);
210     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_MOVIE);
211     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_GENERATED);
212   }
213
214   RNA_enum_item_end(&item, &totitem);
215   *r_free = true;
216
217   return item;
218 }
219
220 static int rna_Image_file_format_get(PointerRNA *ptr)
221 {
222   Image *image = (Image *)ptr->data;
223   ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
224   int imtype = BKE_image_ftype_to_imtype(ibuf ? ibuf->ftype : 0, ibuf ? &ibuf->foptions : NULL);
225
226   BKE_image_release_ibuf(image, ibuf, NULL);
227
228   return imtype;
229 }
230
231 static void rna_Image_file_format_set(PointerRNA *ptr, int value)
232 {
233   Image *image = (Image *)ptr->data;
234   if (BKE_imtype_is_movie(value) == 0) { /* should be able to throw an error here */
235     ImbFormatOptions options;
236     int ftype = BKE_image_imtype_to_ftype(value, &options);
237     BKE_image_file_format_set(image, ftype, &options);
238   }
239 }
240
241 static bool rna_Image_has_data_get(PointerRNA *ptr)
242 {
243   Image *image = (Image *)ptr->data;
244
245   return BKE_image_has_loaded_ibuf(image);
246 }
247
248 static void rna_Image_size_get(PointerRNA *ptr, int *values)
249 {
250   Image *im = (Image *)ptr->data;
251   ImBuf *ibuf;
252   void *lock;
253
254   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
255   if (ibuf) {
256     values[0] = ibuf->x;
257     values[1] = ibuf->y;
258   }
259   else {
260     values[0] = 0;
261     values[1] = 0;
262   }
263
264   BKE_image_release_ibuf(im, ibuf, lock);
265 }
266
267 static void rna_Image_resolution_get(PointerRNA *ptr, float *values)
268 {
269   Image *im = (Image *)ptr->data;
270   ImBuf *ibuf;
271   void *lock;
272
273   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
274   if (ibuf) {
275     values[0] = ibuf->ppm[0];
276     values[1] = ibuf->ppm[1];
277   }
278   else {
279     values[0] = 0;
280     values[1] = 0;
281   }
282
283   BKE_image_release_ibuf(im, ibuf, lock);
284 }
285
286 static void rna_Image_resolution_set(PointerRNA *ptr, const float *values)
287 {
288   Image *im = (Image *)ptr->data;
289   ImBuf *ibuf;
290   void *lock;
291
292   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
293   if (ibuf) {
294     ibuf->ppm[0] = values[0];
295     ibuf->ppm[1] = values[1];
296   }
297
298   BKE_image_release_ibuf(im, ibuf, lock);
299 }
300
301 static int rna_Image_bindcode_get(PointerRNA *ptr)
302 {
303   Image *ima = (Image *)ptr->data;
304   GPUTexture *tex = ima->gputexture[TEXTARGET_TEXTURE_2D];
305   return (tex) ? GPU_texture_opengl_bindcode(tex) : 0;
306 }
307
308 static int rna_Image_depth_get(PointerRNA *ptr)
309 {
310   Image *im = (Image *)ptr->data;
311   ImBuf *ibuf;
312   void *lock;
313   int planes;
314
315   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
316
317   if (!ibuf) {
318     planes = 0;
319   }
320   else if (ibuf->rect_float) {
321     planes = ibuf->planes * 4;
322   }
323   else {
324     planes = ibuf->planes;
325   }
326
327   BKE_image_release_ibuf(im, ibuf, lock);
328
329   return planes;
330 }
331
332 static int rna_Image_frame_duration_get(PointerRNA *ptr)
333 {
334   Image *ima = (Image *)ptr->owner_id;
335   int duration = 1;
336
337   if (BKE_image_has_anim(ima)) {
338     struct anim *anim = ((ImageAnim *)ima->anims.first)->anim;
339     if (anim) {
340       duration = IMB_anim_get_duration(anim, IMB_TC_RECORD_RUN);
341     }
342   }
343   else {
344     /* acquire ensures ima->anim is set, if possible! */
345     void *lock;
346     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
347     BKE_image_release_ibuf(ima, ibuf, lock);
348   }
349
350   return duration;
351 }
352
353 static int rna_Image_pixels_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
354 {
355   Image *ima = (Image *)ptr->owner_id;
356   ImBuf *ibuf;
357   void *lock;
358
359   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
360
361   if (ibuf) {
362     length[0] = ibuf->x * ibuf->y * ibuf->channels;
363   }
364   else {
365     length[0] = 0;
366   }
367
368   BKE_image_release_ibuf(ima, ibuf, lock);
369
370   return length[0];
371 }
372
373 static void rna_Image_pixels_get(PointerRNA *ptr, float *values)
374 {
375   Image *ima = (Image *)ptr->owner_id;
376   ImBuf *ibuf;
377   void *lock;
378   int i, size;
379
380   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
381
382   if (ibuf) {
383     size = ibuf->x * ibuf->y * ibuf->channels;
384
385     if (ibuf->rect_float) {
386       memcpy(values, ibuf->rect_float, sizeof(float) * size);
387     }
388     else {
389       for (i = 0; i < size; i++) {
390         values[i] = ((unsigned char *)ibuf->rect)[i] * (1.0f / 255.0f);
391       }
392     }
393   }
394
395   BKE_image_release_ibuf(ima, ibuf, lock);
396 }
397
398 static void rna_Image_pixels_set(PointerRNA *ptr, const float *values)
399 {
400   Image *ima = (Image *)ptr->owner_id;
401   ImBuf *ibuf;
402   void *lock;
403   int i, size;
404
405   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
406
407   if (ibuf) {
408     size = ibuf->x * ibuf->y * ibuf->channels;
409
410     if (ibuf->rect_float) {
411       memcpy(ibuf->rect_float, values, sizeof(float) * size);
412     }
413     else {
414       for (i = 0; i < size; i++) {
415         ((unsigned char *)ibuf->rect)[i] = unit_float_to_uchar_clamp(values[i]);
416       }
417     }
418
419     ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID | IB_MIPMAP_INVALID;
420     BKE_image_mark_dirty(ima, ibuf);
421     if (!G.background) {
422       GPU_free_image(ima);
423     }
424     WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
425   }
426
427   BKE_image_release_ibuf(ima, ibuf, lock);
428 }
429
430 static int rna_Image_channels_get(PointerRNA *ptr)
431 {
432   Image *im = (Image *)ptr->data;
433   ImBuf *ibuf;
434   void *lock;
435   int channels = 0;
436
437   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
438   if (ibuf) {
439     channels = ibuf->channels;
440   }
441
442   BKE_image_release_ibuf(im, ibuf, lock);
443
444   return channels;
445 }
446
447 static bool rna_Image_is_float_get(PointerRNA *ptr)
448 {
449   Image *im = (Image *)ptr->data;
450   ImBuf *ibuf;
451   void *lock;
452   bool is_float = false;
453
454   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
455   if (ibuf) {
456     is_float = ibuf->rect_float != NULL;
457   }
458
459   BKE_image_release_ibuf(im, ibuf, lock);
460
461   return is_float;
462 }
463
464 static PointerRNA rna_Image_packed_file_get(PointerRNA *ptr)
465 {
466   Image *ima = (Image *)ptr->owner_id;
467
468   if (BKE_image_has_packedfile(ima)) {
469     ImagePackedFile *imapf = ima->packedfiles.first;
470     return rna_pointer_inherit_refine(ptr, &RNA_PackedFile, imapf->packedfile);
471   }
472   else {
473     return PointerRNA_NULL;
474   }
475 }
476
477 static void rna_RenderSlot_clear(ID *id, RenderSlot *slot, ImageUser *iuser)
478 {
479   Image *image = (Image *)id;
480   int index = BLI_findindex(&image->renderslots, slot);
481   BKE_image_clear_renderslot(image, iuser, index);
482
483   WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, image);
484 }
485
486 static PointerRNA rna_render_slots_active_get(PointerRNA *ptr)
487 {
488   Image *image = (Image *)ptr->owner_id;
489   RenderSlot *render_slot = BKE_image_get_renderslot(image, image->render_slot);
490
491   return rna_pointer_inherit_refine(ptr, &RNA_RenderSlot, render_slot);
492 }
493
494 static void rna_render_slots_active_set(PointerRNA *ptr,
495                                         PointerRNA value,
496                                         struct ReportList *UNUSED(reports))
497 {
498   Image *image = (Image *)ptr->owner_id;
499   if (value.owner_id == &image->id) {
500     RenderSlot *slot = (RenderSlot *)value.data;
501     int index = BLI_findindex(&image->renderslots, slot);
502     if (index != -1) {
503       image->render_slot = index;
504     }
505   }
506 }
507
508 static int rna_render_slots_active_index_get(PointerRNA *ptr)
509 {
510   Image *image = (Image *)ptr->owner_id;
511   return image->render_slot;
512 }
513
514 static void rna_render_slots_active_index_set(PointerRNA *ptr, int value)
515 {
516   Image *image = (Image *)ptr->owner_id;
517   int num_slots = BLI_listbase_count(&image->renderslots);
518   image->render_slot = value;
519   CLAMP(image->render_slot, 0, num_slots - 1);
520 }
521
522 static void rna_render_slots_active_index_range(
523     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
524 {
525   Image *image = (Image *)ptr->owner_id;
526   *min = 0;
527   *max = max_ii(0, BLI_listbase_count(&image->renderslots) - 1);
528 }
529
530 #else
531
532 static void rna_def_imageuser(BlenderRNA *brna)
533 {
534   StructRNA *srna;
535   PropertyRNA *prop;
536
537   srna = RNA_def_struct(brna, "ImageUser", NULL);
538   RNA_def_struct_ui_text(
539       srna,
540       "Image User",
541       "Parameters defining how an Image data-block is used by another data-block");
542   RNA_def_struct_path_func(srna, "rna_ImageUser_path");
543
544   prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
545   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
546   RNA_def_property_ui_text(prop, "Auto Refresh", "Always refresh image on frame changes");
547   RNA_def_property_update(prop, 0, "rna_ImageUser_relations_update");
548   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
549
550   prop = RNA_def_property(srna, "frame_current", PROP_INT, PROP_TIME);
551   RNA_def_property_int_sdna(prop, NULL, "framenr");
552   RNA_def_property_range(prop, MINAFRAME, MAXFRAME);
553   RNA_def_property_ui_text(
554       prop, "Current Frame", "Current frame number in image sequence or movie");
555
556   /* animation */
557   prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
558   RNA_def_property_boolean_sdna(prop, NULL, "cycl", 0);
559   RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie");
560   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
561   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
562
563   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
564   RNA_def_property_int_sdna(prop, NULL, "frames");
565   RNA_def_property_range(prop, 0, MAXFRAMEF);
566   RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use");
567   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
568   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
569
570   prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
571   RNA_def_property_int_sdna(prop, NULL, "offset");
572   RNA_def_property_ui_text(
573       prop, "Offset", "Offset the number of the frame to use in the animation");
574   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
575
576   prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
577   RNA_def_property_int_sdna(prop, NULL, "sfra");
578   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
579   RNA_def_property_ui_text(
580       prop,
581       "Start Frame",
582       "Global starting frame of the movie/sequence, assuming first picture has a #1");
583   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
584   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
585
586   prop = RNA_def_property(srna, "multilayer_layer", PROP_INT, PROP_UNSIGNED);
587   RNA_def_property_int_sdna(prop, NULL, "layer");
588   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
589   RNA_def_property_ui_text(prop, "Layer", "Layer in multilayer image");
590
591   prop = RNA_def_property(srna, "multilayer_pass", PROP_INT, PROP_UNSIGNED);
592   RNA_def_property_int_sdna(prop, NULL, "pass");
593   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
594   RNA_def_property_ui_text(prop, "Pass", "Pass in multilayer image");
595
596   prop = RNA_def_property(srna, "multilayer_view", PROP_INT, PROP_UNSIGNED);
597   RNA_def_property_int_sdna(prop, NULL, "view");
598   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
599   RNA_def_property_ui_text(prop, "View", "View in multilayer image");
600 }
601
602 /* image.packed_files */
603 static void rna_def_image_packed_files(BlenderRNA *brna)
604 {
605   StructRNA *srna;
606   PropertyRNA *prop;
607
608   srna = RNA_def_struct(brna, "ImagePackedFile", NULL);
609   RNA_def_struct_sdna(srna, "ImagePackedFile");
610
611   prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
612   RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
613   RNA_def_property_ui_text(prop, "Packed File", "");
614   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
615
616   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
617   RNA_def_property_string_sdna(prop, NULL, "filepath");
618   RNA_def_struct_name_property(srna, prop);
619
620   RNA_api_image_packed_file(srna);
621 }
622
623 static void rna_def_render_slot(BlenderRNA *brna)
624 {
625   StructRNA *srna;
626   PropertyRNA *prop, *parm;
627   FunctionRNA *func;
628
629   srna = RNA_def_struct(brna, "RenderSlot", NULL);
630   RNA_def_struct_ui_text(srna, "Render Slot", "Parameters defining the render slot");
631
632   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
633   RNA_def_property_string_sdna(prop, NULL, "name");
634   RNA_def_property_ui_text(prop, "Name", "Render slot name");
635   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
636
637   func = RNA_def_function(srna, "clear", "rna_RenderSlot_clear");
638   RNA_def_function_flag(func, FUNC_USE_SELF_ID);
639   RNA_def_function_ui_description(func, "Clear the render slot");
640   parm = RNA_def_pointer(func, "iuser", "ImageUser", "ImageUser", "");
641   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
642 }
643
644 static void rna_def_render_slots(BlenderRNA *brna, PropertyRNA *cprop)
645 {
646   StructRNA *srna;
647   FunctionRNA *func;
648   PropertyRNA *prop, *parm;
649
650   RNA_def_property_srna(cprop, "RenderSlots");
651   srna = RNA_def_struct(brna, "RenderSlots", NULL);
652   RNA_def_struct_sdna(srna, "Image");
653   RNA_def_struct_ui_text(srna, "Render Layers", "Collection of render layers");
654
655   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
656   RNA_def_property_int_sdna(prop, NULL, "render_slot");
657   RNA_def_property_int_funcs(prop,
658                              "rna_render_slots_active_index_get",
659                              "rna_render_slots_active_index_set",
660                              "rna_render_slots_active_index_range");
661   RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
662   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
663
664   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
665   RNA_def_property_struct_type(prop, "RenderSlot");
666   RNA_def_property_pointer_funcs(
667       prop, "rna_render_slots_active_get", "rna_render_slots_active_set", NULL, NULL);
668   RNA_def_property_flag(prop, PROP_EDITABLE);
669   RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
670   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
671
672   func = RNA_def_function(srna, "new", "BKE_image_add_renderslot");
673   RNA_def_function_ui_description(func, "Add a render slot to the image");
674   parm = RNA_def_string(func, "name", NULL, 0, "Name", "New name for the render slot");
675   parm = RNA_def_pointer(func, "result", "RenderSlot", "", "Newly created render layer");
676   RNA_def_function_return(func, parm);
677 }
678
679 static void rna_def_image(BlenderRNA *brna)
680 {
681   StructRNA *srna;
682   PropertyRNA *prop;
683   static const EnumPropertyItem prop_type_items[] = {
684       {IMA_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
685       {IMA_TYPE_MULTILAYER, "MULTILAYER", 0, "Multilayer", ""},
686       {IMA_TYPE_UV_TEST, "UV_TEST", 0, "UV Test", ""},
687       {IMA_TYPE_R_RESULT, "RENDER_RESULT", 0, "Render Result", ""},
688       {IMA_TYPE_COMPOSITE, "COMPOSITING", 0, "Compositing", ""},
689       {0, NULL, 0, NULL, NULL},
690   };
691   static const EnumPropertyItem alpha_mode_items[] = {
692       {IMA_ALPHA_STRAIGHT,
693        "STRAIGHT",
694        0,
695        "Straight",
696        "Store RGB and alpha channels separately with alpha acting as a mask, also known as "
697        "unassociated alpha. Commonly used by image editing applications and file formats like "
698        "PNG"},
699       {IMA_ALPHA_PREMUL,
700        "PREMUL",
701        0,
702        "Premultiplied",
703        "Store RGB channels with alpha multiplied in, also known as associated alpha. The natural "
704        "format for renders and used by file formats like OpenEXR"},
705       {IMA_ALPHA_CHANNEL_PACKED,
706        "CHANNEL_PACKED",
707        0,
708        "Channel Packed",
709        "Different images are packed in the RGB and alpha channels, and they should not "
710        "affect each other. Channel packing is commonly used by game engines to save memory"},
711       {IMA_ALPHA_IGNORE,
712        "NONE",
713        0,
714        "None",
715        "Ignore alpha channel from the file and make image fully opaque"},
716       {0, NULL, 0, NULL, NULL},
717   };
718
719   srna = RNA_def_struct(brna, "Image", "ID");
720   RNA_def_struct_ui_text(
721       srna, "Image", "Image data-block referencing an external or packed image");
722   RNA_def_struct_ui_icon(srna, ICON_IMAGE_DATA);
723
724   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
725   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
726   RNA_def_property_string_sdna(prop, NULL, "name");
727   RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name");
728   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
729
730   /* eek. this is horrible but needed so we can save to a new name without blanking the data :( */
731   prop = RNA_def_property(srna, "filepath_raw", PROP_STRING, PROP_FILEPATH);
732   RNA_def_property_string_sdna(prop, NULL, "name");
733   RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name (without data refreshing)");
734
735   prop = RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
736   RNA_def_property_enum_items(prop, rna_enum_image_type_items);
737   RNA_def_property_enum_funcs(
738       prop, "rna_Image_file_format_get", "rna_Image_file_format_set", NULL);
739   RNA_def_property_ui_text(prop, "File Format", "Format used for re-saving this file");
740
741   prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
742   RNA_def_property_enum_items(prop, image_source_items);
743   RNA_def_property_enum_funcs(prop, NULL, "rna_Image_source_set", "rna_Image_source_itemf");
744   RNA_def_property_ui_text(prop, "Source", "Where the image comes from");
745   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
746
747   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
748   RNA_def_property_enum_items(prop, prop_type_items);
749   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
750   RNA_def_property_ui_text(prop, "Type", "How to generate the image");
751   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
752
753   prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
754   RNA_def_property_struct_type(prop, "PackedFile");
755   RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
756   RNA_def_property_pointer_funcs(prop, "rna_Image_packed_file_get", NULL, NULL, NULL);
757   RNA_def_property_ui_text(prop, "Packed File", "First packed file of the image");
758
759   prop = RNA_def_property(srna, "packed_files", PROP_COLLECTION, PROP_NONE);
760   RNA_def_property_collection_sdna(prop, NULL, "packedfiles", NULL);
761   RNA_def_property_struct_type(prop, "ImagePackedFile");
762   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
763   RNA_def_property_ui_text(prop, "Packed Files", "Collection of packed images");
764
765   prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
766   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
767   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_VIEW_AS_RENDER);
768   RNA_def_property_ui_text(
769       prop,
770       "View as Render",
771       "Apply render part of display transformation when displaying this image on the screen");
772   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
773
774   prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
775   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
776   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_DEINTERLACE);
777   RNA_def_property_ui_text(prop, "Deinterlace", "Deinterlace movie file on load");
778   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
779
780   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
781   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
782   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_USE_VIEWS);
783   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
784   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
785
786   prop = RNA_def_property(srna, "is_stereo_3d", PROP_BOOLEAN, PROP_NONE);
787   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
788   RNA_def_property_boolean_funcs(prop, "rna_Image_is_stereo_3d_get", NULL);
789   RNA_def_property_ui_text(prop, "Stereo 3D", "Image has left and right views");
790   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
791
792   prop = RNA_def_property(srna, "is_multiview", PROP_BOOLEAN, PROP_NONE);
793   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
794   RNA_def_property_boolean_funcs(prop, "rna_Image_is_multiview_get", NULL);
795   RNA_def_property_ui_text(prop, "Multiple Views", "Image has more than one view");
796   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
797
798   prop = RNA_def_property(srna, "is_dirty", PROP_BOOLEAN, PROP_NONE);
799   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
800   RNA_def_property_boolean_funcs(prop, "rna_Image_dirty_get", NULL);
801   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
802   RNA_def_property_ui_text(prop, "Dirty", "Image has changed and is not saved");
803
804   /* generated image (image_generated_change_cb) */
805   prop = RNA_def_property(srna, "generated_type", PROP_ENUM, PROP_NONE);
806   RNA_def_property_enum_sdna(prop, NULL, "gen_type");
807   RNA_def_property_enum_items(prop, rna_enum_image_generated_type_items);
808   RNA_def_property_ui_text(prop, "Generated Type", "Generated image type");
809   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
810   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
811
812   prop = RNA_def_property(srna, "generated_width", PROP_INT, PROP_NONE);
813   RNA_def_property_int_sdna(prop, NULL, "gen_x");
814   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
815   RNA_def_property_range(prop, 1, 65536);
816   RNA_def_property_ui_text(prop, "Generated Width", "Generated image width");
817   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
818   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
819
820   prop = RNA_def_property(srna, "generated_height", PROP_INT, PROP_NONE);
821   RNA_def_property_int_sdna(prop, NULL, "gen_y");
822   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
823   RNA_def_property_range(prop, 1, 65536);
824   RNA_def_property_ui_text(prop, "Generated Height", "Generated image height");
825   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
826   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
827
828   prop = RNA_def_property(srna, "use_generated_float", PROP_BOOLEAN, PROP_NONE);
829   RNA_def_property_boolean_sdna(prop, NULL, "gen_flag", IMA_GEN_FLOAT);
830   RNA_def_property_ui_text(prop, "Float Buffer", "Generate floating point buffer");
831   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
832   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
833
834   prop = RNA_def_property(srna, "generated_color", PROP_FLOAT, PROP_COLOR_GAMMA);
835   RNA_def_property_float_sdna(prop, NULL, "gen_color");
836   RNA_def_property_array(prop, 4);
837   RNA_def_property_ui_text(prop, "Color", "Fill color for the generated image");
838   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
839   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
840
841   prop = RNA_def_property(srna, "display_aspect", PROP_FLOAT, PROP_XYZ);
842   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
843   RNA_def_property_float_sdna(prop, NULL, "aspx");
844   RNA_def_property_array(prop, 2);
845   RNA_def_property_range(prop, 0.1f, FLT_MAX);
846   RNA_def_property_ui_range(prop, 0.1f, 5000.f, 1, 2);
847   RNA_def_property_ui_text(
848       prop, "Display Aspect", "Display Aspect for this image, does not affect rendering");
849   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
850
851   prop = RNA_def_property(srna, "bindcode", PROP_INT, PROP_UNSIGNED);
852   RNA_def_property_int_funcs(prop, "rna_Image_bindcode_get", NULL, NULL);
853   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
854   RNA_def_property_ui_text(prop, "Bindcode", "OpenGL bindcode");
855   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
856
857   prop = RNA_def_property(srna, "render_slots", PROP_COLLECTION, PROP_NONE);
858   RNA_def_property_struct_type(prop, "RenderSlot");
859   RNA_def_property_collection_sdna(prop, NULL, "renderslots", NULL);
860   RNA_def_property_ui_text(prop, "Render Slots", "Render slots of the image");
861   rna_def_render_slots(brna, prop);
862
863   /*
864    * Image.has_data and Image.depth are temporary,
865    * Update import_obj.py when they are replaced (Arystan)
866    */
867   prop = RNA_def_property(srna, "has_data", PROP_BOOLEAN, PROP_NONE);
868   RNA_def_property_boolean_funcs(prop, "rna_Image_has_data_get", NULL);
869   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
870   RNA_def_property_ui_text(prop, "Has Data", "True if the image data is loaded into memory");
871
872   prop = RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
873   RNA_def_property_int_funcs(prop, "rna_Image_depth_get", NULL, NULL);
874   RNA_def_property_ui_text(prop, "Depth", "Image bit depth");
875   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
876
877   prop = RNA_def_int_vector(srna,
878                             "size",
879                             2,
880                             NULL,
881                             0,
882                             0,
883                             "Size",
884                             "Width and height in pixels, zero when image data cant be loaded",
885                             0,
886                             0);
887   RNA_def_property_subtype(prop, PROP_PIXEL);
888   RNA_def_property_int_funcs(prop, "rna_Image_size_get", NULL, NULL);
889   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
890
891   prop = RNA_def_float_vector(
892       srna, "resolution", 2, NULL, 0, 0, "Resolution", "X/Y pixels per meter", 0, 0);
893   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
894   RNA_def_property_float_funcs(prop, "rna_Image_resolution_get", "rna_Image_resolution_set", NULL);
895
896   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_UNSIGNED);
897   RNA_def_property_int_funcs(prop, "rna_Image_frame_duration_get", NULL, NULL);
898   RNA_def_property_ui_text(
899       prop, "Duration", "Duration (in frames) of the image (1 when not a video/sequence)");
900   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
901
902   /* NOTE about pixels/channels/is_floa:
903    * this properties describes how image is stored internally (inside of ImBuf),
904    * not how it was saved to disk or how it'll be saved on disk
905    */
906   prop = RNA_def_property(srna, "pixels", PROP_FLOAT, PROP_NONE);
907   RNA_def_property_flag(prop, PROP_DYNAMIC);
908   RNA_def_property_multi_array(prop, 1, NULL);
909   RNA_def_property_ui_text(prop, "Pixels", "Image pixels in floating point values");
910   RNA_def_property_dynamic_array_funcs(prop, "rna_Image_pixels_get_length");
911   RNA_def_property_float_funcs(prop, "rna_Image_pixels_get", "rna_Image_pixels_set", NULL);
912
913   prop = RNA_def_property(srna, "channels", PROP_INT, PROP_UNSIGNED);
914   RNA_def_property_int_funcs(prop, "rna_Image_channels_get", NULL, NULL);
915   RNA_def_property_ui_text(prop, "Channels", "Number of channels in pixels buffer");
916   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
917
918   prop = RNA_def_property(srna, "is_float", PROP_BOOLEAN, PROP_NONE);
919   RNA_def_property_boolean_funcs(prop, "rna_Image_is_float_get", NULL);
920   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
921   RNA_def_property_ui_text(prop, "Is Float", "True if this image is stored in float buffer");
922
923   prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
924   RNA_def_property_pointer_sdna(prop, NULL, "colorspace_settings");
925   RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
926   RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
927
928   prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
929   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
930   RNA_def_property_enum_items(prop, alpha_mode_items);
931   RNA_def_property_ui_text(prop,
932                            "Alpha Mode",
933                            "Representation of alpha in the image file, to convert to and from "
934                            "when saving and loading the image");
935   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_colormanage_update");
936
937   /* multiview */
938   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
939   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
940   RNA_def_property_enum_sdna(prop, NULL, "views_format");
941   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
942   RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
943   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
944
945   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
946   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
947   RNA_def_property_flag(prop, PROP_NEVER_NULL);
948   RNA_def_property_struct_type(prop, "Stereo3dFormat");
949   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
950
951   RNA_api_image(srna);
952 }
953
954 void RNA_def_image(BlenderRNA *brna)
955 {
956   rna_def_render_slot(brna);
957   rna_def_image(brna);
958   rna_def_imageuser(brna);
959   rna_def_image_packed_files(brna);
960 }
961
962 #endif