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