source/blender/editors/space_view3d/drawobject.c

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * Contributor(s): Blender Foundation, full recode and added functions
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file blender/editors/space_view3d/drawobject.c
  29  *  \ingroup spview3d
  30  */
  31
  32
  33 #include <string.h>
  34 #include <math.h>
  35
  36 #include "MEM_guardedalloc.h"
  37
  38 #include "DNA_camera_types.h"
  39 #include "DNA_curve_types.h"
  40 #include "DNA_constraint_types.h" // for drawing constraint
  41 #include "DNA_lamp_types.h"
  42 #include "DNA_lattice_types.h"
  43 #include "DNA_material_types.h"
  44 #include "DNA_meshdata_types.h"
  45 #include "DNA_meta_types.h"
  46 #include "DNA_scene_types.h"
  47 #include "DNA_smoke_types.h"
  48 #include "DNA_speaker_types.h"
  49 #include "DNA_world_types.h"
  50 #include "DNA_armature_types.h"
  51
  52 #include "BLI_blenlib.h"
  53 #include "BLI_math.h"
  54 #include "BLI_editVert.h"
  55 #include "BLI_edgehash.h"
  56 #include "BLI_rand.h"
  57 #include "BLI_utildefines.h"
  58
  59 #include "BKE_anim.h"                   //for the where_on_path function
  60 #include "BKE_constraint.h" // for the get_constraint_target function
  61 #include "BKE_DerivedMesh.h"
  62 #include "BKE_deform.h"
  63 #include "BKE_displist.h"
  64 #include "BKE_font.h"
  65 #include "BKE_global.h"
  66 #include "BKE_image.h"
  67 #include "BKE_key.h"
  68 #include "BKE_lattice.h"
  69 #include "BKE_mesh.h"
  70 #include "BKE_material.h"
  71 #include "BKE_mball.h"
  72 #include "BKE_modifier.h"
  73 #include "BKE_object.h"
  74 #include "BKE_paint.h"
  75 #include "BKE_particle.h"
  76 #include "BKE_pointcache.h"
  77 #include "BKE_unit.h"
  78
  79 #include "smoke_API.h"
  80
  81 #include "IMB_imbuf.h"
  82 #include "IMB_imbuf_types.h"
  83
  84 #include "BIF_gl.h"
  85 #include "BIF_glutil.h"
  86
  87 #include "GPU_draw.h"
  88 #include "GPU_extensions.h"
  89
  90 #include "ED_mesh.h"
  91 #include "ED_particle.h"
  92 #include "ED_screen.h"
  93 #include "ED_sculpt.h"
  94 #include "ED_types.h"
  95 #include "ED_curve.h" /* for ED_curve_editnurbs */
  96
  97 #include "UI_resources.h"
  98
  99 #include "WM_api.h"
 100 #include "wm_subwindow.h"
 101 #include "BLF_api.h"
 102
 103 #include "view3d_intern.h"      // own include
 104
 105
 106 /* this condition has been made more complex since editmode can draw textures */
 107 #define CHECK_OB_DRAWTEXTURE(vd, dt) \
 108 ((vd->drawtype==OB_TEXTURE && dt>OB_SOLID) || \
 109         (vd->drawtype==OB_SOLID && vd->flag2 & V3D_SOLID_TEX))
 110
 111 static void draw_bounding_volume(Scene *scene, Object *ob);
 112
 113 static void drawcube_size(float size);
 114 static void drawcircle_size(float size);
 115 static void draw_empty_sphere(float size);
 116 static void draw_empty_cone(float size);
 117
 118 static int check_ob_drawface_dot(Scene *sce, View3D *vd, char dt)
 119 {
 120         if((sce->toolsettings->selectmode & SCE_SELECT_FACE) == 0)
 121                 return 0;
 122
 123         if(G.f & G_BACKBUFSEL)
 124                 return 0;
 125
 126         if((vd->flag & V3D_ZBUF_SELECT) == 0)
 127                 return 1;
 128
 129         /* if its drawing textures with zbuf sel, then dont draw dots */
 130         if(dt==OB_TEXTURE && vd->drawtype==OB_TEXTURE)
 131                 return 0;
 132
 133         if(vd->drawtype>=OB_SOLID && vd->flag2 & V3D_SOLID_TEX)
 134                 return 0;
 135
 136         return 1;
 137 }
 138
 139 /* ************* only use while object drawing **************
 140  * or after running ED_view3d_init_mats_rv3d
 141  * */
 142 static void view3d_project_short_clip(ARegion *ar, float *vec, short *adr, int local)
 143 {
 144         RegionView3D *rv3d= ar->regiondata;
 145         float fx, fy, vec4[4];
 146
 147         adr[0]= IS_CLIPPED;
 148
 149         /* clipplanes in eye space */
 150         if(rv3d->rflag & RV3D_CLIPPING) {
 151                 if(ED_view3d_test_clipping(rv3d, vec, local))
 152                         return;
 153         }
 154
 155         copy_v3_v3(vec4, vec);
 156         vec4[3]= 1.0;
 157
 158         mul_m4_v4(rv3d->persmatob, vec4);
 159
 160         /* clipplanes in window space */
 161         if( vec4[3] > (float)BL_NEAR_CLIP ) {   /* is the NEAR clipping cutoff for picking */
 162                 fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]);
 163
 164                 if( fx>0 && fx<ar->winx) {
 165
 166                         fy= (ar->winy/2)*(1 + vec4[1]/vec4[3]);
 167
 168                         if(fy > 0.0f && fy < (float)ar->winy) {
 169                                 adr[0]= (short)floorf(fx);
 170                                 adr[1]= (short)floorf(fy);
 171                         }
 172                 }
 173         }
 174 }
 175
 176 /* only use while object drawing */
 177 static void view3d_project_short_noclip(ARegion *ar, float *vec, short *adr)
 178 {
 179         RegionView3D *rv3d= ar->regiondata;
 180         float fx, fy, vec4[4];
 181
 182         adr[0]= IS_CLIPPED;
 183
 184         copy_v3_v3(vec4, vec);
 185         vec4[3]= 1.0;
 186
 187         mul_m4_v4(rv3d->persmatob, vec4);
 188
 189         if( vec4[3] > (float)BL_NEAR_CLIP ) {   /* is the NEAR clipping cutoff for picking */
 190                 fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]);
 191
 192                 if( fx>-32700 && fx<32700) {
 193
 194                         fy= (ar->winy/2)*(1 + vec4[1]/vec4[3]);
 195
 196                         if(fy > -32700.0f && fy < 32700.0f) {
 197                                 adr[0]= (short)floorf(fx);
 198                                 adr[1]= (short)floorf(fy);
 199                         }
 200                 }
 201         }
 202 }
 203
 204 /* ************************ */
 205
 206 /* check for glsl drawing */
 207
 208 int draw_glsl_material(Scene *scene, Object *ob, View3D *v3d, int dt)
 209 {
 210         if(!GPU_glsl_support())
 211                 return 0;
 212         if(G.f & G_PICKSEL)
 213                 return 0;
 214         if(!CHECK_OB_DRAWTEXTURE(v3d, dt))
 215                 return 0;
 216         if(ob==OBACT && (ob && ob->mode & OB_MODE_WEIGHT_PAINT))
 217                 return 0;
 218
 219         return (scene->gm.matmode == GAME_MAT_GLSL) && (dt > OB_SOLID);
 220 }
 221
 222 static int check_material_alpha(Base *base, Mesh *me, int glsl)
 223 {
 224         if(base->flag & OB_FROMDUPLI)
 225                 return 0;
 226
 227         if(G.f & G_PICKSEL)
 228                 return 0;
 229
 230         if(me->edit_mesh)
 231                 return 0;
 232
 233         return (glsl || (base->object->dtx & OB_DRAWTRANSP));
 234 }
 235
 236         /***/
 237 static unsigned int colortab[24]=
 238         {0x0,           0xFF88FF, 0xFFBBFF,
 239          0x403000,      0xFFFF88, 0xFFFFBB,
 240          0x104040,      0x66CCCC, 0x77CCCC,
 241          0x104010,      0x55BB55, 0x66FF66,
 242          0xFFFFFF
 243 };
 244
 245
 246 static float cube[8][3] = {
 247         {-1.0, -1.0, -1.0},
 248         {-1.0, -1.0,  1.0},
 249         {-1.0,  1.0,  1.0},
 250         {-1.0,  1.0, -1.0},
 251         { 1.0, -1.0, -1.0},
 252         { 1.0, -1.0,  1.0},
 253         { 1.0,  1.0,  1.0},
 254         { 1.0,  1.0, -1.0},
 255 };
 256
 257 /* ----------------- OpenGL Circle Drawing - Tables for Optimised Drawing Speed ------------------ */
 258 /* 32 values of sin function (still same result!) */
 259 static float sinval[32] = {
 260         0.00000000,
 261         0.20129852,
 262         0.39435585,
 263         0.57126821,
 264         0.72479278,
 265         0.84864425,
 266         0.93775213,
 267         0.98846832,
 268         0.99871650,
 269         0.96807711,
 270         0.89780453,
 271         0.79077573,
 272         0.65137248,
 273         0.48530196,
 274         0.29936312,
 275         0.10116832,
 276         -0.10116832,
 277         -0.29936312,
 278         -0.48530196,
 279         -0.65137248,
 280         -0.79077573,
 281         -0.89780453,
 282         -0.96807711,
 283         -0.99871650,
 284         -0.98846832,
 285         -0.93775213,
 286         -0.84864425,
 287         -0.72479278,
 288         -0.57126821,
 289         -0.39435585,
 290         -0.20129852,
 291         0.00000000
 292 };
 293
 294 /* 32 values of cos function (still same result!) */
 295 static float cosval[32] ={
 296         1.00000000,
 297         0.97952994,
 298         0.91895781,
 299         0.82076344,
 300         0.68896691,
 301         0.52896401,
 302         0.34730525,
 303         0.15142777,
 304         -0.05064916,
 305         -0.25065253,
 306         -0.44039415,
 307         -0.61210598,
 308         -0.75875812,
 309         -0.87434661,
 310         -0.95413925,
 311         -0.99486932,
 312         -0.99486932,
 313         -0.95413925,
 314         -0.87434661,
 315         -0.75875812,
 316         -0.61210598,
 317         -0.44039415,
 318         -0.25065253,
 319         -0.05064916,
 320         0.15142777,
 321         0.34730525,
 322         0.52896401,
 323         0.68896691,
 324         0.82076344,
 325         0.91895781,
 326         0.97952994,
 327         1.00000000
 328 };
 329
 330 static void draw_xyz_wire(const float c[3], float size, int axis)
 331 {
 332         float v1[3]= {0.f, 0.f, 0.f}, v2[3] = {0.f, 0.f, 0.f};
 333         float dim = size * 0.1f;
 334         float dx[3], dy[3], dz[3];
 335
 336         dx[0]=dim; dx[1]=0.f; dx[2]=0.f;
 337         dy[0]=0.f; dy[1]=dim; dy[2]=0.f;
 338         dz[0]=0.f; dz[1]=0.f; dz[2]=dim;
 339
 340         switch(axis) {
 341                 case 0:         /* x axis */
 342                         glBegin(GL_LINES);
 343
 344                         /* bottom left to top right */
 345                         sub_v3_v3v3(v1, c, dx);
 346                         sub_v3_v3(v1, dy);
 347                         add_v3_v3v3(v2, c, dx);
 348                         add_v3_v3(v2, dy);
 349
 350                         glVertex3fv(v1);
 351                         glVertex3fv(v2);
 352
 353                         /* top left to bottom right */
 354                         mul_v3_fl(dy, 2.f);
 355                         add_v3_v3(v1, dy);
 356                         sub_v3_v3(v2, dy);
 357
 358                         glVertex3fv(v1);
 359                         glVertex3fv(v2);
 360
 361                         glEnd();
 362                         break;
 363                 case 1:         /* y axis */
 364                         glBegin(GL_LINES);
 365
 366                         /* bottom left to top right */
 367                         mul_v3_fl(dx, 0.75f);
 368                         sub_v3_v3v3(v1, c, dx);
 369                         sub_v3_v3(v1, dy);
 370                         add_v3_v3v3(v2, c, dx);
 371                         add_v3_v3(v2, dy);
 372
 373                         glVertex3fv(v1);
 374                         glVertex3fv(v2);
 375
 376                         /* top left to center */
 377                         mul_v3_fl(dy, 2.f);
 378                         add_v3_v3(v1, dy);
 379                         copy_v3_v3(v2, c);
 380
 381                         glVertex3fv(v1);
 382                         glVertex3fv(v2);
 383
 384                         glEnd();
 385                         break;
 386                 case 2:         /* z axis */
 387                         glBegin(GL_LINE_STRIP);
 388
 389                         /* start at top left */
 390                         sub_v3_v3v3(v1, c, dx);
 391                         add_v3_v3v3(v1, c, dz);
 392
 393                         glVertex3fv(v1);
 394
 395                         mul_v3_fl(dx, 2.f);
 396                         add_v3_v3(v1, dx);
 397
 398                         glVertex3fv(v1);
 399
 400                         mul_v3_fl(dz, 2.f);
 401                         sub_v3_v3(v1, dx);
 402                         sub_v3_v3(v1, dz);
 403
 404                         glVertex3fv(v1);
 405
 406                         add_v3_v3(v1, dx);
 407
 408                         glVertex3fv(v1);
 409
 410                         glEnd();
 411                         break;
 412         }
 413
 414 }
 415
 416 void drawaxes(float size, char drawtype)
 417 {
 418         int axis;
 419         float v1[3]= {0.0, 0.0, 0.0};
 420         float v2[3]= {0.0, 0.0, 0.0};
 421         float v3[3]= {0.0, 0.0, 0.0};
 422
 423         switch(drawtype) {
 424
 425         case OB_PLAINAXES:
 426                 for (axis=0; axis<3; axis++) {
 427                         glBegin(GL_LINES);
 428
 429                         v1[axis]= size;
 430                         v2[axis]= -size;
 431                         glVertex3fv(v1);
 432                         glVertex3fv(v2);
 433
 434                         /* reset v1 & v2 to zero */
 435                         v1[axis]= v2[axis]= 0.0f;
 436
 437                         glEnd();
 438                 }
 439                 break;
 440         case OB_SINGLE_ARROW:
 441
 442                 glBegin(GL_LINES);
 443                 /* in positive z direction only */
 444                 v1[2]= size;
 445                 glVertex3fv(v1);
 446                 glVertex3fv(v2);
 447                 glEnd();
 448
 449                 /* square pyramid */
 450                 glBegin(GL_TRIANGLES);
 451
 452                 v2[0]= size * 0.035f; v2[1] = size * 0.035f;
 453                 v3[0]= size * -0.035f; v3[1] = size * 0.035f;
 454                 v2[2]= v3[2]= size * 0.75f;
 455
 456                 for (axis=0; axis<4; axis++) {
 457                         if (axis % 2 == 1) {
 458                                 v2[0] = -v2[0];
 459                                 v3[1] = -v3[1];
 460                         } else {
 461                                 v2[1] = -v2[1];
 462                                 v3[0] = -v3[0];
 463                         }
 464
 465                         glVertex3fv(v1);
 466                         glVertex3fv(v2);
 467                         glVertex3fv(v3);
 468
 469                 }
 470                 glEnd();
 471
 472                 break;
 473         case OB_CUBE:
 474                 drawcube_size(size);
 475                 break;
 476
 477         case OB_CIRCLE:
 478                 drawcircle_size(size);
 479                 break;
 480
 481         case OB_EMPTY_SPHERE:
 482                 draw_empty_sphere(size);
 483                 break;
 484
 485         case OB_EMPTY_CONE:
 486                 draw_empty_cone(size);
 487                 break;
 488
 489         case OB_ARROWS:
 490         default:
 491                 for (axis=0; axis<3; axis++) {
 492                         const int arrow_axis= (axis==0) ? 1:0;
 493
 494                         glBegin(GL_LINES);
 495
 496                         v2[axis]= size;
 497                         glVertex3fv(v1);
 498                         glVertex3fv(v2);
 499
 500                         v1[axis]= size*0.85f;
 501                         v1[arrow_axis]= -size*0.08f;
 502                         glVertex3fv(v1);
 503                         glVertex3fv(v2);
 504
 505                         v1[arrow_axis]= size*0.08f;
 506                         glVertex3fv(v1);
 507                         glVertex3fv(v2);
 508
 509                         glEnd();
 510
 511                         v2[axis]+= size*0.125f;
 512
 513                         draw_xyz_wire(v2, size, axis);
 514
 515
 516                         /* reset v1 & v2 to zero */
 517                         v1[arrow_axis]= v1[axis]= v2[axis]= 0.0f;
 518                 }
 519                 break;
 520         }
 521 }
 522
 523
 524 /* Function to draw an Image on a empty Object */
 525 static void draw_empty_image(Object *ob)
 526 {
 527         Image *ima = (Image*)ob->data;
 528         ImBuf *ibuf = ima ? BKE_image_get_ibuf(ima, NULL) : NULL;
 529
 530         float scale, ofs_x, ofs_y, sca_x, sca_y;
 531         int ima_x, ima_y;
 532
 533         if(ibuf && (ibuf->rect == NULL) && (ibuf->rect_float != NULL)) {
 534                 IMB_rect_from_float(ibuf);
 535         }
 536
 537         /* Get the buffer dimensions so we can fallback to fake ones */
 538         if(ibuf && ibuf->rect) {
 539                 ima_x= ibuf->x;
 540                 ima_y= ibuf->y;
 541         }
 542         else {
 543                 ima_x= 1;
 544                 ima_y= 1;
 545         }
 546
 547         /* Get the image aspect even if the buffer is invalid */
 548         if(ima) {
 549                 if(ima->aspx > ima->aspy) {
 550                         sca_x= 1.0f;
 551                         sca_y= ima->aspy / ima->aspx;
 552                 }
 553                 else if(ima->aspx < ima->aspy) {
 554                         sca_x= ima->aspx / ima->aspy;
 555                         sca_y= 1.0f;
 556                 }
 557                 else {
 558                         sca_x= 1.0f;
 559                         sca_y= 1.0f;
 560                 }
 561         }
 562         else {
 563                 sca_x= 1.0f;
 564                 sca_y= 1.0f;
 565         }
 566
 567         /* Calculate the scale center based on objects origin */
 568         ofs_x= ob->ima_ofs[0] * ima_x;
 569         ofs_y= ob->ima_ofs[1] * ima_y;
 570
 571         glMatrixMode(GL_MODELVIEW);
 572         glPushMatrix();
 573
 574         /* Make sure we are drawing at the origin */
 575         glTranslatef(0.0f,  0.0f,  0.0f);
 576
 577         /* Calculate Image scale */
 578         scale= (ob->empty_drawsize / (float)MAX2(ima_x * sca_x, ima_y * sca_y));
 579
 580         /* Set the object scale */
 581         glScalef(scale * sca_x, scale * sca_y, 1.0f);
 582
 583         if(ibuf && ibuf->rect) {
 584                 /* Setup GL params */
 585                 glEnable(GL_BLEND);
 586                 glBlendFunc(GL_SRC_ALPHA,  GL_ONE_MINUS_SRC_ALPHA);
 587
 588                 /* Use the object color and alpha */
 589                 glColor4fv(ob->col);
 590
 591                 /* Draw the Image on the screen */
 592                 glaDrawPixelsTex(ofs_x, ofs_y, ima_x, ima_y, GL_UNSIGNED_BYTE, ibuf->rect);
 593                 glPixelTransferf(GL_ALPHA_SCALE, 1.0f);
 594
 595                 glDisable(GL_BLEND);
 596         }
 597
 598         UI_ThemeColor((ob->flag & SELECT) ? TH_SELECT : TH_WIRE);
 599
 600         /* Calculate the outline vertex positions */
 601         glBegin(GL_LINE_LOOP);
 602         glVertex2f(ofs_x, ofs_y);
 603         glVertex2f(ofs_x + ima_x, ofs_y);
 604         glVertex2f(ofs_x + ima_x, ofs_y + ima_y);
 605         glVertex2f(ofs_x, ofs_y + ima_y);
 606         glEnd();
 607
 608         /* Reset GL settings */
 609         glMatrixMode(GL_MODELVIEW);
 610         glPopMatrix();
 611 }
 612
 613 void drawcircball(int mode, const float cent[3], float rad, float tmat[][4])
 614 {
 615         float vec[3], vx[3], vy[3];
 616         int a, tot=32;
 617
 618         mul_v3_v3fl(vx, tmat[0], rad);
 619         mul_v3_v3fl(vy, tmat[1], rad);
 620
 621         glBegin(mode);
 622         for(a=0; a<tot; a++) {
 623                 vec[0]= cent[0] + *(sinval+a) * vx[0] + *(cosval+a) * vy[0];
 624                 vec[1]= cent[1] + *(sinval+a) * vx[1] + *(cosval+a) * vy[1];
 625                 vec[2]= cent[2] + *(sinval+a) * vx[2] + *(cosval+a) * vy[2];
 626                 glVertex3fv(vec);
 627         }
 628         glEnd();
 629 }
 630
 631 /* circle for object centers, special_color is for library or ob users */
 632 static void drawcentercircle(View3D *v3d, RegionView3D *rv3d, const float co[3], int selstate, int special_color)
 633 {
 634         const float size= ED_view3d_pixel_size(rv3d, co) * (float)U.obcenter_dia * 0.5f;
 635
 636         /* using gldepthfunc guarantees that it does write z values, but not checks for it, so centers remain visible independt order of drawing */
 637         if(v3d->zbuf)  glDepthFunc(GL_ALWAYS);
 638         glEnable(GL_BLEND);
 639
 640         if(special_color) {
 641                 if (selstate==ACTIVE || selstate==SELECT) glColor4ub(0x88, 0xFF, 0xFF, 155);
 642
 643                 else glColor4ub(0x55, 0xCC, 0xCC, 155);
 644         }
 645         else {
 646                 if (selstate == ACTIVE) UI_ThemeColorShadeAlpha(TH_ACTIVE, 0, -80);
 647                 else if (selstate == SELECT) UI_ThemeColorShadeAlpha(TH_SELECT, 0, -80);
 648                 else if (selstate == DESELECT) UI_ThemeColorShadeAlpha(TH_TRANSFORM, 0, -80);
 649         }
 650         drawcircball(GL_POLYGON, co, size, rv3d->viewinv);
 651
 652         UI_ThemeColorShadeAlpha(TH_WIRE, 0, -30);
 653         drawcircball(GL_LINE_LOOP, co, size, rv3d->viewinv);
 654
 655         glDisable(GL_BLEND);
 656         if(v3d->zbuf)  glDepthFunc(GL_LEQUAL);
 657 }
 658
 659 /* *********** text drawing for object/particles/armature ************* */
 660 static ListBase CachedText[3];
 661 static int CachedTextLevel= 0;
 662
 663 typedef struct ViewCachedString {
 664         struct ViewCachedString *next, *prev;
 665         float vec[3];
 666         union {
 667                 unsigned char ub[4];
 668                 int pack;
 669         } col;
 670         short sco[2];
 671         short xoffs;
 672         short flag;
 673         int str_len, pad;
 674         /* str is allocated past the end */
 675 } ViewCachedString;
 676
 677 void view3d_cached_text_draw_begin(void)
 678 {
 679         ListBase *strings= &CachedText[CachedTextLevel];
 680         strings->first= strings->last= NULL;
 681         CachedTextLevel++;
 682 }
 683
 684 void view3d_cached_text_draw_add(const float co[3], const char *str, short xoffs, short flag, const unsigned char col[4])
 685 {
 686         int alloc_len= strlen(str) + 1;
 687         ListBase *strings= &CachedText[CachedTextLevel-1];
 688         ViewCachedString *vos= MEM_callocN(sizeof(ViewCachedString) + alloc_len, "ViewCachedString");
 689
 690         BLI_addtail(strings, vos);
 691         copy_v3_v3(vos->vec, co);
 692         vos->col.pack= *((int *)col);
 693         vos->xoffs= xoffs;
 694         vos->flag= flag;
 695         vos->str_len= alloc_len-1;
 696
 697         /* allocate past the end */
 698         memcpy(++vos, str, alloc_len);
 699 }
 700
 701 void view3d_cached_text_draw_end(View3D *v3d, ARegion *ar, int depth_write, float mat[][4])
 702 {
 703         RegionView3D *rv3d= ar->regiondata;
 704         ListBase *strings= &CachedText[CachedTextLevel-1];
 705         ViewCachedString *vos;
 706         int a, tot= 0;
 707
 708         /* project first and test */
 709         for(vos= strings->first; vos; vos= vos->next) {
 710                 if(mat && !(vos->flag & V3D_CACHE_TEXT_WORLDSPACE))
 711                         mul_m4_v3(mat, vos->vec);
 712                 view3d_project_short_clip(ar, vos->vec, vos->sco, 0);
 713                 if(vos->sco[0]!=IS_CLIPPED)
 714                         tot++;
 715         }
 716
 717         if(tot) {
 718                 int col_pack_prev= 0;
 719
 720 #if 0
 721                 bglMats mats; /* ZBuffer depth vars */
 722                 double ux, uy, uz;
 723                 float depth;
 724
 725                 if(v3d->zbuf)
 726                         bgl_get_mats(&mats);
 727 #endif
 728                 if(rv3d->rflag & RV3D_CLIPPING)
 729                         for(a=0; a<6; a++)
 730                                 glDisable(GL_CLIP_PLANE0+a);
 731
 732                 glMatrixMode(GL_PROJECTION);
 733                 glPushMatrix();
 734                 glMatrixMode(GL_MODELVIEW);
 735                 glPushMatrix();
 736                 ED_region_pixelspace(ar);
 737
 738                 if(depth_write) {
 739                         if(v3d->zbuf) glDisable(GL_DEPTH_TEST);
 740                 }
 741                 else glDepthMask(0);
 742
 743                 for(vos= strings->first; vos; vos= vos->next) {
 744 #if 0       // too slow, reading opengl info while drawing is very bad, better to see if we cn use the zbuffer while in pixel space - campbell
 745                         if(v3d->zbuf && (vos->flag & V3D_CACHE_TEXT_ZBUF)) {
 746                                 gluProject(vos->vec[0], vos->vec[1], vos->vec[2], mats.modelview, mats.projection, (GLint *)mats.viewport, &ux, &uy, &uz);
 747                                 glReadPixels(ar->winrct.xmin+vos->mval[0]+vos->xoffs, ar->winrct.ymin+vos->mval[1], 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
 748
 749                                 if(uz > depth)
 750                                         continue;
 751                         }
 752 #endif
 753                         if(vos->sco[0]!=IS_CLIPPED) {
 754                                 const char *str= (char *)(vos+1);
 755
 756                                 if(col_pack_prev != vos->col.pack) {
 757                                         glColor3ubv(vos->col.ub);
 758                                         col_pack_prev= vos->col.pack;
 759                                 }
 760                                 if(vos->flag & V3D_CACHE_TEXT_ASCII) {
 761                                         BLF_draw_default_ascii((float)vos->sco[0]+vos->xoffs, (float)vos->sco[1], (depth_write)? 0.0f: 2.0f, str, vos->str_len);
 762                                 }
 763                                 else {
 764                                         BLF_draw_default((float)vos->sco[0]+vos->xoffs, (float)vos->sco[1], (depth_write)? 0.0f: 2.0f, str, vos->str_len);
 765                                 }
 766                         }
 767                 }
 768
 769                 if(depth_write) {
 770                         if(v3d->zbuf) glEnable(GL_DEPTH_TEST);
 771                 }
 772                 else glDepthMask(1);
 773
 774                 glMatrixMode(GL_PROJECTION);
 775                 glPopMatrix();
 776                 glMatrixMode(GL_MODELVIEW);
 777                 glPopMatrix();
 778
 779                 if(rv3d->rflag & RV3D_CLIPPING)
 780                         for(a=0; a<6; a++)
 781                                 glEnable(GL_CLIP_PLANE0+a);
 782         }
 783
 784         if(strings->first)
 785                 BLI_freelistN(strings);
 786
 787         CachedTextLevel--;
 788 }
 789
 790 /* ******************** primitive drawing ******************* */
 791
 792 static void drawcube(void)
 793 {
 794
 795         glBegin(GL_LINE_STRIP);
 796                 glVertex3fv(cube[0]); glVertex3fv(cube[1]);glVertex3fv(cube[2]); glVertex3fv(cube[3]);
 797                 glVertex3fv(cube[0]); glVertex3fv(cube[4]);glVertex3fv(cube[5]); glVertex3fv(cube[6]);
 798                 glVertex3fv(cube[7]); glVertex3fv(cube[4]);
 799         glEnd();
 800
 801         glBegin(GL_LINE_STRIP);
 802                 glVertex3fv(cube[1]); glVertex3fv(cube[5]);
 803         glEnd();
 804
 805         glBegin(GL_LINE_STRIP);
 806                 glVertex3fv(cube[2]); glVertex3fv(cube[6]);
 807         glEnd();
 808
 809         glBegin(GL_LINE_STRIP);
 810                 glVertex3fv(cube[3]); glVertex3fv(cube[7]);
 811         glEnd();
 812 }
 813
 814 /* draws a cube on given the scaling of the cube, assuming that
 815  * all required matrices have been set (used for drawing empties)
 816  */
 817 static void drawcube_size(float size)
 818 {
 819         glBegin(GL_LINE_STRIP);
 820                 glVertex3f(-size,-size,-size); glVertex3f(-size,-size,size);glVertex3f(-size,size,size); glVertex3f(-size,size,-size);
 821                 glVertex3f(-size,-size,-size); glVertex3f(size,-size,-size);glVertex3f(size,-size,size); glVertex3f(size,size,size);
 822                 glVertex3f(size,size,-size); glVertex3f(size,-size,-size);
 823         glEnd();
 824
 825         glBegin(GL_LINE_STRIP);
 826                 glVertex3f(-size,-size,size); glVertex3f(size,-size,size);
 827         glEnd();
 828
 829         glBegin(GL_LINE_STRIP);
 830                 glVertex3f(-size,size,size); glVertex3f(size,size,size);
 831         glEnd();
 832
 833         glBegin(GL_LINE_STRIP);
 834                 glVertex3f(-size,size,-size); glVertex3f(size,size,-size);
 835         glEnd();
 836 }
 837
 838 /* this is an unused (old) cube-drawing function based on a given size */
 839 #if 0
 840 static void drawcube_size(float *size)
 841 {
 842
 843         glPushMatrix();
 844         glScalef(size[0],  size[1],  size[2]);
 845
 846
 847         glBegin(GL_LINE_STRIP);
 848                 glVertex3fv(cube[0]); glVertex3fv(cube[1]);glVertex3fv(cube[2]); glVertex3fv(cube[3]);
 849                 glVertex3fv(cube[0]); glVertex3fv(cube[4]);glVertex3fv(cube[5]); glVertex3fv(cube[6]);
 850                 glVertex3fv(cube[7]); glVertex3fv(cube[4]);
 851         glEnd();
 852
 853         glBegin(GL_LINE_STRIP);
 854                 glVertex3fv(cube[1]); glVertex3fv(cube[5]);
 855         glEnd();
 856
 857         glBegin(GL_LINE_STRIP);
 858                 glVertex3fv(cube[2]); glVertex3fv(cube[6]);
 859         glEnd();
 860
 861         glBegin(GL_LINE_STRIP);
 862                 glVertex3fv(cube[3]); glVertex3fv(cube[7]);
 863         glEnd();
 864
 865         glPopMatrix();
 866 }
 867 #endif
 868
 869 static void drawshadbuflimits(Lamp *la, float mat[][4])
 870 {
 871         float sta[3], end[3], lavec[3];
 872
 873         negate_v3_v3(lavec, mat[2]);
 874         normalize_v3(lavec);
 875
 876         madd_v3_v3v3fl(sta, mat[3], lavec, la->clipsta);
 877         madd_v3_v3v3fl(end, mat[3], lavec, la->clipend);
 878
 879         glBegin(GL_LINE_STRIP);
 880                 glVertex3fv(sta);
 881                 glVertex3fv(end);
 882         glEnd();
 883
 884         glPointSize(3.0);
 885         bglBegin(GL_POINTS);
 886         bglVertex3fv(sta);
 887         bglVertex3fv(end);
 888         bglEnd();
 889         glPointSize(1.0);
 890 }
 891
 892
 893
 894 static void spotvolume(float *lvec, float *vvec, float inp)
 895 {
 896         /* camera is at 0,0,0 */
 897         float temp[3],plane[3],mat1[3][3],mat2[3][3],mat3[3][3],mat4[3][3],q[4],co,si,angle;
 898
 899         normalize_v3(lvec);
 900         normalize_v3(vvec);                             /* is this the correct vector ? */
 901
 902         cross_v3_v3v3(temp,vvec,lvec);          /* equation for a plane through vvec en lvec */
 903         cross_v3_v3v3(plane,lvec,temp);         /* a plane perpendicular to this, parrallel with lvec */
 904
 905         /* vectors are exactly aligned, use the X axis, this is arbitrary */
 906         if(normalize_v3(plane) == 0.0f)
 907                 plane[1]= 1.0f;
 908
 909         /* now we've got two equations: one of a cone and one of a plane, but we have
 910         three unknowns. We remove one unkown by rotating the plane to z=0 (the plane normal) */
 911
 912         /* rotate around cross product vector of (0,0,1) and plane normal, dot product degrees */
 913         /* according definition, we derive cross product is (plane[1],-plane[0],0), en cos = plane[2]);*/
 914
 915         /* translating this comment to english didnt really help me understanding the math! :-) (ton) */
 916
 917         q[1] = plane[1] ;
 918         q[2] = -plane[0] ;
 919         q[3] = 0 ;
 920         normalize_v3(&q[1]);
 921
 922         angle = saacos(plane[2])/2.0f;
 923         co = cos(angle);
 924         si = sqrt(1-co*co);
 925
 926         q[0] =  co;
 927         q[1] *= si;
 928         q[2] *= si;
 929         q[3] =  0;
 930
 931         quat_to_mat3(mat1,q);
 932
 933         /* rotate lamp vector now over acos(inp) degrees */
 934         copy_v3_v3(vvec, lvec);
 935
 936         unit_m3(mat2);
 937         co = inp;
 938         si = sqrt(1-inp*inp);
 939
 940         mat2[0][0] =  co;
 941         mat2[1][0] = -si;
 942         mat2[0][1] =  si;
 943         mat2[1][1] =  co;
 944         mul_m3_m3m3(mat3,mat2,mat1);
 945
 946         mat2[1][0] =  si;
 947         mat2[0][1] = -si;
 948         mul_m3_m3m3(mat4,mat2,mat1);
 949         transpose_m3(mat1);
 950
 951         mul_m3_m3m3(mat2,mat1,mat3);
 952         mul_m3_v3(mat2,lvec);
 953         mul_m3_m3m3(mat2,mat1,mat4);
 954         mul_m3_v3(mat2,vvec);
 955
 956         return;
 957 }
 958
 959 static void draw_spot_cone(Lamp *la, float x, float z)
 960 {
 961         z= fabs(z);
 962
 963         glBegin(GL_TRIANGLE_FAN);
 964         glVertex3f(0.0f, 0.0f, -x);
 965
 966         if(la->mode & LA_SQUARE) {
 967                 glVertex3f(z, z, 0);
 968                 glVertex3f(-z, z, 0);
 969                 glVertex3f(-z, -z, 0);
 970                 glVertex3f(z, -z, 0);
 971                 glVertex3f(z, z, 0);
 972         }
 973         else {
 974                 float angle;
 975                 int a;
 976
 977                 for(a=0; a<33; a++) {
 978                         angle= a*M_PI*2/(33-1);
 979                         glVertex3f(z*cosf(angle), z*sinf(angle), 0);
 980                 }
 981         }
 982
 983         glEnd();
 984 }
 985
 986 static void draw_transp_spot_volume(Lamp *la, float x, float z)
 987 {
 988         glEnable(GL_CULL_FACE);
 989         glEnable(GL_BLEND);
 990         glDepthMask(0);
 991
 992         /* draw backside darkening */
 993         glCullFace(GL_FRONT);
 994
 995         glBlendFunc(GL_ZERO, GL_SRC_ALPHA);
 996         glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
 997
 998         draw_spot_cone(la, x, z);
 999
1000         /* draw front side lighting */
1001         glCullFace(GL_BACK);
1002
1003         glBlendFunc(GL_ONE,  GL_ONE);
1004         glColor4f(0.2f, 0.2f, 0.2f, 1.0f);
1005
1006         draw_spot_cone(la, x, z);
1007
1008         /* restore state */
1009         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1010         glDisable(GL_BLEND);
1011         glDepthMask(1);
1012         glDisable(GL_CULL_FACE);
1013         glCullFace(GL_BACK);
1014 }
1015
1016 static void drawlamp(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base, int dt, int flag)
1017 {
1018         Object *ob= base->object;
1019         const float pixsize= ED_view3d_pixel_size(rv3d, ob->obmat[3]);
1020         Lamp *la= ob->data;
1021         float vec[3], lvec[3], vvec[3], circrad, x,y,z;
1022         float lampsize;
1023         float imat[4][4], curcol[4];
1024         unsigned char col[4];
1025         /* cone can't be drawn for duplicated lamps, because duplilist would be freed to */
1026         /* the moment of view3d_draw_transp() call */
1027         const short is_view= (rv3d->persp==RV3D_CAMOB && v3d->camera == base->object);
1028         const short drawcone= (dt>OB_WIRE && !(G.f & G_PICKSEL) && (la->type == LA_SPOT) && (la->mode & LA_SHOW_CONE) && !(base->flag & OB_FROMDUPLI) && !is_view);
1029
1030         if(drawcone && !v3d->transp) {
1031                 /* in this case we need to draw delayed */
1032                 add_view3d_after(&v3d->afterdraw_transp, base, flag);
1033                 return;
1034         }
1035
1036         /* we first draw only the screen aligned & fixed scale stuff */
1037         glPushMatrix();
1038         glLoadMatrixf(rv3d->viewmat);
1039
1040         /* lets calculate the scale: */
1041         lampsize= pixsize*((float)U.obcenter_dia*0.5f);
1042
1043         /* and view aligned matrix: */
1044         copy_m4_m4(imat, rv3d->viewinv);
1045         normalize_v3(imat[0]);
1046         normalize_v3(imat[1]);
1047
1048         /* lamp center */
1049         copy_v3_v3(vec, ob->obmat[3]);
1050
1051         /* for AA effects */
1052         glGetFloatv(GL_CURRENT_COLOR, curcol);
1053         curcol[3]= 0.6;
1054         glColor4fv(curcol);
1055
1056         if(lampsize > 0.0f) {
1057
1058                 if(ob->id.us>1) {
1059                         if (ob==OBACT || (ob->flag & SELECT)) glColor4ub(0x88, 0xFF, 0xFF, 155);
1060                         else glColor4ub(0x77, 0xCC, 0xCC, 155);
1061                 }
1062
1063                 /* Inner Circle */
1064                 glEnable(GL_BLEND);
1065                 drawcircball(GL_LINE_LOOP, vec, lampsize, imat);
1066                 glDisable(GL_BLEND);
1067                 drawcircball(GL_POLYGON, vec, lampsize, imat);
1068
1069                 /* restore */
1070                 if(ob->id.us>1)
1071                         glColor4fv(curcol);
1072
1073                 /* Outer circle */
1074                 circrad = 3.0f*lampsize;
1075                 setlinestyle(3);
1076
1077                 drawcircball(GL_LINE_LOOP, vec, circrad, imat);
1078
1079                 /* draw dashed outer circle if shadow is on. remember some lamps can't have certain shadows! */
1080                 if(la->type!=LA_HEMI) {
1081                         if(     (la->mode & LA_SHAD_RAY) ||
1082                                 ((la->mode & LA_SHAD_BUF) && (la->type==LA_SPOT))
1083                         ) {
1084                                 drawcircball(GL_LINE_LOOP, vec, circrad + 3.0f*pixsize, imat);
1085                         }
1086                 }
1087         }
1088         else {
1089                 setlinestyle(3);
1090                 circrad = 0.0f;
1091         }
1092
1093         /* draw the pretty sun rays */
1094         if(la->type==LA_SUN) {
1095                 float v1[3], v2[3], mat[3][3];
1096                 short axis;
1097
1098                 /* setup a 45 degree rotation matrix */
1099                 vec_rot_to_mat3(mat, imat[2], (float)M_PI/4.0f);
1100
1101                 /* vectors */
1102                 mul_v3_v3fl(v1, imat[0], circrad * 1.2f);
1103                 mul_v3_v3fl(v2, imat[0], circrad * 2.5f);
1104
1105                 /* center */
1106                 glTranslatef(vec[0], vec[1], vec[2]);
1107
1108                 setlinestyle(3);
1109
1110                 glBegin(GL_LINES);
1111                 for (axis=0; axis<8; axis++) {
1112                         glVertex3fv(v1);
1113                         glVertex3fv(v2);
1114                         mul_m3_v3(mat, v1);
1115                         mul_m3_v3(mat, v2);
1116                 }
1117                 glEnd();
1118
1119                 glTranslatef(-vec[0], -vec[1], -vec[2]);
1120
1121         }
1122
1123         if (la->type==LA_LOCAL) {
1124                 if(la->mode & LA_SPHERE) {
1125                         drawcircball(GL_LINE_LOOP, vec, la->dist, imat);
1126                 }
1127                 /* yafray: for photonlight also draw lightcone as for spot */
1128         }
1129
1130         glPopMatrix();  /* back in object space */
1131         zero_v3(vec);
1132
1133         if(is_view) {
1134                 /* skip drawing extra info */
1135         }
1136         else if ((la->type==LA_SPOT) || (la->type==LA_YF_PHOTON)) {
1137                 lvec[0]=lvec[1]= 0.0;
1138                 lvec[2] = 1.0;
1139                 x = rv3d->persmat[0][2];
1140                 y = rv3d->persmat[1][2];
1141                 z = rv3d->persmat[2][2];
1142                 vvec[0]= x*ob->obmat[0][0] + y*ob->obmat[0][1] + z*ob->obmat[0][2];
1143                 vvec[1]= x*ob->obmat[1][0] + y*ob->obmat[1][1] + z*ob->obmat[1][2];
1144                 vvec[2]= x*ob->obmat[2][0] + y*ob->obmat[2][1] + z*ob->obmat[2][2];
1145
1146                 y = cosf(la->spotsize*(float)(M_PI/360.0));
1147                 spotvolume(lvec, vvec, y);
1148                 x = -la->dist;
1149                 mul_v3_fl(lvec, x);
1150                 mul_v3_fl(vvec, x);
1151
1152                 /* draw the angled sides of the cone */
1153                 glBegin(GL_LINE_STRIP);
1154                         glVertex3fv(vvec);
1155                         glVertex3fv(vec);
1156                         glVertex3fv(lvec);
1157                 glEnd();
1158
1159                 z = x*sqrtf(1.0f - y*y);
1160                 x *= y;
1161
1162                 /* draw the circle/square at the end of the cone */
1163                 glTranslatef(0.0, 0.0 ,  x);
1164                 if(la->mode & LA_SQUARE) {
1165                         float tvec[3];
1166                         float z_abs= fabs(z);
1167
1168                         tvec[0]= tvec[1]= z_abs;
1169                         tvec[2]= 0.0;
1170
1171                         glBegin(GL_LINE_LOOP);
1172                                 glVertex3fv(tvec);
1173                                 tvec[1]= -z_abs; /* neg */
1174                                 glVertex3fv(tvec);
1175                                 tvec[0]= -z_abs; /* neg */
1176                                 glVertex3fv(tvec);
1177                                 tvec[1]= z_abs; /* pos */
1178                                 glVertex3fv(tvec);
1179                         glEnd();
1180                 }
1181                 else circ(0.0, 0.0, fabsf(z));
1182
1183                 /* draw the circle/square representing spotbl */
1184                 if(la->type==LA_SPOT) {
1185                         float spotblcirc = fabs(z)*(1 - pow(la->spotblend, 2));
1186                         /* hide line if it is zero size or overlaps with outer border,
1187                            previously it adjusted to always to show it but that seems
1188                            confusing because it doesn't show the actual blend size */
1189                         if (spotblcirc != 0 && spotblcirc != fabsf(z))
1190                                 circ(0.0, 0.0, spotblcirc);
1191                 }
1192
1193                 if(drawcone)
1194                         draw_transp_spot_volume(la, x, z);
1195
1196                 /* draw clip start, useful for wide cones where its not obvious where the start is */
1197                 glTranslatef(0.0, 0.0 , -x); /* reverse translation above */
1198                 if(la->type==LA_SPOT && (la->mode & LA_SHAD_BUF) ) {
1199                         float lvec_clip[3];
1200                         float vvec_clip[3];
1201                         float clipsta_fac= la->clipsta / -x;
1202
1203                         interp_v3_v3v3(lvec_clip, vec, lvec, clipsta_fac);
1204                         interp_v3_v3v3(vvec_clip, vec, vvec, clipsta_fac);
1205
1206                         glBegin(GL_LINE_STRIP);
1207                                 glVertex3fv(lvec_clip);
1208                                 glVertex3fv(vvec_clip);
1209                         glEnd();
1210                 }
1211         }
1212         else if ELEM(la->type, LA_HEMI, LA_SUN) {
1213
1214                 /* draw the line from the circle along the dist */
1215                 glBegin(GL_LINE_STRIP);
1216                         vec[2] = -circrad;
1217                         glVertex3fv(vec);
1218                         vec[2]= -la->dist;
1219                         glVertex3fv(vec);
1220                 glEnd();
1221
1222                 if(la->type==LA_HEMI) {
1223                         /* draw the hemisphere curves */
1224                         short axis, steps, dir;
1225                         float outdist, zdist, mul;
1226                         zero_v3(vec);
1227                         outdist = 0.14; mul = 1.4; dir = 1;
1228
1229                         setlinestyle(4);
1230                         /* loop over the 4 compass points, and draw each arc as a LINE_STRIP */
1231                         for (axis=0; axis<4; axis++) {
1232                                 float v[3]= {0.0, 0.0, 0.0};
1233                                 zdist = 0.02;
1234
1235                                 glBegin(GL_LINE_STRIP);
1236
1237                                 for (steps=0; steps<6; steps++) {
1238                                         if (axis == 0 || axis == 1) {           /* x axis up, x axis down */
1239                                                 /* make the arcs start at the edge of the energy circle */
1240                                                 if (steps == 0) v[0] = dir*circrad;
1241                                                 else v[0] = v[0] + dir*(steps*outdist);
1242                                         } else if (axis == 2 || axis == 3) {            /* y axis up, y axis down */
1243                                                 /* make the arcs start at the edge of the energy circle */
1244                                                 if (steps == 0) v[1] = dir*circrad;
1245                                                 else v[1] = v[1] + dir*(steps*outdist);
1246                                         }
1247
1248                                         v[2] = v[2] - steps*zdist;
1249
1250                                         glVertex3fv(v);
1251
1252                                         zdist = zdist * mul;
1253                                 }
1254
1255                                 glEnd();
1256                                 /* flip the direction */
1257                                 dir = -dir;
1258                         }
1259                 }
1260         } else if(la->type==LA_AREA) {
1261                 setlinestyle(3);
1262                 if(la->area_shape==LA_AREA_SQUARE)
1263                         fdrawbox(-la->area_size*0.5f, -la->area_size*0.5f, la->area_size*0.5f, la->area_size*0.5f);
1264                 else if(la->area_shape==LA_AREA_RECT)
1265                         fdrawbox(-la->area_size*0.5f, -la->area_sizey*0.5f, la->area_size*0.5f, la->area_sizey*0.5f);
1266
1267                 glBegin(GL_LINE_STRIP);
1268                 glVertex3f(0.0,0.0,-circrad);
1269                 glVertex3f(0.0,0.0,-la->dist);
1270                 glEnd();
1271         }
1272
1273         /* and back to viewspace */
1274         glLoadMatrixf(rv3d->viewmat);
1275         copy_v3_v3(vec, ob->obmat[3]);
1276
1277         setlinestyle(0);
1278
1279         if((la->type == LA_SPOT) && (la->mode & LA_SHAD_BUF) && (is_view == FALSE)) {
1280                 drawshadbuflimits(la, ob->obmat);
1281         }
1282
1283         UI_GetThemeColor4ubv(TH_LAMP, col);
1284         glColor4ubv(col);
1285
1286         glEnable(GL_BLEND);
1287
1288         if (vec[2]>0) vec[2] -= circrad;
1289         else vec[2] += circrad;
1290
1291         glBegin(GL_LINE_STRIP);
1292                 glVertex3fv(vec);
1293                 vec[2]= 0;
1294                 glVertex3fv(vec);
1295         glEnd();
1296
1297         glPointSize(2.0);
1298         glBegin(GL_POINTS);
1299                 glVertex3fv(vec);
1300         glEnd();
1301         glPointSize(1.0);
1302
1303         glDisable(GL_BLEND);
1304
1305         /* restore for drawing extra stuff */
1306         glColor3fv(curcol);
1307
1308 }
1309
1310 static void draw_limit_line(float sta, float end, unsigned int col)
1311 {
1312         glBegin(GL_LINES);
1313         glVertex3f(0.0, 0.0, -sta);
1314         glVertex3f(0.0, 0.0, -end);
1315         glEnd();
1316
1317         glPointSize(3.0);
1318         glBegin(GL_POINTS);
1319         cpack(col);
1320         glVertex3f(0.0, 0.0, -sta);
1321         glVertex3f(0.0, 0.0, -end);
1322         glEnd();
1323         glPointSize(1.0);
1324 }
1325
1326
1327 /* yafray: draw camera focus point (cross, similar to aqsis code in tuhopuu) */
1328 /* qdn: now also enabled for Blender to set focus point for defocus composit node */
1329 static void draw_focus_cross(float dist, float size)
1330 {
1331         glBegin(GL_LINES);
1332         glVertex3f(-size, 0.f, -dist);
1333         glVertex3f(size, 0.f, -dist);
1334         glVertex3f(0.f, -size, -dist);
1335         glVertex3f(0.f, size, -dist);
1336         glEnd();
1337 }
1338
1339 #ifdef VIEW3D_CAMERA_BORDER_HACK
1340 float view3d_camera_border_hack_col[4];
1341 short view3d_camera_border_hack_test= FALSE;
1342 #endif
1343
1344 /* flag similar to draw_object() */
1345 static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, int flag)
1346 {
1347         /* a standing up pyramid with (0,0,0) as top */
1348         Camera *cam;
1349         float vec[8][4], facx, facy, depth, aspx, aspy, caspx, caspy, shx, shy;
1350         int i;
1351         float drawsize;
1352         const short is_view= (rv3d->persp==RV3D_CAMOB && ob==v3d->camera);
1353
1354         const float scax= 1.0f / len_v3(ob->obmat[0]);
1355         const float scay= 1.0f / len_v3(ob->obmat[1]);
1356         const float scaz= 1.0f / len_v3(ob->obmat[2]);
1357
1358 #ifdef VIEW3D_CAMERA_BORDER_HACK
1359         if(is_view && !(G.f & G_PICKSEL)) {
1360                 glGetFloatv(GL_CURRENT_COLOR, view3d_camera_border_hack_col);
1361                 view3d_camera_border_hack_test= TRUE;
1362                 return;
1363         }
1364 #endif
1365
1366         cam= ob->data;
1367         aspx= (float) scene->r.xsch*scene->r.xasp;
1368         aspy= (float) scene->r.ysch*scene->r.yasp;
1369
1370         if(aspx < aspy) {
1371                 caspx= aspx / aspy;
1372                 caspy= 1.0;
1373         }
1374         else {
1375                 caspx= 1.0;
1376                 caspy= aspy / aspx;
1377         }
1378
1379         glDisable(GL_LIGHTING);
1380         glDisable(GL_CULL_FACE);
1381
1382         if(cam->type==CAM_ORTHO) {
1383                 facx= 0.5f * cam->ortho_scale * caspx * scax;
1384                 facy= 0.5f * cam->ortho_scale * caspy * scay;
1385                 shx= cam->shiftx * cam->ortho_scale * scax;
1386                 shy= cam->shifty * cam->ortho_scale * scay;
1387                 depth= is_view ? -((cam->clipsta * scaz) + 0.1f) : - cam->drawsize * cam->ortho_scale * scaz;
1388
1389                 drawsize= 0.5f * cam->ortho_scale;
1390         }
1391         else {
1392                 /* that way it's always visible - clipsta+0.1 */
1393                 float fac;
1394                 drawsize= cam->drawsize / ((scax + scay + scaz) / 3.0f);
1395
1396                 if(is_view) {
1397                         /* fixed depth, variable size (avoids exceeding clipping range) */
1398                         depth = -(cam->clipsta + 0.1f);
1399                         fac = depth / (cam->lens/-16.0f * scaz);
1400                 }
1401                 else {
1402                         /* fixed size, variable depth (stays a reasonable size in the 3D view) */
1403                         depth= drawsize * cam->lens/-16.0f * scaz;
1404                         fac= drawsize;
1405                 }
1406
1407                 facx= fac * caspx * scax;
1408                 facy= fac * caspy * scay;
1409                 shx= cam->shiftx*fac*2 * scax;
1410                 shy= cam->shifty*fac*2 * scay;
1411         }
1412
1413         vec[0][0]= 0.0; vec[0][1]= 0.0; vec[0][2]= 0.0;
1414         vec[1][0]= shx + facx; vec[1][1]= shy + facy; vec[1][2]= depth;
1415         vec[2][0]= shx + facx; vec[2][1]= shy - facy; vec[2][2]= depth;
1416         vec[3][0]= shx - facx; vec[3][1]= shy - facy; vec[3][2]= depth;
1417         vec[4][0]= shx - facx; vec[4][1]= shy + facy; vec[4][2]= depth;
1418
1419         /* camera frame */
1420         glBegin(GL_LINE_LOOP);
1421                 glVertex3fv(vec[1]);
1422                 glVertex3fv(vec[2]);
1423                 glVertex3fv(vec[3]);
1424                 glVertex3fv(vec[4]);
1425         glEnd();
1426
1427         if(is_view)
1428                 return;
1429
1430         /* center point to camera frame */
1431         glBegin(GL_LINE_STRIP);
1432                 glVertex3fv(vec[2]);
1433                 glVertex3fv(vec[0]);
1434                 glVertex3fv(vec[1]);
1435                 glVertex3fv(vec[4]);
1436                 glVertex3fv(vec[0]);
1437                 glVertex3fv(vec[3]);
1438         glEnd();
1439
1440
1441         /* arrow on top */
1442         vec[0][2]= depth;
1443
1444
1445         /* draw an outline arrow for inactive cameras and filled
1446          * for active cameras. We actually draw both outline+filled
1447          * for active cameras so the wire can be seen side-on */
1448         for (i=0;i<2;i++) {
1449                 if (i==0) glBegin(GL_LINE_LOOP);
1450                 else if (i==1 && (ob == v3d->camera)) glBegin(GL_TRIANGLES);
1451                 else break;
1452
1453                 vec[0][0]= shx + ((-0.7f * drawsize) * scax);
1454                 vec[0][1]= shy + ((drawsize * (caspy + 0.1f)) * scay);
1455                 glVertex3fv(vec[0]); /* left */
1456
1457                 vec[0][0]= shx + ((0.7f * drawsize) * scax);
1458                 glVertex3fv(vec[0]); /* right */
1459
1460                 vec[0][0]= shx;
1461                 vec[0][1]= shy + ((1.1f * drawsize * (caspy + 0.7f)) * scay);
1462                 glVertex3fv(vec[0]); /* top */
1463
1464                 glEnd();
1465         }
1466
1467         if(flag==0) {
1468                 if(cam->flag & (CAM_SHOWLIMITS+CAM_SHOWMIST)) {
1469                         float nobmat[4][4];
1470                         World *wrld;
1471
1472                         /* draw in normalized object matrix space */
1473                         copy_m4_m4(nobmat, ob->obmat);
1474                         normalize_m4(nobmat);
1475
1476                         glPushMatrix();
1477                         glLoadMatrixf(rv3d->viewmat);
1478                         glMultMatrixf(nobmat);
1479
1480                         if(cam->flag & CAM_SHOWLIMITS) {
1481                                 draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF);
1482                                 /* qdn: was yafray only, now also enabled for Blender to be used with defocus composit node */
1483                                 draw_focus_cross(dof_camera(ob), cam->drawsize);
1484                         }
1485
1486                         wrld= scene->world;
1487                         if(cam->flag & CAM_SHOWMIST)
1488                                 if(wrld) draw_limit_line(wrld->miststa, wrld->miststa+wrld->mistdist, 0xFFFFFF);
1489
1490                         glPopMatrix();
1491                 }
1492         }
1493 }
1494
1495 /* flag similar to draw_object() */
1496 static void drawspeaker(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, int flag)
1497 {
1498         //Speaker *spk = ob->data;
1499
1500         float vec[3];
1501         int i, j;
1502
1503         glEnable(GL_BLEND);
1504
1505         for(j = 0; j < 3; j++)
1506         {
1507                 vec[2] = .25f * j -.125f;
1508
1509                 glBegin(GL_LINE_LOOP);
1510                 for(i = 0; i < 16; i++)
1511                 {
1512                         vec[0] = cos(M_PI * i / 8.0f) * (j == 0 ? .5f : .25f);
1513                         vec[1] = sin(M_PI * i / 8.0f) * (j == 0 ? .5f : .25f);
1514                         glVertex3fv(vec);
1515                 }
1516                 glEnd();
1517         }
1518
1519         for(j = 0; j < 4; j++)
1520         {
1521                 vec[0] = (((j + 1) % 2) * (j - 1)) * .5f;
1522                 vec[1] = ((j % 2) * (j - 2)) * .5f;
1523                 glBegin(GL_LINE_STRIP);
1524                 for(i = 0; i < 3; i++)
1525                 {
1526                         if(i == 1)
1527                         {
1528                                 vec[0] *= .5f;
1529                                 vec[1] *= .5f;
1530                         }
1531
1532                         vec[2] = .25f * i -.125f;
1533                         glVertex3fv(vec);
1534                 }
1535                 glEnd();
1536         }
1537
1538         glDisable(GL_BLEND);
1539 }
1540
1541 static void lattice_draw_verts(Lattice *lt, DispList *dl, short sel)
1542 {
1543         BPoint *bp = lt->def;
1544         float *co = dl?dl->verts:NULL;
1545         int u, v, w;
1546
1547         UI_ThemeColor(sel?TH_VERTEX_SELECT:TH_VERTEX);
1548         glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE));
1549         bglBegin(GL_POINTS);
1550
1551         for(w=0; w<lt->pntsw; w++) {
1552                 int wxt = (w==0 || w==lt->pntsw-1);
1553                 for(v=0; v<lt->pntsv; v++) {
1554                         int vxt = (v==0 || v==lt->pntsv-1);
1555                         for(u=0; u<lt->pntsu; u++, bp++, co+=3) {
1556                                 int uxt = (u==0 || u==lt->pntsu-1);
1557                                 if(!(lt->flag & LT_OUTSIDE) || uxt || vxt || wxt) {
1558                                         if(bp->hide==0) {
1559                                                 if((bp->f1 & SELECT)==sel) {
1560                                                         bglVertex3fv(dl?co:bp->vec);
1561                                                 }
1562                                         }
1563                                 }
1564                         }
1565                 }
1566         }
1567
1568         glPointSize(1.0);
1569         bglEnd();
1570 }
1571
1572 void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, int x, int y), void *userData)
1573 {
1574         Object *obedit= vc->obedit;
1575         Lattice *lt= obedit->data;
1576         BPoint *bp = lt->editlatt->latt->def;
1577         DispList *dl = find_displist(&obedit->disp, DL_VERTS);
1578         float *co = dl?dl->verts:NULL;
1579         int i, N = lt->editlatt->latt->pntsu*lt->editlatt->latt->pntsv*lt->editlatt->latt->pntsw;
1580         short s[2] = {IS_CLIPPED, 0};
1581
1582         ED_view3d_local_clipping(vc->rv3d, obedit->obmat); /* for local clipping lookups */
1583
1584         for (i=0; i<N; i++, bp++, co+=3) {
1585                 if (bp->hide==0) {
1586                         view3d_project_short_clip(vc->ar, dl?co:bp->vec, s, 1);
1587                         if (s[0] != IS_CLIPPED)
1588                                 func(userData, bp, s[0], s[1]);
1589                 }
1590         }
1591 }
1592
1593 static void drawlattice__point(Lattice *lt, DispList *dl, int u, int v, int w, int use_wcol)
1594 {
1595         int index = ((w*lt->pntsv + v)*lt->pntsu) + u;
1596
1597         if(use_wcol) {
1598                 float col[3];
1599                 MDeformWeight *mdw= defvert_find_index (lt->dvert+index, use_wcol-1);
1600
1601                 weight_to_rgb(mdw?mdw->weight:0.0f, col, col+1, col+2);
1602                 glColor3fv(col);
1603
1604         }
1605
1606         if (dl) {
1607                 glVertex3fv(&dl->verts[index*3]);
1608         } else {
1609                 glVertex3fv(lt->def[index].vec);
1610         }
1611 }
1612
1613 /* lattice color is hardcoded, now also shows weightgroup values in edit mode */
1614 static void drawlattice(Scene *scene, View3D *v3d, Object *ob)
1615 {
1616         Lattice *lt= ob->data;
1617         DispList *dl;
1618         int u, v, w;
1619         int use_wcol= 0, is_edit= (lt->editlatt != NULL);
1620
1621         /* now we default make displist, this will modifiers work for non animated case */
1622         if(ob->disp.first==NULL)
1623                 lattice_calc_modifiers(scene, ob);
1624         dl= find_displist(&ob->disp, DL_VERTS);
1625
1626         if(is_edit) {
1627                 lt= lt->editlatt->latt;
1628
1629                 cpack(0x004000);
1630
1631                 if(ob->defbase.first && lt->dvert) {
1632                         use_wcol= ob->actdef;
1633                         glShadeModel(GL_SMOOTH);
1634                 }
1635         }
1636
1637         glBegin(GL_LINES);
1638         for(w=0; w<lt->pntsw; w++) {
1639                 int wxt = (w==0 || w==lt->pntsw-1);
1640                 for(v=0; v<lt->pntsv; v++) {
1641                         int vxt = (v==0 || v==lt->pntsv-1);
1642                         for(u=0; u<lt->pntsu; u++) {
1643                                 int uxt = (u==0 || u==lt->pntsu-1);
1644
1645                                 if(w && ((uxt || vxt) || !(lt->flag & LT_OUTSIDE))) {
1646                                         drawlattice__point(lt, dl, u, v, w-1, use_wcol);
1647                                         drawlattice__point(lt, dl, u, v, w, use_wcol);
1648                                 }
1649                                 if(v && ((uxt || wxt) || !(lt->flag & LT_OUTSIDE))) {
1650                                         drawlattice__point(lt, dl, u, v-1, w, use_wcol);
1651                                         drawlattice__point(lt, dl, u, v, w, use_wcol);
1652                                 }
1653                                 if(u && ((vxt || wxt) || !(lt->flag & LT_OUTSIDE))) {
1654                                         drawlattice__point(lt, dl, u-1, v, w, use_wcol);
1655                                         drawlattice__point(lt, dl, u, v, w, use_wcol);
1656                                 }
1657                         }
1658                 }
1659         }
1660         glEnd();
1661
1662         /* restoration for weight colors */
1663         if(use_wcol)
1664                 glShadeModel(GL_FLAT);
1665
1666         if(is_edit) {
1667                 if(v3d->zbuf) glDisable(GL_DEPTH_TEST);
1668
1669                 lattice_draw_verts(lt, dl, 0);
1670                 lattice_draw_verts(lt, dl, 1);
1671
1672                 if(v3d->zbuf) glEnable(GL_DEPTH_TEST);
1673         }
1674 }
1675
1676 /* ***************** ******************** */
1677
1678 /* Note! - foreach funcs should be called while drawing or directly after
1679  * if not, ED_view3d_init_mats_rv3d() can be used for selection tools
1680  * but would not give correct results with dupli's for eg. which dont
1681  * use the object matrix in the useual way */
1682 static void mesh_foreachScreenVert__mapFunc(void *userData, int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
1683 {
1684         struct { void (*func)(void *userData, EditVert *eve, int x, int y, int index); void *userData; ViewContext vc; int clipVerts; } *data = userData;
1685         EditVert *eve = EM_get_vert_for_index(index);
1686
1687         if (eve->h==0) {
1688                 short s[2]= {IS_CLIPPED, 0};
1689
1690                 if (data->clipVerts) {
1691                         view3d_project_short_clip(data->vc.ar, co, s, 1);
1692                 } else {
1693                         view3d_project_short_noclip(data->vc.ar, co, s);
1694                 }
1695
1696                 if (s[0]!=IS_CLIPPED)
1697                         data->func(data->userData, eve, s[0], s[1], index);
1698         }
1699 }
1700
1701 void mesh_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, EditVert *eve, int x, int y, int index), void *userData, int clipVerts)
1702 {
1703         struct { void (*func)(void *userData, EditVert *eve, int x, int y, int index); void *userData; ViewContext vc; int clipVerts; } data;
1704         DerivedMesh *dm = editmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
1705
1706         data.vc= *vc;
1707         data.func = func;
1708         data.userData = userData;
1709         data.clipVerts = clipVerts;
1710
1711         if(clipVerts)
1712                 ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1713
1714         EM_init_index_arrays(vc->em, 1, 0, 0);
1715         dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data);
1716         EM_free_index_arrays();
1717
1718         dm->release(dm);
1719 }
1720
1721 static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, float *v0co, float *v1co)
1722 {
1723         struct { void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index); void *userData; ViewContext vc; int clipVerts; } *data = userData;
1724         EditEdge *eed = EM_get_edge_for_index(index);
1725         short s[2][2];
1726
1727         if (eed->h==0) {
1728                 if (data->clipVerts==1) {
1729                         view3d_project_short_clip(data->vc.ar, v0co, s[0], 1);
1730                         view3d_project_short_clip(data->vc.ar, v1co, s[1], 1);
1731                 } else {
1732                         view3d_project_short_noclip(data->vc.ar, v0co, s[0]);
1733                         view3d_project_short_noclip(data->vc.ar, v1co, s[1]);
1734
1735                         if (data->clipVerts==2) {
1736                                 if (!(s[0][0]>=0 && s[0][1]>= 0 && s[0][0]<data->vc.ar->winx && s[0][1]<data->vc.ar->winy))
1737                                         if (!(s[1][0]>=0 && s[1][1]>= 0 && s[1][0]<data->vc.ar->winx && s[1][1]<data->vc.ar->winy))
1738                                                 return;
1739                         }
1740                 }
1741
1742                 data->func(data->userData, eed, s[0][0], s[0][1], s[1][0], s[1][1], index);
1743         }
1744 }
1745
1746 void mesh_foreachScreenEdge(ViewContext *vc, void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index), void *userData, int clipVerts)
1747 {
1748         struct { void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index); void *userData; ViewContext vc; int clipVerts; } data;
1749         DerivedMesh *dm = editmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
1750
1751         data.vc= *vc;
1752         data.func = func;
1753         data.userData = userData;
1754         data.clipVerts = clipVerts;
1755
1756         if(clipVerts)
1757                 ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1758
1759         EM_init_index_arrays(vc->em, 0, 1, 0);
1760         dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
1761         EM_free_index_arrays();
1762
1763         dm->release(dm);
1764 }
1765
1766 static void mesh_foreachScreenFace__mapFunc(void *userData, int index, float *cent, float *UNUSED(no))
1767 {
1768         struct { void (*func)(void *userData, EditFace *efa, int x, int y, int index); void *userData; ViewContext vc; } *data = userData;
1769         EditFace *efa = EM_get_face_for_index(index);
1770         short s[2];
1771
1772         if (efa && efa->h==0 && efa->fgonf!=EM_FGON) {
1773                 view3d_project_short_clip(data->vc.ar, cent, s, 1);
1774
1775                 data->func(data->userData, efa, s[0], s[1], index);
1776         }
1777 }
1778
1779 void mesh_foreachScreenFace(ViewContext *vc, void (*func)(void *userData, EditFace *efa, int x, int y, int index), void *userData)
1780 {
1781         struct { void (*func)(void *userData, EditFace *efa, int x, int y, int index); void *userData; ViewContext vc; } data;
1782         DerivedMesh *dm = editmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
1783
1784         data.vc= *vc;
1785         data.func = func;
1786         data.userData = userData;
1787
1788         //if(clipVerts)
1789         ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1790
1791         EM_init_index_arrays(vc->em, 0, 0, 1);
1792         dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data);
1793         EM_free_index_arrays();
1794
1795         dm->release(dm);
1796 }
1797
1798 void nurbs_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y), void *userData)
1799 {
1800         Curve *cu= vc->obedit->data;
1801         short s[2] = {IS_CLIPPED, 0};
1802         Nurb *nu;
1803         int i;
1804         ListBase *nurbs= ED_curve_editnurbs(cu);
1805
1806         ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1807
1808         for (nu= nurbs->first; nu; nu=nu->next) {
1809                 if(nu->type == CU_BEZIER) {
1810                         for (i=0; i<nu->pntsu; i++) {
1811                                 BezTriple *bezt = &nu->bezt[i];
1812
1813                                 if(bezt->hide==0) {
1814
1815                                         if(cu->drawflag & CU_HIDE_HANDLES) {
1816                                                 view3d_project_short_clip(vc->ar, bezt->vec[1], s, 1);
1817                                                 if (s[0] != IS_CLIPPED)
1818                                                         func(userData, nu, NULL, bezt, 1, s[0], s[1]);
1819                                         } else {
1820                                                 view3d_project_short_clip(vc->ar, bezt->vec[0], s, 1);
1821                                                 if (s[0] != IS_CLIPPED)
1822                                                         func(userData, nu, NULL, bezt, 0, s[0], s[1]);
1823                                                 view3d_project_short_clip(vc->ar, bezt->vec[1], s, 1);
1824                                                 if (s[0] != IS_CLIPPED)
1825                                                         func(userData, nu, NULL, bezt, 1, s[0], s[1]);
1826                                                 view3d_project_short_clip(vc->ar, bezt->vec[2], s, 1);
1827                                                 if (s[0] != IS_CLIPPED)
1828                                                         func(userData, nu, NULL, bezt, 2, s[0], s[1]);
1829                                         }
1830                                 }
1831                         }
1832                 }
1833                 else {
1834                         for (i=0; i<nu->pntsu*nu->pntsv; i++) {
1835                                 BPoint *bp = &nu->bp[i];
1836
1837                                 if(bp->hide==0) {
1838                                         view3d_project_short_clip(vc->ar, bp->vec, s, 1);
1839                                         if (s[0] != IS_CLIPPED)
1840                                                 func(userData, nu, bp, NULL, -1, s[0], s[1]);
1841                                 }
1842                         }
1843                 }
1844         }
1845 }
1846
1847 /* ************** DRAW MESH ****************** */
1848
1849 /* First section is all the "simple" draw routines,
1850  * ones that just pass some sort of primitive to GL,
1851  * with perhaps various options to control lighting,
1852  * color, etc.
1853  *
1854  * These routines should not have user interface related
1855  * logic!!!
1856  */
1857
1858 static void draw_dm_face_normals__mapFunc(void *userData, int index, float *cent, float *no)
1859 {
1860         ToolSettings *ts= ((Scene *)userData)->toolsettings;
1861         EditFace *efa = EM_get_face_for_index(index);
1862
1863         if (efa->h==0 && efa->fgonf!=EM_FGON) {
1864                 glVertex3fv(cent);
1865                 glVertex3f(     cent[0] + no[0]*ts->normalsize,
1866                                         cent[1] + no[1]*ts->normalsize,
1867                                         cent[2] + no[2]*ts->normalsize);
1868         }
1869 }
1870 static void draw_dm_face_normals(Scene *scene, DerivedMesh *dm)
1871 {
1872         glBegin(GL_LINES);
1873         dm->foreachMappedFaceCenter(dm, draw_dm_face_normals__mapFunc, scene);
1874         glEnd();
1875 }
1876
1877 static void draw_dm_face_centers__mapFunc(void *userData, int index, float *cent, float *UNUSED(no))
1878 {
1879         EditFace *efa = EM_get_face_for_index(index);
1880         int sel = *((int*) userData);
1881
1882         if (efa->h==0 && efa->fgonf!=EM_FGON && (efa->f&SELECT)==sel) {
1883                 bglVertex3fv(cent);
1884         }
1885 }
1886 static void draw_dm_face_centers(DerivedMesh *dm, int sel)
1887 {
1888         bglBegin(GL_POINTS);
1889         dm->foreachMappedFaceCenter(dm, draw_dm_face_centers__mapFunc, &sel);
1890         bglEnd();
1891 }
1892
1893 static void draw_dm_vert_normals__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s)
1894 {
1895         Scene *scene= (Scene *)userData;
1896         ToolSettings *ts= scene->toolsettings;
1897         EditVert *eve = EM_get_vert_for_index(index);
1898
1899         if (eve->h==0) {
1900                 glVertex3fv(co);
1901
1902                 if (no_f) {
1903                         glVertex3f(     co[0] + no_f[0]*ts->normalsize,
1904                                                 co[1] + no_f[1]*ts->normalsize,
1905                                                 co[2] + no_f[2]*ts->normalsize);
1906                 } else {
1907                         glVertex3f(     co[0] + no_s[0]*ts->normalsize/32767.0f,
1908                                                 co[1] + no_s[1]*ts->normalsize/32767.0f,
1909                                                 co[2] + no_s[2]*ts->normalsize/32767.0f);
1910                 }
1911         }
1912 }
1913 static void draw_dm_vert_normals(Scene *scene, DerivedMesh *dm)
1914 {
1915         glBegin(GL_LINES);
1916         dm->foreachMappedVert(dm, draw_dm_vert_normals__mapFunc, scene);
1917         glEnd();
1918 }
1919
1920         /* Draw verts with color set based on selection */
1921 static void draw_dm_verts__mapFunc(void *userData, int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
1922 {
1923         struct { int sel; EditVert *eve_act; } * data = userData;
1924         EditVert *eve = EM_get_vert_for_index(index);
1925
1926         if (eve->h==0 && (eve->f&SELECT)==data->sel) {
1927                 /* draw active larger - need to stop/start point drawing for this :/ */
1928                 if (eve==data->eve_act) {
1929                         float size = UI_GetThemeValuef(TH_VERTEX_SIZE);
1930                         UI_ThemeColor4(TH_EDITMESH_ACTIVE);
1931
1932                         bglEnd();
1933
1934                         glPointSize(size);
1935                         bglBegin(GL_POINTS);
1936                         bglVertex3fv(co);
1937                         bglEnd();
1938
1939                         UI_ThemeColor4(data->sel?TH_VERTEX_SELECT:TH_VERTEX);
1940                         glPointSize(size);
1941                         bglBegin(GL_POINTS);
1942                 } else {
1943                         bglVertex3fv(co);
1944                 }
1945         }
1946 }
1947
1948 static void draw_dm_verts(DerivedMesh *dm, int sel, EditVert *eve_act)
1949 {
1950         struct { int sel; EditVert *eve_act; } data;
1951         data.sel = sel;
1952         data.eve_act = eve_act;
1953
1954         bglBegin(GL_POINTS);
1955         dm->foreachMappedVert(dm, draw_dm_verts__mapFunc, &data);
1956         bglEnd();
1957 }
1958
1959         /* Draw edges with color set based on selection */
1960 static int draw_dm_edges_sel__setDrawOptions(void *userData, int index)
1961 {
1962         EditEdge *eed = EM_get_edge_for_index(index);
1963         //unsigned char **cols = userData, *col;
1964         struct { unsigned char *baseCol, *selCol, *actCol; EditEdge *eed_act; } * data = userData;
1965         unsigned char *col;
1966
1967         if (eed->h==0) {
1968                 if (eed==data->eed_act) {
1969                         glColor4ubv(data->actCol);
1970                 } else {
1971                         if (eed->f&SELECT) {
1972                                 col = data->selCol;
1973                         } else {
1974                                 col = data->baseCol;
1975                         }
1976                         /* no alpha, this is used so a transparent color can disable drawing unselected edges in editmode  */
1977                         if (col[3]==0) return 0;
1978
1979                         glColor4ubv(col);
1980                 }
1981                 return 1;
1982         } else {
1983                 return 0;
1984         }
1985 }
1986 static void draw_dm_edges_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditEdge *eed_act)
1987 {
1988         struct { unsigned char *baseCol, *selCol, *actCol; EditEdge *eed_act; } data;
1989
1990         data.baseCol = baseCol;
1991         data.selCol = selCol;
1992         data.actCol = actCol;
1993         data.eed_act = eed_act;
1994         dm->drawMappedEdges(dm, draw_dm_edges_sel__setDrawOptions, &data);
1995 }
1996
1997         /* Draw edges */
1998 static int draw_dm_edges__setDrawOptions(void *UNUSED(userData), int index)
1999 {
2000         return EM_get_edge_for_index(index)->h==0;
2001 }
2002 static void draw_dm_edges(DerivedMesh *dm)
2003 {
2004         dm->drawMappedEdges(dm, draw_dm_edges__setDrawOptions, NULL);
2005 }
2006
2007         /* Draw edges with color interpolated based on selection */
2008 static int draw_dm_edges_sel_interp__setDrawOptions(void *UNUSED(userData), int index)
2009 {
2010         return EM_get_edge_for_index(index)->h==0;
2011 }
2012 static void draw_dm_edges_sel_interp__setDrawInterpOptions(void *userData, int index, float t)
2013 {
2014         EditEdge *eed = EM_get_edge_for_index(index);
2015         unsigned char **cols = userData;
2016         unsigned char *col0 = cols[(eed->v1->f&SELECT)?1:0];
2017         unsigned char *col1 = cols[(eed->v2->f&SELECT)?1:0];
2018
2019         glColor4ub(     col0[0] + (col1[0]-col0[0])*t,
2020                                 col0[1] + (col1[1]-col0[1])*t,
2021                                 col0[2] + (col1[2]-col0[2])*t,
2022                                 col0[3] + (col1[3]-col0[3])*t);
2023 }
2024
2025 static void draw_dm_edges_sel_interp(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol)
2026 {
2027         unsigned char *cols[2];
2028         cols[0]= baseCol;
2029         cols[1]= selCol;
2030         dm->drawMappedEdgesInterp(dm, draw_dm_edges_sel_interp__setDrawOptions, draw_dm_edges_sel_interp__setDrawInterpOptions, cols);
2031 }
2032
2033         /* Draw only seam edges */
2034 static int draw_dm_edges_seams__setDrawOptions(void *UNUSED(userData), int index)
2035 {
2036         EditEdge *eed = EM_get_edge_for_index(index);
2037
2038         return (eed->h==0 && eed->seam);
2039 }
2040 static void draw_dm_edges_seams(DerivedMesh *dm)
2041 {
2042         dm->drawMappedEdges(dm, draw_dm_edges_seams__setDrawOptions, NULL);
2043 }
2044
2045         /* Draw only sharp edges */
2046 static int draw_dm_edges_sharp__setDrawOptions(void *UNUSED(userData), int index)
2047 {
2048         EditEdge *eed = EM_get_edge_for_index(index);
2049
2050         return (eed->h==0 && eed->sharp);
2051 }
2052 static void draw_dm_edges_sharp(DerivedMesh *dm)
2053 {
2054         dm->drawMappedEdges(dm, draw_dm_edges_sharp__setDrawOptions, NULL);
2055 }
2056
2057
2058         /* Draw faces with color set based on selection
2059          * return 2 for the active face so it renders with stipple enabled */
2060 static int draw_dm_faces_sel__setDrawOptions(void *userData, int index, int *UNUSED(drawSmooth_r))
2061 {
2062         struct { unsigned char *cols[3]; EditFace *efa_act; } * data = userData;
2063         EditFace *efa = EM_get_face_for_index(index);
2064         unsigned char *col;
2065
2066         if (efa->h==0) {
2067                 if (efa == data->efa_act) {
2068                         glColor4ubv(data->cols[2]);
2069                         return 2; /* stipple */
2070                 } else {
2071                         col = data->cols[(efa->f&SELECT)?1:0];
2072                         if (col[3]==0) return 0;
2073                         glColor4ubv(col);
2074                         return 1;
2075                 }
2076         }
2077         return 0;
2078 }
2079
2080 /* also draws the active face */
2081 static void draw_dm_faces_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditFace *efa_act)
2082 {
2083         struct { unsigned char *cols[3]; EditFace *efa_act; } data;
2084         data.cols[0] = baseCol;
2085         data.cols[1] = selCol;
2086         data.cols[2] = actCol;
2087         data.efa_act = efa_act;
2088
2089         dm->drawMappedFaces(dm, draw_dm_faces_sel__setDrawOptions, &data, 0, GPU_enable_material);
2090 }
2091
2092 static int draw_dm_creases__setDrawOptions(void *UNUSED(userData), int index)
2093 {
2094         EditEdge *eed = EM_get_edge_for_index(index);
2095
2096         if (eed->h==0 && eed->crease != 0.0f) {
2097                 UI_ThemeColorBlend(TH_WIRE, TH_EDGE_CREASE, eed->crease);
2098                 return 1;
2099         } else {
2100                 return 0;
2101         }
2102 }
2103 static void draw_dm_creases(DerivedMesh *dm)
2104 {
2105         glLineWidth(3.0);
2106         dm->drawMappedEdges(dm, draw_dm_creases__setDrawOptions, NULL);
2107         glLineWidth(1.0);
2108 }
2109
2110 static int draw_dm_bweights__setDrawOptions(void *UNUSED(userData), int index)
2111 {
2112         EditEdge *eed = EM_get_edge_for_index(index);
2113
2114         if (eed->h==0 && eed->bweight != 0.0f) {
2115                 UI_ThemeColorBlend(TH_WIRE, TH_EDGE_SELECT, eed->bweight);
2116                 return 1;
2117         } else {
2118                 return 0;
2119         }
2120 }
2121 static void draw_dm_bweights__mapFunc(void *UNUSED(userData), int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
2122 {
2123         EditVert *eve = EM_get_vert_for_index(index);
2124
2125         if (eve->h==0 && eve->bweight != 0.0f) {
2126                 UI_ThemeColorBlend(TH_VERTEX, TH_VERTEX_SELECT, eve->bweight);
2127                 bglVertex3fv(co);
2128         }
2129 }
2130 static void draw_dm_bweights(Scene *scene, DerivedMesh *dm)
2131 {
2132         ToolSettings *ts= scene->toolsettings;
2133
2134         if (ts->selectmode & SCE_SELECT_VERTEX) {
2135                 glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE) + 2);
2136                 bglBegin(GL_POINTS);
2137                 dm->foreachMappedVert(dm, draw_dm_bweights__mapFunc, NULL);
2138                 bglEnd();
2139         }
2140         else {
2141                 glLineWidth(3.0);
2142                 dm->drawMappedEdges(dm, draw_dm_bweights__setDrawOptions, NULL);
2143                 glLineWidth(1.0);
2144         }
2145 }
2146
2147 /* Second section of routines: Combine first sets to form fancy
2148  * drawing routines (for example rendering twice to get overlays).
2149  *
2150  * Also includes routines that are basic drawing but are too
2151  * specialized to be split out (like drawing creases or measurements).
2152  */
2153
2154 /* EditMesh drawing routines*/
2155
2156 static void draw_em_fancy_verts(Scene *scene, View3D *v3d, Object *obedit, DerivedMesh *cageDM, EditVert *eve_act)
2157 {
2158         ToolSettings *ts= scene->toolsettings;
2159         int sel;
2160
2161         if(v3d->zbuf) glDepthMask(0);           // disable write in zbuffer, zbuf select
2162
2163         for (sel=0; sel<2; sel++) {
2164                 unsigned char col[4], fcol[4];
2165                 int pass;
2166
2167                 UI_GetThemeColor3ubv(sel?TH_VERTEX_SELECT:TH_VERTEX, col);
2168                 UI_GetThemeColor3ubv(sel?TH_FACE_DOT:TH_WIRE, fcol);
2169
2170                 for (pass=0; pass<2; pass++) {
2171                         float size = UI_GetThemeValuef(TH_VERTEX_SIZE);
2172                         float fsize = UI_GetThemeValuef(TH_FACEDOT_SIZE);
2173
2174                         if (pass==0) {
2175                                 if(v3d->zbuf && !(v3d->flag&V3D_ZBUF_SELECT)) {
2176                                         glDisable(GL_DEPTH_TEST);
2177
2178                                         glEnable(GL_BLEND);
2179                                 } else {
2180                                         continue;
2181                                 }
2182
2183                                 size = (size > 2.1f ? size/2.0f:size);
2184                                 fsize = (fsize > 2.1f ? fsize/2.0f:fsize);
2185                                 col[3] = fcol[3] = 100;
2186                         } else {
2187                                 col[3] = fcol[3] = 255;
2188                         }
2189
2190                         if(ts->selectmode & SCE_SELECT_VERTEX) {
2191                                 glPointSize(size);
2192                                 glColor4ubv(col);
2193                                 draw_dm_verts(cageDM, sel, eve_act);
2194                         }
2195
2196                         if(check_ob_drawface_dot(scene, v3d, obedit->dt)) {
2197                                 glPointSize(fsize);
2198                                 glColor4ubv(fcol);
2199                                 draw_dm_face_centers(cageDM, sel);
2200                         }
2201
2202                         if (pass==0) {
2203                                 glDisable(GL_BLEND);
2204                                 glEnable(GL_DEPTH_TEST);
2205                         }
2206                 }
2207         }
2208
2209         if(v3d->zbuf) glDepthMask(1);
2210         glPointSize(1.0);
2211 }
2212
2213 static void draw_em_fancy_edges(Scene *scene, View3D *v3d, Mesh *me, DerivedMesh *cageDM, short sel_only, EditEdge *eed_act)
2214 {
2215         ToolSettings *ts= scene->toolsettings;
2216         int pass;
2217         unsigned char wireCol[4], selCol[4], actCol[4];
2218
2219         /* since this function does transparant... */
2220         UI_GetThemeColor4ubv(TH_EDGE_SELECT, selCol);
2221         UI_GetThemeColor4ubv(TH_WIRE, wireCol);
2222         UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, actCol);
2223
2224         /* when sel only is used, dont render wire, only selected, this is used for
2225          * textured draw mode when the 'edges' option is disabled */
2226         if (sel_only)
2227                 wireCol[3] = 0;
2228
2229         for (pass=0; pass<2; pass++) {
2230                         /* show wires in transparant when no zbuf clipping for select */
2231                 if (pass==0) {
2232                         if (v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT)==0) {
2233                                 glEnable(GL_BLEND);
2234                                 glDisable(GL_DEPTH_TEST);
2235                                 selCol[3] = 85;
2236                                 if (!sel_only) wireCol[3] = 85;
2237                         } else {
2238                                 continue;
2239                         }
2240                 } else {
2241                         selCol[3] = 255;
2242                         if (!sel_only) wireCol[3] = 255;
2243                 }
2244
2245                 if(ts->selectmode == SCE_SELECT_FACE) {
2246                         draw_dm_edges_sel(cageDM, wireCol, selCol, actCol, eed_act);
2247                 }
2248                 else if( (me->drawflag & ME_DRAWEDGES) || (ts->selectmode & SCE_SELECT_EDGE) ) {
2249                         if(cageDM->drawMappedEdgesInterp && (ts->selectmode & SCE_SELECT_VERTEX)) {
2250                                 glShadeModel(GL_SMOOTH);
2251                                 draw_dm_edges_sel_interp(cageDM, wireCol, selCol);
2252                                 glShadeModel(GL_FLAT);
2253                         } else {
2254                                 draw_dm_edges_sel(cageDM, wireCol, selCol, actCol, eed_act);
2255                         }
2256                 }
2257                 else {
2258                         if (!sel_only) {
2259                                 glColor4ubv(wireCol);
2260                                 draw_dm_edges(cageDM);
2261                         }
2262                 }
2263
2264                 if (pass==0) {
2265                         glDisable(GL_BLEND);
2266                         glEnable(GL_DEPTH_TEST);
2267                 }
2268         }
2269 }
2270
2271 static void draw_em_measure_stats(View3D *v3d, RegionView3D *rv3d, Object *ob, EditMesh *em, UnitSettings *unit)
2272 {
2273         Mesh *me= ob->data;
2274         EditEdge *eed;
2275         EditFace *efa;
2276         float v1[3], v2[3], v3[3], v4[3], vmid[3];
2277         float fvec[3];
2278         char val[32]; /* Stores the measurement display text here */
2279         const char *conv_float; /* Use a float conversion matching the grid size */
2280         unsigned char col[4]= {0, 0, 0, 255}; /* color of the text to draw */
2281         float area; /* area of the face */
2282         float grid= unit->system ? unit->scale_length : v3d->grid;
2283         const int do_split= unit->flag & USER_UNIT_OPT_SPLIT;
2284         const int do_global= v3d->flag & V3D_GLOBAL_STATS;
2285         const int do_moving= G.moving;
2286
2287         /* make the precision of the pronted value proportionate to the gridsize */
2288
2289         if (grid < 0.01f)               conv_float= "%.6g";
2290         else if (grid < 0.1f)   conv_float= "%.5g";
2291         else if (grid < 1.0f)   conv_float= "%.4g";
2292         else if (grid < 10.0f)  conv_float= "%.3g";
2293         else                                    conv_float= "%.2g";
2294
2295         if(v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT)==0)
2296                 glDisable(GL_DEPTH_TEST);
2297
2298         if(v3d->zbuf) bglPolygonOffset(rv3d->dist, 5.0f);
2299
2300         if(me->drawflag & ME_DRAWEXTRA_EDGELEN) {
2301                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_EDGELEN, col);
2302
2303                 for(eed= em->edges.first; eed; eed= eed->next) {
2304                         /* draw non fgon edges, or selected edges, or edges next to selected verts while draging */
2305                         if((eed->h != EM_FGON) && ((eed->f & SELECT) || (do_moving && ((eed->v1->f & SELECT) || (eed->v2->f & SELECT)) ))) {
2306                                 copy_v3_v3(v1, eed->v1->co);
2307                                 copy_v3_v3(v2, eed->v2->co);
2308
2309                                 interp_v3_v3v3(vmid, v1, v2, 0.5f);
2310
2311                                 if(do_global) {
2312                                         mul_mat3_m4_v3(ob->obmat, v1);
2313                                         mul_mat3_m4_v3(ob->obmat, v2);
2314                                 }
2315                                 if(unit->system)
2316                                         bUnit_AsString(val, sizeof(val), len_v3v3(v1, v2)*unit->scale_length, 3, unit->system, B_UNIT_LENGTH, do_split, FALSE);
2317                                 else
2318                                         sprintf(val, conv_float, len_v3v3(v1, v2));
2319
2320                                 view3d_cached_text_draw_add(vmid, val, 0, V3D_CACHE_TEXT_ASCII, col);
2321                         }
2322                 }
2323         }
2324
2325         if(me->drawflag & ME_DRAWEXTRA_FACEAREA) {
2326 // XXX          extern int faceselectedOR(EditFace *efa, int flag);             // editmesh.h shouldn't be in this file... ok for now?
2327                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEAREA, col);
2328
2329                 for(efa= em->faces.first; efa; efa= efa->next) {
2330                         if((efa->f & SELECT)) { // XXX || (do_moving && faceselectedOR(efa, SELECT)) ) {
2331                                 copy_v3_v3(v1, efa->v1->co);
2332                                 copy_v3_v3(v2, efa->v2->co);
2333                                 copy_v3_v3(v3, efa->v3->co);
2334                                 if (efa->v4) {
2335                                         copy_v3_v3(v4, efa->v4->co);
2336                                 }
2337                                 if(do_global) {
2338                                         mul_mat3_m4_v3(ob->obmat, v1);
2339                                         mul_mat3_m4_v3(ob->obmat, v2);
2340                                         mul_mat3_m4_v3(ob->obmat, v3);
2341                                         if (efa->v4) mul_mat3_m4_v3(ob->obmat, v4);
2342                                 }
2343
2344                                 if (efa->v4)
2345                                         area=  area_quad_v3(v1, v2, v3, v4);
2346                                 else
2347                                         area = area_tri_v3(v1, v2, v3);
2348
2349                                 if(unit->system)
2350                                         bUnit_AsString(val, sizeof(val), area*unit->scale_length, 3, unit->system, B_UNIT_LENGTH, do_split, FALSE); // XXX should be B_UNIT_AREA
2351                                 else
2352                                         sprintf(val, conv_float, area);
2353
2354                                 view3d_cached_text_draw_add(efa->cent, val, 0, V3D_CACHE_TEXT_ASCII, col);
2355                         }
2356                 }
2357         }
2358
2359         if(me->drawflag & ME_DRAWEXTRA_FACEANG) {
2360                 EditEdge *e1, *e2, *e3, *e4;
2361                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col);
2362                 for(efa= em->faces.first; efa; efa= efa->next) {
2363                         copy_v3_v3(v1, efa->v1->co);
2364                         copy_v3_v3(v2, efa->v2->co);
2365                         copy_v3_v3(v3, efa->v3->co);
2366                         if(efa->v4) {
2367                                 copy_v3_v3(v4, efa->v4->co);
2368                         }
2369                         else {
2370                                 copy_v3_v3(v4, v3);
2371                         }
2372                         if(do_global) {
2373                                 mul_mat3_m4_v3(ob->obmat, v1);
2374                                 mul_mat3_m4_v3(ob->obmat, v2);
2375                                 mul_mat3_m4_v3(ob->obmat, v3);
2376                                 mul_mat3_m4_v3(ob->obmat, v4); /* intentionally executed even for tri's */
2377                         }
2378
2379                         e1= efa->e1;
2380                         e2= efa->e2;
2381                         e3= efa->e3;
2382                         if(efa->e4) e4= efa->e4; else e4= e3;
2383
2384                         /* Calculate the angles */
2385
2386                         if( (e4->f & e1->f & SELECT) || (do_moving && (efa->v1->f & SELECT)) ) {
2387                                 /* Vec 1 */
2388                                 sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v4, v1, v2)));
2389                                 interp_v3_v3v3(fvec, efa->cent, efa->v1->co, 0.8f);
2390                                 view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2391                         }
2392                         if( (e1->f & e2->f & SELECT) || (do_moving && (efa->v2->f & SELECT)) ) {
2393                                 /* Vec 2 */
2394                                 sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v1, v2, v3)));
2395                                 interp_v3_v3v3(fvec, efa->cent, efa->v2->co, 0.8f);
2396                                 view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2397                         }
2398                         if( (e2->f & e3->f & SELECT) || (do_moving && (efa->v3->f & SELECT)) ) {
2399                                 /* Vec 3 */
2400                                 if(efa->v4)
2401                                         sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v2, v3, v4)));
2402                                 else
2403                                         sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v2, v3, v1)));
2404                                 interp_v3_v3v3(fvec, efa->cent, efa->v3->co, 0.8f);
2405                                 view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2406                         }
2407                                 /* Vec 4 */
2408                         if(efa->v4) {
2409                                 if( (e3->f & e4->f & SELECT) || (do_moving && (efa->v4->f & SELECT)) ) {
2410                                         sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v3, v4, v1)));
2411                                         interp_v3_v3v3(fvec, efa->cent, efa->v4->co, 0.8f);
2412                                         view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2413                                 }
2414                         }
2415                 }
2416         }
2417
2418         /* useful for debugging index vs shape key index */
2419 #if 0
2420         {
2421                 EditVert *eve;
2422                 int j;
2423                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col);
2424                 for(eve= em->verts.first, j= 0; eve; eve= eve->next, j++) {
2425                         sprintf(val, "%d:%d", j, eve->keyindex);
2426                         view3d_cached_text_draw_add(eve->co, val, 0, V3D_CACHE_TEXT_ASCII, col);
2427                 }
2428         }
2429 #endif
2430
2431         if(v3d->zbuf) {
2432                 glEnable(GL_DEPTH_TEST);
2433                 bglPolygonOffset(rv3d->dist, 0.0f);
2434         }
2435 }
2436
2437 static int draw_em_fancy__setFaceOpts(void *UNUSED(userData), int index, int *UNUSED(drawSmooth_r))
2438 {
2439         EditFace *efa = EM_get_face_for_index(index);
2440
2441         if (efa->h==0) {
2442                 GPU_enable_material(efa->mat_nr+1, NULL);
2443                 return 1;
2444         }
2445         else
2446                 return 0;
2447 }
2448
2449 static int draw_em_fancy__setGLSLFaceOpts(void *UNUSED(userData), int index)
2450 {
2451         EditFace *efa = EM_get_face_for_index(index);
2452
2453         return (efa->h==0);
2454 }
2455
2456 static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, EditMesh *em, DerivedMesh *cageDM, DerivedMesh *finalDM, int dt)
2457 {
2458         Mesh *me = ob->data;
2459         EditFace *efa_act = EM_get_actFace(em, 0); /* annoying but active faces is stored differently */
2460         EditEdge *eed_act = NULL;
2461         EditVert *eve_act = NULL;
2462
2463         if (em->selected.last) {
2464                 EditSelection *ese = em->selected.last;
2465                 /* face is handeled above */
2466                 /*if (ese->type == EDITFACE ) {
2467                         efa_act = (EditFace *)ese->data;
2468                 } else */ if ( ese->type == EDITEDGE ) {
2469                         eed_act = (EditEdge *)ese->data;
2470                 } else if ( ese->type == EDITVERT ) {
2471                         eve_act = (EditVert *)ese->data;
2472                 }
2473         }
2474
2475         EM_init_index_arrays(em, 1, 1, 1);
2476
2477         if(dt>OB_WIRE) {
2478                 if(CHECK_OB_DRAWTEXTURE(v3d, dt)) {
2479                         if(draw_glsl_material(scene, ob, v3d, dt)) {
2480                                 glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2481
2482                                 finalDM->drawMappedFacesGLSL(finalDM, GPU_enable_material,
2483                                         draw_em_fancy__setGLSLFaceOpts, NULL);
2484                                 GPU_disable_material();
2485
2486                                 glFrontFace(GL_CCW);
2487                         }
2488                         else {
2489                                 draw_mesh_textured(scene, v3d, rv3d, ob, finalDM, 0);
2490                         }
2491                 }
2492                 else {
2493                         /* 3 floats for position, 3 for normal and times two because the faces may actually be quads instead of triangles */
2494                         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, me->flag & ME_TWOSIDED);
2495
2496                         glEnable(GL_LIGHTING);
2497                         glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2498
2499                         finalDM->drawMappedFaces(finalDM, draw_em_fancy__setFaceOpts, NULL, 0, GPU_enable_material);
2500
2501                         glFrontFace(GL_CCW);
2502                         glDisable(GL_LIGHTING);
2503                 }
2504
2505                 // Setup for drawing wire over, disable zbuffer
2506                 // write to show selected edge wires better
2507                 UI_ThemeColor(TH_WIRE);
2508
2509                 bglPolygonOffset(rv3d->dist, 1.0);
2510                 glDepthMask(0);
2511         }
2512         else {
2513                 if (cageDM!=finalDM) {
2514                         UI_ThemeColorBlend(TH_WIRE, TH_BACK, 0.7);
2515                         finalDM->drawEdges(finalDM, 1, 0);
2516                 }
2517         }
2518
2519         if(me->drawflag & ME_DRAWFACES) {       /* transp faces */
2520                 unsigned char col1[4], col2[4], col3[4];
2521
2522                 UI_GetThemeColor4ubv(TH_FACE, col1);
2523                 UI_GetThemeColor4ubv(TH_FACE_SELECT, col2);
2524                 UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, col3);
2525
2526                 glEnable(GL_BLEND);
2527                 glDepthMask(0);         // disable write in zbuffer, needed for nice transp
2528
2529                 /* dont draw unselected faces, only selected, this is MUCH nicer when texturing */
2530                 if CHECK_OB_DRAWTEXTURE(v3d, dt)
2531                         col1[3] = 0;
2532
2533                 draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act);
2534
2535                 glDisable(GL_BLEND);
2536                 glDepthMask(1);         // restore write in zbuffer
2537         } else if (efa_act) {
2538                 /* even if draw faces is off it would be nice to draw the stipple face
2539                  * Make all other faces zero alpha except for the active
2540                  * */
2541                 unsigned char col1[4], col2[4], col3[4];
2542                 col1[3] = col2[3] = 0; /* dont draw */
2543                 UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, col3);
2544
2545                 glEnable(GL_BLEND);
2546                 glDepthMask(0);         // disable write in zbuffer, needed for nice transp
2547
2548                 draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act);
2549
2550                 glDisable(GL_BLEND);
2551                 glDepthMask(1);         // restore write in zbuffer
2552
2553         }
2554
2555         /* here starts all fancy draw-extra over */
2556         if((me->drawflag & ME_DRAWEDGES)==0 && CHECK_OB_DRAWTEXTURE(v3d, dt)) {
2557                 /* we are drawing textures and 'ME_DRAWEDGES' is disabled, dont draw any edges */
2558
2559                 /* only draw selected edges otherwise there is no way of telling if a face is selected */
2560                 draw_em_fancy_edges(scene, v3d, me, cageDM, 1, eed_act);
2561
2562         } else {
2563                 if(me->drawflag & ME_DRAWSEAMS) {
2564                         UI_ThemeColor(TH_EDGE_SEAM);
2565                         glLineWidth(2);
2566
2567                         draw_dm_edges_seams(cageDM);
2568
2569                         glColor3ub(0,0,0);
2570                         glLineWidth(1);
2571                 }
2572
2573                 if(me->drawflag & ME_DRAWSHARP) {
2574                         UI_ThemeColor(TH_EDGE_SHARP);
2575                         glLineWidth(2);
2576
2577                         draw_dm_edges_sharp(cageDM);
2578
2579                         glColor3ub(0,0,0);
2580                         glLineWidth(1);
2581                 }
2582
2583                 if(me->drawflag & ME_DRAWCREASES) {
2584                         draw_dm_creases(cageDM);
2585                 }
2586                 if(me->drawflag & ME_DRAWBWEIGHTS) {
2587                         draw_dm_bweights(scene, cageDM);
2588                 }
2589
2590                 draw_em_fancy_edges(scene, v3d, me, cageDM, 0, eed_act);
2591         }
2592         if(em) {
2593 // XXX          retopo_matrix_update(v3d);
2594
2595                 draw_em_fancy_verts(scene, v3d, ob, cageDM, eve_act);
2596
2597                 if(me->drawflag & ME_DRAWNORMALS) {
2598                         UI_ThemeColor(TH_NORMAL);
2599                         draw_dm_face_normals(scene, cageDM);
2600                 }
2601                 if(me->drawflag & ME_DRAW_VNORMALS) {
2602                         UI_ThemeColor(TH_VNORMAL);
2603                         draw_dm_vert_normals(scene, cageDM);
2604                 }
2605
2606                 if(me->drawflag & (ME_DRAWEXTRA_EDGELEN|ME_DRAWEXTRA_FACEAREA|ME_DRAWEXTRA_FACEANG) && !((v3d->flag2 & V3D_RENDER_OVERRIDE)))
2607                         draw_em_measure_stats(v3d, rv3d, ob, em, &scene->unit);
2608         }
2609
2610         if(dt>OB_WIRE) {
2611                 glDepthMask(1);
2612                 bglPolygonOffset(rv3d->dist, 0.0);
2613                 GPU_disable_material();
2614         }
2615
2616         EM_free_index_arrays();
2617 }
2618
2619 /* Mesh drawing routines */
2620
2621 static void draw_mesh_object_outline(View3D *v3d, Object *ob, DerivedMesh *dm)
2622 {
2623
2624         if(v3d->transp==0) {    // not when we draw the transparent pass
2625                 glLineWidth(UI_GetThemeValuef(TH_OUTLINE_WIDTH) * 2.0f);
2626                 glDepthMask(0);
2627
2628                 /* if transparent, we cannot draw the edges for solid select... edges have no material info.
2629                    drawFacesSolid() doesn't draw the transparent faces */
2630                 if(ob->dtx & OB_DRAWTRANSP) {
2631                         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
2632                         dm->drawFacesSolid(dm, NULL, 0, GPU_enable_material);
2633                         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
2634                         GPU_disable_material();
2635                 }
2636                 else {
2637                         dm->drawEdges(dm, 0, 1);
2638                 }
2639
2640                 glLineWidth(1.0);
2641                 glDepthMask(1);
2642         }
2643 }
2644
2645 static int wpaint__setSolidDrawOptions(void *UNUSED(userData), int UNUSED(index), int *drawSmooth_r)
2646 {
2647         *drawSmooth_r = 1;
2648         return 1;
2649 }
2650
2651 static void draw_mesh_fancy(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base, int dt, int flag)
2652 {
2653         Object *ob= base->object;
2654         Mesh *me = ob->data;
2655         Material *ma= give_current_material(ob, 1);
2656         const short hasHaloMat = (ma && (ma->material_type == MA_TYPE_HALO));
2657         const short is_paint_sel= (ob==OBACT && paint_facesel_test(ob));
2658         int draw_wire = 0;
2659         int /* totvert,*/ totedge, totface;
2660         DerivedMesh *dm= mesh_get_derived_final(scene, ob, scene->customdata_mask);
2661
2662         if(!dm)
2663                 return;
2664
2665         if (ob->dtx&OB_DRAWWIRE) {
2666                 draw_wire = 2; /* draw wire after solid using zoffset and depth buffer adjusment */
2667         }
2668
2669         /* totvert = dm->getNumVerts(dm); */ /*UNUSED*/
2670         totedge = dm->getNumEdges(dm);
2671         totface = dm->getNumFaces(dm);
2672
2673         /* vertexpaint, faceselect wants this, but it doesnt work for shaded? */
2674         if(dt!=OB_SHADED)
2675                 glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2676
2677                 // Unwanted combination.
2678         if (is_paint_sel) draw_wire = 0;
2679
2680         if(dt==OB_BOUNDBOX) {
2681                 if((v3d->flag2 & V3D_RENDER_OVERRIDE && v3d->drawtype >= OB_WIRE)==0)
2682                         draw_bounding_volume(scene, ob);
2683         }
2684         else if(hasHaloMat || (totface==0 && totedge==0)) {
2685                 glPointSize(1.5);
2686                 dm->drawVerts(dm);
2687                 glPointSize(1.0);
2688         }
2689         else if(dt==OB_WIRE || totface==0) {
2690                 draw_wire = 1; /* draw wire only, no depth buffer stuff  */
2691         }
2692         else if(        (is_paint_sel || (ob==OBACT && ob->mode & OB_MODE_TEXTURE_PAINT)) ||
2693                                 CHECK_OB_DRAWTEXTURE(v3d, dt))
2694         {
2695                 if ((v3d->flag&V3D_SELECT_OUTLINE) && ((v3d->flag2 & V3D_RENDER_OVERRIDE)==0) && (base->flag&SELECT) && !(G.f&G_PICKSEL || is_paint_sel) && !draw_wire) {
2696                         draw_mesh_object_outline(v3d, ob, dm);
2697                 }
2698
2699                 if(draw_glsl_material(scene, ob, v3d, dt)) {
2700                         glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2701
2702                         dm->drawFacesGLSL(dm, GPU_enable_material);
2703 //                      if(get_ob_property(ob, "Text"))
2704 // XXX                          draw_mesh_text(ob, 1);
2705                         GPU_disable_material();
2706
2707                         glFrontFace(GL_CCW);
2708                 }
2709                 else {
2710                         draw_mesh_textured(scene, v3d, rv3d, ob, dm, is_paint_sel);
2711                 }
2712
2713                 if(!is_paint_sel) {
2714                         if(base->flag & SELECT)
2715                                 UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT);
2716                         else
2717                                 UI_ThemeColor(TH_WIRE);
2718
2719                         if((v3d->flag2 & V3D_RENDER_OVERRIDE)==0)
2720                                 dm->drawLooseEdges(dm);
2721                 }
2722         }
2723         else if(dt==OB_SOLID) {
2724                 if(ob==OBACT && ob && ob->mode & OB_MODE_WEIGHT_PAINT) {
2725                         /* weight paint in solid mode, special case. focus on making the weights clear
2726                          * rather than the shading, this is also forced in wire view */
2727                         GPU_enable_material(0, NULL);
2728                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, me->mface, 1, GPU_enable_material);
2729
2730                         bglPolygonOffset(rv3d->dist, 1.0);
2731                         glDepthMask(0); // disable write in zbuffer, selected edge wires show better
2732
2733                         glEnable(GL_BLEND);
2734                         glColor4ub(255, 255, 255, 96);
2735                         glEnable(GL_LINE_STIPPLE);
2736                         glLineStipple(1, 0xAAAA);
2737
2738                         dm->drawEdges(dm, 1, 1);
2739
2740                         bglPolygonOffset(rv3d->dist, 0.0);
2741                         glDepthMask(1);
2742                         glDisable(GL_LINE_STIPPLE);
2743
2744                         GPU_disable_material();
2745
2746                         /* since we already draw wire as wp guide, dont draw over the top */
2747                         draw_wire= 0;
2748                 }
2749                 else {
2750                         Paint *p;
2751
2752                         if((v3d->flag&V3D_SELECT_OUTLINE) && ((v3d->flag2 & V3D_RENDER_OVERRIDE)==0) && (base->flag&SELECT) && !draw_wire && !ob->sculpt)
2753                                 draw_mesh_object_outline(v3d, ob, dm);
2754
2755                         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, me->flag & ME_TWOSIDED );
2756
2757                         glEnable(GL_LIGHTING);
2758                         glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2759
2760                         if(ob->sculpt && (p=paint_get_active(scene))) {
2761                                 float planes[4][4];
2762                                 float (*fpl)[4] = NULL;
2763                                 int fast= (p->flags & PAINT_FAST_NAVIGATE) && (rv3d->rflag & RV3D_NAVIGATING);
2764
2765                                 if(ob->sculpt->partial_redraw) {
2766                                         if(ar->do_draw & RGN_DRAW_PARTIAL) {
2767                                                 sculpt_get_redraw_planes(planes, ar, rv3d, ob);
2768                                                 fpl = planes;
2769                                                 ob->sculpt->partial_redraw = 0;
2770                                         }
2771                                 }
2772
2773                                 dm->drawFacesSolid(dm, fpl, fast, GPU_enable_material);
2774                         }
2775                         else
2776                                 dm->drawFacesSolid(dm, NULL, 0, GPU_enable_material);
2777
2778                         GPU_disable_material();
2779
2780                         glFrontFace(GL_CCW);
2781                         glDisable(GL_LIGHTING);
2782
2783                         if(base->flag & SELECT) {
2784                                 UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT);
2785                         } else {
2786                                 UI_ThemeColor(TH_WIRE);
2787                         }
2788                         if(!ob->sculpt && (v3d->flag2 & V3D_RENDER_OVERRIDE)==0)
2789                                 dm->drawLooseEdges(dm);
2790                 }
2791         }
2792         else if(dt==OB_SHADED) {
2793                 if(ob==OBACT) {
2794                         if(ob && ob->mode & OB_MODE_WEIGHT_PAINT) {
2795                                 /* enforce default material settings */
2796                                 GPU_enable_material(0, NULL);
2797
2798                                 /* but set default spec */
2799                                 glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
2800                                 glEnable(GL_COLOR_MATERIAL);    /* according manpages needed */
2801                                 glColor3ub(120, 120, 120);
2802                                 glDisable(GL_COLOR_MATERIAL);
2803                                 /* diffuse */
2804                                 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
2805                                 glEnable(GL_LIGHTING);
2806                                 glEnable(GL_COLOR_MATERIAL);
2807
2808                                 dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, me->mface, 1, GPU_enable_material);
2809                                 glDisable(GL_COLOR_MATERIAL);
2810                                 glDisable(GL_LIGHTING);
2811
2812                                 GPU_disable_material();
2813                         }
2814                         else if(ob->mode & (OB_MODE_VERTEX_PAINT|OB_MODE_TEXTURE_PAINT)) {
2815                                 if(me->mcol)
2816                                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, NULL, 1, GPU_enable_material);
2817                                 else {
2818                                         glColor3f(1.0f, 1.0f, 1.0f);
2819                                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, NULL, 0, GPU_enable_material);
2820                                 }
2821                         }
2822                 }
2823         }
2824
2825         /* set default draw color back for wire or for draw-extra later on */
2826         if (dt!=OB_WIRE) {
2827                 if(base->flag & SELECT) {
2828                         if(ob==OBACT && ob->flag & OB_FROMGROUP)
2829                                 UI_ThemeColor(TH_GROUP_ACTIVE);
2830                         else if(ob->flag & OB_FROMGROUP)
2831                                 UI_ThemeColorShade(TH_GROUP_ACTIVE, -16);
2832                         else if(flag!=DRAW_CONSTCOLOR)
2833                                 UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT);
2834                         else
2835                                 glColor3ub(80,80,80);
2836                 } else {
2837                         if (ob->flag & OB_FROMGROUP)
2838                                 UI_ThemeColor(TH_GROUP);
2839                         else {
2840                                 if(ob->dtx & OB_DRAWWIRE && flag==DRAW_CONSTCOLOR)
2841                                         glColor3ub(80,80,80);
2842                                 else
2843                                         UI_ThemeColor(TH_WIRE);
2844                         }
2845                 }
2846         }
2847         if (draw_wire) {
2848
2849                 /* When using wireframe object traw in particle edit mode
2850                  * the mesh gets in the way of seeing the particles, fade the wire color
2851                  * with the background. */
2852                 if(ob==OBACT && (ob->mode & OB_MODE_PARTICLE_EDIT)) {
2853                         float col_wire[4], col_bg[4], col[3];
2854
2855                         UI_GetThemeColor3fv(TH_BACK, col_bg);
2856                         glGetFloatv(GL_CURRENT_COLOR, col_wire);
2857                         interp_v3_v3v3(col, col_bg, col_wire, 0.15);
2858                         glColor3fv(col);
2859                 }
2860
2861                 /* If drawing wire and drawtype is not OB_WIRE then we are
2862                  * overlaying the wires.
2863                  *
2864                  * UPDATE bug #10290 - With this wire-only objects can draw
2865                  * behind other objects depending on their order in the scene. 2x if 0's below. undo'ing zr's commit: r4059
2866                  *
2867                  * if draw wire is 1 then just drawing wire, no need for depth buffer stuff,
2868                  * otherwise this wire is to overlay solid mode faces so do some depth buffer tricks.
2869                  */
2870                 if (dt!=OB_WIRE && draw_wire==2) {
2871                         bglPolygonOffset(rv3d->dist, 1.0);
2872                         glDepthMask(0); // disable write in zbuffer, selected edge wires show better
2873                 }
2874
2875                 if((v3d->flag2 & V3D_RENDER_OVERRIDE && v3d->drawtype >= OB_SOLID)==0)
2876                         dm->drawEdges(dm, (dt==OB_WIRE || totface==0), me->drawflag & ME_ALLEDGES);
2877
2878                 if (dt!=OB_WIRE && draw_wire==2) {
2879                         glDepthMask(1);
2880                         bglPolygonOffset(rv3d->dist, 0.0);
2881                 }
2882         }
2883
2884         dm->release(dm);
2885 }
2886
2887 /* returns 1 if nothing was drawn, for detecting to draw an object center */
2888 static int draw_mesh_object(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base, int dt, int flag)
2889 {
2890         Object *ob= base->object;
2891         Object *obedit= scene->obedit;
2892         Mesh *me= ob->data;
2893         EditMesh *em= me->edit_mesh;
2894         int do_alpha_pass= 0, drawlinked= 0, retval= 0, glsl, check_alpha;
2895
2896         if(obedit && ob!=obedit && ob->data==obedit->data) {
2897                 if(ob_get_key(ob) || ob_get_key(obedit));
2898                 else if(ob->modifiers.first || obedit->modifiers.first);
2899                 else drawlinked= 1;
2900         }
2901
2902         if(ob==obedit || drawlinked) {
2903                 DerivedMesh *finalDM, *cageDM;
2904
2905                 if (obedit!=ob)
2906                         finalDM = cageDM = editmesh_get_derived_base(ob, em);
2907                 else
2908                         cageDM = editmesh_get_derived_cage_and_final(scene, ob, em, &finalDM,
2909                                                                                         scene->customdata_mask);
2910
2911                 if(dt>OB_WIRE) {
2912                         // no transp in editmode, the fancy draw over goes bad then
2913                         glsl = draw_glsl_material(scene, ob, v3d, dt);
2914                         GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl, NULL);
2915                 }
2916
2917                 draw_em_fancy(scene, v3d, rv3d, ob, em, cageDM, finalDM, dt);
2918
2919                 GPU_end_object_materials();
2920
2921                 if (obedit!=ob && finalDM)
2922                         finalDM->release(finalDM);
2923         }
2924         else {
2925                 /* don't create boundbox here with mesh_get_bb(), the derived system will make it, puts deformed bb's OK */
2926                 if(me->totface<=4 || ED_view3d_boundbox_clip(rv3d, ob->obmat, (ob->bb)? ob->bb: me->bb)) {
2927                         glsl = draw_glsl_material(scene, ob, v3d, dt);
2928                         check_alpha = check_material_alpha(base, me, glsl);
2929
2930                         if(dt==OB_SOLID || glsl) {
2931                                 GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl,
2932                                         (check_alpha)? &do_alpha_pass: NULL);
2933                         }
2934
2935                         draw_mesh_fancy(scene, ar, v3d, rv3d, base, dt, flag);
2936
2937                         GPU_end_object_materials();
2938
2939                         if(me->totvert==0) retval= 1;
2940                 }
2941         }
2942
2943         /* GPU_begin_object_materials checked if this is needed */
2944         if(do_alpha_pass) {
2945                 if(ob->dtx & OB_DRAWXRAY) {
2946                         add_view3d_after(&v3d->afterdraw_xraytransp, base, flag);
2947                 }
2948                 else {
2949                         add_view3d_after(&v3d->afterdraw_transp, base, flag);
2950                 }
2951         }
2952         else if(ob->dtx & OB_DRAWXRAY && ob->dtx & OB_DRAWTRANSP) {
2953                 /* special case xray+transp when alpha is 1.0, without this the object vanishes */
2954                 if(v3d->xray == 0 && v3d->transp == 0) {
2955                         add_view3d_after(&v3d->afterdraw_xray, base, flag);
2956                 }
2957         }
2958
2959         return retval;
2960 }
2961
2962 /* ************** DRAW DISPLIST ****************** */
2963
2964 static int draw_index_wire= 1;
2965 static int index3_nors_incr= 1;
2966
2967 /* returns 1 when nothing was drawn */
2968 static int drawDispListwire(ListBase *dlbase)
2969 {
2970         DispList *dl;
2971         int parts, nr;
2972         float *data;
2973
2974         if(dlbase==NULL) return 1;
2975
2976         glEnableClientState(GL_VERTEX_ARRAY);
2977         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
2978
2979         for(dl= dlbase->first; dl; dl= dl->next) {
2980                 if(dl->parts==0 || dl->nr==0)
2981                         continue;
2982
2983                 data= dl->verts;
2984
2985                 switch(dl->type) {
2986                 case DL_SEGM:
2987
2988                         glVertexPointer(3, GL_FLOAT, 0, data);
2989
2990                         for(parts=0; parts<dl->parts; parts++)
2991                                 glDrawArrays(GL_LINE_STRIP, parts*dl->nr, dl->nr);
2992
2993                         break;
2994                 case DL_POLY:
2995
2996                         glVertexPointer(3, GL_FLOAT, 0, data);
2997
2998                         for(parts=0; parts<dl->parts; parts++)
2999                                 glDrawArrays(GL_LINE_LOOP, parts*dl->nr, dl->nr);
3000
3001                         break;
3002                 case DL_SURF:
3003
3004                         glVertexPointer(3, GL_FLOAT, 0, data);
3005
3006                         for(parts=0; parts<dl->parts; parts++) {
3007                                 if(dl->flag & DL_CYCL_U)
3008                                         glDrawArrays(GL_LINE_LOOP, parts*dl->nr, dl->nr);
3009                                 else
3010                                         glDrawArrays(GL_LINE_STRIP, parts*dl->nr, dl->nr);
3011                         }
3012
3013                         for(nr=0; nr<dl->nr; nr++) {
3014                                 int ofs= 3*dl->nr;
3015
3016                                 data= (  dl->verts )+3*nr;
3017                                 parts= dl->parts;
3018
3019                                 if(dl->flag & DL_CYCL_V) glBegin(GL_LINE_LOOP);
3020                                 else glBegin(GL_LINE_STRIP);
3021
3022                                 while(parts--) {
3023                                         glVertex3fv(data);
3024                                         data+=ofs;
3025                                 }
3026                                 glEnd();
3027
3028                                 /* (ton) this code crashes for me when resolv is 86 or higher... no clue */
3029 //                              glVertexPointer(3, GL_FLOAT, sizeof(float)*3*dl->nr, data + 3*nr);
3030 //                              if(dl->flag & DL_CYCL_V)
3031 //                                      glDrawArrays(GL_LINE_LOOP, 0, dl->parts);
3032 //                              else
3033 //                                      glDrawArrays(GL_LINE_STRIP, 0, dl->parts);
3034                         }
3035                         break;
3036
3037                 case DL_INDEX3:
3038                         if(draw_index_wire) {
3039                                 glVertexPointer(3, GL_FLOAT, 0, dl->verts);
3040                                 glDrawElements(GL_TRIANGLES, 3*dl->parts, GL_UNSIGNED_INT, dl->index);
3041                         }
3042                         break;
3043
3044                 case DL_INDEX4:
3045                         if(draw_index_wire) {
3046                                 glVertexPointer(3, GL_FLOAT, 0, dl->verts);
3047                                 glDrawElements(GL_QUADS, 4*dl->parts, GL_UNSIGNED_INT, dl->index);
3048                         }
3049                         break;
3050                 }
3051         }
3052
3053         glDisableClientState(GL_VERTEX_ARRAY);
3054         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
3055
3056         return 0;
3057 }
3058
3059 static void drawDispListsolid(ListBase *lb, Object *ob, int glsl)
3060 {
3061         DispList *dl;
3062         GPUVertexAttribs gattribs;
3063         float *data, curcol[4];
3064         float *ndata;
3065
3066         if(lb==NULL) return;
3067
3068         /* for drawing wire */
3069         glGetFloatv(GL_CURRENT_COLOR, curcol);
3070
3071         glEnable(GL_LIGHTING);
3072         glEnableClientState(GL_VERTEX_ARRAY);
3073
3074         if(ob->transflag & OB_NEG_SCALE) glFrontFace(GL_CW);
3075         else glFrontFace(GL_CCW);
3076
3077         if(ob->type==OB_MBALL) {        // mball always smooth shaded
3078                 glShadeModel(GL_SMOOTH);
3079         }
3080
3081         dl= lb->first;
3082         while(dl) {
3083                 data= dl->verts;
3084                 ndata= dl->nors;
3085
3086                 switch(dl->type) {
3087                 case DL_SEGM:
3088             &nb