Merge with trunk r39750
[blender.git] / 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_dynamicpaint_types.h"
42 #include "DNA_lamp_types.h"
43 #include "DNA_lattice_types.h"
44 #include "DNA_material_types.h"
45 #include "DNA_meshdata_types.h"
46 #include "DNA_meta_types.h"
47 #include "DNA_scene_types.h"
48 #include "DNA_smoke_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 static void lattice_draw_verts(Lattice *lt, DispList *dl, short sel)
1496 {
1497         BPoint *bp = lt->def;
1498         float *co = dl?dl->verts:NULL;
1499         int u, v, w;
1500
1501         UI_ThemeColor(sel?TH_VERTEX_SELECT:TH_VERTEX);
1502         glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE));
1503         bglBegin(GL_POINTS);
1504
1505         for(w=0; w<lt->pntsw; w++) {
1506                 int wxt = (w==0 || w==lt->pntsw-1);
1507                 for(v=0; v<lt->pntsv; v++) {
1508                         int vxt = (v==0 || v==lt->pntsv-1);
1509                         for(u=0; u<lt->pntsu; u++, bp++, co+=3) {
1510                                 int uxt = (u==0 || u==lt->pntsu-1);
1511                                 if(!(lt->flag & LT_OUTSIDE) || uxt || vxt || wxt) {
1512                                         if(bp->hide==0) {
1513                                                 if((bp->f1 & SELECT)==sel) {
1514                                                         bglVertex3fv(dl?co:bp->vec);
1515                                                 }
1516                                         }
1517                                 }
1518                         }
1519                 }
1520         }
1521         
1522         glPointSize(1.0);
1523         bglEnd();       
1524 }
1525
1526 void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, int x, int y), void *userData)
1527 {
1528         Object *obedit= vc->obedit;
1529         Lattice *lt= obedit->data;
1530         BPoint *bp = lt->editlatt->latt->def;
1531         DispList *dl = find_displist(&obedit->disp, DL_VERTS);
1532         float *co = dl?dl->verts:NULL;
1533         int i, N = lt->editlatt->latt->pntsu*lt->editlatt->latt->pntsv*lt->editlatt->latt->pntsw;
1534         short s[2] = {IS_CLIPPED, 0};
1535
1536         ED_view3d_local_clipping(vc->rv3d, obedit->obmat); /* for local clipping lookups */
1537
1538         for (i=0; i<N; i++, bp++, co+=3) {
1539                 if (bp->hide==0) {
1540                         view3d_project_short_clip(vc->ar, dl?co:bp->vec, s, 1);
1541                         if (s[0] != IS_CLIPPED)
1542                                 func(userData, bp, s[0], s[1]);
1543                 }
1544         }
1545 }
1546
1547 static void drawlattice__point(Lattice *lt, DispList *dl, int u, int v, int w, int use_wcol)
1548 {
1549         int index = ((w*lt->pntsv + v)*lt->pntsu) + u;
1550
1551         if(use_wcol) {
1552                 float col[3];
1553                 MDeformWeight *mdw= defvert_find_index (lt->dvert+index, use_wcol-1);
1554                 
1555                 weight_to_rgb(mdw?mdw->weight:0.0f, col, col+1, col+2);
1556                 glColor3fv(col);
1557
1558         }
1559         
1560         if (dl) {
1561                 glVertex3fv(&dl->verts[index*3]);
1562         } else {
1563                 glVertex3fv(lt->def[index].vec);
1564         }
1565 }
1566
1567 /* lattice color is hardcoded, now also shows weightgroup values in edit mode */
1568 static void drawlattice(Scene *scene, View3D *v3d, Object *ob)
1569 {
1570         Lattice *lt= ob->data;
1571         DispList *dl;
1572         int u, v, w;
1573         int use_wcol= 0, is_edit= (lt->editlatt != NULL);
1574
1575         /* now we default make displist, this will modifiers work for non animated case */
1576         if(ob->disp.first==NULL)
1577                 lattice_calc_modifiers(scene, ob);
1578         dl= find_displist(&ob->disp, DL_VERTS);
1579         
1580         if(is_edit) {
1581                 lt= lt->editlatt->latt;
1582
1583                 cpack(0x004000);
1584                 
1585                 if(ob->defbase.first && lt->dvert) {
1586                         use_wcol= ob->actdef;
1587                         glShadeModel(GL_SMOOTH);
1588                 }
1589         }
1590         
1591         glBegin(GL_LINES);
1592         for(w=0; w<lt->pntsw; w++) {
1593                 int wxt = (w==0 || w==lt->pntsw-1);
1594                 for(v=0; v<lt->pntsv; v++) {
1595                         int vxt = (v==0 || v==lt->pntsv-1);
1596                         for(u=0; u<lt->pntsu; u++) {
1597                                 int uxt = (u==0 || u==lt->pntsu-1);
1598
1599                                 if(w && ((uxt || vxt) || !(lt->flag & LT_OUTSIDE))) {
1600                                         drawlattice__point(lt, dl, u, v, w-1, use_wcol);
1601                                         drawlattice__point(lt, dl, u, v, w, use_wcol);
1602                                 }
1603                                 if(v && ((uxt || wxt) || !(lt->flag & LT_OUTSIDE))) {
1604                                         drawlattice__point(lt, dl, u, v-1, w, use_wcol);
1605                                         drawlattice__point(lt, dl, u, v, w, use_wcol);
1606                                 }
1607                                 if(u && ((vxt || wxt) || !(lt->flag & LT_OUTSIDE))) {
1608                                         drawlattice__point(lt, dl, u-1, v, w, use_wcol);
1609                                         drawlattice__point(lt, dl, u, v, w, use_wcol);
1610                                 }
1611                         }
1612                 }
1613         }               
1614         glEnd();
1615         
1616         /* restoration for weight colors */
1617         if(use_wcol)
1618                 glShadeModel(GL_FLAT);
1619
1620         if(is_edit) {
1621                 if(v3d->zbuf) glDisable(GL_DEPTH_TEST);
1622                 
1623                 lattice_draw_verts(lt, dl, 0);
1624                 lattice_draw_verts(lt, dl, 1);
1625                 
1626                 if(v3d->zbuf) glEnable(GL_DEPTH_TEST); 
1627         }
1628 }
1629
1630 /* ***************** ******************** */
1631
1632 /* Note! - foreach funcs should be called while drawing or directly after
1633  * if not, ED_view3d_init_mats_rv3d() can be used for selection tools
1634  * but would not give correct results with dupli's for eg. which dont
1635  * use the object matrix in the useual way */
1636 static void mesh_foreachScreenVert__mapFunc(void *userData, int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
1637 {
1638         struct { void (*func)(void *userData, EditVert *eve, int x, int y, int index); void *userData; ViewContext vc; int clipVerts; } *data = userData;
1639         EditVert *eve = EM_get_vert_for_index(index);
1640
1641         if (eve->h==0) {
1642                 short s[2]= {IS_CLIPPED, 0};
1643
1644                 if (data->clipVerts) {
1645                         view3d_project_short_clip(data->vc.ar, co, s, 1);
1646                 } else {
1647                         view3d_project_short_noclip(data->vc.ar, co, s);
1648                 }
1649
1650                 if (s[0]!=IS_CLIPPED)
1651                         data->func(data->userData, eve, s[0], s[1], index);
1652         }
1653 }
1654
1655 void mesh_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, EditVert *eve, int x, int y, int index), void *userData, int clipVerts)
1656 {
1657         struct { void (*func)(void *userData, EditVert *eve, int x, int y, int index); void *userData; ViewContext vc; int clipVerts; } data;
1658         DerivedMesh *dm = editmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
1659         
1660         data.vc= *vc;
1661         data.func = func;
1662         data.userData = userData;
1663         data.clipVerts = clipVerts;
1664
1665         if(clipVerts)
1666                 ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1667
1668         EM_init_index_arrays(vc->em, 1, 0, 0);
1669         dm->foreachMappedVert(dm, mesh_foreachScreenVert__mapFunc, &data);
1670         EM_free_index_arrays();
1671
1672         dm->release(dm);
1673 }
1674
1675 static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, float *v0co, float *v1co)
1676 {
1677         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;
1678         EditEdge *eed = EM_get_edge_for_index(index);
1679         short s[2][2];
1680
1681         if (eed->h==0) {
1682                 if (data->clipVerts==1) {
1683                         view3d_project_short_clip(data->vc.ar, v0co, s[0], 1);
1684                         view3d_project_short_clip(data->vc.ar, v1co, s[1], 1);
1685                 } else {
1686                         view3d_project_short_noclip(data->vc.ar, v0co, s[0]);
1687                         view3d_project_short_noclip(data->vc.ar, v1co, s[1]);
1688
1689                         if (data->clipVerts==2) {
1690                                 if (!(s[0][0]>=0 && s[0][1]>= 0 && s[0][0]<data->vc.ar->winx && s[0][1]<data->vc.ar->winy))
1691                                         if (!(s[1][0]>=0 && s[1][1]>= 0 && s[1][0]<data->vc.ar->winx && s[1][1]<data->vc.ar->winy)) 
1692                                                 return;
1693                         }
1694                 }
1695
1696                 data->func(data->userData, eed, s[0][0], s[0][1], s[1][0], s[1][1], index);
1697         }
1698 }
1699
1700 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)
1701 {
1702         struct { void (*func)(void *userData, EditEdge *eed, int x0, int y0, int x1, int y1, int index); void *userData; ViewContext vc; int clipVerts; } data;
1703         DerivedMesh *dm = editmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
1704
1705         data.vc= *vc;
1706         data.func = func;
1707         data.userData = userData;
1708         data.clipVerts = clipVerts;
1709
1710         if(clipVerts)
1711                 ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1712
1713         EM_init_index_arrays(vc->em, 0, 1, 0);
1714         dm->foreachMappedEdge(dm, mesh_foreachScreenEdge__mapFunc, &data);
1715         EM_free_index_arrays();
1716
1717         dm->release(dm);
1718 }
1719
1720 static void mesh_foreachScreenFace__mapFunc(void *userData, int index, float *cent, float *UNUSED(no))
1721 {
1722         struct { void (*func)(void *userData, EditFace *efa, int x, int y, int index); void *userData; ViewContext vc; } *data = userData;
1723         EditFace *efa = EM_get_face_for_index(index);
1724         short s[2];
1725
1726         if (efa && efa->h==0 && efa->fgonf!=EM_FGON) {
1727                 view3d_project_short_clip(data->vc.ar, cent, s, 1);
1728
1729                 data->func(data->userData, efa, s[0], s[1], index);
1730         }
1731 }
1732
1733 void mesh_foreachScreenFace(ViewContext *vc, void (*func)(void *userData, EditFace *efa, int x, int y, int index), void *userData)
1734 {
1735         struct { void (*func)(void *userData, EditFace *efa, int x, int y, int index); void *userData; ViewContext vc; } data;
1736         DerivedMesh *dm = editmesh_get_derived_cage(vc->scene, vc->obedit, vc->em, CD_MASK_BAREMESH);
1737
1738         data.vc= *vc;
1739         data.func = func;
1740         data.userData = userData;
1741
1742         //if(clipVerts)
1743         ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1744
1745         EM_init_index_arrays(vc->em, 0, 0, 1);
1746         dm->foreachMappedFaceCenter(dm, mesh_foreachScreenFace__mapFunc, &data);
1747         EM_free_index_arrays();
1748
1749         dm->release(dm);
1750 }
1751
1752 void nurbs_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y), void *userData)
1753 {
1754         Curve *cu= vc->obedit->data;
1755         short s[2] = {IS_CLIPPED, 0};
1756         Nurb *nu;
1757         int i;
1758         ListBase *nurbs= ED_curve_editnurbs(cu);
1759
1760         ED_view3d_local_clipping(vc->rv3d, vc->obedit->obmat); /* for local clipping lookups */
1761
1762         for (nu= nurbs->first; nu; nu=nu->next) {
1763                 if(nu->type == CU_BEZIER) {
1764                         for (i=0; i<nu->pntsu; i++) {
1765                                 BezTriple *bezt = &nu->bezt[i];
1766
1767                                 if(bezt->hide==0) {
1768                                         
1769                                         if(cu->drawflag & CU_HIDE_HANDLES) {
1770                                                 view3d_project_short_clip(vc->ar, bezt->vec[1], s, 1);
1771                                                 if (s[0] != IS_CLIPPED)
1772                                                         func(userData, nu, NULL, bezt, 1, s[0], s[1]);
1773                                         } else {
1774                                                 view3d_project_short_clip(vc->ar, bezt->vec[0], s, 1);
1775                                                 if (s[0] != IS_CLIPPED)
1776                                                         func(userData, nu, NULL, bezt, 0, s[0], s[1]);
1777                                                 view3d_project_short_clip(vc->ar, bezt->vec[1], s, 1);
1778                                                 if (s[0] != IS_CLIPPED)
1779                                                         func(userData, nu, NULL, bezt, 1, s[0], s[1]);
1780                                                 view3d_project_short_clip(vc->ar, bezt->vec[2], s, 1);
1781                                                 if (s[0] != IS_CLIPPED)
1782                                                         func(userData, nu, NULL, bezt, 2, s[0], s[1]);
1783                                         }
1784                                 }
1785                         }
1786                 }
1787                 else {
1788                         for (i=0; i<nu->pntsu*nu->pntsv; i++) {
1789                                 BPoint *bp = &nu->bp[i];
1790
1791                                 if(bp->hide==0) {
1792                                         view3d_project_short_clip(vc->ar, bp->vec, s, 1);
1793                                         if (s[0] != IS_CLIPPED)
1794                                                 func(userData, nu, bp, NULL, -1, s[0], s[1]);
1795                                 }
1796                         }
1797                 }
1798         }
1799 }
1800
1801 /* ************** DRAW MESH ****************** */
1802
1803 /* First section is all the "simple" draw routines, 
1804  * ones that just pass some sort of primitive to GL,
1805  * with perhaps various options to control lighting,
1806  * color, etc.
1807  *
1808  * These routines should not have user interface related
1809  * logic!!!
1810  */
1811
1812 static void draw_dm_face_normals__mapFunc(void *userData, int index, float *cent, float *no)
1813 {
1814         ToolSettings *ts= ((Scene *)userData)->toolsettings;
1815         EditFace *efa = EM_get_face_for_index(index);
1816
1817         if (efa->h==0 && efa->fgonf!=EM_FGON) {
1818                 glVertex3fv(cent);
1819                 glVertex3f(     cent[0] + no[0]*ts->normalsize,
1820                                         cent[1] + no[1]*ts->normalsize,
1821                                         cent[2] + no[2]*ts->normalsize);
1822         }
1823 }
1824 static void draw_dm_face_normals(Scene *scene, DerivedMesh *dm) 
1825 {
1826         glBegin(GL_LINES);
1827         dm->foreachMappedFaceCenter(dm, draw_dm_face_normals__mapFunc, scene);
1828         glEnd();
1829 }
1830
1831 static void draw_dm_face_centers__mapFunc(void *userData, int index, float *cent, float *UNUSED(no))
1832 {
1833         EditFace *efa = EM_get_face_for_index(index);
1834         int sel = *((int*) userData);
1835
1836         if (efa->h==0 && efa->fgonf!=EM_FGON && (efa->f&SELECT)==sel) {
1837                 bglVertex3fv(cent);
1838         }
1839 }
1840 static void draw_dm_face_centers(DerivedMesh *dm, int sel)
1841 {
1842         bglBegin(GL_POINTS);
1843         dm->foreachMappedFaceCenter(dm, draw_dm_face_centers__mapFunc, &sel);
1844         bglEnd();
1845 }
1846
1847 static void draw_dm_vert_normals__mapFunc(void *userData, int index, float *co, float *no_f, short *no_s)
1848 {
1849         Scene *scene= (Scene *)userData;
1850         ToolSettings *ts= scene->toolsettings;
1851         EditVert *eve = EM_get_vert_for_index(index);
1852
1853         if (eve->h==0) {
1854                 glVertex3fv(co);
1855
1856                 if (no_f) {
1857                         glVertex3f(     co[0] + no_f[0]*ts->normalsize,
1858                                                 co[1] + no_f[1]*ts->normalsize,
1859                                                 co[2] + no_f[2]*ts->normalsize);
1860                 } else {
1861                         glVertex3f(     co[0] + no_s[0]*ts->normalsize/32767.0f,
1862                                                 co[1] + no_s[1]*ts->normalsize/32767.0f,
1863                                                 co[2] + no_s[2]*ts->normalsize/32767.0f);
1864                 }
1865         }
1866 }
1867 static void draw_dm_vert_normals(Scene *scene, DerivedMesh *dm) 
1868 {
1869         glBegin(GL_LINES);
1870         dm->foreachMappedVert(dm, draw_dm_vert_normals__mapFunc, scene);
1871         glEnd();
1872 }
1873
1874         /* Draw verts with color set based on selection */
1875 static void draw_dm_verts__mapFunc(void *userData, int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
1876 {
1877         struct { int sel; EditVert *eve_act; } * data = userData;
1878         EditVert *eve = EM_get_vert_for_index(index);
1879
1880         if (eve->h==0 && (eve->f&SELECT)==data->sel) {
1881                 /* draw active larger - need to stop/start point drawing for this :/ */
1882                 if (eve==data->eve_act) {
1883                         float size = UI_GetThemeValuef(TH_VERTEX_SIZE);
1884                         UI_ThemeColor4(TH_EDITMESH_ACTIVE);
1885                         
1886                         bglEnd();
1887                         
1888                         glPointSize(size);
1889                         bglBegin(GL_POINTS);
1890                         bglVertex3fv(co);
1891                         bglEnd();
1892                         
1893                         UI_ThemeColor4(data->sel?TH_VERTEX_SELECT:TH_VERTEX);
1894                         glPointSize(size);
1895                         bglBegin(GL_POINTS);
1896                 } else {
1897                         bglVertex3fv(co);
1898                 }
1899         }
1900 }
1901
1902 static void draw_dm_verts(DerivedMesh *dm, int sel, EditVert *eve_act)
1903 {
1904         struct { int sel; EditVert *eve_act; } data;
1905         data.sel = sel;
1906         data.eve_act = eve_act;
1907
1908         bglBegin(GL_POINTS);
1909         dm->foreachMappedVert(dm, draw_dm_verts__mapFunc, &data);
1910         bglEnd();
1911 }
1912
1913         /* Draw edges with color set based on selection */
1914 static int draw_dm_edges_sel__setDrawOptions(void *userData, int index)
1915 {
1916         EditEdge *eed = EM_get_edge_for_index(index);
1917         //unsigned char **cols = userData, *col;
1918         struct { unsigned char *baseCol, *selCol, *actCol; EditEdge *eed_act; } * data = userData;
1919         unsigned char *col;
1920
1921         if (eed->h==0) {
1922                 if (eed==data->eed_act) {
1923                         glColor4ubv(data->actCol);
1924                 } else {
1925                         if (eed->f&SELECT) {
1926                                 col = data->selCol;
1927                         } else {
1928                                 col = data->baseCol;
1929                         }
1930                         /* no alpha, this is used so a transparent color can disable drawing unselected edges in editmode  */
1931                         if (col[3]==0) return 0;
1932                         
1933                         glColor4ubv(col);
1934                 }
1935                 return 1;
1936         } else {
1937                 return 0;
1938         }
1939 }
1940 static void draw_dm_edges_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditEdge *eed_act) 
1941 {
1942         struct { unsigned char *baseCol, *selCol, *actCol; EditEdge *eed_act; } data;
1943         
1944         data.baseCol = baseCol;
1945         data.selCol = selCol;
1946         data.actCol = actCol;
1947         data.eed_act = eed_act;
1948         dm->drawMappedEdges(dm, draw_dm_edges_sel__setDrawOptions, &data);
1949 }
1950
1951         /* Draw edges */
1952 static int draw_dm_edges__setDrawOptions(void *UNUSED(userData), int index)
1953 {
1954         return EM_get_edge_for_index(index)->h==0;
1955 }
1956 static void draw_dm_edges(DerivedMesh *dm) 
1957 {
1958         dm->drawMappedEdges(dm, draw_dm_edges__setDrawOptions, NULL);
1959 }
1960
1961         /* Draw edges with color interpolated based on selection */
1962 static int draw_dm_edges_sel_interp__setDrawOptions(void *UNUSED(userData), int index)
1963 {
1964         return EM_get_edge_for_index(index)->h==0;
1965 }
1966 static void draw_dm_edges_sel_interp__setDrawInterpOptions(void *userData, int index, float t)
1967 {
1968         EditEdge *eed = EM_get_edge_for_index(index);
1969         unsigned char **cols = userData;
1970         unsigned char *col0 = cols[(eed->v1->f&SELECT)?1:0];
1971         unsigned char *col1 = cols[(eed->v2->f&SELECT)?1:0];
1972
1973         glColor4ub(     col0[0] + (col1[0]-col0[0])*t,
1974                                 col0[1] + (col1[1]-col0[1])*t,
1975                                 col0[2] + (col1[2]-col0[2])*t,
1976                                 col0[3] + (col1[3]-col0[3])*t);
1977 }
1978
1979 static void draw_dm_edges_sel_interp(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol)
1980 {
1981         unsigned char *cols[2];
1982         cols[0]= baseCol;
1983         cols[1]= selCol;
1984         dm->drawMappedEdgesInterp(dm, draw_dm_edges_sel_interp__setDrawOptions, draw_dm_edges_sel_interp__setDrawInterpOptions, cols);
1985 }
1986
1987         /* Draw only seam edges */
1988 static int draw_dm_edges_seams__setDrawOptions(void *UNUSED(userData), int index)
1989 {
1990         EditEdge *eed = EM_get_edge_for_index(index);
1991
1992         return (eed->h==0 && eed->seam);
1993 }
1994 static void draw_dm_edges_seams(DerivedMesh *dm)
1995 {
1996         dm->drawMappedEdges(dm, draw_dm_edges_seams__setDrawOptions, NULL);
1997 }
1998
1999         /* Draw only sharp edges */
2000 static int draw_dm_edges_sharp__setDrawOptions(void *UNUSED(userData), int index)
2001 {
2002         EditEdge *eed = EM_get_edge_for_index(index);
2003
2004         return (eed->h==0 && eed->sharp);
2005 }
2006 static void draw_dm_edges_sharp(DerivedMesh *dm)
2007 {
2008         dm->drawMappedEdges(dm, draw_dm_edges_sharp__setDrawOptions, NULL);
2009 }
2010
2011
2012         /* Draw faces with color set based on selection
2013          * return 2 for the active face so it renders with stipple enabled */
2014 static int draw_dm_faces_sel__setDrawOptions(void *userData, int index, int *UNUSED(drawSmooth_r))
2015 {
2016         struct { unsigned char *cols[3]; EditFace *efa_act; } * data = userData;
2017         EditFace *efa = EM_get_face_for_index(index);
2018         unsigned char *col;
2019         
2020         if (efa->h==0) {
2021                 if (efa == data->efa_act) {
2022                         glColor4ubv(data->cols[2]);
2023                         return 2; /* stipple */
2024                 } else {
2025                         col = data->cols[(efa->f&SELECT)?1:0];
2026                         if (col[3]==0) return 0;
2027                         glColor4ubv(col);
2028                         return 1;
2029                 }
2030         }
2031         return 0;
2032 }
2033
2034 /* also draws the active face */
2035 static void draw_dm_faces_sel(DerivedMesh *dm, unsigned char *baseCol, unsigned char *selCol, unsigned char *actCol, EditFace *efa_act) 
2036 {
2037         struct { unsigned char *cols[3]; EditFace *efa_act; } data;
2038         data.cols[0] = baseCol;
2039         data.cols[1] = selCol;
2040         data.cols[2] = actCol;
2041         data.efa_act = efa_act;
2042
2043         dm->drawMappedFaces(dm, draw_dm_faces_sel__setDrawOptions, &data, 0, GPU_enable_material);
2044 }
2045
2046 static int draw_dm_creases__setDrawOptions(void *UNUSED(userData), int index)
2047 {
2048         EditEdge *eed = EM_get_edge_for_index(index);
2049
2050         if (eed->h==0 && eed->crease != 0.0f) {
2051                 UI_ThemeColorBlend(TH_WIRE, TH_EDGE_CREASE, eed->crease);
2052                 return 1;
2053         } else {
2054                 return 0;
2055         }
2056 }
2057 static void draw_dm_creases(DerivedMesh *dm)
2058 {
2059         glLineWidth(3.0);
2060         dm->drawMappedEdges(dm, draw_dm_creases__setDrawOptions, NULL);
2061         glLineWidth(1.0);
2062 }
2063
2064 static int draw_dm_bweights__setDrawOptions(void *UNUSED(userData), int index)
2065 {
2066         EditEdge *eed = EM_get_edge_for_index(index);
2067
2068         if (eed->h==0 && eed->bweight != 0.0f) {
2069                 UI_ThemeColorBlend(TH_WIRE, TH_EDGE_SELECT, eed->bweight);
2070                 return 1;
2071         } else {
2072                 return 0;
2073         }
2074 }
2075 static void draw_dm_bweights__mapFunc(void *UNUSED(userData), int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
2076 {
2077         EditVert *eve = EM_get_vert_for_index(index);
2078
2079         if (eve->h==0 && eve->bweight != 0.0f) {
2080                 UI_ThemeColorBlend(TH_VERTEX, TH_VERTEX_SELECT, eve->bweight);
2081                 bglVertex3fv(co);
2082         }
2083 }
2084 static void draw_dm_bweights(Scene *scene, DerivedMesh *dm)
2085 {
2086         ToolSettings *ts= scene->toolsettings;
2087
2088         if (ts->selectmode & SCE_SELECT_VERTEX) {
2089                 glPointSize(UI_GetThemeValuef(TH_VERTEX_SIZE) + 2);
2090                 bglBegin(GL_POINTS);
2091                 dm->foreachMappedVert(dm, draw_dm_bweights__mapFunc, NULL);
2092                 bglEnd();
2093         }
2094         else {
2095                 glLineWidth(3.0);
2096                 dm->drawMappedEdges(dm, draw_dm_bweights__setDrawOptions, NULL);
2097                 glLineWidth(1.0);
2098         }
2099 }
2100
2101 /* Second section of routines: Combine first sets to form fancy
2102  * drawing routines (for example rendering twice to get overlays).
2103  *
2104  * Also includes routines that are basic drawing but are too
2105  * specialized to be split out (like drawing creases or measurements).
2106  */
2107
2108 /* EditMesh drawing routines*/
2109
2110 static void draw_em_fancy_verts(Scene *scene, View3D *v3d, Object *obedit, DerivedMesh *cageDM, EditVert *eve_act)
2111 {
2112         ToolSettings *ts= scene->toolsettings;
2113         int sel;
2114
2115         if(v3d->zbuf) glDepthMask(0);           // disable write in zbuffer, zbuf select
2116
2117         for (sel=0; sel<2; sel++) {
2118                 unsigned char col[4], fcol[4];
2119                 int pass;
2120
2121                 UI_GetThemeColor3ubv(sel?TH_VERTEX_SELECT:TH_VERTEX, col);
2122                 UI_GetThemeColor3ubv(sel?TH_FACE_DOT:TH_WIRE, fcol);
2123
2124                 for (pass=0; pass<2; pass++) {
2125                         float size = UI_GetThemeValuef(TH_VERTEX_SIZE);
2126                         float fsize = UI_GetThemeValuef(TH_FACEDOT_SIZE);
2127
2128                         if (pass==0) {
2129                                 if(v3d->zbuf && !(v3d->flag&V3D_ZBUF_SELECT)) {
2130                                         glDisable(GL_DEPTH_TEST);
2131                                                 
2132                                         glEnable(GL_BLEND);
2133                                 } else {
2134                                         continue;
2135                                 }
2136
2137                                 size = (size > 2.1f ? size/2.0f:size);
2138                                 fsize = (fsize > 2.1f ? fsize/2.0f:fsize);
2139                                 col[3] = fcol[3] = 100;
2140                         } else {
2141                                 col[3] = fcol[3] = 255;
2142                         }
2143                                 
2144                         if(ts->selectmode & SCE_SELECT_VERTEX) {
2145                                 glPointSize(size);
2146                                 glColor4ubv(col);
2147                                 draw_dm_verts(cageDM, sel, eve_act);
2148                         }
2149                         
2150                         if(check_ob_drawface_dot(scene, v3d, obedit->dt)) {
2151                                 glPointSize(fsize);
2152                                 glColor4ubv(fcol);
2153                                 draw_dm_face_centers(cageDM, sel);
2154                         }
2155                         
2156                         if (pass==0) {
2157                                 glDisable(GL_BLEND);
2158                                 glEnable(GL_DEPTH_TEST);
2159                         }
2160                 }
2161         }
2162
2163         if(v3d->zbuf) glDepthMask(1);
2164         glPointSize(1.0);
2165 }
2166
2167 static void draw_em_fancy_edges(Scene *scene, View3D *v3d, Mesh *me, DerivedMesh *cageDM, short sel_only, EditEdge *eed_act)
2168 {
2169         ToolSettings *ts= scene->toolsettings;
2170         int pass;
2171         unsigned char wireCol[4], selCol[4], actCol[4];
2172
2173         /* since this function does transparant... */
2174         UI_GetThemeColor4ubv(TH_EDGE_SELECT, selCol);
2175         UI_GetThemeColor4ubv(TH_WIRE, wireCol);
2176         UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, actCol);
2177         
2178         /* when sel only is used, dont render wire, only selected, this is used for
2179          * textured draw mode when the 'edges' option is disabled */
2180         if (sel_only)
2181                 wireCol[3] = 0;
2182
2183         for (pass=0; pass<2; pass++) {
2184                         /* show wires in transparant when no zbuf clipping for select */
2185                 if (pass==0) {
2186                         if (v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT)==0) {
2187                                 glEnable(GL_BLEND);
2188                                 glDisable(GL_DEPTH_TEST);
2189                                 selCol[3] = 85;
2190                                 if (!sel_only) wireCol[3] = 85;
2191                         } else {
2192                                 continue;
2193                         }
2194                 } else {
2195                         selCol[3] = 255;
2196                         if (!sel_only) wireCol[3] = 255;
2197                 }
2198
2199                 if(ts->selectmode == SCE_SELECT_FACE) {
2200                         draw_dm_edges_sel(cageDM, wireCol, selCol, actCol, eed_act);
2201                 }       
2202                 else if( (me->drawflag & ME_DRAWEDGES) || (ts->selectmode & SCE_SELECT_EDGE) ) {        
2203                         if(cageDM->drawMappedEdgesInterp && (ts->selectmode & SCE_SELECT_VERTEX)) {
2204                                 glShadeModel(GL_SMOOTH);
2205                                 draw_dm_edges_sel_interp(cageDM, wireCol, selCol);
2206                                 glShadeModel(GL_FLAT);
2207                         } else {
2208                                 draw_dm_edges_sel(cageDM, wireCol, selCol, actCol, eed_act);
2209                         }
2210                 }
2211                 else {
2212                         if (!sel_only) {
2213                                 glColor4ubv(wireCol);
2214                                 draw_dm_edges(cageDM);
2215                         }
2216                 }
2217
2218                 if (pass==0) {
2219                         glDisable(GL_BLEND);
2220                         glEnable(GL_DEPTH_TEST);
2221                 }
2222         }
2223 }       
2224
2225 static void draw_em_measure_stats(View3D *v3d, RegionView3D *rv3d, Object *ob, EditMesh *em, UnitSettings *unit)
2226 {
2227         Mesh *me= ob->data;
2228         EditEdge *eed;
2229         EditFace *efa;
2230         float v1[3], v2[3], v3[3], v4[3], vmid[3];
2231         float fvec[3];
2232         char val[32]; /* Stores the measurement display text here */
2233         const char *conv_float; /* Use a float conversion matching the grid size */
2234         unsigned char col[4]= {0, 0, 0, 255}; /* color of the text to draw */
2235         float area; /* area of the face */
2236         float grid= unit->system ? unit->scale_length : v3d->grid;
2237         const int do_split= unit->flag & USER_UNIT_OPT_SPLIT;
2238         const int do_global= v3d->flag & V3D_GLOBAL_STATS;
2239         const int do_moving= G.moving;
2240
2241         /* make the precision of the pronted value proportionate to the gridsize */
2242
2243         if (grid < 0.01f)               conv_float= "%.6g";
2244         else if (grid < 0.1f)   conv_float= "%.5g";
2245         else if (grid < 1.0f)   conv_float= "%.4g";
2246         else if (grid < 10.0f)  conv_float= "%.3g";
2247         else                                    conv_float= "%.2g";
2248
2249         if(v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT)==0)
2250                 glDisable(GL_DEPTH_TEST);
2251
2252         if(v3d->zbuf) bglPolygonOffset(rv3d->dist, 5.0f);
2253         
2254         if(me->drawflag & ME_DRAWEXTRA_EDGELEN) {
2255                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_EDGELEN, col);
2256
2257                 for(eed= em->edges.first; eed; eed= eed->next) {
2258                         /* draw non fgon edges, or selected edges, or edges next to selected verts while draging */
2259                         if((eed->h != EM_FGON) && ((eed->f & SELECT) || (do_moving && ((eed->v1->f & SELECT) || (eed->v2->f & SELECT)) ))) {
2260                                 copy_v3_v3(v1, eed->v1->co);
2261                                 copy_v3_v3(v2, eed->v2->co);
2262
2263                                 interp_v3_v3v3(vmid, v1, v2, 0.5f);
2264
2265                                 if(do_global) {
2266                                         mul_mat3_m4_v3(ob->obmat, v1);
2267                                         mul_mat3_m4_v3(ob->obmat, v2);
2268                                 }
2269                                 if(unit->system)
2270                                         bUnit_AsString(val, sizeof(val), len_v3v3(v1, v2)*unit->scale_length, 3, unit->system, B_UNIT_LENGTH, do_split, FALSE);
2271                                 else
2272                                         sprintf(val, conv_float, len_v3v3(v1, v2));
2273
2274                                 view3d_cached_text_draw_add(vmid, val, 0, V3D_CACHE_TEXT_ASCII, col);
2275                         }
2276                 }
2277         }
2278
2279         if(me->drawflag & ME_DRAWEXTRA_FACEAREA) {
2280 // XXX          extern int faceselectedOR(EditFace *efa, int flag);             // editmesh.h shouldn't be in this file... ok for now?
2281                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEAREA, col);
2282                 
2283                 for(efa= em->faces.first; efa; efa= efa->next) {
2284                         if((efa->f & SELECT)) { // XXX || (do_moving && faceselectedOR(efa, SELECT)) ) {
2285                                 copy_v3_v3(v1, efa->v1->co);
2286                                 copy_v3_v3(v2, efa->v2->co);
2287                                 copy_v3_v3(v3, efa->v3->co);
2288                                 if (efa->v4) {
2289                                         copy_v3_v3(v4, efa->v4->co);
2290                                 }
2291                                 if(do_global) {
2292                                         mul_mat3_m4_v3(ob->obmat, v1);
2293                                         mul_mat3_m4_v3(ob->obmat, v2);
2294                                         mul_mat3_m4_v3(ob->obmat, v3);
2295                                         if (efa->v4) mul_mat3_m4_v3(ob->obmat, v4);
2296                                 }
2297                                 
2298                                 if (efa->v4)
2299                                         area=  area_quad_v3(v1, v2, v3, v4);
2300                                 else
2301                                         area = area_tri_v3(v1, v2, v3);
2302
2303                                 if(unit->system)
2304                                         bUnit_AsString(val, sizeof(val), area*unit->scale_length, 3, unit->system, B_UNIT_LENGTH, do_split, FALSE); // XXX should be B_UNIT_AREA
2305                                 else
2306                                         sprintf(val, conv_float, area);
2307
2308                                 view3d_cached_text_draw_add(efa->cent, val, 0, V3D_CACHE_TEXT_ASCII, col);
2309                         }
2310                 }
2311         }
2312
2313         if(me->drawflag & ME_DRAWEXTRA_FACEANG) {
2314                 EditEdge *e1, *e2, *e3, *e4;
2315                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col);
2316                 for(efa= em->faces.first; efa; efa= efa->next) {
2317                         copy_v3_v3(v1, efa->v1->co);
2318                         copy_v3_v3(v2, efa->v2->co);
2319                         copy_v3_v3(v3, efa->v3->co);
2320                         if(efa->v4) {
2321                                 copy_v3_v3(v4, efa->v4->co); 
2322                         }
2323                         else {
2324                                 copy_v3_v3(v4, v3);
2325                         }
2326                         if(do_global) {
2327                                 mul_mat3_m4_v3(ob->obmat, v1);
2328                                 mul_mat3_m4_v3(ob->obmat, v2);
2329                                 mul_mat3_m4_v3(ob->obmat, v3);
2330                                 mul_mat3_m4_v3(ob->obmat, v4); /* intentionally executed even for tri's */
2331                         }
2332                         
2333                         e1= efa->e1;
2334                         e2= efa->e2;
2335                         e3= efa->e3;
2336                         if(efa->e4) e4= efa->e4; else e4= e3;
2337                         
2338                         /* Calculate the angles */
2339                                 
2340                         if( (e4->f & e1->f & SELECT) || (do_moving && (efa->v1->f & SELECT)) ) {
2341                                 /* Vec 1 */
2342                                 sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v4, v1, v2)));
2343                                 interp_v3_v3v3(fvec, efa->cent, efa->v1->co, 0.8f);
2344                                 view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2345                         }
2346                         if( (e1->f & e2->f & SELECT) || (do_moving && (efa->v2->f & SELECT)) ) {
2347                                 /* Vec 2 */
2348                                 sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v1, v2, v3)));
2349                                 interp_v3_v3v3(fvec, efa->cent, efa->v2->co, 0.8f);
2350                                 view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2351                         }
2352                         if( (e2->f & e3->f & SELECT) || (do_moving && (efa->v3->f & SELECT)) ) {
2353                                 /* Vec 3 */
2354                                 if(efa->v4) 
2355                                         sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v2, v3, v4)));
2356                                 else
2357                                         sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v2, v3, v1)));
2358                                 interp_v3_v3v3(fvec, efa->cent, efa->v3->co, 0.8f);
2359                                 view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2360                         }
2361                                 /* Vec 4 */
2362                         if(efa->v4) {
2363                                 if( (e3->f & e4->f & SELECT) || (do_moving && (efa->v4->f & SELECT)) ) {
2364                                         sprintf(val,"%.3g", RAD2DEGF(angle_v3v3v3(v3, v4, v1)));
2365                                         interp_v3_v3v3(fvec, efa->cent, efa->v4->co, 0.8f);
2366                                         view3d_cached_text_draw_add(fvec, val, 0, V3D_CACHE_TEXT_ASCII, col);
2367                                 }
2368                         }
2369                 }
2370         }
2371
2372         /* useful for debugging index vs shape key index */
2373 #if 0
2374         {
2375                 EditVert *eve;
2376                 int j;
2377                 UI_GetThemeColor3ubv(TH_DRAWEXTRA_FACEANG, col);
2378                 for(eve= em->verts.first, j= 0; eve; eve= eve->next, j++) {
2379                         sprintf(val, "%d:%d", j, eve->keyindex);
2380                         view3d_cached_text_draw_add(eve->co, val, 0, V3D_CACHE_TEXT_ASCII, col);
2381                 }
2382         }
2383 #endif
2384
2385         if(v3d->zbuf) {
2386                 glEnable(GL_DEPTH_TEST);
2387                 bglPolygonOffset(rv3d->dist, 0.0f);
2388         }
2389 }
2390
2391 static int draw_em_fancy__setFaceOpts(void *UNUSED(userData), int index, int *UNUSED(drawSmooth_r))
2392 {
2393         EditFace *efa = EM_get_face_for_index(index);
2394
2395         if (efa->h==0) {
2396                 GPU_enable_material(efa->mat_nr+1, NULL);
2397                 return 1;
2398         }
2399         else
2400                 return 0;
2401 }
2402
2403 static int draw_em_fancy__setGLSLFaceOpts(void *UNUSED(userData), int index)
2404 {
2405         EditFace *efa = EM_get_face_for_index(index);
2406
2407         return (efa->h==0);
2408 }
2409
2410 static void draw_em_fancy(Scene *scene, View3D *v3d, RegionView3D *rv3d, Object *ob, EditMesh *em, DerivedMesh *cageDM, DerivedMesh *finalDM, int dt)
2411 {
2412         Mesh *me = ob->data;
2413         EditFace *efa_act = EM_get_actFace(em, 0); /* annoying but active faces is stored differently */
2414         EditEdge *eed_act = NULL;
2415         EditVert *eve_act = NULL;
2416         
2417         if (em->selected.last) {
2418                 EditSelection *ese = em->selected.last;
2419                 /* face is handeled above */
2420                 /*if (ese->type == EDITFACE ) {
2421                         efa_act = (EditFace *)ese->data;
2422                 } else */ if ( ese->type == EDITEDGE ) {
2423                         eed_act = (EditEdge *)ese->data;
2424                 } else if ( ese->type == EDITVERT ) {
2425                         eve_act = (EditVert *)ese->data;
2426                 }
2427         }
2428         
2429         EM_init_index_arrays(em, 1, 1, 1);
2430
2431         if(dt>OB_WIRE) {
2432                 if(CHECK_OB_DRAWTEXTURE(v3d, dt)) {
2433                         if(draw_glsl_material(scene, ob, v3d, dt)) {
2434                                 glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2435
2436                                 finalDM->drawMappedFacesGLSL(finalDM, GPU_enable_material,
2437                                         draw_em_fancy__setGLSLFaceOpts, NULL);
2438                                 GPU_disable_material();
2439
2440                                 glFrontFace(GL_CCW);
2441                         }
2442                         else {
2443                                 draw_mesh_textured(scene, v3d, rv3d, ob, finalDM, 0);
2444                         }
2445                 }
2446                 else {
2447                         /* 3 floats for position, 3 for normal and times two because the faces may actually be quads instead of triangles */
2448                         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, me->flag & ME_TWOSIDED);
2449
2450                         glEnable(GL_LIGHTING);
2451                         glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2452
2453                         finalDM->drawMappedFaces(finalDM, draw_em_fancy__setFaceOpts, NULL, 0, GPU_enable_material);
2454
2455                         glFrontFace(GL_CCW);
2456                         glDisable(GL_LIGHTING);
2457                 }
2458                         
2459                 // Setup for drawing wire over, disable zbuffer
2460                 // write to show selected edge wires better
2461                 UI_ThemeColor(TH_WIRE);
2462
2463                 bglPolygonOffset(rv3d->dist, 1.0);
2464                 glDepthMask(0);
2465         } 
2466         else {
2467                 if (cageDM!=finalDM) {
2468                         UI_ThemeColorBlend(TH_WIRE, TH_BACK, 0.7);
2469                         finalDM->drawEdges(finalDM, 1, 0);
2470                 }
2471         }
2472         
2473         if(me->drawflag & ME_DRAWFACES) {       /* transp faces */
2474                 unsigned char col1[4], col2[4], col3[4];
2475                         
2476                 UI_GetThemeColor4ubv(TH_FACE, col1);
2477                 UI_GetThemeColor4ubv(TH_FACE_SELECT, col2);
2478                 UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, col3);
2479                 
2480                 glEnable(GL_BLEND);
2481                 glDepthMask(0);         // disable write in zbuffer, needed for nice transp
2482                 
2483                 /* dont draw unselected faces, only selected, this is MUCH nicer when texturing */
2484                 if CHECK_OB_DRAWTEXTURE(v3d, dt)
2485                         col1[3] = 0;
2486                 
2487                 draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act);
2488
2489                 glDisable(GL_BLEND);
2490                 glDepthMask(1);         // restore write in zbuffer
2491         } else if (efa_act) {
2492                 /* even if draw faces is off it would be nice to draw the stipple face
2493                  * Make all other faces zero alpha except for the active
2494                  * */
2495                 unsigned char col1[4], col2[4], col3[4];
2496                 col1[3] = col2[3] = 0; /* dont draw */
2497                 UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, col3);
2498                 
2499                 glEnable(GL_BLEND);
2500                 glDepthMask(0);         // disable write in zbuffer, needed for nice transp
2501                 
2502                 draw_dm_faces_sel(cageDM, col1, col2, col3, efa_act);
2503
2504                 glDisable(GL_BLEND);
2505                 glDepthMask(1);         // restore write in zbuffer
2506                 
2507         }
2508
2509         /* here starts all fancy draw-extra over */
2510         if((me->drawflag & ME_DRAWEDGES)==0 && CHECK_OB_DRAWTEXTURE(v3d, dt)) {
2511                 /* we are drawing textures and 'ME_DRAWEDGES' is disabled, dont draw any edges */
2512                 
2513                 /* only draw selected edges otherwise there is no way of telling if a face is selected */
2514                 draw_em_fancy_edges(scene, v3d, me, cageDM, 1, eed_act);
2515                 
2516         } else {
2517                 if(me->drawflag & ME_DRAWSEAMS) {
2518                         UI_ThemeColor(TH_EDGE_SEAM);
2519                         glLineWidth(2);
2520         
2521                         draw_dm_edges_seams(cageDM);
2522         
2523                         glColor3ub(0,0,0);
2524                         glLineWidth(1);
2525                 }
2526                 
2527                 if(me->drawflag & ME_DRAWSHARP) {
2528                         UI_ThemeColor(TH_EDGE_SHARP);
2529                         glLineWidth(2);
2530         
2531                         draw_dm_edges_sharp(cageDM);
2532         
2533                         glColor3ub(0,0,0);
2534                         glLineWidth(1);
2535                 }
2536         
2537                 if(me->drawflag & ME_DRAWCREASES) {
2538                         draw_dm_creases(cageDM);
2539                 }
2540                 if(me->drawflag & ME_DRAWBWEIGHTS) {
2541                         draw_dm_bweights(scene, cageDM);
2542                 }
2543         
2544                 draw_em_fancy_edges(scene, v3d, me, cageDM, 0, eed_act);
2545         }
2546         if(em) {
2547 // XXX          retopo_matrix_update(v3d);
2548
2549                 draw_em_fancy_verts(scene, v3d, ob, cageDM, eve_act);
2550
2551                 if(me->drawflag & ME_DRAWNORMALS) {
2552                         UI_ThemeColor(TH_NORMAL);
2553                         draw_dm_face_normals(scene, cageDM);
2554                 }
2555                 if(me->drawflag & ME_DRAW_VNORMALS) {
2556                         UI_ThemeColor(TH_VNORMAL);
2557                         draw_dm_vert_normals(scene, cageDM);
2558                 }
2559
2560                 if(me->drawflag & (ME_DRAWEXTRA_EDGELEN|ME_DRAWEXTRA_FACEAREA|ME_DRAWEXTRA_FACEANG) && !((v3d->flag2 & V3D_RENDER_OVERRIDE)))
2561                         draw_em_measure_stats(v3d, rv3d, ob, em, &scene->unit);
2562         }
2563
2564         if(dt>OB_WIRE) {
2565                 glDepthMask(1);
2566                 bglPolygonOffset(rv3d->dist, 0.0);
2567                 GPU_disable_material();
2568         }
2569
2570         EM_free_index_arrays();
2571 }
2572
2573 /* Mesh drawing routines */
2574
2575 static void draw_mesh_object_outline(View3D *v3d, Object *ob, DerivedMesh *dm)
2576 {
2577         
2578         if(v3d->transp==0) {    // not when we draw the transparent pass
2579                 glLineWidth(UI_GetThemeValuef(TH_OUTLINE_WIDTH) * 2.0f);
2580                 glDepthMask(0);
2581                 
2582                 /* if transparent, we cannot draw the edges for solid select... edges have no material info.
2583                    drawFacesSolid() doesn't draw the transparent faces */
2584                 if(ob->dtx & OB_DRAWTRANSP) {
2585                         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
2586                         dm->drawFacesSolid(dm, NULL, 0, GPU_enable_material);
2587                         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
2588                         GPU_disable_material();
2589                 }
2590                 else {
2591                         dm->drawEdges(dm, 0, 1);
2592                 }
2593                                         
2594                 glLineWidth(1.0);
2595                 glDepthMask(1);
2596         }
2597 }
2598
2599 static int wpaint__setSolidDrawOptions(void *UNUSED(userData), int UNUSED(index), int *drawSmooth_r)
2600 {
2601         *drawSmooth_r = 1;
2602         return 1;
2603 }
2604
2605 static void draw_mesh_fancy(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base, int dt, int flag)
2606 {
2607         Object *ob= base->object;
2608         Mesh *me = ob->data;
2609         Material *ma= give_current_material(ob, 1);
2610         const short hasHaloMat = (ma && (ma->material_type == MA_TYPE_HALO));
2611         int draw_wire = 0;
2612         int /* totvert,*/ totedge, totface;
2613         DerivedMesh *dm= mesh_get_derived_final(scene, ob, scene->customdata_mask);
2614         ModifierData *md = NULL;
2615         int draw_flags = (ob==OBACT && paint_facesel_test(ob)) ? DRAW_IS_PAINT_SEL : 0;
2616
2617         if(!dm)
2618                 return;
2619
2620         /* check to draw dynamic paint colors */
2621         if ((md = modifiers_findByType(ob, eModifierType_DynamicPaint)))
2622         {
2623                 /* check if target has an active dp modifier    */
2624                 if(md && md->mode & (eModifierMode_Realtime | eModifierMode_Render))                                    
2625                 {
2626                         DynamicPaintModifierData *pmd = (DynamicPaintModifierData *)md;
2627                         /* if canvas is ready to preview vertex colors */
2628                         if (pmd->canvas && pmd->canvas->flags & MOD_DPAINT_PREVIEW_READY &&
2629                                 DM_get_face_data_layer(dm, CD_WEIGHT_MCOL)) {
2630                                 draw_flags |= DRAW_DYNAMIC_PAINT_PREVIEW;
2631                         }
2632                 }
2633         }
2634         
2635         if (ob->dtx&OB_DRAWWIRE) {
2636                 draw_wire = 2; /* draw wire after solid using zoffset and depth buffer adjusment */
2637         }
2638         
2639         /* totvert = dm->getNumVerts(dm); */ /*UNUSED*/
2640         totedge = dm->getNumEdges(dm);
2641         totface = dm->getNumFaces(dm);
2642         
2643         /* vertexpaint, faceselect wants this, but it doesnt work for shaded? */
2644         if(dt!=OB_SHADED)
2645                 glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2646
2647                 // Unwanted combination.
2648         if (draw_flags & DRAW_IS_PAINT_SEL) draw_wire = 0;
2649
2650         if(dt==OB_BOUNDBOX) {
2651                 if((v3d->flag2 & V3D_RENDER_OVERRIDE && v3d->drawtype >= OB_WIRE)==0)
2652                         draw_bounding_volume(scene, ob);
2653         }
2654         else if(hasHaloMat || (totface==0 && totedge==0)) {
2655                 glPointSize(1.5);
2656                 dm->drawVerts(dm);
2657                 glPointSize(1.0);
2658         }
2659         else if(dt==OB_WIRE || totface==0) {
2660                 draw_wire = 1; /* draw wire only, no depth buffer stuff  */
2661         }
2662         else if(        (draw_flags & DRAW_IS_PAINT_SEL || (ob==OBACT && ob->mode & OB_MODE_TEXTURE_PAINT)) ||
2663                                 CHECK_OB_DRAWTEXTURE(v3d, dt))
2664         {
2665                 if ((v3d->flag&V3D_SELECT_OUTLINE) && ((v3d->flag2 & V3D_RENDER_OVERRIDE)==0) && (base->flag&SELECT) && !(G.f&G_PICKSEL || (draw_flags & DRAW_IS_PAINT_SEL)) && !draw_wire) {
2666                         draw_mesh_object_outline(v3d, ob, dm);
2667                 }
2668
2669                 if(draw_glsl_material(scene, ob, v3d, dt) && !(draw_flags & DRAW_DYNAMIC_PAINT_PREVIEW)) {
2670                         glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2671
2672                         dm->drawFacesGLSL(dm, GPU_enable_material);
2673 //                      if(get_ob_property(ob, "Text"))
2674 // XXX                          draw_mesh_text(ob, 1);
2675                         GPU_disable_material();
2676
2677                         glFrontFace(GL_CCW);
2678                 }
2679                 else {
2680                         draw_mesh_textured(scene, v3d, rv3d, ob, dm, draw_flags);
2681                 }
2682
2683                 if(!(draw_flags & DRAW_IS_PAINT_SEL)) {
2684                         if(base->flag & SELECT)
2685                                 UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT);
2686                         else
2687                                 UI_ThemeColor(TH_WIRE);
2688
2689                         if((v3d->flag2 & V3D_RENDER_OVERRIDE)==0)
2690                                 dm->drawLooseEdges(dm);
2691                 }
2692         }
2693         else if(dt==OB_SOLID) {
2694                 if(ob==OBACT && ob && ob->mode & OB_MODE_WEIGHT_PAINT) {
2695                         /* weight paint in solid mode, special case. focus on making the weights clear
2696                          * rather than the shading, this is also forced in wire view */
2697                         GPU_enable_material(0, NULL);
2698                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, me->mface, 1, GPU_enable_material);
2699                 
2700                         bglPolygonOffset(rv3d->dist, 1.0);
2701                         glDepthMask(0); // disable write in zbuffer, selected edge wires show better
2702
2703                         glEnable(GL_BLEND);
2704                         glColor4ub(255, 255, 255, 96);
2705                         glEnable(GL_LINE_STIPPLE);
2706                         glLineStipple(1, 0xAAAA);
2707
2708                         dm->drawEdges(dm, 1, 1);
2709
2710                         bglPolygonOffset(rv3d->dist, 0.0);
2711                         glDepthMask(1);
2712                         glDisable(GL_LINE_STIPPLE);
2713
2714                         GPU_disable_material();
2715                         
2716                         /* since we already draw wire as wp guide, dont draw over the top */
2717                         draw_wire= 0;
2718                 }
2719                 else if (draw_flags & DRAW_DYNAMIC_PAINT_PREVIEW) {
2720                         /* for object selection draws no shade */
2721                         if (flag & (DRAW_PICKING|DRAW_CONSTCOLOR)) {
2722                                 dm->drawFacesSolid(dm, NULL, 0, GPU_enable_material);
2723                         }
2724                         else {
2725                                 /* draw outline */
2726                                 if((v3d->flag&V3D_SELECT_OUTLINE) && ((v3d->flag2 & V3D_RENDER_OVERRIDE)==0) && (base->flag&SELECT) && !draw_wire && !ob->sculpt)
2727                                         draw_mesh_object_outline(v3d, ob, dm);
2728
2729                                 /* materials arent compatible with vertex colors */
2730                                 GPU_end_object_materials();
2731
2732                                 GPU_enable_material(0, NULL);
2733                                 
2734                                 /* set default spec */
2735                                 glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
2736                                 glEnable(GL_COLOR_MATERIAL);    /* according manpages needed */
2737                                 glColor3ub(120, 120, 120);
2738                                 glDisable(GL_COLOR_MATERIAL);
2739                                 /* diffuse */
2740                                 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
2741                                 glEnable(GL_LIGHTING);
2742                                 glEnable(GL_COLOR_MATERIAL);
2743
2744                                 dm->drawMappedFaces(dm, NULL, NULL, 1, GPU_enable_material);
2745                                 glDisable(GL_COLOR_MATERIAL);
2746                                 glDisable(GL_LIGHTING);
2747
2748                                 GPU_disable_material();
2749                         }
2750                 }
2751                 else {
2752                         Paint *p;
2753
2754                         if((v3d->flag&V3D_SELECT_OUTLINE) && ((v3d->flag2 & V3D_RENDER_OVERRIDE)==0) && (base->flag&SELECT) && !draw_wire && !ob->sculpt)
2755                                 draw_mesh_object_outline(v3d, ob, dm);
2756
2757                         glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, me->flag & ME_TWOSIDED );
2758
2759                         glEnable(GL_LIGHTING);
2760                         glFrontFace((ob->transflag&OB_NEG_SCALE)?GL_CW:GL_CCW);
2761
2762                         if(ob->sculpt && (p=paint_get_active(scene))) {
2763                                 float planes[4][4];
2764                                 float (*fpl)[4] = NULL;
2765                                 int fast= (p->flags & PAINT_FAST_NAVIGATE) && (rv3d->rflag & RV3D_NAVIGATING);
2766
2767                                 if(ob->sculpt->partial_redraw) {
2768                                         if(ar->do_draw & RGN_DRAW_PARTIAL) {
2769                                                 sculpt_get_redraw_planes(planes, ar, rv3d, ob);
2770                                                 fpl = planes;
2771                                                 ob->sculpt->partial_redraw = 0;
2772                                         }
2773                                 }
2774
2775                                 dm->drawFacesSolid(dm, fpl, fast, GPU_enable_material);
2776                         }
2777                         else
2778                                 dm->drawFacesSolid(dm, NULL, 0, GPU_enable_material);
2779
2780                         GPU_disable_material();
2781
2782                         glFrontFace(GL_CCW);
2783                         glDisable(GL_LIGHTING);
2784
2785                         if(base->flag & SELECT) {
2786                                 UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT);
2787                         } else {
2788                                 UI_ThemeColor(TH_WIRE);
2789                         }
2790                         if(!ob->sculpt && (v3d->flag2 & V3D_RENDER_OVERRIDE)==0)
2791                                 dm->drawLooseEdges(dm);
2792                 }
2793         }
2794         else if(dt==OB_SHADED) {
2795                 if(ob==OBACT) {
2796                         if(ob && ob->mode & OB_MODE_WEIGHT_PAINT) {
2797                                 /* enforce default material settings */
2798                                 GPU_enable_material(0, NULL);
2799                                 
2800                                 /* but set default spec */
2801                                 glColorMaterial(GL_FRONT_AND_BACK, GL_SPECULAR);
2802                                 glEnable(GL_COLOR_MATERIAL);    /* according manpages needed */
2803                                 glColor3ub(120, 120, 120);
2804                                 glDisable(GL_COLOR_MATERIAL);
2805                                 /* diffuse */
2806                                 glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
2807                                 glEnable(GL_LIGHTING);
2808                                 glEnable(GL_COLOR_MATERIAL);
2809
2810                                 dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, me->mface, 1, GPU_enable_material);
2811                                 glDisable(GL_COLOR_MATERIAL);
2812                                 glDisable(GL_LIGHTING);
2813
2814                                 GPU_disable_material();
2815                         }
2816                         else if(ob->mode & (OB_MODE_VERTEX_PAINT|OB_MODE_TEXTURE_PAINT)) {
2817                                 if(me->mcol)
2818                                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, NULL, 1, GPU_enable_material);
2819                                 else {
2820                                         glColor3f(1.0f, 1.0f, 1.0f);
2821                                         dm->drawMappedFaces(dm, wpaint__setSolidDrawOptions, NULL, 0, GPU_enable_material);
2822                                 }
2823                         }
2824                 }
2825         }
2826         
2827         /* set default draw color back for wire or for draw-extra later on */
2828         if (dt!=OB_WIRE) {
2829                 if(base->flag & SELECT) {
2830                         if(ob==OBACT && ob->flag & OB_FROMGROUP) 
2831                                 UI_ThemeColor(TH_GROUP_ACTIVE);
2832                         else if(ob->flag & OB_FROMGROUP) 
2833                                 UI_ThemeColorShade(TH_GROUP_ACTIVE, -16);
2834                         else if(flag!=DRAW_CONSTCOLOR)
2835                                 UI_ThemeColor((ob==OBACT)?TH_ACTIVE:TH_SELECT);
2836                         else
2837                                 glColor3ub(80,80,80);
2838                 } else {
2839                         if (ob->flag & OB_FROMGROUP) 
2840                                 UI_ThemeColor(TH_GROUP);
2841                         else {
2842                                 if(ob->dtx & OB_DRAWWIRE && flag==DRAW_CONSTCOLOR)
2843                                         glColor3ub(80,80,80);
2844                                 else
2845                                         UI_ThemeColor(TH_WIRE);
2846                         }
2847                 }
2848         }
2849         if (draw_wire) {
2850
2851                 /* When using wireframe object traw in particle edit mode
2852                  * the mesh gets in the way of seeing the particles, fade the wire color
2853                  * with the background. */
2854                 if(ob==OBACT && (ob->mode & OB_MODE_PARTICLE_EDIT)) {
2855                         float col_wire[4], col_bg[4], col[3];
2856
2857                         UI_GetThemeColor3fv(TH_BACK, col_bg);
2858                         glGetFloatv(GL_CURRENT_COLOR, col_wire);
2859                         interp_v3_v3v3(col, col_bg, col_wire, 0.15);
2860                         glColor3fv(col);
2861                 }
2862
2863                 /* If drawing wire and drawtype is not OB_WIRE then we are
2864                  * overlaying the wires.
2865                  *
2866                  * UPDATE bug #10290 - With this wire-only objects can draw
2867                  * behind other objects depending on their order in the scene. 2x if 0's below. undo'ing zr's commit: r4059
2868                  *
2869                  * if draw wire is 1 then just drawing wire, no need for depth buffer stuff,
2870                  * otherwise this wire is to overlay solid mode faces so do some depth buffer tricks.
2871                  */
2872                 if (dt!=OB_WIRE && draw_wire==2) {
2873                         bglPolygonOffset(rv3d->dist, 1.0);
2874                         glDepthMask(0); // disable write in zbuffer, selected edge wires show better
2875                 }
2876                 
2877                 if((v3d->flag2 & V3D_RENDER_OVERRIDE && v3d->drawtype >= OB_SOLID)==0)
2878                         dm->drawEdges(dm, (dt==OB_WIRE || totface==0), me->drawflag & ME_ALLEDGES);
2879
2880                 if (dt!=OB_WIRE && draw_wire==2) {
2881                         glDepthMask(1);
2882                         bglPolygonOffset(rv3d->dist, 0.0);
2883                 }
2884         }
2885
2886         dm->release(dm);
2887 }
2888
2889 /* returns 1 if nothing was drawn, for detecting to draw an object center */
2890 static int draw_mesh_object(Scene *scene, ARegion *ar, View3D *v3d, RegionView3D *rv3d, Base *base, int dt, int flag)
2891 {
2892         Object *ob= base->object;
2893         Object *obedit= scene->obedit;
2894         Mesh *me= ob->data;
2895         EditMesh *em= me->edit_mesh;
2896         int do_alpha_pass= 0, drawlinked= 0, retval= 0, glsl, check_alpha, i;
2897
2898         /* If we are drawing shadows and any of the materials don't cast a shadow,
2899          * then don't draw the object */
2900         if (v3d->flag2 & V3D_RENDER_SHADOW) {
2901                 for(i=0; i<ob->totcol; ++i) {
2902                         Material *ma= give_current_material(ob, i);
2903                         if (ma && !(ma->mode & MA_SHADBUF)) {
2904                                 return 1;
2905                         }
2906                 }
2907         }
2908         
2909         if(obedit && ob!=obedit && ob->data==obedit->data) {
2910                 if(ob_get_key(ob) || ob_get_key(obedit));
2911                 else if(ob->modifiers.first || obedit->modifiers.first);
2912                 else drawlinked= 1;
2913         }
2914         
2915         if(ob==obedit || drawlinked) {
2916                 DerivedMesh *finalDM, *cageDM;
2917                 
2918                 if (obedit!=ob)
2919                         finalDM = cageDM = editmesh_get_derived_base(ob, em);
2920                 else
2921                         cageDM = editmesh_get_derived_cage_and_final(scene, ob, em, &finalDM,
2922                                                                                         scene->customdata_mask);
2923
2924                 if(dt>OB_WIRE) {
2925                         // no transp in editmode, the fancy draw over goes bad then
2926                         glsl = draw_glsl_material(scene, ob, v3d, dt);
2927                         GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl, NULL);
2928                 }
2929
2930                 draw_em_fancy(scene, v3d, rv3d, ob, em, cageDM, finalDM, dt);
2931
2932                 GPU_end_object_materials();
2933
2934                 if (obedit!=ob && finalDM)
2935                         finalDM->release(finalDM);
2936         }
2937         else {
2938                 /* don't create boundbox here with mesh_get_bb(), the derived system will make it, puts deformed bb's OK */
2939                 if(me->totface<=4 || ED_view3d_boundbox_clip(rv3d, ob->obmat, (ob->bb)? ob->bb: me->bb)) {
2940                         glsl = draw_glsl_material(scene, ob, v3d, dt);
2941                         check_alpha = check_material_alpha(base, me, glsl);
2942
2943                         if(dt==OB_SOLID || glsl) {
2944                                 GPU_begin_object_materials(v3d, rv3d, scene, ob, glsl,
2945                                         (check_alpha)? &do_alpha_pass: NULL);
2946                         }
2947
2948                         draw_mesh_fancy(scene, ar, v3d, rv3d, base, dt, flag);
2949
2950                         GPU_end_object_materials();
2951                         
2952                         if(me->totvert==0) retval= 1;
2953                 }
2954         }
2955         
2956         /* GPU_begin_object_materials checked if this is needed */
2957         if(do_alpha_pass) {
2958                 if(ob->dtx & OB_DRAWXRAY) {
2959                         add_view3d_after(&v3d->afterdraw_xraytransp, base, flag);
2960                 }
2961                 else {
2962                         add_view3d_after(&v3d->afterdraw_transp, base, flag);
2963                 }
2964         }
2965         else if(ob->dtx & OB_DRAWXRAY && ob->dtx & OB_DRAWTRANSP) {
2966                 /* special case xray+transp when alpha is 1.0, without this the object vanishes */
2967                 if(v3d->xray == 0 && v3d->transp == 0) {
2968                         add_view3d_after(&v3d->afterdraw_xray, base, flag);
2969                 }
2970         }
2971         
2972         return retval;
2973 }
2974
2975 /* ************** DRAW DISPLIST ****************** */
2976
2977 static int draw_index_wire= 1;
2978 static int index3_nors_incr= 1;
2979
2980 /* returns 1 when nothing was drawn */
2981 static int drawDispListwire(ListBase *dlbase)
2982 {
2983         DispList *dl;
2984         int parts, nr;
2985         float *data;
2986
2987         if(dlbase==NULL) return 1;
2988         
2989         glEnableClientState(GL_VERTEX_ARRAY);
2990         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
2991
2992         for(dl= dlbase->first; dl; dl= dl->next) {
2993                 if(dl->parts==0 || dl->nr==0)
2994                         continue;
2995                 
2996                 data= dl->verts;
2997         
2998                 switch(dl->type) {
2999                 case DL_SEGM:
3000                         
3001                         glVertexPointer(3, GL_FLOAT, 0, data);
3002                         
3003                         for(parts=0; parts<dl->parts; parts++)
3004                                 glDrawArrays(GL_LINE_STRIP, parts*dl->nr, dl->nr);
3005                                 
3006                         break;
3007                 case DL_POLY:
3008                         
3009                         glVertexPointer(3, GL_FLOAT, 0, data);
3010                         
3011                         for(parts=0; parts<dl->parts; parts++)
3012                                 glDrawArrays(GL_LINE_LOOP, parts*dl->nr, dl->nr);
3013                         
3014                         break;
3015                 case DL_SURF:
3016                         
3017                         glVertexPointer(3, GL_FLOAT, 0, data);
3018                         
3019                         for(parts=0; parts<dl->parts; parts++) {
3020                                 if(dl->flag & DL_CYCL_U) 
3021                                         glDrawArrays(GL_LINE_LOOP, parts*dl->nr, dl->nr);
3022                                 else
3023                                         glDrawArrays(GL_LINE_STRIP, parts*dl->nr, dl->nr);
3024                         }
3025                         
3026                         for(nr=0; nr<dl->nr; nr++) {
3027                                 int ofs= 3*dl->nr;
3028                                 
3029                                 data= (  dl->verts )+3*nr;
3030                                 parts= dl->parts;
3031
3032                                 if(dl->flag & DL_CYCL_V) glBegin(GL_LINE_LOOP);
3033                                 else glBegin(GL_LINE_STRIP);
3034                                 
3035                                 while(parts--) {
3036                                         glVertex3fv(data);
3037                                         data+=ofs;
3038                                 }
3039                                 glEnd();
3040                                 
3041                                 /* (ton) this code crashes for me when resolv is 86 or higher... no clue */
3042 //                              glVertexPointer(3, GL_FLOAT, sizeof(float)*3*dl->nr, data + 3*nr);
3043 //                              if(dl->flag & DL_CYCL_V) 
3044 //                                      glDrawArrays(GL_LINE_LOOP, 0, dl->parts);
3045 //                              else
3046 //                                      glDrawArrays(GL_LINE_STRIP, 0, dl->parts);
3047                         }
3048                         break;
3049                         
3050                 case DL_INDEX3:
3051                         if(draw_index_wire) {
3052                                 glVertexPointer(3, GL_FLOAT, 0, dl->verts);
3053                                 glDrawElements(GL_TRIANGLES, 3*dl->parts, GL_UNSIGNED_INT, dl->index);
3054                         }
3055                         break;
3056                         
3057                 case DL_INDEX4:
3058                         if(draw_index_wire) {
3059                                 glVertexPointer(3, GL_FLOAT, 0, dl->verts);
3060                                 glDrawElements(GL_QUADS, 4*dl->parts, GL_UNSIGNED_INT, dl->index);
3061                         }
3062                         break;
3063                 }
3064         }
3065         
3066         glDisableClientState(GL_VERTEX_ARRAY);
3067         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); 
3068         
3069         return 0;
3070 }