style cleanup: follow style guide for formatting of if/for/while loops, and else...
[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(efa, &iter, em->bm, BM_FACES_OF_MESH, NULL) {
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= curve_editnurbs((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_font_getselection(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 the material in the selected material slot to the selected vertices";
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= curve_editnurbs((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 vertices assigned to the selected 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 vertices assigned to the selected 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                 if (ob != ob_iter && give_matarar(ob_iter)) {
334                         if (ob->data != ob_iter->data)
335                                 assign_matarar(ob_iter, matar, ob->totcol);
336                         
337                         if (ob_iter->totcol==ob->totcol) {
338                                 ob_iter->actcol= ob->actcol;
339                                 WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob_iter);
340                         }
341                 }
342         }
343         CTX_DATA_END;
344
345         return OPERATOR_FINISHED;
346 }
347
348
349 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
350 {
351         /* identifiers */
352         ot->name = "Copy Material to Others";
353         ot->idname = "OBJECT_OT_material_slot_copy";
354         ot->description = "Copies materials to other selected objects";
355
356         /* api callbacks */
357         ot->exec = material_slot_copy_exec;
358
359         /* flags */
360         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
361 }
362
363 /********************** new material operator *********************/
364
365 static int new_material_exec(bContext *C, wmOperator *UNUSED(op))
366 {
367         Scene *scene= CTX_data_scene(C);
368         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
369         PointerRNA ptr, idptr;
370         PropertyRNA *prop;
371
372         /* add or copy material */
373         if (ma) {
374                 ma= copy_material(ma);
375         }
376         else {
377                 ma= add_material("Material");
378
379                 if (scene_use_new_shading_nodes(scene)) {
380                         ED_node_shader_default(scene, &ma->id);
381                         ma->use_nodes= 1;
382                 }
383         }
384
385         /* hook into UI */
386         uiIDContextProperty(C, &ptr, &prop);
387
388         if (prop) {
389                 /* when creating new ID blocks, use is already 1, but RNA
390                  * pointer se also increases user, so this compensates it */
391                 ma->id.us--;
392
393                 RNA_id_pointer_create(&ma->id, &idptr);
394                 RNA_property_pointer_set(&ptr, prop, idptr);
395                 RNA_property_update(C, &ptr, prop);
396         }
397
398         WM_event_add_notifier(C, NC_MATERIAL|NA_ADDED, ma);
399         
400         return OPERATOR_FINISHED;
401 }
402
403 void MATERIAL_OT_new(wmOperatorType *ot)
404 {
405         /* identifiers */
406         ot->name = "New Material";
407         ot->idname = "MATERIAL_OT_new";
408         ot->description = "Add a new material";
409         
410         /* api callbacks */
411         ot->exec = new_material_exec;
412
413         /* flags */
414         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
415 }
416
417 /********************** new texture operator *********************/
418
419 static int new_texture_exec(bContext *C, wmOperator *UNUSED(op))
420 {
421         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
422         PointerRNA ptr, idptr;
423         PropertyRNA *prop;
424
425         /* add or copy texture */
426         if (tex)
427                 tex= copy_texture(tex);
428         else
429                 tex= add_texture("Texture");
430
431         /* hook into UI */
432         uiIDContextProperty(C, &ptr, &prop);
433
434         if (prop) {
435                 /* when creating new ID blocks, use is already 1, but RNA
436                  * pointer se also increases user, so this compensates it */
437                 tex->id.us--;
438
439                 RNA_id_pointer_create(&tex->id, &idptr);
440                 RNA_property_pointer_set(&ptr, prop, idptr);
441                 RNA_property_update(C, &ptr, prop);
442         }
443
444         WM_event_add_notifier(C, NC_TEXTURE|NA_ADDED, tex);
445         
446         return OPERATOR_FINISHED;
447 }
448
449 void TEXTURE_OT_new(wmOperatorType *ot)
450 {
451         /* identifiers */
452         ot->name = "New Texture";
453         ot->idname = "TEXTURE_OT_new";
454         ot->description = "Add a new texture";
455         
456         /* api callbacks */
457         ot->exec = new_texture_exec;
458
459         /* flags */
460         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
461 }
462
463 /********************** new world operator *********************/
464
465 static int new_world_exec(bContext *C, wmOperator *UNUSED(op))
466 {
467         Scene *scene= CTX_data_scene(C);
468         World *wo= CTX_data_pointer_get_type(C, "world", &RNA_World).data;
469         PointerRNA ptr, idptr;
470         PropertyRNA *prop;
471
472         /* add or copy world */
473         if (wo) {
474                 wo= copy_world(wo);
475         }
476         else {
477                 wo= add_world("World");
478
479                 if (scene_use_new_shading_nodes(scene)) {
480                         ED_node_shader_default(scene, &wo->id);
481                         wo->use_nodes= 1;
482                 }
483         }
484
485         /* hook into UI */
486         uiIDContextProperty(C, &ptr, &prop);
487
488         if (prop) {
489                 /* when creating new ID blocks, use is already 1, but RNA
490                  * pointer se also increases user, so this compensates it */
491                 wo->id.us--;
492
493                 RNA_id_pointer_create(&wo->id, &idptr);
494                 RNA_property_pointer_set(&ptr, prop, idptr);
495                 RNA_property_update(C, &ptr, prop);
496         }
497
498         WM_event_add_notifier(C, NC_WORLD|NA_ADDED, wo);
499         
500         return OPERATOR_FINISHED;
501 }
502
503 void WORLD_OT_new(wmOperatorType *ot)
504 {
505         /* identifiers */
506         ot->name = "New World";
507         ot->idname = "WORLD_OT_new";
508         ot->description = "Add a new world";
509         
510         /* api callbacks */
511         ot->exec = new_world_exec;
512
513         /* flags */
514         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
515 }
516
517 /********************** render layer operators *********************/
518
519 static int render_layer_add_exec(bContext *C, wmOperator *UNUSED(op))
520 {
521         Scene *scene= CTX_data_scene(C);
522
523         scene_add_render_layer(scene, NULL);
524         scene->r.actlay= BLI_countlist(&scene->r.layers) - 1;
525
526         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
527         
528         return OPERATOR_FINISHED;
529 }
530
531 void SCENE_OT_render_layer_add(wmOperatorType *ot)
532 {
533         /* identifiers */
534         ot->name = "Add Render Layer";
535         ot->idname = "SCENE_OT_render_layer_add";
536         ot->description = "Add a render layer";
537         
538         /* api callbacks */
539         ot->exec = render_layer_add_exec;
540
541         /* flags */
542         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
543 }
544
545 static int render_layer_remove_exec(bContext *C, wmOperator *UNUSED(op))
546 {
547         Scene *scene = CTX_data_scene(C);
548         SceneRenderLayer *rl = BLI_findlink(&scene->r.layers, scene->r.actlay);
549
550         if (!scene_remove_render_layer(CTX_data_main(C), scene, rl))
551                 return OPERATOR_CANCELLED;
552
553         WM_event_add_notifier(C, NC_SCENE|ND_RENDER_OPTIONS, scene);
554         
555         return OPERATOR_FINISHED;
556 }
557
558 void SCENE_OT_render_layer_remove(wmOperatorType *ot)
559 {
560         /* identifiers */
561         ot->name = "Remove Render Layer";
562         ot->idname = "SCENE_OT_render_layer_remove";
563         ot->description = "Remove the selected render layer";
564         
565         /* api callbacks */
566         ot->exec = render_layer_remove_exec;
567
568         /* flags */
569         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
570 }
571
572 static int texture_slot_move(bContext *C, wmOperator *op)
573 {
574         ID *id= CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
575
576         if (id) {
577                 MTex **mtex_ar, *mtexswap;
578                 short act;
579                 int type= RNA_enum_get(op->ptr, "type");
580                 struct AnimData *adt= BKE_animdata_from_id(id);
581
582                 give_active_mtex(id, &mtex_ar, &act);
583
584                 if (type == -1) { /* Up */
585                         if (act > 0) {
586                                 mtexswap = mtex_ar[act];
587                                 mtex_ar[act] = mtex_ar[act-1];
588                                 mtex_ar[act-1] = mtexswap;
589                                 
590                                 BKE_animdata_fix_paths_rename(id, adt, "texture_slots", NULL, NULL, act-1, -1, 0);
591                                 BKE_animdata_fix_paths_rename(id, adt, "texture_slots", NULL, NULL, act, act-1, 0);
592                                 BKE_animdata_fix_paths_rename(id, adt, "texture_slots", NULL, NULL, -1, act, 0);
593
594                                 if (GS(id->name)==ID_MA) {
595                                         Material *ma= (Material *)id;
596                                         int mtexuse = ma->septex & (1<<act);
597                                         ma->septex &= ~(1<<act);
598                                         ma->septex |= (ma->septex & (1<<(act-1))) << 1;
599                                         ma->septex &= ~(1<<(act-1));
600                                         ma->septex |= mtexuse >> 1;
601                                 }
602                                 
603                                 set_active_mtex(id, act-1);
604                         }
605                 }
606                 else { /* Down */
607                         if (act < MAX_MTEX-1) {
608                                 mtexswap = mtex_ar[act];
609                                 mtex_ar[act] = mtex_ar[act+1];
610                                 mtex_ar[act+1] = mtexswap;
611                                 
612                                 BKE_animdata_fix_paths_rename(id, adt, "texture_slots", NULL, NULL, act+1, -1, 0);
613                                 BKE_animdata_fix_paths_rename(id, adt, "texture_slots", NULL, NULL, act, act+1, 0);
614                                 BKE_animdata_fix_paths_rename(id, adt, "texture_slots", NULL, NULL, -1, act, 0);
615
616                                 if (GS(id->name)==ID_MA) {
617                                         Material *ma= (Material *)id;
618                                         int mtexuse = ma->septex & (1<<act);
619                                         ma->septex &= ~(1<<act);
620                                         ma->septex |= (ma->septex & (1<<(act+1))) >> 1;
621                                         ma->septex &= ~(1<<(act+1));
622                                         ma->septex |= mtexuse << 1;
623                                 }
624                                 
625                                 set_active_mtex(id, act+1);
626                         }
627                 }
628
629                 DAG_id_tag_update(id, 0);
630                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
631         }
632
633         return OPERATOR_FINISHED;
634 }
635
636 void TEXTURE_OT_slot_move(wmOperatorType *ot)
637 {
638         static EnumPropertyItem slot_move[] = {
639                 {-1, "UP", 0, "Up", ""},
640                 {1, "DOWN", 0, "Down", ""},
641                 {0, NULL, 0, NULL, NULL}
642         };
643
644         /* identifiers */
645         ot->name = "Move Texture Slot";
646         ot->idname = "TEXTURE_OT_slot_move";
647         ot->description = "Move texture slots up and down";
648
649         /* api callbacks */
650         ot->exec = texture_slot_move;
651
652         /* flags */
653         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
654
655         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
656 }
657
658
659
660 /********************** environment map operators *********************/
661
662 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *path, const char imtype)
663 {
664         float layout[12];
665         if ( RNA_struct_find_property(op->ptr, "layout") )
666                 RNA_float_get_array(op->ptr, "layout",layout);
667         else
668                 memcpy(layout, default_envmap_layout, sizeof(layout));
669
670         if (RE_WriteEnvmapResult(op->reports, scene, env, path, imtype, layout)) {
671                 return OPERATOR_FINISHED;
672         }
673         else {
674                 return OPERATOR_CANCELLED;
675         }
676
677 }
678
679 static int envmap_save_exec(bContext *C, wmOperator *op)
680 {
681         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
682         Scene *scene = CTX_data_scene(C);
683         //int imtype = RNA_enum_get(op->ptr, "file_type");
684         char imtype = scene->r.im_format.imtype;
685         char path[FILE_MAX];
686         
687         RNA_string_get(op->ptr, "filepath", path);
688         
689         if (scene->r.scemode & R_EXTENSION) {
690                 BKE_add_image_extension(path, imtype);
691         }
692         
693         WM_cursor_wait(1);
694         
695         save_envmap(op, scene, tex->env, path, imtype);
696         
697         WM_cursor_wait(0);
698         
699         WM_event_add_notifier(C, NC_TEXTURE, tex);
700         
701         return OPERATOR_FINISHED;
702 }
703
704 static int envmap_save_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
705 {
706         //Scene *scene= CTX_data_scene(C);
707         
708         if (RNA_struct_property_is_set(op->ptr, "filepath"))
709                 return envmap_save_exec(C, op);
710
711         //RNA_enum_set(op->ptr, "file_type", scene->r.im_format.imtype);
712         RNA_string_set(op->ptr, "filepath", G.main->name);
713         WM_event_add_fileselect(C, op);
714         
715         return OPERATOR_RUNNING_MODAL;
716 }
717
718 static int envmap_save_poll(bContext *C)
719 {
720         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
721
722         if (!tex) 
723                 return 0;
724         if (!tex->env || !tex->env->ok)
725                 return 0;
726         if (tex->env->cube[1]==NULL)
727                 return 0;
728         
729         return 1;
730 }
731
732 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
733 {
734         PropertyRNA *prop;
735         /* identifiers */
736         ot->name = "Save Environment Map";
737         ot->idname = "TEXTURE_OT_envmap_save";
738         ot->description = "Save the current generated Environment map to an image file";
739         
740         /* api callbacks */
741         ot->exec = envmap_save_exec;
742         ot->invoke = envmap_save_invoke;
743         ot->poll = envmap_save_poll;
744         
745         /* flags */
746         ot->flag = OPTYPE_REGISTER; /* no undo since this doesnt modify the env-map */
747         
748         /* properties */
749         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);
750         RNA_def_property_flag(prop, PROP_HIDDEN);
751
752         WM_operator_properties_filesel(ot, FOLDERFILE|IMAGEFILE|MOVIEFILE, FILE_SPECIAL, FILE_SAVE, WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY);
753 }
754
755 static int envmap_clear_exec(bContext *C, wmOperator *UNUSED(op))
756 {
757         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
758         
759         BKE_free_envmapdata(tex->env);
760         
761         WM_event_add_notifier(C, NC_TEXTURE|NA_EDITED, tex);
762         
763         return OPERATOR_FINISHED;
764 }
765
766 static int envmap_clear_poll(bContext *C)
767 {
768         Tex *tex= CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
769         
770         if (!tex) 
771                 return 0;
772         if (!tex->env || !tex->env->ok)
773                 return 0;
774         if (tex->env->cube[1]==NULL)
775                 return 0;
776         
777         return 1;
778 }
779
780 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
781 {
782         /* identifiers */
783         ot->name = "Clear Environment Map";
784         ot->idname = "TEXTURE_OT_envmap_clear";
785         ot->description = "Discard the environment map and free it from memory";
786         
787         /* api callbacks */
788         ot->exec = envmap_clear_exec;
789         ot->poll = envmap_clear_poll;
790         
791         /* flags */
792         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
793 }
794
795 static int envmap_clear_all_exec(bContext *C, wmOperator *UNUSED(op))
796 {
797         Main *bmain = CTX_data_main(C);
798         Tex *tex;
799         
800         for (tex=bmain->tex.first; tex; tex=tex->id.next)
801                 if (tex->env)
802                         BKE_free_envmapdata(tex->env);
803         
804         WM_event_add_notifier(C, NC_TEXTURE|NA_EDITED, tex);
805         
806         return OPERATOR_FINISHED;
807 }
808
809 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
810 {
811         /* identifiers */
812         ot->name = "Clear All Environment Maps";
813         ot->idname = "TEXTURE_OT_envmap_clear_all";
814         ot->description = "Discard all environment maps in the .blend file and free them from memory";
815         
816         /* api callbacks */
817         ot->exec = envmap_clear_all_exec;
818         ot->poll = envmap_clear_poll;
819         
820         /* flags */
821         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
822 }
823
824 /********************** material operators *********************/
825
826 /* material copy/paste */
827 static int copy_material_exec(bContext *C, wmOperator *UNUSED(op))
828 {
829         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
830
831         if (ma==NULL)
832                 return OPERATOR_CANCELLED;
833
834         copy_matcopybuf(ma);
835
836         return OPERATOR_FINISHED;
837 }
838
839 void MATERIAL_OT_copy(wmOperatorType *ot)
840 {
841         /* identifiers */
842         ot->name = "Copy Material";
843         ot->idname = "MATERIAL_OT_copy";
844         ot->description = "Copy the material settings and nodes";
845
846         /* api callbacks */
847         ot->exec = copy_material_exec;
848
849         /* flags */
850         ot->flag = OPTYPE_REGISTER; /* no undo needed since no changes are made to the material */
851 }
852
853 static int paste_material_exec(bContext *C, wmOperator *UNUSED(op))
854 {
855         Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
856
857         if (ma==NULL)
858                 return OPERATOR_CANCELLED;
859
860         paste_matcopybuf(ma);
861
862         WM_event_add_notifier(C, NC_MATERIAL|ND_SHADING_DRAW, ma);
863
864         return OPERATOR_FINISHED;
865 }
866
867 void MATERIAL_OT_paste(wmOperatorType *ot)
868 {
869         /* identifiers */
870         ot->name = "Paste Material";
871         ot->idname = "MATERIAL_OT_paste";
872         ot->description = "Paste the material settings and nodes";
873
874         /* api callbacks */
875         ot->exec = paste_material_exec;
876
877         /* flags */
878         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
879 }
880
881
882 static short mtexcopied=0; /* must be reset on file load */
883 static MTex mtexcopybuf;
884
885 void ED_render_clear_mtex_copybuf(void)
886 {       /* use for file reload */
887         mtexcopied= 0;
888 }
889
890 static void copy_mtex_copybuf(ID *id)
891 {
892         MTex **mtex= NULL;
893         
894         switch(GS(id->name)) {
895                 case ID_MA:
896                         mtex= &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
897                         break;
898                 case ID_LA:
899                         mtex= &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
900                         // la->mtex[(int)la->texact] // TODO
901                         break;
902                 case ID_WO:
903                         mtex= &(((World *)id)->mtex[(int)((World *)id)->texact]);
904                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
905                         break;
906                 case ID_PA:
907                         mtex= &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
908                         break;
909         }
910         
911         if (mtex && *mtex) {
912                 memcpy(&mtexcopybuf, *mtex, sizeof(MTex));
913                 mtexcopied= 1;
914         }
915         else {
916                 mtexcopied= 0;
917         }
918 }
919
920 static void paste_mtex_copybuf(ID *id)
921 {
922         MTex **mtex= NULL;
923         
924         if (mtexcopied == 0 || mtexcopybuf.tex==NULL)
925                 return;
926         
927         switch(GS(id->name)) {
928                 case ID_MA:
929                         mtex= &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
930                         break;
931                 case ID_LA:
932                         mtex= &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
933                         // la->mtex[(int)la->texact] // TODO
934                         break;
935                 case ID_WO:
936                         mtex= &(((World *)id)->mtex[(int)((World *)id)->texact]);
937                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
938                         break;
939                 case ID_PA:
940                         mtex= &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
941                         break;
942                 default:
943                         BLI_assert("invalid id type");
944                         return;
945         }
946         
947         if (mtex) {
948                 if (*mtex==NULL) {
949                         *mtex= MEM_mallocN(sizeof(MTex), "mtex copy");
950                 }
951                 else if ((*mtex)->tex) {
952                         (*mtex)->tex->id.us--;
953                 }
954                 
955                 memcpy(*mtex, &mtexcopybuf, sizeof(MTex));
956                 
957                 id_us_plus((ID *)mtexcopybuf.tex);
958         }
959 }
960
961
962 static int copy_mtex_exec(bContext *C, wmOperator *UNUSED(op))
963 {
964         ID *id= CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
965
966         if (id==NULL) {
967                 /* copying empty slot */
968                 ED_render_clear_mtex_copybuf();
969                 return OPERATOR_CANCELLED;
970         }
971
972         copy_mtex_copybuf(id);
973
974         return OPERATOR_FINISHED;
975 }
976
977 static int copy_mtex_poll(bContext *C)
978 {
979         ID *id= CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
980         
981         return (id != NULL);
982 }
983
984 void TEXTURE_OT_slot_copy(wmOperatorType *ot)
985 {
986         /* identifiers */
987         ot->name = "Copy Texture Slot Settings";
988         ot->idname = "TEXTURE_OT_slot_copy";
989         ot->description = "Copy the material texture settings and nodes";
990
991         /* api callbacks */
992         ot->exec = copy_mtex_exec;
993         ot->poll = copy_mtex_poll;
994         
995         /* flags */
996         ot->flag = OPTYPE_REGISTER; /* no undo needed since no changes are made to the mtex */
997 }
998
999 static int paste_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1000 {
1001         ID *id= CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1002
1003         if (id==NULL) {
1004                 Material *ma= CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1005                 Lamp *la= CTX_data_pointer_get_type(C, "lamp", &RNA_Lamp).data;
1006                 World *wo= CTX_data_pointer_get_type(C, "world", &RNA_World).data;
1007                 ParticleSystem *psys= CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1008                 
1009                 if (ma)
1010                         id = &ma->id;
1011                 else if (la)
1012                         id = &la->id;
1013                 else if (wo)
1014                         id = &wo->id;
1015                 else if (psys)
1016                         id = &psys->part->id;
1017                 
1018                 if (id==NULL)
1019                         return OPERATOR_CANCELLED;
1020         }
1021
1022         paste_mtex_copybuf(id);
1023
1024         WM_event_add_notifier(C, NC_TEXTURE|ND_SHADING_DRAW, NULL);
1025
1026         return OPERATOR_FINISHED;
1027 }
1028
1029 void TEXTURE_OT_slot_paste(wmOperatorType *ot)
1030 {
1031         /* identifiers */
1032         ot->name = "Paste Texture Slot Settings";
1033         ot->idname = "TEXTURE_OT_slot_paste";
1034         ot->description = "Copy the texture settings and nodes";
1035
1036         /* api callbacks */
1037         ot->exec = paste_mtex_exec;
1038
1039         /* flags */
1040         ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
1041 }
1042