Merge branch 'master' into blender2.8
[blender.git] / source / blender / makesrna / intern / rna_color.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Blender Foundation (2008).
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/makesrna/intern/rna_color.c
24  *  \ingroup RNA
25  */
26
27 #include <stdlib.h>
28 #include <stdio.h>
29
30 #include "DNA_color_types.h"
31 #include "DNA_texture_types.h"
32
33 #include "BLI_utildefines.h"
34
35 #include "RNA_define.h"
36 #include "rna_internal.h"
37
38 #include "WM_api.h"
39 #include "WM_types.h"
40
41 #ifdef RNA_RUNTIME
42
43 #include "RNA_access.h"
44
45 #include "DNA_image_types.h"
46 #include "DNA_material_types.h"
47 #include "DNA_movieclip_types.h"
48 #include "DNA_node_types.h"
49 #include "DNA_object_types.h"
50 #include "DNA_particle_types.h"
51 #include "DNA_sequence_types.h"
52
53 #include "MEM_guardedalloc.h"
54
55 #include "BKE_colorband.h"
56 #include "BKE_colortools.h"
57 #include "BKE_image.h"
58 #include "BKE_movieclip.h"
59 #include "BKE_node.h"
60 #include "BKE_sequencer.h"
61 #include "BKE_linestyle.h"
62
63 #include "DEG_depsgraph.h"
64
65 #include "ED_node.h"
66
67 #include "IMB_colormanagement.h"
68 #include "IMB_imbuf.h"
69
70 static int rna_CurveMapping_curves_length(PointerRNA *ptr)
71 {
72         CurveMapping *cumap = (CurveMapping *)ptr->data;
73         int len;
74
75         for (len = 0; len < CM_TOT; len++)
76                 if (!cumap->cm[len].curve)
77                         break;
78
79         return len;
80 }
81
82 static void rna_CurveMapping_curves_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
83 {
84         CurveMapping *cumap = (CurveMapping *)ptr->data;
85
86         rna_iterator_array_begin(iter, cumap->cm, sizeof(CurveMap), rna_CurveMapping_curves_length(ptr), 0, NULL);
87 }
88
89 static void rna_CurveMapping_clip_set(PointerRNA *ptr, bool value)
90 {
91         CurveMapping *cumap = (CurveMapping *)ptr->data;
92
93         if (value) cumap->flag |= CUMA_DO_CLIP;
94         else cumap->flag &= ~CUMA_DO_CLIP;
95
96         curvemapping_changed(cumap, false);
97 }
98
99 static void rna_CurveMapping_black_level_set(PointerRNA *ptr, const float *values)
100 {
101         CurveMapping *cumap = (CurveMapping *)ptr->data;
102         cumap->black[0] = values[0];
103         cumap->black[1] = values[1];
104         cumap->black[2] = values[2];
105         curvemapping_set_black_white(cumap, NULL, NULL);
106 }
107
108 static void rna_CurveMapping_white_level_set(PointerRNA *ptr, const float *values)
109 {
110         CurveMapping *cumap = (CurveMapping *)ptr->data;
111         cumap->white[0] = values[0];
112         cumap->white[1] = values[1];
113         cumap->white[2] = values[2];
114         curvemapping_set_black_white(cumap, NULL, NULL);
115 }
116
117 static void rna_CurveMapping_tone_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *UNUSED(ptr))
118 {
119         WM_main_add_notifier(NC_NODE | NA_EDITED, NULL);
120         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
121 }
122
123 static void rna_CurveMapping_clipminx_range(PointerRNA *ptr, float *min, float *max,
124                                             float *UNUSED(softmin), float *UNUSED(softmax))
125 {
126         CurveMapping *cumap = (CurveMapping *)ptr->data;
127
128         *min = -100.0f;
129         *max = cumap->clipr.xmax;
130 }
131
132 static void rna_CurveMapping_clipminy_range(PointerRNA *ptr, float *min, float *max,
133                                             float *UNUSED(softmin), float *UNUSED(softmax))
134 {
135         CurveMapping *cumap = (CurveMapping *)ptr->data;
136
137         *min = -100.0f;
138         *max = cumap->clipr.ymax;
139 }
140
141 static void rna_CurveMapping_clipmaxx_range(PointerRNA *ptr, float *min, float *max,
142                                             float *UNUSED(softmin), float *UNUSED(softmax))
143 {
144         CurveMapping *cumap = (CurveMapping *)ptr->data;
145
146         *min = cumap->clipr.xmin;
147         *max = 100.0f;
148 }
149
150 static void rna_CurveMapping_clipmaxy_range(PointerRNA *ptr, float *min, float *max,
151                                             float *UNUSED(softmin), float *UNUSED(softmax))
152 {
153         CurveMapping *cumap = (CurveMapping *)ptr->data;
154
155         *min = cumap->clipr.ymin;
156         *max = 100.0f;
157 }
158
159
160 static char *rna_ColorRamp_path(PointerRNA *ptr)
161 {
162         char *path = NULL;
163
164         /* handle the cases where a single data-block may have 2 ramp types */
165         if (ptr->id.data) {
166                 ID *id = ptr->id.data;
167
168                 switch (GS(id->name)) {
169                         case ID_NT:
170                         {
171                                 bNodeTree *ntree = (bNodeTree *)id;
172                                 bNode *node;
173                                 PointerRNA node_ptr;
174                                 char *node_path;
175
176                                 for (node = ntree->nodes.first; node; node = node->next) {
177                                         if (ELEM(node->type, SH_NODE_VALTORGB, CMP_NODE_VALTORGB, TEX_NODE_VALTORGB)) {
178                                                 if (node->storage == ptr->data) {
179                                                         /* all node color ramp properties called 'color_ramp'
180                                                          * prepend path from ID to the node
181                                                          */
182                                                         RNA_pointer_create(id, &RNA_Node, node, &node_ptr);
183                                                         node_path = RNA_path_from_ID_to_struct(&node_ptr);
184                                                         path = BLI_sprintfN("%s.color_ramp", node_path);
185                                                         MEM_freeN(node_path);
186                                                 }
187                                         }
188                                 }
189                                 break;
190                         }
191
192                         case ID_LS:
193                         {
194                                 /* may be NULL */
195                                 path = BKE_linestyle_path_to_color_ramp((FreestyleLineStyle *)id, (ColorBand *)ptr->data);
196                                 break;
197                         }
198
199                         default:
200                                 /* everything else just uses 'color_ramp' */
201                                 path = BLI_strdup("color_ramp");
202                                 break;
203                 }
204         }
205         else {
206                 /* everything else just uses 'color_ramp' */
207                 path = BLI_strdup("color_ramp");
208         }
209
210         return path;
211 }
212
213 static char *rna_ColorRampElement_path(PointerRNA *ptr)
214 {
215         PointerRNA ramp_ptr;
216         PropertyRNA *prop;
217         char *path = NULL;
218         int index;
219
220         /* helper macro for use here to try and get the path
221          *      - this calls the standard code for getting a path to a texture...
222          */
223
224 #define COLRAMP_GETPATH                                                       \
225 {                                                                             \
226         prop = RNA_struct_find_property(&ramp_ptr, "elements");                   \
227         if (prop) {                                                               \
228                 index = RNA_property_collection_lookup_index(&ramp_ptr, prop, ptr);   \
229                 if (index != -1) {                                                    \
230                         char *texture_path = rna_ColorRamp_path(&ramp_ptr);               \
231                         path = BLI_sprintfN("%s.elements[%d]", texture_path, index);      \
232                         MEM_freeN(texture_path);                                          \
233                 }                                                                     \
234         }                                                                         \
235 } (void)0
236
237         /* determine the path from the ID-block to the ramp */
238         /* FIXME: this is a very slow way to do it, but it will have to suffice... */
239         if (ptr->id.data) {
240                 ID *id = ptr->id.data;
241
242                 switch (GS(id->name)) {
243                         case ID_NT:
244                         {
245                                 bNodeTree *ntree = (bNodeTree *)id;
246                                 bNode *node;
247
248                                 for (node = ntree->nodes.first; node; node = node->next) {
249                                         if (ELEM(node->type, SH_NODE_VALTORGB, CMP_NODE_VALTORGB, TEX_NODE_VALTORGB)) {
250                                                 RNA_pointer_create(id, &RNA_ColorRamp, node->storage, &ramp_ptr);
251                                                 COLRAMP_GETPATH;
252                                         }
253                                 }
254                                 break;
255                         }
256                         case ID_LS:
257                         {
258                                 ListBase listbase;
259                                 LinkData *link;
260
261                                 BKE_linestyle_modifier_list_color_ramps((FreestyleLineStyle *)id, &listbase);
262                                 for (link = (LinkData *)listbase.first; link; link = link->next) {
263                                         RNA_pointer_create(id, &RNA_ColorRamp, link->data, &ramp_ptr);
264                                         COLRAMP_GETPATH;
265                                 }
266                                 BLI_freelistN(&listbase);
267                                 break;
268                         }
269
270                         default: /* everything else should have a "color_ramp" property */
271                         {
272                                 /* create pointer to the ID block, and try to resolve "color_ramp" pointer */
273                                 RNA_id_pointer_create(id, &ramp_ptr);
274                                 if (RNA_path_resolve(&ramp_ptr, "color_ramp", &ramp_ptr, &prop)) {
275                                         COLRAMP_GETPATH;
276                                 }
277                                 break;
278                         }
279                 }
280         }
281
282         /* cleanup the macro we defined */
283 #undef COLRAMP_GETPATH
284
285         return path;
286 }
287
288 static void rna_ColorRamp_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
289 {
290         if (ptr->id.data) {
291                 ID *id = ptr->id.data;
292
293                 switch (GS(id->name)) {
294                         case ID_MA:
295                         {
296                                 Material *ma = ptr->id.data;
297
298                                 DEG_id_tag_update(&ma->id, 0);
299                                 WM_main_add_notifier(NC_MATERIAL | ND_SHADING_DRAW, ma);
300                                 break;
301                         }
302                         case ID_NT:
303                         {
304                                 bNodeTree *ntree = (bNodeTree *)id;
305                                 bNode *node;
306
307                                 for (node = ntree->nodes.first; node; node = node->next) {
308                                         if (ELEM(node->type, SH_NODE_VALTORGB, CMP_NODE_VALTORGB, TEX_NODE_VALTORGB)) {
309                                                 ED_node_tag_update_nodetree(bmain, ntree, node);
310                                         }
311                                 }
312                                 break;
313                         }
314                         case ID_TE:
315                         {
316                                 Tex *tex = ptr->id.data;
317
318                                 DEG_id_tag_update(&tex->id, 0);
319                                 WM_main_add_notifier(NC_TEXTURE, tex);
320                                 break;
321                         }
322                         case ID_LS:
323                         {
324                                 FreestyleLineStyle *linestyle = ptr->id.data;
325
326                                 WM_main_add_notifier(NC_LINESTYLE, linestyle);
327                                 break;
328                         }
329                         case ID_PA:
330                         {
331                                 ParticleSettings *part = ptr->id.data;
332
333                                 DEG_id_tag_update(&part->id, OB_RECALC_DATA | PSYS_RECALC_REDO);
334                                 WM_main_add_notifier(NC_OBJECT | ND_PARTICLE | NA_EDITED, part);
335                         }
336                         default:
337                                 break;
338                 }
339         }
340 }
341
342 static void rna_ColorRamp_eval(struct ColorBand *coba, float position, float color[4])
343 {
344         BKE_colorband_evaluate(coba, position, color);
345 }
346
347 static CBData *rna_ColorRampElement_new(struct ColorBand *coba, ReportList *reports, float position)
348 {
349         CBData *element = BKE_colorband_element_add(coba, position);
350
351         if (element == NULL)
352                 BKE_reportf(reports, RPT_ERROR, "Unable to add element to colorband (limit %d)", MAXCOLORBAND);
353
354         return element;
355 }
356
357 static void rna_ColorRampElement_remove(struct ColorBand *coba, ReportList *reports, PointerRNA *element_ptr)
358 {
359         CBData *element = element_ptr->data;
360         int index = (int)(element - coba->data);
361         if (BKE_colorband_element_remove(coba, index) == false) {
362                 BKE_report(reports, RPT_ERROR, "Element not found in element collection or last element");
363                 return;
364         }
365
366         RNA_POINTER_INVALIDATE(element_ptr);
367 }
368
369 static void rna_CurveMap_remove_point(CurveMap *cuma, ReportList *reports, PointerRNA *point_ptr)
370 {
371         CurveMapPoint *point = point_ptr->data;
372         if (curvemap_remove_point(cuma, point) == false) {
373                 BKE_report(reports, RPT_ERROR, "Unable to remove curve point");
374                 return;
375         }
376
377         RNA_POINTER_INVALIDATE(point_ptr);
378 }
379
380 static void rna_Scopes_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
381 {
382         Scopes *s = (Scopes *)ptr->data;
383         s->ok = 0;
384 }
385
386 static int rna_ColorManagedDisplaySettings_display_device_get(struct PointerRNA *ptr)
387 {
388         ColorManagedDisplaySettings *display = (ColorManagedDisplaySettings *) ptr->data;
389
390         return IMB_colormanagement_display_get_named_index(display->display_device);
391 }
392
393 static void rna_ColorManagedDisplaySettings_display_device_set(struct PointerRNA *ptr, int value)
394 {
395         ColorManagedDisplaySettings *display = (ColorManagedDisplaySettings *) ptr->data;
396         const char *name = IMB_colormanagement_display_get_indexed_name(value);
397
398         if (name) {
399                 BLI_strncpy(display->display_device, name, sizeof(display->display_device));
400         }
401 }
402
403 static const EnumPropertyItem *rna_ColorManagedDisplaySettings_display_device_itemf(
404         bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
405 {
406         EnumPropertyItem *items = NULL;
407         int totitem = 0;
408
409         IMB_colormanagement_display_items_add(&items, &totitem);
410         RNA_enum_item_end(&items, &totitem);
411
412         *r_free = true;
413
414         return items;
415 }
416
417 static void rna_ColorManagedDisplaySettings_display_device_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
418 {
419         ID *id = ptr->id.data;
420
421         if (!id)
422                 return;
423
424         if (GS(id->name) == ID_SCE) {
425                 Scene *scene = (Scene *) id;
426
427                 IMB_colormanagement_validate_settings(&scene->display_settings, &scene->view_settings);
428
429                 DEG_id_tag_update(id, 0);
430                 WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
431         }
432 }
433
434 static char *rna_ColorManagedDisplaySettings_path(PointerRNA *UNUSED(ptr))
435 {
436         return BLI_sprintfN("display_settings");
437 }
438
439 static int rna_ColorManagedViewSettings_view_transform_get(PointerRNA *ptr)
440 {
441         ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
442
443         return IMB_colormanagement_view_get_named_index(view->view_transform);
444 }
445
446 static void rna_ColorManagedViewSettings_view_transform_set(PointerRNA *ptr, int value)
447 {
448         ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
449
450         const char *name = IMB_colormanagement_view_get_indexed_name(value);
451
452         if (name) {
453                 BLI_strncpy(view->view_transform, name, sizeof(view->view_transform));
454         }
455 }
456
457 static const EnumPropertyItem *rna_ColorManagedViewSettings_view_transform_itemf(
458         bContext *C, PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
459 {
460         Scene *scene = CTX_data_scene(C);
461         EnumPropertyItem *items = NULL;
462         ColorManagedDisplaySettings *display_settings = &scene->display_settings;
463         int totitem = 0;
464
465         IMB_colormanagement_view_items_add(&items, &totitem, display_settings->display_device);
466         RNA_enum_item_end(&items, &totitem);
467
468         *r_free = true;
469         return items;
470 }
471
472 static int rna_ColorManagedViewSettings_look_get(PointerRNA *ptr)
473 {
474         ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
475
476         return IMB_colormanagement_look_get_named_index(view->look);
477 }
478
479 static void rna_ColorManagedViewSettings_look_set(PointerRNA *ptr, int value)
480 {
481         ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
482
483         const char *name = IMB_colormanagement_look_get_indexed_name(value);
484
485         if (name) {
486                 BLI_strncpy(view->look, name, sizeof(view->look));
487         }
488 }
489
490 static const EnumPropertyItem *rna_ColorManagedViewSettings_look_itemf(
491         bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *r_free)
492 {
493         ColorManagedViewSettings *view = (ColorManagedViewSettings *) ptr->data;
494         EnumPropertyItem *items = NULL;
495         int totitem = 0;
496
497         IMB_colormanagement_look_items_add(&items, &totitem, view->view_transform);
498         RNA_enum_item_end(&items, &totitem);
499
500         *r_free = true;
501         return items;
502 }
503
504 static void rna_ColorManagedViewSettings_use_curves_set(PointerRNA *ptr, bool value)
505 {
506         ColorManagedViewSettings *view_settings = (ColorManagedViewSettings *) ptr->data;
507
508         if (value) {
509                 view_settings->flag |= COLORMANAGE_VIEW_USE_CURVES;
510
511                 if (view_settings->curve_mapping == NULL) {
512                         view_settings->curve_mapping = curvemapping_add(4, 0.0f, 0.0f, 1.0f, 1.0f);
513                 }
514         }
515         else {
516                 view_settings->flag &= ~COLORMANAGE_VIEW_USE_CURVES;
517         }
518 }
519
520 static char *rna_ColorManagedViewSettings_path(PointerRNA *UNUSED(ptr))
521 {
522         return BLI_sprintfN("view_settings");
523 }
524
525
526 static int rna_ColorManagedColorspaceSettings_colorspace_get(struct PointerRNA *ptr)
527 {
528         ColorManagedColorspaceSettings *colorspace = (ColorManagedColorspaceSettings *) ptr->data;
529
530         return IMB_colormanagement_colorspace_get_named_index(colorspace->name);
531 }
532
533 static void rna_ColorManagedColorspaceSettings_colorspace_set(struct PointerRNA *ptr, int value)
534 {
535         ColorManagedColorspaceSettings *colorspace = (ColorManagedColorspaceSettings *) ptr->data;
536         const char *name = IMB_colormanagement_colorspace_get_indexed_name(value);
537
538         if (name && name[0]) {
539                 BLI_strncpy(colorspace->name, name, sizeof(colorspace->name));
540         }
541 }
542
543 static const EnumPropertyItem *rna_ColorManagedColorspaceSettings_colorspace_itemf(
544         bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
545 {
546         EnumPropertyItem *items = NULL;
547         int totitem = 0;
548
549         IMB_colormanagement_colorspace_items_add(&items, &totitem);
550         RNA_enum_item_end(&items, &totitem);
551
552         *r_free = true;
553
554         return items;
555 }
556
557 static void rna_ColorManagedColorspaceSettings_reload_update(Main *bmain, Scene *UNUSED(scene), PointerRNA *ptr)
558 {
559         ID *id = ptr->id.data;
560
561         if (GS(id->name) == ID_IM) {
562                 Image *ima = (Image *) id;
563
564                 DEG_id_tag_update(&ima->id, 0);
565
566                 BKE_image_signal(bmain, ima, NULL, IMA_SIGNAL_COLORMANAGE);
567
568                 WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, &ima->id);
569                 WM_main_add_notifier(NC_IMAGE | NA_EDITED, &ima->id);
570         }
571         else if (GS(id->name) == ID_MC) {
572                 MovieClip *clip = (MovieClip *) id;
573
574                 BKE_movieclip_reload(bmain, clip);
575
576                 /* all sequencers for now, we don't know which scenes are using this clip as a strip */
577                 BKE_sequencer_cache_cleanup();
578                 BKE_sequencer_preprocessed_cache_cleanup();
579
580                 WM_main_add_notifier(NC_MOVIECLIP | ND_DISPLAY, &clip->id);
581                 WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, &clip->id);
582         }
583         else if (GS(id->name) == ID_SCE) {
584                 Scene *scene = (Scene *) id;
585
586                 if (scene->ed) {
587                         ColorManagedColorspaceSettings *colorspace_settings = (ColorManagedColorspaceSettings *) ptr->data;
588                         Sequence *seq;
589                         bool seq_found = false;
590
591                         if (&scene->sequencer_colorspace_settings != colorspace_settings) {
592                                 SEQ_BEGIN(scene->ed, seq);
593                                 {
594                                         if (seq->strip && &seq->strip->colorspace_settings == colorspace_settings) {
595                                                 seq_found = true;
596                                                 break;
597                                         }
598                                 }
599                                 SEQ_END;
600                         }
601
602                         if (seq_found) {
603                                 BKE_sequence_free_anim(seq);
604
605                                 if (seq->strip->proxy && seq->strip->proxy->anim) {
606                                         IMB_free_anim(seq->strip->proxy->anim);
607                                         seq->strip->proxy->anim = NULL;
608                                 }
609
610                                 BKE_sequence_invalidate_cache(scene, seq);
611                                 BKE_sequencer_preprocessed_cache_cleanup_sequence(seq);
612                         }
613                         else {
614                                 SEQ_BEGIN(scene->ed, seq);
615                                 {
616                                         BKE_sequence_free_anim(seq);
617                                 }
618                                 SEQ_END;
619
620                                 BKE_sequencer_cache_cleanup();
621                                 BKE_sequencer_preprocessed_cache_cleanup();
622                         }
623
624                         WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
625                 }
626         }
627 }
628
629 static char *rna_ColorManagedSequencerColorspaceSettings_path(PointerRNA *UNUSED(ptr))
630 {
631         return BLI_sprintfN("sequencer_colorspace_settings");
632 }
633
634 static char *rna_ColorManagedInputColorspaceSettings_path(PointerRNA *UNUSED(ptr))
635 {
636         return BLI_sprintfN("colorspace_settings");
637 }
638
639 static void rna_ColorManagement_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
640 {
641         ID *id = ptr->id.data;
642
643         if (!id)
644                 return;
645
646         if (GS(id->name) == ID_SCE) {
647                 DEG_id_tag_update(id, 0);
648                 WM_main_add_notifier(NC_SCENE | ND_SEQUENCER, NULL);
649         }
650 }
651
652 /* this function only exists because #curvemap_evaluateF uses a 'const' qualifier */
653 static float rna_CurveMap_evaluateF(struct CurveMap *cuma, ReportList *reports, float value)
654 {
655         if (!cuma->table) {
656                 BKE_report(reports, RPT_ERROR, "CurveMap table not initialized, call initialize() on CurveMapping owner of the CurveMap");
657                 return 0.0f;
658         }
659         return curvemap_evaluateF(cuma, value);
660 }
661
662 static void rna_CurveMap_initialize(struct CurveMapping *cumap)
663 {
664         curvemapping_initialize(cumap);
665 }
666 #else
667
668 static void rna_def_curvemappoint(BlenderRNA *brna)
669 {
670         StructRNA *srna;
671         PropertyRNA *prop;
672         static const EnumPropertyItem prop_handle_type_items[] = {
673                 {0, "AUTO", 0, "Auto Handle", ""},
674                 {CUMA_HANDLE_AUTO_ANIM, "AUTO_CLAMPED", 0, "Auto Clamped Handle", ""},
675                 {CUMA_HANDLE_VECTOR, "VECTOR", 0, "Vector Handle", ""},
676                 {0, NULL, 0, NULL, NULL}
677         };
678
679         srna = RNA_def_struct(brna, "CurveMapPoint", NULL);
680         RNA_def_struct_ui_text(srna, "CurveMapPoint", "Point of a curve used for a curve mapping");
681
682         prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
683         RNA_def_property_float_sdna(prop, NULL, "x");
684         RNA_def_property_array(prop, 2);
685         RNA_def_property_ui_text(prop, "Location", "X/Y coordinates of the curve point");
686
687         prop = RNA_def_property(srna, "handle_type", PROP_ENUM, PROP_NONE);
688         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
689         RNA_def_property_enum_items(prop, prop_handle_type_items);
690         RNA_def_property_ui_text(prop, "Handle Type", "Curve interpolation at this point: Bezier or vector");
691
692         prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
693         RNA_def_property_boolean_sdna(prop, NULL, "flag", CUMA_SELECT);
694         RNA_def_property_ui_text(prop, "Select", "Selection state of the curve point");
695 }
696
697 static void rna_def_curvemap_points_api(BlenderRNA *brna, PropertyRNA *cprop)
698 {
699         StructRNA *srna;
700         PropertyRNA *parm;
701         FunctionRNA *func;
702
703         RNA_def_property_srna(cprop, "CurveMapPoints");
704         srna = RNA_def_struct(brna, "CurveMapPoints", NULL);
705         RNA_def_struct_sdna(srna, "CurveMap");
706         RNA_def_struct_ui_text(srna, "Curve Map Point", "Collection of Curve Map Points");
707
708         func = RNA_def_function(srna, "new", "curvemap_insert");
709         RNA_def_function_ui_description(func, "Add point to CurveMap");
710         parm = RNA_def_float(func, "position", 0.0f, -FLT_MAX, FLT_MAX, "Position", "Position to add point", -FLT_MAX, FLT_MAX);
711         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
712         parm = RNA_def_float(func, "value", 0.0f, -FLT_MAX, FLT_MAX, "Value", "Value of point", -FLT_MAX, FLT_MAX);
713         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
714         parm = RNA_def_pointer(func, "point", "CurveMapPoint", "", "New point");
715         RNA_def_function_return(func, parm);
716
717         func = RNA_def_function(srna, "remove", "rna_CurveMap_remove_point");
718         RNA_def_function_flag(func, FUNC_USE_REPORTS);
719         RNA_def_function_ui_description(func, "Delete point from CurveMap");
720         parm = RNA_def_pointer(func, "point", "CurveMapPoint", "", "PointElement to remove");
721         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
722         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
723 }
724
725 static void rna_def_curvemap(BlenderRNA *brna)
726 {
727         StructRNA *srna;
728         PropertyRNA *prop, *parm;
729         FunctionRNA *func;
730
731         static const EnumPropertyItem prop_extend_items[] = {
732                 {0, "HORIZONTAL", 0, "Horizontal", ""},
733                 {CUMA_EXTEND_EXTRAPOLATE, "EXTRAPOLATED", 0, "Extrapolated", ""},
734                 {0, NULL, 0, NULL, NULL}
735         };
736
737         srna = RNA_def_struct(brna, "CurveMap", NULL);
738         RNA_def_struct_ui_text(srna, "CurveMap", "Curve in a curve mapping");
739
740         prop = RNA_def_property(srna, "extend", PROP_ENUM, PROP_NONE);
741         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
742         RNA_def_property_enum_items(prop, prop_extend_items);
743         RNA_def_property_ui_text(prop, "Extend", "Extrapolate the curve or extend it horizontally");
744
745         prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
746         RNA_def_property_collection_sdna(prop, NULL, "curve", "totpoint");
747         RNA_def_property_struct_type(prop, "CurveMapPoint");
748         RNA_def_property_ui_text(prop, "Points", "");
749         rna_def_curvemap_points_api(brna, prop);
750
751         func = RNA_def_function(srna, "evaluate", "rna_CurveMap_evaluateF");
752         RNA_def_function_flag(func, FUNC_USE_REPORTS);
753         RNA_def_function_ui_description(func, "Evaluate curve at given location");
754         parm = RNA_def_float(func, "position", 0.0f, -FLT_MAX, FLT_MAX, "Position", "Position to evaluate curve at", -FLT_MAX, FLT_MAX);
755         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
756         parm = RNA_def_float(func, "value", 0.0f, -FLT_MAX, FLT_MAX, "Value", "Value of curve at given location", -FLT_MAX, FLT_MAX);
757         RNA_def_function_return(func, parm);
758 }
759
760 static void rna_def_curvemapping(BlenderRNA *brna)
761 {
762         StructRNA *srna;
763         PropertyRNA *prop;
764         FunctionRNA *func;
765
766         static const EnumPropertyItem tone_items[] = {
767                 {CURVE_TONE_STANDARD, "STANDARD", 0, "Standard",  ""},
768                 {CURVE_TONE_FILMLIKE, "FILMLIKE", 0, "Film like", ""},
769                 {0, NULL, 0, NULL, NULL}
770         };
771
772         srna = RNA_def_struct(brna, "CurveMapping", NULL);
773         RNA_def_struct_ui_text(srna, "CurveMapping",
774                                "Curve mapping to map color, vector and scalar values to other values using "
775                                "a user defined curve");
776
777         prop = RNA_def_property(srna, "tone", PROP_ENUM, PROP_NONE);
778         RNA_def_property_enum_sdna(prop, NULL, "tone");
779         RNA_def_property_enum_items(prop, tone_items);
780         RNA_def_property_ui_text(prop, "Tone", "Tone of the curve");
781         RNA_def_property_update(prop, 0, "rna_CurveMapping_tone_update");
782
783
784         prop = RNA_def_property(srna, "use_clip", PROP_BOOLEAN, PROP_NONE);
785         RNA_def_property_boolean_sdna(prop, NULL, "flag", CUMA_DO_CLIP);
786         RNA_def_property_ui_text(prop, "Clip", "Force the curve view to fit a defined boundary");
787         RNA_def_property_boolean_funcs(prop, NULL, "rna_CurveMapping_clip_set");
788
789         prop = RNA_def_property(srna, "clip_min_x", PROP_FLOAT, PROP_NONE);
790         RNA_def_property_float_sdna(prop, NULL, "clipr.xmin");
791         RNA_def_property_range(prop, -100.0f, 100.0f);
792         RNA_def_property_ui_text(prop, "Clip Min X", "");
793         RNA_def_property_float_funcs(prop, NULL, NULL, "rna_CurveMapping_clipminx_range");
794
795         prop = RNA_def_property(srna, "clip_min_y", PROP_FLOAT, PROP_NONE);
796         RNA_def_property_float_sdna(prop, NULL, "clipr.ymin");
797         RNA_def_property_range(prop, -100.0f, 100.0f);
798         RNA_def_property_ui_text(prop, "Clip Min Y", "");
799         RNA_def_property_float_funcs(prop, NULL, NULL, "rna_CurveMapping_clipminy_range");
800
801         prop = RNA_def_property(srna, "clip_max_x", PROP_FLOAT, PROP_NONE);
802         RNA_def_property_float_sdna(prop, NULL, "clipr.xmax");
803         RNA_def_property_range(prop, -100.0f, 100.0f);
804         RNA_def_property_ui_text(prop, "Clip Max X", "");
805         RNA_def_property_float_funcs(prop, NULL, NULL, "rna_CurveMapping_clipmaxx_range");
806
807         prop = RNA_def_property(srna, "clip_max_y", PROP_FLOAT, PROP_NONE);
808         RNA_def_property_float_sdna(prop, NULL, "clipr.ymax");
809         RNA_def_property_range(prop, -100.0f, 100.0f);
810         RNA_def_property_ui_text(prop, "Clip Max Y", "");
811         RNA_def_property_float_funcs(prop, NULL, NULL, "rna_CurveMapping_clipmaxy_range");
812
813         prop = RNA_def_property(srna, "curves", PROP_COLLECTION, PROP_NONE);
814         RNA_def_property_collection_funcs(prop, "rna_CurveMapping_curves_begin", "rna_iterator_array_next",
815                                           "rna_iterator_array_end", "rna_iterator_array_get",
816                                           "rna_CurveMapping_curves_length", NULL, NULL, NULL);
817         RNA_def_property_struct_type(prop, "CurveMap");
818         RNA_def_property_ui_text(prop, "Curves", "");
819
820         prop = RNA_def_property(srna, "black_level", PROP_FLOAT, PROP_COLOR);
821         RNA_def_property_float_sdna(prop, NULL, "black");
822         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
823         RNA_def_property_ui_range(prop, -1000.0f, 1000.0f, 1, 3);
824         RNA_def_property_ui_text(prop, "Black Level", "For RGB curves, the color that black is mapped to");
825         RNA_def_property_float_funcs(prop, NULL, "rna_CurveMapping_black_level_set", NULL);
826
827         prop = RNA_def_property(srna, "white_level", PROP_FLOAT, PROP_COLOR);
828         RNA_def_property_float_sdna(prop, NULL, "white");
829         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
830         RNA_def_property_ui_range(prop, -1000.0f, 1000.0f, 1, 3);
831         RNA_def_property_ui_text(prop, "White Level", "For RGB curves, the color that white is mapped to");
832         RNA_def_property_float_funcs(prop, NULL, "rna_CurveMapping_white_level_set", NULL);
833
834         func = RNA_def_function(srna, "update", "curvemapping_changed_all");
835         RNA_def_function_ui_description(func, "Update curve mapping after making changes");
836
837         func = RNA_def_function(srna, "initialize", "rna_CurveMap_initialize");
838         RNA_def_function_ui_description(func, "Initialize curve");
839 }
840
841 static void rna_def_color_ramp_element(BlenderRNA *brna)
842 {
843         StructRNA *srna;
844         PropertyRNA *prop;
845
846         srna = RNA_def_struct(brna, "ColorRampElement", NULL);
847         RNA_def_struct_sdna(srna, "CBData");
848         RNA_def_struct_path_func(srna, "rna_ColorRampElement_path");
849         RNA_def_struct_ui_text(srna, "Color Ramp Element", "Element defining a color at a position in the color ramp");
850
851         prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR);
852         RNA_def_property_float_sdna(prop, NULL, "r");
853         RNA_def_property_array(prop, 4);
854         RNA_def_property_ui_text(prop, "Color", "Set color of selected color stop");
855         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
856
857         prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_COLOR);
858         RNA_def_property_float_sdna(prop, NULL, "a");
859         RNA_def_property_ui_text(prop, "Alpha", "Set alpha of selected color stop");
860         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
861
862         prop = RNA_def_property(srna, "position", PROP_FLOAT, PROP_NONE);
863         RNA_def_property_float_sdna(prop, NULL, "pos");
864         RNA_def_property_range(prop, 0, 1);
865         RNA_def_property_ui_text(prop, "Position", "Set position of selected color stop");
866         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
867 }
868
869 static void rna_def_color_ramp_element_api(BlenderRNA *brna, PropertyRNA *cprop)
870 {
871         StructRNA *srna;
872         PropertyRNA *parm;
873         FunctionRNA *func;
874
875         RNA_def_property_srna(cprop, "ColorRampElements");
876         srna = RNA_def_struct(brna, "ColorRampElements", NULL);
877         RNA_def_struct_sdna(srna, "ColorBand");
878         RNA_def_struct_path_func(srna, "rna_ColorRampElement_path");
879         RNA_def_struct_ui_text(srna, "Color Ramp Elements", "Collection of Color Ramp Elements");
880
881         /* TODO, make these functions generic in texture.c */
882         func = RNA_def_function(srna, "new", "rna_ColorRampElement_new");
883         RNA_def_function_ui_description(func, "Add element to ColorRamp");
884         RNA_def_function_flag(func, FUNC_USE_REPORTS);
885         parm = RNA_def_float(func, "position", 0.0f, 0.0f, 1.0f, "Position", "Position to add element", 0.0f, 1.0f);
886         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
887         /* return type */
888         parm = RNA_def_pointer(func, "element", "ColorRampElement", "", "New element");
889         RNA_def_function_return(func, parm);
890
891         func = RNA_def_function(srna, "remove", "rna_ColorRampElement_remove");
892         RNA_def_function_ui_description(func, "Delete element from ColorRamp");
893         RNA_def_function_flag(func, FUNC_USE_REPORTS);
894         parm = RNA_def_pointer(func, "element", "ColorRampElement", "", "Element to remove");
895         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
896         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
897 }
898
899 static void rna_def_color_ramp(BlenderRNA *brna)
900 {
901         StructRNA *srna;
902         PropertyRNA *prop;
903
904         FunctionRNA *func;
905         PropertyRNA *parm;
906
907         static const EnumPropertyItem prop_interpolation_items[] = {
908                 {COLBAND_INTERP_EASE, "EASE", 0, "Ease", ""},
909                 {COLBAND_INTERP_CARDINAL, "CARDINAL", 0, "Cardinal", ""},
910                 {COLBAND_INTERP_LINEAR, "LINEAR", 0, "Linear", ""},
911                 {COLBAND_INTERP_B_SPLINE, "B_SPLINE", 0, "B-Spline", ""},
912                 {COLBAND_INTERP_CONSTANT, "CONSTANT", 0, "Constant", ""},
913                 {0, NULL, 0, NULL, NULL}
914         };
915
916         static const EnumPropertyItem prop_mode_items[] = {
917                 {COLBAND_BLEND_RGB, "RGB", 0, "RGB", ""},
918                 {COLBAND_BLEND_HSV, "HSV", 0, "HSV", ""},
919                 {COLBAND_BLEND_HSL, "HSL", 0, "HSL", ""},
920                 {0, NULL, 0, NULL, NULL}
921         };
922
923         static const EnumPropertyItem prop_hsv_items[] = {
924                 {COLBAND_HUE_NEAR, "NEAR", 0, "Near", ""},
925                 {COLBAND_HUE_FAR, "FAR", 0, "Far", ""},
926                 {COLBAND_HUE_CW, "CW", 0, "Clockwise", ""},
927                 {COLBAND_HUE_CCW, "CCW", 0, "Counter-Clockwise", ""},
928                 {0, NULL, 0, NULL, NULL}
929         };
930
931         srna = RNA_def_struct(brna, "ColorRamp", NULL);
932         RNA_def_struct_sdna(srna, "ColorBand");
933         RNA_def_struct_path_func(srna, "rna_ColorRamp_path");
934         RNA_def_struct_ui_text(srna, "Color Ramp", "Color ramp mapping a scalar value to a color");
935
936         prop = RNA_def_property(srna, "elements", PROP_COLLECTION, PROP_COLOR);
937         RNA_def_property_collection_sdna(prop, NULL, "data", "tot");
938         RNA_def_property_struct_type(prop, "ColorRampElement");
939         RNA_def_property_ui_text(prop, "Elements", "");
940         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
941         rna_def_color_ramp_element_api(brna, prop);
942
943         prop = RNA_def_property(srna, "interpolation", PROP_ENUM, PROP_NONE);
944         RNA_def_property_enum_sdna(prop, NULL, "ipotype");
945         RNA_def_property_enum_items(prop, prop_interpolation_items);
946         RNA_def_property_ui_text(prop, "Interpolation", "Set interpolation between color stops");
947         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
948
949         prop = RNA_def_property(srna, "hue_interpolation", PROP_ENUM, PROP_NONE);
950         RNA_def_property_enum_sdna(prop, NULL, "ipotype_hue");
951         RNA_def_property_enum_items(prop, prop_hsv_items);
952         RNA_def_property_ui_text(prop, "Color Interpolation", "Set color interpolation");
953         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
954
955         prop = RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
956         RNA_def_property_enum_sdna(prop, NULL, "color_mode");
957         RNA_def_property_enum_items(prop, prop_mode_items);
958         RNA_def_property_ui_text(prop, "Color Mode", "Set color mode to use for interpolation");
959         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
960
961 #if 0 /* use len(elements) */
962         prop = RNA_def_property(srna, "total", PROP_INT, PROP_NONE);
963         RNA_def_property_int_sdna(prop, NULL, "tot");
964         /* needs a function to do the right thing when adding elements like colorband_add_cb() */
965         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
966         RNA_def_property_range(prop, 0, 31); /* MAXCOLORBAND = 32 */
967         RNA_def_property_ui_text(prop, "Total", "Total number of elements");
968         RNA_def_property_update(prop, 0, "rna_ColorRamp_update");
969 #endif
970
971         func = RNA_def_function(srna, "evaluate", "rna_ColorRamp_eval");
972         RNA_def_function_ui_description(func, "Evaluate ColorRamp");
973         parm = RNA_def_float(func, "position", 1.0f, 0.0f, 1.0f, "Position", "Evaluate ColorRamp at position", 0.0f, 1.0f);
974         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
975         /* return */
976         parm = RNA_def_float_color(func, "color", 4, NULL, -FLT_MAX, FLT_MAX, "Color", "Color at given position",
977                                    -FLT_MAX, FLT_MAX);
978         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
979         RNA_def_function_output(func, parm);
980 }
981
982 static void rna_def_histogram(BlenderRNA *brna)
983 {
984         StructRNA *srna;
985         PropertyRNA *prop;
986
987         static const EnumPropertyItem prop_mode_items[] = {
988                 {HISTO_MODE_LUMA, "LUMA", 0, "Luma", "Luma"},
989                 {HISTO_MODE_RGB, "RGB", 0, "RGB", "Red Green Blue"},
990                 {HISTO_MODE_R, "R", 0, "R", "Red"},
991                 {HISTO_MODE_G, "G", 0, "G", "Green"},
992                 {HISTO_MODE_B, "B", 0, "B", "Blue"},
993                 {HISTO_MODE_ALPHA, "A", 0, "A", "Alpha"},
994                 {0, NULL, 0, NULL, NULL}
995         };
996
997         srna = RNA_def_struct(brna, "Histogram", NULL);
998         RNA_def_struct_ui_text(srna, "Histogram", "Statistical view of the levels of color in an image");
999
1000         prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
1001         RNA_def_property_enum_sdna(prop, NULL, "mode");
1002         RNA_def_property_enum_items(prop, prop_mode_items);
1003         RNA_def_property_ui_text(prop, "Mode", "Channels to display when drawing the histogram");
1004
1005         prop = RNA_def_property(srna, "show_line", PROP_BOOLEAN, PROP_NONE);
1006         RNA_def_property_boolean_sdna(prop, NULL, "flag", HISTO_FLAG_LINE);
1007         RNA_def_property_ui_text(prop, "Show Line", "Display lines rather than filled shapes");
1008         RNA_def_property_ui_icon(prop, ICON_GRAPH, 0);
1009 }
1010
1011 static void rna_def_scopes(BlenderRNA *brna)
1012 {
1013         StructRNA *srna;
1014         PropertyRNA *prop;
1015
1016         static const EnumPropertyItem prop_wavefrm_mode_items[] = {
1017                 {SCOPES_WAVEFRM_LUMA, "LUMA", ICON_COLOR, "Luma", ""},
1018                 {SCOPES_WAVEFRM_RGB_PARADE, "PARADE", ICON_COLOR, "Parade", ""},
1019                 {SCOPES_WAVEFRM_YCC_601, "YCBCR601", ICON_COLOR, "YCbCr (ITU 601)", ""},
1020                 {SCOPES_WAVEFRM_YCC_709, "YCBCR709", ICON_COLOR, "YCbCr (ITU 709)", ""},
1021                 {SCOPES_WAVEFRM_YCC_JPEG, "YCBCRJPG", ICON_COLOR, "YCbCr (Jpeg)", ""},
1022                 {SCOPES_WAVEFRM_RGB, "RGB", ICON_COLOR, "Red Green Blue", ""},
1023                 {0, NULL, 0, NULL, NULL}
1024         };
1025
1026         srna = RNA_def_struct(brna, "Scopes", NULL);
1027         RNA_def_struct_ui_text(srna, "Scopes", "Scopes for statistical view of an image");
1028
1029         prop = RNA_def_property(srna, "use_full_resolution", PROP_BOOLEAN, PROP_NONE);
1030         RNA_def_property_boolean_sdna(prop, "Scopes", "sample_full", 1);
1031         RNA_def_property_ui_text(prop, "Full Sample", "Sample every pixel of the image");
1032         RNA_def_property_update(prop, 0, "rna_Scopes_update");
1033
1034         prop = RNA_def_property(srna, "accuracy", PROP_FLOAT, PROP_PERCENTAGE);
1035         RNA_def_property_float_sdna(prop, "Scopes", "accuracy");
1036         RNA_def_property_range(prop, 0.0, 100.0);
1037         RNA_def_property_ui_range(prop, 0.0, 100.0, 10, 1);
1038         RNA_def_property_ui_text(prop, "Accuracy", "Proportion of original image source pixel lines to sample");
1039         RNA_def_property_update(prop, 0, "rna_Scopes_update");
1040
1041         prop = RNA_def_property(srna, "histogram", PROP_POINTER, PROP_NONE);
1042         RNA_def_property_pointer_sdna(prop, "Scopes", "hist");
1043         RNA_def_property_struct_type(prop, "Histogram");
1044         RNA_def_property_ui_text(prop, "Histogram", "Histogram for viewing image statistics");
1045
1046         prop = RNA_def_property(srna, "waveform_mode", PROP_ENUM, PROP_NONE);
1047         RNA_def_property_enum_sdna(prop, "Scopes", "wavefrm_mode");
1048         RNA_def_property_enum_items(prop, prop_wavefrm_mode_items);
1049         RNA_def_property_ui_text(prop, "Waveform Mode", "");
1050         RNA_def_property_update(prop, 0, "rna_Scopes_update");
1051
1052         prop = RNA_def_property(srna, "waveform_alpha", PROP_FLOAT, PROP_FACTOR);
1053         RNA_def_property_float_sdna(prop, "Scopes", "wavefrm_alpha");
1054         RNA_def_property_range(prop, 0, 1);
1055         RNA_def_property_ui_text(prop, "Waveform Opacity", "Opacity of the points");
1056
1057         prop = RNA_def_property(srna, "vectorscope_alpha", PROP_FLOAT, PROP_FACTOR);
1058         RNA_def_property_float_sdna(prop, "Scopes", "vecscope_alpha");
1059         RNA_def_property_range(prop, 0, 1);
1060         RNA_def_property_ui_text(prop, "Vectorscope Opacity", "Opacity of the points");
1061 }
1062
1063 static void rna_def_colormanage(BlenderRNA *brna)
1064 {
1065         StructRNA *srna;
1066         PropertyRNA *prop;
1067
1068         static const EnumPropertyItem display_device_items[] = {
1069                 {0, "DEFAULT", 0, "Default", ""},
1070                 {0, NULL, 0, NULL, NULL}
1071         };
1072
1073         static const EnumPropertyItem look_items[] = {
1074                 {0, "NONE", 0, "None", "Do not modify image in an artistic manner"},
1075                 {0, NULL, 0, NULL, NULL}
1076         };
1077
1078         static const EnumPropertyItem view_transform_items[] = {
1079                 {0, "NONE", 0, "None", "Do not perform any color transform on display, use old non-color managed technique for display"},
1080                 {0, NULL, 0, NULL, NULL}
1081         };
1082
1083         static const EnumPropertyItem color_space_items[] = {
1084                 {0, "NONE", 0, "None", "Do not perform any color transform on load, treat colors as in scene linear space already"},
1085                 {0, NULL, 0, NULL, NULL}
1086         };
1087
1088         /* ** Display Settings  **  */
1089         srna = RNA_def_struct(brna, "ColorManagedDisplaySettings", NULL);
1090         RNA_def_struct_path_func(srna, "rna_ColorManagedDisplaySettings_path");
1091         RNA_def_struct_ui_text(srna, "ColorManagedDisplaySettings", "Color management specific to display device");
1092
1093         prop = RNA_def_property(srna, "display_device", PROP_ENUM, PROP_NONE);
1094         RNA_def_property_enum_items(prop, display_device_items);
1095         RNA_def_property_enum_funcs(prop, "rna_ColorManagedDisplaySettings_display_device_get",
1096                                           "rna_ColorManagedDisplaySettings_display_device_set",
1097                                           "rna_ColorManagedDisplaySettings_display_device_itemf");
1098         RNA_def_property_ui_text(prop, "Display Device", "Display device name");
1099         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagedDisplaySettings_display_device_update");
1100
1101         /* ** View Settings  **  */
1102         srna = RNA_def_struct(brna, "ColorManagedViewSettings", NULL);
1103         RNA_def_struct_path_func(srna, "rna_ColorManagedViewSettings_path");
1104         RNA_def_struct_ui_text(srna, "ColorManagedViewSettings", "Color management settings used for displaying images on the display");
1105
1106         prop = RNA_def_property(srna, "look", PROP_ENUM, PROP_NONE);
1107         RNA_def_property_enum_items(prop, look_items);
1108         RNA_def_property_enum_funcs(prop, "rna_ColorManagedViewSettings_look_get",
1109                                           "rna_ColorManagedViewSettings_look_set",
1110                                           "rna_ColorManagedViewSettings_look_itemf");
1111         RNA_def_property_ui_text(prop, "Look", "Additional transform applied before view transform for an artistic needs");
1112         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
1113
1114         prop = RNA_def_property(srna, "view_transform", PROP_ENUM, PROP_NONE);
1115         RNA_def_property_enum_items(prop, view_transform_items);
1116         RNA_def_property_enum_funcs(prop, "rna_ColorManagedViewSettings_view_transform_get",
1117                                           "rna_ColorManagedViewSettings_view_transform_set",
1118                                           "rna_ColorManagedViewSettings_view_transform_itemf");
1119         RNA_def_property_ui_text(prop, "View Transform", "View used when converting image to a display space");
1120         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
1121
1122         prop = RNA_def_property(srna, "exposure", PROP_FLOAT, PROP_FACTOR);
1123         RNA_def_property_float_sdna(prop, NULL, "exposure");
1124         RNA_def_property_float_default(prop, 0.0f);
1125         RNA_def_property_range(prop, -32.0f, 32.0f);
1126         RNA_def_property_ui_range(prop, -10.0f, 10.0f, 1, 3);
1127         RNA_def_property_ui_text(prop, "Exposure", "Exposure (stops) applied before display transform");
1128         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
1129
1130         prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_FACTOR);
1131         RNA_def_property_float_sdna(prop, NULL, "gamma");
1132         RNA_def_property_float_default(prop, 1.0f);
1133         RNA_def_property_range(prop, 0.0f, 5.0f);
1134         RNA_def_property_ui_text(prop, "Gamma", "Amount of gamma modification applied after display transform");
1135         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
1136
1137         prop = RNA_def_property(srna, "curve_mapping", PROP_POINTER, PROP_NONE);
1138         RNA_def_property_pointer_sdna(prop, NULL, "curve_mapping");
1139         RNA_def_property_ui_text(prop, "Curve", "Color curve mapping applied before display transform");
1140         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
1141
1142         prop = RNA_def_property(srna, "use_curve_mapping", PROP_BOOLEAN, PROP_NONE);
1143         RNA_def_property_boolean_sdna(prop, NULL, "flag", COLORMANAGE_VIEW_USE_CURVES);
1144         RNA_def_property_boolean_funcs(prop, NULL, "rna_ColorManagedViewSettings_use_curves_set");
1145         RNA_def_property_ui_text(prop, "Use Curves", "Use RGB curved for pre-display transformation");
1146         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagement_update");
1147
1148         /* ** Colorspace **  */
1149         srna = RNA_def_struct(brna, "ColorManagedInputColorspaceSettings", NULL);
1150         RNA_def_struct_path_func(srna, "rna_ColorManagedInputColorspaceSettings_path");
1151         RNA_def_struct_ui_text(srna, "ColorManagedInputColorspaceSettings", "Input color space settings");
1152
1153         prop = RNA_def_property(srna, "name", PROP_ENUM, PROP_NONE);
1154         RNA_def_property_flag(prop, PROP_ENUM_NO_CONTEXT);
1155         RNA_def_property_enum_items(prop, color_space_items);
1156         RNA_def_property_enum_funcs(prop, "rna_ColorManagedColorspaceSettings_colorspace_get",
1157                                           "rna_ColorManagedColorspaceSettings_colorspace_set",
1158                                           "rna_ColorManagedColorspaceSettings_colorspace_itemf");
1159         RNA_def_property_ui_text(prop, "Input Color Space", "Color space of the image or movie on disk");
1160         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagedColorspaceSettings_reload_update");
1161
1162         //
1163         srna = RNA_def_struct(brna, "ColorManagedSequencerColorspaceSettings", NULL);
1164         RNA_def_struct_path_func(srna, "rna_ColorManagedSequencerColorspaceSettings_path");
1165         RNA_def_struct_ui_text(srna, "ColorManagedSequencerColorspaceSettings", "Input color space settings");
1166
1167         prop = RNA_def_property(srna, "name", PROP_ENUM, PROP_NONE);
1168         RNA_def_property_flag(prop, PROP_ENUM_NO_CONTEXT);
1169         RNA_def_property_enum_items(prop, color_space_items);
1170         RNA_def_property_enum_funcs(prop, "rna_ColorManagedColorspaceSettings_colorspace_get",
1171                                           "rna_ColorManagedColorspaceSettings_colorspace_set",
1172                                           "rna_ColorManagedColorspaceSettings_colorspace_itemf");
1173         RNA_def_property_ui_text(prop, "Color Space", "Color space that the sequencer operates in");
1174         RNA_def_property_update(prop, NC_WINDOW, "rna_ColorManagedColorspaceSettings_reload_update");
1175 }
1176
1177 void RNA_def_color(BlenderRNA *brna)
1178 {
1179         rna_def_curvemappoint(brna);
1180         rna_def_curvemap(brna);
1181         rna_def_curvemapping(brna);
1182         rna_def_color_ramp_element(brna);
1183         rna_def_color_ramp(brna);
1184         rna_def_histogram(brna);
1185         rna_def_scopes(brna);
1186         rna_def_colormanage(brna);
1187 }
1188
1189 #endif