source/blender/editors/space_view3d/drawmesh.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  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * Contributor(s): Blender Foundation, full update, glsl support
  22  *
  23  * ***** END GPL LICENSE BLOCK *****
  24  */
  25
  26 /** \file blender/editors/space_view3d/drawmesh.c
  27  *  \ingroup spview3d
  28  */
  29
  30 #include <string.h>
  31 #include <math.h>
  32
  33 #include "MEM_guardedalloc.h"
  34
  35 #include "BLI_utildefines.h"
  36 #include "BLI_blenlib.h"
  37 #include "BLI_math.h"
  38 #include "BLI_edgehash.h"
  39 #include "BLI_utildefines.h"
  40
  41 #include "DNA_material_types.h"
  42 #include "DNA_mesh_types.h"
  43 #include "DNA_meshdata_types.h"
  44 #include "DNA_node_types.h"
  45 #include "DNA_object_types.h"
  46 #include "DNA_property_types.h"
  47 #include "DNA_scene_types.h"
  48 #include "DNA_screen_types.h"
  49 #include "DNA_view3d_types.h"
  50 #include "DNA_windowmanager_types.h"
  51
  52 #include "BKE_DerivedMesh.h"
  53 #include "BKE_effect.h"
  54 #include "BKE_image.h"
  55 #include "BKE_material.h"
  56 #include "BKE_paint.h"
  57 #include "BKE_property.h"
  58 #include "BKE_tessmesh.h"
  59 #include "BKE_scene.h"
  60
  61 #include "BIF_gl.h"
  62 #include "BIF_glutil.h"
  63
  64 #include "UI_resources.h"
  65
  66 #include "GPU_buffers.h"
  67 #include "GPU_extensions.h"
  68 #include "GPU_draw.h"
  69 #include "GPU_material.h"
  70
  71 #include "ED_mesh.h"
  72 #include "ED_uvedit.h"
  73
  74 #include "view3d_intern.h"  // own include
  75
  76 /* user data structures for derived mesh callbacks */
  77 typedef struct drawMeshFaceSelect_userData {
  78         Mesh *me;
  79         EdgeHash *eh;
  80 } drawMeshFaceSelect_userData;
  81
  82 typedef struct drawEMTFMapped_userData {
  83         BMEditMesh *em;
  84         short has_mcol;
  85         short has_mtface;
  86         MFace *mf;
  87         MTFace *tf;
  88 } drawEMTFMapped_userData;
  89
  90 typedef struct drawTFace_userData {
  91         MFace *mf;
  92         MTFace *tf;
  93 } drawTFace_userData;
  94
  95 /**************************** Face Select Mode *******************************/
  96
  97 /* Flags for marked edges */
  98 enum {
  99         eEdge_Visible = (1 << 0),
 100         eEdge_Select = (1 << 1),
 101 };
 102
 103 /* Creates a hash of edges to flags indicating selected/visible */
 104 static void get_marked_edge_info__orFlags(EdgeHash *eh, int v0, int v1, int flags)
 105 {
 106         int *flags_p;
 107
 108         if (!BLI_edgehash_haskey(eh, v0, v1))
 109                 BLI_edgehash_insert(eh, v0, v1, NULL);
 110
 111         flags_p = (int *) BLI_edgehash_lookup_p(eh, v0, v1);
 112         *flags_p |= flags;
 113 }
 114
 115 static EdgeHash *get_tface_mesh_marked_edge_info(Mesh *me)
 116 {
 117         EdgeHash *eh = BLI_edgehash_new();
 118         MPoly *mp;
 119         MLoop *ml;
 120         MLoop *ml_next;
 121         int i, j;
 122
 123         for (i = 0; i < me->totpoly; i++) {
 124                 mp = &me->mpoly[i];
 125
 126                 if (!(mp->flag & ME_HIDE)) {
 127                         unsigned int flags = eEdge_Visible;
 128                         if (mp->flag & ME_FACE_SEL) flags |= eEdge_Select;
 129
 130                         ml = me->mloop + mp->loopstart;
 131                         for (j = 0; j < mp->totloop; j++, ml++) {
 132                                 ml_next = ME_POLY_LOOP_NEXT(me->mloop, mp, j);
 133                                 get_marked_edge_info__orFlags(eh, ml->v, ml_next->v, flags);
 134                         }
 135                 }
 136         }
 137
 138         return eh;
 139 }
 140
 141
 142 static DMDrawOption draw_mesh_face_select__setHiddenOpts(void *userData, int index)
 143 {
 144         drawMeshFaceSelect_userData *data = userData;
 145         Mesh *me = data->me;
 146         MEdge *med = &me->medge[index];
 147         uintptr_t flags = (intptr_t) BLI_edgehash_lookup(data->eh, med->v1, med->v2);
 148
 149         if (me->drawflag & ME_DRAWEDGES) {
 150                 if ((me->drawflag & ME_HIDDENEDGES) || (flags & eEdge_Visible))
 151                         return DM_DRAW_OPTION_NORMAL;
 152                 else
 153                         return DM_DRAW_OPTION_SKIP;
 154         }
 155         else if (flags & eEdge_Select)
 156                 return DM_DRAW_OPTION_NORMAL;
 157         else
 158                 return DM_DRAW_OPTION_SKIP;
 159 }
 160
 161 static DMDrawOption draw_mesh_face_select__setSelectOpts(void *userData, int index)
 162 {
 163         drawMeshFaceSelect_userData *data = userData;
 164         MEdge *med = &data->me->medge[index];
 165         uintptr_t flags = (intptr_t) BLI_edgehash_lookup(data->eh, med->v1, med->v2);
 166
 167         return (flags & eEdge_Select) ? DM_DRAW_OPTION_NORMAL : DM_DRAW_OPTION_SKIP;
 168 }
 169
 170 /* draws unselected */
 171 static DMDrawOption draw_mesh_face_select__drawFaceOptsInv(void *userData, int index)
 172 {
 173         Mesh *me = (Mesh *)userData;
 174
 175         MPoly *mpoly = &me->mpoly[index];
 176         if (!(mpoly->flag & ME_HIDE) && !(mpoly->flag & ME_FACE_SEL))
 177                 return DM_DRAW_OPTION_NO_MCOL;  /* Don't set color */
 178         else
 179                 return DM_DRAW_OPTION_SKIP;
 180 }
 181
 182 void draw_mesh_face_select(RegionView3D *rv3d, Mesh *me, DerivedMesh *dm)
 183 {
 184         drawMeshFaceSelect_userData data;
 185
 186         data.me = me;
 187         data.eh = get_tface_mesh_marked_edge_info(me);
 188
 189         glEnable(GL_DEPTH_TEST);
 190         glDisable(GL_LIGHTING);
 191         bglPolygonOffset(rv3d->dist, 1.0);
 192
 193         /* Draw (Hidden) Edges */
 194         setlinestyle(1);
 195         UI_ThemeColor(TH_EDGE_FACESEL);
 196         dm->drawMappedEdges(dm, draw_mesh_face_select__setHiddenOpts, &data);
 197         setlinestyle(0);
 198
 199         /* Draw Selected Faces */
 200         if (me->drawflag & ME_DRAWFACES) {
 201                 glEnable(GL_BLEND);
 202                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 203                 /* dull unselected faces so as not to get in the way of seeing color */
 204                 glColor4ub(96, 96, 96, 64);
 205                 dm->drawMappedFaces(dm, draw_mesh_face_select__drawFaceOptsInv, NULL, NULL, (void *)me, 0);
 206                 glDisable(GL_BLEND);
 207         }
 208
 209         bglPolygonOffset(rv3d->dist, 1.0);
 210
 211         /* Draw Stippled Outline for selected faces */
 212         glColor3ub(255, 255, 255);
 213         setlinestyle(1);
 214         dm->drawMappedEdges(dm, draw_mesh_face_select__setSelectOpts, &data);
 215         setlinestyle(0);
 216
 217         bglPolygonOffset(rv3d->dist, 0.0);  // resets correctly now, even after calling accumulated offsets
 218
 219         BLI_edgehash_free(data.eh, NULL);
 220 }
 221
 222 /***************************** Texture Drawing ******************************/
 223
 224 static Material *give_current_material_or_def(Object *ob, int matnr)
 225 {
 226         extern Material defmaterial;    // render module abuse...
 227         Material *ma = give_current_material(ob, matnr);
 228
 229         return ma ? ma : &defmaterial;
 230 }
 231
 232 /* Icky globals, fix with userdata parameter */
 233
 234 static struct TextureDrawState {
 235         Object *ob;
 236         int islit, istex;
 237         int color_profile;
 238         unsigned char obcol[4];
 239 } Gtexdraw = {NULL, 0, 0, 0, {0, 0, 0, 0}};
 240
 241 static int set_draw_settings_cached(int clearcache, MTFace *texface, Material *ma, struct TextureDrawState gtexdraw)
 242 {
 243         static Material *c_ma;
 244         static int c_textured;
 245         static MTFace c_texface;
 246         static int c_backculled;
 247         static int c_badtex;
 248         static int c_lit;
 249         static int c_has_texface;
 250
 251         Object *litob = NULL; //to get mode to turn off mipmap in painting mode
 252         int backculled = GEMAT_BACKCULL;
 253         int alphablend = 0;
 254         int textured = 0;
 255         int lit = 0;
 256         int has_texface = texface != NULL;
 257         int need_set_tpage = FALSE;
 258
 259         if (clearcache) {
 260                 c_textured = c_lit = c_backculled = -1;
 261                 memset(&c_texface, 0, sizeof(MTFace));
 262                 c_badtex = 0;
 263                 c_has_texface = -1;
 264         }
 265         else {
 266                 textured = gtexdraw.istex;
 267                 litob = gtexdraw.ob;
 268         }
 269
 270         /* convert number of lights into boolean */
 271         if (gtexdraw.islit) lit = 1;
 272
 273         if (ma) {
 274                 alphablend = ma->game.alpha_blend;
 275                 if (ma->mode & MA_SHLESS) lit = 0;
 276                 backculled = ma->game.flag & GEMAT_BACKCULL;
 277         }
 278
 279         if (texface) {
 280                 textured = textured && (texface->tpage);
 281
 282                 /* no material, render alpha if texture has depth=32 */
 283                 if (!ma && BKE_image_has_alpha(texface->tpage))
 284                         alphablend = GPU_BLEND_ALPHA;
 285         }
 286
 287         else
 288                 textured = 0;
 289
 290         if (backculled != c_backculled) {
 291                 if (backculled) glEnable(GL_CULL_FACE);
 292                 else glDisable(GL_CULL_FACE);
 293
 294                 c_backculled = backculled;
 295         }
 296
 297         /* need to re-set tpage if textured flag changed or existsment of texface changed..  */
 298         need_set_tpage = textured != c_textured || has_texface != c_has_texface;
 299         /* ..or if settings inside texface were changed (if texface was used) */
 300         need_set_tpage |= texface && memcmp(&c_texface, texface, sizeof(c_texface));
 301
 302         if (need_set_tpage) {
 303                 if (textured) {
 304                         c_badtex = !GPU_set_tpage(texface, !(litob->mode & OB_MODE_TEXTURE_PAINT), alphablend);
 305                 }
 306                 else {
 307                         GPU_set_tpage(NULL, 0, 0);
 308                         c_badtex = 0;
 309                 }
 310                 c_textured = textured;
 311                 c_has_texface = has_texface;
 312                 if (texface)
 313                         memcpy(&c_texface, texface, sizeof(c_texface));
 314         }
 315
 316         if (c_badtex) lit = 0;
 317         if (lit != c_lit || ma != c_ma) {
 318                 if (lit) {
 319                         float spec[4];
 320                         if (!ma) ma = give_current_material_or_def(NULL, 0);  //default material
 321
 322                         spec[0] = ma->spec * ma->specr;
 323                         spec[1] = ma->spec * ma->specg;
 324                         spec[2] = ma->spec * ma->specb;
 325                         spec[3] = 1.0;
 326
 327                         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, spec);
 328                         glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
 329                         glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, CLAMPIS(ma->har, 0, 128));
 330                         glEnable(GL_LIGHTING);
 331                         glEnable(GL_COLOR_MATERIAL);
 332                 }
 333                 else {
 334                         glDisable(GL_LIGHTING);
 335                         glDisable(GL_COLOR_MATERIAL);
 336                 }
 337                 c_lit = lit;
 338         }
 339
 340         return c_badtex;
 341 }
 342
 343 static void draw_textured_begin(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob)
 344 {
 345         unsigned char obcol[4];
 346         int istex, solidtex;
 347
 348         // XXX scene->obedit warning
 349
 350         /* texture draw is abused for mask selection mode, do this so wire draw
 351          * with face selection in weight paint is not lit. */
 352         if ((v3d->drawtype <= OB_WIRE) && (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT))) {
 353                 solidtex = FALSE;
 354                 Gtexdraw.islit = 0;
 355         }
 356         else if (v3d->drawtype == OB_SOLID || ((ob->mode & OB_MODE_EDIT) && v3d->drawtype != OB_TEXTURE)) {
 357                 /* draw with default lights in solid draw mode and edit mode */
 358                 solidtex = TRUE;
 359                 Gtexdraw.islit = -1;
 360         }
 361         else {
 362                 /* draw with lights in the scene otherwise */
 363                 solidtex = FALSE;
 364                 Gtexdraw.islit = GPU_scene_object_lights(scene, ob, v3d->lay, rv3d->viewmat, !rv3d->is_persp);
 365         }
 366
 367         rgba_float_to_uchar(obcol, ob->col);
 368
 369         glCullFace(GL_BACK); glEnable(GL_CULL_FACE);
 370         if (solidtex || v3d->drawtype == OB_TEXTURE) istex = 1;
 371         else istex = 0;
 372
 373         Gtexdraw.ob = ob;
 374         Gtexdraw.istex = istex;
 375         Gtexdraw.color_profile = scene->r.color_mgt_flag & R_COLOR_MANAGEMENT;
 376         memcpy(Gtexdraw.obcol, obcol, sizeof(obcol));
 377         set_draw_settings_cached(1, NULL, NULL, Gtexdraw);
 378         glShadeModel(GL_SMOOTH);
 379 }
 380
 381 static void draw_textured_end(void)
 382 {
 383         /* switch off textures */
 384         GPU_set_tpage(NULL, 0, 0);
 385
 386         glShadeModel(GL_FLAT);
 387         glDisable(GL_CULL_FACE);
 388
 389         /* XXX, bad patch - GPU_default_lights() calls
 390          * glLightfv(GL_LIGHT_POSITION, ...) which
 391          * is transformed by the current matrix... we
 392          * need to make sure that matrix is identity.
 393          *
 394          * It would be better if drawmesh.c kept track
 395          * of and restored the light settings it changed.
 396          *  - zr
 397          */
 398         glPushMatrix();
 399         glLoadIdentity();
 400         GPU_default_lights();
 401         glPopMatrix();
 402 }
 403
 404 static DMDrawOption draw_tface__set_draw_legacy(MTFace *tface, int has_mcol, int matnr)
 405 {
 406         Material *ma = give_current_material(Gtexdraw.ob, matnr + 1);
 407         int validtexture = 0;
 408
 409         if (ma && (ma->game.flag & GEMAT_INVISIBLE))
 410                 return DM_DRAW_OPTION_SKIP;
 411
 412         validtexture = set_draw_settings_cached(0, tface, ma, Gtexdraw);
 413
 414         if (tface && validtexture) {
 415                 glColor3ub(0xFF, 0x00, 0xFF);
 416                 return DM_DRAW_OPTION_NO_MCOL; /* Don't set color */
 417         }
 418         else if (ma && (ma->shade_flag & MA_OBCOLOR)) {
 419                 glColor3ubv(Gtexdraw.obcol);
 420                 return DM_DRAW_OPTION_NO_MCOL; /* Don't set color */
 421         }
 422         else if (!has_mcol) {
 423                 if (tface) glColor3f(1.0, 1.0, 1.0);
 424                 else {
 425                         if (ma) {
 426                                 float col[3];
 427                                 if (Gtexdraw.color_profile) linearrgb_to_srgb_v3_v3(col, &ma->r);
 428                                 else copy_v3_v3(col, &ma->r);
 429
 430                                 glColor3fv(col);
 431                         }
 432                         else glColor3f(1.0, 1.0, 1.0);
 433                 }
 434                 return DM_DRAW_OPTION_NO_MCOL; /* Don't set color */
 435         }
 436         else {
 437                 return DM_DRAW_OPTION_NORMAL; /* Set color from mcol */
 438         }
 439 }
 440
 441 static DMDrawOption draw_mcol__set_draw_legacy(MTFace *UNUSED(tface), int has_mcol, int UNUSED(matnr))
 442 {
 443         if (has_mcol)
 444                 return DM_DRAW_OPTION_NORMAL;
 445         else
 446                 return DM_DRAW_OPTION_NO_MCOL;
 447 }
 448
 449 static DMDrawOption draw_tface__set_draw(MTFace *tface, int has_mcol, int matnr)
 450 {
 451         Material *ma = give_current_material(Gtexdraw.ob, matnr + 1);
 452
 453         if (ma && (ma->game.flag & GEMAT_INVISIBLE)) return 0;
 454
 455         if (tface && set_draw_settings_cached(0, tface, ma, Gtexdraw)) {
 456                 return DM_DRAW_OPTION_NO_MCOL; /* Don't set color */
 457         }
 458         else if (tface && (tface->mode & TF_OBCOL)) {
 459                 return DM_DRAW_OPTION_NO_MCOL; /* Don't set color */
 460         }
 461         else if (!has_mcol) {
 462                 /* XXX: this return value looks wrong (and doesn't match comment) */
 463                 return DM_DRAW_OPTION_NORMAL; /* Don't set color */
 464         }
 465         else {
 466                 return DM_DRAW_OPTION_NORMAL; /* Set color from mcol */
 467         }
 468 }
 469 static void add_tface_color_layer(DerivedMesh *dm)
 470 {
 471         MTFace *tface = DM_get_tessface_data_layer(dm, CD_MTFACE);
 472         MFace *mface = dm->getTessFaceArray(dm);
 473         MCol *finalCol;
 474         int i, j;
 475         MCol *mcol = dm->getTessFaceDataArray(dm, CD_PREVIEW_MCOL);
 476         if (!mcol)
 477                 mcol = dm->getTessFaceDataArray(dm, CD_MCOL);
 478
 479         finalCol = MEM_mallocN(sizeof(MCol) * 4 * dm->getNumTessFaces(dm), "add_tface_color_layer");
 480         for (i = 0; i < dm->getNumTessFaces(dm); i++) {
 481                 Material *ma = give_current_material(Gtexdraw.ob, mface[i].mat_nr + 1);
 482
 483                 if (ma && (ma->game.flag & GEMAT_INVISIBLE)) {
 484                         if (mcol)
 485                                 memcpy(&finalCol[i * 4], &mcol[i * 4], sizeof(MCol) * 4);
 486                         else
 487                                 for (j = 0; j < 4; j++) {
 488                                         finalCol[i * 4 + j].b = 255;
 489                                         finalCol[i * 4 + j].g = 255;
 490                                         finalCol[i * 4 + j].r = 255;
 491                                 }
 492                 }
 493                 else if (tface && mface && set_draw_settings_cached(0, tface, ma, Gtexdraw)) {
 494                         for (j = 0; j < 4; j++) {
 495                                 finalCol[i * 4 + j].b = 255;
 496                                 finalCol[i * 4 + j].g = 0;
 497                                 finalCol[i * 4 + j].r = 255;
 498                         }
 499                 }
 500                 else if (tface && (tface->mode & TF_OBCOL)) {
 501                         for (j = 0; j < 4; j++) {
 502                                 finalCol[i * 4 + j].b = FTOCHAR(Gtexdraw.obcol[0]);
 503                                 finalCol[i * 4 + j].g = FTOCHAR(Gtexdraw.obcol[1]);
 504                                 finalCol[i * 4 + j].r = FTOCHAR(Gtexdraw.obcol[2]);
 505                         }
 506                 }
 507                 else if (!mcol) {
 508                         if (tface) {
 509                                 for (j = 0; j < 4; j++) {
 510                                         finalCol[i * 4 + j].b = 255;
 511                                         finalCol[i * 4 + j].g = 255;
 512                                         finalCol[i * 4 + j].r = 255;
 513                                 }
 514                         }
 515                         else {
 516                                 float col[3];
 517                                 Material *ma = give_current_material(Gtexdraw.ob, mface[i].mat_nr + 1);
 518
 519                                 if (ma) {
 520                                         if (Gtexdraw.color_profile) linearrgb_to_srgb_v3_v3(col, &ma->r);
 521                                         else copy_v3_v3(col, &ma->r);
 522
 523                                         for (j = 0; j < 4; j++) {
 524                                                 finalCol[i * 4 + j].b = FTOCHAR(col[0]);
 525                                                 finalCol[i * 4 + j].g = FTOCHAR(col[1]);
 526                                                 finalCol[i * 4 + j].r = FTOCHAR(col[2]);
 527                                         }
 528                                 }
 529                                 else
 530                                         for (j = 0; j < 4; j++) {
 531                                                 finalCol[i * 4 + j].b = 255;
 532                                                 finalCol[i * 4 + j].g = 255;
 533                                                 finalCol[i * 4 + j].r = 255;
 534                                         }
 535                         }
 536                 }
 537                 else {
 538                         for (j = 0; j < 4; j++) {
 539                                 finalCol[i * 4 + j].r = mcol[i * 4 + j].r;
 540                                 finalCol[i * 4 + j].g = mcol[i * 4 + j].g;
 541                                 finalCol[i * 4 + j].b = mcol[i * 4 + j].b;
 542                         }
 543                 }
 544         }
 545         CustomData_add_layer(&dm->faceData, CD_TEXTURE_MCOL, CD_ASSIGN, finalCol, dm->numTessFaceData);
 546 }
 547
 548 static DMDrawOption draw_tface_mapped__set_draw(void *userData, int index)
 549 {
 550         Mesh *me = (Mesh *)userData;
 551
 552         /* array checked for NULL before calling */
 553         MPoly *mpoly = &me->mpoly[index];
 554
 555         BLI_assert(index >= 0 && index < me->totpoly);
 556
 557         if (mpoly->flag & ME_HIDE) {
 558                 return DM_DRAW_OPTION_SKIP;
 559         }
 560         else {
 561                 MTexPoly *tpoly = (me->mtpoly) ? &me->mtpoly[index] : NULL;
 562                 MTFace mtf = {{{0}}};
 563                 int matnr = mpoly->mat_nr;
 564
 565                 if (tpoly) {
 566                         ME_MTEXFACE_CPY(&mtf, tpoly);
 567                 }
 568
 569                 return draw_tface__set_draw(&mtf, (me->mloopcol != NULL), matnr);
 570         }
 571 }
 572
 573 static DMDrawOption draw_em_tf_mapped__set_draw(void *userData, int index)
 574 {
 575         drawEMTFMapped_userData *data = userData;
 576         BMEditMesh *em = data->em;
 577         BMFace *efa = EDBM_face_at_index(em, index);
 578
 579         if (efa == NULL || BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
 580                 return DM_DRAW_OPTION_SKIP;
 581         }
 582         else {
 583                 MTFace mtf = {{{0}}};
 584                 int matnr = efa->mat_nr;
 585
 586                 if (data->has_mtface) {
 587                         MTexPoly *tpoly = CustomData_bmesh_get(&em->bm->pdata, efa->head.data, CD_MTEXPOLY);
 588                         ME_MTEXFACE_CPY(&mtf, tpoly);
 589                 }
 590
 591                 return draw_tface__set_draw_legacy(data->has_mtface ? &mtf : NULL,
 592                                                    data->has_mcol, matnr);
 593         }
 594 }
 595
 596 /* when face select is on, use face hidden flag */
 597 static DMDrawOption wpaint__setSolidDrawOptions_facemask(void *userData, int index)
 598 {
 599         Mesh *me = (Mesh *)userData;
 600         MPoly *mp = &me->mpoly[index];
 601         if (mp->flag & ME_HIDE)
 602                 return DM_DRAW_OPTION_SKIP;
 603         return DM_DRAW_OPTION_NORMAL;
 604 }
 605
 606 static void draw_mesh_text(Scene *scene, Object *ob, int glsl)
 607 {
 608         Mesh *me = ob->data;
 609         DerivedMesh *ddm;
 610         MPoly *mp, *mface  = me->mpoly;
 611         MTexPoly *mtpoly   = me->mtpoly;
 612         MLoopUV *mloopuv   = me->mloopuv;
 613         MLoopUV *luv;
 614         MLoopCol *mloopcol = me->mloopcol;  /* why does mcol exist? */
 615         MLoopCol *lcol;
 616
 617         bProperty *prop = get_ob_property(ob, "Text");
 618         GPUVertexAttribs gattribs;
 619         int a, totpoly = me->totpoly;
 620
 621         /* fake values to pass to GPU_render_text() */
 622         MCol tmp_mcol[4]  = {{0}};
 623         MCol *tmp_mcol_pt  = mloopcol ? tmp_mcol : NULL;
 624         MTFace tmp_tf      = {{{0}}};
 625
 626         /* don't draw without tfaces */
 627         if (!mtpoly || !mloopuv)
 628                 return;
 629
 630         /* don't draw when editing */
 631         if (ob->mode & OB_MODE_EDIT)
 632                 return;
 633         else if (ob == OBACT)
 634                 if (paint_facesel_test(ob) || paint_vertsel_test(ob))
 635                         return;
 636
 637         ddm = mesh_get_derived_deform(scene, ob, CD_MASK_BAREMESH);
 638
 639         for (a = 0, mp = mface; a < totpoly; a++, mtpoly++, mp++) {
 640                 short matnr = mp->mat_nr;
 641                 int mf_smooth = mp->flag & ME_SMOOTH;
 642                 Material *mat = me->mat[matnr];
 643                 int mode = mat->game.flag;
 644
 645                 if (!(mode & GEMAT_INVISIBLE) && (mode & GEMAT_TEXT) && mp->totloop >= 3) {
 646                         /* get the polygon as a tri/quad */
 647                         int mp_vi[4];
 648                         float v1[3], v2[3], v3[3], v4[3];
 649                         char string[MAX_PROPSTRING];
 650                         int characters, i, glattrib = -1, badtex = 0;
 651
 652
 653                         /* TEXFACE */
 654                         ME_MTEXFACE_CPY(&tmp_tf, mtpoly);
 655
 656                         if (glsl) {
 657                                 GPU_enable_material(matnr + 1, &gattribs);
 658
 659                                 for (i = 0; i < gattribs.totlayer; i++) {
 660                                         if (gattribs.layer[i].type == CD_MTFACE) {
 661                                                 glattrib = gattribs.layer[i].glindex;
 662                                                 break;
 663                                         }
 664                                 }
 665                         }
 666                         else {
 667                                 badtex = set_draw_settings_cached(0, &tmp_tf, mat, Gtexdraw);
 668                                 if (badtex) {
 669                                         continue;
 670                                 }
 671                         }
 672
 673                         mp_vi[0] = me->mloop[mp->loopstart + 0].v;
 674                         mp_vi[1] = me->mloop[mp->loopstart + 1].v;
 675                         mp_vi[2] = me->mloop[mp->loopstart + 2].v;
 676                         mp_vi[3] = (mp->totloop >= 4) ? me->mloop[mp->loopstart + 3].v : 0;
 677
 678                         /* UV */
 679                         luv = &mloopuv[mp->loopstart];
 680                         copy_v2_v2(tmp_tf.uv[0], luv->uv); luv++;
 681                         copy_v2_v2(tmp_tf.uv[1], luv->uv); luv++;
 682                         copy_v2_v2(tmp_tf.uv[2], luv->uv); luv++;
 683                         if (mp->totloop >= 4) {
 684                                 copy_v2_v2(tmp_tf.uv[3], luv->uv);
 685                         }
 686
 687                         /* COLOR */
 688                         if (mloopcol) {
 689                                 unsigned int totloop_clamp = MIN2(4, mp->totloop);
 690                                 unsigned int j;
 691                                 lcol = &mloopcol[mp->loopstart];
 692
 693                                 for (j = 0; j <= totloop_clamp; j++, lcol++) {
 694                                         MESH_MLOOPCOL_TO_MCOL(lcol, &tmp_mcol[j]);
 695                                 }
 696                         }
 697
 698                         /* LOCATION */
 699                         ddm->getVertCo(ddm, mp_vi[0], v1);
 700                         ddm->getVertCo(ddm, mp_vi[1], v2);
 701                         ddm->getVertCo(ddm, mp_vi[2], v3);
 702                         if (mp->totloop >= 4) {
 703                                 ddm->getVertCo(ddm, mp_vi[3], v4);
 704                         }
 705
 706
 707
 708                         // The BM_FONT handling is in the gpu module, shared with the
 709                         // game engine, was duplicated previously
 710
 711                         set_property_valstr(prop, string);
 712                         characters = strlen(string);
 713
 714                         if (!BKE_image_get_ibuf(mtpoly->tpage, NULL))
 715                                 characters = 0;
 716
 717                         if (!mf_smooth) {
 718                                 float nor[3];
 719
 720                                 normal_tri_v3(nor, v1, v2, v3);
 721
 722                                 glNormal3fv(nor);
 723                         }
 724
 725                         GPU_render_text(&tmp_tf, mode, string, characters,
 726                                         (unsigned int *)tmp_mcol_pt, v1, v2, v3, (mp->totloop >= 4 ? v4 : NULL), glattrib);
 727                 }
 728         }
 729
 730         ddm->release(ddm);
 731 }
 732
 733 static int compareDrawOptions(void *userData, int cur_index, int next_index)
 734 {
 735         drawTFace_userData *data = userData;
 736
 737         if (data->mf && data->mf[cur_index].mat_nr != data->mf[next_index].mat_nr)
 738                 return 0;
 739
 740         if (data->tf && data->tf[cur_index].tpage != data->tf[next_index].tpage)
 741                 return 0;
 742
 743         return 1;
 744 }
 745
 746 static int compareDrawOptionsEm(void *userData, int cur_index, int next_index)
 747 {
 748         drawEMTFMapped_userData *data = userData;
 749
 750         if (data->mf && data->mf[cur_index].mat_nr != data->mf[next_index].mat_nr)
 751                 return 0;
 752
 753         if (data->tf && data->tf[cur_index].tpage != data->tf[next_index].tpage)
 754                 return 0;
 755
 756         return 1;
 757 }
 758
 759 void draw_mesh_textured_old(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, DerivedMesh *dm, int draw_flags)
 760 {
 761         Mesh *me = ob->data;
 762
 763         /* correct for negative scale */
 764         if (ob->transflag & OB_NEG_SCALE) glFrontFace(GL_CW);
 765         else glFrontFace(GL_CCW);
 766
 767         /* draw the textured mesh */
 768         draw_textured_begin(scene, v3d, rv3d, ob);
 769
 770         glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 771
 772         if (ob->mode & OB_MODE_EDIT) {
 773                 drawEMTFMapped_userData data;
 774
 775                 data.em = me->edit_btmesh;
 776                 data.has_mcol = CustomData_has_layer(&me->edit_btmesh->bm->ldata, CD_MLOOPCOL);
 777                 data.has_mtface = CustomData_has_layer(&me->edit_btmesh->bm->pdata, CD_MTEXPOLY);
 778                 data.mf = DM_get_tessface_data_layer(dm, CD_MFACE);
 779                 data.tf = DM_get_tessface_data_layer(dm, CD_MTFACE);
 780
 781                 dm->drawMappedFacesTex(dm, draw_em_tf_mapped__set_draw, compareDrawOptionsEm, &data);
 782         }
 783         else if (draw_flags & DRAW_FACE_SELECT) {
 784                 if (ob->mode & OB_MODE_WEIGHT_PAINT)
 785                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions_facemask, GPU_enable_material, NULL, me,
 786                                             DM_DRAW_USE_COLORS | DM_DRAW_ALWAYS_SMOOTH);
 787                 else
 788                         dm->drawMappedFacesTex(dm, me->mpoly ? draw_tface_mapped__set_draw : NULL, NULL, me);
 789         }
 790         else {
 791                 if (GPU_buffer_legacy(dm)) {
 792                         if (draw_flags & DRAW_MODIFIERS_PREVIEW)
 793                                 dm->drawFacesTex(dm, draw_mcol__set_draw_legacy, NULL, NULL);
 794                         else
 795                                 dm->drawFacesTex(dm, draw_tface__set_draw_legacy, NULL, NULL);
 796                 }
 797                 else {
 798                         drawTFace_userData userData;
 799
 800                         if (!CustomData_has_layer(&dm->faceData, CD_TEXTURE_MCOL))
 801                                 add_tface_color_layer(dm);
 802
 803                         userData.mf = DM_get_tessface_data_layer(dm, CD_MFACE);
 804                         userData.tf = DM_get_tessface_data_layer(dm, CD_MTFACE);
 805
 806                         dm->drawFacesTex(dm, draw_tface__set_draw, compareDrawOptions, &userData);
 807                 }
 808         }
 809
 810         /* draw game engine text hack */
 811         if (get_ob_property(ob, "Text"))
 812                 draw_mesh_text(scene, ob, 0);
 813
 814         draw_textured_end();
 815
 816         /* draw edges and selected faces over textured mesh */
 817         if (!(ob == scene->obedit) && (draw_flags & DRAW_FACE_SELECT))
 818                 draw_mesh_face_select(rv3d, me, dm);
 819
 820         /* reset from negative scale correction */
 821         glFrontFace(GL_CCW);
 822
 823         /* in editmode, the blend mode needs to be set in case it was ADD */
 824         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 825 }
 826
 827 /************************** NEW SHADING NODES ********************************/
 828
 829 typedef struct TexMatCallback {
 830         Scene *scene;
 831         Object *ob;
 832         Mesh *me;
 833         DerivedMesh *dm;
 834 } TexMatCallback;
 835
 836 static void tex_mat_set_material_cb(void *UNUSED(userData), int mat_nr, void *attribs)
 837 {
 838         /* all we have to do here is simply enable the GLSL material, but note
 839          * that the GLSL code will give different result depending on the drawtype,
 840          * in texture draw mode it will output the active texture node, in material
 841          * draw mode it will show the full material. */
 842         GPU_enable_material(mat_nr, attribs);
 843 }
 844
 845 static void tex_mat_set_texture_cb(void *userData, int mat_nr, void *attribs)
 846 {
 847         /* texture draw mode without GLSL */
 848         TexMatCallback *data = (TexMatCallback *)userData;
 849         GPUVertexAttribs *gattribs = attribs;
 850         Image *ima;
 851         ImageUser *iuser;
 852         bNode *node;
 853         int texture_set = 0;
 854
 855         /* draw image texture if we find one */
 856         if (ED_object_get_active_image(data->ob, mat_nr, &ima, &iuser, &node)) {
 857                 /* get openl texture */
 858                 int mipmap = 1;
 859                 int bindcode = (ima) ? GPU_verify_image(ima, iuser, 0, 0, mipmap) : 0;
 860                 float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 861
 862                 if (bindcode) {
 863                         NodeTexBase *texbase = node->storage;
 864
 865                         /* disable existing material */
 866                         GPU_disable_material();
 867                         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, zero);
 868                         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero);
 869                         glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 0);
 870
 871                         /* bind texture */
 872                         glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
 873                         glEnable(GL_COLOR_MATERIAL);
 874                         glEnable(GL_TEXTURE_2D);
 875
 876                         glBindTexture(GL_TEXTURE_2D, ima->bindcode);
 877                         glColor3f(1.0f, 1.0f, 1.0f);
 878
 879                         glMatrixMode(GL_TEXTURE);
 880                         glLoadMatrixf(texbase->tex_mapping.mat);
 881                         glMatrixMode(GL_MODELVIEW);
 882
 883                         /* use active UV texture layer */
 884                         memset(gattribs, 0, sizeof(*gattribs));
 885
 886                         gattribs->layer[0].type = CD_MTFACE;
 887                         gattribs->layer[0].name[0] = '\0';
 888                         gattribs->layer[0].gltexco = 1;
 889                         gattribs->totlayer = 1;
 890
 891                         texture_set = 1;
 892                 }
 893         }
 894
 895         if (!texture_set) {
 896                 glMatrixMode(GL_TEXTURE);
 897                 glLoadIdentity();
 898                 glMatrixMode(GL_MODELVIEW);
 899
 900                 /* disable texture */
 901                 glDisable(GL_TEXTURE_2D);
 902                 glDisable(GL_COLOR_MATERIAL);
 903
 904                 /* draw single color */
 905                 GPU_enable_material(mat_nr, attribs);
 906         }
 907 }
 908
 909 static int tex_mat_set_face_mesh_cb(void *userData, int index)
 910 {
 911         /* faceselect mode face hiding */
 912         TexMatCallback *data = (TexMatCallback *)userData;
 913         Mesh *me = (Mesh *)data->me;
 914         MPoly *mp = &me->mpoly[index];
 915
 916         return !(mp->flag & ME_HIDE);
 917 }
 918
 919 static int tex_mat_set_face_editmesh_cb(void *userData, int index)
 920 {
 921         /* editmode face hiding */
 922         TexMatCallback *data = (TexMatCallback *)userData;
 923         Mesh *me = (Mesh *)data->me;
 924         BMFace *efa = EDBM_face_at_index(me->edit_btmesh, index);
 925
 926         return !BM_elem_flag_test(efa, BM_ELEM_HIDDEN);
 927 }
 928
 929 void draw_mesh_textured(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, DerivedMesh *dm, int draw_flags)
 930 {
 931         if ((!scene_use_new_shading_nodes(scene)) || (draw_flags & DRAW_MODIFIERS_PREVIEW)) {
 932                 draw_mesh_textured_old(scene, v3d, rv3d, ob, dm, draw_flags);
 933                 return;
 934         }
 935         else if (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT)) {
 936                 draw_mesh_paint(rv3d, ob, dm, draw_flags);
 937                 return;
 938         }
 939
 940         /* set opengl state for negative scale & color */
 941         if (ob->transflag & OB_NEG_SCALE) glFrontFace(GL_CW);
 942         else glFrontFace(GL_CCW);
 943
 944         glEnable(GL_LIGHTING);
 945
 946         {
 947                 Mesh *me = ob->data;
 948                 TexMatCallback data = {scene, ob, me, dm};
 949                 int (*set_face_cb)(void *, int);
 950                 int glsl;
 951
 952                 /* face hiding callback depending on mode */
 953                 if (ob == scene->obedit)
 954                         set_face_cb = tex_mat_set_face_editmesh_cb;
 955                 else if (draw_flags & DRAW_FACE_SELECT)
 956                         set_face_cb = tex_mat_set_face_mesh_cb;
 957                 else
 958                         set_face_cb = NULL;
 959
 960                 /* test if we can use glsl */
 961                 glsl = (v3d->drawtype == OB_MATERIAL) && GPU_glsl_support();
 962
 963                 GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl, NULL);
 964
 965                 if (glsl) {
 966                         /* draw glsl */
 967                         dm->drawMappedFacesMat(dm,
 968                                                tex_mat_set_material_cb,
 969                                                set_face_cb, &data);
 970                 }
 971                 else {
 972                         float zero[4] = {0.0f, 0.0f, 0.0f, 0.0f};
 973
 974                         /* draw textured */
 975                         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, zero);
 976                         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zero);
 977                         glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 0);
 978
 979                         dm->drawMappedFacesMat(dm,
 980                                                tex_mat_set_texture_cb,
 981                                                set_face_cb, &data);
 982                 }
 983
 984                 GPU_end_object_materials();
 985         }
 986
 987         /* reset opengl state */
 988         glDisable(GL_COLOR_MATERIAL);
 989         glDisable(GL_TEXTURE_2D);
 990         glDisable(GL_LIGHTING);
 991         glBindTexture(GL_TEXTURE_2D, 0);
 992         glFrontFace(GL_CCW);
 993
 994         glMatrixMode(GL_TEXTURE);
 995         glLoadIdentity();
 996         glMatrixMode(GL_MODELVIEW);
 997
 998         /* faceselect mode drawing over textured mesh */
 999         if (!(ob == scene->obedit) && (draw_flags & DRAW_FACE_SELECT))
1000                 draw_mesh_face_select(rv3d, ob->data, dm);
1001 }
1002
1003 /* Vertex Paint and Weight Paint */
1004
1005 void draw_mesh_paint(RegionView3D *rv3d, Object *ob, DerivedMesh *dm, int draw_flags)
1006 {
1007         DMSetDrawOptions facemask = NULL;
1008         Mesh *me = ob->data;
1009
1010         /* hide faces in face select mode */
1011         if (draw_flags & DRAW_FACE_SELECT)
1012                 facemask = wpaint__setSolidDrawOptions_facemask;
1013
1014         if (ob && ob->mode & OB_MODE_WEIGHT_PAINT) {
1015                 /* enforce default material settings */
1016                 GPU_enable_material(0, NULL);
1017
1018                 /* but set default spec */
1019                 glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
1020                 glEnable(GL_COLOR_MATERIAL);    /* according manpages needed */
1021                 glColor3ub(120, 120, 120);
1022                 glDisable(GL_COLOR_MATERIAL);
1023
1024                 /* diffuse */
1025                 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
1026                 glEnable(GL_LIGHTING);
1027                 glEnable(GL_COLOR_MATERIAL);
1028
1029                 dm->drawMappedFaces(dm, facemask, GPU_enable_material, NULL, me,
1030                                                         DM_DRAW_USE_COLORS | DM_DRAW_ALWAYS_SMOOTH);
1031
1032                 glDisable(GL_COLOR_MATERIAL);
1033                 glDisable(GL_LIGHTING);
1034
1035                 GPU_disable_material();
1036         }
1037         else if (ob->mode & OB_MODE_VERTEX_PAINT) {
1038                 if (me->mloopcol)
1039                         dm->drawMappedFaces(dm, facemask, GPU_enable_material, NULL, me,
1040                                                                 DM_DRAW_USE_COLORS | DM_DRAW_ALWAYS_SMOOTH);
1041                 else {
1042                         glColor3f(1.0f, 1.0f, 1.0f);
1043                         dm->drawMappedFaces(dm, facemask, GPU_enable_material, NULL, me,
1044                                                                 DM_DRAW_ALWAYS_SMOOTH);
1045                 }
1046         }
1047
1048         /* draw face selection on top */
1049         if (draw_flags & DRAW_FACE_SELECT)
1050                 draw_mesh_face_select(rv3d, me, dm);
1051 }
1052