Texture painting:
[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_blenlib.h"
45 #include "BLI_utildefines.h"
46
47 #include "BLF_translation.h"
48
49 #include "BKE_animsys.h"
50 #include "BKE_context.h"
51 #include "BKE_curve.h"
52 #include "BKE_depsgraph.h"
53 #include "BKE_font.h"
54 #include "BKE_freestyle.h"
55 #include "BKE_global.h"
56 #include "BKE_image.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 "IMB_imbuf.h"
69 #include "IMB_imbuf_types.h"
70
71 #include "GPU_material.h"
72
73 #ifdef WITH_FREESTYLE
74 #  include "FRS_freestyle.h"
75 #endif
76
77 #include "RNA_access.h"
78 #include "RNA_enum_types.h"
79
80 #include "WM_api.h"
81 #include "WM_types.h"
82
83 #include "ED_object.h"
84 #include "ED_curve.h"
85 #include "ED_mesh.h"
86 #include "ED_node.h"
87 #include "ED_render.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         object_add_material_slot(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         object_remove_material_slot(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         DAG_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 (isNurbsel(nu))
208                                                 nu->mat_nr = nu->charidx = ob->actcol - 1;
209                         }
210                 }
211                 else if (ob->type == OB_FONT) {
212                         EditFont *ef = ((Curve *)ob->data)->editfont;
213                         int i, selstart, selend;
214
215                         if (ef && BKE_vfont_select_get(ob, &selstart, &selend)) {
216                                 for (i = selstart; i <= selend; i++)
217                                         ef->textbufinfo[i].mat_nr = ob->actcol;
218                         }
219                 }
220         }
221
222         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
223         WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
224         
225         return OPERATOR_FINISHED;
226 }
227
228 void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
229 {
230         /* identifiers */
231         ot->name = "Assign Material Slot";
232         ot->idname = "OBJECT_OT_material_slot_assign";
233         ot->description = "Assign active material slot to selection";
234         
235         /* api callbacks */
236         ot->exec = material_slot_assign_exec;
237         ot->poll = ED_operator_object_active_editable;
238
239         /* flags */
240         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
241 }
242
243 static int material_slot_de_select(bContext *C, bool select)
244 {
245         Object *ob = ED_object_context(C);
246
247         if (!ob)
248                 return OPERATOR_CANCELLED;
249
250         if (ob->type == OB_MESH) {
251                 BMEditMesh *em = BKE_editmesh_from_object(ob);
252
253                 if (em) {
254                         EDBM_deselect_by_material(em, ob->actcol - 1, select);
255                 }
256         }
257         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
258                 ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
259                 Nurb *nu;
260                 BPoint *bp;
261                 BezTriple *bezt;
262                 int a;
263
264                 if (nurbs) {
265                         for (nu = nurbs->first; nu; nu = nu->next) {
266                                 if (nu->mat_nr == ob->actcol - 1) {
267                                         if (nu->bezt) {
268                                                 a = nu->pntsu;
269                                                 bezt = nu->bezt;
270                                                 while (a--) {
271                                                         if (bezt->hide == 0) {
272                                                                 if (select) {
273                                                                         bezt->f1 |= SELECT;
274                                                                         bezt->f2 |= SELECT;
275                                                                         bezt->f3 |= SELECT;
276                                                                 }
277                                                                 else {
278                                                                         bezt->f1 &= ~SELECT;
279                                                                         bezt->f2 &= ~SELECT;
280                                                                         bezt->f3 &= ~SELECT;
281                                                                 }
282                                                         }
283                                                         bezt++;
284                                                 }
285                                         }
286                                         else if (nu->bp) {
287                                                 a = nu->pntsu * nu->pntsv;
288                                                 bp = nu->bp;
289                                                 while (a--) {
290                                                         if (bp->hide == 0) {
291                                                                 if (select) bp->f1 |= SELECT;
292                                                                 else bp->f1 &= ~SELECT;
293                                                         }
294                                                         bp++;
295                                                 }
296                                         }
297                                 }
298                         }
299                 }
300         }
301
302         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
303
304         return OPERATOR_FINISHED;
305 }
306
307 static int material_slot_select_exec(bContext *C, wmOperator *UNUSED(op))
308 {
309         return material_slot_de_select(C, true);
310 }
311
312 void OBJECT_OT_material_slot_select(wmOperatorType *ot)
313 {
314         /* identifiers */
315         ot->name = "Select Material Slot";
316         ot->idname = "OBJECT_OT_material_slot_select";
317         ot->description = "Select by active material slot";
318         
319         /* api callbacks */
320         ot->exec = material_slot_select_exec;
321
322         /* flags */
323         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
324 }
325
326 static int material_slot_deselect_exec(bContext *C, wmOperator *UNUSED(op))
327 {
328         return material_slot_de_select(C, false);
329 }
330
331 void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
332 {
333         /* identifiers */
334         ot->name = "Deselect Material Slot";
335         ot->idname = "OBJECT_OT_material_slot_deselect";
336         ot->description = "Deselect by active material slot";
337         
338         /* api callbacks */
339         ot->exec = material_slot_deselect_exec;
340
341         /* flags */
342         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
343 }
344
345
346 static int material_slot_copy_exec(bContext *C, wmOperator *UNUSED(op))
347 {
348         Object *ob = ED_object_context(C);
349         Material ***matar;
350
351         if (!ob || !(matar = give_matarar(ob)))
352                 return OPERATOR_CANCELLED;
353
354         CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects)
355         {
356                 if (ob != ob_iter && give_matarar(ob_iter)) {
357                         if (ob->data != ob_iter->data)
358                                 assign_matarar(ob_iter, matar, ob->totcol);
359                         
360                         if (ob_iter->totcol == ob->totcol) {
361                                 ob_iter->actcol = ob->actcol;
362                                 DAG_id_tag_update(&ob_iter->id, OB_RECALC_DATA);
363                                 WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob_iter);
364                         }
365                 }
366         }
367         CTX_DATA_END;
368
369         return OPERATOR_FINISHED;
370 }
371
372
373 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
374 {
375         /* identifiers */
376         ot->name = "Copy Material to Others";
377         ot->idname = "OBJECT_OT_material_slot_copy";
378         ot->description = "Copies materials to other selected objects";
379
380         /* api callbacks */
381         ot->exec = material_slot_copy_exec;
382
383         /* flags */
384         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
385 }
386
387 /********************** new material operator *********************/
388
389 static int new_material_exec(bContext *C, wmOperator *UNUSED(op))
390 {
391         Scene *scene = CTX_data_scene(C);
392         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
393         Main *bmain = CTX_data_main(C);
394         PointerRNA ptr, idptr;
395         PropertyRNA *prop;
396
397         /* add or copy material */
398         if (ma) {
399                 ma = BKE_material_copy(ma);
400         }
401         else {
402                 ma = BKE_material_add(bmain, DATA_("Material"));
403
404                 if (BKE_scene_use_new_shading_nodes(scene)) {
405                         ED_node_shader_default(C, &ma->id);
406                         ma->use_nodes = true;
407                 }
408         }
409
410         /* hook into UI */
411         uiIDContextProperty(C, &ptr, &prop);
412
413         if (prop) {
414                 /* when creating new ID blocks, use is already 1, but RNA
415                  * pointer se also increases user, so this compensates it */
416                 ma->id.us--;
417
418                 RNA_id_pointer_create(&ma->id, &idptr);
419                 RNA_property_pointer_set(&ptr, prop, idptr);
420                 RNA_property_update(C, &ptr, prop);
421         }
422
423         WM_event_add_notifier(C, NC_MATERIAL | NA_ADDED, ma);
424         
425         return OPERATOR_FINISHED;
426 }
427
428 void MATERIAL_OT_new(wmOperatorType *ot)
429 {
430         /* identifiers */
431         ot->name = "New Material";
432         ot->idname = "MATERIAL_OT_new";
433         ot->description = "Add a new material";
434         
435         /* api callbacks */
436         ot->exec = new_material_exec;
437
438         /* flags */
439         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
440 }
441
442 /********************** new texture operator *********************/
443
444 static int new_texture_exec(bContext *C, wmOperator *UNUSED(op))
445 {
446         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
447         Main *bmain = CTX_data_main(C);
448         PointerRNA ptr, idptr;
449         PropertyRNA *prop;
450
451         /* add or copy texture */
452         if (tex) {
453                 tex = BKE_texture_copy(tex);
454         }
455         else {
456                 tex = add_texture(bmain, DATA_("Texture"));
457         }
458
459         /* hook into UI */
460         uiIDContextProperty(C, &ptr, &prop);
461
462         if (prop) {
463                 /* when creating new ID blocks, use is already 1, but RNA
464                  * pointer se also increases user, so this compensates it */
465                 tex->id.us--;
466
467                 if (ptr.id.data && GS(((ID *)ptr.id.data)->name) == ID_MA &&
468                     RNA_property_pointer_get(&ptr, prop).id.data == NULL)
469                 {
470                         /* In case we are assigning new texture to a material, and active slot was empty, reset 'use' flag. */
471                         Material *ma = (Material *)ptr.id.data;
472                         ma->septex &= ~(1 << ma->texact);
473                 }
474
475                 RNA_id_pointer_create(&tex->id, &idptr);
476                 RNA_property_pointer_set(&ptr, prop, idptr);
477                 RNA_property_update(C, &ptr, prop);
478         }
479
480         WM_event_add_notifier(C, NC_TEXTURE | NA_ADDED, tex);
481         
482         return OPERATOR_FINISHED;
483 }
484
485 void TEXTURE_OT_new(wmOperatorType *ot)
486 {
487         /* identifiers */
488         ot->name = "New Texture";
489         ot->idname = "TEXTURE_OT_new";
490         ot->description = "Add a new texture";
491         
492         /* api callbacks */
493         ot->exec = new_texture_exec;
494
495         /* flags */
496         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
497 }
498
499 /********************** new world operator *********************/
500
501 static int new_world_exec(bContext *C, wmOperator *UNUSED(op))
502 {
503         Scene *scene = CTX_data_scene(C);
504         World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
505         Main *bmain = CTX_data_main(C);
506         PointerRNA ptr, idptr;
507         PropertyRNA *prop;
508
509         /* add or copy world */
510         if (wo) {
511                 wo = BKE_world_copy(wo);
512         }
513         else {
514                 wo = add_world(bmain, DATA_("World"));
515
516                 if (BKE_scene_use_new_shading_nodes(scene)) {
517                         ED_node_shader_default(C, &wo->id);
518                         wo->use_nodes = true;
519                 }
520         }
521
522         /* hook into UI */
523         uiIDContextProperty(C, &ptr, &prop);
524
525         if (prop) {
526                 /* when creating new ID blocks, use is already 1, but RNA
527                  * pointer se also increases user, so this compensates it */
528                 wo->id.us--;
529
530                 RNA_id_pointer_create(&wo->id, &idptr);
531                 RNA_property_pointer_set(&ptr, prop, idptr);
532                 RNA_property_update(C, &ptr, prop);
533         }
534
535         WM_event_add_notifier(C, NC_WORLD | NA_ADDED, wo);
536         
537         return OPERATOR_FINISHED;
538 }
539
540 void WORLD_OT_new(wmOperatorType *ot)
541 {
542         /* identifiers */
543         ot->name = "New World";
544         ot->idname = "WORLD_OT_new";
545         ot->description = "Add a new world";
546         
547         /* api callbacks */
548         ot->exec = new_world_exec;
549
550         /* flags */
551         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
552 }
553
554 /********************** render layer operators *********************/
555
556 static int render_layer_add_exec(bContext *C, wmOperator *UNUSED(op))
557 {
558         Scene *scene = CTX_data_scene(C);
559
560         BKE_scene_add_render_layer(scene, NULL);
561         scene->r.actlay = BLI_countlist(&scene->r.layers) - 1;
562
563         DAG_id_tag_update(&scene->id, 0);
564         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
565         
566         return OPERATOR_FINISHED;
567 }
568
569 void SCENE_OT_render_layer_add(wmOperatorType *ot)
570 {
571         /* identifiers */
572         ot->name = "Add Render Layer";
573         ot->idname = "SCENE_OT_render_layer_add";
574         ot->description = "Add a render layer";
575         
576         /* api callbacks */
577         ot->exec = render_layer_add_exec;
578
579         /* flags */
580         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
581 }
582
583 static int render_layer_remove_exec(bContext *C, wmOperator *UNUSED(op))
584 {
585         Scene *scene = CTX_data_scene(C);
586         SceneRenderLayer *rl = BLI_findlink(&scene->r.layers, scene->r.actlay);
587
588         if (!BKE_scene_remove_render_layer(CTX_data_main(C), scene, rl))
589                 return OPERATOR_CANCELLED;
590
591         DAG_id_tag_update(&scene->id, 0);
592         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
593         
594         return OPERATOR_FINISHED;
595 }
596
597 void SCENE_OT_render_layer_remove(wmOperatorType *ot)
598 {
599         /* identifiers */
600         ot->name = "Remove Render Layer";
601         ot->idname = "SCENE_OT_render_layer_remove";
602         ot->description = "Remove the selected render layer";
603         
604         /* api callbacks */
605         ot->exec = render_layer_remove_exec;
606
607         /* flags */
608         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
609 }
610
611 #ifdef WITH_FREESTYLE
612
613 static bool freestyle_linestyle_check_report(FreestyleLineSet *lineset, ReportList *reports)
614 {
615         if (!lineset) {
616                 BKE_report(reports, RPT_ERROR, "No active lineset and associated line style to manipulate the modifier");
617                 return false;
618         }
619         if (!lineset->linestyle) {
620                 BKE_report(reports, RPT_ERROR, "The active lineset does not have a line style (indicating data corruption)");
621                 return false;
622         }
623
624         return true;
625 }
626
627 static int freestyle_active_module_poll(bContext *C)
628 {
629         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
630         FreestyleModuleConfig *module = ptr.data;
631
632         return module != NULL;
633 }
634
635 static int freestyle_module_add_exec(bContext *C, wmOperator *UNUSED(op))
636 {
637         Scene *scene = CTX_data_scene(C);
638         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
639
640         BKE_freestyle_module_add(&srl->freestyleConfig);
641
642         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
643
644         return OPERATOR_FINISHED;
645 }
646
647 void SCENE_OT_freestyle_module_add(wmOperatorType *ot)
648 {
649         /* identifiers */
650         ot->name = "Add Freestyle Module";
651         ot->idname = "SCENE_OT_freestyle_module_add";
652         ot->description = "Add a style module into the list of modules";
653
654         /* api callbacks */
655         ot->exec = freestyle_module_add_exec;
656
657         /* flags */
658         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
659 }
660
661 static int freestyle_module_remove_exec(bContext *C, wmOperator *UNUSED(op))
662 {
663         Scene *scene = CTX_data_scene(C);
664         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
665         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
666         FreestyleModuleConfig *module = ptr.data;
667
668         BKE_freestyle_module_delete(&srl->freestyleConfig, module);
669
670         DAG_id_tag_update(&scene->id, 0);
671         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
672
673         return OPERATOR_FINISHED;
674 }
675
676 void SCENE_OT_freestyle_module_remove(wmOperatorType *ot)
677 {
678         /* identifiers */
679         ot->name = "Remove Freestyle Module";
680         ot->idname = "SCENE_OT_freestyle_module_remove";
681         ot->description = "Remove the style module from the stack";
682
683         /* api callbacks */
684         ot->poll = freestyle_active_module_poll;
685         ot->exec = freestyle_module_remove_exec;
686
687         /* flags */
688         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
689 }
690
691 static int freestyle_module_move_exec(bContext *C, wmOperator *op)
692 {
693         Scene *scene = CTX_data_scene(C);
694         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
695         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
696         FreestyleModuleConfig *module = ptr.data;
697         int dir = RNA_enum_get(op->ptr, "direction");
698
699         if (dir == 1) {
700                 BKE_freestyle_module_move_up(&srl->freestyleConfig, module);
701         }
702         else {
703                 BKE_freestyle_module_move_down(&srl->freestyleConfig, module);
704         }
705         DAG_id_tag_update(&scene->id, 0);
706         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
707
708         return OPERATOR_FINISHED;
709 }
710
711 void SCENE_OT_freestyle_module_move(wmOperatorType *ot)
712 {
713         static EnumPropertyItem direction_items[] = {
714                 {1, "UP", 0, "Up", ""},
715                 {-1, "DOWN", 0, "Down", ""},
716                 {0, NULL, 0, NULL, NULL}
717         };
718
719         /* identifiers */
720         ot->name = "Move Freestyle Module";
721         ot->idname = "SCENE_OT_freestyle_module_move";
722         ot->description = "Change the position of the style module within in the list of style modules";
723
724         /* api callbacks */
725         ot->poll = freestyle_active_module_poll;
726         ot->exec = freestyle_module_move_exec;
727
728         /* flags */
729         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
730
731         /* props */
732         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction", "Direction to move, UP or DOWN");
733 }
734
735 static int freestyle_lineset_add_exec(bContext *C, wmOperator *UNUSED(op))
736 {
737         Scene *scene = CTX_data_scene(C);
738         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
739
740         BKE_freestyle_lineset_add(&srl->freestyleConfig, NULL);
741
742         DAG_id_tag_update(&scene->id, 0);
743         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
744
745         return OPERATOR_FINISHED;
746 }
747
748 void SCENE_OT_freestyle_lineset_add(wmOperatorType *ot)
749 {
750         /* identifiers */
751         ot->name = "Add Line Set";
752         ot->idname = "SCENE_OT_freestyle_lineset_add";
753         ot->description = "Add a line set into the list of line sets";
754
755         /* api callbacks */
756         ot->exec = freestyle_lineset_add_exec;
757
758         /* flags */
759         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
760 }
761
762 static int freestyle_active_lineset_poll(bContext *C)
763 {
764         Scene *scene = CTX_data_scene(C);
765         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
766
767         if (!srl) {
768                 return false;
769         }
770
771         return BKE_freestyle_lineset_get_active(&srl->freestyleConfig) != NULL;
772 }
773
774 static int freestyle_lineset_copy_exec(bContext *C, wmOperator *UNUSED(op))
775 {
776         Scene *scene = CTX_data_scene(C);
777         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
778
779         FRS_copy_active_lineset(&srl->freestyleConfig);
780
781         return OPERATOR_FINISHED;
782 }
783
784 void SCENE_OT_freestyle_lineset_copy(wmOperatorType *ot)
785 {
786         /* identifiers */
787         ot->name = "Copy Line Set";
788         ot->idname = "SCENE_OT_freestyle_lineset_copy";
789         ot->description = "Copy the active line set to a buffer";
790
791         /* api callbacks */
792         ot->exec = freestyle_lineset_copy_exec;
793         ot->poll = freestyle_active_lineset_poll;
794
795         /* flags */
796         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
797 }
798
799 static int freestyle_lineset_paste_exec(bContext *C, wmOperator *UNUSED(op))
800 {
801         Scene *scene = CTX_data_scene(C);
802         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
803
804         FRS_paste_active_lineset(&srl->freestyleConfig);
805
806         DAG_id_tag_update(&scene->id, 0);
807         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
808
809         return OPERATOR_FINISHED;
810 }
811
812 void SCENE_OT_freestyle_lineset_paste(wmOperatorType *ot)
813 {
814         /* identifiers */
815         ot->name = "Paste Line Set";
816         ot->idname = "SCENE_OT_freestyle_lineset_paste";
817         ot->description = "Paste the buffer content to the active line set";
818
819         /* api callbacks */
820         ot->exec = freestyle_lineset_paste_exec;
821         ot->poll = freestyle_active_lineset_poll;
822
823         /* flags */
824         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
825 }
826
827 static int freestyle_lineset_remove_exec(bContext *C, wmOperator *UNUSED(op))
828 {
829         Scene *scene = CTX_data_scene(C);
830         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
831
832         FRS_delete_active_lineset(&srl->freestyleConfig);
833
834         DAG_id_tag_update(&scene->id, 0);
835         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
836
837         return OPERATOR_FINISHED;
838 }
839
840 void SCENE_OT_freestyle_lineset_remove(wmOperatorType *ot)
841 {
842         /* identifiers */
843         ot->name = "Remove Line Set";
844         ot->idname = "SCENE_OT_freestyle_lineset_remove";
845         ot->description = "Remove the active line set from the list of line sets";
846
847         /* api callbacks */
848         ot->exec = freestyle_lineset_remove_exec;
849         ot->poll = freestyle_active_lineset_poll;
850
851         /* flags */
852         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
853 }
854
855 static int freestyle_lineset_move_exec(bContext *C, wmOperator *op)
856 {
857         Scene *scene = CTX_data_scene(C);
858         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
859         int dir = RNA_enum_get(op->ptr, "direction");
860
861         if (dir == 1) {
862                 FRS_move_active_lineset_up(&srl->freestyleConfig);
863         }
864         else {
865                 FRS_move_active_lineset_down(&srl->freestyleConfig);
866         }
867         DAG_id_tag_update(&scene->id, 0);
868         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
869
870         return OPERATOR_FINISHED;
871 }
872
873 void SCENE_OT_freestyle_lineset_move(wmOperatorType *ot)
874 {
875         static EnumPropertyItem direction_items[] = {
876                 {1, "UP", 0, "Up", ""},
877                 {-1, "DOWN", 0, "Down", ""},
878                 {0, NULL, 0, NULL, NULL}
879         };
880
881         /* identifiers */
882         ot->name = "Move Line Set";
883         ot->idname = "SCENE_OT_freestyle_lineset_move";
884         ot->description = "Change the position of the active line set within the list of line sets";
885
886         /* api callbacks */
887         ot->exec = freestyle_lineset_move_exec;
888         ot->poll = freestyle_active_lineset_poll;
889
890         /* flags */
891         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
892
893         /* props */
894         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction", "Direction to move, UP or DOWN");
895 }
896
897 static int freestyle_linestyle_new_exec(bContext *C, wmOperator *op)
898 {
899         Scene *scene = CTX_data_scene(C);
900         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
901         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
902
903         if (!lineset) {
904                 BKE_report(op->reports, RPT_ERROR, "No active lineset to add a new line style to");
905                 return OPERATOR_CANCELLED;
906         }
907         if (lineset->linestyle) {
908                 lineset->linestyle->id.us--;
909                 lineset->linestyle = BKE_linestyle_copy(lineset->linestyle);
910         }
911         else {
912                 lineset->linestyle = BKE_linestyle_new("LineStyle", NULL);
913         }
914         DAG_id_tag_update(&lineset->linestyle->id, 0);
915         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
916
917         return OPERATOR_FINISHED;
918 }
919
920 void SCENE_OT_freestyle_linestyle_new(wmOperatorType *ot)
921 {
922         /* identifiers */
923         ot->name = "New Line Style";
924         ot->idname = "SCENE_OT_freestyle_linestyle_new";
925         ot->description = "Create a new line style, reusable by multiple line sets";
926
927         /* api callbacks */
928         ot->exec = freestyle_linestyle_new_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_color_modifier_add_exec(bContext *C, wmOperator *op)
936 {
937         Scene *scene = CTX_data_scene(C);
938         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
939         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
940         int type = RNA_enum_get(op->ptr, "type");
941
942         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
943                 return OPERATOR_CANCELLED;
944         }
945
946         if (BKE_linestyle_color_modifier_add(lineset->linestyle, NULL, type) == NULL) {
947                 BKE_report(op->reports, RPT_ERROR, "Unknown line color modifier type");
948                 return OPERATOR_CANCELLED;
949         }
950         DAG_id_tag_update(&lineset->linestyle->id, 0);
951         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
952
953         return OPERATOR_FINISHED;
954 }
955
956 void SCENE_OT_freestyle_color_modifier_add(wmOperatorType *ot)
957 {
958         /* identifiers */
959         ot->name = "Add Line Color Modifier";
960         ot->idname = "SCENE_OT_freestyle_color_modifier_add";
961         ot->description = "Add a line color modifier to the line style associated with the active lineset";
962
963         /* api callbacks */
964         ot->invoke = WM_menu_invoke;
965         ot->exec = freestyle_color_modifier_add_exec;
966         ot->poll = freestyle_active_lineset_poll;
967
968         /* flags */
969         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
970
971         /* properties */
972         ot->prop = RNA_def_enum(ot->srna, "type", linestyle_color_modifier_type_items, 0, "Type", "");
973 }
974
975 static int freestyle_alpha_modifier_add_exec(bContext *C, wmOperator *op)
976 {
977         Scene *scene = CTX_data_scene(C);
978         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
979         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
980         int type = RNA_enum_get(op->ptr, "type");
981
982         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
983                 return OPERATOR_CANCELLED;
984         }
985
986         if (BKE_linestyle_alpha_modifier_add(lineset->linestyle, NULL, type) == NULL) {
987                 BKE_report(op->reports, RPT_ERROR, "Unknown alpha transparency modifier type");
988                 return OPERATOR_CANCELLED;
989         }
990         DAG_id_tag_update(&lineset->linestyle->id, 0);
991         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
992
993         return OPERATOR_FINISHED;
994 }
995
996 void SCENE_OT_freestyle_alpha_modifier_add(wmOperatorType *ot)
997 {
998         /* identifiers */
999         ot->name = "Add Alpha Transparency Modifier";
1000         ot->idname = "SCENE_OT_freestyle_alpha_modifier_add";
1001         ot->description = "Add an alpha transparency modifier to the line style associated with the active lineset";
1002
1003         /* api callbacks */
1004         ot->invoke = WM_menu_invoke;
1005         ot->exec = freestyle_alpha_modifier_add_exec;
1006         ot->poll = freestyle_active_lineset_poll;
1007
1008         /* flags */
1009         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1010
1011         /* properties */
1012         ot->prop = RNA_def_enum(ot->srna, "type", linestyle_alpha_modifier_type_items, 0, "Type", "");
1013 }
1014
1015 static int freestyle_thickness_modifier_add_exec(bContext *C, wmOperator *op)
1016 {
1017         Scene *scene = CTX_data_scene(C);
1018         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1019         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1020         int type = RNA_enum_get(op->ptr, "type");
1021
1022         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1023                 return OPERATOR_CANCELLED;
1024         }
1025
1026         if (BKE_linestyle_thickness_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1027                 BKE_report(op->reports, RPT_ERROR, "Unknown line thickness modifier type");
1028                 return OPERATOR_CANCELLED;
1029         }
1030         DAG_id_tag_update(&lineset->linestyle->id, 0);
1031         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1032
1033         return OPERATOR_FINISHED;
1034 }
1035
1036 void SCENE_OT_freestyle_thickness_modifier_add(wmOperatorType *ot)
1037 {
1038         /* identifiers */
1039         ot->name = "Add Line Thickness Modifier";
1040         ot->idname = "SCENE_OT_freestyle_thickness_modifier_add";
1041         ot->description = "Add a line thickness modifier to the line style associated with the active lineset";
1042
1043         /* api callbacks */
1044         ot->invoke = WM_menu_invoke;
1045         ot->exec = freestyle_thickness_modifier_add_exec;
1046         ot->poll = freestyle_active_lineset_poll;
1047
1048         /* flags */
1049         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1050
1051         /* properties */
1052         ot->prop = RNA_def_enum(ot->srna, "type", linestyle_thickness_modifier_type_items, 0, "Type", "");
1053 }
1054
1055 static int freestyle_geometry_modifier_add_exec(bContext *C, wmOperator *op)
1056 {
1057         Scene *scene = CTX_data_scene(C);
1058         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1059         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1060         int type = RNA_enum_get(op->ptr, "type");
1061
1062         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1063                 return OPERATOR_CANCELLED;
1064         }
1065
1066         if (BKE_linestyle_geometry_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1067                 BKE_report(op->reports, RPT_ERROR, "Unknown stroke geometry modifier type");
1068                 return OPERATOR_CANCELLED;
1069         }
1070         DAG_id_tag_update(&lineset->linestyle->id, 0);
1071         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1072
1073         return OPERATOR_FINISHED;
1074 }
1075
1076 void SCENE_OT_freestyle_geometry_modifier_add(wmOperatorType *ot)
1077 {
1078         /* identifiers */
1079         ot->name = "Add Stroke Geometry Modifier";
1080         ot->idname = "SCENE_OT_freestyle_geometry_modifier_add";
1081         ot->description = "Add a stroke geometry modifier to the line style associated with the active lineset";
1082
1083         /* api callbacks */
1084         ot->invoke = WM_menu_invoke;
1085         ot->exec = freestyle_geometry_modifier_add_exec;
1086         ot->poll = freestyle_active_lineset_poll;
1087
1088         /* flags */
1089         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1090
1091         /* properties */
1092         ot->prop = RNA_def_enum(ot->srna, "type", linestyle_geometry_modifier_type_items, 0, "Type", "");
1093 }
1094
1095 static int freestyle_get_modifier_type(PointerRNA *ptr)
1096 {
1097         if (RNA_struct_is_a(ptr->type, &RNA_LineStyleColorModifier))
1098                 return LS_MODIFIER_TYPE_COLOR;
1099         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleAlphaModifier))
1100                 return LS_MODIFIER_TYPE_ALPHA;
1101         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleThicknessModifier))
1102                 return LS_MODIFIER_TYPE_THICKNESS;
1103         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleGeometryModifier))
1104                 return LS_MODIFIER_TYPE_GEOMETRY;
1105         return -1;
1106 }
1107
1108 static int freestyle_modifier_remove_exec(bContext *C, wmOperator *op)
1109 {
1110         Scene *scene = CTX_data_scene(C);
1111         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1112         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1113         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1114         LineStyleModifier *modifier = ptr.data;
1115
1116         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1117                 return OPERATOR_CANCELLED;
1118         }
1119
1120         switch (freestyle_get_modifier_type(&ptr)) {
1121                 case LS_MODIFIER_TYPE_COLOR:
1122                         BKE_linestyle_color_modifier_remove(lineset->linestyle, modifier);
1123                         break;
1124                 case LS_MODIFIER_TYPE_ALPHA:
1125                         BKE_linestyle_alpha_modifier_remove(lineset->linestyle, modifier);
1126                         break;
1127                 case LS_MODIFIER_TYPE_THICKNESS:
1128                         BKE_linestyle_thickness_modifier_remove(lineset->linestyle, modifier);
1129                         break;
1130                 case LS_MODIFIER_TYPE_GEOMETRY:
1131                         BKE_linestyle_geometry_modifier_remove(lineset->linestyle, modifier);
1132                         break;
1133                 default:
1134                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1135                         return OPERATOR_CANCELLED;
1136         }
1137         DAG_id_tag_update(&lineset->linestyle->id, 0);
1138         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1139
1140         return OPERATOR_FINISHED;
1141 }
1142
1143 void SCENE_OT_freestyle_modifier_remove(wmOperatorType *ot)
1144 {
1145         /* identifiers */
1146         ot->name = "Remove Modifier";
1147         ot->idname = "SCENE_OT_freestyle_modifier_remove";
1148         ot->description = "Remove the modifier from the list of modifiers";
1149
1150         /* api callbacks */
1151         ot->exec = freestyle_modifier_remove_exec;
1152         ot->poll = freestyle_active_lineset_poll;
1153
1154         /* flags */
1155         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1156 }
1157
1158 static int freestyle_modifier_copy_exec(bContext *C, wmOperator *op)
1159 {
1160         Scene *scene = CTX_data_scene(C);
1161         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1162         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1163         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1164         LineStyleModifier *modifier = ptr.data;
1165
1166         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1167                 return OPERATOR_CANCELLED;
1168         }
1169
1170         switch (freestyle_get_modifier_type(&ptr)) {
1171                 case LS_MODIFIER_TYPE_COLOR:
1172                         BKE_linestyle_color_modifier_copy(lineset->linestyle, modifier);
1173                         break;
1174                 case LS_MODIFIER_TYPE_ALPHA:
1175                         BKE_linestyle_alpha_modifier_copy(lineset->linestyle, modifier);
1176                         break;
1177                 case LS_MODIFIER_TYPE_THICKNESS:
1178                         BKE_linestyle_thickness_modifier_copy(lineset->linestyle, modifier);
1179                         break;
1180                 case LS_MODIFIER_TYPE_GEOMETRY:
1181                         BKE_linestyle_geometry_modifier_copy(lineset->linestyle, modifier);
1182                         break;
1183                 default:
1184                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1185                         return OPERATOR_CANCELLED;
1186         }
1187         DAG_id_tag_update(&lineset->linestyle->id, 0);
1188         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1189
1190         return OPERATOR_FINISHED;
1191 }
1192
1193 void SCENE_OT_freestyle_modifier_copy(wmOperatorType *ot)
1194 {
1195         /* identifiers */
1196         ot->name = "Copy Modifier";
1197         ot->idname = "SCENE_OT_freestyle_modifier_copy";
1198         ot->description = "Duplicate the modifier within the list of modifiers";
1199
1200         /* api callbacks */
1201         ot->exec = freestyle_modifier_copy_exec;
1202         ot->poll = freestyle_active_lineset_poll;
1203
1204         /* flags */
1205         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1206 }
1207
1208 static int freestyle_modifier_move_exec(bContext *C, wmOperator *op)
1209 {
1210         Scene *scene = CTX_data_scene(C);
1211         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1212         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1213         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1214         LineStyleModifier *modifier = ptr.data;
1215         int dir = RNA_enum_get(op->ptr, "direction");
1216
1217         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1218                 return OPERATOR_CANCELLED;
1219         }
1220
1221         switch (freestyle_get_modifier_type(&ptr)) {
1222                 case LS_MODIFIER_TYPE_COLOR:
1223                         BKE_linestyle_color_modifier_move(lineset->linestyle, modifier, dir);
1224                         break;
1225                 case LS_MODIFIER_TYPE_ALPHA:
1226                         BKE_linestyle_alpha_modifier_move(lineset->linestyle, modifier, dir);
1227                         break;
1228                 case LS_MODIFIER_TYPE_THICKNESS:
1229                         BKE_linestyle_thickness_modifier_move(lineset->linestyle, modifier, dir);
1230                         break;
1231                 case LS_MODIFIER_TYPE_GEOMETRY:
1232                         BKE_linestyle_geometry_modifier_move(lineset->linestyle, modifier, dir);
1233                         break;
1234                 default:
1235                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1236                         return OPERATOR_CANCELLED;
1237         }
1238         DAG_id_tag_update(&lineset->linestyle->id, 0);
1239         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1240
1241         return OPERATOR_FINISHED;
1242 }
1243
1244 void SCENE_OT_freestyle_modifier_move(wmOperatorType *ot)
1245 {
1246         static EnumPropertyItem direction_items[] = {
1247                 {1, "UP", 0, "Up", ""},
1248                 {-1, "DOWN", 0, "Down", ""},
1249                 {0, NULL, 0, NULL, NULL}
1250         };
1251
1252         /* identifiers */
1253         ot->name = "Move Modifier";
1254         ot->idname = "SCENE_OT_freestyle_modifier_move";
1255         ot->description = "Move the modifier within the list of modifiers";
1256
1257         /* api callbacks */
1258         ot->exec = freestyle_modifier_move_exec;
1259         ot->poll = freestyle_active_lineset_poll;
1260
1261         /* flags */
1262         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1263
1264         /* props */
1265         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction", "Direction to move, UP or DOWN");
1266 }
1267
1268 static int freestyle_stroke_material_create_exec(bContext *C, wmOperator *op)
1269 {
1270         Main *bmain = CTX_data_main(C);
1271         Scene *scene = CTX_data_scene(C);
1272         FreestyleLineStyle *linestyle = BKE_linestyle_active_from_scene(scene);
1273
1274         if (!linestyle) {
1275                 BKE_report(op->reports, RPT_ERROR, "No active line style in the current scene");
1276                 return OPERATOR_CANCELLED;
1277         }
1278
1279         FRS_create_stroke_material(bmain, linestyle);
1280
1281         return OPERATOR_FINISHED;
1282 }
1283
1284 void SCENE_OT_freestyle_stroke_material_create(wmOperatorType *ot)
1285 {
1286         /* identifiers */
1287         ot->name = "Create Freestyle Stroke Material";
1288         ot->idname = "SCENE_OT_freestyle_stroke_material_create";
1289         ot->description = "Create Freestyle stroke material for testing";
1290
1291         /* api callbacks */
1292         ot->exec = freestyle_stroke_material_create_exec;
1293
1294         /* flags */
1295         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1296 }
1297
1298 #endif /* WITH_FREESTYLE */
1299
1300 static int texture_slot_move_exec(bContext *C, wmOperator *op)
1301 {
1302         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1303
1304         if (id) {
1305                 MTex **mtex_ar, *mtexswap;
1306                 short act;
1307                 int type = RNA_enum_get(op->ptr, "type");
1308                 struct AnimData *adt = BKE_animdata_from_id(id);
1309
1310                 give_active_mtex(id, &mtex_ar, &act);
1311
1312                 if (type == -1) { /* Up */
1313                         if (act > 0) {
1314                                 mtexswap = mtex_ar[act];
1315                                 mtex_ar[act] = mtex_ar[act - 1];
1316                                 mtex_ar[act - 1] = mtexswap;
1317                                 
1318                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act - 1, -1, 0);
1319                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act - 1, 0);
1320                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1321
1322                                 if (GS(id->name) == ID_MA) {
1323                                         Material *ma = (Material *)id;
1324                                         int mtexuse = ma->septex & (1 << act);
1325                                         ma->septex &= ~(1 << act);
1326                                         ma->septex |= (ma->septex & (1 << (act - 1))) << 1;
1327                                         ma->septex &= ~(1 << (act - 1));
1328                                         ma->septex |= mtexuse >> 1;
1329                                 }
1330                                 
1331                                 set_active_mtex(id, act - 1);
1332                         }
1333                 }
1334                 else { /* Down */
1335                         if (act < MAX_MTEX - 1) {
1336                                 mtexswap = mtex_ar[act];
1337                                 mtex_ar[act] = mtex_ar[act + 1];
1338                                 mtex_ar[act + 1] = mtexswap;
1339                                 
1340                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act + 1, -1, 0);
1341                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act + 1, 0);
1342                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1343
1344                                 if (GS(id->name) == ID_MA) {
1345                                         Material *ma = (Material *)id;
1346                                         int mtexuse = ma->septex & (1 << act);
1347                                         ma->septex &= ~(1 << act);
1348                                         ma->septex |= (ma->septex & (1 << (act + 1))) >> 1;
1349                                         ma->septex &= ~(1 << (act + 1));
1350                                         ma->septex |= mtexuse << 1;
1351                                 }
1352                                 
1353                                 set_active_mtex(id, act + 1);
1354                         }
1355                 }
1356
1357                 DAG_id_tag_update(id, 0);
1358                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
1359         }
1360
1361         return OPERATOR_FINISHED;
1362 }
1363
1364 void TEXTURE_OT_slot_move(wmOperatorType *ot)
1365 {
1366         static EnumPropertyItem slot_move[] = {
1367                 {-1, "UP", 0, "Up", ""},
1368                 {1, "DOWN", 0, "Down", ""},
1369                 {0, NULL, 0, NULL, NULL}
1370         };
1371
1372         /* identifiers */
1373         ot->name = "Move Texture Slot";
1374         ot->idname = "TEXTURE_OT_slot_move";
1375         ot->description = "Move texture slots up and down";
1376
1377         /* api callbacks */
1378         ot->exec = texture_slot_move_exec;
1379
1380         /* flags */
1381         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1382
1383         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
1384 }
1385
1386
1387
1388 /********************** environment map operators *********************/
1389
1390 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *path, const char imtype)
1391 {
1392         float layout[12];
1393         if (RNA_struct_find_property(op->ptr, "layout") )
1394                 RNA_float_get_array(op->ptr, "layout", layout);
1395         else
1396                 memcpy(layout, default_envmap_layout, sizeof(layout));
1397
1398         if (RE_WriteEnvmapResult(op->reports, scene, env, path, imtype, layout)) {
1399                 return OPERATOR_FINISHED;
1400         }
1401         else {
1402                 return OPERATOR_CANCELLED;
1403         }
1404
1405 }
1406
1407 static int envmap_save_exec(bContext *C, wmOperator *op)
1408 {
1409         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1410         Scene *scene = CTX_data_scene(C);
1411         //int imtype = RNA_enum_get(op->ptr, "file_type");
1412         char imtype = scene->r.im_format.imtype;
1413         char path[FILE_MAX];
1414         
1415         RNA_string_get(op->ptr, "filepath", path);
1416         
1417         if (scene->r.scemode & R_EXTENSION) {
1418                 BKE_add_image_extension(path, &scene->r.im_format);
1419         }
1420         
1421         WM_cursor_wait(1);
1422         
1423         save_envmap(op, scene, tex->env, path, imtype);
1424         
1425         WM_cursor_wait(0);
1426         
1427         WM_event_add_notifier(C, NC_TEXTURE, tex);
1428         
1429         return OPERATOR_FINISHED;
1430 }
1431
1432 static int envmap_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1433 {
1434         //Scene *scene= CTX_data_scene(C);
1435         
1436         if (RNA_struct_property_is_set(op->ptr, "filepath"))
1437                 return envmap_save_exec(C, op);
1438
1439         //RNA_enum_set(op->ptr, "file_type", scene->r.im_format.imtype);
1440         RNA_string_set(op->ptr, "filepath", G.main->name);
1441         WM_event_add_fileselect(C, op);
1442         
1443         return OPERATOR_RUNNING_MODAL;
1444 }
1445
1446 static int envmap_save_poll(bContext *C)
1447 {
1448         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1449
1450         if (!tex) 
1451                 return 0;
1452         if (!tex->env || !tex->env->ok)
1453                 return 0;
1454         if (tex->env->cube[1] == NULL)
1455                 return 0;
1456         
1457         return 1;
1458 }
1459
1460 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
1461 {
1462         PropertyRNA *prop;
1463         /* identifiers */
1464         ot->name = "Save Environment Map";
1465         ot->idname = "TEXTURE_OT_envmap_save";
1466         ot->description = "Save the current generated Environment map to an image file";
1467         
1468         /* api callbacks */
1469         ot->exec = envmap_save_exec;
1470         ot->invoke = envmap_save_invoke;
1471         ot->poll = envmap_save_poll;
1472         
1473         /* flags */
1474         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo since this doesnt modify the env-map */
1475         
1476         /* properties */
1477         prop = RNA_def_float_array(ot->srna, "layout", 12, default_envmap_layout, 0.0f, 0.0f,
1478                                    "File layout",
1479                                    "Flat array describing the X,Y position of each cube face in the output image, "
1480                                    "where 1 is the size of a face - order is [+Z -Z +Y -X -Y +X] "
1481                                    "(use -1 to skip a face)", 0.0f, 0.0f);
1482         RNA_def_property_flag(prop, PROP_HIDDEN);
1483
1484         WM_operator_properties_filesel(ot, FOLDERFILE | IMAGEFILE | MOVIEFILE, FILE_SPECIAL, FILE_SAVE,
1485                                        WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY);
1486 }
1487
1488 static int envmap_clear_exec(bContext *C, wmOperator *UNUSED(op))
1489 {
1490         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1491         
1492         BKE_free_envmapdata(tex->env);
1493         
1494         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1495         
1496         return OPERATOR_FINISHED;
1497 }
1498
1499 static int envmap_clear_poll(bContext *C)
1500 {
1501         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1502         
1503         if (!tex) 
1504                 return 0;
1505         if (!tex->env || !tex->env->ok)
1506                 return 0;
1507         if (tex->env->cube[1] == NULL)
1508                 return 0;
1509         
1510         return 1;
1511 }
1512
1513 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
1514 {
1515         /* identifiers */
1516         ot->name = "Clear Environment Map";
1517         ot->idname = "TEXTURE_OT_envmap_clear";
1518         ot->description = "Discard the environment map and free it from memory";
1519         
1520         /* api callbacks */
1521         ot->exec = envmap_clear_exec;
1522         ot->poll = envmap_clear_poll;
1523         
1524         /* flags */
1525         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1526 }
1527
1528 static int envmap_clear_all_exec(bContext *C, wmOperator *UNUSED(op))
1529 {
1530         Main *bmain = CTX_data_main(C);
1531         Tex *tex;
1532         
1533         for (tex = bmain->tex.first; tex; tex = tex->id.next)
1534                 if (tex->env)
1535                         BKE_free_envmapdata(tex->env);
1536         
1537         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1538         
1539         return OPERATOR_FINISHED;
1540 }
1541
1542 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
1543 {
1544         /* identifiers */
1545         ot->name = "Clear All Environment Maps";
1546         ot->idname = "TEXTURE_OT_envmap_clear_all";
1547         ot->description = "Discard all environment maps in the .blend file and free them from memory";
1548         
1549         /* api callbacks */
1550         ot->exec = envmap_clear_all_exec;
1551         ot->poll = envmap_clear_poll;
1552         
1553         /* flags */
1554         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1555 }
1556
1557 /********************** material operators *********************/
1558
1559 /* material copy/paste */
1560 static int copy_material_exec(bContext *C, wmOperator *UNUSED(op))
1561 {
1562         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1563
1564         if (ma == NULL)
1565                 return OPERATOR_CANCELLED;
1566
1567         copy_matcopybuf(ma);
1568
1569         return OPERATOR_FINISHED;
1570 }
1571
1572 void MATERIAL_OT_copy(wmOperatorType *ot)
1573 {
1574         /* identifiers */
1575         ot->name = "Copy Material";
1576         ot->idname = "MATERIAL_OT_copy";
1577         ot->description = "Copy the material settings and nodes";
1578
1579         /* api callbacks */
1580         ot->exec = copy_material_exec;
1581
1582         /* flags */
1583         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo needed since no changes are made to the material */
1584 }
1585
1586 static int paste_material_exec(bContext *C, wmOperator *UNUSED(op))
1587 {
1588         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1589
1590         if (ma == NULL)
1591                 return OPERATOR_CANCELLED;
1592
1593         paste_matcopybuf(ma);
1594
1595         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, ma);
1596
1597         return OPERATOR_FINISHED;
1598 }
1599
1600 void MATERIAL_OT_paste(wmOperatorType *ot)
1601 {
1602         /* identifiers */
1603         ot->name = "Paste Material";
1604         ot->idname = "MATERIAL_OT_paste";
1605         ot->description = "Paste the material settings and nodes";
1606
1607         /* api callbacks */
1608         ot->exec = paste_material_exec;
1609
1610         /* flags */
1611         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1612 }
1613
1614
1615 static short mtexcopied = 0; /* must be reset on file load */
1616 static MTex mtexcopybuf;
1617
1618 void ED_render_clear_mtex_copybuf(void)
1619 {   /* use for file reload */
1620         mtexcopied = 0;
1621 }
1622
1623 static void copy_mtex_copybuf(ID *id)
1624 {
1625         MTex **mtex = NULL;
1626         
1627         switch (GS(id->name)) {
1628                 case ID_MA:
1629                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1630                         break;
1631                 case ID_LA:
1632                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1633                         // la->mtex[(int)la->texact] // TODO
1634                         break;
1635                 case ID_WO:
1636                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1637                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1638                         break;
1639                 case ID_PA:
1640                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1641                         break;
1642                 case ID_LS:
1643                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1644                         break;
1645         }
1646         
1647         if (mtex && *mtex) {
1648                 memcpy(&mtexcopybuf, *mtex, sizeof(MTex));
1649                 mtexcopied = 1;
1650         }
1651         else {
1652                 mtexcopied = 0;
1653         }
1654 }
1655
1656 static void paste_mtex_copybuf(ID *id)
1657 {
1658         MTex **mtex = NULL;
1659         
1660         if (mtexcopied == 0 || mtexcopybuf.tex == NULL)
1661                 return;
1662         
1663         switch (GS(id->name)) {
1664                 case ID_MA:
1665                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1666                         break;
1667                 case ID_LA:
1668                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1669                         // la->mtex[(int)la->texact] // TODO
1670                         break;
1671                 case ID_WO:
1672                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1673                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1674                         break;
1675                 case ID_PA:
1676                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1677                         break;
1678                 case ID_LS:
1679                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1680                         break;
1681                 default:
1682                         BLI_assert("invalid id type");
1683                         return;
1684         }
1685         
1686         if (mtex) {
1687                 if (*mtex == NULL) {
1688                         *mtex = MEM_mallocN(sizeof(MTex), "mtex copy");
1689                 }
1690                 else if ((*mtex)->tex) {
1691                         (*mtex)->tex->id.us--;
1692                 }
1693                 
1694                 memcpy(*mtex, &mtexcopybuf, sizeof(MTex));
1695                 
1696                 id_us_plus((ID *)mtexcopybuf.tex);
1697         }
1698 }
1699
1700
1701 static int copy_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1702 {
1703         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1704
1705         if (id == NULL) {
1706                 /* copying empty slot */
1707                 ED_render_clear_mtex_copybuf();
1708                 return OPERATOR_CANCELLED;
1709         }
1710
1711         copy_mtex_copybuf(id);
1712
1713         return OPERATOR_FINISHED;
1714 }
1715
1716 static int copy_mtex_poll(bContext *C)
1717 {
1718         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1719         
1720         return (id != NULL);
1721 }
1722
1723 void TEXTURE_OT_slot_copy(wmOperatorType *ot)
1724 {
1725         /* identifiers */
1726         ot->name = "Copy Texture Slot Settings";
1727         ot->idname = "TEXTURE_OT_slot_copy";
1728         ot->description = "Copy the material texture settings and nodes";
1729
1730         /* api callbacks */
1731         ot->exec = copy_mtex_exec;
1732         ot->poll = copy_mtex_poll;
1733         
1734         /* flags */
1735         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo needed since no changes are made to the mtex */
1736 }
1737
1738 static int paste_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1739 {
1740         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1741
1742         if (id == NULL) {
1743                 Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1744                 Lamp *la = CTX_data_pointer_get_type(C, "lamp", &RNA_Lamp).data;
1745                 World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
1746                 ParticleSystem *psys = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1747                 FreestyleLineStyle *linestyle = CTX_data_pointer_get_type(C, "line_style", &RNA_FreestyleLineStyle).data;
1748
1749                 if (ma)
1750                         id = &ma->id;
1751                 else if (la)
1752                         id = &la->id;
1753                 else if (wo)
1754                         id = &wo->id;
1755                 else if (psys)
1756                         id = &psys->part->id;
1757                 else if (linestyle)
1758                         id = &linestyle->id;
1759                 
1760                 if (id == NULL)
1761                         return OPERATOR_CANCELLED;
1762         }
1763
1764         paste_mtex_copybuf(id);
1765
1766         WM_event_add_notifier(C, NC_TEXTURE | ND_SHADING_LINKS, NULL);
1767
1768         return OPERATOR_FINISHED;
1769 }
1770
1771 void TEXTURE_OT_slot_paste(wmOperatorType *ot)
1772 {
1773         /* identifiers */
1774         ot->name = "Paste Texture Slot Settings";
1775         ot->idname = "TEXTURE_OT_slot_paste";
1776         ot->description = "Copy the texture settings and nodes";
1777
1778         /* api callbacks */
1779         ot->exec = paste_mtex_exec;
1780
1781         /* flags */
1782         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1783 }
1784