Merge remote-tracking branch 'origin/master' into blender2.8
[blender.git] / source / blender / editors / render / render_shading.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  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software Foundation,
15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16  *
17  * The Original Code is Copyright (C) 2009 Blender Foundation.
18  * All rights reserved.
19  *
20  * Contributor(s): Blender Foundation
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file blender/editors/render/render_shading.c
26  *  \ingroup edrend
27  */
28
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_curve_types.h"
35 #include "DNA_lamp_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_node_types.h"
38 #include "DNA_object_types.h"
39 #include "DNA_particle_types.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_space_types.h"
42 #include "DNA_world_types.h"
43
44 #include "BLI_utildefines.h"
45 #include "BLI_listbase.h"
46 #include "BLI_math_vector.h"
47
48 #include "BLT_translation.h"
49
50 #include "BKE_animsys.h"
51 #include "BKE_context.h"
52 #include "BKE_curve.h"
53 #include "BKE_font.h"
54 #include "BKE_global.h"
55 #include "BKE_image.h"
56 #include "BKE_layer.h"
57 #include "BKE_library.h"
58 #include "BKE_linestyle.h"
59 #include "BKE_main.h"
60 #include "BKE_material.h"
61 #include "BKE_paint.h"
62 #include "BKE_report.h"
63 #include "BKE_scene.h"
64 #include "BKE_texture.h"
65 #include "BKE_world.h"
66 #include "BKE_editmesh.h"
67
68 #include "DEG_depsgraph.h"
69 #include "DEG_depsgraph_build.h"
70
71 #ifdef WITH_FREESTYLE
72 #  include "BKE_freestyle.h"
73 #  include "FRS_freestyle.h"
74 #  include "RNA_enum_types.h"
75 #endif
76
77 #include "RNA_access.h"
78
79 #include "WM_api.h"
80 #include "WM_types.h"
81
82 #include "ED_object.h"
83 #include "ED_curve.h"
84 #include "ED_mesh.h"
85 #include "ED_node.h"
86 #include "ED_render.h"
87 #include "ED_scene.h"
88 #include "ED_screen.h"
89
90 #include "RNA_define.h"
91
92 #include "UI_interface.h"
93
94 #include "RE_pipeline.h"
95
96 #include "render_intern.h"  // own include
97
98 /********************** material slot operators *********************/
99
100 static int material_slot_add_exec(bContext *C, wmOperator *UNUSED(op))
101 {
102         Object *ob = ED_object_context(C);
103
104         if (!ob)
105                 return OPERATOR_CANCELLED;
106         
107         BKE_object_material_slot_add(ob);
108
109         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
110                 Scene *scene = CTX_data_scene(C);
111                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
112                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
113         }
114         
115         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
116         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
117         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_PREVIEW, ob);
118         
119         return OPERATOR_FINISHED;
120 }
121
122 void OBJECT_OT_material_slot_add(wmOperatorType *ot)
123 {
124         /* identifiers */
125         ot->name = "Add Material Slot";
126         ot->idname = "OBJECT_OT_material_slot_add";
127         ot->description = "Add a new material slot";
128         
129         /* api callbacks */
130         ot->exec = material_slot_add_exec;
131         ot->poll = ED_operator_object_active_editable;
132
133         /* flags */
134         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
135 }
136
137 static int material_slot_remove_exec(bContext *C, wmOperator *op)
138 {
139         Object *ob = ED_object_context(C);
140
141         if (!ob)
142                 return OPERATOR_CANCELLED;
143
144         /* Removing material slots in edit mode screws things up, see bug #21822.*/
145         if (ob == CTX_data_edit_object(C)) {
146                 BKE_report(op->reports, RPT_ERROR, "Unable to remove material slot in edit mode");
147                 return OPERATOR_CANCELLED;
148         }
149         
150         BKE_object_material_slot_remove(ob);
151
152         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
153                 Scene *scene = CTX_data_scene(C);
154                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
155                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
156         }
157         
158         DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
159         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
160         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
161         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_PREVIEW, ob);
162         
163         return OPERATOR_FINISHED;
164 }
165
166 void OBJECT_OT_material_slot_remove(wmOperatorType *ot)
167 {
168         /* identifiers */
169         ot->name = "Remove Material Slot";
170         ot->idname = "OBJECT_OT_material_slot_remove";
171         ot->description = "Remove the selected material slot";
172         
173         /* api callbacks */
174         ot->exec = material_slot_remove_exec;
175         ot->poll = ED_operator_object_active_editable;
176
177         /* flags */
178         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
179 }
180
181 static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op))
182 {
183         Object *ob = ED_object_context(C);
184
185         if (!ob)
186                 return OPERATOR_CANCELLED;
187
188         if (ob && ob->actcol > 0) {
189                 if (ob->type == OB_MESH) {
190                         BMEditMesh *em = BKE_editmesh_from_object(ob);
191                         BMFace *efa;
192                         BMIter iter;
193
194                         if (em) {
195                                 BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
196                                         if (BM_elem_flag_test(efa, BM_ELEM_SELECT))
197                                                 efa->mat_nr = ob->actcol - 1;
198                                 }
199                         }
200                 }
201                 else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
202                         Nurb *nu;
203                         ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
204
205                         if (nurbs) {
206                                 for (nu = nurbs->first; nu; nu = nu->next) {
207                                         if (ED_curve_nurb_select_check(ob->data, nu)) {
208                                                 nu->mat_nr = ob->actcol - 1;
209                                         }
210                                 }
211                         }
212                 }
213                 else if (ob->type == OB_FONT) {
214                         EditFont *ef = ((Curve *)ob->data)->editfont;
215                         int i, selstart, selend;
216
217                         if (ef && BKE_vfont_select_get(ob, &selstart, &selend)) {
218                                 for (i = selstart; i <= selend; i++)
219                                         ef->textbufinfo[i].mat_nr = ob->actcol;
220                         }
221                 }
222         }
223
224         DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
225         WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
226         
227         return OPERATOR_FINISHED;
228 }
229
230 void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
231 {
232         /* identifiers */
233         ot->name = "Assign Material Slot";
234         ot->idname = "OBJECT_OT_material_slot_assign";
235         ot->description = "Assign active material slot to selection";
236         
237         /* api callbacks */
238         ot->exec = material_slot_assign_exec;
239         ot->poll = ED_operator_object_active_editable;
240
241         /* flags */
242         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
243 }
244
245 static int material_slot_de_select(bContext *C, bool select)
246 {
247         Object *ob = ED_object_context(C);
248
249         if (!ob)
250                 return OPERATOR_CANCELLED;
251
252         if (ob->type == OB_MESH) {
253                 BMEditMesh *em = BKE_editmesh_from_object(ob);
254
255                 if (em) {
256                         EDBM_deselect_by_material(em, ob->actcol - 1, select);
257                 }
258         }
259         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
260                 ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
261                 Nurb *nu;
262                 BPoint *bp;
263                 BezTriple *bezt;
264                 int a;
265
266                 if (nurbs) {
267                         for (nu = nurbs->first; nu; nu = nu->next) {
268                                 if (nu->mat_nr == ob->actcol - 1) {
269                                         if (nu->bezt) {
270                                                 a = nu->pntsu;
271                                                 bezt = nu->bezt;
272                                                 while (a--) {
273                                                         if (bezt->hide == 0) {
274                                                                 if (select) {
275                                                                         bezt->f1 |= SELECT;
276                                                                         bezt->f2 |= SELECT;
277                                                                         bezt->f3 |= SELECT;
278                                                                 }
279                                                                 else {
280                                                                         bezt->f1 &= ~SELECT;
281                                                                         bezt->f2 &= ~SELECT;
282                                                                         bezt->f3 &= ~SELECT;
283                                                                 }
284                                                         }
285                                                         bezt++;
286                                                 }
287                                         }
288                                         else if (nu->bp) {
289                                                 a = nu->pntsu * nu->pntsv;
290                                                 bp = nu->bp;
291                                                 while (a--) {
292                                                         if (bp->hide == 0) {
293                                                                 if (select) bp->f1 |= SELECT;
294                                                                 else bp->f1 &= ~SELECT;
295                                                         }
296                                                         bp++;
297                                                 }
298                                         }
299                                 }
300                         }
301                 }
302         }
303
304         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
305
306         return OPERATOR_FINISHED;
307 }
308
309 static int material_slot_select_exec(bContext *C, wmOperator *UNUSED(op))
310 {
311         return material_slot_de_select(C, true);
312 }
313
314 void OBJECT_OT_material_slot_select(wmOperatorType *ot)
315 {
316         /* identifiers */
317         ot->name = "Select Material Slot";
318         ot->idname = "OBJECT_OT_material_slot_select";
319         ot->description = "Select by active material slot";
320         
321         /* api callbacks */
322         ot->exec = material_slot_select_exec;
323
324         /* flags */
325         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
326 }
327
328 static int material_slot_deselect_exec(bContext *C, wmOperator *UNUSED(op))
329 {
330         return material_slot_de_select(C, false);
331 }
332
333 void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
334 {
335         /* identifiers */
336         ot->name = "Deselect Material Slot";
337         ot->idname = "OBJECT_OT_material_slot_deselect";
338         ot->description = "Deselect by active material slot";
339         
340         /* api callbacks */
341         ot->exec = material_slot_deselect_exec;
342
343         /* flags */
344         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
345 }
346
347
348 static int material_slot_copy_exec(bContext *C, wmOperator *UNUSED(op))
349 {
350         Object *ob = ED_object_context(C);
351         Material ***matar;
352
353         if (!ob || !(matar = give_matarar(ob)))
354                 return OPERATOR_CANCELLED;
355
356         CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects)
357         {
358                 if (ob != ob_iter && give_matarar(ob_iter)) {
359                         if (ob->data != ob_iter->data)
360                                 assign_matarar(ob_iter, matar, ob->totcol);
361                         
362                         if (ob_iter->totcol == ob->totcol) {
363                                 ob_iter->actcol = ob->actcol;
364                                 DEG_id_tag_update(&ob_iter->id, OB_RECALC_DATA);
365                                 WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob_iter);
366                         }
367                 }
368         }
369         CTX_DATA_END;
370
371         return OPERATOR_FINISHED;
372 }
373
374
375 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
376 {
377         /* identifiers */
378         ot->name = "Copy Material to Others";
379         ot->idname = "OBJECT_OT_material_slot_copy";
380         ot->description = "Copies materials to other selected objects";
381
382         /* api callbacks */
383         ot->exec = material_slot_copy_exec;
384
385         /* flags */
386         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
387 }
388
389 static int material_slot_move_exec(bContext *C, wmOperator *op)
390 {
391         Object *ob = ED_object_context(C);
392
393         unsigned int *slot_remap;
394         int index_pair[2];
395
396         int dir = RNA_enum_get(op->ptr, "direction");
397
398         if (!ob || ob->totcol < 2) {
399                 return OPERATOR_CANCELLED;
400         }
401
402         /* up */
403         if (dir == 1 && ob->actcol > 1) {
404                 index_pair[0] = ob->actcol - 2;
405                 index_pair[1] = ob->actcol - 1;
406                 ob->actcol--;
407         }
408         /* down */
409         else if (dir == -1 && ob->actcol < ob->totcol) {
410                 index_pair[0] = ob->actcol - 1;
411                 index_pair[1] = ob->actcol - 0;
412                 ob->actcol++;
413         }
414         else {
415                 return OPERATOR_CANCELLED;
416         }
417
418         slot_remap = MEM_mallocN(sizeof(unsigned int) * ob->totcol, __func__);
419
420         range_vn_u(slot_remap, ob->totcol, 0);
421
422         slot_remap[index_pair[0]] = index_pair[1];
423         slot_remap[index_pair[1]] = index_pair[0];
424
425         BKE_material_remap_object(ob, slot_remap);
426
427         MEM_freeN(slot_remap);
428
429         DEG_id_tag_update(&ob->id, OB_RECALC_DATA);
430         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
431         WM_event_add_notifier(C, NC_OBJECT | ND_DATA, ob);
432
433         return OPERATOR_FINISHED;
434 }
435
436 void OBJECT_OT_material_slot_move(wmOperatorType *ot)
437 {
438         static const EnumPropertyItem material_slot_move[] = {
439                 {1, "UP", 0, "Up", ""},
440                 {-1, "DOWN", 0, "Down", ""},
441                 {0, NULL, 0, NULL, NULL}
442         };
443
444         /* identifiers */
445         ot->name = "Move Material";
446         ot->idname = "OBJECT_OT_material_slot_move";
447         ot->description = "Move the active material up/down in the list";
448
449         /* api callbacks */
450         ot->exec = material_slot_move_exec;
451
452         /* flags */
453         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
454
455         RNA_def_enum(ot->srna, "direction", material_slot_move, 0, "Direction",
456                      "Direction to move the active material towards");
457 }
458
459 /********************** new material operator *********************/
460
461 static int new_material_exec(bContext *C, wmOperator *UNUSED(op))
462 {
463         Scene *scene = CTX_data_scene(C);
464         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
465         Main *bmain = CTX_data_main(C);
466         PointerRNA ptr, idptr;
467         PropertyRNA *prop;
468
469         /* add or copy material */
470         if (ma) {
471                 ma = BKE_material_copy(bmain, ma);
472         }
473         else {
474                 ma = BKE_material_add(bmain, DATA_("Material"));
475
476                 if (BKE_scene_use_new_shading_nodes(scene)) {
477                         ED_node_shader_default(C, &ma->id);
478                         ma->use_nodes = true;
479                 }
480         }
481
482         /* hook into UI */
483         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
484
485         if (prop) {
486                 /* when creating new ID blocks, use is already 1, but RNA
487                  * pointer use also increases user, so this compensates it */
488                 id_us_min(&ma->id);
489
490                 RNA_id_pointer_create(&ma->id, &idptr);
491                 RNA_property_pointer_set(&ptr, prop, idptr);
492                 RNA_property_update(C, &ptr, prop);
493         }
494
495         WM_event_add_notifier(C, NC_MATERIAL | NA_ADDED, ma);
496         
497         return OPERATOR_FINISHED;
498 }
499
500 void MATERIAL_OT_new(wmOperatorType *ot)
501 {
502         /* identifiers */
503         ot->name = "New Material";
504         ot->idname = "MATERIAL_OT_new";
505         ot->description = "Add a new material";
506         
507         /* api callbacks */
508         ot->exec = new_material_exec;
509
510         /* flags */
511         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
512 }
513
514 /********************** new texture operator *********************/
515
516 static int new_texture_exec(bContext *C, wmOperator *UNUSED(op))
517 {
518         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
519         Main *bmain = CTX_data_main(C);
520         PointerRNA ptr, idptr;
521         PropertyRNA *prop;
522
523         /* add or copy texture */
524         if (tex) {
525                 tex = BKE_texture_copy(bmain, tex);
526         }
527         else {
528                 tex = BKE_texture_add(bmain, DATA_("Texture"));
529         }
530
531         /* hook into UI */
532         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
533
534         if (prop) {
535                 /* when creating new ID blocks, use is already 1, but RNA
536                  * pointer use also increases user, so this compensates it */
537                 id_us_min(&tex->id);
538
539                 if (ptr.id.data && GS(((ID *)ptr.id.data)->name) == ID_MA &&
540                     RNA_property_pointer_get(&ptr, prop).id.data == NULL)
541                 {
542                         /* In case we are assigning new texture to a material, and active slot was empty, reset 'use' flag. */
543                         Material *ma = (Material *)ptr.id.data;
544                         ma->septex &= ~(1 << ma->texact);
545                 }
546
547                 RNA_id_pointer_create(&tex->id, &idptr);
548                 RNA_property_pointer_set(&ptr, prop, idptr);
549                 RNA_property_update(C, &ptr, prop);
550         }
551
552         WM_event_add_notifier(C, NC_TEXTURE | NA_ADDED, tex);
553         
554         return OPERATOR_FINISHED;
555 }
556
557 void TEXTURE_OT_new(wmOperatorType *ot)
558 {
559         /* identifiers */
560         ot->name = "New Texture";
561         ot->idname = "TEXTURE_OT_new";
562         ot->description = "Add a new texture";
563         
564         /* api callbacks */
565         ot->exec = new_texture_exec;
566
567         /* flags */
568         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
569 }
570
571 /********************** new world operator *********************/
572
573 static int new_world_exec(bContext *C, wmOperator *UNUSED(op))
574 {
575         Scene *scene = CTX_data_scene(C);
576         World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
577         Main *bmain = CTX_data_main(C);
578         PointerRNA ptr, idptr;
579         PropertyRNA *prop;
580
581         /* add or copy world */
582         if (wo) {
583                 wo = BKE_world_copy(bmain, wo);
584         }
585         else {
586                 wo = BKE_world_add(bmain, DATA_("World"));
587
588                 if (BKE_scene_use_new_shading_nodes(scene)) {
589                         ED_node_shader_default(C, &wo->id);
590                         wo->use_nodes = true;
591                 }
592         }
593
594         /* hook into UI */
595         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
596
597         if (prop) {
598                 /* when creating new ID blocks, use is already 1, but RNA
599                  * pointer use also increases user, so this compensates it */
600                 id_us_min(&wo->id);
601
602                 RNA_id_pointer_create(&wo->id, &idptr);
603                 RNA_property_pointer_set(&ptr, prop, idptr);
604                 RNA_property_update(C, &ptr, prop);
605         }
606
607         WM_event_add_notifier(C, NC_WORLD | NA_ADDED, wo);
608         
609         return OPERATOR_FINISHED;
610 }
611
612 void WORLD_OT_new(wmOperatorType *ot)
613 {
614         /* identifiers */
615         ot->name = "New World";
616         ot->idname = "WORLD_OT_new";
617         ot->description = "Create a new world Data-Block";
618         
619         /* api callbacks */
620         ot->exec = new_world_exec;
621
622         /* flags */
623         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
624 }
625
626 /********************** render layer operators *********************/
627
628 static int view_layer_add_exec(bContext *C, wmOperator *UNUSED(op))
629 {
630         Scene *scene = CTX_data_scene(C);
631
632         BKE_view_layer_add(scene, NULL);
633         scene->active_view_layer = BLI_listbase_count(&scene->view_layers) - 1;
634
635         DEG_id_tag_update(&scene->id, 0);
636         DEG_relations_tag_update(CTX_data_main(C));
637         WM_event_add_notifier(C, NC_SCENE | ND_LAYER, scene);
638         
639         return OPERATOR_FINISHED;
640 }
641
642 void SCENE_OT_view_layer_add(wmOperatorType *ot)
643 {
644         /* identifiers */
645         ot->name = "Add View Layer";
646         ot->idname = "SCENE_OT_view_layer_add";
647         ot->description = "Add a view layer";
648         
649         /* api callbacks */
650         ot->exec = view_layer_add_exec;
651
652         /* flags */
653         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
654 }
655
656 static int view_layer_remove_exec(bContext *C, wmOperator *UNUSED(op))
657 {
658         Main *bmain = CTX_data_main(C);
659         Scene *scene = CTX_data_scene(C);
660         ViewLayer *view_layer = BKE_view_layer_from_scene_get(scene);
661
662         if (!ED_scene_view_layer_delete(bmain, scene, view_layer, NULL)) {
663                 return OPERATOR_CANCELLED;
664         }
665
666         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
667
668         return OPERATOR_FINISHED;
669 }
670
671 void SCENE_OT_view_layer_remove(wmOperatorType *ot)
672 {
673         /* identifiers */
674         ot->name = "Remove View Layer";
675         ot->idname = "SCENE_OT_view_layer_remove";
676         ot->description = "Remove the selected view layer";
677         
678         /* api callbacks */
679         ot->exec = view_layer_remove_exec;
680
681         /* flags */
682         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
683 }
684
685 /********************** render view operators *********************/
686
687 static int render_view_remove_poll(bContext *C)
688 {
689         Scene *scene = CTX_data_scene(C);
690
691         /* don't allow user to remove "left" and "right" views */
692         return scene->r.actview > 1;
693 }
694
695 static int render_view_add_exec(bContext *C, wmOperator *UNUSED(op))
696 {
697         Scene *scene = CTX_data_scene(C);
698
699         BKE_scene_add_render_view(scene, NULL);
700         scene->r.actview = BLI_listbase_count(&scene->r.views) - 1;
701
702         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
703
704         return OPERATOR_FINISHED;
705 }
706
707 void SCENE_OT_render_view_add(wmOperatorType *ot)
708 {
709         /* identifiers */
710         ot->name = "Add Render View";
711         ot->idname = "SCENE_OT_render_view_add";
712         ot->description = "Add a render view";
713
714         /* api callbacks */
715         ot->exec = render_view_add_exec;
716
717         /* flags */
718         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
719 }
720
721 static int render_view_remove_exec(bContext *C, wmOperator *UNUSED(op))
722 {
723         Scene *scene = CTX_data_scene(C);
724         SceneRenderView *rv = BLI_findlink(&scene->r.views, scene->r.actview);
725
726         if (!BKE_scene_remove_render_view(scene, rv))
727                 return OPERATOR_CANCELLED;
728
729         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
730
731         return OPERATOR_FINISHED;
732 }
733
734 void SCENE_OT_render_view_remove(wmOperatorType *ot)
735 {
736         /* identifiers */
737         ot->name = "Remove Render View";
738         ot->idname = "SCENE_OT_render_view_remove";
739         ot->description = "Remove the selected render view";
740
741         /* api callbacks */
742         ot->exec = render_view_remove_exec;
743         ot->poll = render_view_remove_poll;
744
745         /* flags */
746         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
747 }
748
749 #ifdef WITH_FREESTYLE
750
751 static bool freestyle_linestyle_check_report(FreestyleLineSet *lineset, ReportList *reports)
752 {
753         if (!lineset) {
754                 BKE_report(reports, RPT_ERROR, "No active lineset and associated line style to manipulate the modifier");
755                 return false;
756         }
757         if (!lineset->linestyle) {
758                 BKE_report(reports, RPT_ERROR, "The active lineset does not have a line style (indicating data corruption)");
759                 return false;
760         }
761
762         return true;
763 }
764
765 static int freestyle_active_module_poll(bContext *C)
766 {
767         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
768         FreestyleModuleConfig *module = ptr.data;
769
770         return module != NULL;
771 }
772
773 static int freestyle_module_add_exec(bContext *C, wmOperator *UNUSED(op))
774 {
775         Scene *scene = CTX_data_scene(C);
776         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
777
778         BKE_freestyle_module_add(&view_layer->freestyle_config);
779
780         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
781
782         return OPERATOR_FINISHED;
783 }
784
785 void SCENE_OT_freestyle_module_add(wmOperatorType *ot)
786 {
787         /* identifiers */
788         ot->name = "Add Freestyle Module";
789         ot->idname = "SCENE_OT_freestyle_module_add";
790         ot->description = "Add a style module into the list of modules";
791
792         /* api callbacks */
793         ot->exec = freestyle_module_add_exec;
794
795         /* flags */
796         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
797 }
798
799 static int freestyle_module_remove_exec(bContext *C, wmOperator *UNUSED(op))
800 {
801         Scene *scene = CTX_data_scene(C);
802         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
803         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
804         FreestyleModuleConfig *module = ptr.data;
805
806         BKE_freestyle_module_delete(&view_layer->freestyle_config, module);
807
808         DEG_id_tag_update(&scene->id, 0);
809         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
810
811         return OPERATOR_FINISHED;
812 }
813
814 void SCENE_OT_freestyle_module_remove(wmOperatorType *ot)
815 {
816         /* identifiers */
817         ot->name = "Remove Freestyle Module";
818         ot->idname = "SCENE_OT_freestyle_module_remove";
819         ot->description = "Remove the style module from the stack";
820
821         /* api callbacks */
822         ot->poll = freestyle_active_module_poll;
823         ot->exec = freestyle_module_remove_exec;
824
825         /* flags */
826         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
827 }
828
829 static int freestyle_module_move_exec(bContext *C, wmOperator *op)
830 {
831         Scene *scene = CTX_data_scene(C);
832         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
833         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
834         FreestyleModuleConfig *module = ptr.data;
835         int dir = RNA_enum_get(op->ptr, "direction");
836
837         if (BKE_freestyle_module_move(&view_layer->freestyle_config, module, dir)) {
838                 DEG_id_tag_update(&scene->id, 0);
839                 WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
840         }
841
842         return OPERATOR_FINISHED;
843 }
844
845 void SCENE_OT_freestyle_module_move(wmOperatorType *ot)
846 {
847         static const EnumPropertyItem direction_items[] = {
848                 {-1, "UP", 0, "Up", ""},
849                 {1, "DOWN", 0, "Down", ""},
850                 {0, NULL, 0, NULL, NULL}
851         };
852
853         /* identifiers */
854         ot->name = "Move Freestyle Module";
855         ot->idname = "SCENE_OT_freestyle_module_move";
856         ot->description = "Change the position of the style module within in the list of style modules";
857
858         /* api callbacks */
859         ot->poll = freestyle_active_module_poll;
860         ot->exec = freestyle_module_move_exec;
861
862         /* flags */
863         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
864
865         /* props */
866         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
867                      "Direction to move the chosen style module towards");
868 }
869
870 static int freestyle_lineset_add_exec(bContext *C, wmOperator *UNUSED(op))
871 {
872         Main *bmain = CTX_data_main(C);
873         Scene *scene = CTX_data_scene(C);
874         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
875
876         BKE_freestyle_lineset_add(bmain, &view_layer->freestyle_config, NULL);
877
878         DEG_id_tag_update(&scene->id, 0);
879         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
880
881         return OPERATOR_FINISHED;
882 }
883
884 void SCENE_OT_freestyle_lineset_add(wmOperatorType *ot)
885 {
886         /* identifiers */
887         ot->name = "Add Line Set";
888         ot->idname = "SCENE_OT_freestyle_lineset_add";
889         ot->description = "Add a line set into the list of line sets";
890
891         /* api callbacks */
892         ot->exec = freestyle_lineset_add_exec;
893
894         /* flags */
895         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
896 }
897
898 static int freestyle_active_lineset_poll(bContext *C)
899 {
900         Scene *scene = CTX_data_scene(C);
901         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
902
903         if (!view_layer) {
904                 return false;
905         }
906
907         return BKE_freestyle_lineset_get_active(&view_layer->freestyle_config) != NULL;
908 }
909
910 static int freestyle_lineset_copy_exec(bContext *C, wmOperator *UNUSED(op))
911 {
912         Scene *scene = CTX_data_scene(C);
913         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
914
915         FRS_copy_active_lineset(&view_layer->freestyle_config);
916
917         return OPERATOR_FINISHED;
918 }
919
920 void SCENE_OT_freestyle_lineset_copy(wmOperatorType *ot)
921 {
922         /* identifiers */
923         ot->name = "Copy Line Set";
924         ot->idname = "SCENE_OT_freestyle_lineset_copy";
925         ot->description = "Copy the active line set to a buffer";
926
927         /* api callbacks */
928         ot->exec = freestyle_lineset_copy_exec;
929         ot->poll = freestyle_active_lineset_poll;
930
931         /* flags */
932         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
933 }
934
935 static int freestyle_lineset_paste_exec(bContext *C, wmOperator *UNUSED(op))
936 {
937         Scene *scene = CTX_data_scene(C);
938         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
939
940         FRS_paste_active_lineset(&view_layer->freestyle_config);
941
942         DEG_id_tag_update(&scene->id, 0);
943         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
944
945         return OPERATOR_FINISHED;
946 }
947
948 void SCENE_OT_freestyle_lineset_paste(wmOperatorType *ot)
949 {
950         /* identifiers */
951         ot->name = "Paste Line Set";
952         ot->idname = "SCENE_OT_freestyle_lineset_paste";
953         ot->description = "Paste the buffer content to the active line set";
954
955         /* api callbacks */
956         ot->exec = freestyle_lineset_paste_exec;
957         ot->poll = freestyle_active_lineset_poll;
958
959         /* flags */
960         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
961 }
962
963 static int freestyle_lineset_remove_exec(bContext *C, wmOperator *UNUSED(op))
964 {
965         Scene *scene = CTX_data_scene(C);
966         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
967
968         FRS_delete_active_lineset(&view_layer->freestyle_config);
969
970         DEG_id_tag_update(&scene->id, 0);
971         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
972
973         return OPERATOR_FINISHED;
974 }
975
976 void SCENE_OT_freestyle_lineset_remove(wmOperatorType *ot)
977 {
978         /* identifiers */
979         ot->name = "Remove Line Set";
980         ot->idname = "SCENE_OT_freestyle_lineset_remove";
981         ot->description = "Remove the active line set from the list of line sets";
982
983         /* api callbacks */
984         ot->exec = freestyle_lineset_remove_exec;
985         ot->poll = freestyle_active_lineset_poll;
986
987         /* flags */
988         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
989 }
990
991 static int freestyle_lineset_move_exec(bContext *C, wmOperator *op)
992 {
993         Scene *scene = CTX_data_scene(C);
994         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
995         int dir = RNA_enum_get(op->ptr, "direction");
996
997         if (FRS_move_active_lineset(&view_layer->freestyle_config, dir)) {
998                 DEG_id_tag_update(&scene->id, 0);
999                 WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
1000         }
1001
1002         return OPERATOR_FINISHED;
1003 }
1004
1005 void SCENE_OT_freestyle_lineset_move(wmOperatorType *ot)
1006 {
1007         static const EnumPropertyItem direction_items[] = {
1008                 {-1, "UP", 0, "Up", ""},
1009                 {1, "DOWN", 0, "Down", ""},
1010                 {0, NULL, 0, NULL, NULL}
1011         };
1012
1013         /* identifiers */
1014         ot->name = "Move Line Set";
1015         ot->idname = "SCENE_OT_freestyle_lineset_move";
1016         ot->description = "Change the position of the active line set within the list of line sets";
1017
1018         /* api callbacks */
1019         ot->exec = freestyle_lineset_move_exec;
1020         ot->poll = freestyle_active_lineset_poll;
1021
1022         /* flags */
1023         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1024
1025         /* props */
1026         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
1027                      "Direction to move the active line set towards");
1028 }
1029
1030 static int freestyle_linestyle_new_exec(bContext *C, wmOperator *op)
1031 {
1032         Main *bmain = CTX_data_main(C);
1033         Scene *scene = CTX_data_scene(C);
1034         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1035         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1036
1037         if (!lineset) {
1038                 BKE_report(op->reports, RPT_ERROR, "No active lineset to add a new line style to");
1039                 return OPERATOR_CANCELLED;
1040         }
1041         if (lineset->linestyle) {
1042                 id_us_min(&lineset->linestyle->id);
1043                 lineset->linestyle = BKE_linestyle_copy(bmain, lineset->linestyle);
1044         }
1045         else {
1046                 lineset->linestyle = BKE_linestyle_new(bmain, "LineStyle");
1047         }
1048         DEG_id_tag_update(&lineset->linestyle->id, 0);
1049         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1050
1051         return OPERATOR_FINISHED;
1052 }
1053
1054 void SCENE_OT_freestyle_linestyle_new(wmOperatorType *ot)
1055 {
1056         /* identifiers */
1057         ot->name = "New Line Style";
1058         ot->idname = "SCENE_OT_freestyle_linestyle_new";
1059         ot->description = "Create a new line style, reusable by multiple line sets";
1060
1061         /* api callbacks */
1062         ot->exec = freestyle_linestyle_new_exec;
1063         ot->poll = freestyle_active_lineset_poll;
1064
1065         /* flags */
1066         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1067 }
1068
1069 static int freestyle_color_modifier_add_exec(bContext *C, wmOperator *op)
1070 {
1071         Scene *scene = CTX_data_scene(C);
1072         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1073         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1074         int type = RNA_enum_get(op->ptr, "type");
1075
1076         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1077                 return OPERATOR_CANCELLED;
1078         }
1079
1080         if (BKE_linestyle_color_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1081                 BKE_report(op->reports, RPT_ERROR, "Unknown line color modifier type");
1082                 return OPERATOR_CANCELLED;
1083         }
1084         DEG_id_tag_update(&lineset->linestyle->id, 0);
1085         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1086
1087         return OPERATOR_FINISHED;
1088 }
1089
1090 void SCENE_OT_freestyle_color_modifier_add(wmOperatorType *ot)
1091 {
1092         /* identifiers */
1093         ot->name = "Add Line Color Modifier";
1094         ot->idname = "SCENE_OT_freestyle_color_modifier_add";
1095         ot->description = "Add a line color modifier to the line style associated with the active lineset";
1096
1097         /* api callbacks */
1098         ot->invoke = WM_menu_invoke;
1099         ot->exec = freestyle_color_modifier_add_exec;
1100         ot->poll = freestyle_active_lineset_poll;
1101
1102         /* flags */
1103         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1104
1105         /* properties */
1106         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_color_modifier_type_items, 0, "Type", "");
1107 }
1108
1109 static int freestyle_alpha_modifier_add_exec(bContext *C, wmOperator *op)
1110 {
1111         Scene *scene = CTX_data_scene(C);
1112         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1113         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1114         int type = RNA_enum_get(op->ptr, "type");
1115
1116         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1117                 return OPERATOR_CANCELLED;
1118         }
1119
1120         if (BKE_linestyle_alpha_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1121                 BKE_report(op->reports, RPT_ERROR, "Unknown alpha transparency modifier type");
1122                 return OPERATOR_CANCELLED;
1123         }
1124         DEG_id_tag_update(&lineset->linestyle->id, 0);
1125         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1126
1127         return OPERATOR_FINISHED;
1128 }
1129
1130 void SCENE_OT_freestyle_alpha_modifier_add(wmOperatorType *ot)
1131 {
1132         /* identifiers */
1133         ot->name = "Add Alpha Transparency Modifier";
1134         ot->idname = "SCENE_OT_freestyle_alpha_modifier_add";
1135         ot->description = "Add an alpha transparency modifier to the line style associated with the active lineset";
1136
1137         /* api callbacks */
1138         ot->invoke = WM_menu_invoke;
1139         ot->exec = freestyle_alpha_modifier_add_exec;
1140         ot->poll = freestyle_active_lineset_poll;
1141
1142         /* flags */
1143         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1144
1145         /* properties */
1146         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_alpha_modifier_type_items, 0, "Type", "");
1147 }
1148
1149 static int freestyle_thickness_modifier_add_exec(bContext *C, wmOperator *op)
1150 {
1151         Scene *scene = CTX_data_scene(C);
1152         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1153         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1154         int type = RNA_enum_get(op->ptr, "type");
1155
1156         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1157                 return OPERATOR_CANCELLED;
1158         }
1159
1160         if (BKE_linestyle_thickness_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1161                 BKE_report(op->reports, RPT_ERROR, "Unknown line thickness modifier type");
1162                 return OPERATOR_CANCELLED;
1163         }
1164         DEG_id_tag_update(&lineset->linestyle->id, 0);
1165         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1166
1167         return OPERATOR_FINISHED;
1168 }
1169
1170 void SCENE_OT_freestyle_thickness_modifier_add(wmOperatorType *ot)
1171 {
1172         /* identifiers */
1173         ot->name = "Add Line Thickness Modifier";
1174         ot->idname = "SCENE_OT_freestyle_thickness_modifier_add";
1175         ot->description = "Add a line thickness modifier to the line style associated with the active lineset";
1176
1177         /* api callbacks */
1178         ot->invoke = WM_menu_invoke;
1179         ot->exec = freestyle_thickness_modifier_add_exec;
1180         ot->poll = freestyle_active_lineset_poll;
1181
1182         /* flags */
1183         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1184
1185         /* properties */
1186         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_thickness_modifier_type_items, 0, "Type", "");
1187 }
1188
1189 static int freestyle_geometry_modifier_add_exec(bContext *C, wmOperator *op)
1190 {
1191         Scene *scene = CTX_data_scene(C);
1192         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1193         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1194         int type = RNA_enum_get(op->ptr, "type");
1195
1196         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1197                 return OPERATOR_CANCELLED;
1198         }
1199
1200         if (BKE_linestyle_geometry_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1201                 BKE_report(op->reports, RPT_ERROR, "Unknown stroke geometry modifier type");
1202                 return OPERATOR_CANCELLED;
1203         }
1204         DEG_id_tag_update(&lineset->linestyle->id, 0);
1205         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1206
1207         return OPERATOR_FINISHED;
1208 }
1209
1210 void SCENE_OT_freestyle_geometry_modifier_add(wmOperatorType *ot)
1211 {
1212         /* identifiers */
1213         ot->name = "Add Stroke Geometry Modifier";
1214         ot->idname = "SCENE_OT_freestyle_geometry_modifier_add";
1215         ot->description = "Add a stroke geometry modifier to the line style associated with the active lineset";
1216
1217         /* api callbacks */
1218         ot->invoke = WM_menu_invoke;
1219         ot->exec = freestyle_geometry_modifier_add_exec;
1220         ot->poll = freestyle_active_lineset_poll;
1221
1222         /* flags */
1223         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1224
1225         /* properties */
1226         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_geometry_modifier_type_items, 0, "Type", "");
1227 }
1228
1229 static int freestyle_get_modifier_type(PointerRNA *ptr)
1230 {
1231         if (RNA_struct_is_a(ptr->type, &RNA_LineStyleColorModifier))
1232                 return LS_MODIFIER_TYPE_COLOR;
1233         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleAlphaModifier))
1234                 return LS_MODIFIER_TYPE_ALPHA;
1235         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleThicknessModifier))
1236                 return LS_MODIFIER_TYPE_THICKNESS;
1237         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleGeometryModifier))
1238                 return LS_MODIFIER_TYPE_GEOMETRY;
1239         return -1;
1240 }
1241
1242 static int freestyle_modifier_remove_exec(bContext *C, wmOperator *op)
1243 {
1244         Scene *scene = CTX_data_scene(C);
1245         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1246         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1247         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1248         LineStyleModifier *modifier = ptr.data;
1249
1250         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1251                 return OPERATOR_CANCELLED;
1252         }
1253
1254         switch (freestyle_get_modifier_type(&ptr)) {
1255                 case LS_MODIFIER_TYPE_COLOR:
1256                         BKE_linestyle_color_modifier_remove(lineset->linestyle, modifier);
1257                         break;
1258                 case LS_MODIFIER_TYPE_ALPHA:
1259                         BKE_linestyle_alpha_modifier_remove(lineset->linestyle, modifier);
1260                         break;
1261                 case LS_MODIFIER_TYPE_THICKNESS:
1262                         BKE_linestyle_thickness_modifier_remove(lineset->linestyle, modifier);
1263                         break;
1264                 case LS_MODIFIER_TYPE_GEOMETRY:
1265                         BKE_linestyle_geometry_modifier_remove(lineset->linestyle, modifier);
1266                         break;
1267                 default:
1268                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1269                         return OPERATOR_CANCELLED;
1270         }
1271         DEG_id_tag_update(&lineset->linestyle->id, 0);
1272         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1273
1274         return OPERATOR_FINISHED;
1275 }
1276
1277 void SCENE_OT_freestyle_modifier_remove(wmOperatorType *ot)
1278 {
1279         /* identifiers */
1280         ot->name = "Remove Modifier";
1281         ot->idname = "SCENE_OT_freestyle_modifier_remove";
1282         ot->description = "Remove the modifier from the list of modifiers";
1283
1284         /* api callbacks */
1285         ot->exec = freestyle_modifier_remove_exec;
1286         ot->poll = freestyle_active_lineset_poll;
1287
1288         /* flags */
1289         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1290 }
1291
1292 static int freestyle_modifier_copy_exec(bContext *C, wmOperator *op)
1293 {
1294         Scene *scene = CTX_data_scene(C);
1295         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1296         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1297         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1298         LineStyleModifier *modifier = ptr.data;
1299
1300         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1301                 return OPERATOR_CANCELLED;
1302         }
1303
1304         switch (freestyle_get_modifier_type(&ptr)) {
1305                 case LS_MODIFIER_TYPE_COLOR:
1306                         BKE_linestyle_color_modifier_copy(lineset->linestyle, modifier, 0);
1307                         break;
1308                 case LS_MODIFIER_TYPE_ALPHA:
1309                         BKE_linestyle_alpha_modifier_copy(lineset->linestyle, modifier, 0);
1310                         break;
1311                 case LS_MODIFIER_TYPE_THICKNESS:
1312                         BKE_linestyle_thickness_modifier_copy(lineset->linestyle, modifier, 0);
1313                         break;
1314                 case LS_MODIFIER_TYPE_GEOMETRY:
1315                         BKE_linestyle_geometry_modifier_copy(lineset->linestyle, modifier, 0);
1316                         break;
1317                 default:
1318                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1319                         return OPERATOR_CANCELLED;
1320         }
1321         DEG_id_tag_update(&lineset->linestyle->id, 0);
1322         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1323
1324         return OPERATOR_FINISHED;
1325 }
1326
1327 void SCENE_OT_freestyle_modifier_copy(wmOperatorType *ot)
1328 {
1329         /* identifiers */
1330         ot->name = "Copy Modifier";
1331         ot->idname = "SCENE_OT_freestyle_modifier_copy";
1332         ot->description = "Duplicate the modifier within the list of modifiers";
1333
1334         /* api callbacks */
1335         ot->exec = freestyle_modifier_copy_exec;
1336         ot->poll = freestyle_active_lineset_poll;
1337
1338         /* flags */
1339         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1340 }
1341
1342 static int freestyle_modifier_move_exec(bContext *C, wmOperator *op)
1343 {
1344         Scene *scene = CTX_data_scene(C);
1345         ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
1346         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&view_layer->freestyle_config);
1347         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1348         LineStyleModifier *modifier = ptr.data;
1349         int dir = RNA_enum_get(op->ptr, "direction");
1350         bool changed = false;
1351
1352         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1353                 return OPERATOR_CANCELLED;
1354         }
1355
1356         switch (freestyle_get_modifier_type(&ptr)) {
1357                 case LS_MODIFIER_TYPE_COLOR:
1358                         changed = BKE_linestyle_color_modifier_move(lineset->linestyle, modifier, dir);
1359                         break;
1360                 case LS_MODIFIER_TYPE_ALPHA:
1361                         changed = BKE_linestyle_alpha_modifier_move(lineset->linestyle, modifier, dir);
1362                         break;
1363                 case LS_MODIFIER_TYPE_THICKNESS:
1364                         changed = BKE_linestyle_thickness_modifier_move(lineset->linestyle, modifier, dir);
1365                         break;
1366                 case LS_MODIFIER_TYPE_GEOMETRY:
1367                         changed = BKE_linestyle_geometry_modifier_move(lineset->linestyle, modifier, dir);
1368                         break;
1369                 default:
1370                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1371                         return OPERATOR_CANCELLED;
1372         }
1373
1374         if (changed) {
1375                 DEG_id_tag_update(&lineset->linestyle->id, 0);
1376                 WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1377         }
1378
1379         return OPERATOR_FINISHED;
1380 }
1381
1382 void SCENE_OT_freestyle_modifier_move(wmOperatorType *ot)
1383 {
1384         static const EnumPropertyItem direction_items[] = {
1385                 {-1, "UP", 0, "Up", ""},
1386                 {1, "DOWN", 0, "Down", ""},
1387                 {0, NULL, 0, NULL, NULL}
1388         };
1389
1390         /* identifiers */
1391         ot->name = "Move Modifier";
1392         ot->idname = "SCENE_OT_freestyle_modifier_move";
1393         ot->description = "Move the modifier within the list of modifiers";
1394
1395         /* api callbacks */
1396         ot->exec = freestyle_modifier_move_exec;
1397         ot->poll = freestyle_active_lineset_poll;
1398
1399         /* flags */
1400         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1401
1402         /* props */
1403         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
1404                      "Direction to move the chosen modifier towards");
1405 }
1406
1407 static int freestyle_stroke_material_create_exec(bContext *C, wmOperator *op)
1408 {
1409         Main *bmain = CTX_data_main(C);
1410         Scene *scene = CTX_data_scene(C);
1411         FreestyleLineStyle *linestyle = BKE_linestyle_active_from_scene(scene);
1412
1413         if (!linestyle) {
1414                 BKE_report(op->reports, RPT_ERROR, "No active line style in the current scene");
1415                 return OPERATOR_CANCELLED;
1416         }
1417
1418         FRS_create_stroke_material(bmain, linestyle);
1419
1420         return OPERATOR_FINISHED;
1421 }
1422
1423 void SCENE_OT_freestyle_stroke_material_create(wmOperatorType *ot)
1424 {
1425         /* identifiers */
1426         ot->name = "Create Freestyle Stroke Material";
1427         ot->idname = "SCENE_OT_freestyle_stroke_material_create";
1428         ot->description = "Create Freestyle stroke material for testing";
1429
1430         /* api callbacks */
1431         ot->exec = freestyle_stroke_material_create_exec;
1432
1433         /* flags */
1434         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1435 }
1436
1437 #endif /* WITH_FREESTYLE */
1438
1439 static int texture_slot_move_exec(bContext *C, wmOperator *op)
1440 {
1441         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1442
1443         if (id) {
1444                 MTex **mtex_ar, *mtexswap;
1445                 short act;
1446                 int type = RNA_enum_get(op->ptr, "type");
1447                 struct AnimData *adt = BKE_animdata_from_id(id);
1448
1449                 give_active_mtex(id, &mtex_ar, &act);
1450
1451                 if (type == -1) { /* Up */
1452                         if (act > 0) {
1453                                 mtexswap = mtex_ar[act];
1454                                 mtex_ar[act] = mtex_ar[act - 1];
1455                                 mtex_ar[act - 1] = mtexswap;
1456                                 
1457                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act - 1, -1, 0);
1458                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act - 1, 0);
1459                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1460
1461                                 if (GS(id->name) == ID_MA) {
1462                                         Material *ma = (Material *)id;
1463                                         int mtexuse = ma->septex & (1 << act);
1464                                         ma->septex &= ~(1 << act);
1465                                         ma->septex |= (ma->septex & (1 << (act - 1))) << 1;
1466                                         ma->septex &= ~(1 << (act - 1));
1467                                         ma->septex |= mtexuse >> 1;
1468                                 }
1469                                 
1470                                 set_active_mtex(id, act - 1);
1471                         }
1472                 }
1473                 else { /* Down */
1474                         if (act < MAX_MTEX - 1) {
1475                                 mtexswap = mtex_ar[act];
1476                                 mtex_ar[act] = mtex_ar[act + 1];
1477                                 mtex_ar[act + 1] = mtexswap;
1478                                 
1479                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act + 1, -1, 0);
1480                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act + 1, 0);
1481                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1482
1483                                 if (GS(id->name) == ID_MA) {
1484                                         Material *ma = (Material *)id;
1485                                         int mtexuse = ma->septex & (1 << act);
1486                                         ma->septex &= ~(1 << act);
1487                                         ma->septex |= (ma->septex & (1 << (act + 1))) >> 1;
1488                                         ma->septex &= ~(1 << (act + 1));
1489                                         ma->septex |= mtexuse << 1;
1490                                 }
1491                                 
1492                                 set_active_mtex(id, act + 1);
1493                         }
1494                 }
1495
1496                 DEG_id_tag_update(id, 0);
1497                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
1498         }
1499
1500         return OPERATOR_FINISHED;
1501 }
1502
1503 void TEXTURE_OT_slot_move(wmOperatorType *ot)
1504 {
1505         static const EnumPropertyItem slot_move[] = {
1506                 {-1, "UP", 0, "Up", ""},
1507                 {1, "DOWN", 0, "Down", ""},
1508                 {0, NULL, 0, NULL, NULL}
1509         };
1510
1511         /* identifiers */
1512         ot->name = "Move Texture Slot";
1513         ot->idname = "TEXTURE_OT_slot_move";
1514         ot->description = "Move texture slots up and down";
1515
1516         /* api callbacks */
1517         ot->exec = texture_slot_move_exec;
1518
1519         /* flags */
1520         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1521
1522         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
1523 }
1524
1525
1526
1527 /********************** environment map operators *********************/
1528
1529 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *path, const char imtype)
1530 {
1531         PropertyRNA *prop;
1532         float layout[12];
1533
1534         if ((prop = RNA_struct_find_property(op->ptr, "layout"))) {
1535                 RNA_property_float_get_array(op->ptr, prop, layout);
1536         }
1537         else {
1538                 memcpy(layout, default_envmap_layout, sizeof(layout));
1539         }
1540
1541         if (RE_WriteEnvmapResult(op->reports, scene, env, path, imtype, layout)) {
1542                 return OPERATOR_FINISHED;
1543         }
1544         else {
1545                 return OPERATOR_CANCELLED;
1546         }
1547
1548 }
1549
1550 static int envmap_save_exec(bContext *C, wmOperator *op)
1551 {
1552         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1553         Scene *scene = CTX_data_scene(C);
1554         //int imtype = RNA_enum_get(op->ptr, "file_type");
1555         char imtype = scene->r.im_format.imtype;
1556         char path[FILE_MAX];
1557         
1558         RNA_string_get(op->ptr, "filepath", path);
1559         
1560         if (scene->r.scemode & R_EXTENSION) {
1561                 BKE_image_path_ensure_ext_from_imformat(path, &scene->r.im_format);
1562         }
1563         
1564         WM_cursor_wait(1);
1565         
1566         save_envmap(op, scene, tex->env, path, imtype);
1567         
1568         WM_cursor_wait(0);
1569         
1570         WM_event_add_notifier(C, NC_TEXTURE, tex);
1571         
1572         return OPERATOR_FINISHED;
1573 }
1574
1575 static int envmap_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1576 {
1577         //Scene *scene= CTX_data_scene(C);
1578         
1579         if (RNA_struct_property_is_set(op->ptr, "filepath"))
1580                 return envmap_save_exec(C, op);
1581
1582         //RNA_enum_set(op->ptr, "file_type", scene->r.im_format.imtype);
1583         RNA_string_set(op->ptr, "filepath", G.main->name);
1584         WM_event_add_fileselect(C, op);
1585         
1586         return OPERATOR_RUNNING_MODAL;
1587 }
1588
1589 static int envmap_save_poll(bContext *C)
1590 {
1591         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1592
1593         if (!tex) 
1594                 return 0;
1595         if (!tex->env || !tex->env->ok)
1596                 return 0;
1597         if (tex->env->cube[1] == NULL)
1598                 return 0;
1599         
1600         return 1;
1601 }
1602
1603 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
1604 {
1605         PropertyRNA *prop;
1606         /* identifiers */
1607         ot->name = "Save Environment Map";
1608         ot->idname = "TEXTURE_OT_envmap_save";
1609         ot->description = "Save the current generated Environment map to an image file";
1610         
1611         /* api callbacks */
1612         ot->exec = envmap_save_exec;
1613         ot->invoke = envmap_save_invoke;
1614         ot->poll = envmap_save_poll;
1615         
1616         /* flags */
1617         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo since this doesnt modify the env-map */
1618         
1619         /* properties */
1620         prop = RNA_def_float_array(ot->srna, "layout", 12, default_envmap_layout, 0.0f, 0.0f,
1621                                    "File layout",
1622                                    "Flat array describing the X,Y position of each cube face in the output image, "
1623                                    "where 1 is the size of a face - order is [+Z -Z +Y -X -Y +X] "
1624                                    "(use -1 to skip a face)", 0.0f, 0.0f);
1625         RNA_def_property_flag(prop, PROP_HIDDEN);
1626
1627         WM_operator_properties_filesel(
1628                 ot, FILE_TYPE_FOLDER | FILE_TYPE_IMAGE | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_SAVE,
1629                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
1630 }
1631
1632 static int envmap_clear_exec(bContext *C, wmOperator *UNUSED(op))
1633 {
1634         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1635         
1636         BKE_texture_envmap_free_data(tex->env);
1637         
1638         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1639         
1640         return OPERATOR_FINISHED;
1641 }
1642
1643 static int envmap_clear_poll(bContext *C)
1644 {
1645         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1646         
1647         if (!tex) 
1648                 return 0;
1649         if (!tex->env || !tex->env->ok)
1650                 return 0;
1651         if (tex->env->cube[1] == NULL)
1652                 return 0;
1653         
1654         return 1;
1655 }
1656
1657 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
1658 {
1659         /* identifiers */
1660         ot->name = "Clear Environment Map";
1661         ot->idname = "TEXTURE_OT_envmap_clear";
1662         ot->description = "Discard the environment map and free it from memory";
1663         
1664         /* api callbacks */
1665         ot->exec = envmap_clear_exec;
1666         ot->poll = envmap_clear_poll;
1667         
1668         /* flags */
1669         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1670 }
1671
1672 static int envmap_clear_all_exec(bContext *C, wmOperator *UNUSED(op))
1673 {
1674         Main *bmain = CTX_data_main(C);
1675         Tex *tex;
1676         
1677         for (tex = bmain->tex.first; tex; tex = tex->id.next)
1678                 if (tex->env)
1679                         BKE_texture_envmap_free_data(tex->env);
1680         
1681         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1682         
1683         return OPERATOR_FINISHED;
1684 }
1685
1686 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
1687 {
1688         /* identifiers */
1689         ot->name = "Clear All Environment Maps";
1690         ot->idname = "TEXTURE_OT_envmap_clear_all";
1691         ot->description = "Discard all environment maps in the .blend file and free them from memory";
1692         
1693         /* api callbacks */
1694         ot->exec = envmap_clear_all_exec;
1695         ot->poll = envmap_clear_poll;
1696         
1697         /* flags */
1698         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1699 }
1700
1701 /********************** material operators *********************/
1702
1703 /* material copy/paste */
1704 static int copy_material_exec(bContext *C, wmOperator *UNUSED(op))
1705 {
1706         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1707
1708         if (ma == NULL)
1709                 return OPERATOR_CANCELLED;
1710
1711         copy_matcopybuf(ma);
1712
1713         return OPERATOR_FINISHED;
1714 }
1715
1716 void MATERIAL_OT_copy(wmOperatorType *ot)
1717 {
1718         /* identifiers */
1719         ot->name = "Copy Material";
1720         ot->idname = "MATERIAL_OT_copy";
1721         ot->description = "Copy the material settings and nodes";
1722
1723         /* api callbacks */
1724         ot->exec = copy_material_exec;
1725
1726         /* flags */
1727         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo needed since no changes are made to the material */
1728 }
1729
1730 static int paste_material_exec(bContext *C, wmOperator *UNUSED(op))
1731 {
1732         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1733
1734         if (ma == NULL)
1735                 return OPERATOR_CANCELLED;
1736
1737         paste_matcopybuf(ma);
1738
1739         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, ma);
1740
1741         return OPERATOR_FINISHED;
1742 }
1743
1744 void MATERIAL_OT_paste(wmOperatorType *ot)
1745 {
1746         /* identifiers */
1747         ot->name = "Paste Material";
1748         ot->idname = "MATERIAL_OT_paste";
1749         ot->description = "Paste the material settings and nodes";
1750
1751         /* api callbacks */
1752         ot->exec = paste_material_exec;
1753
1754         /* flags */
1755         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1756 }
1757
1758
1759 static short mtexcopied = 0; /* must be reset on file load */
1760 static MTex mtexcopybuf;
1761
1762 void ED_render_clear_mtex_copybuf(void)
1763 {   /* use for file reload */
1764         mtexcopied = 0;
1765 }
1766
1767 static void copy_mtex_copybuf(ID *id)
1768 {
1769         MTex **mtex = NULL;
1770         
1771         switch (GS(id->name)) {
1772                 case ID_MA:
1773                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1774                         break;
1775                 case ID_LA:
1776                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1777                         // la->mtex[(int)la->texact] // TODO
1778                         break;
1779                 case ID_WO:
1780                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1781                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1782                         break;
1783                 case ID_PA:
1784                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1785                         break;
1786                 case ID_LS:
1787                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1788                         break;
1789                 default:
1790                         break;
1791         }
1792         
1793         if (mtex && *mtex) {
1794                 memcpy(&mtexcopybuf, *mtex, sizeof(MTex));
1795                 mtexcopied = 1;
1796         }
1797         else {
1798                 mtexcopied = 0;
1799         }
1800 }
1801
1802 static void paste_mtex_copybuf(ID *id)
1803 {
1804         MTex **mtex = NULL;
1805         
1806         if (mtexcopied == 0 || mtexcopybuf.tex == NULL)
1807                 return;
1808         
1809         switch (GS(id->name)) {
1810                 case ID_MA:
1811                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1812                         break;
1813                 case ID_LA:
1814                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1815                         // la->mtex[(int)la->texact] // TODO
1816                         break;
1817                 case ID_WO:
1818                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1819                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1820                         break;
1821                 case ID_PA:
1822                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1823                         break;
1824                 case ID_LS:
1825                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1826                         break;
1827                 default:
1828                         BLI_assert(!"invalid id type");
1829                         return;
1830         }
1831         
1832         if (mtex) {
1833                 if (*mtex == NULL) {
1834                         *mtex = MEM_mallocN(sizeof(MTex), "mtex copy");
1835                 }
1836                 else if ((*mtex)->tex) {
1837                         id_us_min(&(*mtex)->tex->id);
1838                 }
1839                 
1840                 memcpy(*mtex, &mtexcopybuf, sizeof(MTex));
1841                 
1842                 id_us_plus((ID *)mtexcopybuf.tex);
1843         }
1844 }
1845
1846
1847 static int copy_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1848 {
1849         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1850
1851         if (id == NULL) {
1852                 /* copying empty slot */
1853                 ED_render_clear_mtex_copybuf();
1854                 return OPERATOR_CANCELLED;
1855         }
1856
1857         copy_mtex_copybuf(id);
1858
1859         return OPERATOR_FINISHED;
1860 }
1861
1862 static int copy_mtex_poll(bContext *C)
1863 {
1864         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1865         
1866         return (id != NULL);
1867 }
1868
1869 void TEXTURE_OT_slot_copy(wmOperatorType *ot)
1870 {
1871         /* identifiers */
1872         ot->name = "Copy Texture Slot Settings";
1873         ot->idname = "TEXTURE_OT_slot_copy";
1874         ot->description = "Copy the material texture settings and nodes";
1875
1876         /* api callbacks */
1877         ot->exec = copy_mtex_exec;
1878         ot->poll = copy_mtex_poll;
1879         
1880         /* flags */
1881         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo needed since no changes are made to the mtex */
1882 }
1883
1884 static int paste_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1885 {
1886         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1887
1888         if (id == NULL) {
1889                 Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1890                 Lamp *la = CTX_data_pointer_get_type(C, "lamp", &RNA_Lamp).data;
1891                 World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
1892                 ParticleSystem *psys = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1893                 FreestyleLineStyle *linestyle = CTX_data_pointer_get_type(C, "line_style", &RNA_FreestyleLineStyle).data;
1894
1895                 if (ma)
1896                         id = &ma->id;
1897                 else if (la)
1898                         id = &la->id;
1899                 else if (wo)
1900                         id = &wo->id;
1901                 else if (psys)
1902                         id = &psys->part->id;
1903                 else if (linestyle)
1904                         id = &linestyle->id;
1905                 
1906                 if (id == NULL)
1907                         return OPERATOR_CANCELLED;
1908         }
1909
1910         paste_mtex_copybuf(id);
1911
1912         WM_event_add_notifier(C, NC_TEXTURE | ND_SHADING_LINKS, NULL);
1913
1914         return OPERATOR_FINISHED;
1915 }
1916
1917 void TEXTURE_OT_slot_paste(wmOperatorType *ot)
1918 {
1919         /* identifiers */
1920         ot->name = "Paste Texture Slot Settings";
1921         ot->idname = "TEXTURE_OT_slot_paste";
1922         ot->description = "Copy the texture settings and nodes";
1923
1924         /* api callbacks */
1925         ot->exec = paste_mtex_exec;
1926
1927         /* flags */
1928         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1929 }
1930