c033e393625e451baf48fe279b5d179a4e72d1a8
[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 = ptr->id.data;
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 = ptr->id.data;
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 = ptr->id.data;
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 = ptr->id.data;
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 = ptr->id.data;
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->id.data;
152
153   BKE_image_user_frame_calc(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->id.data) {
177     /* ImageUser *iuser = ptr->data; */
178
179     switch (GS(((ID *)ptr->id.data)->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   else if (ibuf->rect_float)
320     planes = ibuf->planes * 4;
321   else
322     planes = ibuf->planes;
323
324   BKE_image_release_ibuf(im, ibuf, lock);
325
326   return planes;
327 }
328
329 static int rna_Image_frame_duration_get(PointerRNA *ptr)
330 {
331   Image *ima = ptr->id.data;
332   int duration = 1;
333
334   if (BKE_image_has_anim(ima)) {
335     duration = IMB_anim_get_duration(((ImageAnim *)ima->anims.first)->anim, IMB_TC_RECORD_RUN);
336   }
337   else {
338     /* acquire ensures ima->anim is set, if possible! */
339     void *lock;
340     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
341     BKE_image_release_ibuf(ima, ibuf, lock);
342   }
343
344   return duration;
345 }
346
347 static int rna_Image_pixels_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
348 {
349   Image *ima = ptr->id.data;
350   ImBuf *ibuf;
351   void *lock;
352
353   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
354
355   if (ibuf)
356     length[0] = ibuf->x * ibuf->y * ibuf->channels;
357   else
358     length[0] = 0;
359
360   BKE_image_release_ibuf(ima, ibuf, lock);
361
362   return length[0];
363 }
364
365 static void rna_Image_pixels_get(PointerRNA *ptr, float *values)
366 {
367   Image *ima = ptr->id.data;
368   ImBuf *ibuf;
369   void *lock;
370   int i, size;
371
372   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
373
374   if (ibuf) {
375     size = ibuf->x * ibuf->y * ibuf->channels;
376
377     if (ibuf->rect_float) {
378       memcpy(values, ibuf->rect_float, sizeof(float) * size);
379     }
380     else {
381       for (i = 0; i < size; i++)
382         values[i] = ((unsigned char *)ibuf->rect)[i] * (1.0f / 255.0f);
383     }
384   }
385
386   BKE_image_release_ibuf(ima, ibuf, lock);
387 }
388
389 static void rna_Image_pixels_set(PointerRNA *ptr, const float *values)
390 {
391   Image *ima = ptr->id.data;
392   ImBuf *ibuf;
393   void *lock;
394   int i, size;
395
396   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
397
398   if (ibuf) {
399     size = ibuf->x * ibuf->y * ibuf->channels;
400
401     if (ibuf->rect_float) {
402       memcpy(ibuf->rect_float, values, sizeof(float) * size);
403     }
404     else {
405       for (i = 0; i < size; i++)
406         ((unsigned char *)ibuf->rect)[i] = unit_float_to_uchar_clamp(values[i]);
407     }
408
409     ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID | IB_MIPMAP_INVALID;
410     BKE_image_mark_dirty(ima, ibuf);
411     if (!G.background) {
412       GPU_free_image(ima);
413     }
414     WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
415   }
416
417   BKE_image_release_ibuf(ima, ibuf, lock);
418 }
419
420 static int rna_Image_channels_get(PointerRNA *ptr)
421 {
422   Image *im = (Image *)ptr->data;
423   ImBuf *ibuf;
424   void *lock;
425   int channels = 0;
426
427   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
428   if (ibuf)
429     channels = ibuf->channels;
430
431   BKE_image_release_ibuf(im, ibuf, lock);
432
433   return channels;
434 }
435
436 static bool rna_Image_is_float_get(PointerRNA *ptr)
437 {
438   Image *im = (Image *)ptr->data;
439   ImBuf *ibuf;
440   void *lock;
441   bool is_float = false;
442
443   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
444   if (ibuf)
445     is_float = ibuf->rect_float != NULL;
446
447   BKE_image_release_ibuf(im, ibuf, lock);
448
449   return is_float;
450 }
451
452 static PointerRNA rna_Image_packed_file_get(PointerRNA *ptr)
453 {
454   Image *ima = (Image *)ptr->id.data;
455
456   if (BKE_image_has_packedfile(ima)) {
457     ImagePackedFile *imapf = ima->packedfiles.first;
458     return rna_pointer_inherit_refine(ptr, &RNA_PackedFile, imapf->packedfile);
459   }
460   else {
461     return PointerRNA_NULL;
462   }
463 }
464
465 static void rna_RenderSlot_clear(ID *id, RenderSlot *slot, ImageUser *iuser)
466 {
467   Image *image = (Image *)id;
468   int index = BLI_findindex(&image->renderslots, slot);
469   BKE_image_clear_renderslot(image, iuser, index);
470
471   WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, image);
472 }
473
474 static PointerRNA rna_render_slots_active_get(PointerRNA *ptr)
475 {
476   Image *image = (Image *)ptr->id.data;
477   RenderSlot *render_slot = BKE_image_get_renderslot(image, image->render_slot);
478
479   return rna_pointer_inherit_refine(ptr, &RNA_RenderSlot, render_slot);
480 }
481
482 static void rna_render_slots_active_set(struct ReportList *UNUSED(reports),
483                                         PointerRNA *ptr,
484                                         PointerRNA value)
485 {
486   Image *image = (Image *)ptr->id.data;
487   if (value.id.data == image) {
488     RenderSlot *slot = (RenderSlot *)value.data;
489     int index = BLI_findindex(&image->renderslots, slot);
490     if (index != -1)
491       image->render_slot = index;
492   }
493 }
494
495 static int rna_render_slots_active_index_get(PointerRNA *ptr)
496 {
497   Image *image = (Image *)ptr->id.data;
498   return image->render_slot;
499 }
500
501 static void rna_render_slots_active_index_set(PointerRNA *ptr, int value)
502 {
503   Image *image = (Image *)ptr->id.data;
504   int num_slots = BLI_listbase_count(&image->renderslots);
505   image->render_slot = value;
506   CLAMP(image->render_slot, 0, num_slots - 1);
507 }
508
509 static void rna_render_slots_active_index_range(
510     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
511 {
512   Image *image = (Image *)ptr->id.data;
513   *min = 0;
514   *max = max_ii(0, BLI_listbase_count(&image->renderslots) - 1);
515 }
516
517 #else
518
519 static void rna_def_imageuser(BlenderRNA *brna)
520 {
521   StructRNA *srna;
522   PropertyRNA *prop;
523
524   srna = RNA_def_struct(brna, "ImageUser", NULL);
525   RNA_def_struct_ui_text(
526       srna,
527       "Image User",
528       "Parameters defining how an Image data-block is used by another data-block");
529   RNA_def_struct_path_func(srna, "rna_ImageUser_path");
530
531   prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
532   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
533   RNA_def_property_ui_text(prop, "Auto Refresh", "Always refresh image on frame changes");
534   RNA_def_property_update(prop, 0, "rna_ImageUser_relations_update");
535   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
536
537   prop = RNA_def_property(srna, "frame_current", PROP_INT, PROP_TIME);
538   RNA_def_property_int_sdna(prop, NULL, "framenr");
539   RNA_def_property_range(prop, MINAFRAME, MAXFRAME);
540   RNA_def_property_ui_text(
541       prop, "Current Frame", "Current frame number in image sequence or movie");
542
543   /* animation */
544   prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
545   RNA_def_property_boolean_sdna(prop, NULL, "cycl", 0);
546   RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie");
547   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
548   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
549
550   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
551   RNA_def_property_int_sdna(prop, NULL, "frames");
552   RNA_def_property_range(prop, 0, MAXFRAMEF);
553   RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use");
554   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
555   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
556
557   prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
558   RNA_def_property_int_sdna(prop, NULL, "offset");
559   RNA_def_property_ui_text(
560       prop, "Offset", "Offset the number of the frame to use in the animation");
561   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
562
563   prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
564   RNA_def_property_int_sdna(prop, NULL, "sfra");
565   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
566   RNA_def_property_ui_text(
567       prop,
568       "Start Frame",
569       "Global starting frame of the movie/sequence, assuming first picture has a #1");
570   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
571   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
572
573   prop = RNA_def_property(srna, "multilayer_layer", PROP_INT, PROP_UNSIGNED);
574   RNA_def_property_int_sdna(prop, NULL, "layer");
575   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
576   RNA_def_property_ui_text(prop, "Layer", "Layer in multilayer image");
577
578   prop = RNA_def_property(srna, "multilayer_pass", PROP_INT, PROP_UNSIGNED);
579   RNA_def_property_int_sdna(prop, NULL, "pass");
580   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
581   RNA_def_property_ui_text(prop, "Pass", "Pass in multilayer image");
582
583   prop = RNA_def_property(srna, "multilayer_view", PROP_INT, PROP_UNSIGNED);
584   RNA_def_property_int_sdna(prop, NULL, "view");
585   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
586   RNA_def_property_ui_text(prop, "View", "View in multilayer image");
587 }
588
589 /* image.packed_files */
590 static void rna_def_image_packed_files(BlenderRNA *brna)
591 {
592   StructRNA *srna;
593   PropertyRNA *prop;
594
595   srna = RNA_def_struct(brna, "ImagePackedFile", NULL);
596   RNA_def_struct_sdna(srna, "ImagePackedFile");
597
598   prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
599   RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
600   RNA_def_property_ui_text(prop, "Packed File", "");
601   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
602
603   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
604   RNA_def_property_string_sdna(prop, NULL, "filepath");
605   RNA_def_struct_name_property(srna, prop);
606
607   RNA_api_image_packed_file(srna);
608 }
609
610 static void rna_def_render_slot(BlenderRNA *brna)
611 {
612   StructRNA *srna;
613   PropertyRNA *prop, *parm;
614   FunctionRNA *func;
615
616   srna = RNA_def_struct(brna, "RenderSlot", NULL);
617   RNA_def_struct_ui_text(srna, "Render Slot", "Parameters defining the render slot");
618
619   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
620   RNA_def_property_string_sdna(prop, NULL, "name");
621   RNA_def_property_ui_text(prop, "Name", "Render slot name");
622   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
623
624   func = RNA_def_function(srna, "clear", "rna_RenderSlot_clear");
625   RNA_def_function_flag(func, FUNC_USE_SELF_ID);
626   RNA_def_function_ui_description(func, "Clear the render slot");
627   parm = RNA_def_pointer(func, "iuser", "ImageUser", "ImageUser", "");
628   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
629 }
630
631 static void rna_def_render_slots(BlenderRNA *brna, PropertyRNA *cprop)
632 {
633   StructRNA *srna;
634   FunctionRNA *func;
635   PropertyRNA *prop, *parm;
636
637   RNA_def_property_srna(cprop, "RenderSlots");
638   srna = RNA_def_struct(brna, "RenderSlots", NULL);
639   RNA_def_struct_sdna(srna, "Image");
640   RNA_def_struct_ui_text(srna, "Render Layers", "Collection of render layers");
641
642   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
643   RNA_def_property_int_sdna(prop, NULL, "render_slot");
644   RNA_def_property_int_funcs(prop,
645                              "rna_render_slots_active_index_get",
646                              "rna_render_slots_active_index_set",
647                              "rna_render_slots_active_index_range");
648   RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
649   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
650
651   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
652   RNA_def_property_struct_type(prop, "RenderSlot");
653   RNA_def_property_pointer_funcs(
654       prop, "rna_render_slots_active_get", "rna_render_slots_active_set", NULL, NULL);
655   RNA_def_property_flag(prop, PROP_EDITABLE);
656   RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
657   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
658
659   func = RNA_def_function(srna, "new", "BKE_image_add_renderslot");
660   RNA_def_function_ui_description(func, "Add a render slot to the image");
661   parm = RNA_def_string(func, "name", NULL, 0, "Name", "New name for the render slot");
662   parm = RNA_def_pointer(func, "result", "RenderSlot", "", "Newly created render layer");
663   RNA_def_function_return(func, parm);
664 }
665
666 static void rna_def_image(BlenderRNA *brna)
667 {
668   StructRNA *srna;
669   PropertyRNA *prop;
670   static const EnumPropertyItem prop_type_items[] = {
671       {IMA_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
672       {IMA_TYPE_MULTILAYER, "MULTILAYER", 0, "Multilayer", ""},
673       {IMA_TYPE_UV_TEST, "UV_TEST", 0, "UV Test", ""},
674       {IMA_TYPE_R_RESULT, "RENDER_RESULT", 0, "Render Result", ""},
675       {IMA_TYPE_COMPOSITE, "COMPOSITING", 0, "Compositing", ""},
676       {0, NULL, 0, NULL, NULL},
677   };
678   static const EnumPropertyItem alpha_mode_items[] = {
679       {IMA_ALPHA_STRAIGHT,
680        "STRAIGHT",
681        0,
682        "Straight",
683        "Store RGB and alpha channels separately with alpha acting as a mask, also known as "
684        "unassociated alpha. Commonly used by image editing applications and file formats like "
685        "PNG"},
686       {IMA_ALPHA_PREMUL,
687        "PREMUL",
688        0,
689        "Premultiplied",
690        "Store RGB channels with alpha multipled in, also known as associated alpha. The natural "
691        "format for renders and used by file formats like OpenEXR"},
692       {IMA_ALPHA_CHANNEL_PACKED,
693        "CHANNEL_PACKED",
694        0,
695        "Channel Packed",
696        "Different images are packed in the RGB and alpha channels, and they should not "
697        "affect each other. Channel packing is commonly used by game engines to save memory"},
698       {IMA_ALPHA_IGNORE,
699        "NONE",
700        0,
701        "None",
702        "Ignore alpha channel from the file and make image fully opaque"},
703       {0, NULL, 0, NULL, NULL},
704   };
705
706   srna = RNA_def_struct(brna, "Image", "ID");
707   RNA_def_struct_ui_text(
708       srna, "Image", "Image data-block referencing an external or packed image");
709   RNA_def_struct_ui_icon(srna, ICON_IMAGE_DATA);
710
711   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
712   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
713   RNA_def_property_string_sdna(prop, NULL, "name");
714   RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name");
715   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
716
717   /* eek. this is horrible but needed so we can save to a new name without blanking the data :( */
718   prop = RNA_def_property(srna, "filepath_raw", PROP_STRING, PROP_FILEPATH);
719   RNA_def_property_string_sdna(prop, NULL, "name");
720   RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name (without data refreshing)");
721
722   prop = RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
723   RNA_def_property_enum_items(prop, rna_enum_image_type_items);
724   RNA_def_property_enum_funcs(
725       prop, "rna_Image_file_format_get", "rna_Image_file_format_set", NULL);
726   RNA_def_property_ui_text(prop, "File Format", "Format used for re-saving this file");
727
728   prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
729   RNA_def_property_enum_items(prop, image_source_items);
730   RNA_def_property_enum_funcs(prop, NULL, "rna_Image_source_set", "rna_Image_source_itemf");
731   RNA_def_property_ui_text(prop, "Source", "Where the image comes from");
732   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
733
734   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
735   RNA_def_property_enum_items(prop, prop_type_items);
736   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
737   RNA_def_property_ui_text(prop, "Type", "How to generate the image");
738   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
739
740   prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
741   RNA_def_property_struct_type(prop, "PackedFile");
742   RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
743   RNA_def_property_pointer_funcs(prop, "rna_Image_packed_file_get", NULL, NULL, NULL);
744   RNA_def_property_ui_text(prop, "Packed File", "First packed file of the image");
745
746   prop = RNA_def_property(srna, "packed_files", PROP_COLLECTION, PROP_NONE);
747   RNA_def_property_collection_sdna(prop, NULL, "packedfiles", NULL);
748   RNA_def_property_struct_type(prop, "ImagePackedFile");
749   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
750   RNA_def_property_ui_text(prop, "Packed Files", "Collection of packed images");
751
752   prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
753   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
754   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_VIEW_AS_RENDER);
755   RNA_def_property_ui_text(
756       prop,
757       "View as Render",
758       "Apply render part of display transformation when displaying this image on the screen");
759   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
760
761   prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
762   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
763   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_DEINTERLACE);
764   RNA_def_property_ui_text(prop, "Deinterlace", "Deinterlace movie file on load");
765   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
766
767   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
768   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
769   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_USE_VIEWS);
770   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
771   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
772
773   prop = RNA_def_property(srna, "is_stereo_3d", PROP_BOOLEAN, PROP_NONE);
774   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
775   RNA_def_property_boolean_funcs(prop, "rna_Image_is_stereo_3d_get", NULL);
776   RNA_def_property_ui_text(prop, "Stereo 3D", "Image has left and right views");
777   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
778
779   prop = RNA_def_property(srna, "is_multiview", PROP_BOOLEAN, PROP_NONE);
780   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
781   RNA_def_property_boolean_funcs(prop, "rna_Image_is_multiview_get", NULL);
782   RNA_def_property_ui_text(prop, "Multiple Views", "Image has more than one view");
783   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
784
785   prop = RNA_def_property(srna, "is_dirty", PROP_BOOLEAN, PROP_NONE);
786   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
787   RNA_def_property_boolean_funcs(prop, "rna_Image_dirty_get", NULL);
788   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
789   RNA_def_property_ui_text(prop, "Dirty", "Image has changed and is not saved");
790
791   /* generated image (image_generated_change_cb) */
792   prop = RNA_def_property(srna, "generated_type", PROP_ENUM, PROP_NONE);
793   RNA_def_property_enum_sdna(prop, NULL, "gen_type");
794   RNA_def_property_enum_items(prop, rna_enum_image_generated_type_items);
795   RNA_def_property_ui_text(prop, "Generated Type", "Generated image type");
796   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
797   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
798
799   prop = RNA_def_property(srna, "generated_width", PROP_INT, PROP_NONE);
800   RNA_def_property_int_sdna(prop, NULL, "gen_x");
801   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
802   RNA_def_property_range(prop, 1, 65536);
803   RNA_def_property_ui_text(prop, "Generated Width", "Generated image width");
804   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
805   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
806
807   prop = RNA_def_property(srna, "generated_height", PROP_INT, PROP_NONE);
808   RNA_def_property_int_sdna(prop, NULL, "gen_y");
809   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
810   RNA_def_property_range(prop, 1, 65536);
811   RNA_def_property_ui_text(prop, "Generated Height", "Generated image height");
812   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
813   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
814
815   prop = RNA_def_property(srna, "use_generated_float", PROP_BOOLEAN, PROP_NONE);
816   RNA_def_property_boolean_sdna(prop, NULL, "gen_flag", IMA_GEN_FLOAT);
817   RNA_def_property_ui_text(prop, "Float Buffer", "Generate floating point buffer");
818   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
819   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
820
821   prop = RNA_def_property(srna, "generated_color", PROP_FLOAT, PROP_COLOR_GAMMA);
822   RNA_def_property_float_sdna(prop, NULL, "gen_color");
823   RNA_def_property_array(prop, 4);
824   RNA_def_property_ui_text(prop, "Color", "Fill color for the generated image");
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, "display_aspect", PROP_FLOAT, PROP_XYZ);
829   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
830   RNA_def_property_float_sdna(prop, NULL, "aspx");
831   RNA_def_property_array(prop, 2);
832   RNA_def_property_range(prop, 0.1f, FLT_MAX);
833   RNA_def_property_ui_range(prop, 0.1f, 5000.f, 1, 2);
834   RNA_def_property_ui_text(
835       prop, "Display Aspect", "Display Aspect for this image, does not affect rendering");
836   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
837
838   prop = RNA_def_property(srna, "bindcode", PROP_INT, PROP_UNSIGNED);
839   RNA_def_property_int_funcs(prop, "rna_Image_bindcode_get", NULL, NULL);
840   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
841   RNA_def_property_ui_text(prop, "Bindcode", "OpenGL bindcode");
842   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
843
844   prop = RNA_def_property(srna, "render_slots", PROP_COLLECTION, PROP_NONE);
845   RNA_def_property_struct_type(prop, "RenderSlot");
846   RNA_def_property_collection_sdna(prop, NULL, "renderslots", NULL);
847   RNA_def_property_ui_text(prop, "Render Slots", "Render slots of the image");
848   rna_def_render_slots(brna, prop);
849
850   /*
851    * Image.has_data and Image.depth are temporary,
852    * Update import_obj.py when they are replaced (Arystan)
853    */
854   prop = RNA_def_property(srna, "has_data", PROP_BOOLEAN, PROP_NONE);
855   RNA_def_property_boolean_funcs(prop, "rna_Image_has_data_get", NULL);
856   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
857   RNA_def_property_ui_text(prop, "Has Data", "True if the image data is loaded into memory");
858
859   prop = RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
860   RNA_def_property_int_funcs(prop, "rna_Image_depth_get", NULL, NULL);
861   RNA_def_property_ui_text(prop, "Depth", "Image bit depth");
862   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
863
864   prop = RNA_def_int_vector(srna,
865                             "size",
866                             2,
867                             NULL,
868                             0,
869                             0,
870                             "Size",
871                             "Width and height in pixels, zero when image data cant be loaded",
872                             0,
873                             0);
874   RNA_def_property_subtype(prop, PROP_PIXEL);
875   RNA_def_property_int_funcs(prop, "rna_Image_size_get", NULL, NULL);
876   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
877
878   prop = RNA_def_float_vector(
879       srna, "resolution", 2, NULL, 0, 0, "Resolution", "X/Y pixels per meter", 0, 0);
880   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
881   RNA_def_property_float_funcs(prop, "rna_Image_resolution_get", "rna_Image_resolution_set", NULL);
882
883   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_UNSIGNED);
884   RNA_def_property_int_funcs(prop, "rna_Image_frame_duration_get", NULL, NULL);
885   RNA_def_property_ui_text(
886       prop, "Duration", "Duration (in frames) of the image (1 when not a video/sequence)");
887   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
888
889   /* NOTE about pixels/channels/is_floa:
890    * this properties describes how image is stored internally (inside of ImBuf),
891    * not how it was saved to disk or how it'll be saved on disk
892    */
893   prop = RNA_def_property(srna, "pixels", PROP_FLOAT, PROP_NONE);
894   RNA_def_property_flag(prop, PROP_DYNAMIC);
895   RNA_def_property_multi_array(prop, 1, NULL);
896   RNA_def_property_ui_text(prop, "Pixels", "Image pixels in floating point values");
897   RNA_def_property_dynamic_array_funcs(prop, "rna_Image_pixels_get_length");
898   RNA_def_property_float_funcs(prop, "rna_Image_pixels_get", "rna_Image_pixels_set", NULL);
899
900   prop = RNA_def_property(srna, "channels", PROP_INT, PROP_UNSIGNED);
901   RNA_def_property_int_funcs(prop, "rna_Image_channels_get", NULL, NULL);
902   RNA_def_property_ui_text(prop, "Channels", "Number of channels in pixels buffer");
903   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
904
905   prop = RNA_def_property(srna, "is_float", PROP_BOOLEAN, PROP_NONE);
906   RNA_def_property_boolean_funcs(prop, "rna_Image_is_float_get", NULL);
907   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
908   RNA_def_property_ui_text(prop, "Is Float", "True if this image is stored in float buffer");
909
910   prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
911   RNA_def_property_pointer_sdna(prop, NULL, "colorspace_settings");
912   RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
913   RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
914
915   prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
916   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
917   RNA_def_property_enum_items(prop, alpha_mode_items);
918   RNA_def_property_ui_text(
919       prop, "Alpha Mode", "Representation of alpha information in the RGBA pixels");
920   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_colormanage_update");
921
922   /* multiview */
923   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
924   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_STATIC);
925   RNA_def_property_enum_sdna(prop, NULL, "views_format");
926   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
927   RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
928   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
929
930   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
931   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
932   RNA_def_property_flag(prop, PROP_NEVER_NULL);
933   RNA_def_property_struct_type(prop, "Stereo3dFormat");
934   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
935
936   RNA_api_image(srna);
937 }
938
939 void RNA_def_image(BlenderRNA *brna)
940 {
941   rna_def_render_slot(brna);
942   rna_def_image(brna);
943   rna_def_imageuser(brna);
944   rna_def_image_packed_files(brna);
945 }
946
947 #endif