Cleanup: Clang tidy else after return
[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_api.h"
41 #include "WM_types.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     {IMA_SRC_TILED, "TILED", 0, "UDIM Tiles", "Tiled UDIM image texture"},
61     {0, NULL, 0, NULL, NULL},
62 };
63
64 #ifdef RNA_RUNTIME
65
66 #  include "BLI_math_base.h"
67
68 #  include "BKE_global.h"
69
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 void rna_Image_gpu_texture_update(Main *UNUSED(bmain),
196                                          Scene *UNUSED(scene),
197                                          PointerRNA *ptr)
198 {
199   Image *ima = (Image *)ptr->owner_id;
200
201   if (!G.background) {
202     BKE_image_free_gputextures(ima);
203   }
204
205   WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
206 }
207
208 static const EnumPropertyItem *rna_Image_source_itemf(bContext *UNUSED(C),
209                                                       PointerRNA *ptr,
210                                                       PropertyRNA *UNUSED(prop),
211                                                       bool *r_free)
212 {
213   Image *ima = (Image *)ptr->data;
214   EnumPropertyItem *item = NULL;
215   int totitem = 0;
216
217   if (ima->source == IMA_SRC_VIEWER) {
218     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_VIEWER);
219   }
220   else {
221     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_FILE);
222     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_SEQUENCE);
223     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_MOVIE);
224     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_GENERATED);
225     RNA_enum_items_add_value(&item, &totitem, image_source_items, IMA_SRC_TILED);
226   }
227
228   RNA_enum_item_end(&item, &totitem);
229   *r_free = true;
230
231   return item;
232 }
233
234 static int rna_Image_file_format_get(PointerRNA *ptr)
235 {
236   Image *image = (Image *)ptr->data;
237   ImBuf *ibuf = BKE_image_acquire_ibuf(image, NULL, NULL);
238   int imtype = BKE_image_ftype_to_imtype(ibuf ? ibuf->ftype : IMB_FTYPE_NONE,
239                                          ibuf ? &ibuf->foptions : NULL);
240
241   BKE_image_release_ibuf(image, ibuf, NULL);
242
243   return imtype;
244 }
245
246 static void rna_Image_file_format_set(PointerRNA *ptr, int value)
247 {
248   Image *image = (Image *)ptr->data;
249   if (BKE_imtype_is_movie(value) == 0) { /* should be able to throw an error here */
250     ImbFormatOptions options;
251     int ftype = BKE_image_imtype_to_ftype(value, &options);
252     BKE_image_file_format_set(image, ftype, &options);
253   }
254 }
255
256 static void rna_UDIMTile_label_get(PointerRNA *ptr, char *value)
257 {
258   ImageTile *tile = (ImageTile *)ptr->data;
259   Image *image = (Image *)ptr->owner_id;
260
261   /* We don't know the length of the target string here, so we assume
262    * that it has been allocated according to what rna_UDIMTile_label_length returned. */
263   BKE_image_get_tile_label(image, tile, value, sizeof(tile->label));
264 }
265
266 static int rna_UDIMTile_label_length(PointerRNA *ptr)
267 {
268   ImageTile *tile = (ImageTile *)ptr->data;
269   Image *image = (Image *)ptr->owner_id;
270
271   char label[sizeof(tile->label)];
272   BKE_image_get_tile_label(image, tile, label, sizeof(label));
273
274   return strlen(label);
275 }
276
277 static void rna_UDIMTile_tile_number_set(PointerRNA *ptr, int value)
278 {
279   ImageTile *tile = (ImageTile *)ptr->data;
280   Image *image = (Image *)ptr->owner_id;
281
282   /* The index of the first tile can't be changed. */
283   if (tile->tile_number == 1001) {
284     return;
285   }
286
287   /* Check that no other tile already has that number. */
288   ImageTile *cur_tile = BKE_image_get_tile(image, value);
289   if (cur_tile == NULL || cur_tile == tile) {
290     tile->tile_number = value;
291   }
292 }
293
294 static int rna_Image_active_tile_index_get(PointerRNA *ptr)
295 {
296   Image *image = (Image *)ptr->data;
297   return image->active_tile_index;
298 }
299
300 static void rna_Image_active_tile_index_set(PointerRNA *ptr, int value)
301 {
302   Image *image = (Image *)ptr->data;
303   int num_tiles = BLI_listbase_count(&image->tiles);
304
305   image->active_tile_index = min_ii(value, num_tiles - 1);
306 }
307
308 static void rna_Image_active_tile_index_range(
309     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
310 {
311   Image *image = (Image *)ptr->data;
312   int num_tiles = BLI_listbase_count(&image->tiles);
313
314   *min = 0;
315   *max = max_ii(0, num_tiles - 1);
316 }
317
318 static PointerRNA rna_Image_active_tile_get(PointerRNA *ptr)
319 {
320   Image *image = (Image *)ptr->data;
321   ImageTile *tile = BLI_findlink(&image->tiles, image->active_tile_index);
322
323   return rna_pointer_inherit_refine(ptr, &RNA_UDIMTile, tile);
324 }
325
326 static void rna_Image_active_tile_set(PointerRNA *ptr,
327                                       PointerRNA value,
328                                       struct ReportList *UNUSED(reports))
329 {
330   Image *image = (Image *)ptr->data;
331   ImageTile *tile = (ImageTile *)value.data;
332   const int index = BLI_findindex(&image->tiles, tile);
333   if (index != -1) {
334     image->active_tile_index = index;
335   }
336 }
337
338 static bool rna_Image_has_data_get(PointerRNA *ptr)
339 {
340   Image *image = (Image *)ptr->data;
341
342   return BKE_image_has_loaded_ibuf(image);
343 }
344
345 static void rna_Image_size_get(PointerRNA *ptr, int *values)
346 {
347   Image *im = (Image *)ptr->data;
348   ImBuf *ibuf;
349   void *lock;
350
351   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
352   if (ibuf) {
353     values[0] = ibuf->x;
354     values[1] = ibuf->y;
355   }
356   else {
357     values[0] = 0;
358     values[1] = 0;
359   }
360
361   BKE_image_release_ibuf(im, ibuf, lock);
362 }
363
364 static void rna_Image_resolution_get(PointerRNA *ptr, float *values)
365 {
366   Image *im = (Image *)ptr->data;
367   ImBuf *ibuf;
368   void *lock;
369
370   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
371   if (ibuf) {
372     values[0] = ibuf->ppm[0];
373     values[1] = ibuf->ppm[1];
374   }
375   else {
376     values[0] = 0;
377     values[1] = 0;
378   }
379
380   BKE_image_release_ibuf(im, ibuf, lock);
381 }
382
383 static void rna_Image_resolution_set(PointerRNA *ptr, const float *values)
384 {
385   Image *im = (Image *)ptr->data;
386   ImBuf *ibuf;
387   void *lock;
388
389   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
390   if (ibuf) {
391     ibuf->ppm[0] = values[0];
392     ibuf->ppm[1] = values[1];
393   }
394
395   BKE_image_release_ibuf(im, ibuf, lock);
396 }
397
398 static int rna_Image_bindcode_get(PointerRNA *ptr)
399 {
400   Image *ima = (Image *)ptr->data;
401   GPUTexture *tex = ima->gputexture[TEXTARGET_2D][0];
402   return (tex) ? GPU_texture_opengl_bindcode(tex) : 0;
403 }
404
405 static int rna_Image_depth_get(PointerRNA *ptr)
406 {
407   Image *im = (Image *)ptr->data;
408   ImBuf *ibuf;
409   void *lock;
410   int planes;
411
412   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
413
414   if (!ibuf) {
415     planes = 0;
416   }
417   else if (ibuf->rect_float) {
418     planes = ibuf->planes * 4;
419   }
420   else {
421     planes = ibuf->planes;
422   }
423
424   BKE_image_release_ibuf(im, ibuf, lock);
425
426   return planes;
427 }
428
429 static int rna_Image_frame_duration_get(PointerRNA *ptr)
430 {
431   Image *ima = (Image *)ptr->owner_id;
432   int duration = 1;
433
434   if (BKE_image_has_anim(ima)) {
435     struct anim *anim = ((ImageAnim *)ima->anims.first)->anim;
436     if (anim) {
437       duration = IMB_anim_get_duration(anim, IMB_TC_RECORD_RUN);
438     }
439   }
440   else {
441     /* acquire ensures ima->anim is set, if possible! */
442     void *lock;
443     ImBuf *ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
444     BKE_image_release_ibuf(ima, ibuf, lock);
445   }
446
447   return duration;
448 }
449
450 static int rna_Image_pixels_get_length(PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
451 {
452   Image *ima = (Image *)ptr->owner_id;
453   ImBuf *ibuf;
454   void *lock;
455
456   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
457
458   if (ibuf) {
459     length[0] = ibuf->x * ibuf->y * ibuf->channels;
460   }
461   else {
462     length[0] = 0;
463   }
464
465   BKE_image_release_ibuf(ima, ibuf, lock);
466
467   return length[0];
468 }
469
470 static void rna_Image_pixels_get(PointerRNA *ptr, float *values)
471 {
472   Image *ima = (Image *)ptr->owner_id;
473   ImBuf *ibuf;
474   void *lock;
475   int i, size;
476
477   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
478
479   if (ibuf) {
480     size = ibuf->x * ibuf->y * ibuf->channels;
481
482     if (ibuf->rect_float) {
483       memcpy(values, ibuf->rect_float, sizeof(float) * size);
484     }
485     else {
486       for (i = 0; i < size; i++) {
487         values[i] = ((unsigned char *)ibuf->rect)[i] * (1.0f / 255.0f);
488       }
489     }
490   }
491
492   BKE_image_release_ibuf(ima, ibuf, lock);
493 }
494
495 static void rna_Image_pixels_set(PointerRNA *ptr, const float *values)
496 {
497   Image *ima = (Image *)ptr->owner_id;
498   ImBuf *ibuf;
499   void *lock;
500   int i, size;
501
502   ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
503
504   if (ibuf) {
505     size = ibuf->x * ibuf->y * ibuf->channels;
506
507     if (ibuf->rect_float) {
508       memcpy(ibuf->rect_float, values, sizeof(float) * size);
509     }
510     else {
511       for (i = 0; i < size; i++) {
512         ((unsigned char *)ibuf->rect)[i] = unit_float_to_uchar_clamp(values[i]);
513       }
514     }
515
516     ibuf->userflags |= IB_DISPLAY_BUFFER_INVALID | IB_MIPMAP_INVALID;
517     BKE_image_mark_dirty(ima, ibuf);
518     if (!G.background) {
519       BKE_image_free_gputextures(ima);
520     }
521     WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
522   }
523
524   BKE_image_release_ibuf(ima, ibuf, lock);
525 }
526
527 static int rna_Image_channels_get(PointerRNA *ptr)
528 {
529   Image *im = (Image *)ptr->data;
530   ImBuf *ibuf;
531   void *lock;
532   int channels = 0;
533
534   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
535   if (ibuf) {
536     channels = ibuf->channels;
537   }
538
539   BKE_image_release_ibuf(im, ibuf, lock);
540
541   return channels;
542 }
543
544 static bool rna_Image_is_float_get(PointerRNA *ptr)
545 {
546   Image *im = (Image *)ptr->data;
547   ImBuf *ibuf;
548   void *lock;
549   bool is_float = false;
550
551   ibuf = BKE_image_acquire_ibuf(im, NULL, &lock);
552   if (ibuf) {
553     is_float = ibuf->rect_float != NULL;
554   }
555
556   BKE_image_release_ibuf(im, ibuf, lock);
557
558   return is_float;
559 }
560
561 static PointerRNA rna_Image_packed_file_get(PointerRNA *ptr)
562 {
563   Image *ima = (Image *)ptr->owner_id;
564
565   if (BKE_image_has_packedfile(ima)) {
566     ImagePackedFile *imapf = ima->packedfiles.first;
567     return rna_pointer_inherit_refine(ptr, &RNA_PackedFile, imapf->packedfile);
568   }
569   else {
570     return PointerRNA_NULL;
571   }
572 }
573
574 static void rna_RenderSlot_clear(ID *id, RenderSlot *slot, ImageUser *iuser)
575 {
576   Image *image = (Image *)id;
577   int index = BLI_findindex(&image->renderslots, slot);
578   BKE_image_clear_renderslot(image, iuser, index);
579
580   WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, image);
581 }
582
583 static PointerRNA rna_render_slots_active_get(PointerRNA *ptr)
584 {
585   Image *image = (Image *)ptr->owner_id;
586   RenderSlot *render_slot = BKE_image_get_renderslot(image, image->render_slot);
587
588   return rna_pointer_inherit_refine(ptr, &RNA_RenderSlot, render_slot);
589 }
590
591 static void rna_render_slots_active_set(PointerRNA *ptr,
592                                         PointerRNA value,
593                                         struct ReportList *UNUSED(reports))
594 {
595   Image *image = (Image *)ptr->owner_id;
596   if (value.owner_id == &image->id) {
597     RenderSlot *slot = (RenderSlot *)value.data;
598     int index = BLI_findindex(&image->renderslots, slot);
599     if (index != -1) {
600       image->render_slot = index;
601       image->gpuflag |= IMA_GPU_REFRESH;
602     }
603   }
604 }
605
606 static int rna_render_slots_active_index_get(PointerRNA *ptr)
607 {
608   Image *image = (Image *)ptr->owner_id;
609   return image->render_slot;
610 }
611
612 static void rna_render_slots_active_index_set(PointerRNA *ptr, int value)
613 {
614   Image *image = (Image *)ptr->owner_id;
615   int num_slots = BLI_listbase_count(&image->renderslots);
616   image->render_slot = value;
617   image->gpuflag |= IMA_GPU_REFRESH;
618   CLAMP(image->render_slot, 0, num_slots - 1);
619 }
620
621 static void rna_render_slots_active_index_range(
622     PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
623 {
624   Image *image = (Image *)ptr->owner_id;
625   *min = 0;
626   *max = max_ii(0, BLI_listbase_count(&image->renderslots) - 1);
627 }
628
629 static ImageTile *rna_UDIMTile_new(Image *image, int tile_number, const char *label)
630 {
631   ImageTile *tile = BKE_image_add_tile(image, tile_number, label);
632
633   WM_main_add_notifier(NC_IMAGE | ND_DRAW, NULL);
634
635   return tile;
636 }
637
638 static void rna_UDIMTile_remove(Image *image, PointerRNA *ptr)
639 {
640   ImageTile *tile = (ImageTile *)ptr->data;
641   BKE_image_remove_tile(image, tile);
642
643   WM_main_add_notifier(NC_IMAGE | ND_DRAW, NULL);
644 }
645
646 #else
647
648 static void rna_def_imageuser(BlenderRNA *brna)
649 {
650   StructRNA *srna;
651   PropertyRNA *prop;
652
653   srna = RNA_def_struct(brna, "ImageUser", NULL);
654   RNA_def_struct_ui_text(
655       srna,
656       "Image User",
657       "Parameters defining how an Image data-block is used by another data-block");
658   RNA_def_struct_path_func(srna, "rna_ImageUser_path");
659
660   prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
661   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_ANIM_ALWAYS);
662   RNA_def_property_ui_text(prop, "Auto Refresh", "Always refresh image on frame changes");
663   RNA_def_property_update(prop, 0, "rna_ImageUser_relations_update");
664   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
665
666   prop = RNA_def_property(srna, "frame_current", PROP_INT, PROP_TIME);
667   RNA_def_property_int_sdna(prop, NULL, "framenr");
668   RNA_def_property_range(prop, MINAFRAME, MAXFRAME);
669   RNA_def_property_ui_text(
670       prop, "Current Frame", "Current frame number in image sequence or movie");
671
672   /* animation */
673   prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
674   RNA_def_property_boolean_sdna(prop, NULL, "cycl", 0);
675   RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie");
676   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
677   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
678
679   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
680   RNA_def_property_int_sdna(prop, NULL, "frames");
681   RNA_def_property_range(prop, 0, MAXFRAMEF);
682   RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use");
683   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
684   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
685
686   prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
687   RNA_def_property_int_sdna(prop, NULL, "offset");
688   RNA_def_property_ui_text(
689       prop, "Offset", "Offset the number of the frame to use in the animation");
690   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
691
692   prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
693   RNA_def_property_int_sdna(prop, NULL, "sfra");
694   RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
695   RNA_def_property_ui_text(
696       prop,
697       "Start Frame",
698       "Global starting frame of the movie/sequence, assuming first picture has a #1");
699   RNA_def_property_update(prop, 0, "rna_ImageUser_update");
700   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
701
702   prop = RNA_def_property(srna, "multilayer_layer", PROP_INT, PROP_UNSIGNED);
703   RNA_def_property_int_sdna(prop, NULL, "layer");
704   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
705   RNA_def_property_ui_text(prop, "Layer", "Layer in multilayer image");
706
707   prop = RNA_def_property(srna, "multilayer_pass", PROP_INT, PROP_UNSIGNED);
708   RNA_def_property_int_sdna(prop, NULL, "pass");
709   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
710   RNA_def_property_ui_text(prop, "Pass", "Pass in multilayer image");
711
712   prop = RNA_def_property(srna, "multilayer_view", PROP_INT, PROP_UNSIGNED);
713   RNA_def_property_int_sdna(prop, NULL, "view");
714   RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
715   RNA_def_property_ui_text(prop, "View", "View in multilayer image");
716
717   prop = RNA_def_property(srna, "tile", PROP_INT, PROP_UNSIGNED);
718   RNA_def_property_int_sdna(prop, NULL, "tile");
719   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
720   RNA_def_property_ui_text(prop, "Tile", "Tile in tiled image");
721 }
722
723 /* image.packed_files */
724 static void rna_def_image_packed_files(BlenderRNA *brna)
725 {
726   StructRNA *srna;
727   PropertyRNA *prop;
728
729   srna = RNA_def_struct(brna, "ImagePackedFile", NULL);
730   RNA_def_struct_sdna(srna, "ImagePackedFile");
731
732   prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
733   RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
734   RNA_def_property_ui_text(prop, "Packed File", "");
735   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
736
737   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
738   RNA_def_property_string_sdna(prop, NULL, "filepath");
739   RNA_def_struct_name_property(srna, prop);
740
741   RNA_api_image_packed_file(srna);
742 }
743
744 static void rna_def_render_slot(BlenderRNA *brna)
745 {
746   StructRNA *srna;
747   PropertyRNA *prop, *parm;
748   FunctionRNA *func;
749
750   srna = RNA_def_struct(brna, "RenderSlot", NULL);
751   RNA_def_struct_ui_text(srna, "Render Slot", "Parameters defining the render slot");
752
753   prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
754   RNA_def_property_string_sdna(prop, NULL, "name");
755   RNA_def_property_ui_text(prop, "Name", "Render slot name");
756   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
757
758   func = RNA_def_function(srna, "clear", "rna_RenderSlot_clear");
759   RNA_def_function_flag(func, FUNC_USE_SELF_ID);
760   RNA_def_function_ui_description(func, "Clear the render slot");
761   parm = RNA_def_pointer(func, "iuser", "ImageUser", "ImageUser", "");
762   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
763 }
764
765 static void rna_def_render_slots(BlenderRNA *brna, PropertyRNA *cprop)
766 {
767   StructRNA *srna;
768   FunctionRNA *func;
769   PropertyRNA *prop, *parm;
770
771   RNA_def_property_srna(cprop, "RenderSlots");
772   srna = RNA_def_struct(brna, "RenderSlots", NULL);
773   RNA_def_struct_sdna(srna, "Image");
774   RNA_def_struct_ui_text(srna, "Render Layers", "Collection of render layers");
775
776   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
777   RNA_def_property_int_sdna(prop, NULL, "render_slot");
778   RNA_def_property_int_funcs(prop,
779                              "rna_render_slots_active_index_get",
780                              "rna_render_slots_active_index_set",
781                              "rna_render_slots_active_index_range");
782   RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
783   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
784
785   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
786   RNA_def_property_struct_type(prop, "RenderSlot");
787   RNA_def_property_pointer_funcs(
788       prop, "rna_render_slots_active_get", "rna_render_slots_active_set", NULL, NULL);
789   RNA_def_property_flag(prop, PROP_EDITABLE);
790   RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
791   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
792
793   func = RNA_def_function(srna, "new", "BKE_image_add_renderslot");
794   RNA_def_function_ui_description(func, "Add a render slot to the image");
795   parm = RNA_def_string(func, "name", NULL, 0, "Name", "New name for the render slot");
796   parm = RNA_def_pointer(func, "result", "RenderSlot", "", "Newly created render layer");
797   RNA_def_function_return(func, parm);
798 }
799
800 static void rna_def_udim_tile(BlenderRNA *brna)
801 {
802   StructRNA *srna;
803   PropertyRNA *prop;
804
805   srna = RNA_def_struct(brna, "UDIMTile", NULL);
806   RNA_def_struct_sdna(srna, "ImageTile");
807   RNA_def_struct_ui_text(srna, "UDIM Tile", "Properties of the UDIM tile");
808
809   prop = RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
810   RNA_def_property_string_sdna(prop, NULL, "label");
811   RNA_def_property_ui_text(prop, "Label", "Tile label");
812   RNA_def_property_string_funcs(prop, "rna_UDIMTile_label_get", "rna_UDIMTile_label_length", NULL);
813   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
814
815   prop = RNA_def_property(srna, "number", PROP_INT, PROP_NONE);
816   RNA_def_property_int_sdna(prop, NULL, "tile_number");
817   RNA_def_property_ui_text(prop, "Number", "Number of the position that this tile covers");
818   RNA_def_property_int_funcs(prop, NULL, "rna_UDIMTile_tile_number_set", NULL);
819   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
820 }
821
822 static void rna_def_udim_tiles(BlenderRNA *brna, PropertyRNA *cprop)
823 {
824   StructRNA *srna;
825   PropertyRNA *prop;
826
827   FunctionRNA *func;
828   PropertyRNA *parm;
829
830   RNA_def_property_srna(cprop, "UDIMTiles");
831   srna = RNA_def_struct(brna, "UDIMTiles", NULL);
832   RNA_def_struct_sdna(srna, "Image");
833   RNA_def_struct_ui_text(srna, "UDIM Tiles", "Collection of UDIM tiles");
834
835   prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
836   RNA_def_property_int_sdna(prop, NULL, "active_tile_index");
837   RNA_def_property_int_funcs(prop,
838                              "rna_Image_active_tile_index_get",
839                              "rna_Image_active_tile_index_set",
840                              "rna_Image_active_tile_index_range");
841   RNA_def_property_ui_text(prop, "Active Tile Index", "Active index in tiles array");
842
843   prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
844   RNA_def_property_struct_type(prop, "UDIMTile");
845   RNA_def_property_pointer_funcs(
846       prop, "rna_Image_active_tile_get", "rna_Image_active_tile_set", NULL, NULL);
847   RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
848   RNA_def_property_ui_text(prop, "Active Image Tile", "Active Image Tile");
849
850   func = RNA_def_function(srna, "new", "rna_UDIMTile_new");
851   RNA_def_function_ui_description(func, "Add a tile to the image");
852   parm = RNA_def_int(
853       func, "tile_number", 1, 1, INT_MAX, "", "Number of the newly created tile", 1, 100);
854   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
855   parm = RNA_def_string(func, "label", NULL, 0, "", "Optional label for the tile");
856   parm = RNA_def_pointer(func, "result", "UDIMTile", "", "Newly created image tile");
857   RNA_def_function_return(func, parm);
858
859   func = RNA_def_function(srna, "get", "BKE_image_get_tile");
860   RNA_def_function_ui_description(func, "Get a tile based on its tile number");
861   parm = RNA_def_int(func, "tile_number", 0, 0, INT_MAX, "", "Number of the tile", 0, 100);
862   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
863   parm = RNA_def_pointer(func, "result", "UDIMTile", "", "The tile");
864   RNA_def_function_return(func, parm);
865
866   func = RNA_def_function(srna, "remove", "rna_UDIMTile_remove");
867   RNA_def_function_ui_description(func, "Remove an image tile");
868   parm = RNA_def_pointer(func, "tile", "UDIMTile", "", "Image tile to remove");
869   RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
870   RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
871 }
872
873 static void rna_def_image(BlenderRNA *brna)
874 {
875   StructRNA *srna;
876   PropertyRNA *prop;
877   static const EnumPropertyItem prop_type_items[] = {
878       {IMA_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
879       {IMA_TYPE_MULTILAYER, "MULTILAYER", 0, "Multilayer", ""},
880       {IMA_TYPE_UV_TEST, "UV_TEST", 0, "UV Test", ""},
881       {IMA_TYPE_R_RESULT, "RENDER_RESULT", 0, "Render Result", ""},
882       {IMA_TYPE_COMPOSITE, "COMPOSITING", 0, "Compositing", ""},
883       {0, NULL, 0, NULL, NULL},
884   };
885   static const EnumPropertyItem alpha_mode_items[] = {
886       {IMA_ALPHA_STRAIGHT,
887        "STRAIGHT",
888        0,
889        "Straight",
890        "Store RGB and alpha channels separately with alpha acting as a mask, also known as "
891        "unassociated alpha. Commonly used by image editing applications and file formats like "
892        "PNG"},
893       {IMA_ALPHA_PREMUL,
894        "PREMUL",
895        0,
896        "Premultiplied",
897        "Store RGB channels with alpha multiplied in, also known as associated alpha. The natural "
898        "format for renders and used by file formats like OpenEXR"},
899       {IMA_ALPHA_CHANNEL_PACKED,
900        "CHANNEL_PACKED",
901        0,
902        "Channel Packed",
903        "Different images are packed in the RGB and alpha channels, and they should not "
904        "affect each other. Channel packing is commonly used by game engines to save memory"},
905       {IMA_ALPHA_IGNORE,
906        "NONE",
907        0,
908        "None",
909        "Ignore alpha channel from the file and make image fully opaque"},
910       {0, NULL, 0, NULL, NULL},
911   };
912
913   srna = RNA_def_struct(brna, "Image", "ID");
914   RNA_def_struct_ui_text(
915       srna, "Image", "Image data-block referencing an external or packed image");
916   RNA_def_struct_ui_icon(srna, ICON_IMAGE_DATA);
917
918   prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
919   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
920   RNA_def_property_string_sdna(prop, NULL, "filepath");
921   RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name");
922   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
923
924   /* eek. this is horrible but needed so we can save to a new name without blanking the data :( */
925   prop = RNA_def_property(srna, "filepath_raw", PROP_STRING, PROP_FILEPATH);
926   RNA_def_property_string_sdna(prop, NULL, "filepath");
927   RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name (without data refreshing)");
928
929   prop = RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
930   RNA_def_property_enum_items(prop, rna_enum_image_type_items);
931   RNA_def_property_enum_funcs(
932       prop, "rna_Image_file_format_get", "rna_Image_file_format_set", NULL);
933   RNA_def_property_ui_text(prop, "File Format", "Format used for re-saving this file");
934
935   prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
936   RNA_def_property_enum_items(prop, image_source_items);
937   RNA_def_property_enum_funcs(prop, NULL, "rna_Image_source_set", "rna_Image_source_itemf");
938   RNA_def_property_ui_text(prop, "Source", "Where the image comes from");
939   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
940
941   prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
942   RNA_def_property_enum_items(prop, prop_type_items);
943   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
944   RNA_def_property_ui_text(prop, "Type", "How to generate the image");
945   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
946
947   prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
948   RNA_def_property_struct_type(prop, "PackedFile");
949   RNA_def_property_pointer_sdna(prop, NULL, "packedfile");
950   RNA_def_property_pointer_funcs(prop, "rna_Image_packed_file_get", NULL, NULL, NULL);
951   RNA_def_property_ui_text(prop, "Packed File", "First packed file of the image");
952
953   prop = RNA_def_property(srna, "packed_files", PROP_COLLECTION, PROP_NONE);
954   RNA_def_property_collection_sdna(prop, NULL, "packedfiles", NULL);
955   RNA_def_property_struct_type(prop, "ImagePackedFile");
956   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
957   RNA_def_property_ui_text(prop, "Packed Files", "Collection of packed images");
958
959   prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
960   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
961   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_VIEW_AS_RENDER);
962   RNA_def_property_ui_text(
963       prop,
964       "View as Render",
965       "Apply render part of display transformation when displaying this image on the screen");
966   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
967
968   prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
969   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
970   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_DEINTERLACE);
971   RNA_def_property_ui_text(prop, "Deinterlace", "Deinterlace movie file on load");
972   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
973
974   prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
975   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
976   RNA_def_property_boolean_sdna(prop, NULL, "flag", IMA_USE_VIEWS);
977   RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
978   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
979
980   prop = RNA_def_property(srna, "is_stereo_3d", PROP_BOOLEAN, PROP_NONE);
981   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
982   RNA_def_property_boolean_funcs(prop, "rna_Image_is_stereo_3d_get", NULL);
983   RNA_def_property_ui_text(prop, "Stereo 3D", "Image has left and right views");
984   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
985
986   prop = RNA_def_property(srna, "is_multiview", PROP_BOOLEAN, PROP_NONE);
987   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
988   RNA_def_property_boolean_funcs(prop, "rna_Image_is_multiview_get", NULL);
989   RNA_def_property_ui_text(prop, "Multiple Views", "Image has more than one view");
990   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
991
992   prop = RNA_def_property(srna, "is_dirty", PROP_BOOLEAN, PROP_NONE);
993   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
994   RNA_def_property_boolean_funcs(prop, "rna_Image_dirty_get", NULL);
995   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
996   RNA_def_property_ui_text(prop, "Dirty", "Image has changed and is not saved");
997
998   /* generated image (image_generated_change_cb) */
999   prop = RNA_def_property(srna, "generated_type", PROP_ENUM, PROP_NONE);
1000   RNA_def_property_enum_sdna(prop, NULL, "gen_type");
1001   RNA_def_property_enum_items(prop, rna_enum_image_generated_type_items);
1002   RNA_def_property_ui_text(prop, "Generated Type", "Generated image type");
1003   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1004   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1005
1006   prop = RNA_def_property(srna, "generated_width", PROP_INT, PROP_PIXEL);
1007   RNA_def_property_int_sdna(prop, NULL, "gen_x");
1008   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
1009   RNA_def_property_range(prop, 1, 65536);
1010   RNA_def_property_ui_text(prop, "Generated Width", "Generated image width");
1011   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1012   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1013
1014   prop = RNA_def_property(srna, "generated_height", PROP_INT, PROP_PIXEL);
1015   RNA_def_property_int_sdna(prop, NULL, "gen_y");
1016   RNA_def_property_flag(prop, PROP_PROPORTIONAL);
1017   RNA_def_property_range(prop, 1, 65536);
1018   RNA_def_property_ui_text(prop, "Generated Height", "Generated image height");
1019   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1020   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1021
1022   prop = RNA_def_property(srna, "use_generated_float", PROP_BOOLEAN, PROP_NONE);
1023   RNA_def_property_boolean_sdna(prop, NULL, "gen_flag", IMA_GEN_FLOAT);
1024   RNA_def_property_ui_text(prop, "Float Buffer", "Generate floating-point buffer");
1025   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1026   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1027
1028   prop = RNA_def_property(srna, "generated_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1029   RNA_def_property_float_sdna(prop, NULL, "gen_color");
1030   RNA_def_property_array(prop, 4);
1031   RNA_def_property_ui_text(prop, "Color", "Fill color for the generated image");
1032   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1033   RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1034
1035   prop = RNA_def_property(srna, "display_aspect", PROP_FLOAT, PROP_XYZ);
1036   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1037   RNA_def_property_float_sdna(prop, NULL, "aspx");
1038   RNA_def_property_array(prop, 2);
1039   RNA_def_property_range(prop, 0.1f, FLT_MAX);
1040   RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
1041   RNA_def_property_ui_text(
1042       prop, "Display Aspect", "Display Aspect for this image, does not affect rendering");
1043   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
1044
1045   prop = RNA_def_property(srna, "bindcode", PROP_INT, PROP_UNSIGNED);
1046   RNA_def_property_int_funcs(prop, "rna_Image_bindcode_get", NULL, NULL);
1047   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1048   RNA_def_property_ui_text(prop, "Bindcode", "OpenGL bindcode");
1049   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, NULL);
1050
1051   prop = RNA_def_property(srna, "render_slots", PROP_COLLECTION, PROP_NONE);
1052   RNA_def_property_struct_type(prop, "RenderSlot");
1053   RNA_def_property_collection_sdna(prop, NULL, "renderslots", NULL);
1054   RNA_def_property_ui_text(prop, "Render Slots", "Render slots of the image");
1055   rna_def_render_slots(brna, prop);
1056
1057   prop = RNA_def_property(srna, "tiles", PROP_COLLECTION, PROP_NONE);
1058   RNA_def_property_struct_type(prop, "UDIMTile");
1059   RNA_def_property_collection_sdna(prop, NULL, "tiles", NULL);
1060   RNA_def_property_ui_text(prop, "Image Tiles", "Tiles of the image");
1061   rna_def_udim_tiles(brna, prop);
1062
1063   /*
1064    * Image.has_data and Image.depth are temporary,
1065    * Update import_obj.py when they are replaced (Arystan)
1066    */
1067   prop = RNA_def_property(srna, "has_data", PROP_BOOLEAN, PROP_NONE);
1068   RNA_def_property_boolean_funcs(prop, "rna_Image_has_data_get", NULL);
1069   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1070   RNA_def_property_ui_text(prop, "Has Data", "True if the image data is loaded into memory");
1071
1072   prop = RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
1073   RNA_def_property_int_funcs(prop, "rna_Image_depth_get", NULL, NULL);
1074   RNA_def_property_ui_text(prop, "Depth", "Image bit depth");
1075   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1076
1077   prop = RNA_def_int_vector(srna,
1078                             "size",
1079                             2,
1080                             NULL,
1081                             0,
1082                             0,
1083                             "Size",
1084                             "Width and height in pixels, zero when image data cant be loaded",
1085                             0,
1086                             0);
1087   RNA_def_property_subtype(prop, PROP_PIXEL);
1088   RNA_def_property_int_funcs(prop, "rna_Image_size_get", NULL, NULL);
1089   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1090
1091   prop = RNA_def_float_vector(
1092       srna, "resolution", 2, NULL, 0, 0, "Resolution", "X/Y pixels per meter", 0, 0);
1093   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1094   RNA_def_property_float_funcs(prop, "rna_Image_resolution_get", "rna_Image_resolution_set", NULL);
1095
1096   prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_UNSIGNED);
1097   RNA_def_property_int_funcs(prop, "rna_Image_frame_duration_get", NULL, NULL);
1098   RNA_def_property_ui_text(
1099       prop, "Duration", "Duration (in frames) of the image (1 when not a video/sequence)");
1100   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1101
1102   /* NOTE about pixels/channels/is_float:
1103    * These properties describe how the image is stored internally (inside of ImBuf),
1104    * not how it was saved to disk or how it'll be saved on disk.
1105    */
1106   prop = RNA_def_property(srna, "pixels", PROP_FLOAT, PROP_NONE);
1107   RNA_def_property_flag(prop, PROP_DYNAMIC);
1108   RNA_def_property_multi_array(prop, 1, NULL);
1109   RNA_def_property_ui_text(prop, "Pixels", "Image pixels in floating-point values");
1110   RNA_def_property_dynamic_array_funcs(prop, "rna_Image_pixels_get_length");
1111   RNA_def_property_float_funcs(prop, "rna_Image_pixels_get", "rna_Image_pixels_set", NULL);
1112
1113   prop = RNA_def_property(srna, "channels", PROP_INT, PROP_UNSIGNED);
1114   RNA_def_property_int_funcs(prop, "rna_Image_channels_get", NULL, NULL);
1115   RNA_def_property_ui_text(prop, "Channels", "Number of channels in pixels buffer");
1116   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1117
1118   prop = RNA_def_property(srna, "is_float", PROP_BOOLEAN, PROP_NONE);
1119   RNA_def_property_boolean_funcs(prop, "rna_Image_is_float_get", NULL);
1120   RNA_def_property_clear_flag(prop, PROP_EDITABLE);
1121   RNA_def_property_ui_text(
1122       prop, "Is Float", "True if this image is stored in floating-point buffer");
1123
1124   prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
1125   RNA_def_property_pointer_sdna(prop, NULL, "colorspace_settings");
1126   RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
1127   RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
1128
1129   prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
1130   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1131   RNA_def_property_enum_items(prop, alpha_mode_items);
1132   RNA_def_property_ui_text(prop,
1133                            "Alpha Mode",
1134                            "Representation of alpha in the image file, to convert to and from "
1135                            "when saving and loading the image");
1136   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_colormanage_update");
1137
1138   prop = RNA_def_property(srna, "use_half_precision", PROP_BOOLEAN, PROP_NONE);
1139   RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", IMA_HIGH_BITDEPTH);
1140   RNA_def_property_ui_text(prop,
1141                            "Half Float Precision",
1142                            "Use 16 bits per channel to lower the memory usage during rendering");
1143   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_gpu_texture_update");
1144
1145   /* multiview */
1146   prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
1147   RNA_def_property_override_flag(prop, PROPOVERRIDE_OVERRIDABLE_LIBRARY);
1148   RNA_def_property_enum_sdna(prop, NULL, "views_format");
1149   RNA_def_property_enum_items(prop, rna_enum_views_format_items);
1150   RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
1151   RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
1152
1153   prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
1154   RNA_def_property_pointer_sdna(prop, NULL, "stereo3d_format");
1155   RNA_def_property_flag(prop, PROP_NEVER_NULL);
1156   RNA_def_property_struct_type(prop, "Stereo3dFormat");
1157   RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
1158
1159   RNA_api_image(srna);
1160 }
1161
1162 void RNA_def_image(BlenderRNA *brna)
1163 {
1164   rna_def_render_slot(brna);
1165   rna_def_udim_tile(brna);
1166   rna_def_image(brna);
1167   rna_def_imageuser(brna);
1168   rna_def_image_packed_files(brna);
1169 }
1170
1171 #endif