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