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_curve_types.h"
  35 #include "DNA_lamp_types.h"
  36 #include "DNA_material_types.h"
  37 #include "DNA_node_types.h"
  38 #include "DNA_object_types.h"
  39 #include "DNA_particle_types.h"
  40 #include "DNA_scene_types.h"
  41 #include "DNA_space_types.h"
  42 #include "DNA_world_types.h"
  43
  44 #include "BLI_utildefines.h"
  45 #include "BLI_listbase.h"
  46 #include "BLI_math_vector.h"
  47
  48 #include "BLT_translation.h"
  49
  50 #include "BKE_animsys.h"
  51 #include "BKE_context.h"
  52 #include "BKE_curve.h"
  53 #include "BKE_depsgraph.h"
  54 #include "BKE_font.h"
  55 #include "BKE_global.h"
  56 #include "BKE_image.h"
  57 #include "BKE_library.h"
  58 #include "BKE_linestyle.h"
  59 #include "BKE_main.h"
  60 #include "BKE_material.h"
  61 #include "BKE_paint.h"
  62 #include "BKE_report.h"
  63 #include "BKE_scene.h"
  64 #include "BKE_texture.h"
  65 #include "BKE_world.h"
  66 #include "BKE_editmesh.h"
  67
  68
  69
  70 #ifdef WITH_FREESTYLE
  71 #  include "BKE_freestyle.h"
  72 #  include "FRS_freestyle.h"
  73 #  include "RNA_enum_types.h"
  74 #endif
  75
  76 #include "RNA_access.h"
  77
  78 #include "WM_api.h"
  79 #include "WM_types.h"
  80
  81 #include "ED_object.h"
  82 #include "ED_curve.h"
  83 #include "ED_mesh.h"
  84 #include "ED_node.h"
  85 #include "ED_render.h"
  86 #include "ED_screen.h"
  87
  88 #include "RNA_define.h"
  89
  90 #include "UI_interface.h"
  91
  92 #include "RE_pipeline.h"
  93
  94 #include "render_intern.h"  // own include
  95
  96 /********************** material slot operators *********************/
  97
  98 static int material_slot_add_exec(bContext *C, wmOperator *UNUSED(op))
  99 {
 100         Main *bmain = CTX_data_main(C);
 101         Object *ob = ED_object_context(C);
 102
 103         if (!ob)
 104                 return OPERATOR_CANCELLED;
 105
 106         BKE_object_material_slot_add(bmain, ob);
 107
 108         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
 109                 Scene *scene = CTX_data_scene(C);
 110                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 111                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
 112         }
 113
 114         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
 115         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
 116         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_PREVIEW, ob);
 117
 118         return OPERATOR_FINISHED;
 119 }
 120
 121 void OBJECT_OT_material_slot_add(wmOperatorType *ot)
 122 {
 123         /* identifiers */
 124         ot->name = "Add Material Slot";
 125         ot->idname = "OBJECT_OT_material_slot_add";
 126         ot->description = "Add a new material slot";
 127
 128         /* api callbacks */
 129         ot->exec = material_slot_add_exec;
 130         ot->poll = ED_operator_object_active_editable;
 131
 132         /* flags */
 133         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 134 }
 135
 136 static int material_slot_remove_exec(bContext *C, wmOperator *op)
 137 {
 138         Object *ob = ED_object_context(C);
 139
 140         if (!ob)
 141                 return OPERATOR_CANCELLED;
 142
 143         /* Removing material slots in edit mode screws things up, see bug #21822.*/
 144         if (ob == CTX_data_edit_object(C)) {
 145                 BKE_report(op->reports, RPT_ERROR, "Unable to remove material slot in edit mode");
 146                 return OPERATOR_CANCELLED;
 147         }
 148
 149         BKE_object_material_slot_remove(CTX_data_main(C), ob);
 150
 151         if (ob->mode & OB_MODE_TEXTURE_PAINT) {
 152                 Scene *scene = CTX_data_scene(C);
 153                 BKE_paint_proj_mesh_data_check(scene, ob, NULL, NULL, NULL, NULL);
 154                 WM_event_add_notifier(C, NC_SCENE | ND_TOOLSETTINGS, NULL);
 155         }
 156
 157         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
 158         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
 159         WM_event_add_notifier(C, NC_OBJECT | ND_OB_SHADING, ob);
 160         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_PREVIEW, ob);
 161
 162         return OPERATOR_FINISHED;
 163 }
 164
 165 void OBJECT_OT_material_slot_remove(wmOperatorType *ot)
 166 {
 167         /* identifiers */
 168         ot->name = "Remove Material Slot";
 169         ot->idname = "OBJECT_OT_material_slot_remove";
 170         ot->description = "Remove the selected material slot";
 171
 172         /* api callbacks */
 173         ot->exec = material_slot_remove_exec;
 174         ot->poll = ED_operator_object_active_editable;
 175
 176         /* flags */
 177         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 178 }
 179
 180 static int material_slot_assign_exec(bContext *C, wmOperator *UNUSED(op))
 181 {
 182         Object *ob = ED_object_context(C);
 183
 184         if (!ob)
 185                 return OPERATOR_CANCELLED;
 186
 187         if (ob && ob->actcol > 0) {
 188                 if (ob->type == OB_MESH) {
 189                         BMEditMesh *em = BKE_editmesh_from_object(ob);
 190                         BMFace *efa;
 191                         BMIter iter;
 192
 193                         if (em) {
 194                                 BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
 195                                         if (BM_elem_flag_test(efa, BM_ELEM_SELECT))
 196                                                 efa->mat_nr = ob->actcol - 1;
 197                                 }
 198                         }
 199                 }
 200                 else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
 201                         Nurb *nu;
 202                         ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
 203
 204                         if (nurbs) {
 205                                 for (nu = nurbs->first; nu; nu = nu->next) {
 206                                         if (ED_curve_nurb_select_check(ob->data, nu)) {
 207                                                 nu->mat_nr = ob->actcol - 1;
 208                                         }
 209                                 }
 210                         }
 211                 }
 212                 else if (ob->type == OB_FONT) {
 213                         EditFont *ef = ((Curve *)ob->data)->editfont;
 214                         int i, selstart, selend;
 215
 216                         if (ef && BKE_vfont_select_get(ob, &selstart, &selend)) {
 217                                 for (i = selstart; i <= selend; i++)
 218                                         ef->textbufinfo[i].mat_nr = ob->actcol;
 219                         }
 220                 }
 221         }
 222
 223         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
 224         WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
 225
 226         return OPERATOR_FINISHED;
 227 }
 228
 229 void OBJECT_OT_material_slot_assign(wmOperatorType *ot)
 230 {
 231         /* identifiers */
 232         ot->name = "Assign Material Slot";
 233         ot->idname = "OBJECT_OT_material_slot_assign";
 234         ot->description = "Assign active material slot to selection";
 235
 236         /* api callbacks */
 237         ot->exec = material_slot_assign_exec;
 238         ot->poll = ED_operator_object_active_editable;
 239
 240         /* flags */
 241         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 242 }
 243
 244 static int material_slot_de_select(bContext *C, bool select)
 245 {
 246         Object *ob = ED_object_context(C);
 247
 248         if (!ob)
 249                 return OPERATOR_CANCELLED;
 250
 251         if (ob->type == OB_MESH) {
 252                 BMEditMesh *em = BKE_editmesh_from_object(ob);
 253
 254                 if (em) {
 255                         EDBM_deselect_by_material(em, ob->actcol - 1, select);
 256                 }
 257         }
 258         else if (ELEM(ob->type, OB_CURVE, OB_SURF)) {
 259                 ListBase *nurbs = BKE_curve_editNurbs_get((Curve *)ob->data);
 260                 Nurb *nu;
 261                 BPoint *bp;
 262                 BezTriple *bezt;
 263                 int a;
 264
 265                 if (nurbs) {
 266                         for (nu = nurbs->first; nu; nu = nu->next) {
 267                                 if (nu->mat_nr == ob->actcol - 1) {
 268                                         if (nu->bezt) {
 269                                                 a = nu->pntsu;
 270                                                 bezt = nu->bezt;
 271                                                 while (a--) {
 272                                                         if (bezt->hide == 0) {
 273                                                                 if (select) {
 274                                                                         bezt->f1 |= SELECT;
 275                                                                         bezt->f2 |= SELECT;
 276                                                                         bezt->f3 |= SELECT;
 277                                                                 }
 278                                                                 else {
 279                                                                         bezt->f1 &= ~SELECT;
 280                                                                         bezt->f2 &= ~SELECT;
 281                                                                         bezt->f3 &= ~SELECT;
 282                                                                 }
 283                                                         }
 284                                                         bezt++;
 285                                                 }
 286                                         }
 287                                         else if (nu->bp) {
 288                                                 a = nu->pntsu * nu->pntsv;
 289                                                 bp = nu->bp;
 290                                                 while (a--) {
 291                                                         if (bp->hide == 0) {
 292                                                                 if (select) bp->f1 |= SELECT;
 293                                                                 else bp->f1 &= ~SELECT;
 294                                                         }
 295                                                         bp++;
 296                                                 }
 297                                         }
 298                                 }
 299                         }
 300                 }
 301         }
 302
 303         WM_event_add_notifier(C, NC_GEOM | ND_SELECT, ob->data);
 304
 305         return OPERATOR_FINISHED;
 306 }
 307
 308 static int material_slot_select_exec(bContext *C, wmOperator *UNUSED(op))
 309 {
 310         return material_slot_de_select(C, true);
 311 }
 312
 313 void OBJECT_OT_material_slot_select(wmOperatorType *ot)
 314 {
 315         /* identifiers */
 316         ot->name = "Select Material Slot";
 317         ot->idname = "OBJECT_OT_material_slot_select";
 318         ot->description = "Select by active material slot";
 319
 320         /* api callbacks */
 321         ot->exec = material_slot_select_exec;
 322
 323         /* flags */
 324         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 325 }
 326
 327 static int material_slot_deselect_exec(bContext *C, wmOperator *UNUSED(op))
 328 {
 329         return material_slot_de_select(C, false);
 330 }
 331
 332 void OBJECT_OT_material_slot_deselect(wmOperatorType *ot)
 333 {
 334         /* identifiers */
 335         ot->name = "Deselect Material Slot";
 336         ot->idname = "OBJECT_OT_material_slot_deselect";
 337         ot->description = "Deselect by active material slot";
 338
 339         /* api callbacks */
 340         ot->exec = material_slot_deselect_exec;
 341
 342         /* flags */
 343         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 344 }
 345
 346
 347 static int material_slot_copy_exec(bContext *C, wmOperator *UNUSED(op))
 348 {
 349         Main *bmain = CTX_data_main(C);
 350         Object *ob = ED_object_context(C);
 351         Material ***matar;
 352
 353         if (!ob || !(matar = give_matarar(ob)))
 354                 return OPERATOR_CANCELLED;
 355
 356         CTX_DATA_BEGIN (C, Object *, ob_iter, selected_editable_objects)
 357         {
 358                 if (ob != ob_iter && give_matarar(ob_iter)) {
 359                         if (ob->data != ob_iter->data)
 360                                 assign_matarar(bmain, ob_iter, matar, ob->totcol);
 361
 362                         if (ob_iter->totcol == ob->totcol) {
 363                                 ob_iter->actcol = ob->actcol;
 364                                 DAG_id_tag_update(&ob_iter->id, OB_RECALC_DATA);
 365                                 WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob_iter);
 366                         }
 367                 }
 368         }
 369         CTX_DATA_END;
 370
 371         return OPERATOR_FINISHED;
 372 }
 373
 374
 375 void OBJECT_OT_material_slot_copy(wmOperatorType *ot)
 376 {
 377         /* identifiers */
 378         ot->name = "Copy Material to Others";
 379         ot->idname = "OBJECT_OT_material_slot_copy";
 380         ot->description = "Copies materials to other selected objects";
 381
 382         /* api callbacks */
 383         ot->exec = material_slot_copy_exec;
 384
 385         /* flags */
 386         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 387 }
 388
 389 static int material_slot_move_exec(bContext *C, wmOperator *op)
 390 {
 391         Object *ob = ED_object_context(C);
 392
 393         unsigned int *slot_remap;
 394         int index_pair[2];
 395
 396         int dir = RNA_enum_get(op->ptr, "direction");
 397
 398         if (!ob || ob->totcol < 2) {
 399                 return OPERATOR_CANCELLED;
 400         }
 401
 402         /* up */
 403         if (dir == 1 && ob->actcol > 1) {
 404                 index_pair[0] = ob->actcol - 2;
 405                 index_pair[1] = ob->actcol - 1;
 406                 ob->actcol--;
 407         }
 408         /* down */
 409         else if (dir == -1 && ob->actcol < ob->totcol) {
 410                 index_pair[0] = ob->actcol - 1;
 411                 index_pair[1] = ob->actcol - 0;
 412                 ob->actcol++;
 413         }
 414         else {
 415                 return OPERATOR_CANCELLED;
 416         }
 417
 418         slot_remap = MEM_mallocN(sizeof(unsigned int) * ob->totcol, __func__);
 419
 420         range_vn_u(slot_remap, ob->totcol, 0);
 421
 422         slot_remap[index_pair[0]] = index_pair[1];
 423         slot_remap[index_pair[1]] = index_pair[0];
 424
 425         BKE_material_remap_object(ob, slot_remap);
 426
 427         MEM_freeN(slot_remap);
 428
 429         DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
 430         WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
 431         WM_event_add_notifier(C, NC_OBJECT | ND_DATA, ob);
 432
 433         return OPERATOR_FINISHED;
 434 }
 435
 436 void OBJECT_OT_material_slot_move(wmOperatorType *ot)
 437 {
 438         static const EnumPropertyItem material_slot_move[] = {
 439                 {1, "UP", 0, "Up", ""},
 440                 {-1, "DOWN", 0, "Down", ""},
 441                 {0, NULL, 0, NULL, NULL}
 442         };
 443
 444         /* identifiers */
 445         ot->name = "Move Material";
 446         ot->idname = "OBJECT_OT_material_slot_move";
 447         ot->description = "Move the active material up/down in the list";
 448
 449         /* api callbacks */
 450         ot->exec = material_slot_move_exec;
 451
 452         /* flags */
 453         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 454
 455         RNA_def_enum(ot->srna, "direction", material_slot_move, 0, "Direction",
 456                      "Direction to move the active material towards");
 457 }
 458
 459 /********************** new material operator *********************/
 460
 461 static int new_material_exec(bContext *C, wmOperator *UNUSED(op))
 462 {
 463         Scene *scene = CTX_data_scene(C);
 464         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
 465         Main *bmain = CTX_data_main(C);
 466         PointerRNA ptr, idptr;
 467         PropertyRNA *prop;
 468
 469         /* add or copy material */
 470         if (ma) {
 471                 ma = BKE_material_copy(bmain, ma);
 472         }
 473         else {
 474                 ma = BKE_material_add(bmain, DATA_("Material"));
 475
 476                 if (BKE_scene_use_new_shading_nodes(scene)) {
 477                         ED_node_shader_default(C, &ma->id);
 478                         ma->use_nodes = true;
 479                 }
 480         }
 481
 482         /* hook into UI */
 483         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
 484
 485         if (prop) {
 486                 if (RNA_struct_is_a(ptr.type, &RNA_Object)) {
 487                         /* Add slot follows user-preferences for creating new slots,
 488                          * RNA pointer assignment doesn't, see: T60014. */
 489                         Object *ob = ptr.data;
 490                         if (give_current_material_p(ob, ob->actcol) == NULL) {
 491                                 BKE_object_material_slot_add(bmain, ob);
 492                         }
 493                 }
 494
 495                 /* when creating new ID blocks, use is already 1, but RNA
 496                  * pointer use also increases user, so this compensates it */
 497                 id_us_min(&ma->id);
 498
 499                 RNA_id_pointer_create(&ma->id, &idptr);
 500                 RNA_property_pointer_set(&ptr, prop, idptr);
 501                 RNA_property_update(C, &ptr, prop);
 502         }
 503
 504         WM_event_add_notifier(C, NC_MATERIAL | NA_ADDED, ma);
 505
 506         return OPERATOR_FINISHED;
 507 }
 508
 509 void MATERIAL_OT_new(wmOperatorType *ot)
 510 {
 511         /* identifiers */
 512         ot->name = "New Material";
 513         ot->idname = "MATERIAL_OT_new";
 514         ot->description = "Add a new material";
 515
 516         /* api callbacks */
 517         ot->exec = new_material_exec;
 518
 519         /* flags */
 520         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 521 }
 522
 523 /********************** new texture operator *********************/
 524
 525 static int new_texture_exec(bContext *C, wmOperator *UNUSED(op))
 526 {
 527         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
 528         Main *bmain = CTX_data_main(C);
 529         PointerRNA ptr, idptr;
 530         PropertyRNA *prop;
 531
 532         /* add or copy texture */
 533         if (tex) {
 534                 tex = BKE_texture_copy(bmain, tex);
 535         }
 536         else {
 537                 tex = BKE_texture_add(bmain, DATA_("Texture"));
 538         }
 539
 540         /* hook into UI */
 541         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
 542
 543         if (prop) {
 544                 /* when creating new ID blocks, use is already 1, but RNA
 545                  * pointer use also increases user, so this compensates it */
 546                 id_us_min(&tex->id);
 547
 548                 if (ptr.id.data && GS(((ID *)ptr.id.data)->name) == ID_MA &&
 549                     RNA_property_pointer_get(&ptr, prop).id.data == NULL)
 550                 {
 551                         /* In case we are assigning new texture to a material, and active slot was empty, reset 'use' flag. */
 552                         Material *ma = (Material *)ptr.id.data;
 553                         ma->septex &= ~(1 << ma->texact);
 554                 }
 555
 556                 RNA_id_pointer_create(&tex->id, &idptr);
 557                 RNA_property_pointer_set(&ptr, prop, idptr);
 558                 RNA_property_update(C, &ptr, prop);
 559         }
 560
 561         WM_event_add_notifier(C, NC_TEXTURE | NA_ADDED, tex);
 562
 563         return OPERATOR_FINISHED;
 564 }
 565
 566 void TEXTURE_OT_new(wmOperatorType *ot)
 567 {
 568         /* identifiers */
 569         ot->name = "New Texture";
 570         ot->idname = "TEXTURE_OT_new";
 571         ot->description = "Add a new texture";
 572
 573         /* api callbacks */
 574         ot->exec = new_texture_exec;
 575
 576         /* flags */
 577         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 578 }
 579
 580 /********************** new world operator *********************/
 581
 582 static int new_world_exec(bContext *C, wmOperator *UNUSED(op))
 583 {
 584         Scene *scene = CTX_data_scene(C);
 585         World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
 586         Main *bmain = CTX_data_main(C);
 587         PointerRNA ptr, idptr;
 588         PropertyRNA *prop;
 589
 590         /* add or copy world */
 591         if (wo) {
 592                 wo = BKE_world_copy(bmain, wo);
 593         }
 594         else {
 595                 wo = BKE_world_add(bmain, DATA_("World"));
 596
 597                 if (BKE_scene_use_new_shading_nodes(scene)) {
 598                         ED_node_shader_default(C, &wo->id);
 599                         wo->use_nodes = true;
 600                 }
 601         }
 602
 603         /* hook into UI */
 604         UI_context_active_but_prop_get_templateID(C, &ptr, &prop);
 605
 606         if (prop) {
 607                 /* when creating new ID blocks, use is already 1, but RNA
 608                  * pointer use also increases user, so this compensates it */
 609                 id_us_min(&wo->id);
 610
 611                 RNA_id_pointer_create(&wo->id, &idptr);
 612                 RNA_property_pointer_set(&ptr, prop, idptr);
 613                 RNA_property_update(C, &ptr, prop);
 614         }
 615
 616         WM_event_add_notifier(C, NC_WORLD | NA_ADDED, wo);
 617
 618         return OPERATOR_FINISHED;
 619 }
 620
 621 void WORLD_OT_new(wmOperatorType *ot)
 622 {
 623         /* identifiers */
 624         ot->name = "New World";
 625         ot->idname = "WORLD_OT_new";
 626         ot->description = "Create a new world Data-Block";
 627
 628         /* api callbacks */
 629         ot->exec = new_world_exec;
 630
 631         /* flags */
 632         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 633 }
 634
 635 /********************** render layer operators *********************/
 636
 637 static int render_layer_add_exec(bContext *C, wmOperator *UNUSED(op))
 638 {
 639         Scene *scene = CTX_data_scene(C);
 640
 641         BKE_scene_add_render_layer(scene, NULL);
 642         scene->r.actlay = BLI_listbase_count(&scene->r.layers) - 1;
 643
 644         DAG_id_tag_update(&scene->id, 0);
 645         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 646
 647         return OPERATOR_FINISHED;
 648 }
 649
 650 void SCENE_OT_render_layer_add(wmOperatorType *ot)
 651 {
 652         /* identifiers */
 653         ot->name = "Add Render Layer";
 654         ot->idname = "SCENE_OT_render_layer_add";
 655         ot->description = "Add a render layer";
 656
 657         /* api callbacks */
 658         ot->exec = render_layer_add_exec;
 659
 660         /* flags */
 661         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 662 }
 663
 664 static int render_layer_remove_exec(bContext *C, wmOperator *UNUSED(op))
 665 {
 666         Scene *scene = CTX_data_scene(C);
 667         SceneRenderLayer *rl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 668
 669         if (!BKE_scene_remove_render_layer(CTX_data_main(C), scene, rl))
 670                 return OPERATOR_CANCELLED;
 671
 672         DAG_id_tag_update(&scene->id, 0);
 673         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 674
 675         return OPERATOR_FINISHED;
 676 }
 677
 678 void SCENE_OT_render_layer_remove(wmOperatorType *ot)
 679 {
 680         /* identifiers */
 681         ot->name = "Remove Render Layer";
 682         ot->idname = "SCENE_OT_render_layer_remove";
 683         ot->description = "Remove the selected render layer";
 684
 685         /* api callbacks */
 686         ot->exec = render_layer_remove_exec;
 687
 688         /* flags */
 689         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 690 }
 691
 692 /********************** render view operators *********************/
 693
 694 static bool render_view_remove_poll(bContext *C)
 695 {
 696         Scene *scene = CTX_data_scene(C);
 697
 698         /* don't allow user to remove "left" and "right" views */
 699         return scene->r.actview > 1;
 700 }
 701
 702 static int render_view_add_exec(bContext *C, wmOperator *UNUSED(op))
 703 {
 704         Scene *scene = CTX_data_scene(C);
 705
 706         BKE_scene_add_render_view(scene, NULL);
 707         scene->r.actview = BLI_listbase_count(&scene->r.views) - 1;
 708
 709         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 710
 711         return OPERATOR_FINISHED;
 712 }
 713
 714 void SCENE_OT_render_view_add(wmOperatorType *ot)
 715 {
 716         /* identifiers */
 717         ot->name = "Add Render View";
 718         ot->idname = "SCENE_OT_render_view_add";
 719         ot->description = "Add a render view";
 720
 721         /* api callbacks */
 722         ot->exec = render_view_add_exec;
 723
 724         /* flags */
 725         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 726 }
 727
 728 static int render_view_remove_exec(bContext *C, wmOperator *UNUSED(op))
 729 {
 730         Scene *scene = CTX_data_scene(C);
 731         SceneRenderView *rv = BLI_findlink(&scene->r.views, scene->r.actview);
 732
 733         if (!BKE_scene_remove_render_view(scene, rv))
 734                 return OPERATOR_CANCELLED;
 735
 736         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 737
 738         return OPERATOR_FINISHED;
 739 }
 740
 741 void SCENE_OT_render_view_remove(wmOperatorType *ot)
 742 {
 743         /* identifiers */
 744         ot->name = "Remove Render View";
 745         ot->idname = "SCENE_OT_render_view_remove";
 746         ot->description = "Remove the selected render view";
 747
 748         /* api callbacks */
 749         ot->exec = render_view_remove_exec;
 750         ot->poll = render_view_remove_poll;
 751
 752         /* flags */
 753         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 754 }
 755
 756 #ifdef WITH_FREESTYLE
 757
 758 static bool freestyle_linestyle_check_report(FreestyleLineSet *lineset, ReportList *reports)
 759 {
 760         if (!lineset) {
 761                 BKE_report(reports, RPT_ERROR, "No active lineset and associated line style to manipulate the modifier");
 762                 return false;
 763         }
 764         if (!lineset->linestyle) {
 765                 BKE_report(reports, RPT_ERROR, "The active lineset does not have a line style (indicating data corruption)");
 766                 return false;
 767         }
 768
 769         return true;
 770 }
 771
 772 static bool freestyle_active_module_poll(bContext *C)
 773 {
 774         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
 775         FreestyleModuleConfig *module = ptr.data;
 776
 777         return module != NULL;
 778 }
 779
 780 static int freestyle_module_add_exec(bContext *C, wmOperator *UNUSED(op))
 781 {
 782         Scene *scene = CTX_data_scene(C);
 783         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 784
 785         BKE_freestyle_module_add(&srl->freestyleConfig);
 786
 787         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 788
 789         return OPERATOR_FINISHED;
 790 }
 791
 792 void SCENE_OT_freestyle_module_add(wmOperatorType *ot)
 793 {
 794         /* identifiers */
 795         ot->name = "Add Freestyle Module";
 796         ot->idname = "SCENE_OT_freestyle_module_add";
 797         ot->description = "Add a style module into the list of modules";
 798
 799         /* api callbacks */
 800         ot->exec = freestyle_module_add_exec;
 801
 802         /* flags */
 803         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 804 }
 805
 806 static int freestyle_module_remove_exec(bContext *C, wmOperator *UNUSED(op))
 807 {
 808         Scene *scene = CTX_data_scene(C);
 809         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 810         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
 811         FreestyleModuleConfig *module = ptr.data;
 812
 813         BKE_freestyle_module_delete(&srl->freestyleConfig, module);
 814
 815         DAG_id_tag_update(&scene->id, 0);
 816         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 817
 818         return OPERATOR_FINISHED;
 819 }
 820
 821 void SCENE_OT_freestyle_module_remove(wmOperatorType *ot)
 822 {
 823         /* identifiers */
 824         ot->name = "Remove Freestyle Module";
 825         ot->idname = "SCENE_OT_freestyle_module_remove";
 826         ot->description = "Remove the style module from the stack";
 827
 828         /* api callbacks */
 829         ot->poll = freestyle_active_module_poll;
 830         ot->exec = freestyle_module_remove_exec;
 831
 832         /* flags */
 833         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 834 }
 835
 836 static int freestyle_module_move_exec(bContext *C, wmOperator *op)
 837 {
 838         Scene *scene = CTX_data_scene(C);
 839         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 840         PointerRNA ptr = CTX_data_pointer_get_type(C, "freestyle_module", &RNA_FreestyleModuleSettings);
 841         FreestyleModuleConfig *module = ptr.data;
 842         int dir = RNA_enum_get(op->ptr, "direction");
 843
 844         if (BKE_freestyle_module_move(&srl->freestyleConfig, module, dir)) {
 845                 DAG_id_tag_update(&scene->id, 0);
 846                 WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 847         }
 848
 849         return OPERATOR_FINISHED;
 850 }
 851
 852 void SCENE_OT_freestyle_module_move(wmOperatorType *ot)
 853 {
 854         static const EnumPropertyItem direction_items[] = {
 855                 {-1, "UP", 0, "Up", ""},
 856                 {1, "DOWN", 0, "Down", ""},
 857                 {0, NULL, 0, NULL, NULL}
 858         };
 859
 860         /* identifiers */
 861         ot->name = "Move Freestyle Module";
 862         ot->idname = "SCENE_OT_freestyle_module_move";
 863         ot->description = "Change the position of the style module within in the list of style modules";
 864
 865         /* api callbacks */
 866         ot->poll = freestyle_active_module_poll;
 867         ot->exec = freestyle_module_move_exec;
 868
 869         /* flags */
 870         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 871
 872         /* props */
 873         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
 874                      "Direction to move the chosen style module towards");
 875 }
 876
 877 static int freestyle_lineset_add_exec(bContext *C, wmOperator *UNUSED(op))
 878 {
 879         Main *bmain = CTX_data_main(C);
 880         Scene *scene = CTX_data_scene(C);
 881         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 882
 883         BKE_freestyle_lineset_add(bmain, &srl->freestyleConfig, NULL);
 884
 885         DAG_id_tag_update(&scene->id, 0);
 886         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 887
 888         return OPERATOR_FINISHED;
 889 }
 890
 891 void SCENE_OT_freestyle_lineset_add(wmOperatorType *ot)
 892 {
 893         /* identifiers */
 894         ot->name = "Add Line Set";
 895         ot->idname = "SCENE_OT_freestyle_lineset_add";
 896         ot->description = "Add a line set into the list of line sets";
 897
 898         /* api callbacks */
 899         ot->exec = freestyle_lineset_add_exec;
 900
 901         /* flags */
 902         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 903 }
 904
 905 static bool freestyle_active_lineset_poll(bContext *C)
 906 {
 907         Scene *scene = CTX_data_scene(C);
 908         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 909
 910         if (!srl) {
 911                 return false;
 912         }
 913
 914         return BKE_freestyle_lineset_get_active(&srl->freestyleConfig) != NULL;
 915 }
 916
 917 static int freestyle_lineset_copy_exec(bContext *C, wmOperator *UNUSED(op))
 918 {
 919         Scene *scene = CTX_data_scene(C);
 920         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 921
 922         FRS_copy_active_lineset(&srl->freestyleConfig);
 923
 924         return OPERATOR_FINISHED;
 925 }
 926
 927 void SCENE_OT_freestyle_lineset_copy(wmOperatorType *ot)
 928 {
 929         /* identifiers */
 930         ot->name = "Copy Line Set";
 931         ot->idname = "SCENE_OT_freestyle_lineset_copy";
 932         ot->description = "Copy the active line set to a buffer";
 933
 934         /* api callbacks */
 935         ot->exec = freestyle_lineset_copy_exec;
 936         ot->poll = freestyle_active_lineset_poll;
 937
 938         /* flags */
 939         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 940 }
 941
 942 static int freestyle_lineset_paste_exec(bContext *C, wmOperator *UNUSED(op))
 943 {
 944         Scene *scene = CTX_data_scene(C);
 945         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 946
 947         FRS_paste_active_lineset(&srl->freestyleConfig);
 948
 949         DAG_id_tag_update(&scene->id, 0);
 950         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 951
 952         return OPERATOR_FINISHED;
 953 }
 954
 955 void SCENE_OT_freestyle_lineset_paste(wmOperatorType *ot)
 956 {
 957         /* identifiers */
 958         ot->name = "Paste Line Set";
 959         ot->idname = "SCENE_OT_freestyle_lineset_paste";
 960         ot->description = "Paste the buffer content to the active line set";
 961
 962         /* api callbacks */
 963         ot->exec = freestyle_lineset_paste_exec;
 964         ot->poll = freestyle_active_lineset_poll;
 965
 966         /* flags */
 967         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 968 }
 969
 970 static int freestyle_lineset_remove_exec(bContext *C, wmOperator *UNUSED(op))
 971 {
 972         Scene *scene = CTX_data_scene(C);
 973         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
 974
 975         FRS_delete_active_lineset(&srl->freestyleConfig);
 976
 977         DAG_id_tag_update(&scene->id, 0);
 978         WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
 979
 980         return OPERATOR_FINISHED;
 981 }
 982
 983 void SCENE_OT_freestyle_lineset_remove(wmOperatorType *ot)
 984 {
 985         /* identifiers */
 986         ot->name = "Remove Line Set";
 987         ot->idname = "SCENE_OT_freestyle_lineset_remove";
 988         ot->description = "Remove the active line set from the list of line sets";
 989
 990         /* api callbacks */
 991         ot->exec = freestyle_lineset_remove_exec;
 992         ot->poll = freestyle_active_lineset_poll;
 993
 994         /* flags */
 995         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
 996 }
 997
 998 static int freestyle_lineset_move_exec(bContext *C, wmOperator *op)
 999 {
1000         Scene *scene = CTX_data_scene(C);
1001         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1002         int dir = RNA_enum_get(op->ptr, "direction");
1003
1004         if (FRS_move_active_lineset(&srl->freestyleConfig, dir)) {
1005                 DAG_id_tag_update(&scene->id, 0);
1006                 WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, scene);
1007         }
1008
1009         return OPERATOR_FINISHED;
1010 }
1011
1012 void SCENE_OT_freestyle_lineset_move(wmOperatorType *ot)
1013 {
1014         static const EnumPropertyItem direction_items[] = {
1015                 {-1, "UP", 0, "Up", ""},
1016                 {1, "DOWN", 0, "Down", ""},
1017                 {0, NULL, 0, NULL, NULL}
1018         };
1019
1020         /* identifiers */
1021         ot->name = "Move Line Set";
1022         ot->idname = "SCENE_OT_freestyle_lineset_move";
1023         ot->description = "Change the position of the active line set within the list of line sets";
1024
1025         /* api callbacks */
1026         ot->exec = freestyle_lineset_move_exec;
1027         ot->poll = freestyle_active_lineset_poll;
1028
1029         /* flags */
1030         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1031
1032         /* props */
1033         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
1034                      "Direction to move the active line set towards");
1035 }
1036
1037 static int freestyle_linestyle_new_exec(bContext *C, wmOperator *op)
1038 {
1039         Main *bmain = CTX_data_main(C);
1040         Scene *scene = CTX_data_scene(C);
1041         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1042         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1043
1044         if (!lineset) {
1045                 BKE_report(op->reports, RPT_ERROR, "No active lineset to add a new line style to");
1046                 return OPERATOR_CANCELLED;
1047         }
1048         if (lineset->linestyle) {
1049                 id_us_min(&lineset->linestyle->id);
1050                 lineset->linestyle = BKE_linestyle_copy(bmain, lineset->linestyle);
1051         }
1052         else {
1053                 lineset->linestyle = BKE_linestyle_new(bmain, "LineStyle");
1054         }
1055         DAG_id_tag_update(&lineset->linestyle->id, 0);
1056         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1057
1058         return OPERATOR_FINISHED;
1059 }
1060
1061 void SCENE_OT_freestyle_linestyle_new(wmOperatorType *ot)
1062 {
1063         /* identifiers */
1064         ot->name = "New Line Style";
1065         ot->idname = "SCENE_OT_freestyle_linestyle_new";
1066         ot->description = "Create a new line style, reusable by multiple line sets";
1067
1068         /* api callbacks */
1069         ot->exec = freestyle_linestyle_new_exec;
1070         ot->poll = freestyle_active_lineset_poll;
1071
1072         /* flags */
1073         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1074 }
1075
1076 static int freestyle_color_modifier_add_exec(bContext *C, wmOperator *op)
1077 {
1078         Scene *scene = CTX_data_scene(C);
1079         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1080         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1081         int type = RNA_enum_get(op->ptr, "type");
1082
1083         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1084                 return OPERATOR_CANCELLED;
1085         }
1086
1087         if (BKE_linestyle_color_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1088                 BKE_report(op->reports, RPT_ERROR, "Unknown line color modifier type");
1089                 return OPERATOR_CANCELLED;
1090         }
1091         DAG_id_tag_update(&lineset->linestyle->id, 0);
1092         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1093
1094         return OPERATOR_FINISHED;
1095 }
1096
1097 void SCENE_OT_freestyle_color_modifier_add(wmOperatorType *ot)
1098 {
1099         /* identifiers */
1100         ot->name = "Add Line Color Modifier";
1101         ot->idname = "SCENE_OT_freestyle_color_modifier_add";
1102         ot->description = "Add a line color modifier to the line style associated with the active lineset";
1103
1104         /* api callbacks */
1105         ot->invoke = WM_menu_invoke;
1106         ot->exec = freestyle_color_modifier_add_exec;
1107         ot->poll = freestyle_active_lineset_poll;
1108
1109         /* flags */
1110         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1111
1112         /* properties */
1113         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_color_modifier_type_items, 0, "Type", "");
1114 }
1115
1116 static int freestyle_alpha_modifier_add_exec(bContext *C, wmOperator *op)
1117 {
1118         Scene *scene = CTX_data_scene(C);
1119         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1120         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1121         int type = RNA_enum_get(op->ptr, "type");
1122
1123         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1124                 return OPERATOR_CANCELLED;
1125         }
1126
1127         if (BKE_linestyle_alpha_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1128                 BKE_report(op->reports, RPT_ERROR, "Unknown alpha transparency modifier type");
1129                 return OPERATOR_CANCELLED;
1130         }
1131         DAG_id_tag_update(&lineset->linestyle->id, 0);
1132         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1133
1134         return OPERATOR_FINISHED;
1135 }
1136
1137 void SCENE_OT_freestyle_alpha_modifier_add(wmOperatorType *ot)
1138 {
1139         /* identifiers */
1140         ot->name = "Add Alpha Transparency Modifier";
1141         ot->idname = "SCENE_OT_freestyle_alpha_modifier_add";
1142         ot->description = "Add an alpha transparency modifier to the line style associated with the active lineset";
1143
1144         /* api callbacks */
1145         ot->invoke = WM_menu_invoke;
1146         ot->exec = freestyle_alpha_modifier_add_exec;
1147         ot->poll = freestyle_active_lineset_poll;
1148
1149         /* flags */
1150         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1151
1152         /* properties */
1153         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_alpha_modifier_type_items, 0, "Type", "");
1154 }
1155
1156 static int freestyle_thickness_modifier_add_exec(bContext *C, wmOperator *op)
1157 {
1158         Scene *scene = CTX_data_scene(C);
1159         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1160         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1161         int type = RNA_enum_get(op->ptr, "type");
1162
1163         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1164                 return OPERATOR_CANCELLED;
1165         }
1166
1167         if (BKE_linestyle_thickness_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1168                 BKE_report(op->reports, RPT_ERROR, "Unknown line thickness modifier type");
1169                 return OPERATOR_CANCELLED;
1170         }
1171         DAG_id_tag_update(&lineset->linestyle->id, 0);
1172         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1173
1174         return OPERATOR_FINISHED;
1175 }
1176
1177 void SCENE_OT_freestyle_thickness_modifier_add(wmOperatorType *ot)
1178 {
1179         /* identifiers */
1180         ot->name = "Add Line Thickness Modifier";
1181         ot->idname = "SCENE_OT_freestyle_thickness_modifier_add";
1182         ot->description = "Add a line thickness modifier to the line style associated with the active lineset";
1183
1184         /* api callbacks */
1185         ot->invoke = WM_menu_invoke;
1186         ot->exec = freestyle_thickness_modifier_add_exec;
1187         ot->poll = freestyle_active_lineset_poll;
1188
1189         /* flags */
1190         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1191
1192         /* properties */
1193         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_thickness_modifier_type_items, 0, "Type", "");
1194 }
1195
1196 static int freestyle_geometry_modifier_add_exec(bContext *C, wmOperator *op)
1197 {
1198         Scene *scene = CTX_data_scene(C);
1199         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1200         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1201         int type = RNA_enum_get(op->ptr, "type");
1202
1203         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1204                 return OPERATOR_CANCELLED;
1205         }
1206
1207         if (BKE_linestyle_geometry_modifier_add(lineset->linestyle, NULL, type) == NULL) {
1208                 BKE_report(op->reports, RPT_ERROR, "Unknown stroke geometry modifier type");
1209                 return OPERATOR_CANCELLED;
1210         }
1211         DAG_id_tag_update(&lineset->linestyle->id, 0);
1212         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1213
1214         return OPERATOR_FINISHED;
1215 }
1216
1217 void SCENE_OT_freestyle_geometry_modifier_add(wmOperatorType *ot)
1218 {
1219         /* identifiers */
1220         ot->name = "Add Stroke Geometry Modifier";
1221         ot->idname = "SCENE_OT_freestyle_geometry_modifier_add";
1222         ot->description = "Add a stroke geometry modifier to the line style associated with the active lineset";
1223
1224         /* api callbacks */
1225         ot->invoke = WM_menu_invoke;
1226         ot->exec = freestyle_geometry_modifier_add_exec;
1227         ot->poll = freestyle_active_lineset_poll;
1228
1229         /* flags */
1230         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1231
1232         /* properties */
1233         ot->prop = RNA_def_enum(ot->srna, "type", rna_enum_linestyle_geometry_modifier_type_items, 0, "Type", "");
1234 }
1235
1236 static int freestyle_get_modifier_type(PointerRNA *ptr)
1237 {
1238         if (RNA_struct_is_a(ptr->type, &RNA_LineStyleColorModifier))
1239                 return LS_MODIFIER_TYPE_COLOR;
1240         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleAlphaModifier))
1241                 return LS_MODIFIER_TYPE_ALPHA;
1242         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleThicknessModifier))
1243                 return LS_MODIFIER_TYPE_THICKNESS;
1244         else if (RNA_struct_is_a(ptr->type, &RNA_LineStyleGeometryModifier))
1245                 return LS_MODIFIER_TYPE_GEOMETRY;
1246         return -1;
1247 }
1248
1249 static int freestyle_modifier_remove_exec(bContext *C, wmOperator *op)
1250 {
1251         Scene *scene = CTX_data_scene(C);
1252         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1253         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1254         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1255         LineStyleModifier *modifier = ptr.data;
1256
1257         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1258                 return OPERATOR_CANCELLED;
1259         }
1260
1261         switch (freestyle_get_modifier_type(&ptr)) {
1262                 case LS_MODIFIER_TYPE_COLOR:
1263                         BKE_linestyle_color_modifier_remove(lineset->linestyle, modifier);
1264                         break;
1265                 case LS_MODIFIER_TYPE_ALPHA:
1266                         BKE_linestyle_alpha_modifier_remove(lineset->linestyle, modifier);
1267                         break;
1268                 case LS_MODIFIER_TYPE_THICKNESS:
1269                         BKE_linestyle_thickness_modifier_remove(lineset->linestyle, modifier);
1270                         break;
1271                 case LS_MODIFIER_TYPE_GEOMETRY:
1272                         BKE_linestyle_geometry_modifier_remove(lineset->linestyle, modifier);
1273                         break;
1274                 default:
1275                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1276                         return OPERATOR_CANCELLED;
1277         }
1278         DAG_id_tag_update(&lineset->linestyle->id, 0);
1279         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1280
1281         return OPERATOR_FINISHED;
1282 }
1283
1284 void SCENE_OT_freestyle_modifier_remove(wmOperatorType *ot)
1285 {
1286         /* identifiers */
1287         ot->name = "Remove Modifier";
1288         ot->idname = "SCENE_OT_freestyle_modifier_remove";
1289         ot->description = "Remove the modifier from the list of modifiers";
1290
1291         /* api callbacks */
1292         ot->exec = freestyle_modifier_remove_exec;
1293         ot->poll = freestyle_active_lineset_poll;
1294
1295         /* flags */
1296         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1297 }
1298
1299 static int freestyle_modifier_copy_exec(bContext *C, wmOperator *op)
1300 {
1301         Scene *scene = CTX_data_scene(C);
1302         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1303         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1304         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1305         LineStyleModifier *modifier = ptr.data;
1306
1307         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1308                 return OPERATOR_CANCELLED;
1309         }
1310
1311         switch (freestyle_get_modifier_type(&ptr)) {
1312                 case LS_MODIFIER_TYPE_COLOR:
1313                         BKE_linestyle_color_modifier_copy(lineset->linestyle, modifier, 0);
1314                         break;
1315                 case LS_MODIFIER_TYPE_ALPHA:
1316                         BKE_linestyle_alpha_modifier_copy(lineset->linestyle, modifier, 0);
1317                         break;
1318                 case LS_MODIFIER_TYPE_THICKNESS:
1319                         BKE_linestyle_thickness_modifier_copy(lineset->linestyle, modifier, 0);
1320                         break;
1321                 case LS_MODIFIER_TYPE_GEOMETRY:
1322                         BKE_linestyle_geometry_modifier_copy(lineset->linestyle, modifier, 0);
1323                         break;
1324                 default:
1325                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1326                         return OPERATOR_CANCELLED;
1327         }
1328         DAG_id_tag_update(&lineset->linestyle->id, 0);
1329         WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1330
1331         return OPERATOR_FINISHED;
1332 }
1333
1334 void SCENE_OT_freestyle_modifier_copy(wmOperatorType *ot)
1335 {
1336         /* identifiers */
1337         ot->name = "Copy Modifier";
1338         ot->idname = "SCENE_OT_freestyle_modifier_copy";
1339         ot->description = "Duplicate the modifier within the list of modifiers";
1340
1341         /* api callbacks */
1342         ot->exec = freestyle_modifier_copy_exec;
1343         ot->poll = freestyle_active_lineset_poll;
1344
1345         /* flags */
1346         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1347 }
1348
1349 static int freestyle_modifier_move_exec(bContext *C, wmOperator *op)
1350 {
1351         Scene *scene = CTX_data_scene(C);
1352         SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);
1353         FreestyleLineSet *lineset = BKE_freestyle_lineset_get_active(&srl->freestyleConfig);
1354         PointerRNA ptr = CTX_data_pointer_get_type(C, "modifier", &RNA_LineStyleModifier);
1355         LineStyleModifier *modifier = ptr.data;
1356         int dir = RNA_enum_get(op->ptr, "direction");
1357         bool changed = false;
1358
1359         if (!freestyle_linestyle_check_report(lineset, op->reports)) {
1360                 return OPERATOR_CANCELLED;
1361         }
1362
1363         switch (freestyle_get_modifier_type(&ptr)) {
1364                 case LS_MODIFIER_TYPE_COLOR:
1365                         changed = BKE_linestyle_color_modifier_move(lineset->linestyle, modifier, dir);
1366                         break;
1367                 case LS_MODIFIER_TYPE_ALPHA:
1368                         changed = BKE_linestyle_alpha_modifier_move(lineset->linestyle, modifier, dir);
1369                         break;
1370                 case LS_MODIFIER_TYPE_THICKNESS:
1371                         changed = BKE_linestyle_thickness_modifier_move(lineset->linestyle, modifier, dir);
1372                         break;
1373                 case LS_MODIFIER_TYPE_GEOMETRY:
1374                         changed = BKE_linestyle_geometry_modifier_move(lineset->linestyle, modifier, dir);
1375                         break;
1376                 default:
1377                         BKE_report(op->reports, RPT_ERROR, "The object the data pointer refers to is not a valid modifier");
1378                         return OPERATOR_CANCELLED;
1379         }
1380
1381         if (changed) {
1382                 DAG_id_tag_update(&lineset->linestyle->id, 0);
1383                 WM_event_add_notifier(C, NC_LINESTYLE, lineset->linestyle);
1384         }
1385
1386         return OPERATOR_FINISHED;
1387 }
1388
1389 void SCENE_OT_freestyle_modifier_move(wmOperatorType *ot)
1390 {
1391         static const EnumPropertyItem direction_items[] = {
1392                 {-1, "UP", 0, "Up", ""},
1393                 {1, "DOWN", 0, "Down", ""},
1394                 {0, NULL, 0, NULL, NULL}
1395         };
1396
1397         /* identifiers */
1398         ot->name = "Move Modifier";
1399         ot->idname = "SCENE_OT_freestyle_modifier_move";
1400         ot->description = "Move the modifier within the list of modifiers";
1401
1402         /* api callbacks */
1403         ot->exec = freestyle_modifier_move_exec;
1404         ot->poll = freestyle_active_lineset_poll;
1405
1406         /* flags */
1407         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1408
1409         /* props */
1410         RNA_def_enum(ot->srna, "direction", direction_items, 0, "Direction",
1411                      "Direction to move the chosen modifier towards");
1412 }
1413
1414 static int freestyle_stroke_material_create_exec(bContext *C, wmOperator *op)
1415 {
1416         Main *bmain = CTX_data_main(C);
1417         Scene *scene = CTX_data_scene(C);
1418         FreestyleLineStyle *linestyle = BKE_linestyle_active_from_scene(scene);
1419
1420         if (!linestyle) {
1421                 BKE_report(op->reports, RPT_ERROR, "No active line style in the current scene");
1422                 return OPERATOR_CANCELLED;
1423         }
1424
1425         FRS_create_stroke_material(bmain, linestyle);
1426
1427         return OPERATOR_FINISHED;
1428 }
1429
1430 void SCENE_OT_freestyle_stroke_material_create(wmOperatorType *ot)
1431 {
1432         /* identifiers */
1433         ot->name = "Create Freestyle Stroke Material";
1434         ot->idname = "SCENE_OT_freestyle_stroke_material_create";
1435         ot->description = "Create Freestyle stroke material for testing";
1436
1437         /* api callbacks */
1438         ot->exec = freestyle_stroke_material_create_exec;
1439
1440         /* flags */
1441         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1442 }
1443
1444 #endif /* WITH_FREESTYLE */
1445
1446 static int texture_slot_move_exec(bContext *C, wmOperator *op)
1447 {
1448         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1449
1450         if (id) {
1451                 MTex **mtex_ar, *mtexswap;
1452                 short act;
1453                 int type = RNA_enum_get(op->ptr, "type");
1454                 struct AnimData *adt = BKE_animdata_from_id(id);
1455
1456                 give_active_mtex(id, &mtex_ar, &act);
1457
1458                 if (type == -1) { /* Up */
1459                         if (act > 0) {
1460                                 mtexswap = mtex_ar[act];
1461                                 mtex_ar[act] = mtex_ar[act - 1];
1462                                 mtex_ar[act - 1] = mtexswap;
1463
1464                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act - 1, -1, 0);
1465                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act - 1, 0);
1466                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1467
1468                                 if (GS(id->name) == ID_MA) {
1469                                         Material *ma = (Material *)id;
1470                                         int mtexuse = ma->septex & (1 << act);
1471                                         ma->septex &= ~(1 << act);
1472                                         ma->septex |= (ma->septex & (1 << (act - 1))) << 1;
1473                                         ma->septex &= ~(1 << (act - 1));
1474                                         ma->septex |= mtexuse >> 1;
1475                                 }
1476
1477                                 set_active_mtex(id, act - 1);
1478                         }
1479                 }
1480                 else { /* Down */
1481                         if (act < MAX_MTEX - 1) {
1482                                 mtexswap = mtex_ar[act];
1483                                 mtex_ar[act] = mtex_ar[act + 1];
1484                                 mtex_ar[act + 1] = mtexswap;
1485
1486                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act + 1, -1, 0);
1487                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, act, act + 1, 0);
1488                                 BKE_animdata_fix_paths_rename(id, adt, NULL, "texture_slots", NULL, NULL, -1, act, 0);
1489
1490                                 if (GS(id->name) == ID_MA) {
1491                                         Material *ma = (Material *)id;
1492                                         int mtexuse = ma->septex & (1 << act);
1493                                         ma->septex &= ~(1 << act);
1494                                         ma->septex |= (ma->septex & (1 << (act + 1))) >> 1;
1495                                         ma->septex &= ~(1 << (act + 1));
1496                                         ma->septex |= mtexuse << 1;
1497                                 }
1498
1499                                 set_active_mtex(id, act + 1);
1500                         }
1501                 }
1502
1503                 DAG_id_tag_update(id, 0);
1504                 WM_event_add_notifier(C, NC_TEXTURE, CTX_data_scene(C));
1505         }
1506
1507         return OPERATOR_FINISHED;
1508 }
1509
1510 void TEXTURE_OT_slot_move(wmOperatorType *ot)
1511 {
1512         static const EnumPropertyItem slot_move[] = {
1513                 {-1, "UP", 0, "Up", ""},
1514                 {1, "DOWN", 0, "Down", ""},
1515                 {0, NULL, 0, NULL, NULL}
1516         };
1517
1518         /* identifiers */
1519         ot->name = "Move Texture Slot";
1520         ot->idname = "TEXTURE_OT_slot_move";
1521         ot->description = "Move texture slots up and down";
1522
1523         /* api callbacks */
1524         ot->exec = texture_slot_move_exec;
1525
1526         /* flags */
1527         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1528
1529         RNA_def_enum(ot->srna, "type", slot_move, 0, "Type", "");
1530 }
1531
1532
1533
1534 /********************** environment map operators *********************/
1535
1536 static int save_envmap(wmOperator *op, Scene *scene, EnvMap *env, char *path, const char imtype)
1537 {
1538         PropertyRNA *prop;
1539         float layout[12];
1540
1541         if ((prop = RNA_struct_find_property(op->ptr, "layout"))) {
1542                 RNA_property_float_get_array(op->ptr, prop, layout);
1543         }
1544         else {
1545                 memcpy(layout, default_envmap_layout, sizeof(layout));
1546         }
1547
1548         if (RE_WriteEnvmapResult(op->reports, scene, env, path, imtype, layout)) {
1549                 return OPERATOR_FINISHED;
1550         }
1551         else {
1552                 return OPERATOR_CANCELLED;
1553         }
1554
1555 }
1556
1557 static int envmap_save_exec(bContext *C, wmOperator *op)
1558 {
1559         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1560         Scene *scene = CTX_data_scene(C);
1561         //int imtype = RNA_enum_get(op->ptr, "file_type");
1562         char imtype = scene->r.im_format.imtype;
1563         char path[FILE_MAX];
1564
1565         RNA_string_get(op->ptr, "filepath", path);
1566
1567         if (scene->r.scemode & R_EXTENSION) {
1568                 BKE_image_path_ensure_ext_from_imformat(path, &scene->r.im_format);
1569         }
1570
1571         WM_cursor_wait(1);
1572
1573         save_envmap(op, scene, tex->env, path, imtype);
1574
1575         WM_cursor_wait(0);
1576
1577         WM_event_add_notifier(C, NC_TEXTURE, tex);
1578
1579         return OPERATOR_FINISHED;
1580 }
1581
1582 static int envmap_save_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
1583 {
1584         Main *bmain = CTX_data_main(C);
1585         //Scene *scene= CTX_data_scene(C);
1586
1587         if (RNA_struct_property_is_set(op->ptr, "filepath"))
1588                 return envmap_save_exec(C, op);
1589
1590         //RNA_enum_set(op->ptr, "file_type", scene->r.im_format.imtype);
1591         RNA_string_set(op->ptr, "filepath", BKE_main_blendfile_path(bmain));
1592         WM_event_add_fileselect(C, op);
1593
1594         return OPERATOR_RUNNING_MODAL;
1595 }
1596
1597 static bool envmap_save_poll(bContext *C)
1598 {
1599         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1600
1601         if (!tex)
1602                 return 0;
1603         if (!tex->env || !tex->env->ok)
1604                 return 0;
1605         if (tex->env->cube[1] == NULL)
1606                 return 0;
1607
1608         return 1;
1609 }
1610
1611 void TEXTURE_OT_envmap_save(wmOperatorType *ot)
1612 {
1613         PropertyRNA *prop;
1614         /* identifiers */
1615         ot->name = "Save Environment Map";
1616         ot->idname = "TEXTURE_OT_envmap_save";
1617         ot->description = "Save the current generated Environment map to an image file";
1618
1619         /* api callbacks */
1620         ot->exec = envmap_save_exec;
1621         ot->invoke = envmap_save_invoke;
1622         ot->poll = envmap_save_poll;
1623
1624         /* flags */
1625         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL; /* no undo since this doesnt modify the env-map */
1626
1627         /* properties */
1628         prop = RNA_def_float_array(ot->srna, "layout", 12, default_envmap_layout, 0.0f, 0.0f,
1629                                    "File layout",
1630                                    "Flat array describing the X,Y position of each cube face in the output image, "
1631                                    "where 1 is the size of a face - order is [+Z -Z +Y -X -Y +X] "
1632                                    "(use -1 to skip a face)", 0.0f, 0.0f);
1633         RNA_def_property_flag(prop, PROP_HIDDEN);
1634
1635         WM_operator_properties_filesel(
1636                 ot, FILE_TYPE_FOLDER | FILE_TYPE_IMAGE | FILE_TYPE_MOVIE, FILE_SPECIAL, FILE_SAVE,
1637                 WM_FILESEL_FILEPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
1638 }
1639
1640 static int envmap_clear_exec(bContext *C, wmOperator *UNUSED(op))
1641 {
1642         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1643
1644         BKE_texture_envmap_free_data(tex->env);
1645
1646         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1647
1648         return OPERATOR_FINISHED;
1649 }
1650
1651 static bool envmap_clear_poll(bContext *C)
1652 {
1653         Tex *tex = CTX_data_pointer_get_type(C, "texture", &RNA_Texture).data;
1654
1655         if (!tex)
1656                 return 0;
1657         if (!tex->env || !tex->env->ok)
1658                 return 0;
1659         if (tex->env->cube[1] == NULL)
1660                 return 0;
1661
1662         return 1;
1663 }
1664
1665 void TEXTURE_OT_envmap_clear(wmOperatorType *ot)
1666 {
1667         /* identifiers */
1668         ot->name = "Clear Environment Map";
1669         ot->idname = "TEXTURE_OT_envmap_clear";
1670         ot->description = "Discard the environment map and free it from memory";
1671
1672         /* api callbacks */
1673         ot->exec = envmap_clear_exec;
1674         ot->poll = envmap_clear_poll;
1675
1676         /* flags */
1677         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1678 }
1679
1680 static int envmap_clear_all_exec(bContext *C, wmOperator *UNUSED(op))
1681 {
1682         Main *bmain = CTX_data_main(C);
1683         Tex *tex;
1684
1685         for (tex = bmain->tex.first; tex; tex = tex->id.next)
1686                 if (tex->env)
1687                         BKE_texture_envmap_free_data(tex->env);
1688
1689         WM_event_add_notifier(C, NC_TEXTURE | NA_EDITED, tex);
1690
1691         return OPERATOR_FINISHED;
1692 }
1693
1694 void TEXTURE_OT_envmap_clear_all(wmOperatorType *ot)
1695 {
1696         /* identifiers */
1697         ot->name = "Clear All Environment Maps";
1698         ot->idname = "TEXTURE_OT_envmap_clear_all";
1699         ot->description = "Discard all environment maps in the .blend file and free them from memory";
1700
1701         /* api callbacks */
1702         ot->exec = envmap_clear_all_exec;
1703         ot->poll = envmap_clear_poll;
1704
1705         /* flags */
1706         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
1707 }
1708
1709 /********************** material operators *********************/
1710
1711 /* material copy/paste */
1712 static int copy_material_exec(bContext *C, wmOperator *UNUSED(op))
1713 {
1714         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1715
1716         if (ma == NULL)
1717                 return OPERATOR_CANCELLED;
1718
1719         copy_matcopybuf(CTX_data_main(C), ma);
1720
1721         return OPERATOR_FINISHED;
1722 }
1723
1724 void MATERIAL_OT_copy(wmOperatorType *ot)
1725 {
1726         /* identifiers */
1727         ot->name = "Copy Material";
1728         ot->idname = "MATERIAL_OT_copy";
1729         ot->description = "Copy the material settings and nodes";
1730
1731         /* api callbacks */
1732         ot->exec = copy_material_exec;
1733
1734         /* flags */
1735         /* no undo needed since no changes are made to the material */
1736         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL;
1737 }
1738
1739 static int paste_material_exec(bContext *C, wmOperator *UNUSED(op))
1740 {
1741         Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1742
1743         if (ma == NULL)
1744                 return OPERATOR_CANCELLED;
1745
1746         paste_matcopybuf(CTX_data_main(C), ma);
1747
1748         WM_event_add_notifier(C, NC_MATERIAL | ND_SHADING_LINKS, ma);
1749
1750         return OPERATOR_FINISHED;
1751 }
1752
1753 void MATERIAL_OT_paste(wmOperatorType *ot)
1754 {
1755         /* identifiers */
1756         ot->name = "Paste Material";
1757         ot->idname = "MATERIAL_OT_paste";
1758         ot->description = "Paste the material settings and nodes";
1759
1760         /* api callbacks */
1761         ot->exec = paste_material_exec;
1762
1763         /* flags */
1764         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1765 }
1766
1767
1768 static short mtexcopied = 0; /* must be reset on file load */
1769 static MTex mtexcopybuf;
1770
1771 void ED_render_clear_mtex_copybuf(void)
1772 {   /* use for file reload */
1773         mtexcopied = 0;
1774 }
1775
1776 static void copy_mtex_copybuf(ID *id)
1777 {
1778         MTex **mtex = NULL;
1779
1780         switch (GS(id->name)) {
1781                 case ID_MA:
1782                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1783                         break;
1784                 case ID_LA:
1785                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1786                         // la->mtex[(int)la->texact] // TODO
1787                         break;
1788                 case ID_WO:
1789                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1790                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1791                         break;
1792                 case ID_PA:
1793                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1794                         break;
1795                 case ID_LS:
1796                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1797                         break;
1798                 default:
1799                         break;
1800         }
1801
1802         if (mtex && *mtex) {
1803                 memcpy(&mtexcopybuf, *mtex, sizeof(MTex));
1804                 mtexcopied = 1;
1805         }
1806         else {
1807                 mtexcopied = 0;
1808         }
1809 }
1810
1811 static void paste_mtex_copybuf(ID *id)
1812 {
1813         MTex **mtex = NULL;
1814
1815         if (mtexcopied == 0 || mtexcopybuf.tex == NULL)
1816                 return;
1817
1818         switch (GS(id->name)) {
1819                 case ID_MA:
1820                         mtex = &(((Material *)id)->mtex[(int)((Material *)id)->texact]);
1821                         break;
1822                 case ID_LA:
1823                         mtex = &(((Lamp *)id)->mtex[(int)((Lamp *)id)->texact]);
1824                         // la->mtex[(int)la->texact] // TODO
1825                         break;
1826                 case ID_WO:
1827                         mtex = &(((World *)id)->mtex[(int)((World *)id)->texact]);
1828                         // mtex= wrld->mtex[(int)wrld->texact]; // TODO
1829                         break;
1830                 case ID_PA:
1831                         mtex = &(((ParticleSettings *)id)->mtex[(int)((ParticleSettings *)id)->texact]);
1832                         break;
1833                 case ID_LS:
1834                         mtex = &(((FreestyleLineStyle *)id)->mtex[(int)((FreestyleLineStyle *)id)->texact]);
1835                         break;
1836                 default:
1837                         BLI_assert(!"invalid id type");
1838                         return;
1839         }
1840
1841         if (mtex) {
1842                 if (*mtex == NULL) {
1843                         *mtex = MEM_mallocN(sizeof(MTex), "mtex copy");
1844                 }
1845                 else if ((*mtex)->tex) {
1846                         id_us_min(&(*mtex)->tex->id);
1847                 }
1848
1849                 memcpy(*mtex, &mtexcopybuf, sizeof(MTex));
1850
1851                 id_us_plus((ID *)mtexcopybuf.tex);
1852         }
1853 }
1854
1855
1856 static int copy_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1857 {
1858         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1859
1860         if (id == NULL) {
1861                 /* copying empty slot */
1862                 ED_render_clear_mtex_copybuf();
1863                 return OPERATOR_CANCELLED;
1864         }
1865
1866         copy_mtex_copybuf(id);
1867
1868         return OPERATOR_FINISHED;
1869 }
1870
1871 static bool copy_mtex_poll(bContext *C)
1872 {
1873         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1874
1875         return (id != NULL);
1876 }
1877
1878 void TEXTURE_OT_slot_copy(wmOperatorType *ot)
1879 {
1880         /* identifiers */
1881         ot->name = "Copy Texture Slot Settings";
1882         ot->idname = "TEXTURE_OT_slot_copy";
1883         ot->description = "Copy the material texture settings and nodes";
1884
1885         /* api callbacks */
1886         ot->exec = copy_mtex_exec;
1887         ot->poll = copy_mtex_poll;
1888
1889         /* flags */
1890         /* no undo needed since no changes are made to the mtex */
1891         ot->flag = OPTYPE_REGISTER | OPTYPE_INTERNAL;
1892 }
1893
1894 static int paste_mtex_exec(bContext *C, wmOperator *UNUSED(op))
1895 {
1896         ID *id = CTX_data_pointer_get_type(C, "texture_slot", &RNA_TextureSlot).id.data;
1897
1898         if (id == NULL) {
1899                 Material *ma = CTX_data_pointer_get_type(C, "material", &RNA_Material).data;
1900                 Lamp *la = CTX_data_pointer_get_type(C, "lamp", &RNA_Lamp).data;
1901                 World *wo = CTX_data_pointer_get_type(C, "world", &RNA_World).data;
1902                 ParticleSystem *psys = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem).data;
1903                 FreestyleLineStyle *linestyle = CTX_data_pointer_get_type(C, "line_style", &RNA_FreestyleLineStyle).data;
1904
1905                 if (ma)
1906                         id = &ma->id;
1907                 else if (la)
1908                         id = &la->id;
1909                 else if (wo)
1910                         id = &wo->id;
1911                 else if (psys)
1912                         id = &psys->part->id;
1913                 else if (linestyle)
1914                         id = &linestyle->id;
1915
1916                 if (id == NULL)
1917                         return OPERATOR_CANCELLED;
1918         }
1919
1920         paste_mtex_copybuf(id);
1921
1922         WM_event_add_notifier(C, NC_TEXTURE | ND_SHADING_LINKS, NULL);
1923
1924         return OPERATOR_FINISHED;
1925 }
1926
1927 void TEXTURE_OT_slot_paste(wmOperatorType *ot)
1928 {
1929         /* identifiers */
1930         ot->name = "Paste Texture Slot Settings";
1931         ot->idname = "TEXTURE_OT_slot_paste";
1932         ot->description = "Copy the texture settings and nodes";
1933
1934         /* api callbacks */
1935         ot->exec = paste_mtex_exec;
1936
1937         /* flags */
1938         ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO | OPTYPE_INTERNAL;
1939 }