Blender V5.3
rna_image.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstdlib>
10
11#include "DNA_image_types.h"
12#include "DNA_scene_types.h"
13
14#include "BLT_translation.hh"
15
16#include "RNA_define.hh"
17#include "RNA_enum_types.hh"
18
19#include "rna_internal.hh"
20
21#include "WM_api.hh"
22#include "WM_types.hh"
23
24namespace blender {
25
27 {IMA_GENTYPE_BLANK, "BLANK", 0, "Blank", "Generate a blank image"},
28 {IMA_GENTYPE_GRID, "UV_GRID", 0, "UV Grid", "Generated grid to test UV mappings"},
30 "COLOR_GRID",
31 0,
32 "Color Grid",
33 "Generated improved UV grid to test UV mappings"},
34 {0, nullptr, 0, nullptr, nullptr},
35};
36
38 {IMA_SRC_FILE, "FILE", 0, "Single Image", "Single image file"},
39 {IMA_SRC_SEQUENCE, "SEQUENCE", 0, "Image Sequence", "Multiple image files, as a sequence"},
40 {IMA_SRC_MOVIE, "MOVIE", 0, "Movie", "Movie file"},
41 {IMA_SRC_GENERATED, "GENERATED", 0, "Generated", "Generated image"},
42 {IMA_SRC_VIEWER, "VIEWER", 0, "Viewer", "Compositing node viewer"},
43 {IMA_SRC_TILED, "TILED", 0, "UDIM Tiles", "Tiled UDIM image texture"},
44 {0, nullptr, 0, nullptr, nullptr},
45};
46
47} // namespace blender
48
49#ifdef RNA_RUNTIME
50
51# include <algorithm>
52# include <fmt/format.h>
53
54# include "BLI_listbase.hh"
55# include "BLI_math_base_c.hh"
56# include "BLI_math_vector_c.hh"
57
58# include "BKE_global.hh"
59# include "BKE_image.hh"
60# include "BKE_image_format.hh"
61# include "BKE_image_gpu.hh"
62# include "BKE_lib_id.hh"
63# include "BKE_main.hh"
64# include "BKE_main_invariants.hh"
66# include "BKE_screen.hh"
67
68# include "GPU_texture.hh"
69
70# include "IMB_imbuf.hh"
71# include "IMB_imbuf_types.hh"
72# include "IMB_partial_update.hh"
73
74# include "MOV_read.hh"
75
76# include "ED_image.hh"
77# include "ED_node.hh"
78
79# include "DNA_space_types.h"
80
81# include "DEG_depsgraph.hh"
82# include "DEG_depsgraph_build.hh"
83
84namespace blender {
85
87{
88 Image *image = id_cast<Image *>(value.owner_id);
89 return image->type != IMA_TYPE_R_RESULT && image->type != IMA_TYPE_COMPOSITE;
90}
91
92static bool rna_Image_is_stereo_3d_get(PointerRNA *ptr)
93{
94 return BKE_image_is_stereo(static_cast<Image *>(ptr->data));
95}
96
97static bool rna_Image_is_multiview_get(PointerRNA *ptr)
98{
99 return BKE_image_is_multiview(static_cast<Image *>(ptr->data));
100}
101
102static bool rna_Image_dirty_get(PointerRNA *ptr)
103{
104 return BKE_image_is_dirty(static_cast<Image *>(ptr->data));
105}
106
107static void rna_Image_source_set(PointerRNA *ptr, int value)
108{
109 Image *ima = id_cast<Image *>(ptr->owner_id);
110
111 if (value != ima->source) {
112 ima->source = eImageSource(value);
115 if (ima->source == IMA_SRC_TILED) {
117 }
118
119 DEG_id_tag_update(&ima->id, 0);
122 }
123}
124
125static void rna_Image_reload_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
126{
127 Image *ima = id_cast<Image *>(ptr->owner_id);
128 BKE_image_signal(bmain, ima, nullptr, IMA_SIGNAL_RELOAD);
130 DEG_id_tag_update(&ima->id, 0);
132}
133
134static int rna_Image_generated_type_get(PointerRNA *ptr)
135{
136 Image *ima = static_cast<Image *>(ptr->data);
137 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
138 return base_tile->gen_type;
139}
140
141static void rna_Image_generated_type_set(PointerRNA *ptr, int value)
142{
143 Image *ima = static_cast<Image *>(ptr->data);
144 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
145 base_tile->gen_type = eImageGenType(value);
146}
147
148static int rna_Image_generated_width_get(PointerRNA *ptr)
149{
150 Image *ima = static_cast<Image *>(ptr->data);
151 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
152 return base_tile->gen_x;
153}
154
155static void rna_Image_generated_width_set(PointerRNA *ptr, int value)
156{
157 Image *ima = static_cast<Image *>(ptr->data);
158 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
159 base_tile->gen_x = std::clamp(value, 1, 65536);
160}
161
162static int rna_Image_generated_height_get(PointerRNA *ptr)
163{
164 Image *ima = static_cast<Image *>(ptr->data);
165 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
166 return base_tile->gen_y;
167}
168
169static void rna_Image_generated_height_set(PointerRNA *ptr, int value)
170{
171 Image *ima = static_cast<Image *>(ptr->data);
172 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
173 base_tile->gen_y = std::clamp(value, 1, 65536);
174}
175
176static bool rna_Image_generated_float_get(PointerRNA *ptr)
177{
178 Image *ima = static_cast<Image *>(ptr->data);
179 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
180 return (base_tile->gen_flag & IMA_GEN_FLOAT) != 0;
181}
182
183static void rna_Image_generated_float_set(PointerRNA *ptr, bool value)
184{
185 Image *ima = static_cast<Image *>(ptr->data);
186 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
187 if (value) {
188 base_tile->gen_flag |= IMA_GEN_FLOAT;
189 }
190 else {
191 base_tile->gen_flag &= ~IMA_GEN_FLOAT;
192 }
193}
194
195void rna_Image_generated_color_get(PointerRNA *ptr, float values[4])
196{
197 Image *ima = static_cast<Image *>(ptr->data);
198 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
199 copy_v4_v4(values, base_tile->gen_color);
200}
201
202void rna_Image_generated_color_set(PointerRNA *ptr, const float values[4])
203{
204 Image *ima = static_cast<Image *>(ptr->data);
205 ImageTile *base_tile = BKE_image_get_tile(ima, 0);
206 for (uint i = 0; i < 4; i++) {
207 base_tile->gen_color[i] = std::clamp(values[i], 0.0f, FLT_MAX);
208 }
209}
210
211static void rna_Image_generated_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
212{
213 Image *ima = id_cast<Image *>(ptr->owner_id);
214 BKE_image_signal(bmain, ima, nullptr, IMA_SIGNAL_FREE);
216}
217
218static void rna_Image_colormanage_update(Main *bmain, Scene * /*scene*/, PointerRNA *ptr)
219{
220 Image *ima = id_cast<Image *>(ptr->owner_id);
221 BKE_image_signal(bmain, ima, nullptr, IMA_SIGNAL_COLORMANAGE);
222 DEG_id_tag_update(&ima->id, 0);
226}
227
228static void rna_Image_alpha_mode_update(Main *bmain, Scene *scene, PointerRNA *ptr)
229{
230 Image *ima = id_cast<Image *>(ptr->owner_id);
231 /* When operating on a generated image, avoid re-generating when changing the alpha-mode
232 * as it doesn't impact generated images, causing them to reload pixel data, see #82785. */
233 if (ima->source == IMA_SRC_GENERATED) {
234 return;
235 }
236 rna_Image_colormanage_update(bmain, scene, ptr);
237}
238
239static void rna_Image_views_format_update(Main *bmain, Scene *scene, PointerRNA *ptr)
240{
241 Image *ima = id_cast<Image *>(ptr->owner_id);
242 ImBuf *ibuf;
243 void *lock;
244
245 ibuf = BKE_image_acquire_ibuf(ima, nullptr, &lock);
246
247 if (ibuf) {
248 ImageUser iuser = {nullptr};
249 iuser.scene = scene;
250 BKE_image_signal(bmain, ima, &iuser, IMA_SIGNAL_FREE);
251 }
252
253 BKE_image_release_ibuf(ima, ibuf, lock);
255}
256
257static void rna_ImageUser_update(Main *bmain, Scene *scene, PointerRNA *ptr)
258{
259 ImageUser *iuser = static_cast<ImageUser *>(ptr->data);
260 ID *id = ptr->owner_id;
261
262 if (scene != nullptr) {
263 BKE_image_user_frame_calc(nullptr, iuser, scene->r.cfra);
264 }
265
266 if (id) {
267 if (GS(id->name) == ID_NT) {
268 /* Special update for node-trees. */
269 BKE_ntree_update_tag_image_user_changed(id_cast<bNodeTree *>(id), iuser);
271 }
272 else {
273 /* Update material or texture for render preview. */
274 DEG_id_tag_update(id, 0);
276 }
277 }
278}
279
280static void rna_ImageUser_relations_update(Main *bmain, Scene *scene, PointerRNA *ptr)
281{
282 rna_ImageUser_update(bmain, scene, ptr);
284}
285
286static std::optional<std::string> rna_ImageUser_path(const PointerRNA *ptr)
287{
288 if (ptr->owner_id) {
289 switch (GS(ptr->owner_id->name)) {
290 case ID_OB:
291 case ID_TE:
292 return "image_user";
293 case ID_NT:
294 return rna_Node_ImageUser_path(ptr);
295 case ID_CA:
297 case ID_SCR: {
298 const bScreen *screen = reinterpret_cast<bScreen *>(ptr->owner_id);
299 const ImageUser *iuser = static_cast<ImageUser *>(ptr->data);
300
301 for (const auto [area_index, area] : screen->areabase.enumerate()) {
302 for (const auto [space_index, sl] : area.spacedata.enumerate()) {
303 if (sl.spacetype == SPACE_IMAGE) {
304 const SpaceImage *sima = reinterpret_cast<const SpaceImage *>(&sl);
305 if (&sima->iuser == iuser) {
306 return fmt::format("areas[{}].spaces[{}].image_user", area_index, space_index);
307 }
308 }
309 }
310 }
311 return " ... image_user";
312 }
313 default:
314 break;
315 }
316 }
317
318 return "";
319}
320
321static void rna_Image_gpu_texture_update(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
322{
323 Image *ima = id_cast<Image *>(ptr->owner_id);
324
326
328}
329
330static const EnumPropertyItem *rna_Image_source_itemf(bContext * /*C*/,
331 PointerRNA *ptr,
332 PropertyRNA * /*prop*/,
333 bool *r_free)
334{
335 Image *ima = static_cast<Image *>(ptr->data);
336 EnumPropertyItem *item = nullptr;
337 int totitem = 0;
338
339 if (ima->source == IMA_SRC_VIEWER) {
341 }
342 else {
348 }
349
350 RNA_enum_item_end(&item, &totitem);
351 *r_free = true;
352
353 return item;
354}
355
356static int rna_Image_file_format_get(PointerRNA *ptr)
357{
358 Image *image = static_cast<Image *>(ptr->data);
359 ImBuf *ibuf = BKE_image_acquire_ibuf(image, nullptr, nullptr);
360 int imtype = BKE_ftype_to_imtype(ibuf ? ibuf->ftype : IMB_FTYPE_NONE,
361 ibuf ? &ibuf->foptions : nullptr);
362
363 BKE_image_release_ibuf(image, ibuf, nullptr);
364
365 return imtype;
366}
367
368static void rna_Image_file_format_set(PointerRNA *ptr, int value)
369{
370 Image *image = static_cast<Image *>(ptr->data);
371 if (BKE_imtype_is_movie(value) == 0) { /* should be able to throw an error here */
375 }
376}
377
378static void rna_UDIMTile_size_get(PointerRNA *ptr, int *values)
379{
380 ImageTile *tile = static_cast<ImageTile *>(ptr->data);
381 Image *image = id_cast<Image *>(ptr->owner_id);
382
383 ImageUser image_user;
384 BKE_imageuser_default(&image_user);
385 image_user.tile = tile->tile_number;
386
387 void *lock;
388 ImBuf *ibuf = BKE_image_acquire_ibuf(image, &image_user, &lock);
389 if (ibuf) {
390 values[0] = ibuf->x;
391 values[1] = ibuf->y;
392 }
393 else {
394 values[0] = 0;
395 values[1] = 0;
396 }
397
399}
400
401static int rna_UDIMTile_channels_get(PointerRNA *ptr)
402{
403 ImageTile *tile = static_cast<ImageTile *>(ptr->data);
404 Image *image = id_cast<Image *>(ptr->owner_id);
405
406 ImageUser image_user;
407 BKE_imageuser_default(&image_user);
408 image_user.tile = tile->tile_number;
409
410 int channels = 0;
411
412 void *lock;
413 ImBuf *ibuf = BKE_image_acquire_ibuf(image, &image_user, &lock);
414 if (ibuf) {
415 channels = ibuf->channels;
416 }
417
419
420 return channels;
421}
422
423static void rna_UDIMTile_label_get(PointerRNA *ptr, char *value)
424{
425 const ImageTile *tile = static_cast<ImageTile *>(ptr->data);
426 const Image *image = id_cast<Image *>(ptr->owner_id);
427
428 /* Pass in a fixed size buffer as the value may be allocated based on the callbacks length. */
429 char value_buf[sizeof(tile->label)];
430 int len = BKE_image_get_tile_label(image, tile, value_buf, sizeof(tile->label));
431 memcpy(value, value_buf, len + 1);
432}
433
434static int rna_UDIMTile_label_length(PointerRNA *ptr)
435{
436 const ImageTile *tile = static_cast<ImageTile *>(ptr->data);
437 const Image *image = id_cast<Image *>(ptr->owner_id);
438
439 char label[sizeof(tile->label)];
440 return BKE_image_get_tile_label(image, tile, label, sizeof(label));
441}
442
443static void rna_UDIMTile_tile_number_set(PointerRNA *ptr, int value)
444{
445 ImageTile *tile = static_cast<ImageTile *>(ptr->data);
446 Image *image = id_cast<Image *>(ptr->owner_id);
447
448 /* Check that no other tile already has that number. */
449 ImageTile *cur_tile = BKE_image_get_tile(image, value);
450 if (cur_tile == nullptr) {
452 }
453}
454
455static void rna_UDIMTile_generated_update(Main * /*bmain*/, Scene * /*scene*/, PointerRNA *ptr)
456{
457 Image *ima = id_cast<Image *>(ptr->owner_id);
458 ImageTile *tile = static_cast<ImageTile *>(ptr->data);
459
460 /* If the tile is still marked as generated, then update the tile as requested. */
461 if ((tile->gen_flag & IMA_GEN_TILE) != 0) {
463 }
464}
465
466static int rna_Image_active_tile_index_get(PointerRNA *ptr)
467{
468 Image *image = static_cast<Image *>(ptr->data);
469 return image->active_tile_index;
470}
471
472static void rna_Image_active_tile_index_set(PointerRNA *ptr, int value)
473{
474 Image *image = static_cast<Image *>(ptr->data);
475 int num_tiles = image->tiles.count();
476
477 image->active_tile_index = min_ii(value, num_tiles - 1);
478}
479
480static void rna_Image_active_tile_index_range(
481 PointerRNA *ptr, int *min, int *max, int * /*softmin*/, int * /*softmax*/)
482{
483 Image *image = static_cast<Image *>(ptr->data);
484 int num_tiles = image->tiles.count();
485
486 *min = 0;
487 *max = max_ii(0, num_tiles - 1);
488}
489
490static PointerRNA rna_Image_active_tile_get(PointerRNA *ptr)
491{
492 Image *image = static_cast<Image *>(ptr->data);
493 ImageTile *tile = static_cast<ImageTile *>(
494 BLI_findlink(&image->tiles, image->active_tile_index));
495
496 return RNA_pointer_create_with_parent(*ptr, RNA_UDIMTile, tile);
497}
498
499static void rna_Image_active_tile_set(PointerRNA *ptr, PointerRNA value, ReportList * /*reports*/)
500{
501 Image *image = static_cast<Image *>(ptr->data);
502 ImageTile *tile = static_cast<ImageTile *>(value.data);
503 const int index = BLI_findindex(&image->tiles, tile);
504 if (index != -1) {
505 image->active_tile_index = index;
506 }
507}
508
509static bool rna_Image_has_data_get(PointerRNA *ptr)
510{
511 Image *image = static_cast<Image *>(ptr->data);
512
514}
515
516static void rna_Image_size_get(PointerRNA *ptr, int *values)
517{
518 Image *im = static_cast<Image *>(ptr->data);
519 ImBuf *ibuf;
520 void *lock;
521
522 ibuf = BKE_image_acquire_ibuf(im, nullptr, &lock);
523 if (ibuf) {
524 values[0] = ibuf->x;
525 values[1] = ibuf->y;
526 }
527 else {
528 values[0] = 0;
529 values[1] = 0;
530 }
531
532 BKE_image_release_ibuf(im, ibuf, lock);
533}
534
535static void rna_Image_resolution_get(PointerRNA *ptr, float *values)
536{
537 Image *im = static_cast<Image *>(ptr->data);
538 ImBuf *ibuf;
539 void *lock;
540
541 ibuf = BKE_image_acquire_ibuf(im, nullptr, &lock);
542 if (ibuf) {
543 values[0] = ibuf->ppm[0];
544 values[1] = ibuf->ppm[1];
545 }
546 else {
547 values[0] = 0;
548 values[1] = 0;
549 }
550
551 BKE_image_release_ibuf(im, ibuf, lock);
552}
553
554static void rna_Image_resolution_set(PointerRNA *ptr, const float *values)
555{
556 Image *im = static_cast<Image *>(ptr->data);
557 ImBuf *ibuf;
558 void *lock;
559
560 ibuf = BKE_image_acquire_ibuf(im, nullptr, &lock);
561 if (ibuf) {
562 ibuf->ppm[0] = values[0];
563 ibuf->ppm[1] = values[1];
564 }
565
566 BKE_image_release_ibuf(im, ibuf, lock);
567}
568
569static int rna_Image_depth_get(PointerRNA *ptr)
570{
571 Image *im = static_cast<Image *>(ptr->data);
572 void *lock;
573 ImBuf *ibuf = BKE_image_acquire_ibuf(im, nullptr, &lock);
574
575 int depth = 0;
576 if (!ibuf) {
577 depth = 0;
578 }
579 else if (ibuf->float_data()) {
580 depth = ibuf->color_mode_channels_get() * 8 * 4;
581 }
582 else {
583 depth = ibuf->color_mode_channels_get() * 8;
584 }
585
586 BKE_image_release_ibuf(im, ibuf, lock);
587
588 return depth;
589}
590
591static int rna_Image_frame_duration_get(PointerRNA *ptr)
592{
593 Image *ima = id_cast<Image *>(ptr->owner_id);
594 int duration = 1;
595
596 if (!BKE_image_has_anim(ima)) {
597 /* Ensure image has been loaded into memory and frame duration is known. */
598 void *lock;
599 ImBuf *ibuf = BKE_image_acquire_ibuf(ima, nullptr, &lock);
600 BKE_image_release_ibuf(ima, ibuf, lock);
601 }
602
603 if (BKE_image_has_anim(ima)) {
604 MovieReader *anim = (ima->anims.first())->anim;
605 if (anim) {
606 duration = MOV_get_duration_frames(anim);
607 }
608 }
609
610 return duration;
611}
612
613static int rna_Image_pixels_get_length(const PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION])
614{
615 Image *ima = id_cast<Image *>(ptr->owner_id);
616 ImBuf *ibuf;
617 void *lock;
618
619 ibuf = BKE_image_acquire_ibuf(ima, nullptr, &lock);
620
621 if (ibuf) {
622 length[0] = IMB_get_pixel_count(ibuf) * size_t(ibuf->channels);
623 }
624 else {
625 length[0] = 0;
626 }
627
628 BKE_image_release_ibuf(ima, ibuf, lock);
629
630 return length[0];
631}
632
633static void rna_Image_pixels_get(PointerRNA *ptr, float *values)
634{
635 Image *ima = id_cast<Image *>(ptr->owner_id);
636 ImBuf *ibuf;
637 void *lock;
638
639 ibuf = BKE_image_acquire_ibuf(ima, nullptr, &lock);
640
641 if (ibuf) {
642 const size_t size = IMB_get_pixel_count(ibuf) * size_t(ibuf->channels);
643
644 if (ibuf->float_data()) {
645 memcpy(values, ibuf->float_data(), sizeof(float) * size);
646 }
647 else {
648 const uchar *byte_data = ibuf->byte_data();
649 for (size_t i = 0; i < size; i++) {
650 values[i] = byte_data[i] * (1.0f / 255.0f);
651 }
652 }
653 }
654
655 BKE_image_release_ibuf(ima, ibuf, lock);
656}
657
658static void rna_Image_pixels_set(PointerRNA *ptr, const float *values)
659{
660 Image *ima = id_cast<Image *>(ptr->owner_id);
661 ImBuf *ibuf;
662 void *lock;
663
664 ibuf = BKE_image_acquire_ibuf(ima, nullptr, &lock);
665
666 if (ibuf) {
667 const size_t size = IMB_get_pixel_count(ibuf) * size_t(ibuf->channels);
668
669 if (float *float_data = ibuf->float_data_for_write()) {
670 memcpy(float_data, values, sizeof(float) * size);
671 }
672 else {
673 uchar *byte_data = ibuf->byte_data_for_write();
674 for (size_t i = 0; i < size; i++) {
675 byte_data[i] = unit_float_to_uchar_clamp(values[i]);
676 }
677 }
678
679 /* NOTE: Do update from the set() because typically pixels.foreach_set() is used to update
680 * the values, and it does not invoke the update(). */
681
683 IMB_mark_dirty(ibuf);
685 }
686
687 BKE_image_release_ibuf(ima, ibuf, lock);
688}
689
690static int rna_Image_channels_get(PointerRNA *ptr)
691{
692 Image *im = static_cast<Image *>(ptr->data);
693 ImBuf *ibuf;
694 void *lock;
695 int channels = 0;
696
697 ibuf = BKE_image_acquire_ibuf(im, nullptr, &lock);
698 if (ibuf) {
699 channels = ibuf->channels;
700 }
701
702 BKE_image_release_ibuf(im, ibuf, lock);
703
704 return channels;
705}
706
707static bool rna_Image_is_float_get(PointerRNA *ptr)
708{
709 Image *im = static_cast<Image *>(ptr->data);
710 ImBuf *ibuf;
711 void *lock;
712 bool is_float = false;
713
714 ibuf = BKE_image_acquire_ibuf(im, nullptr, &lock);
715 if (ibuf) {
716 is_float = ibuf->float_data() != nullptr;
717 }
718
719 BKE_image_release_ibuf(im, ibuf, lock);
720
721 return is_float;
722}
723
724static PointerRNA rna_Image_packed_file_get(PointerRNA *ptr)
725{
726 Image *ima = id_cast<Image *>(ptr->owner_id);
727
728 if (BKE_image_has_packedfile(ima)) {
729 ImagePackedFile *imapf = ima->packedfiles.first();
730 return RNA_pointer_create_with_parent(*ptr, RNA_PackedFile, imapf->packedfile);
731 }
732 return {};
733}
734
735static void rna_RenderSlot_clear(ID *id, RenderSlot *slot, ImageUser *iuser)
736{
737 Image *image = id_cast<Image *>(id);
738 int index = BLI_findindex(&image->renderslots, slot);
740
742}
743
744static PointerRNA rna_render_slots_active_get(PointerRNA *ptr)
745{
746 Image *image = id_cast<Image *>(ptr->owner_id);
747 RenderSlot *render_slot = BKE_image_get_renderslot(image, image->render_slot);
748
749 return RNA_pointer_create_with_parent(*ptr, RNA_RenderSlot, render_slot);
750}
751
752static void rna_render_slots_active_set(PointerRNA *ptr,
753 PointerRNA value,
754 ReportList * /*reports*/)
755{
756 Image *image = id_cast<Image *>(ptr->owner_id);
757 if (value.owner_id == &image->id) {
758 RenderSlot *slot = static_cast<RenderSlot *>(value.data);
759 int index = BLI_findindex(&image->renderslots, slot);
760 if (index != -1) {
761 image->render_slot = index;
762 }
763 }
764}
765
766static int rna_render_slots_active_index_get(PointerRNA *ptr)
767{
768 Image *image = id_cast<Image *>(ptr->owner_id);
769 return image->render_slot;
770}
771
772static void rna_render_slots_active_index_set(PointerRNA *ptr, int value)
773{
774 Image *image = id_cast<Image *>(ptr->owner_id);
775 int num_slots = image->renderslots.count();
776 image->render_slot = value;
777 CLAMP(image->render_slot, 0, num_slots - 1);
778}
779
780static void rna_render_slots_active_index_range(
781 PointerRNA *ptr, int *min, int *max, int * /*softmin*/, int * /*softmax*/)
782{
783 Image *image = id_cast<Image *>(ptr->owner_id);
784 *min = 0;
785 *max = max_ii(0, image->renderslots.count() - 1);
786}
787
788static ImageTile *rna_UDIMTile_new(Image *image, int tile_number, const char *label)
789{
790 ImageTile *tile = BKE_image_add_tile(image, tile_number, label);
791
793
794 return tile;
795}
796
797static void rna_UDIMTile_remove(Image *image, PointerRNA *ptr)
798{
799 ImageTile *tile = static_cast<ImageTile *>(ptr->data);
801
803}
804
805} // namespace blender
806
807#else
808
809namespace blender {
810
812{
813 StructRNA *srna;
814 PropertyRNA *prop;
815
816 srna = RNA_def_struct(brna, "ImageUser", nullptr);
818 srna,
819 "Image User",
820 "Parameters defining how an Image data-block is used by another data-block");
821 RNA_def_struct_path_func(srna, "rna_ImageUser_path");
822
824
825 prop = RNA_def_property(srna, "use_auto_refresh", PROP_BOOLEAN, PROP_NONE);
826 RNA_def_property_boolean_sdna(prop, nullptr, "flag", IMA_ANIM_ALWAYS);
827 RNA_def_property_ui_text(prop, "Auto Refresh", "Always refresh image on frame changes");
828 RNA_def_property_update(prop, 0, "rna_ImageUser_relations_update");
830
831 prop = RNA_def_property(srna, "frame_current", PROP_INT, PROP_TIME);
832 RNA_def_property_int_sdna(prop, nullptr, "framenr");
835 prop, "Current Frame", "Current frame number in image sequence or movie");
836
837 /* animation */
838 prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
839 RNA_def_property_boolean_sdna(prop, nullptr, "cycl", 0);
840 RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie");
841 RNA_def_property_update(prop, 0, "rna_ImageUser_update");
843
844 prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
845 RNA_def_property_int_sdna(prop, nullptr, "frames");
847 RNA_def_property_ui_text(prop, "Frames", "Number of images of a movie to use");
848 RNA_def_property_update(prop, 0, "rna_ImageUser_update");
850
851 prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
852 RNA_def_property_int_sdna(prop, nullptr, "offset");
854 prop, "Offset", "Offset the number of the frame to use in the animation");
855 RNA_def_property_update(prop, 0, "rna_ImageUser_update");
856
857 prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_TIME);
858 RNA_def_property_int_sdna(prop, nullptr, "sfra");
861 prop,
862 "Start Frame",
863 "Global starting frame of the movie/sequence, assuming first picture has a #1");
864 RNA_def_property_update(prop, 0, "rna_ImageUser_update");
866
867 prop = RNA_def_property(srna, "multilayer_layer", PROP_INT, PROP_UNSIGNED);
868 RNA_def_property_int_sdna(prop, nullptr, "layer");
869 RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
870 RNA_def_property_ui_text(prop, "Layer", "Layer in multilayer image");
871
872 prop = RNA_def_property(srna, "multilayer_pass", PROP_INT, PROP_UNSIGNED);
873 RNA_def_property_int_sdna(prop, nullptr, "pass");
874 RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
875 RNA_def_property_ui_text(prop, "Pass", "Pass in multilayer image");
876
877 prop = RNA_def_property(srna, "multilayer_view", PROP_INT, PROP_UNSIGNED);
878 RNA_def_property_int_sdna(prop, nullptr, "view");
879 RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_multi_cb */
880 RNA_def_property_ui_text(prop, "View", "View in multilayer image");
881
882 prop = RNA_def_property(srna, "tile", PROP_INT, PROP_UNSIGNED);
883 RNA_def_property_int_sdna(prop, nullptr, "tile");
885 RNA_def_property_ui_text(prop, "Tile", "Tile in tiled image");
886
888}
889
890/* image.packed_files */
892{
893 StructRNA *srna;
894 PropertyRNA *prop;
895
896 srna = RNA_def_struct(brna, "ImagePackedFile", nullptr);
897 RNA_def_struct_sdna(srna, "ImagePackedFile");
898
899 prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
900 RNA_def_property_pointer_sdna(prop, nullptr, "packedfile");
901 RNA_def_property_ui_text(prop, "Packed File", "");
903
904 prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
905 RNA_def_property_string_sdna(prop, nullptr, "filepath");
908
909 prop = RNA_def_property(srna, "view", PROP_INT, PROP_NONE);
910 RNA_def_property_int_sdna(prop, nullptr, "view");
911 RNA_def_property_ui_text(prop, "View Index", "");
913
914 prop = RNA_def_property(srna, "tile_number", PROP_INT, PROP_NONE);
915 RNA_def_property_int_sdna(prop, nullptr, "tile_number");
916 RNA_def_property_ui_text(prop, "Tile Number", "");
918
920}
921
923{
924 StructRNA *srna;
925 PropertyRNA *prop, *parm;
926 FunctionRNA *func;
927
928 srna = RNA_def_struct(brna, "RenderSlot", nullptr);
929 RNA_def_struct_ui_text(srna, "Render Slot", "Parameters defining the render slot");
930
931 prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
932 RNA_def_property_string_sdna(prop, nullptr, "name");
933 RNA_def_property_ui_text(prop, "Name", "Render slot name");
935
936 func = RNA_def_function(srna, "clear", "rna_RenderSlot_clear");
938 RNA_def_function_ui_description(func, "Clear the render slot");
939 parm = RNA_def_pointer(func, "iuser", "ImageUser", "ImageUser", "");
941}
942
944{
945 StructRNA *srna;
946 FunctionRNA *func;
947 PropertyRNA *prop, *parm;
948
949 RNA_def_property_srna(cprop, "RenderSlots");
950 srna = RNA_def_struct(brna, "RenderSlots", nullptr);
951 RNA_def_struct_sdna(srna, "Image");
952 RNA_def_struct_ui_text(srna, "Render Layers", "Collection of render layers");
953
954 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
955 RNA_def_property_int_sdna(prop, nullptr, "render_slot");
957 "rna_render_slots_active_index_get",
958 "rna_render_slots_active_index_set",
959 "rna_render_slots_active_index_range");
960 RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
962
963 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
964 RNA_def_property_struct_type(prop, "RenderSlot");
966 prop, "rna_render_slots_active_get", "rna_render_slots_active_set", nullptr, nullptr);
968 RNA_def_property_ui_text(prop, "Active", "Active render slot of the image");
970
971 func = RNA_def_function(srna, "new", "BKE_image_add_renderslot");
972 RNA_def_function_ui_description(func, "Add a render slot to the image");
973 parm = RNA_def_string(func, "name", nullptr, 0, "Name", "New name for the render slot");
974 parm = RNA_def_pointer(func, "result", "RenderSlot", "", "Newly created render layer");
976 RNA_def_function_return(func, parm);
977}
978
980{
981 StructRNA *srna;
982 PropertyRNA *prop;
983
984 srna = RNA_def_struct(brna, "UDIMTile", nullptr);
985 RNA_def_struct_sdna(srna, "ImageTile");
986 RNA_def_struct_ui_text(srna, "UDIM Tile", "Properties of the UDIM tile");
987
988 prop = RNA_def_property(srna, "label", PROP_STRING, PROP_NONE);
989 RNA_def_property_string_sdna(prop, nullptr, "label");
990 RNA_def_property_ui_text(prop, "Label", "Tile label");
992 prop, "rna_UDIMTile_label_get", "rna_UDIMTile_label_length", nullptr);
994
995 prop = RNA_def_property(srna, "number", PROP_INT, PROP_NONE);
996 RNA_def_property_int_sdna(prop, nullptr, "tile_number");
997 RNA_def_property_ui_text(prop, "Number", "Number of the position that this tile covers");
998 RNA_def_property_int_funcs(prop, nullptr, "rna_UDIMTile_tile_number_set", nullptr);
1000
1001 prop = RNA_def_int_vector(
1002 srna,
1003 "size",
1004 2,
1005 nullptr,
1006 0,
1007 0,
1008 "Size",
1009 "Width and height of the tile buffer in pixels, zero when image data cannot be loaded",
1010 0,
1011 0);
1013 RNA_def_property_int_funcs(prop, "rna_UDIMTile_size_get", nullptr, nullptr);
1015
1016 prop = RNA_def_property(srna, "channels", PROP_INT, PROP_UNSIGNED);
1017 RNA_def_property_int_funcs(prop, "rna_UDIMTile_channels_get", nullptr, nullptr);
1018 RNA_def_property_ui_text(prop, "Channels", "Number of channels in the tile pixels buffer");
1020
1021 /* Generated tile information. */
1022 prop = RNA_def_property(srna, "generated_type", PROP_ENUM, PROP_NONE);
1023 RNA_def_property_enum_sdna(prop, nullptr, "gen_type");
1025 RNA_def_property_ui_text(prop, "Generated Type", "Generated image type");
1026 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_UDIMTile_generated_update");
1028
1029 prop = RNA_def_property(srna, "generated_width", PROP_INT, PROP_PIXEL);
1030 RNA_def_property_int_sdna(prop, nullptr, "gen_x");
1032 RNA_def_property_range(prop, 1, 65536);
1033 RNA_def_property_ui_text(prop, "Generated Width", "Generated image width");
1034 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_UDIMTile_generated_update");
1036
1037 prop = RNA_def_property(srna, "generated_height", PROP_INT, PROP_PIXEL);
1038 RNA_def_property_int_sdna(prop, nullptr, "gen_y");
1040 RNA_def_property_range(prop, 1, 65536);
1041 RNA_def_property_ui_text(prop, "Generated Height", "Generated image height");
1042 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_UDIMTile_generated_update");
1044
1045 prop = RNA_def_property(srna, "use_generated_float", PROP_BOOLEAN, PROP_NONE);
1046 RNA_def_property_boolean_sdna(prop, nullptr, "gen_flag", IMA_GEN_FLOAT);
1047 RNA_def_property_ui_text(prop, "Float Buffer", "Generate floating-point buffer");
1048 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_UDIMTile_generated_update");
1050
1051 prop = RNA_def_property(srna, "is_generated_tile", PROP_BOOLEAN, PROP_NONE);
1052 RNA_def_property_boolean_sdna(prop, nullptr, "gen_flag", IMA_GEN_TILE);
1053 RNA_def_property_ui_text(prop, "Is Generated Tile", "Is this image tile generated");
1055
1056 prop = RNA_def_property(srna, "generated_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1057 RNA_def_property_float_sdna(prop, nullptr, "gen_color");
1058 RNA_def_property_array(prop, 4);
1059 RNA_def_property_ui_text(prop, "Color", "Fill color for the generated image");
1060 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_UDIMTile_generated_update");
1062}
1063
1065{
1066 StructRNA *srna;
1067 PropertyRNA *prop;
1068
1069 FunctionRNA *func;
1070 PropertyRNA *parm;
1071
1072 RNA_def_property_srna(cprop, "UDIMTiles");
1073 srna = RNA_def_struct(brna, "UDIMTiles", nullptr);
1074 RNA_def_struct_sdna(srna, "Image");
1075 RNA_def_struct_ui_text(srna, "UDIM Tiles", "Collection of UDIM tiles");
1076
1077 prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
1078 RNA_def_property_int_sdna(prop, nullptr, "active_tile_index");
1080 "rna_Image_active_tile_index_get",
1081 "rna_Image_active_tile_index_set",
1082 "rna_Image_active_tile_index_range");
1083 RNA_def_property_ui_text(prop, "Active Tile Index", "Active index in tiles array");
1084
1085 prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1086 RNA_def_property_struct_type(prop, "UDIMTile");
1088 prop, "rna_Image_active_tile_get", "rna_Image_active_tile_set", nullptr, nullptr);
1090 RNA_def_property_ui_text(prop, "Active Image Tile", "Active Image Tile");
1091
1092 func = RNA_def_function(srna, "new", "rna_UDIMTile_new");
1093 RNA_def_function_ui_description(func, "Add a tile to the image");
1094 parm = RNA_def_int(
1095 func, "tile_number", 1, 1, INT_MAX, "", "Number of the newly created tile", 1, 100);
1097 parm = RNA_def_string(func, "label", nullptr, 0, "", "Optional label for the tile");
1098 parm = RNA_def_pointer(func, "result", "UDIMTile", "", "Newly created image tile");
1099 RNA_def_function_return(func, parm);
1100
1101 func = RNA_def_function(srna, "get", "BKE_image_get_tile");
1102 RNA_def_function_ui_description(func, "Get a tile based on its tile number");
1103 parm = RNA_def_int(func, "tile_number", 0, 0, INT_MAX, "", "Number of the tile", 0, 100);
1105 parm = RNA_def_pointer(func, "result", "UDIMTile", "", "The tile");
1106 RNA_def_function_return(func, parm);
1107
1108 func = RNA_def_function(srna, "remove", "rna_UDIMTile_remove");
1109 RNA_def_function_ui_description(func, "Remove an image tile");
1110 parm = RNA_def_pointer(func, "tile", "UDIMTile", "", "Image tile to remove");
1113}
1114
1115static void rna_def_image(BlenderRNA *brna)
1116{
1117 StructRNA *srna;
1118 PropertyRNA *prop;
1119 static const EnumPropertyItem prop_type_items[] = {
1120 {IMA_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
1121 {IMA_TYPE_MULTILAYER, "MULTILAYER", 0, "Multilayer", ""},
1122 {IMA_TYPE_UV_TEST, "UV_TEST", 0, "UV Test", ""},
1123 {IMA_TYPE_R_RESULT, "RENDER_RESULT", 0, "Render Result", ""},
1124 {IMA_TYPE_COMPOSITE, "COMPOSITING", 0, "Compositing", ""},
1125 {0, nullptr, 0, nullptr, nullptr},
1126 };
1127 static const EnumPropertyItem alpha_mode_items[] = {
1129 "STRAIGHT",
1130 0,
1131 "Straight",
1132 "Store RGB and alpha channels separately with alpha acting as a mask, also known as "
1133 "unassociated alpha. Commonly used by image editing applications and file formats like "
1134 "PNG."},
1136 "PREMUL",
1137 0,
1138 "Premultiplied",
1139 "Store RGB channels with alpha multiplied in, also known as associated alpha. The natural "
1140 "format for renders and used by file formats like OpenEXR."},
1142 "CHANNEL_PACKED",
1143 0,
1144 "Channel Packed",
1145 "Different images are packed in the RGB and alpha channels, and they should not "
1146 "affect each other. Channel packing is commonly used by game engines to save memory."},
1148 "NONE",
1149 0,
1150 "None",
1151 "Ignore alpha channel from the file and make image fully opaque"},
1152 {0, nullptr, 0, nullptr, nullptr},
1153 };
1154
1155 srna = RNA_def_struct(brna, "Image", "ID");
1157 srna, "Image", "Image data-block referencing an external or packed image");
1158 RNA_def_struct_ui_icon(srna, ICON_IMAGE_DATA);
1159
1160 prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
1162 RNA_def_property_string_sdna(prop, nullptr, "filepath");
1164 RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name");
1165 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
1166
1167 /* eek. this is horrible but needed so we can save to a new name without blanking the data :( */
1168 prop = RNA_def_property(srna, "filepath_raw", PROP_STRING, PROP_FILEPATH);
1169 RNA_def_property_string_sdna(prop, nullptr, "filepath");
1171 RNA_def_property_ui_text(prop, "File Name", "Image/Movie file name (without data refreshing)");
1172
1173 prop = RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
1176 prop, "rna_Image_file_format_get", "rna_Image_file_format_set", nullptr);
1177 RNA_def_property_ui_text(prop, "File Format", "Format used for re-saving this file");
1178
1179 prop = RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
1182 RNA_def_property_enum_funcs(prop, nullptr, "rna_Image_source_set", "rna_Image_source_itemf");
1183 RNA_def_property_ui_text(prop, "Source", "Where the image comes from");
1185
1186 prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1187 RNA_def_property_enum_items(prop, prop_type_items);
1189 RNA_def_property_ui_text(prop, "Type", "How to generate the image");
1191
1192 prop = RNA_def_property(srna, "packed_file", PROP_POINTER, PROP_NONE);
1193 RNA_def_property_struct_type(prop, "PackedFile");
1194 RNA_def_property_pointer_sdna(prop, nullptr, "packedfile");
1195 RNA_def_property_pointer_funcs(prop, "rna_Image_packed_file_get", nullptr, nullptr, nullptr);
1196 RNA_def_property_ui_text(prop, "Packed File", "First packed file of the image");
1197
1198 prop = RNA_def_property(srna, "packed_files", PROP_COLLECTION, PROP_NONE);
1199 RNA_def_property_collection_sdna(prop, nullptr, "packedfiles", nullptr);
1200 RNA_def_property_struct_type(prop, "ImagePackedFile");
1202 RNA_def_property_ui_text(prop, "Packed Files", "Collection of packed images");
1203
1204 prop = RNA_def_property(srna, "use_view_as_render", PROP_BOOLEAN, PROP_NONE);
1206 RNA_def_property_boolean_sdna(prop, nullptr, "flag", IMA_VIEW_AS_RENDER);
1208 prop,
1209 "View as Render",
1210 "Apply render part of display transformation when displaying this image on the screen");
1212
1213 prop = RNA_def_property(srna, "use_deinterlace", PROP_BOOLEAN, PROP_NONE);
1215 RNA_def_property_boolean_sdna(prop, nullptr, "flag", IMA_DEINTERLACE);
1216 RNA_def_property_ui_text(prop, "Deinterlace", "Deinterlace movie file on load");
1217 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_reload_update");
1218
1219 prop = RNA_def_property(srna, "use_multiview", PROP_BOOLEAN, PROP_NONE);
1221 RNA_def_property_boolean_sdna(prop, nullptr, "flag", IMA_USE_VIEWS);
1222 RNA_def_property_ui_text(prop, "Use Multi-View", "Use Multiple Views (when available)");
1223 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
1224
1225 prop = RNA_def_property(srna, "is_stereo_3d", PROP_BOOLEAN, PROP_NONE);
1227 RNA_def_property_boolean_funcs(prop, "rna_Image_is_stereo_3d_get", nullptr);
1228 RNA_def_property_ui_text(prop, "Stereo 3D", "Image has left and right views");
1230
1231 prop = RNA_def_property(srna, "is_multiview", PROP_BOOLEAN, PROP_NONE);
1233 RNA_def_property_boolean_funcs(prop, "rna_Image_is_multiview_get", nullptr);
1234 RNA_def_property_ui_text(prop, "Multiple Views", "Image has more than one view");
1236
1237 prop = RNA_def_property(srna, "is_dirty", PROP_BOOLEAN, PROP_NONE);
1239 RNA_def_property_boolean_funcs(prop, "rna_Image_dirty_get", nullptr);
1241 RNA_def_property_ui_text(prop, "Dirty", "Image has changed and is not saved");
1242
1243 /* generated image (image_generated_change_cb) */
1244 prop = RNA_def_property(srna, "generated_type", PROP_ENUM, PROP_NONE);
1245 RNA_def_property_enum_sdna(prop, nullptr, "gen_type");
1247 RNA_def_property_ui_text(prop, "Generated Type", "Generated image type");
1249 prop, "rna_Image_generated_type_get", "rna_Image_generated_type_set", nullptr);
1250 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1252
1253 prop = RNA_def_property(srna, "generated_width", PROP_INT, PROP_PIXEL);
1254 RNA_def_property_int_sdna(prop, nullptr, "gen_x");
1256 RNA_def_property_range(prop, 1, 65536);
1257 RNA_def_property_ui_text(prop, "Generated Width", "Generated image width");
1259 prop, "rna_Image_generated_width_get", "rna_Image_generated_width_set", nullptr);
1260 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1262
1263 prop = RNA_def_property(srna, "generated_height", PROP_INT, PROP_PIXEL);
1264 RNA_def_property_int_sdna(prop, nullptr, "gen_y");
1266 RNA_def_property_range(prop, 1, 65536);
1267 RNA_def_property_ui_text(prop, "Generated Height", "Generated image height");
1269 prop, "rna_Image_generated_height_get", "rna_Image_generated_height_set", nullptr);
1270 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1272
1273 prop = RNA_def_property(srna, "use_generated_float", PROP_BOOLEAN, PROP_NONE);
1274 RNA_def_property_boolean_sdna(prop, nullptr, "gen_flag", IMA_GEN_FLOAT);
1275 RNA_def_property_ui_text(prop, "Float Buffer", "Generate floating-point buffer");
1277 prop, "rna_Image_generated_float_get", "rna_Image_generated_float_set");
1278 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1280
1281 prop = RNA_def_property(srna, "generated_color", PROP_FLOAT, PROP_COLOR_GAMMA);
1282 RNA_def_property_float_sdna(prop, nullptr, "gen_color");
1283 RNA_def_property_array(prop, 4);
1284 RNA_def_property_ui_text(prop, "Color", "Fill color for the generated image");
1286 prop, "rna_Image_generated_color_get", "rna_Image_generated_color_set", nullptr);
1287 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_generated_update");
1289
1290 prop = RNA_def_property(srna, "display_aspect", PROP_FLOAT, PROP_XYZ);
1292 RNA_def_property_float_sdna(prop, nullptr, "aspx");
1293 RNA_def_property_array(prop, 2);
1294 RNA_def_property_range(prop, 0.1f, FLT_MAX);
1295 RNA_def_property_ui_range(prop, 0.1f, 5000.0f, 1, 2);
1297 prop, "Display Aspect", "Display Aspect for this image, does not affect rendering");
1299
1300 prop = RNA_def_property(srna, "render_slots", PROP_COLLECTION, PROP_NONE);
1301 RNA_def_property_struct_type(prop, "RenderSlot");
1302 RNA_def_property_collection_sdna(prop, nullptr, "renderslots", nullptr);
1303 RNA_def_property_ui_text(prop, "Render Slots", "Render slots of the image");
1304 rna_def_render_slots(brna, prop);
1305
1306 prop = RNA_def_property(srna, "tiles", PROP_COLLECTION, PROP_NONE);
1307 RNA_def_property_struct_type(prop, "UDIMTile");
1308 RNA_def_property_collection_sdna(prop, nullptr, "tiles", nullptr);
1309 RNA_def_property_ui_text(prop, "Image Tiles", "Tiles of the image");
1310 rna_def_udim_tiles(brna, prop);
1311
1312 prop = RNA_def_property(srna, "has_data", PROP_BOOLEAN, PROP_NONE);
1313 RNA_def_property_boolean_funcs(prop, "rna_Image_has_data_get", nullptr);
1315 RNA_def_property_ui_text(prop, "Has Data", "True if the image data is loaded into memory");
1316
1317 prop = RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
1318 RNA_def_property_int_funcs(prop, "rna_Image_depth_get", nullptr, nullptr);
1319 RNA_def_property_ui_text(prop, "Depth", "Image bit depth");
1321
1322 prop = RNA_def_int_vector(
1323 srna,
1324 "size",
1325 2,
1326 nullptr,
1327 0,
1328 0,
1329 "Size",
1330 "Width and height of the image buffer in pixels, zero when image data cannot be loaded",
1331 0,
1332 0);
1334 RNA_def_property_int_funcs(prop, "rna_Image_size_get", nullptr, nullptr);
1336
1337 prop = RNA_def_float_vector(srna,
1338 "resolution",
1339 2,
1340 nullptr,
1341 0,
1342 0,
1343 "Resolution",
1344 "X/Y pixels per meter, for the image buffer",
1345 0,
1346 0);
1349 prop, "rna_Image_resolution_get", "rna_Image_resolution_set", nullptr);
1350
1351 prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_UNSIGNED);
1352 RNA_def_property_int_funcs(prop, "rna_Image_frame_duration_get", nullptr, nullptr);
1354 prop, "Duration", "Duration (in frames) of the image (1 when not a video/sequence)");
1356
1357 /* NOTE: About pixels/channels/is_float:
1358 * These properties describe how the image is stored internally (inside of ImBuf),
1359 * not how it was saved to disk or how it'll be saved on disk.
1360 */
1361 prop = RNA_def_property(srna, "pixels", PROP_FLOAT, PROP_NONE);
1363 RNA_def_property_multi_array(prop, 1, nullptr);
1364 RNA_def_property_ui_text(prop, "Pixels", "Image buffer pixels in floating-point values");
1365 RNA_def_property_dynamic_array_funcs(prop, "rna_Image_pixels_get_length");
1366 RNA_def_property_float_funcs(prop, "rna_Image_pixels_get", "rna_Image_pixels_set", nullptr);
1367
1368 prop = RNA_def_property(srna, "channels", PROP_INT, PROP_UNSIGNED);
1369 RNA_def_property_int_funcs(prop, "rna_Image_channels_get", nullptr, nullptr);
1370 RNA_def_property_ui_text(prop, "Channels", "Number of channels in pixels buffer");
1372
1373 prop = RNA_def_property(srna, "is_float", PROP_BOOLEAN, PROP_NONE);
1374 RNA_def_property_boolean_funcs(prop, "rna_Image_is_float_get", nullptr);
1377 prop, "Is Float", "True if this image is stored in floating-point buffer");
1378
1379 prop = RNA_def_property(srna, "colorspace_settings", PROP_POINTER, PROP_NONE);
1380 RNA_def_property_pointer_sdna(prop, nullptr, "colorspace_settings");
1381 RNA_def_property_struct_type(prop, "ColorManagedInputColorspaceSettings");
1382 RNA_def_property_ui_text(prop, "Color Space Settings", "Input color space settings");
1383
1384 prop = RNA_def_property(srna, "alpha_mode", PROP_ENUM, PROP_NONE);
1386 RNA_def_property_enum_items(prop, alpha_mode_items);
1388 "Alpha Mode",
1389 "Representation of alpha in the image file, to convert to and from "
1390 "when saving and loading the image");
1391 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_alpha_mode_update");
1392
1393 prop = RNA_def_property(srna, "use_half_precision", PROP_BOOLEAN, PROP_NONE);
1396 "Half Float Precision",
1397 "Use 16 bits per channel to lower the memory usage during rendering."
1398 "\nNote: Not supported by Cycles");
1399 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_gpu_texture_update");
1400
1401 prop = RNA_def_property(srna, "seam_margin", PROP_INT, PROP_NONE);
1403 prop,
1404 "Seam Margin",
1405 "Margin to take into account when fixing UV seams during painting. Higher "
1406 "number would improve seam-fixes for mipmaps, but decreases performance.");
1407 RNA_def_property_ui_range(prop, 1, 100, 1, 1);
1408
1409 /* multiview */
1410 prop = RNA_def_property(srna, "views_format", PROP_ENUM, PROP_NONE);
1412 RNA_def_property_enum_sdna(prop, nullptr, "views_format");
1414 RNA_def_property_ui_text(prop, "Views Format", "Mode to load image views");
1415 RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, "rna_Image_views_format_update");
1416
1417 prop = RNA_def_property(srna, "stereo_3d_format", PROP_POINTER, PROP_NONE);
1418 RNA_def_property_pointer_sdna(prop, nullptr, "stereo3d_format");
1420 RNA_def_property_struct_type(prop, "Stereo3dFormat");
1421 RNA_def_property_ui_text(prop, "Stereo 3D Format", "Settings for stereo 3d");
1422
1423 RNA_api_image(srna);
1424}
1425
1427{
1428 rna_def_render_slot(brna);
1429 rna_def_udim_tile(brna);
1430 rna_def_image(brna);
1431 rna_def_imageuser(brna);
1433}
1434
1435} // namespace blender
1436
1437#endif
#define G_MAIN
#define IMA_SIGNAL_COLORMANAGE
Definition BKE_image.hh:184
#define IMA_SIGNAL_FREE
Definition BKE_image.hh:179
#define IMA_SIGNAL_SRC_CHANGE
Definition BKE_image.hh:181
#define IMA_SIGNAL_RELOAD
Definition BKE_image.hh:178
#define BLT_I18NCONTEXT_ID_IMAGE
#define MINAFRAME
#define MAXFRAMEF
#define MINAFRAMEF
#define MAXFRAME
#define RNA_MAX_ARRAY_DIMENSION
Definition RNA_define.hh:29
#define ND_DRAW
Definition WM_types.hh:502
#define ND_DISPLAY
Definition WM_types.hh:534
#define NA_EDITED
Definition WM_types.hh:634
#define NC_IMAGE
Definition WM_types.hh:397
volatile int lock
#define CLAMP(a, b, c)
btScalar max
SIMD_FORCE_INLINE btScalar length() const
Return the length of the vector.
Definition btVector3.h:257
CCL_NAMESPACE_BEGIN struct Options options
#define FLT_MAX
#define INT_MAX
ccl_gpu_kernel_postfix ccl_global KernelWorkTile const int num_tiles
const ccl_global KernelWorkTile * tile
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
int size(const AssetLibraryReference *library_reference)
BMesh Iterators.
bool BKE_image_is_multiview(const Image *ima)
void WM_main_add_notifier(uint type, void *reference)
void BKE_image_user_frame_calc(Image *ima, ImageUser *iuser, int cfra)
void RNA_def_property_srna(PropertyRNA *prop, const char *type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_def_struct_ui_text(StructRNA *srna, const char *name, const char *description)
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
void RNA_def_property_dynamic_array_funcs(PropertyRNA *prop, const char *getlength)
void RNA_def_struct_ui_icon(StructRNA *srna, int icon)
void RNA_def_property_string_sdna(PropertyRNA *prop, const char *structname, const char *propname)
MINLINE unsigned char unit_float_to_uchar_clamp(float val)
PropertyRNA * RNA_def_string(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value, const int maxlen, const char *ui_name, const char *ui_description)
@ IMA_TYPE_MULTILAYER
@ IMA_ALPHA_CHANNEL_PACKED
void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
bool BKE_image_clear_renderslot(Image *ima, ImageUser *iuser, int slot)
unsigned int uint
Definition BKE_text.h:55
void RNA_api_image_packed_file(StructRNA *srna)
void RNA_def_property_float_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void RNA_def_property_pointer_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_def_property_pointer_funcs(PropertyRNA *prop, const char *get, const char *set, const char *type_fn, const char *poll)
void RNA_def_property_collection_sdna(PropertyRNA *prop, const char *structname, const char *propname, const char *lengthpropname)
void BKE_image_signal(Main *bmain, Image *ima, ImageUser *iuser, int signal)
size_t IMB_get_pixel_count(const ImBuf *ibuf)
Get the length of the data of the given image buffer in pixels.
bool BKE_image_has_loaded_ibuf(Image *image)
void RNA_def_property_boolean_funcs(PropertyRNA *prop, const char *get, const char *set)
void RNA_def_property_multi_array(PropertyRNA *prop, int dimension, const int length[])
void BKE_image_free_gpu_texture_caches(Image *ima)
Definition image_gpu.cc:818
void RNA_def_function_ui_description(FunctionRNA *func, const char *description)
void IMB_mark_dirty(ImBuf *ibuf)
@ FUNC_USE_SELF_ID
Definition RNA_types.hh:980
bool BKE_image_fill_tile(Image *ima, ImageTile *tile)
void RNA_define_lib_overridable(const bool make_overridable)
ImageTile * BKE_image_get_tile(Image *ima, int tile_number)
PropertyRNA * RNA_def_int_vector(StructOrFunctionRNA *cont_, const char *identifier, const int len, const int *default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
eImbFileType BKE_imtype_to_ftype(char imtype, ImbFormatOptions *r_options)
PropertyRNA * RNA_def_pointer(StructOrFunctionRNA *cont_, const char *identifier, const char *type, const char *ui_name, const char *ui_description)
static void rna_def_image_packed_files(BlenderRNA *brna)
Definition rna_image.cc:891
void RNA_def_property_struct_type(PropertyRNA *prop, const char *type)
static const EnumPropertyItem image_source_items[]
Definition rna_image.cc:37
MINLINE int max_ii(int a, int b)
static void rna_def_render_slots(BlenderRNA *brna, PropertyRNA *cprop)
Definition rna_image.cc:943
ImageTile * BKE_image_add_tile(Image *ima, int tile_number, const char *label)
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
void RNA_def_property_float_sdna(PropertyRNA *prop, const char *structname, const char *propname)
PropertyRNA * RNA_def_float_vector(StructOrFunctionRNA *cont_, const char *identifier, const int len, const float *default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
@ PROPOVERRIDE_OVERRIDABLE_LIBRARY
Definition RNA_types.hh:588
@ IMA_GENTYPE_GRID_COLOR
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier_c_str, int type, int subtype)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
int BLI_findindex(const ListBase *listbase, const void *vlink) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:593
void RNA_def_struct_sdna(StructRNA *srna, const char *structname)
void RNA_def_parameter_clear_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
void RNA_def_property_enum_items(PropertyRNA *prop, const EnumPropertyItem *item)
bool BKE_image_remove_tile(Image *ima, ImageTile *tile)
const EnumPropertyItem rna_enum_image_type_all_items[]
Definition rna_scene.cc:398
unsigned char uchar
Definition BKE_text.h:58
@ PROP_BOOLEAN
Definition RNA_types.hh:210
@ PROP_POINTER
Definition RNA_types.hh:215
@ PROP_STRING
Definition RNA_types.hh:213
@ PROP_COLLECTION
Definition RNA_types.hh:216
void RNA_def_parameter_flags(PropertyRNA *prop, PropertyFlag flag_property, ParameterFlag flag_parameter)
bool BKE_image_is_stereo(const Image *ima)
void RNA_def_property_int_funcs(PropertyRNA *prop, const char *get, const char *set, const char *range)
void DEG_id_tag_update(ID *id, unsigned int flags)
void RNA_def_property_override_flag(PropertyRNA *prop, PropertyOverrideFlag flag)
void RNA_def_property_boolean_sdna(PropertyRNA *prop, const char *structname, const char *propname, int64_t booleanbit)
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
void BKE_main_ensure_invariants(Main &bmain, std::optional< Span< ID * > > modified_ids=std::nullopt)
void BKE_ntree_update_tag_image_user_changed(bNodeTree *ntree, ImageUser *iuser)
void RNA_def_struct_path_func(StructRNA *srna, const char *path)
bool rna_Image_no_renderresult_or_viewer_poll(PointerRNA *ptr, const PointerRNA value)
RenderSlot * BKE_image_get_renderslot(Image *ima, int index)
void RNA_def_property_subtype(PropertyRNA *prop, PropertySubType subtype)
void RNA_def_function_return(FunctionRNA *func, PropertyRNA *ret)
const EnumPropertyItem rna_enum_views_format_items[]
Definition rna_scene.cc:511
static void rna_def_udim_tile(BlenderRNA *brna)
Definition rna_image.cc:979
void RNA_enum_items_add_value(EnumPropertyItem **items, int *totitem, const EnumPropertyItem *item, int value)
void IMB_partial_update_mark_full(ImBuf *ibuf)
void RNA_enum_item_end(EnumPropertyItem **items, int *totitem)
void RNA_def_property_enum_funcs(PropertyRNA *prop, const char *get, const char *set, const char *item)
FunctionRNA * RNA_def_function(StructRNA *srna, const char *identifier_c_str, const char *call)
void RNA_def_property_enum_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_def_property_translation_context(PropertyRNA *prop, const char *context)
void RNA_def_property_clear_flag(PropertyRNA *prop, PropertyFlag flag)
bool BKE_imtype_is_movie(char imtype)
static void rna_def_imageuser(BlenderRNA *brna)
Definition rna_image.cc:811
ImBuf * BKE_image_acquire_ibuf(Image *ima, ImageUser *iuser, void **r_lock)
void RNA_def_function_flag(FunctionRNA *func, FunctionFlag flag)
char BKE_ftype_to_imtype(eImbFileType ftype, const ImbFormatOptions *options)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
static void rna_def_udim_tiles(BlenderRNA *brna, PropertyRNA *cprop)
void RNA_def_image(BlenderRNA *brna)
StructRNA * RNA_def_struct(BlenderRNA *brna, const char *identifier, const char *from)
int BKE_image_get_tile_label(const Image *ima, const ImageTile *tile, char *label, int label_maxncpy)
@ ID_RECALC_SOURCE
Definition DNA_ID.h:1143
@ ID_RECALC_EDITORS
Definition DNA_ID.h:1111
ID_Type GS(const char *name)
Definition DNA_ID.h:410
@ PROP_EDITABLE
Definition RNA_types.hh:376
@ PROP_PROPORTIONAL
Definition RNA_types.hh:419
@ PROP_DYNAMIC
Definition RNA_types.hh:498
@ PROP_THICK_WRAP
Definition RNA_types.hh:493
@ PROP_PATH_SUPPORTS_BLEND_RELATIVE
Definition RNA_types.hh:526
@ PROP_NEVER_NULL
Definition RNA_types.hh:447
@ PROP_ANIMATABLE
Definition RNA_types.hh:389
void RNA_def_property_int_sdna(PropertyRNA *prop, const char *structname, const char *propname)
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *func)
PointerRNA RNA_pointer_create_with_parent(const PointerRNA &parent, StructRNA *type, void *data)
void DEG_relations_tag_update(Main *bmain)
static void rna_def_render_slot(BlenderRNA *brna)
Definition rna_image.cc:922
MINLINE void copy_v4_v4(float r[4], const float a[4])
void RNA_def_property_string_funcs(PropertyRNA *prop, const char *get, const char *length, const char *set)
void BKE_image_reassign_tile(Image *ima, ImageTile *tile, int new_tile_number)
bool BKE_image_has_packedfile(const Image *image)
std::optional< std::string > rna_CameraBackgroundImage_image_or_movieclip_user_path(const PointerRNA *ptr)
@ PROP_FILEPATH
Definition RNA_types.hh:284
@ PROP_COLOR_GAMMA
Definition RNA_types.hh:329
@ PROP_UNSIGNED
Definition RNA_types.hh:306
@ PARM_REQUIRED
Definition RNA_types.hh:631
@ PARM_RNAPTR
Definition RNA_types.hh:633
int MOV_get_duration_frames(const MovieReader *anim)
const EnumPropertyItem rna_enum_image_generated_type_items[]
Definition rna_image.cc:26
void RNA_api_image(StructRNA *srna)
void BKE_image_file_format_set(Image *image, eImbFileType ftype, const ImbFormatOptions *options)
void RNA_def_struct_name_property(StructRNA *srna, PropertyRNA *prop, const bool allow_replace)
void BKE_imageuser_default(ImageUser *iuser)
MINLINE int min_ii(int a, int b)
bool BKE_id_is_in_global_main(ID *id)
Definition lib_id.cc:2759
void RNA_def_property_array(PropertyRNA *prop, int length)
static void rna_def_image(BlenderRNA *brna)
std::optional< std::string > rna_Node_ImageUser_path(const PointerRNA *ptr)
void BKE_image_release_ibuf(Image *ima, ImBuf *ibuf, void *lock)
#define min(a, b)
Definition sort.cc:38
struct Scene * scene