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