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