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