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