code cleanup: use const events for modal and invoke operators.
[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 #include "RNA_access.h"
73
74 #include "WM_api.h"
75 #include "WM_types.h"
76
77 #include "ED_object.h"
78 #include "ED_curve.h"
79 #include "ED_mesh.h"
80 #include "ED_node.h"
81 #include "ED_render.h"
82 #include "ED_screen.h"
83
84 #include "RNA_define.h"
85
86 #include "UI_interface.h"
87
88 #include "RE_pipeline.h"
89
90 #include "render_intern.h"  // own include
91
92 /********************** material slot operators *********************/
93
94 static int material_slot_add_exec(bContext *C, wmOperator *UNUSED(op))
95 {
96         Object *ob = ED_object_context(C);
97
98         if (!ob)
99                 return OPERATOR_CANCELLED;
100
101         object_add_material_slot(ob);
102         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
103         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
104         
105         return OPERATOR_FINISHED;
106 }
107
108 void OBJECT_OT_material_slot_add(wmOperatorType *ot)
109 {
110         /* identifiers */
111         ot->name = "Add Material Slot";
112         ot->idname = "OBJECT_OT_material_slot_add";
113         ot->description = "Add a new material slot";
114         
115         /* api callbacks */
116         ot->exec = material_slot_add_exec;
117         ot->poll = ED_operator_object_active_editable;
118
119         /* flags */
120         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
121 }
122
123 static int material_slot_remove_exec(bContext *C, wmOperator *op)
124 {
125         Object *ob = ED_object_context(C);
126
127         if (!ob)
128                 return OPERATOR_CANCELLED;
129
130         /* Removing material slots in edit mode screws things up, see bug #21822.*/
131         if (ob == CTX_data_edit_object(C)) {
132                 BKE_report(op->reports, RPT_ERROR, "Unable to remove material slot in edit mode");
133                 return OPERATOR_CANCELLED;
134         }
135
136         object_remove_material_slot(ob);
137         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
138         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
139         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
140         
141         return OPERATOR_FINISHED;
142 }
143
144 void OBJECT_OT_material_slot_remove(wmOperatorType *ot)
145 {
146         /* identifiers */
147         ot->name = "Remove Material Slot";
148         ot->idname = "OBJECT_OT_material_slot_remove";
149         ot->description = "Remove the selected material slot";
150         
151         /* api callbacks */
152         ot->exec = material_slot_remove_exec;
153         ot->poll = ED_operator_object_active_editable;
154
155         /* flags */
156         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
157 }
158
159 static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op))
160 {
161         Object *ob = ED_object_context(C);
162
163         if (!ob)
164                 return OPERATOR_CANCELLED;
165
166         if (ob && ob->actcol > 0) {
167                 if (ob->type == OB_MESH) {
168                         BMEditMesh *em = BMEdit_FromObject(ob);
169                         BMFace *efa;
170                         BMIter iter;
171
172                         if (em) {
173                                 BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
174                                         if (BM_elem_flag_test(efa, BM_ELEM_SELECT))
175                                                 efa->mat_nr = ob->actcol - 1;
176                                 }
177                         }
178                 }
179                 else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
180                         Nurb *nu;
181                         ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
182
183                         if (nurbs) {
184                                 for (nu = nurbs->first; nu; nu = nu->next)
185                                         if (isNurbsel(nu))
186                                                 nu->mat_nr = nu->charidx = ob->actcol - 1;
187                         }
188                 }
189                 else if (ob->type == OB_FONT) {
190                         EditFont *ef = ((Curve *)ob->data)->editfont;
191                         int i, selstart, selend;
192
193                         if (ef && BKE_vfont_select_get(ob, &selstart, &selend)) {
194                                 for (i = selstart; i <= selend; i++)
195                                         ef->textbufinfo[i].mat_nr = ob->actcol;
196                         }
197                 }
198         }
199
200         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
201         WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
202         
203         return OPERATOR_FINISHED;
204 }
205
206 void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
207 {
208         /* identifiers */
209         ot->name = "Assign Material Slot";
210         ot->idname = "OBJECT_OT_material_slot_assign";
211         ot->description = "Assign active material slot to selection";
212         
213         /* api callbacks */
214         ot->exec = material_slot_assign_exec;
215         ot->poll = ED_operator_object_active_editable;
216
217         /* flags */
218         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
219 }
220
221 static int material_slot_de_select(bContext *C, int select)
222 {
223         Object *ob = ED_object_context(C);
224
225         if (!ob)
226                 return OPERATOR_CANCELLED;
227
228         if (ob->type == OB_MESH) {
229                 BMEditMesh *em = BMEdit_FromObject(ob);
230
231                 if (em) {
232                         EDBM_deselect_by_material(em, ob->actcol - 1, select);
233                 }
234         }
235         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
236                 ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
237                 Nurb *nu;
238                 BPoint *bp;
239                 BezTriple *bezt;
240                 int a;
241
242                 if (nurbs) {
243                         for (nu = nurbs->first; nu; nu = nu->next) {
244                                 if (nu->mat_nr == ob->actcol - 1) {
245                                         if (nu->bezt) {
246                                                 a = nu->pntsu;
247                                                 bezt = nu->bezt;
248                                                 while (a--) {
249                                                         if (bezt->hide == 0) {
250                                                                 if (select) {
251                                                                         bezt->f1 |= SELECT;
252                                                                         bezt->f2 |= SELECT;
253                                                                         bezt->f3 |= SELECT;
254                                                                 }
255                                                                 else {
256                                                                         bezt->f1 &= ~SELECT;
257                                                                         bezt->f2 &= ~SELECT;
258                                                                         bezt->f3 &= ~SELECT;
259                                                                 }
260                                                         }
261                                                         bezt++;
262                                                 }
263                                         }
264                                         else if (nu->bp) {
265                                                 a = nu->pntsu * nu->pntsv;
266                                                 bp = nu->bp;
267                                                 while (a--) {
268                                                         if (bp->hide == 0) {
269                                                                 if (select) bp->f1 |= SELECT;
270                                                                 else bp->f1 &= ~SELECT;
271                                                         }
272                                                         bp++;
273                                                 }
274                                         }
275                                 }
276                         }
277                 }
278         }
279
280         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
281
282         return OPERATOR_FINISHED;
283 }
284
285 static int material_slot_select_exec(bContext *C, wmOperator *UNUSED(op))
286 {
287         return material_slot_de_select(C, 1);
288 }
289
290 void OBJECT_OT_material_slot_select(wmOperatorType *ot)
291 {
292         /* identifiers */
293         ot->name = "Select Material Slot";
294         ot->idname = "OBJECT_OT_material_slot_select";
295         ot->description = "Select by active material slot";
296         
297         /* api callbacks */
298         ot->exec = material_slot_select_exec;
299
300         /* flags */
301         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
302 }
303
304 static int material_slot_deselect_exec(bContext *C, wmOperator *UNUSED(op))
305 {
306         return material_slot_de_select(C, 0);
307 }
308
309 void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
310 {
311         /* identifiers */
312         ot->name = "Deselect Material Slot";
313         ot->idname = "OBJECT_OT_material_slot_deselect";
314         ot->description = "Deselect by active material slot";
315         
316         /* api callbacks */
317         ot->exec = material_slot_deselect_exec;
318
319         /* flags */
320         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
321 }
322
323
324 static int material_slot_copy_exec(bContext *C, wmOperator *UNUSED(op))
325 {
326         Object *ob = ED_object_context(C);
327         Material ***matar;
328
329         if (!ob || !(matar = give_matarar(ob)))
330                 return OPERATOR_CANCELLED;
331
332         CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects)
333         {
334                 if (ob != ob_iter && give_matarar(ob_iter)) {
335                         if (ob->data != ob_iter->data)
336                                 assign_matarar(ob_iter, matar, ob->totcol);
337                         
338                         if (ob_iter->totcol == ob->totcol) {
339                                 ob_iter->actcol = ob->actcol;
340                                 WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob_iter);
341                         }
342                 }
343         }
344         CTX_DATA_END;
345
346         return OPERATOR_FINISHED;
347 }
348
349
350 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
351 {
352         /* identifiers */
353         ot->name = "Copy Material to Others";
354         ot->idname = "OBJECT_OT_material_slot_copy";
355         ot->description = "Copies materials to other selected objects";
356
357         /* api callbacks */
358         ot->exec = material_slot_copy_exec;
359
360         /* flags */
361         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
362 }
363
364 /********************** new material operator *********************/
365
366 static int new_material_exec(bContext *C, wmOperator *UNUSED(op))
367 {
368         Scene *scene = CTX_data_scene(C);
369         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
370         Main *bmain = CTX_data_main(C);
371         PointerRNA ptr, idptr;
372         PropertyRNA *prop;
373
374         /* add or copy material */
375         if (ma) {
376                 ma = BKE_material_copy(ma);
377         }
378         else {
379                 ma = BKE_material_add(bmain, "Material");
380
381                 if (BKE_scene_use_new_shading_nodes(scene)) {
382                         ED_node_shader_default(scene, &ma->id);
383                         ma->use_nodes = TRUE;
384                 }
385         }
386
387         /* hook into UI */
388         uiIDContextProperty(C, &ptr, &prop);
389
390         if (prop) {
391                 /* when creating new ID blocks, use is already 1, but RNA
392                  * pointer se also increases user, so this compensates it */
393                 ma->id.us--;
394
395                 RNA_id_pointer_create(&ma->id, &idptr);
396                 RNA_property_pointer_set(&ptr, prop, idptr);
397                 RNA_property_update(C, &ptr, prop);
398         }
399
400         WM_event_add_notifier(C, NC_MATERIAL | NA_ADDED, ma);
401         
402         return OPERATOR_FINISHED;
403 }
404
405 void MATERIAL_OT_new(wmOperatorType *ot)
406 {
407         /* identifiers */
408         ot->name = "New Material";
409         ot->idname = "MATERIAL_OT_new";
410         ot->description = "Add a new material";
411         
412         /* api callbacks */
413         ot->exec = new_material_exec;
414
415         /* flags */
416         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
417 }
418
419 /********************** new texture operator *********************/
420
421 static int new_texture_exec(bContext *C, wmOperator *UNUSED(op))
422 {
423         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
424         Main *bmain = CTX_data_main(C);
425         PointerRNA ptr, idptr;
426         PropertyRNA *prop;
427
428         /* add or copy texture */
429         if (tex)
430                 tex = BKE_texture_copy(tex);
431         else
432                 tex = add_texture(bmain, "Texture");
433
434         /* hook into UI */
435         uiIDContextProperty(C, &ptr, &prop);
436
437         if (prop) {
438                 /* when creating new ID blocks, use is already 1, but RNA
439                  * pointer se also increases user, so this compensates it */
440                 tex->id.us--;
441
442                 RNA_id_pointer_create(&tex->id, &idptr);
443                 RNA_property_pointer_set(&ptr, prop, idptr);
444                 RNA_property_update(C, &ptr, prop);
445         }
446
447         WM_event_add_notifier(C, NC_TEXTURE | NA_ADDED, tex);
448         
449         return OPERATOR_FINISHED;
450 }
451
452 void TEXTURE_OT_new(wmOperatorType *ot)
453 {
454         /* identifiers */
455         ot->name = "New Texture";
456         ot->idname = "TEXTURE_OT_new";
457         ot->description = "Add a new texture";
458         
459         /* api callbacks */
460         ot->exec = new_texture_exec;
461
462         /* flags */
463         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
464 }
465
466 /********************** new world operator *********************/
467
468 static int new_world_exec(bContext *C, wmOperator *UNUSED(op))
469 {
470         Scene *scene = CTX_data_scene(C);
471         World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
472         Main *bmain = CTX_data_main(C);
473         PointerRNA ptr, idptr;
474         PropertyRNA *prop;
475
476         /* add or copy world */
477         if (wo) {
478                 wo = BKE_world_copy(wo);
479         }
480         else {
481                 wo = add_world(bmain, "World");
482
483                 if (BKE_scene_use_new_shading_nodes(scene)) {
484                         ED_node_shader_default(scene, &wo->id);
485                         wo->use_nodes = TRUE;
486                 }
487         }
488
489         /* hook into UI */
490         uiIDContextProperty(C, &ptr, &prop);
491
492         if (prop) {
493                 /* when creating new ID blocks, use is already 1, but RNA
494                  * pointer se also increases user, so this compensates it */
495                 wo->id.us--;
496
497                 RNA_id_pointer_create(&wo->id, &idptr);
498                 RNA_property_pointer_set(&ptr, prop, idptr);
499                 RNA_property_update(C, &ptr, prop);
500         }
501
502         WM_event_add_notifier(C, NC_WORLD | NA_ADDED, wo);
503         
504         return OPERATOR_FINISHED;
505 }
506
507 void WORLD_OT_new(wmOperatorType *ot)
508 {
509         /* identifiers */
510         ot->name = "New World";
511         ot->idname = "WORLD_OT_new";
512         ot->description = "Add a new world";
513         
514         /* api callbacks */
515         ot->exec = new_world_exec;
516
517         /* flags */
518         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
519 }
520
521 /********************** render layer operators *********************/
522
523 static int render_layer_add_exec(bContext *C, wmOperator *UNUSED(op))
524 {
525         Scene *scene = CTX_data_scene(C);
526
527         BKE_scene_add_render_layer(scene, NULL);
528         scene->r.actlay = BLI_countlist(&scene->r.layers) - 1;
529
530         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
531         
532         return OPERATOR_FINISHED;
533 }
534
535 void SCENE_OT_render_layer_add(wmOperatorType *ot)
536 {
537         /* identifiers */
538         ot->name = "Add Render Layer";
539         ot->idname = "SCENE_OT_render_layer_add";
540         ot->description = "Add a render layer";
541         
542         /* api callbacks */
543         ot->exec = render_layer_add_exec;
544
545         /* flags */
546         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
547 }
548
549 static int render_layer_remove_exec(bContext *C, wmOperator *UNUSED(op))
550 {
551         Scene *scene = CTX_data_scene(C);
552         SceneRenderLayer *rl = BLI_findlink(&scene->r.layers, scene->r.actlay);
553
554         if (!BKE_scene_remove_render_layer(CTX_data_main(C), scene, rl))
555                 return OPERATOR_CANCELLED;
556
557         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
558         
559         return OPERATOR_FINISHED;
560 }
561
562 void SCENE_OT_render_layer_remove(wmOperatorType *ot)
563 {
564         /* identifiers */
565         ot->name = "Remove Render Layer";
566         ot->idname = "SCENE_OT_render_layer_remove";
567         ot->description = "Remove the selected render layer";
568         
569         /* api callbacks */
570         ot->exec = render_layer_remove_exec;
571
572         /* flags */
573         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
574 }
575
576 static int texture_slot_move(bContext *C, wmOperator *op)
577 {
578         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
579
580         if (id) {
581                 MTex **mtex_ar, *mtexswap;
582                 short act;
583                 int type = RNA_enum_get(op->ptr, "type");
584                 struct AnimData *adt = BKE_animdata_from_id(id);
585
586                 give_active_mtex(id, &mtex_ar, &act);
587
588                 if (type == -1) { /* Up */
589                         if (act > 0) {
590                                 mtexswap = mtex_ar[act];
591                                 mtex_ar[act] = mtex_ar[act - 1];
592                                 mtex_ar[act - 1] = mtexswap;
593                                 
594                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act - 1, -1, 0);
595                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act - 1, 0);
596                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
597
598                                 if (GS(id->name) == ID_MA) {
599                                         Material *ma = (Material *)id;
600                                         int mtexuse = ma->septex & (1 << act);
601                                         ma->septex &= ~(1 << act);
602                                         ma->septex |= (ma->septex & (1 << (act - 1))) << 1;
603                                         ma->septex &= ~(1 << (act - 1));
604                                         ma->septex |= mtexuse >> 1;
605                                 }
606                                 
607                                 set_active_mtex(id, act - 1);
608                         }
609                 }
610                 else { /* Down */
611                         if (act < MAX_MTEX - 1) {
612                                 mtexswap = mtex_ar[act];
613                                 mtex_ar[act] = mtex_ar[act + 1];
614                                 mtex_ar[act + 1] = mtexswap;
615                                 
616                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act + 1, -1, 0);
617                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act + 1, 0);
618                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
619
620                                 if (GS(id->name) == ID_MA) {
621                                         Material *ma = (Material *)id;
622                                         int mtexuse = ma->septex & (1 << act);
623                                         ma->septex &= ~(1 << act);
624                                         ma->septex |= (ma->septex & (1 << (act + 1))) >> 1;
625                                         ma->septex &= ~(1 << (act + 1));
626                                         ma->septex |= mtexuse << 1;
627                                 }
628                                 
629                                 set_active_mtex(id, act + 1);
630                         }
631                 }
632
633                 DAG_id_tag_update(id, 0);
634                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
635         }
636
637         return OPERATOR_FINISHED;
638 }
639
640 void TEXTURE_OT_slot_move(wmOperatorType *ot)
641 {
642         static EnumPropertyItem slot_move[] = {
643                 {-1, "UP", 0, "Up", ""},
644                 {1, "DOWN", 0, "Down", ""},
645                 {0, NULL, 0, NULL, NULL}
646         };
647
648         /* identifiers */
649         ot->name = "Move Texture Slot";
650         ot->idname = "TEXTURE_OT_slot_move";
651         ot->description = "Move texture slots up and down";
652
653         /* api callbacks */
654         ot->exec = texture_slot_move;
655
656         /* flags */
657         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
658
659         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
660 }
661
662
663
664 /********************** environment map operators *********************/
665
666 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *path, const char imtype)
667 {
668         float layout[12];
669         if (RNA_struct_find_property(op->ptr, "layout") )
670                 RNA_float_get_array(op->ptr, "layout", layout);
671         else
672                 memcpy(layout, default_envmap_layout, sizeof(layout));
673
674         if (RE_WriteEnvmapResult(op->reports, scene, env, path, imtype, layout)) {
675                 return OPERATOR_FINISHED;
676         }
677         else {
678                 return OPERATOR_CANCELLED;
679         }
680
681 }
682
683 static int envmap_save_exec(bContext *C, wmOperator *op)
684 {
685         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
686         Scene *scene = CTX_data_scene(C);
687         //int imtype = RNA_enum_get(op->ptr, "file_type");
688         char imtype = scene->r.im_format.imtype;
689         char path[FILE_MAX];
690         
691         RNA_string_get(op->ptr, "filepath", path);
692         
693         if (scene->r.scemode & R_EXTENSION) {
694                 BKE_add_image_extension(path, &scene->r.im_format);
695         }
696         
697         WM_cursor_wait(1);
698         
699         save_envmap(op, scene, tex->env, path, imtype);
700         
701         WM_cursor_wait(0);
702         
703         WM_event_add_notifier(C, NC_TEXTURE, tex);
704         
705         return OPERATOR_FINISHED;
706 }
707
708 static int envmap_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
709 {
710         //Scene *scene= CTX_data_scene(C);
711         
712         if (RNA_struct_property_is_set(op->ptr, "filepath"))
713                 return envmap_save_exec(C, op);
714
715         //RNA_enum_set(op->ptr, "file_type", scene->r.im_format.imtype);
716         RNA_string_set(op->ptr, "filepath", G.main->name);
717         WM_event_add_fileselect(C, op);
718         
719         return OPERATOR_RUNNING_MODAL;
720 }
721
722 static int envmap_save_poll(bContext *C)
723 {
724         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
725
726         if (!tex) 
727                 return 0;
728         if (!tex->env || !tex->env->ok)
729                 return 0;
730         if (tex->env->cube[1] == NULL)
731                 return 0;
732         
733         return 1;
734 }
735
736 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
737 {
738         PropertyRNA *prop;
739         /* identifiers */
740         ot->name = "Save Environment Map";
741         ot->idname = "TEXTURE_OT_envmap_save";
742         ot->description = "Save the current generated Environment map to an image file";
743         
744         /* api callbacks */
745         ot->exec = envmap_save_exec;
746         ot->invoke = envmap_save_invoke;
747         ot->poll = envmap_save_poll;
748         
749         /* flags */
750         ot->flag = OPTYPE_REGISTER; /* no undo since this doesnt modify the env-map */
751         
752         /* properties */
753         prop = RNA_def_float_array(ot->srna, "layout", 12, default_envmap_layout, 0.0f, 0.0f,
754                                    "File layout",
755                                    "Flat array describing the X,Y position of each cube face in the output image, "
756                                    "where 1 is the size of a face - order is [+Z -Z +Y -X -Y +X] "
757                                    "(use -1 to skip a face)", 0.0f, 0.0f);
758         RNA_def_property_flag(prop, PROP_HIDDEN);
759
760         WM_operator_properties_filesel(ot, FOLDERFILE | IMAGEFILE | MOVIEFILE, FILE_SPECIAL, FILE_SAVE,
761                                        WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY);
762 }
763
764 static int envmap_clear_exec(bContext *C, wmOperator *UNUSED(op))
765 {
766         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
767         
768         BKE_free_envmapdata(tex->env);
769         
770         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
771         
772         return OPERATOR_FINISHED;
773 }
774
775 static int envmap_clear_poll(bContext *C)
776 {
777         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
778         
779         if (!tex) 
780                 return 0;
781         if (!tex->env || !tex->env->ok)
782                 return 0;
783         if (tex->env->cube[1] == NULL)
784                 return 0;
785         
786         return 1;
787 }
788
789 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
790 {
791         /* identifiers */
792         ot->name = "Clear Environment Map";
793         ot->idname = "TEXTURE_OT_envmap_clear";
794         ot->description = "Discard the environment map and free it from memory";
795         
796         /* api callbacks */
797         ot->exec = envmap_clear_exec;
798         ot->poll = envmap_clear_poll;
799         
800         /* flags */
801         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
802 }
803
804 static int envmap_clear_all_exec(bContext *C, wmOperator *UNUSED(op))
805 {
806         Main *bmain = CTX_data_main(C);
807         Tex *tex;
808         
809         for (tex = bmain->tex.first; tex; tex = tex->id.next)
810                 if (tex->env)
811                         BKE_free_envmapdata(tex->env);
812         
813         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
814         
815         return OPERATOR_FINISHED;
816 }
817
818 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
819 {
820         /* identifiers */
821         ot->name = "Clear All Environment Maps";
822         ot->idname = "TEXTURE_OT_envmap_clear_all";
823         ot->description = "Discard all environment maps in the .blend file and free them from memory";
824         
825         /* api callbacks */
826         ot->exec = envmap_clear_all_exec;
827         ot->poll = envmap_clear_poll;
828         
829         /* flags */
830         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
831 }
832
833 /********************** material operators *********************/
834
835 /* material copy/paste */
836 static int copy_material_exec(bContext *C, wmOperator *UNUSED(op))
837 {
838         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
839
840         if (ma == NULL)
841                 return OPERATOR_CANCELLED;
842
843         copy_matcopybuf(ma);
844
845         return OPERATOR_FINISHED;
846 }
847
848 void MATERIAL_OT_copy(wmOperatorType *ot)
849 {
850         /* identifiers */
851         ot->name = "Copy Material";
852         ot->idname = "MATERIAL_OT_copy";
853         ot->description = "Copy the material settings and nodes";
854
855         /* api callbacks */
856         ot->exec = copy_material_exec;
857
858         /* flags */
859         ot->flag = OPTYPE_REGISTER; /* no undo needed since no changes are made to the material */
860 }
861
862 static int paste_material_exec(bContext *C, wmOperator *UNUSED(op))
863 {
864         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
865
866         if (ma == NULL)
867                 return OPERATOR_CANCELLED;
868
869         paste_matcopybuf(ma);
870
871         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, ma);
872
873         return OPERATOR_FINISHED;
874 }
875
876 void MATERIAL_OT_paste(wmOperatorType *ot)
877 {
878         /* identifiers */
879         ot->name = "Paste Material";
880         ot->idname = "MATERIAL_OT_paste";
881         ot->description = "Paste the material settings and nodes";
882
883         /* api callbacks */
884         ot->exec = paste_material_exec;
885
886         /* flags */
887         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
888 }
889
890
891 static short mtexcopied = 0; /* must be reset on file load */
892 static MTex mtexcopybuf;
893
894 void ED_render_clear_mtex_copybuf(void)
895 {   /* use for file reload */
896         mtexcopied = 0;
897 }
898
899 static void copy_mtex_copybuf(ID *id)
900 {
901         MTex **mtex = NULL;
902         
903         switch (GS(id->name)) {
904                 case ID_MA:
905                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
906                         break;
907                 case ID_LA:
908                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
909                         // la->mtex[(int)la->texact] // TODO
910                         break;
911                 case ID_WO:
912                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
913                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
914                         break;
915                 case ID_PA:
916                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
917                         break;
918         }
919         
920         if (mtex && *mtex) {
921                 memcpy(&mtexcopybuf, *mtex, sizeof(MTex));
922                 mtexcopied = 1;
923         }
924         else {
925                 mtexcopied = 0;
926         }
927 }
928
929 static void paste_mtex_copybuf(ID *id)
930 {
931         MTex **mtex = NULL;
932         
933         if (mtexcopied == 0 || mtexcopybuf.tex == NULL)
934                 return;
935         
936         switch (GS(id->name)) {
937                 case ID_MA:
938                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
939                         break;
940                 case ID_LA:
941                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
942                         // la->mtex[(int)la->texact] // TODO
943                         break;
944                 case ID_WO:
945                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
946                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
947                         break;
948                 case ID_PA:
949                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
950                         break;
951                 default:
952                         BLI_assert("invalid id type");
953                         return;
954         }
955         
956         if (mtex) {
957                 if (*mtex == NULL) {
958                         *mtex = MEM_mallocN(sizeof(MTex), "mtex copy");
959                 }
960                 else if ((*mtex)->tex) {
961                         (*mtex)->tex->id.us--;
962                 }
963                 
964                 memcpy(*mtex, &mtexcopybuf, sizeof(MTex));
965                 
966                 id_us_plus((ID *)mtexcopybuf.tex);
967         }
968 }
969
970
971 static int copy_mtex_exec(bContext *C, wmOperator *UNUSED(op))
972 {
973         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
974
975         if (id == NULL) {
976                 /* copying empty slot */
977                 ED_render_clear_mtex_copybuf();
978                 return OPERATOR_CANCELLED;
979         }
980
981         copy_mtex_copybuf(id);
982
983         return OPERATOR_FINISHED;
984 }
985
986 static int copy_mtex_poll(bContext *C)
987 {
988         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
989         
990         return (id != NULL);
991 }
992
993 void TEXTURE_OT_slot_copy(wmOperatorType *ot)
994 {
995         /* identifiers */
996         ot->name = "Copy Texture Slot Settings";
997         ot->idname = "TEXTURE_OT_slot_copy";
998         ot->description = "Copy the material texture settings and nodes";
999
1000         /* api callbacks */
1001         ot->exec = copy_mtex_exec;
1002         ot->poll = copy_mtex_poll;
1003         
1004         /* flags */
1005         ot->flag = OPTYPE_REGISTER; /* no undo needed since no changes are made to the mtex */
1006 }
1007
1008 static int paste_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1009 {
1010         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1011
1012         if (id == NULL) {
1013                 Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1014                 Lamp *la = CTX_data_pointer_get_type(C, "lamp", &RNA_Lamp).data;
1015                 World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
1016                 ParticleSystem *psys = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1017                 
1018                 if (ma)
1019                         id = &ma->id;
1020                 else if (la)
1021                         id = &la->id;
1022                 else if (wo)
1023                         id = &wo->id;
1024                 else if (psys)
1025                         id = &psys->part->id;
1026                 
1027                 if (id == NULL)
1028                         return OPERATOR_CANCELLED;
1029         }
1030
1031         paste_mtex_copybuf(id);
1032
1033         WM_event_add_notifier(C, NC_TEXTURE | ND_SHADING_LINKS, NULL);
1034
1035         return OPERATOR_FINISHED;
1036 }
1037
1038 void TEXTURE_OT_slot_paste(wmOperatorType *ot)
1039 {
1040         /* identifiers */
1041         ot->name = "Paste Texture Slot Settings";
1042         ot->idname = "TEXTURE_OT_slot_paste";
1043         ot->description = "Copy the texture settings and nodes";
1044
1045         /* api callbacks */
1046         ot->exec = paste_mtex_exec;
1047
1048         /* flags */
1049         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1050 }
1051