Merged changes in the trunk up to revision 27647.
[blender.git] / source / blender / editors / render / render_shading.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  * The Original Code is Copyright (C) 2009 Blender Foundation.
20  * All rights reserved.
21  *
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_curve_types.h"
33 #include "DNA_lamp_types.h"
34 #include "DNA_material_types.h"
35 #include "DNA_meshdata_types.h"
36 #include "DNA_node_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_texture_types.h"
39 #include "DNA_scene_types.h"
40 #include "DNA_space_types.h"
41 #include "DNA_world_types.h"
42
43 #include "BKE_animsys.h"
44 #include "BKE_context.h"
45 #include "BKE_depsgraph.h"
46 #include "BKE_font.h"
47 #include "BKE_global.h"
48 #include "BKE_icons.h"
49 #include "BKE_image.h"
50 #include "BKE_library.h"
51 #include "BKE_main.h"
52 #include "BKE_material.h"
53 #include "BKE_node.h"
54 #include "BKE_report.h"
55 #include "BKE_scene.h"
56 #include "BKE_texture.h"
57 #include "BKE_utildefines.h"
58 #include "BKE_world.h"
59
60 #include "IMB_imbuf.h"
61 #include "IMB_imbuf_types.h"
62
63 #include "BLI_blenlib.h"
64 #include "BLI_math.h"
65 #include "BLI_editVert.h"
66 #include "BLI_listbase.h"
67
68 #include "GPU_material.h"
69
70 #include "FRS_freestyle.h"
71
72 #include "RNA_access.h"
73 #include "RNA_enum_types.h"
74
75 #include "WM_api.h"
76 #include "WM_types.h"
77
78 #include "ED_curve.h"
79 #include "ED_mesh.h"
80 #include "ED_render.h"
81
82 #include "RNA_access.h"
83 #include "RNA_define.h"
84
85 #include "UI_interface.h"
86 #include "UI_resources.h"
87
88 #include "render_intern.h"      // own include
89
90 /***************************** Updates ***********************************
91  * ED_render_id_flush_update gets called from DAG_id_flush_update, to do *
92  * editor level updates when the ID changes. when these ID blocks are in *
93  * the dependency graph, we can get rid of the manual dependency checks  */
94
95 static int mtex_use_tex(MTex **mtex, int tot, Tex *tex)
96 {
97         int a;
98
99         if(!mtex)
100                 return 0;
101
102         for(a=0; a<tot; a++)
103                 if(mtex[a] && mtex[a]->tex == tex)
104                         return 1;
105         
106         return 0;
107 }
108
109 static int nodes_use_tex(bNodeTree *ntree, Tex *tex)
110 {
111         bNode *node;
112
113         for(node=ntree->nodes.first; node; node= node->next) {
114                 if(node->id) {
115                         if(node->id == (ID*)tex) {
116                                 return 1;
117                         }
118                         else if(node->type==NODE_GROUP) {
119                                 if(nodes_use_tex((bNodeTree *)node->id, tex))
120                                         return 1;
121                         }
122                 }
123         }
124
125         return 0;
126 }
127
128 static void material_changed(Main *bmain, Material *ma)
129 {
130         /* icons */
131         BKE_icon_changed(BKE_icon_getid(&ma->id));
132
133         /* glsl */
134         if(ma->gpumaterial.first)
135                 GPU_material_free(ma);
136 }
137
138 static void texture_changed(Main *bmain, Tex *tex)
139 {
140         Material *ma;
141         Lamp *la;
142         World *wo;
143
144         /* icons */
145         BKE_icon_changed(BKE_icon_getid(&tex->id));
146
147         /* find materials */
148         for(ma=bmain->mat.first; ma; ma=ma->id.next) {
149                 if(mtex_use_tex(ma->mtex, MAX_MTEX, tex));
150                 else if(ma->use_nodes && ma->nodetree && nodes_use_tex(ma->nodetree, tex));
151                 else continue;
152
153                 BKE_icon_changed(BKE_icon_getid(&ma->id));
154
155                 if(ma->gpumaterial.first)
156                         GPU_material_free(ma);
157         }
158
159         /* find lamps */
160         for(la=bmain->lamp.first; la; la=la->id.next) {
161                 if(mtex_use_tex(la->mtex, MAX_MTEX, tex));
162                 else continue;
163
164                 BKE_icon_changed(BKE_icon_getid(&la->id));
165         }
166
167         /* find worlds */
168         for(wo=bmain->world.first; wo; wo=wo->id.next) {
169                 if(mtex_use_tex(wo->mtex, MAX_MTEX, tex));
170                 else continue;
171
172                 BKE_icon_changed(BKE_icon_getid(&wo->id));
173         }
174 }
175
176 static void lamp_changed(Main *bmain, Lamp *la)
177 {
178         Object *ob;
179         Material *ma;
180
181         /* icons */
182         BKE_icon_changed(BKE_icon_getid(&la->id));
183
184         /* glsl */
185         for(ob=bmain->object.first; ob; ob=ob->id.next)
186                 if(ob->data == la && ob->gpulamp.first)
187                         GPU_lamp_free(ob);
188
189         for(ma=bmain->mat.first; ma; ma=ma->id.next)
190                 if(ma->gpumaterial.first)
191                         GPU_material_free(ma);
192 }
193
194 static void world_changed(Main *bmain, World *wo)
195 {
196         Material *ma;
197
198         /* icons */
199         BKE_icon_changed(BKE_icon_getid(&wo->id));
200
201         /* glsl */
202         for(ma=bmain->mat.first; ma; ma=ma->id.next)
203                 if(ma->gpumaterial.first)
204                         GPU_material_free(ma);
205 }
206
207 void ED_render_id_flush_update(Main *bmain, ID *id)
208 {
209         if(!id)
210                 return;
211
212         switch(GS(id->name)) {
213                 case ID_MA:
214                         material_changed(bmain, (Material*)id);
215                         break;
216                 case ID_TE:
217                         texture_changed(bmain, (Tex*)id);
218                         break;
219                 case ID_WO:
220                         world_changed(bmain, (World*)id);
221                         break;
222                 case ID_LA:
223                         lamp_changed(bmain, (Lamp*)id);
224                         break;
225                 default:
226                         break;
227         }
228 }
229
230 /********************** material slot operators *********************/
231
232 static int material_slot_add_exec(bContext *C, wmOperator *op)
233 {
234         Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
235
236         if(!ob)
237                 return OPERATOR_CANCELLED;
238
239         object_add_material_slot(ob);
240         WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
241         
242         return OPERATOR_FINISHED;
243 }
244
245 void OBJECT_OT_material_slot_add(wmOperatorType *ot)
246 {
247         /* identifiers */
248         ot->name= "Add Material Slot";
249         ot->idname= "OBJECT_OT_material_slot_add";
250         ot->description="Add a new material slot or duplicate the selected one";
251         
252         /* api callbacks */
253         ot->exec= material_slot_add_exec;
254
255         /* flags */
256         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
257 }
258
259 static int material_slot_remove_exec(bContext *C, wmOperator *op)
260 {
261         Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
262
263         if(!ob)
264                 return OPERATOR_CANCELLED;
265
266         object_remove_material_slot(ob);
267         WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);
268         
269         return OPERATOR_FINISHED;
270 }
271
272 void OBJECT_OT_material_slot_remove(wmOperatorType *ot)
273 {
274         /* identifiers */
275         ot->name= "Remove Material Slot";
276         ot->idname= "OBJECT_OT_material_slot_remove";
277         ot->description="Remove the selected material slot";
278         
279         /* api callbacks */
280         ot->exec= material_slot_remove_exec;
281
282         /* flags */
283         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
284 }
285
286 static int material_slot_assign_exec(bContext *C, wmOperator *op)
287 {
288         Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
289
290         if(!ob)
291                 return OPERATOR_CANCELLED;
292
293         if(ob && ob->actcol>0) {
294                 if(ob->type == OB_MESH) {
295                         EditMesh *em= ((Mesh*)ob->data)->edit_mesh;
296                         EditFace *efa;
297
298                         if(em) {
299                                 for(efa= em->faces.first; efa; efa=efa->next)
300                                         if(efa->f & SELECT)
301                                                 efa->mat_nr= ob->actcol-1;
302                         }
303                 }
304                 else if(ELEM(ob->type, OB_CURVE, OB_SURF)) {
305                         ListBase *editnurb= ((Curve*)ob->data)->editnurb;
306                         Nurb *nu;
307
308                         if(editnurb) {
309                                 for(nu= editnurb->first; nu; nu= nu->next)
310                                         if(isNurbsel(nu))
311                                                 nu->mat_nr= nu->charidx= ob->actcol-1;
312                         }
313                 }
314                 else if(ob->type == OB_FONT) {
315                         EditFont *ef= ((Curve*)ob->data)->editfont;
316                 int i, selstart, selend;
317
318                         if(ef && BKE_font_getselection(ob, &selstart, &selend)) {
319                                 for(i=selstart; i<=selend; i++)
320                                         ef->textbufinfo[i].mat_nr = ob->actcol-1;
321                         }
322                 }
323         }
324
325     DAG_id_flush_update(&ob->id, OB_RECALC_DATA);
326     WM_event_add_notifier(C, NC_GEOM|ND_DATA, ob->data);
327         
328         return OPERATOR_FINISHED;
329 }
330
331 void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
332 {
333         /* identifiers */
334         ot->name= "Assign Material Slot";
335         ot->idname= "OBJECT_OT_material_slot_assign";
336         ot->description="Assign the material in the selected material slot to the selected vertices";
337         
338         /* api callbacks */
339         ot->exec= material_slot_assign_exec;
340
341         /* flags */
342         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
343 }
344
345 static int material_slot_de_select(bContext *C, int select)
346 {
347         Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
348
349         if(!ob)
350                 return OPERATOR_CANCELLED;
351
352         if(ob->type == OB_MESH) {
353                 EditMesh *em= ((Mesh*)ob->data)->edit_mesh;
354
355                 if(em) {
356                         if(select)
357                                 EM_select_by_material(em, ob->actcol-1);
358                         else
359                                 EM_deselect_by_material(em, ob->actcol-1);
360                 }
361         }
362         else if ELEM(ob->type, OB_CURVE, OB_SURF) {
363                 ListBase *editnurb= ((Curve*)ob->data)->editnurb;
364                 Nurb *nu;
365                 BPoint *bp;
366                 BezTriple *bezt;
367                 int a;
368
369                 for(nu= editnurb->first; nu; nu=nu->next) {
370                         if(nu->mat_nr==ob->actcol-1) {
371                                 if(nu->bezt) {
372                                         a= nu->pntsu;
373                                         bezt= nu->bezt;
374                                         while(a--) {
375                                                 if(bezt->hide==0) {
376                                                         if(select) {
377                                                                 bezt->f1 |= SELECT;
378                                                                 bezt->f2 |= SELECT;
379                                                                 bezt->f3 |= SELECT;
380                                                         }
381                                                         else {
382                                                                 bezt->f1 &= ~SELECT;
383                                                                 bezt->f2 &= ~SELECT;
384                                                                 bezt->f3 &= ~SELECT;
385                                                         }
386                                                 }
387                                                 bezt++;
388                                         }
389                                 }
390                                 else if(nu->bp) {
391                                         a= nu->pntsu*nu->pntsv;
392                                         bp= nu->bp;
393                                         while(a--) {
394                                                 if(bp->hide==0) {
395                                                         if(select) bp->f1 |= SELECT;
396                                                         else bp->f1 &= ~SELECT;
397                                                 }
398                                                 bp++;
399                                         }
400                                 }
401                         }
402                 }
403         }
404
405     WM_event_add_notifier(C, NC_GEOM|ND_SELECT, ob->data);
406
407         return OPERATOR_FINISHED;
408 }
409
410 static int material_slot_select_exec(bContext *C, wmOperator *op)
411 {
412         return material_slot_de_select(C, 1);
413 }
414
415 void OBJECT_OT_material_slot_select(wmOperatorType *ot)
416 {
417         /* identifiers */
418         ot->name= "Select Material Slot";
419         ot->idname= "OBJECT_OT_material_slot_select";
420         ot->description="Select vertices assigned to the selected material slot";
421         
422         /* api callbacks */
423         ot->exec= material_slot_select_exec;
424
425         /* flags */
426         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
427 }
428
429 static int material_slot_deselect_exec(bContext *C, wmOperator *op)
430 {
431         return material_slot_de_select(C, 0);
432 }
433
434 void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
435 {
436         /* identifiers */
437         ot->name= "Deselect Material Slot";
438         ot->idname= "OBJECT_OT_material_slot_deselect";
439         ot->description="Deselect vertices assigned to the selected material slot";
440         
441         /* api callbacks */
442         ot->exec= material_slot_deselect_exec;
443
444         /* flags */
445         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
446 }
447
448
449 static int material_slot_copy_exec(bContext *C, wmOperator *op)
450 {
451         Object *ob= CTX_data_pointer_get_type(C, "object", &RNA_Object).data;
452         Material ***matar;
453
454         if(!ob || !(matar= give_matarar(ob)))
455                 return OPERATOR_CANCELLED;
456
457         CTX_DATA_BEGIN(C, Object*, ob_iter, selected_editable_objects) {
458                 if(ob != ob_iter && give_matarar(ob_iter)) {
459                         if (ob->data != ob_iter->data)
460                                 assign_matarar(ob_iter, matar, ob->totcol);
461                         
462                         if(ob_iter->totcol==ob->totcol) {
463                                 ob_iter->actcol= ob->actcol;
464                                 WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob_iter);
465                         }
466                 }
467         }
468         CTX_DATA_END;
469
470         return OPERATOR_FINISHED;
471 }
472
473
474 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
475 {
476         /* identifiers */
477         ot->name= "Copy Material to Others";
478         ot->idname= "OBJECT_OT_material_slot_copy";
479         ot->description="Copies materials to other selected objects";
480
481         /* api callbacks */
482         ot->exec= material_slot_copy_exec;
483
484         /* flags */
485         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
486 }
487
488 /********************** new material operator *********************/
489
490 static int new_material_exec(bContext *C, wmOperator *op)
491 {
492         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
493         PointerRNA ptr, idptr;
494         PropertyRNA *prop;
495
496         /* add or copy material */
497         if(ma)
498                 ma= copy_material(ma);
499         else
500                 ma= add_material("Material");
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                 ma->id.us--;
509
510                 RNA_id_pointer_create(&ma->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_MATERIAL|NA_ADDED, ma);
516         
517         return OPERATOR_FINISHED;
518 }
519
520 void MATERIAL_OT_new(wmOperatorType *ot)
521 {
522         /* identifiers */
523         ot->name= "New Material";
524         ot->idname= "MATERIAL_OT_new";
525         ot->description="Add a new material";
526         
527         /* api callbacks */
528         ot->exec= new_material_exec;
529
530         /* flags */
531         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
532 }
533
534 /********************** new texture operator *********************/
535
536 static int new_texture_exec(bContext *C, wmOperator *op)
537 {
538         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
539         PointerRNA ptr, idptr;
540         PropertyRNA *prop;
541
542         /* add or copy texture */
543         if(tex)
544                 tex= copy_texture(tex);
545         else
546                 tex= add_texture("Texture");
547
548         /* hook into UI */
549         uiIDContextProperty(C, &ptr, &prop);
550
551         if(prop) {
552                 /* when creating new ID blocks, use is already 1, but RNA
553                  * pointer se also increases user, so this compensates it */
554                 tex->id.us--;
555
556                 RNA_id_pointer_create(&tex->id, &idptr);
557                 RNA_property_pointer_set(&ptr, prop, idptr);
558                 RNA_property_update(C, &ptr, prop);
559         }
560
561         WM_event_add_notifier(C, NC_TEXTURE|NA_ADDED, tex);
562         
563         return OPERATOR_FINISHED;
564 }
565
566 void TEXTURE_OT_new(wmOperatorType *ot)
567 {
568         /* identifiers */
569         ot->name= "New Texture";
570         ot->idname= "TEXTURE_OT_new";
571         ot->description="Add a new texture";
572         
573         /* api callbacks */
574         ot->exec= new_texture_exec;
575
576         /* flags */
577         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
578 }
579
580 /********************** new world operator *********************/
581
582 static int new_world_exec(bContext *C, wmOperator *op)
583 {
584         World *wo= CTX_data_pointer_get_type(C, "world", &RNA_World).data;
585         PointerRNA ptr, idptr;
586         PropertyRNA *prop;
587
588         /* add or copy world */
589         if(wo)
590                 wo= copy_world(wo);
591         else
592                 wo= add_world("World");
593
594         /* hook into UI */
595         uiIDContextProperty(C, &ptr, &prop);
596
597         if(prop) {
598                 /* when creating new ID blocks, use is already 1, but RNA
599                  * pointer se also increases user, so this compensates it */
600                 wo->id.us--;
601
602                 RNA_id_pointer_create(&wo->id, &idptr);
603                 RNA_property_pointer_set(&ptr, prop, idptr);
604                 RNA_property_update(C, &ptr, prop);
605         }
606
607         WM_event_add_notifier(C, NC_WORLD|NA_ADDED, wo);
608         
609         return OPERATOR_FINISHED;
610 }
611
612 void WORLD_OT_new(wmOperatorType *ot)
613 {
614         /* identifiers */
615         ot->name= "New World";
616         ot->idname= "WORLD_OT_new";
617         ot->description= "Add a new world";
618         
619         /* api callbacks */
620         ot->exec= new_world_exec;
621
622         /* flags */
623         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
624 }
625
626 /********************** render layer operators *********************/
627
628 static int render_layer_add_exec(bContext *C, wmOperator *op)
629 {
630         Scene *scene= CTX_data_scene(C);
631
632         scene_add_render_layer(scene);
633         scene->r.actlay= BLI_countlist(&scene->r.layers) - 1;
634
635         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
636         
637         return OPERATOR_FINISHED;
638 }
639
640 void SCENE_OT_render_layer_add(wmOperatorType *ot)
641 {
642         /* identifiers */
643         ot->name= "Add Render Layer";
644         ot->idname= "SCENE_OT_render_layer_add";
645         ot->description="Add a render layer";
646         
647         /* api callbacks */
648         ot->exec= render_layer_add_exec;
649
650         /* flags */
651         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
652 }
653
654 static int render_layer_remove_exec(bContext *C, wmOperator *op)
655 {
656         Scene *scene= CTX_data_scene(C);
657         SceneRenderLayer *rl;
658         int act= scene->r.actlay;
659
660         if(BLI_countlist(&scene->r.layers) <= 1)
661                 return OPERATOR_CANCELLED;
662         
663         rl= BLI_findlink(&scene->r.layers, scene->r.actlay);
664         BLI_remlink(&scene->r.layers, rl);
665         MEM_freeN(rl);
666
667         scene->r.actlay= 0;
668         
669         if(scene->nodetree) {
670                 bNode *node;
671                 for(node= scene->nodetree->nodes.first; node; node= node->next) {
672                         if(node->type==CMP_NODE_R_LAYERS && node->id==NULL) {
673                                 if(node->custom1==act)
674                                         node->custom1= 0;
675                                 else if(node->custom1>act)
676                                         node->custom1--;
677                         }
678                 }
679         }
680
681         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
682         
683         return OPERATOR_FINISHED;
684 }
685
686 void SCENE_OT_render_layer_remove(wmOperatorType *ot)
687 {
688         /* identifiers */
689         ot->name= "Remove Render Layer";
690         ot->idname= "SCENE_OT_render_layer_remove";
691         ot->description="Remove the selected render layer";
692         
693         /* api callbacks */
694         ot->exec= render_layer_remove_exec;
695
696         /* flags */
697         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
698 }
699
700 static int freestyle_module_add_exec(bContext *C, wmOperator *op)
701 {
702         Scene *scene= CTX_data_scene(C);
703         SceneRenderLayer *srl = (SceneRenderLayer*) BLI_findlink(&scene->r.layers, scene->r.actlay);
704
705         FRS_add_module(&srl->freestyleConfig);
706
707         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
708         
709         return OPERATOR_FINISHED;
710 }
711
712 void SCENE_OT_freestyle_module_add(wmOperatorType *ot)
713 {
714         /* identifiers */
715         ot->name= "Add Freestyle Module";
716         ot->idname= "SCENE_OT_freestyle_module_add";
717         ot->description="Add a style module into the list of modules.";
718         
719         /* api callbacks */
720         ot->exec= freestyle_module_add_exec;
721
722         /* flags */
723         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
724 }
725
726 static int freestyle_module_remove_exec(bContext *C, wmOperator *op)
727 {
728         Scene *scene= CTX_data_scene(C);
729         SceneRenderLayer *srl = (SceneRenderLayer*) BLI_findlink(&scene->r.layers, scene->r.actlay);
730         PointerRNA ptr= CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
731         FreestyleModuleConfig *module= ptr.data;
732
733         FRS_delete_module(&srl->freestyleConfig, module);
734
735         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
736         
737         return OPERATOR_FINISHED;
738 }
739
740 void SCENE_OT_freestyle_module_remove(wmOperatorType *ot)
741 {
742         /* identifiers */
743         ot->name= "Remove Freestyle Module";
744         ot->idname= "SCENE_OT_freestyle_module_remove";
745         ot->description="Remove the style module from the stack.";
746         
747         /* api callbacks */
748         ot->exec= freestyle_module_remove_exec;
749
750         /* flags */
751         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
752 }
753
754 static int freestyle_module_move_up_exec(bContext *C, wmOperator *op)
755 {
756         Scene *scene= CTX_data_scene(C);
757         SceneRenderLayer *srl = (SceneRenderLayer*) BLI_findlink(&scene->r.layers, scene->r.actlay);
758         PointerRNA ptr= CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
759         FreestyleModuleConfig *module= ptr.data;
760         int active = RNA_boolean_get(op->ptr, "active");
761
762         if(active)
763                 FRS_move_up_module(&srl->freestyleConfig, module);
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_module_move_up(wmOperatorType *ot)
771 {
772         /* identifiers */
773         ot->name= "Move Up Freestyle Module";
774         ot->idname= "SCENE_OT_freestyle_module_move_up";
775         ot->description="Move the style module up in the stack.";
776         
777         /* api callbacks */
778         ot->exec= freestyle_module_move_up_exec;
779
780         /* flags */
781         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
782
783         /* props */
784         RNA_def_boolean(ot->srna, "active", 0, "Active", "True if the operator is enabled.");
785 }
786
787 static int freestyle_module_move_down_exec(bContext *C, wmOperator *op)
788 {
789         Scene *scene= CTX_data_scene(C);
790         SceneRenderLayer *srl = (SceneRenderLayer*) BLI_findlink(&scene->r.layers, scene->r.actlay);
791         PointerRNA ptr= CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
792         FreestyleModuleConfig *module= ptr.data;
793         int active = RNA_boolean_get(op->ptr, "active");
794
795         if(active)
796                 FRS_move_down_module(&srl->freestyleConfig, module);
797
798         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
799         
800         return OPERATOR_FINISHED;
801 }
802
803 void SCENE_OT_freestyle_module_move_down(wmOperatorType *ot)
804 {
805         /* identifiers */
806         ot->name= "Move Down Freestyle Module";
807         ot->idname= "SCENE_OT_freestyle_module_move_down";
808         ot->description="Move the style module down in the stack.";
809         
810         /* api callbacks */
811         ot->exec= freestyle_module_move_down_exec;
812
813         /* flags */
814         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
815
816         /* props */
817         RNA_def_boolean(ot->srna, "active", 0, "Active", "True if the operator is enabled.");
818 }
819
820 static int texture_slot_move(bContext *C, wmOperator *op)
821 {
822         ID *id= CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
823         Material *ma = (Material *)id;
824
825         if(id) {
826                 MTex **mtex_ar, *mtexswap;
827                 short act;
828                 int type= RNA_enum_get(op->ptr, "type");
829
830                 give_active_mtex(id, &mtex_ar, &act);
831
832                 if(type == -1) { /* Up */
833                         if(act > 0) {
834                                 mtexswap = mtex_ar[act];
835                                 mtex_ar[act] = mtex_ar[act-1];
836                                 mtex_ar[act-1] = mtexswap;
837                                 
838                                 BKE_animdata_fix_paths_rename(id, ma->adt, "texture_slots", NULL, NULL, act-1, -1, 0);
839                                 BKE_animdata_fix_paths_rename(id, ma->adt, "texture_slots", NULL, NULL, act, act-1, 0);
840                                 BKE_animdata_fix_paths_rename(id, ma->adt, "texture_slots", NULL, NULL, -1, act, 0);
841
842                                 if(GS(id->name)==ID_MA) {
843                                         Material *ma= (Material *)id;
844                                         int mtexuse = ma->septex & (1<<act);
845                                         ma->septex &= ~(1<<act);
846                                         ma->septex |= (ma->septex & (1<<(act-1))) << 1;
847                                         ma->septex &= ~(1<<(act-1));
848                                         ma->septex |= mtexuse >> 1;
849                                 }
850                                 
851                                 set_active_mtex(id, act-1);
852                         }
853                 }
854                 else { /* Down */
855                         if(act < MAX_MTEX-1) {
856                                 mtexswap = mtex_ar[act];
857                                 mtex_ar[act] = mtex_ar[act+1];
858                                 mtex_ar[act+1] = mtexswap;
859                                 
860                                 BKE_animdata_fix_paths_rename(id, ma->adt, "texture_slots", NULL, NULL, act+1, -1, 0);
861                                 BKE_animdata_fix_paths_rename(id, ma->adt, "texture_slots", NULL, NULL, act, act+1, 0);
862                                 BKE_animdata_fix_paths_rename(id, ma->adt, "texture_slots", NULL, NULL, -1, act, 0);
863
864                                 if(GS(id->name)==ID_MA) {
865                                         Material *ma= (Material *)id;
866                                         int mtexuse = ma->septex & (1<<act);
867                                         ma->septex &= ~(1<<act);
868                                         ma->septex |= (ma->septex & (1<<(act+1))) >> 1;
869                                         ma->septex &= ~(1<<(act+1));
870                                         ma->septex |= mtexuse << 1;
871                                 }
872                                 
873                                 set_active_mtex(id, act+1);
874                         }
875                 }
876
877                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
878         }
879
880         return OPERATOR_FINISHED;
881 }
882
883 void TEXTURE_OT_slot_move(wmOperatorType *ot)
884 {
885         static EnumPropertyItem slot_move[] = {
886                 {-1, "UP", 0, "Up", ""},
887                 {1, "DOWN", 0, "Down", ""},
888                 {0, NULL, 0, NULL, NULL}
889         };
890
891         /* identifiers */
892         ot->name= "Move Texture Slot";
893         ot->idname= "TEXTURE_OT_slot_move";
894         ot->description="Move texture slots up and down";
895
896         /* api callbacks */
897         ot->exec= texture_slot_move;
898
899         /* flags */
900         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
901
902         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
903 }
904
905
906
907 /********************** environment map operators *********************/
908
909 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *str, int imtype)
910 {
911         ImBuf *ibuf;
912         int dx;
913         int retval;
914         
915         if(env->cube[1]==NULL) {
916                 BKE_report(op->reports, RPT_ERROR, "There is no generated environment map available to save");
917                 return OPERATOR_CANCELLED;
918         }
919         
920         dx= env->cube[1]->x;
921         
922         if (env->type == ENV_CUBE) {
923                 ibuf = IMB_allocImBuf(3*dx, 2*dx, 24, IB_rectfloat, 0);
924
925                 IMB_rectcpy(ibuf, env->cube[0], 0, 0, 0, 0, dx, dx);
926                 IMB_rectcpy(ibuf, env->cube[1], dx, 0, 0, 0, dx, dx);
927                 IMB_rectcpy(ibuf, env->cube[2], 2*dx, 0, 0, 0, dx, dx);
928                 IMB_rectcpy(ibuf, env->cube[3], 0, dx, 0, 0, dx, dx);
929                 IMB_rectcpy(ibuf, env->cube[4], dx, dx, 0, 0, dx, dx);
930                 IMB_rectcpy(ibuf, env->cube[5], 2*dx, dx, 0, 0, dx, dx);
931         }
932         else if (env->type == ENV_PLANE) {
933                 ibuf = IMB_allocImBuf(dx, dx, 24, IB_rectfloat, 0);
934                 IMB_rectcpy(ibuf, env->cube[1], 0, 0, 0, 0, dx, dx);            
935         }
936         
937         if (scene->r.color_mgt_flag & R_COLOR_MANAGEMENT)
938                 ibuf->profile = IB_PROFILE_LINEAR_RGB;
939         
940         if (BKE_write_ibuf(scene, ibuf, str, imtype, scene->r.subimtype, scene->r.quality)) {
941                 retval = OPERATOR_FINISHED;
942         }
943         else {
944                 BKE_reportf(op->reports, RPT_ERROR, "Error saving environment map to %s.", str);
945                 retval = OPERATOR_CANCELLED;
946         }
947         
948         IMB_freeImBuf(ibuf);
949         ibuf = NULL;
950         
951         return retval;
952 }
953
954 static int envmap_save_exec(bContext *C, wmOperator *op)
955 {
956         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
957         Scene *scene = CTX_data_scene(C);
958         //int imtype = RNA_enum_get(op->ptr, "file_type");
959         int imtype = scene->r.imtype;
960         char path[FILE_MAX];
961         
962         RNA_string_get(op->ptr, "path", path);
963         
964         if(scene->r.scemode & R_EXTENSION)  {
965                 BKE_add_image_extension(path, imtype);
966         }
967         
968         WM_cursor_wait(1);
969         
970         save_envmap(op, scene, tex->env, path, imtype);
971         
972         WM_cursor_wait(0);
973         
974         WM_event_add_notifier(C, NC_TEXTURE, tex);
975         
976         return OPERATOR_FINISHED;
977 }
978
979 static int envmap_save_invoke(bContext *C, wmOperator *op, wmEvent *event)
980 {
981         //Scene *scene= CTX_data_scene(C);
982         
983         if(!RNA_property_is_set(op->ptr, "relative_path"))
984                 RNA_boolean_set(op->ptr, "relative_path", U.flag & USER_RELPATHS);
985         
986         if(RNA_property_is_set(op->ptr, "path"))
987                 return envmap_save_exec(C, op);
988
989         //RNA_enum_set(op->ptr, "file_type", scene->r.imtype);
990         
991         RNA_string_set(op->ptr, "path", G.sce);
992         WM_event_add_fileselect(C, op);
993         
994         return OPERATOR_RUNNING_MODAL;
995 }
996
997 static int envmap_save_poll(bContext *C)
998 {
999         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1000
1001         if (!tex) 
1002                 return 0;
1003         if (!tex->env || !tex->env->ok)
1004                 return 0;
1005         if (tex->env->cube[1]==NULL)
1006                 return 0;
1007         
1008         return 1;
1009 }
1010
1011 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
1012 {
1013         /* identifiers */
1014         ot->name= "Save Environment Map";
1015         ot->idname= "TEXTURE_OT_envmap_save";
1016         ot->description="Save the current generated Environment map to an image file";
1017         
1018         /* api callbacks */
1019         ot->exec= envmap_save_exec;
1020         ot->invoke= envmap_save_invoke;
1021         ot->poll= envmap_save_poll;
1022         
1023         /* flags */
1024         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1025         
1026         /* properties */
1027         //RNA_def_enum(ot->srna, "file_type", image_file_type_items, R_PNG, "File Type", "File type to save image as.");
1028         WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE|MOVIEFILE, FILE_SPECIAL, FILE_SAVE);
1029         
1030         RNA_def_boolean(ot->srna, "relative_path", 0, "Relative Path", "Save image with relative path to current .blend file");
1031 }
1032
1033 static int envmap_clear_exec(bContext *C, wmOperator *op)
1034 {
1035         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1036         
1037         BKE_free_envmapdata(tex->env);
1038         
1039         WM_event_add_notifier(C, NC_TEXTURE|NA_EDITED, tex);
1040         
1041         return OPERATOR_FINISHED;
1042 }
1043
1044 static int envmap_clear_poll(bContext *C)
1045 {
1046         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1047         
1048         if (!tex) 
1049                 return 0;
1050         if (!tex->env || !tex->env->ok)
1051                 return 0;
1052         if (tex->env->cube[1]==NULL)
1053                 return 0;
1054         
1055         return 1;
1056 }
1057
1058 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
1059 {
1060         /* identifiers */
1061         ot->name= "Clear Environment Map";
1062         ot->idname= "TEXTURE_OT_envmap_clear";
1063         ot->description="Discard the environment map and free it from memory";
1064         
1065         /* api callbacks */
1066         ot->exec= envmap_clear_exec;
1067         ot->poll= envmap_clear_poll;
1068         
1069         /* flags */
1070         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1071 }
1072
1073 static int envmap_clear_all_exec(bContext *C, wmOperator *op)
1074 {
1075         Main *bmain = CTX_data_main(C);
1076         Tex *tex;
1077         
1078         for (tex=bmain->tex.first; tex; tex=tex->id.next)
1079                 if (tex->env)
1080                         BKE_free_envmapdata(tex->env);
1081         
1082         WM_event_add_notifier(C, NC_TEXTURE|NA_EDITED, tex);
1083         
1084         return OPERATOR_FINISHED;
1085 }
1086
1087 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
1088 {
1089         /* identifiers */
1090         ot->name= "Clear All Environment Maps";
1091         ot->idname= "TEXTURE_OT_envmap_clear_all";
1092         ot->description="Discard all environment maps in the .blend file and free them from memory";
1093         
1094         /* api callbacks */
1095         ot->exec= envmap_clear_all_exec;
1096         ot->poll= envmap_clear_poll;
1097         
1098         /* flags */
1099         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1100 }
1101
1102 /********************** material operators *********************/
1103
1104 /* material copy/paste */
1105 static int copy_material_exec(bContext *C, wmOperator *op)
1106 {
1107         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1108
1109         if(ma==NULL)
1110                 return OPERATOR_CANCELLED;
1111
1112         copy_matcopybuf(ma);
1113
1114         WM_event_add_notifier(C, NC_MATERIAL, ma);
1115
1116         return OPERATOR_FINISHED;
1117 }
1118
1119 void MATERIAL_OT_copy(wmOperatorType *ot)
1120 {
1121         /* identifiers */
1122         ot->name= "Copy Material";
1123         ot->idname= "MATERIAL_OT_copy";
1124         ot->description="Copy the material settings and nodes";
1125
1126         /* api callbacks */
1127         ot->exec= copy_material_exec;
1128
1129         /* flags */
1130         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1131 }
1132
1133 static int paste_material_exec(bContext *C, wmOperator *op)
1134 {
1135         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1136
1137         if(ma==NULL)
1138                 return OPERATOR_CANCELLED;
1139
1140         paste_matcopybuf(ma);
1141
1142         WM_event_add_notifier(C, NC_MATERIAL|ND_SHADING_DRAW, ma);
1143
1144         return OPERATOR_FINISHED;
1145 }
1146
1147 void MATERIAL_OT_paste(wmOperatorType *ot)
1148 {
1149         /* identifiers */
1150         ot->name= "Paste Material";
1151         ot->idname= "MATERIAL_OT_paste";
1152         ot->description="Copy the material settings and nodes";
1153
1154         /* api callbacks */
1155         ot->exec= paste_material_exec;
1156
1157         /* flags */
1158         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1159 }
1160
1161 static int copy_material_mtex_exec(bContext *C, wmOperator *op)
1162 {
1163         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1164
1165         if(ma==NULL)
1166                 return OPERATOR_CANCELLED;
1167
1168         copy_mat_mtex_copybuf(&ma->id);
1169
1170         WM_event_add_notifier(C, NC_MATERIAL, ma);
1171
1172         return OPERATOR_FINISHED;
1173 }
1174
1175 void MATERIAL_OT_mtex_copy(wmOperatorType *ot)
1176 {
1177         /* identifiers */
1178         ot->name= "Copy Material Texture Settings";
1179         ot->idname= "MATERIAL_OT_mtex_copy";
1180         ot->description="Copy the material texture settings and nodes";
1181
1182         /* api callbacks */
1183         ot->exec= copy_material_mtex_exec;
1184
1185         /* flags */
1186         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1187 }
1188
1189 static int paste_material_mtex_exec(bContext *C, wmOperator *op)
1190 {
1191         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1192
1193         if(ma==NULL)
1194                 return OPERATOR_CANCELLED;
1195
1196         paste_mat_mtex_copybuf(&ma->id);
1197
1198         WM_event_add_notifier(C, NC_MATERIAL|ND_SHADING_DRAW, ma);
1199
1200         return OPERATOR_FINISHED;
1201 }
1202
1203 void MATERIAL_OT_mtex_paste(wmOperatorType *ot)
1204 {
1205         /* identifiers */
1206         ot->name= "Paste Material Texture Settings";
1207         ot->idname= "MATERIAL_OT_mtex_paste";
1208         ot->description="Copy the material texture settings and nodes";
1209
1210         /* api callbacks */
1211         ot->exec= paste_material_mtex_exec;
1212
1213         /* flags */
1214         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
1215 }