Bugfix #3434
[blender.git] / source / blender / src / drawview.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 //#define NAN_LINEAR_PHYSICS
34
35 #include <math.h>
36 #include <string.h>
37
38 #ifdef HAVE_CONFIG_H
39 #include <config.h>
40 #endif
41
42 #ifndef WIN32
43 #include <unistd.h>
44 #include <sys/times.h>
45 #else
46 #include <io.h>
47 #endif   
48
49 #include "MEM_guardedalloc.h"
50
51 #include "PIL_time.h"
52
53 #include "BMF_Api.h"
54
55 #include "IMB_imbuf_types.h"
56
57 #include "DNA_action_types.h"
58 #include "DNA_armature_types.h"
59 #include "DNA_camera_types.h"
60 #include "DNA_constraint_types.h"
61 #include "DNA_curve_types.h"
62 #include "DNA_group_types.h"
63 #include "DNA_image_types.h"
64 #include "DNA_lattice_types.h"
65 #include "DNA_mesh_types.h"
66 #include "DNA_meshdata_types.h"
67 #include "DNA_meta_types.h"
68 #include "DNA_object_types.h"
69 #include "DNA_screen_types.h"
70 #include "DNA_texture_types.h"
71 #include "DNA_view3d_types.h"
72 #include "DNA_userdef_types.h"
73 #include "DNA_space_types.h"
74
75 #include "BLI_blenlib.h"
76 #include "BLI_arithb.h"
77 #include "BLI_editVert.h"
78
79 #include "BKE_action.h"
80 #include "BKE_armature.h"
81 #include "BKE_anim.h"
82 #include "BKE_constraint.h"
83 #include "BKE_curve.h"
84 #include "BKE_displist.h"
85 #include "BKE_depsgraph.h"
86 #include "BKE_global.h"
87 #include "BKE_lattice.h"
88 #include "BKE_library.h"
89 #include "BKE_image.h"
90 #include "BKE_ipo.h"
91 #include "BKE_key.h"
92 #include "BKE_main.h"
93 #include "BKE_object.h"
94 #include "BKE_texture.h"
95 #include "BKE_utildefines.h"
96
97 #include "BIF_butspace.h"
98 #include "BIF_drawimage.h"
99 #include "BIF_editgroup.h"
100 #include "BIF_editarmature.h"
101 #include "BIF_editmesh.h"
102 #include "BIF_gl.h"
103 #include "BIF_glutil.h"
104 #include "BIF_interface.h"
105 #include "BIF_mywindow.h"
106 #include "BIF_poseobject.h"
107 #include "BIF_resources.h"
108 #include "BIF_screen.h"
109 #include "BIF_space.h"
110
111 #include "BDR_drawmesh.h"
112 #include "BDR_drawobject.h"
113 #include "BDR_editobject.h"
114 #include "BDR_vpaint.h"
115
116 #include "BSE_drawview.h"
117 #include "BSE_filesel.h"
118 #include "BSE_headerbuttons.h"
119 #include "BSE_seqaudio.h"
120 #include "BSE_trans_types.h"
121 #include "BSE_time.h"
122 #include "BSE_view.h"
123
124 #include "RE_renderconverter.h"
125
126 #include "BPY_extern.h"
127
128 #include "blendef.h"
129 #include "mydevice.h"
130 #include "butspace.h"  // event codes
131
132 #include "BIF_transform.h"
133
134 /* Modules used */
135 #include "render.h"             // for ogl render
136 #include "radio.h"
137
138 /* locals */
139 void drawname(Object *ob);
140 void star_stuff_init_func(void);
141 void star_stuff_vertex_func(float* i);
142 void star_stuff_term_func(void);
143
144 void star_stuff_init_func(void)
145 {
146         cpack(-1);
147         glPointSize(1.0);
148         glBegin(GL_POINTS);
149 }
150 void star_stuff_vertex_func(float* i)
151 {
152         glVertex3fv(i);
153 }
154 void star_stuff_term_func(void)
155 {
156         glEnd();
157 }
158
159 void setalpha_bgpic(BGpic *bgpic)
160 {
161         int x, y, alph;
162         char *rect;
163         
164         alph= (int)(255.0*(1.0-bgpic->blend));
165         
166         rect= (char *)bgpic->rect;
167         for(y=0; y< bgpic->yim; y++) {
168                 for(x= bgpic->xim; x>0; x--, rect+=4) {
169                         rect[3]= alph;
170                 }
171         }
172 }
173
174
175 void default_gl_light(void)
176 {
177         int a;
178         
179         /* initialize */
180         if(U.light[0].flag==0 && U.light[1].flag==0 && U.light[2].flag==0) {
181                 U.light[0].flag= 1;
182                 U.light[0].vec[0]= -0.3; U.light[0].vec[1]= 0.3; U.light[0].vec[2]= 0.9;
183                 U.light[0].col[0]= 0.8; U.light[0].col[1]= 0.8; U.light[0].col[2]= 0.8;
184                 U.light[0].spec[0]= 0.5; U.light[0].spec[1]= 0.5; U.light[0].spec[2]= 0.5;
185                 U.light[0].spec[3]= 1.0;
186                 
187                 U.light[1].flag= 0;
188                 U.light[1].vec[0]= 0.5; U.light[1].vec[1]= 0.5; U.light[1].vec[2]= 0.1;
189                 U.light[1].col[0]= 0.4; U.light[1].col[1]= 0.4; U.light[1].col[2]= 0.8;
190                 U.light[1].spec[0]= 0.3; U.light[1].spec[1]= 0.3; U.light[1].spec[2]= 0.5;
191                 U.light[1].spec[3]= 1.0;
192         
193                 U.light[2].flag= 0;
194                 U.light[2].vec[0]= 0.3; U.light[2].vec[1]= -0.3; U.light[2].vec[2]= -0.2;
195                 U.light[2].col[0]= 0.8; U.light[2].col[1]= 0.5; U.light[2].col[2]= 0.4;
196                 U.light[2].spec[0]= 0.5; U.light[2].spec[1]= 0.4; U.light[2].spec[2]= 0.3;
197                 U.light[2].spec[3]= 1.0;
198         }
199         
200
201         glLightfv(GL_LIGHT0, GL_POSITION, U.light[0].vec); 
202         glLightfv(GL_LIGHT0, GL_DIFFUSE, U.light[0].col); 
203         glLightfv(GL_LIGHT0, GL_SPECULAR, U.light[0].spec); 
204
205         glLightfv(GL_LIGHT1, GL_POSITION, U.light[1].vec); 
206         glLightfv(GL_LIGHT1, GL_DIFFUSE, U.light[1].col); 
207         glLightfv(GL_LIGHT1, GL_SPECULAR, U.light[1].spec); 
208
209         glLightfv(GL_LIGHT2, GL_POSITION, U.light[2].vec); 
210         glLightfv(GL_LIGHT2, GL_DIFFUSE, U.light[2].col); 
211         glLightfv(GL_LIGHT2, GL_SPECULAR, U.light[2].spec); 
212
213         for(a=0; a<8; a++) {
214                 if(a<3) {
215                         if(U.light[a].flag) glEnable(GL_LIGHT0+a);
216                         else glDisable(GL_LIGHT0+a);
217                         
218                         // clear stuff from other opengl lamp usage
219                         glLightf(GL_LIGHT0+a, GL_SPOT_CUTOFF, 180.0);
220                         glLightf(GL_LIGHT0+a, GL_CONSTANT_ATTENUATION, 1.0);
221                         glLightf(GL_LIGHT0+a, GL_LINEAR_ATTENUATION, 0.0);
222                 }
223                 else glDisable(GL_LIGHT0+a);
224         }
225         
226         glDisable(GL_LIGHTING);
227
228         glDisable(GL_COLOR_MATERIAL);
229 }
230
231 /* also called when render 'ogl' */
232 void init_gl_stuff(void)        
233 {
234         float mat_ambient[] = { 0.0, 0.0, 0.0, 0.0 };
235         float mat_specular[] = { 0.5, 0.5, 0.5, 1.0 };
236         float mat_shininess[] = { 35.0 };
237         int a, x, y;
238         GLubyte pat[32*32];
239         const GLubyte *patc= pat;
240         
241         
242         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
243         glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_specular);
244         glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
245         glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
246
247         default_gl_light();
248         
249         /* no local viewer, looks ugly in ortho mode */
250         /* glLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, &one); */
251         
252         glDepthFunc(GL_LEQUAL);
253         /* scaling matrices */
254         glEnable(GL_NORMALIZE);
255
256         glShadeModel(GL_FLAT);
257
258         glDisable(GL_ALPHA_TEST);
259         glDisable(GL_BLEND);
260         glDisable(GL_DEPTH_TEST);
261         glDisable(GL_FOG);
262         glDisable(GL_LIGHTING);
263         glDisable(GL_LOGIC_OP);
264         glDisable(GL_STENCIL_TEST);
265         glDisable(GL_TEXTURE_1D);
266         glDisable(GL_TEXTURE_2D);
267
268         glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
269         glPixelTransferi(GL_RED_SCALE, 1);
270         glPixelTransferi(GL_RED_BIAS, 0);
271         glPixelTransferi(GL_GREEN_SCALE, 1);
272         glPixelTransferi(GL_GREEN_BIAS, 0);
273         glPixelTransferi(GL_BLUE_SCALE, 1);
274         glPixelTransferi(GL_BLUE_BIAS, 0);
275         glPixelTransferi(GL_ALPHA_SCALE, 1);
276         glPixelTransferi(GL_ALPHA_BIAS, 0);
277         
278         glPixelTransferi(GL_DEPTH_BIAS, 0);
279         glPixelTransferi(GL_DEPTH_SCALE, 1);
280         glDepthRange(0.0, 1.0);
281         
282         a= 0;
283         for(x=0; x<32; x++) {
284                 for(y=0; y<4; y++) {
285                         if( (x) & 1) pat[a++]= 0x88;
286                         else pat[a++]= 0x22;
287                 }
288         }
289         
290         glPolygonStipple(patc);
291
292
293         init_realtime_GL();     
294 }
295
296 void circf(float x, float y, float rad)
297 {
298         GLUquadricObj *qobj = gluNewQuadric(); 
299         
300         gluQuadricDrawStyle(qobj, GLU_FILL); 
301         
302         glPushMatrix(); 
303         
304         glTranslatef(x,  y, 0.); 
305         
306         gluDisk( qobj, 0.0,  rad, 32, 1); 
307         
308         glPopMatrix(); 
309         
310         gluDeleteQuadric(qobj);
311 }
312
313 void circ(float x, float y, float rad)
314 {
315         GLUquadricObj *qobj = gluNewQuadric(); 
316         
317         gluQuadricDrawStyle(qobj, GLU_SILHOUETTE); 
318         
319         glPushMatrix(); 
320         
321         glTranslatef(x,  y, 0.); 
322         
323         gluDisk( qobj, 0.0,  rad, 32, 1); 
324         
325         glPopMatrix(); 
326         
327         gluDeleteQuadric(qobj);
328 }
329
330 /* **********  ********** */
331
332 static void draw_bgpic(void)
333 {
334         BGpic *bgpic;
335         Image *ima;
336         float vec[4], fac, asp, zoomx, zoomy;
337         float x1, y1, x2, y2, cx, cy;
338         
339         bgpic= G.vd->bgpic;
340         if(bgpic==0) return;
341         
342         if(bgpic->tex) {
343                 init_render_texture(bgpic->tex);
344                 free_unused_animimages();
345                 ima= bgpic->tex->ima;
346                 end_render_texture(bgpic->tex);
347         }
348         else {
349                 ima= bgpic->ima;
350         }
351         
352         if(ima==0) return;
353         if(ima->ok==0) return;
354
355         tag_image_time(ima);
356         
357         /* test for image */
358         if(ima->ibuf==0) {
359         
360                 if(bgpic->rect) MEM_freeN(bgpic->rect);
361                 bgpic->rect= 0;
362                 
363                 if(bgpic->tex) {
364                         ima_ibuf_is_nul(bgpic->tex, bgpic->tex->ima);
365                 }
366                 else {
367                         waitcursor(1);
368                         load_image(ima, IB_rect, G.sce, G.scene->r.cfra);
369                         waitcursor(0);
370                 }
371                 if(ima->ibuf==0) {
372                         ima->ok= 0;
373                         return;
374                 }
375         }
376
377         if(bgpic->rect==0) {
378                 
379                 bgpic->rect= MEM_dupallocN(ima->ibuf->rect);
380                 bgpic->xim= ima->ibuf->x;
381                 bgpic->yim= ima->ibuf->y;
382                 setalpha_bgpic(bgpic);
383         }
384
385         if(G.vd->persp==2) {
386                 rcti vb;
387
388                 calc_viewborder(G.vd, &vb);
389
390                 x1= vb.xmin;
391                 y1= vb.ymin;
392                 x2= vb.xmax;
393                 y2= vb.ymax;
394         }
395         else {
396                 float sco[2];
397
398                 /* calc window coord */
399                 initgrabz(0.0, 0.0, 0.0);
400                 window_to_3d(vec, 1, 0);
401                 fac= MAX3( fabs(vec[0]), fabs(vec[1]), fabs(vec[1]) );
402                 fac= 1.0/fac;
403         
404                 asp= ( (float)ima->ibuf->y)/(float)ima->ibuf->x;
405
406                 vec[0] = vec[1] = vec[2] = 0.0;
407                 view3d_project_float(curarea, vec, sco, G.vd->persmat);
408                 cx = sco[0];
409                 cy = sco[1];
410         
411                 x1=  cx+ fac*(bgpic->xof-bgpic->size);
412                 y1=  cy+ asp*fac*(bgpic->yof-bgpic->size);
413                 x2=  cx+ fac*(bgpic->xof+bgpic->size);
414                 y2=  cy+ asp*fac*(bgpic->yof+bgpic->size);
415         }
416         
417         /* complete clip? */
418         
419         if(x2 < 0 ) return;
420         if(y2 < 0 ) return;
421         if(x1 > curarea->winx ) return;
422         if(y1 > curarea->winy ) return;
423         
424         zoomx= (x2-x1)/ima->ibuf->x;
425         zoomy= (y2-y1)/ima->ibuf->y;
426
427         glEnable(GL_BLEND);
428         if(G.vd->zbuf) glDisable(GL_DEPTH_TEST);
429
430         glBlendFunc(GL_SRC_ALPHA,  GL_ONE_MINUS_SRC_ALPHA); 
431          
432         glMatrixMode(GL_PROJECTION);
433         glPushMatrix();
434         glMatrixMode(GL_MODELVIEW);
435         glPushMatrix();
436         
437         glaDefine2DArea(&curarea->winrct);
438         glPixelZoom(zoomx, zoomy);
439         glaDrawPixelsSafe(x1, y1, ima->ibuf->x, ima->ibuf->y, bgpic->rect);
440         glPixelZoom(1.0, 1.0);
441
442         glMatrixMode(GL_PROJECTION);
443         glPopMatrix();
444         glMatrixMode(GL_MODELVIEW);
445         glPopMatrix();
446         
447         glBlendFunc(GL_ONE,  GL_ZERO); 
448         glDisable(GL_BLEND);
449         if(G.vd->zbuf) glEnable(GL_DEPTH_TEST);
450         
451         areawinset(curarea->win);       // restore viewport / scissor
452 }
453
454 void timestr(double time, char *str)
455 {
456         /* format 00:00:00.00 (hr:min:sec) string has to be 12 long */
457         int  hr= (int)      time/(60*60);
458         int min= (int) fmod(time/60, 60.0);
459         int sec= (int) fmod(time, 60.0);
460         int hun= (int) fmod(time*100.0, 100.0);
461
462         if (hr) {
463                 sprintf(str, "%.2d:%.2d:%.2d.%.2d",hr,min,sec,hun);
464         } else {
465                 sprintf(str, "%.2d:%.2d.%.2d",min,sec,hun);
466         }
467
468         str[11]=0;
469 }
470
471 static void drawgrid_draw(float wx, float wy, float x, float y, float dx)
472 {
473         float fx, fy;
474         
475         x+= (wx); 
476         y+= (wy);
477         fx= x/dx;
478         fx= x-dx*floor(fx);
479         
480         while(fx< curarea->winx) {
481                 fdrawline(fx,  0.0,  fx,  (float)curarea->winy); 
482                 fx+= dx; 
483         }
484
485         fy= y/dx;
486         fy= y-dx*floor(fy);
487         
488
489         while(fy< curarea->winy) {
490                 fdrawline(0.0,  fy,  (float)curarea->winx,  fy); 
491                 fy+= dx;
492         }
493
494 }
495
496 // not intern, called in editobject for constraint axis too
497 void make_axis_color(char *col, char *col2, char axis)
498 {
499         if(axis=='x') {
500                 col2[0]= col[0]>219?255:col[0]+36;
501                 col2[1]= col[1]<26?0:col[1]-26;
502                 col2[2]= col[2]<26?0:col[2]-26;
503         }
504         else if(axis=='y') {
505                 col2[0]= col[0]<46?0:col[0]-36;
506                 col2[1]= col[1]>189?255:col[1]+66;
507                 col2[2]= col[2]<46?0:col[2]-36; 
508         }
509         else {
510                 col2[0]= col[0]<26?0:col[0]-26; 
511                 col2[1]= col[1]<26?0:col[1]-26; 
512                 col2[2]= col[2]>209?255:col[2]+46;
513         }
514         
515 }
516
517 static void drawgrid(void)
518 {
519         /* extern short bgpicmode; */
520         float wx, wy, x, y, fw, fx, fy, dx;
521         float vec4[4];
522         char col[3], col2[3];
523         
524         vec4[0]=vec4[1]=vec4[2]=0.0; 
525         vec4[3]= 1.0;
526         Mat4MulVec4fl(G.vd->persmat, vec4);
527         fx= vec4[0]; 
528         fy= vec4[1]; 
529         fw= vec4[3];
530
531         wx= (curarea->winx/2.0);        /* because of rounding errors, grid at wrong location */
532         wy= (curarea->winy/2.0);
533
534         x= (wx)*fx/fw;
535         y= (wy)*fy/fw;
536
537         vec4[0]=vec4[1]=G.vd->grid; 
538         vec4[2]= 0.0;
539         vec4[3]= 1.0;
540         Mat4MulVec4fl(G.vd->persmat, vec4);
541         fx= vec4[0]; 
542         fy= vec4[1]; 
543         fw= vec4[3];
544
545         dx= fabs(x-(wx)*fx/fw);
546         if(dx==0) dx= fabs(y-(wy)*fy/fw);
547         
548         glDepthMask(0);         // disable write in zbuffer
549
550         /* check zoom out */
551         BIF_ThemeColor(TH_GRID);
552         persp(PERSP_WIN);
553         
554         if(dx<6.0) {
555                 G.vd->gridview*= 10.0;
556                 dx*= 10.0;
557                 
558                 if(dx<6.0) {    
559                         G.vd->gridview*= 10.0;
560                         dx*= 10.0;
561                         
562                         if(dx<6.0) {
563                                 G.vd->gridview*= 10.0;
564                                 dx*=10;
565                                 if(dx<6.0);
566                                 else {
567                                         BIF_ThemeColor(TH_GRID);
568                                         drawgrid_draw(wx, wy, x, y, dx);
569                                 }
570                         }
571                         else {  // start blending out
572                                 BIF_ThemeColorBlend(TH_BACK, TH_GRID, dx/60.0);
573                                 drawgrid_draw(wx, wy, x, y, dx);
574                         
575                                 BIF_ThemeColor(TH_GRID);
576                                 drawgrid_draw(wx, wy, x, y, 10*dx);
577                         }
578                 }
579                 else {  // start blending out (6 < dx < 60)
580                         BIF_ThemeColorBlend(TH_BACK, TH_GRID, dx/60.0);
581                         drawgrid_draw(wx, wy, x, y, dx);
582                         
583                         BIF_ThemeColor(TH_GRID);
584                         drawgrid_draw(wx, wy, x, y, 10*dx);
585                 }
586         }
587         else {
588                 if(dx>60.0) {           // start blending in
589                         G.vd->gridview/= 10.0;
590                         dx/= 10.0;                      
591                         if(dx>60.0) {           // start blending in
592                                 G.vd->gridview/= 10.0;
593                                 dx/= 10.0;
594                                 if(dx>60.0) {
595                                         BIF_ThemeColor(TH_GRID);
596                                         drawgrid_draw(wx, wy, x, y, dx);
597                                 }
598                                 else {
599                                         BIF_ThemeColorBlend(TH_BACK, TH_GRID, dx/60.0);
600                                         drawgrid_draw(wx, wy, x, y, dx);
601                                         BIF_ThemeColor(TH_GRID);
602                                         drawgrid_draw(wx, wy, x, y, dx*10);
603                                 }
604                         }
605                         else {
606                                 BIF_ThemeColorBlend(TH_BACK, TH_GRID, dx/60.0);
607                                 drawgrid_draw(wx, wy, x, y, dx);
608                                 BIF_ThemeColor(TH_GRID);                                
609                                 drawgrid_draw(wx, wy, x, y, dx*10);
610                         }
611                 }
612                 else {
613                         BIF_ThemeColorBlend(TH_BACK, TH_GRID, dx/60.0);
614                         drawgrid_draw(wx, wy, x, y, dx);
615                         BIF_ThemeColor(TH_GRID);
616                         drawgrid_draw(wx, wy, x, y, dx*10);
617                 }
618         }
619
620         x+= (wx); 
621         y+= (wy);
622         BIF_GetThemeColor3ubv(TH_GRID, col);
623
624         setlinestyle(0);
625         
626         /* center cross */
627         if(G.vd->view==3) make_axis_color(col, col2, 'y');
628         else make_axis_color(col, col2, 'x');
629         glColor3ubv(col2);
630         
631         fdrawline(0.0,  y,  (float)curarea->winx,  y); 
632         
633         if(G.vd->view==7) make_axis_color(col, col2, 'y');
634         else make_axis_color(col, col2, 'z');
635         glColor3ubv(col2);
636
637         fdrawline(x, 0.0, x, (float)curarea->winy); 
638
639         glDepthMask(1);         // enable write in zbuffer
640         persp(PERSP_VIEW);
641 }
642
643
644 static void drawfloor(void)
645 {
646         View3D *vd;
647         float vert[3], grid;
648         int a, gridlines;
649         char col[3], col2[3];
650         short draw_line = 0;
651                 
652         vd= curarea->spacedata.first;
653
654         vert[2]= 0.0;
655
656         if(vd->gridlines<3) return;
657         
658         if(G.vd->zbuf && G.obedit) glDepthMask(0);      // for zbuffer-select
659         
660         gridlines= vd->gridlines/2;
661         grid= gridlines*vd->grid;
662         
663         BIF_GetThemeColor3ubv(TH_GRID, col);
664         
665         /* draw the Y axis and/or grid lines */
666         for(a= -gridlines;a<=gridlines;a++) {
667                 if(a==0) {
668                         /* check for the 'show Y axis' preference */
669                         if (vd->gridflag & V3D_SHOW_Y) { 
670                                 make_axis_color(col, col2, 'y');
671                                 glColor3ubv(col2);
672                                 
673                                 draw_line = 1;
674                         } else if (vd->gridflag & V3D_SHOW_FLOOR) {
675                                 BIF_ThemeColorShade(TH_GRID, -10);
676                         } else {
677                                 draw_line = 0;
678                         }
679                 } else {
680                         /* check for the 'show grid floor' preference */
681                         if (vd->gridflag & V3D_SHOW_FLOOR) {
682                                 if( (a % 10)==0) {
683                                         BIF_ThemeColorShade(TH_GRID, -10);
684                                 }
685                                 else BIF_ThemeColorShade(TH_GRID, 10);
686                                 
687                                 draw_line = 1;
688                         } else {
689                                 draw_line = 0;
690                         }
691                 }
692                 
693                 if (draw_line) {
694                         glBegin(GL_LINE_STRIP);
695                 vert[0]= a*vd->grid;
696                 vert[1]= grid;
697                 glVertex3fv(vert);
698                 vert[1]= -grid;
699                 glVertex3fv(vert);
700                         glEnd();
701                 }
702         }
703         
704         /* draw the X axis and/or grid lines */
705         for(a= -gridlines;a<=gridlines;a++) {
706                 if(a==0) {
707                         /* check for the 'show X axis' preference */
708                         if (vd->gridflag & V3D_SHOW_X) { 
709                                 make_axis_color(col, col2, 'x');
710                                 glColor3ubv(col2);
711                                 
712                                 draw_line = 1;
713                         } else if (vd->gridflag & V3D_SHOW_FLOOR) {
714                                 BIF_ThemeColorShade(TH_GRID, -10);
715                         } else {
716                                 draw_line = 0;
717                         }
718                 } else {
719                         /* check for the 'show grid floor' preference */
720                         if (vd->gridflag & V3D_SHOW_FLOOR) {
721                                 if( (a % 10)==0) {
722                                         BIF_ThemeColorShade(TH_GRID, -10);
723                                 }
724                                 else BIF_ThemeColorShade(TH_GRID, 10);
725                                 
726                                 draw_line = 1;
727                         } else {
728                                 draw_line = 0;
729                         }
730                 }
731                 
732                 if (draw_line) {
733                         glBegin(GL_LINE_STRIP);
734                 vert[1]= a*vd->grid;
735                 vert[0]= grid;
736                 glVertex3fv(vert );
737                 vert[0]= -grid;
738                 glVertex3fv(vert);
739                         glEnd();
740                 }
741         }
742         
743         /* draw the Z axis line */      
744         /* check for the 'show Z axis' preference */
745         if (vd->gridflag & V3D_SHOW_Z) {
746                 make_axis_color(col, col2, 'z');
747                 glColor3ubv(col2);
748                 
749                 glBegin(GL_LINE_STRIP);
750                 vert[0]= 0;
751                 vert[1]= 0;
752                 vert[2]= grid;
753                 glVertex3fv(vert );
754                 vert[2]= -grid;
755                 glVertex3fv(vert);
756                 glEnd();
757         }
758
759         if(G.vd->zbuf && G.obedit) glDepthMask(1);      
760
761 }
762
763 static void drawcursor(View3D *v3d)
764 {
765         short mx,my,co[2];
766         int flag;
767         
768         /* we dont want the clipping for cursor */
769         flag= v3d->flag;
770         v3d->flag= 0;
771         project_short( give_cursor(), co);
772         v3d->flag= flag;
773         
774         mx = co[0];
775         my = co[1];
776
777         if(mx!=IS_CLIPPED) {
778                 setlinestyle(0); 
779                 cpack(0xFF);
780                 circ((float)mx, (float)my, 10.0);
781                 setlinestyle(4); 
782                 cpack(0xFFFFFF);
783                 circ((float)mx, (float)my, 10.0);
784                 setlinestyle(0);
785                 cpack(0x0);
786                 
787                 sdrawline(mx-20, my, mx-5, my);
788                 sdrawline(mx+5, my, mx+20, my);
789                 sdrawline(mx, my-20, mx, my-5);
790                 sdrawline(mx, my+5, mx, my+20);
791         }
792 }
793
794 /* ********* custom clipping *********** */
795
796 static void view3d_draw_clipping(View3D *v3d)
797 {
798         BoundBox *bb= v3d->clipbb;
799         
800         BIF_ThemeColorShade(TH_BACK, -8);
801         
802         glBegin(GL_QUADS);
803
804         glVertex3fv(bb->vec[0]); glVertex3fv(bb->vec[1]); glVertex3fv(bb->vec[2]); glVertex3fv(bb->vec[3]);
805         glVertex3fv(bb->vec[0]); glVertex3fv(bb->vec[4]); glVertex3fv(bb->vec[5]); glVertex3fv(bb->vec[1]);
806         glVertex3fv(bb->vec[4]); glVertex3fv(bb->vec[7]); glVertex3fv(bb->vec[6]); glVertex3fv(bb->vec[5]);
807         glVertex3fv(bb->vec[7]); glVertex3fv(bb->vec[3]); glVertex3fv(bb->vec[2]); glVertex3fv(bb->vec[6]);
808         glVertex3fv(bb->vec[1]); glVertex3fv(bb->vec[5]); glVertex3fv(bb->vec[6]); glVertex3fv(bb->vec[2]);
809         glVertex3fv(bb->vec[7]); glVertex3fv(bb->vec[4]); glVertex3fv(bb->vec[0]); glVertex3fv(bb->vec[3]);
810         
811         glEnd();
812 }
813
814 void view3d_set_clipping(View3D *v3d)
815 {
816         double plane[4];
817         int a;
818         
819         for(a=0; a<4; a++) {
820                 QUATCOPY(plane, v3d->clip[a]);
821                 glClipPlane(GL_CLIP_PLANE0+a, plane);
822                 glEnable(GL_CLIP_PLANE0+a);
823         }
824 }
825
826 void view3d_clr_clipping(void)
827 {
828         int a;
829         
830         for(a=0; a<4; a++) {
831                 glDisable(GL_CLIP_PLANE0+a);
832         }
833 }
834
835 int view3d_test_clipping(View3D *v3d, float *vec)
836 {
837         /* vec in world coordinates, returns 1 if clipped */
838         float view[3];
839         
840         VECCOPY(view, vec);
841         
842         if(0.0f < v3d->clip[0][3] + INPR(view, v3d->clip[0]))
843                 if(0.0f < v3d->clip[1][3] + INPR(view, v3d->clip[1]))
844                         if(0.0f < v3d->clip[2][3] + INPR(view, v3d->clip[2]))
845                                 if(0.0f < v3d->clip[3][3] + INPR(view, v3d->clip[3]))
846                                         return 0;
847
848         return 1;
849 }
850
851 /* ********* end custom clipping *********** */
852
853 static void view3d_get_viewborder_size(View3D *v3d, float size_r[2])
854 {
855         float winmax= MAX2(v3d->area->winx, v3d->area->winy);
856         float aspect= (float) (G.scene->r.xsch*G.scene->r.xasp)/(G.scene->r.ysch*G.scene->r.yasp);
857
858         if(aspect>1.0) {
859                 size_r[0]= winmax;
860                 size_r[1]= winmax/aspect;
861         } else {
862                 size_r[0]= winmax*aspect;
863                 size_r[1]= winmax;
864         }
865 }
866
867 void calc_viewborder(struct View3D *v3d, rcti *viewborder_r)
868 {
869         float zoomfac, size[2];
870
871         view3d_get_viewborder_size(v3d, size);
872
873                 /* magic zoom calculation, no idea what
874              * it signifies, if you find out, tell me! -zr
875                  */
876         /* simple, its magic dude!
877          * well, to be honest, this gives a natural feeling zooming
878          * with multiple keypad presses (ton)
879          */
880         
881         zoomfac= (M_SQRT2 + v3d->camzoom/50.0);
882         zoomfac= (zoomfac*zoomfac)*0.25;
883         
884         size[0]= size[0]*zoomfac;
885         size[1]= size[1]*zoomfac;
886
887                 /* center in window */
888         viewborder_r->xmin= 0.5*v3d->area->winx - 0.5*size[0];
889         viewborder_r->ymin= 0.5*v3d->area->winy - 0.5*size[1];
890         viewborder_r->xmax= viewborder_r->xmin + size[0];
891         viewborder_r->ymax= viewborder_r->ymin + size[1];
892 }
893
894 void view3d_set_1_to_1_viewborder(View3D *v3d)
895 {
896         float size[2];
897         int im_width= (G.scene->r.size*G.scene->r.xsch)/100;
898
899         view3d_get_viewborder_size(v3d, size);
900
901         v3d->camzoom= (sqrt(4.0*im_width/size[0]) - M_SQRT2)*50.0;
902         v3d->camzoom= CLAMPIS(v3d->camzoom, -30, 300);
903 }
904
905 static void drawviewborder(void)
906 {
907         extern void gl_round_box(int mode, float minx, float miny, float maxx, float maxy, float rad);          // interface_panel.c
908         float fac, a;
909         float x1, x2, y1, y2;
910         float x3, y3, x4, y4;
911         rcti viewborder;
912         Camera *ca;
913
914         ca = G.vd->camera->data;
915         if (ca==NULL) return;
916         
917         calc_viewborder(G.vd, &viewborder);
918         x1= viewborder.xmin;
919         y1= viewborder.ymin;
920         x2= viewborder.xmax;
921         y2= viewborder.ymax;
922
923         /* passepartout, specified in camera edit buttons */
924         if (ca->flag & CAM_SHOWPASSEPARTOUT) {
925                 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
926                 glEnable(GL_BLEND);
927                 glColor4f(0, 0, 0, ca->passepartalpha);
928                 
929                 if (x1 > 0.0) {
930                         glRectf(0.0, (float)curarea->winy, x1, 0.0);
931                         glRectf(x2, (float)curarea->winy, (float)curarea->winx, 0.0);
932                 }
933                 if (y1 > 0.0)   {
934                         glRectf(x1, (float)curarea->winy, x2, y2);
935                         glRectf(x1, y1, x2, 0.0);
936                 }
937                 glDisable(GL_BLEND);
938         }
939         
940         /* edge */
941         glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
942         
943         setlinestyle(0);
944         BIF_ThemeColor(TH_BACK);
945         glRectf(x1, y1, x2, y2);
946         
947         setlinestyle(3);
948         BIF_ThemeColor(TH_WIRE);
949         glRectf(x1, y1, x2, y2);
950         
951
952         /* camera name */
953         if (ca->flag & CAM_SHOWNAME) {
954                 glRasterPos2f(x1, y1-15);
955                 
956                 BMF_DrawString(G.font, G.vd->camera->id.name+2);
957         }
958
959
960         /* border */
961         if(G.scene->r.mode & R_BORDER) {
962                 
963                 cpack(0);
964                 x3= x1+ G.scene->r.border.xmin*(x2-x1);
965                 y3= y1+ G.scene->r.border.ymin*(y2-y1);
966                 x4= x1+ G.scene->r.border.xmax*(x2-x1);
967                 y4= y1+ G.scene->r.border.ymax*(y2-y1);
968                 
969                 cpack(0x4040FF);
970                 glRectf(x3,  y3,  x4,  y4); 
971         }
972
973         /* safety border */
974         if (ca->flag & CAM_SHOWTITLESAFE) {
975                 fac= 0.1;
976                 
977                 a= fac*(x2-x1);
978                 x1+= a; 
979                 x2-= a;
980         
981                 a= fac*(y2-y1);
982                 y1+= a;
983                 y2-= a;
984         
985                 BIF_ThemeColorBlendShade(TH_WIRE, TH_BACK, 0.25, 0);
986                 
987                 uiSetRoundBox(15);
988                 gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, 12.0);
989         }
990         
991         setlinestyle(0);
992         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
993
994 }
995
996
997 void backdrawview3d(int test)
998 {
999         struct Base *base;
1000
1001         if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT));
1002         else if(G.obedit && G.vd->drawtype>OB_WIRE && (G.vd->flag & V3D_ZBUF_SELECT));
1003         else {
1004                 G.vd->flag &= ~V3D_NEEDBACKBUFDRAW;
1005                 return;
1006         }
1007
1008         if( !(G.vd->flag & V3D_NEEDBACKBUFDRAW) ) return;
1009
1010         if(test) {
1011                 if(qtest()) {
1012                         addafterqueue(curarea->win, BACKBUFDRAW, 1);
1013                         return;
1014                 }
1015         }
1016         persp(PERSP_VIEW);
1017
1018 #ifdef __APPLE__
1019         glDrawBuffer(GL_AUX0);
1020 #endif  
1021         if(G.vd->drawtype > OB_WIRE) G.vd->zbuf= TRUE;
1022         curarea->win_swap &= ~WIN_BACK_OK;
1023         
1024         glDisable(GL_DITHER);
1025
1026         glClearColor(0.0, 0.0, 0.0, 0.0); 
1027         if(G.vd->zbuf) {
1028                 glEnable(GL_DEPTH_TEST);
1029                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1030         }
1031         else {
1032                 glClear(GL_COLOR_BUFFER_BIT);
1033                 glDisable(GL_DEPTH_TEST);
1034         }
1035         
1036         if(G.vd->flag & V3D_CLIPPING)
1037                 view3d_set_clipping(G.vd);
1038         
1039         G.f |= G_BACKBUFSEL;
1040         
1041         base= (G.scene->basact);
1042         if(base && (base->lay & G.vd->lay)) {
1043                 draw_object_backbufsel(base->object);
1044         }
1045
1046         G.vd->flag &= ~V3D_NEEDBACKBUFDRAW;
1047
1048         G.f &= ~G_BACKBUFSEL;
1049         G.vd->zbuf= FALSE; 
1050         glDisable(GL_DEPTH_TEST);
1051         glEnable(GL_DITHER);
1052
1053 #ifdef __APPLE__
1054         glDrawBuffer(GL_BACK); /* we were in aux buffers */
1055 #endif
1056
1057         if(G.vd->flag & V3D_CLIPPING)
1058                 view3d_clr_clipping();
1059         
1060         /* it is important to end a view in a transform compatible with buttons */
1061         persp(PERSP_WIN);  // set ortho
1062         bwin_scalematrix(curarea->win, G.vd->blockscale, G.vd->blockscale, G.vd->blockscale);
1063
1064 }
1065
1066                 
1067 void drawname(Object *ob)
1068 {
1069         cpack(0x404040);
1070         glRasterPos3f(0.0,  0.0,  0.0);
1071         
1072         BMF_DrawString(G.font, " ");
1073         BMF_DrawString(G.font, ob->id.name+2);
1074 }
1075
1076
1077 static void draw_selected_name(Object *ob)
1078 {
1079         char info[128];
1080
1081         if(ob->type==OB_ARMATURE) {
1082                 char *name= NULL;
1083                 
1084                 if(ob==G.obedit) {
1085                         EditBone *ebo;
1086                         for (ebo=G.edbo.first; ebo; ebo=ebo->next){
1087                                 if (ebo->flag & BONE_ACTIVE) {
1088                                         name= ebo->name;
1089                                         break;
1090                                 }
1091                         }
1092                 }
1093                 else if(ob->pose && (ob->flag & OB_POSEMODE)) {
1094                         bPoseChannel *pchan;
1095                         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1096                                 if(pchan->bone->flag & BONE_ACTIVE) {
1097                                         name= pchan->name;
1098                                         break;
1099                                 }
1100                         }
1101                 }
1102                 if(name)
1103                         sprintf(info, "(%d) %s %s", CFRA, ob->id.name+2, name);
1104                 else
1105                         sprintf(info, "(%d) %s", CFRA, ob->id.name+2);
1106         }
1107         else sprintf(info, "(%d) %s", CFRA, ob->id.name+2);
1108
1109         BIF_ThemeColor(TH_TEXT_HI);
1110         glRasterPos2i(30,  10);
1111         BMF_DrawString(G.fonts, info);
1112 }
1113
1114
1115 static void draw_view_icon(void)
1116 {
1117         BIFIconID icon;
1118         
1119         if(G.vd->view==7) icon= ICON_AXIS_TOP;
1120         else if(G.vd->view==1) icon= ICON_AXIS_FRONT;
1121         else if(G.vd->view==3) icon= ICON_AXIS_SIDE;
1122         else return ;
1123
1124         glEnable(GL_BLEND);
1125         glBlendFunc(GL_SRC_ALPHA,  GL_ONE_MINUS_SRC_ALPHA); 
1126         
1127         BIF_draw_icon(5.0, 5.0, icon);
1128         
1129         glBlendFunc(GL_ONE,  GL_ZERO); 
1130         glDisable(GL_BLEND);
1131 }
1132
1133 /* ******************* view3d space & buttons ************** */
1134
1135 static void view3d_change_bgpic_ima(View3D *v3d, Image *newima) {
1136         if (v3d->bgpic && v3d->bgpic->ima!=newima) {
1137                 if (newima)
1138                         id_us_plus((ID*) newima);
1139                 if (v3d->bgpic->ima)
1140                         v3d->bgpic->ima->id.us--;
1141                 v3d->bgpic->ima= newima;
1142
1143                 if(v3d->bgpic->rect) MEM_freeN(v3d->bgpic->rect);
1144                 v3d->bgpic->rect= NULL;
1145                 
1146                 allqueue(REDRAWVIEW3D, 0);
1147         }
1148 }
1149 static void view3d_change_bgpic_tex(View3D *v3d, Tex *newtex) {
1150         if (v3d->bgpic && v3d->bgpic->tex!=newtex) {
1151                 if (newtex)
1152                         id_us_plus((ID*) newtex);
1153                 if (v3d->bgpic->tex)
1154                         v3d->bgpic->tex->id.us--;
1155                 v3d->bgpic->tex= newtex;
1156                 
1157                 allqueue(REDRAWVIEW3D, 0);
1158         }
1159 }
1160
1161 static void load_bgpic_image(char *name)
1162 {
1163         Image *ima;
1164         View3D *vd;
1165         
1166         areawinset(curarea->win);
1167         vd= G.vd;
1168         if(vd==0 || vd->bgpic==0) return;
1169         
1170         ima= add_image(name);
1171         if(ima) {
1172                 if(vd->bgpic->ima) {
1173                         vd->bgpic->ima->id.us--;
1174                 }
1175                 vd->bgpic->ima= ima;
1176                 
1177                 free_image_buffers(ima);        /* force read again */
1178                 ima->ok= 1;
1179         }
1180         allqueue(REDRAWVIEW3D, 0);
1181         
1182 }
1183
1184 /* this one assumes there is only one global active object in blender...  (for object panel) */
1185 static float ob_eul[4]; // used for quat too....
1186 /* this one assumes there is only one editmode in blender...  (for object panel) */
1187 static float ve_median[5];
1188
1189 /* is used for both read and write... */
1190 static void v3d_editvertex_buts(uiBlock *block, Object *ob, float lim)
1191 {
1192         static int curdef=0;
1193         static float *defweightp= NULL;
1194         EditMesh *em = G.editMesh;
1195         EditVert *eve, *evedef=NULL;
1196         EditEdge *eed;
1197         float median[5];
1198         int tot, totw, totweight, totedge;
1199         char defstr[320];
1200         
1201         median[0]= median[1]= median[2]= median[3]= median[4]= 0.0;
1202         tot= totw= totweight= totedge= 0;
1203         defstr[0]= 0;
1204
1205         if(ob->type==OB_MESH) {         
1206                 eve= em->verts.first;
1207                 while(eve) {
1208                         if(eve->f & 1) {
1209                                 evedef= eve;
1210                                 tot++;
1211                                 VecAddf(median, median, eve->co);
1212                         }
1213                         eve= eve->next;
1214                 }
1215                 eed= em->edges.first;
1216                 while(eed) {
1217                         if((eed->f & SELECT)) {
1218                                 totedge++;
1219                                 median[3]+= eed->crease;
1220                         }
1221                         eed= eed->next;
1222                 }
1223                 /* check for defgroups */
1224                 if(tot==1 && evedef->totweight) {
1225                         bDeformGroup *dg;
1226                         int i, max=1, init=1;
1227                         char str[32];
1228                         
1229                         for (i=0; i<evedef->totweight; i++){
1230                                 dg = BLI_findlink (&ob->defbase, evedef->dw[i].def_nr);
1231                                 max+= sprintf(str, "%s %%x%d|", dg->name, evedef->dw[i].def_nr); 
1232                                 if(max<320) strcat(defstr, str);
1233                                 
1234                                 if(curdef==evedef->dw[i].def_nr) {
1235                                         init= 0;
1236                                         defweightp= &evedef->dw[i].weight;
1237                                 }
1238                         }
1239                         
1240                         if(init) {      // needs new initialized 
1241                                 curdef= evedef->dw[0].def_nr;
1242                                 defweightp= &evedef->dw[0].weight;
1243                         }
1244                 }
1245         }
1246         else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
1247                 extern ListBase editNurb; /* editcurve.c */
1248                 Nurb *nu;
1249                 BPoint *bp;
1250                 BezTriple *bezt;
1251                 int a;
1252                 
1253                 nu= editNurb.first;
1254                 while(nu) {
1255                         if((nu->type & 7)==1) {
1256                                 bezt= nu->bezt;
1257                                 a= nu->pntsu;
1258                                 while(a--) {
1259                                         if(bezt->f2 & 1) {
1260                                                 VecAddf(median, median, bezt->vec[1]);
1261                                                 tot++;
1262                                                 median[4]+= bezt->weight;
1263                                                 totweight++;
1264                                         }
1265                                         else {
1266                                                 if(bezt->f1 & 1) {
1267                                                         VecAddf(median, median, bezt->vec[0]);
1268                                                         tot++;
1269                                                 }
1270                                                 if(bezt->f3 & 1) {
1271                                                         VecAddf(median, median, bezt->vec[2]);
1272                                                         tot++;
1273                                                 }
1274                                         }
1275                                         bezt++;
1276                                 }
1277                         }
1278                         else {
1279                                 bp= nu->bp;
1280                                 a= nu->pntsu*nu->pntsv;
1281                                 while(a--) {
1282                                         if(bp->f1 & 1) {
1283                                                 VecAddf(median, median, bp->vec);
1284                                                 median[3]+= bp->vec[3];
1285                                                 totw++;
1286                                                 tot++;
1287                                                 median[4]+= bp->weight;
1288                                                 totweight++;
1289                                         }
1290                                         bp++;
1291                                 }
1292                         }
1293                         nu= nu->next;
1294                 }
1295         }
1296         else if(ob->type==OB_LATTICE) {
1297                 BPoint *bp;
1298                 int a;
1299                 
1300                 a= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
1301                 bp= editLatt->def;
1302                 while(a--) {
1303                         if(bp->f1 & SELECT) {
1304                                 VecAddf(median, median, bp->vec);
1305                                 tot++;
1306                                 median[4]+= bp->weight;
1307                                 totweight++;
1308                         }
1309                         bp++;
1310                 }
1311         }
1312         
1313         if(tot==0) return;
1314
1315         median[0] /= (float)tot;
1316         median[1] /= (float)tot;
1317         median[2] /= (float)tot;
1318         if(totedge) median[3] /= (float)totedge;
1319         else if(totw) median[3] /= (float)totw;
1320         if(totweight) median[4] /= (float)totweight;
1321         
1322         if(G.vd->flag & V3D_GLOBAL_STATS)
1323                 Mat4MulVecfl(ob->obmat, median);
1324         
1325         if(block) {     // buttons
1326         
1327                 uiBlockBeginAlign(block);
1328                 uiDefButBitS(block, TOG, V3D_GLOBAL_STATS, REDRAWVIEW3D, "Global",              160, 150, 70, 19, &G.vd->flag, 0, 0, 0, 0, "Displays global values");
1329                 uiDefButBitS(block, TOGN, V3D_GLOBAL_STATS, REDRAWVIEW3D, "Local",              230, 150, 70, 19, &G.vd->flag, 0, 0, 0, 0, "Displays local values");
1330                 
1331                 memcpy(ve_median, median, sizeof(ve_median));
1332                 
1333                 uiBlockBeginAlign(block);
1334                 if(tot==1) {
1335                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex X:", 10, 110, 290, 19, &(ve_median[0]), -lim, lim, 10, 3, "");
1336                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex Y:", 10, 90, 290, 19, &(ve_median[1]), -lim, lim, 10, 3, "");
1337                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex Z:", 10, 70, 290, 19, &(ve_median[2]), -lim, lim, 10, 3, "");
1338                         if(totw==1)
1339                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Vertex W:", 10, 50, 290, 19, &(ve_median[3]), 0.01, 100.0, 10, 3, "");
1340                         uiBlockEndAlign(block);
1341         
1342                         if(defstr[0]) {
1343                                 uiDefBut(block, LABEL, 1, "Vertex Deform Groups",               10, 40, 290, 20, NULL, 0.0, 0.0, 0, 0, "");
1344
1345                                 uiBlockBeginAlign(block);
1346                                 uiDefButF(block, NUM, B_NOP, "Weight:",                 10, 20, 150, 19, defweightp, 0.0f, 1.0f, 10, 3, "Weight value");
1347                                 uiDefButI(block, MENU, REDRAWVIEW3D, defstr,    160, 20, 140, 19, &curdef, 0.0, 0.0, 0, 0, "Current Vertex Group");
1348                                 uiBlockEndAlign(block);
1349                         }
1350                         else if(totweight)
1351                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   10, 20, 290, 19, &(ve_median[4]), 0.0, 1.0, 10, 3, "");
1352
1353                 }
1354                 else {
1355                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median X:", 10, 110, 290, 19, &(ve_median[0]), -lim, lim, 10, 3, "");
1356                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Y:", 10, 90, 290, 19, &(ve_median[1]), -lim, lim, 10, 3, "");
1357                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Z:", 10, 70, 290, 19, &(ve_median[2]), -lim, lim, 10, 3, "");
1358                         if(totw==tot)
1359                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median W:", 10, 50, 290, 19, &(ve_median[3]), 0.01, 100.0, 10, 3, "");
1360                         uiBlockEndAlign(block);
1361                         if(totweight)
1362                                 uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Weight:",   10, 20, 290, 19, &(ve_median[4]), 0.0, 1.0, 10, 3, "Weight is used for SoftBody Goal");
1363                 }
1364                 
1365                 if(totedge==1)
1366                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Crease W:", 10, 30, 290, 19, &(ve_median[3]), 0.0, 1.0, 10, 3, "");
1367                 else if(totedge>1)
1368                         uiDefButF(block, NUM, B_OBJECTPANELMEDIAN, "Median Crease W:",  10, 30, 290, 19, &(ve_median[3]), 0.0, 1.0, 10, 3, "");
1369                 
1370         }
1371         else {  // apply
1372                 
1373                 if(G.vd->flag & V3D_GLOBAL_STATS) {
1374                         Mat4Invert(ob->imat, ob->obmat);
1375                         Mat4MulVecfl(ob->imat, median);
1376                         Mat4MulVecfl(ob->imat, ve_median);
1377                 }
1378                 VecSubf(median, ve_median, median);
1379                 median[3]= ve_median[3]-median[3];
1380                 median[4]= ve_median[4]-median[4];
1381                 
1382                 if(ob->type==OB_MESH) {
1383                         float diffac= 1.0;
1384                         
1385                         eve= em->verts.first;
1386                         while(eve) {
1387                                 if(eve->f & 1) {
1388                                         VecAddf(eve->co, eve->co, median);
1389                                 }
1390                                 eve= eve->next;
1391                         }
1392                         
1393                         /* calculate the differences to squeeze a range smaller when values are close to 1 or 0 */
1394                         /* this way you can edit a median value which is applied on clipped values :) */
1395                         if(totedge>1) {
1396                                 float max= 0.0;
1397                                 for(eed= em->edges.first; eed; eed= eed->next) {
1398                                         if(eed->f & SELECT) {
1399                                                 if(max < ABS(eed->crease-ve_median[3])) max= ABS(eed->crease-ve_median[3]);
1400                                         }
1401                                 }
1402                                 if(max>0.0) {
1403                                         if(ve_median[3]> 0.5) diffac= (1.0-ve_median[3])/max;
1404                                         else diffac= (ve_median[3])/max;
1405                                         if(diffac>1.0) diffac= 1.0;
1406                                 }
1407                         }
1408                         
1409                         for(eed= em->edges.first; eed; eed= eed->next) {
1410                                 if(eed->f & SELECT) {
1411                                         eed->crease+= median[3];
1412                                         eed->crease= ve_median[3] + diffac*(eed->crease-ve_median[3]);
1413                                         
1414                                         CLAMP(eed->crease, 0.0, 1.0);
1415                                 }
1416                         }
1417                         
1418                         recalc_editnormals();
1419                 }
1420                 else if(ob->type==OB_CURVE || ob->type==OB_SURF) {
1421                         extern ListBase editNurb; /* editcurve.c */
1422                         Nurb *nu;
1423                         BPoint *bp;
1424                         BezTriple *bezt;
1425                         int a;
1426                         
1427                         nu= editNurb.first;
1428                         while(nu) {
1429                                 if((nu->type & 7)==1) {
1430                                         bezt= nu->bezt;
1431                                         a= nu->pntsu;
1432                                         while(a--) {
1433                                                 if(bezt->f2 & 1) {
1434                                                         VecAddf(bezt->vec[0], bezt->vec[0], median);
1435                                                         VecAddf(bezt->vec[1], bezt->vec[1], median);
1436                                                         VecAddf(bezt->vec[2], bezt->vec[2], median);
1437                                                         bezt->weight+= median[4];
1438                                                 }
1439                                                 else {
1440                                                         if(bezt->f1 & 1) {
1441                                                                 VecAddf(bezt->vec[0], bezt->vec[0], median);
1442                                                         }
1443                                                         if(bezt->f3 & 1) {
1444                                                                 VecAddf(bezt->vec[2], bezt->vec[2], median);
1445                                                         }
1446                                                 }
1447                                                 bezt++;
1448                                         }
1449                                 }
1450                                 else {
1451                                         bp= nu->bp;
1452                                         a= nu->pntsu*nu->pntsv;
1453                                         while(a--) {
1454                                                 if(bp->f1 & 1) {
1455                                                         VecAddf(bp->vec, bp->vec, median);
1456                                                         bp->vec[3]+= median[3];
1457                                                         bp->weight+= median[4];
1458                                                 }
1459                                                 bp++;
1460                                         }
1461                                 }
1462                                 test2DNurb(nu);
1463                                 testhandlesNurb(nu); /* test for bezier too */
1464
1465                                 nu= nu->next;
1466                         }
1467                 }
1468                 else if(ob->type==OB_LATTICE) {
1469                         BPoint *bp;
1470                         int a;
1471                         
1472                         a= editLatt->pntsu*editLatt->pntsv*editLatt->pntsw;
1473                         bp= editLatt->def;
1474                         while(a--) {
1475                                 if(bp->f1 & SELECT) {
1476                                         VecAddf(bp->vec, bp->vec, median);
1477                                         bp->weight+= median[4];
1478                                 }
1479                                 bp++;
1480                         }
1481                 }
1482                 
1483                 BIF_undo_push("Transform properties");
1484         }
1485 }
1486
1487 /* assumes armature active */
1488 static void validate_bonebutton_cb(void *bonev, void *namev)
1489 {
1490         Object *ob= OBACT;
1491         
1492         if(ob && ob->type==OB_ARMATURE) {
1493                 Bone *bone= bonev;
1494                 char oldname[32], newname[32];
1495                 
1496                 /* need to be on the stack */
1497                 BLI_strncpy(newname, bone->name, 32);
1498                 BLI_strncpy(oldname, (char *)namev, 32);
1499                 /* restore */
1500                 BLI_strncpy(bone->name, oldname, 32);
1501                 
1502                 armature_bone_rename(ob->data, oldname, newname); // editarmature.c
1503                 allqueue(REDRAWALL, 0);
1504         }
1505 }
1506
1507
1508 static void v3d_posearmature_buts(uiBlock *block, Object *ob, float lim)
1509 {
1510         uiBut *but;
1511         bArmature *arm;
1512         bPoseChannel *pchan;
1513         Bone *bone;
1514
1515         arm = get_armature(OBACT);
1516         if (!arm || !ob->pose) return;
1517
1518         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1519                 bone = pchan->bone;
1520                 if(bone && (bone->flag & BONE_ACTIVE)) break;
1521         }
1522         if (!pchan) return;
1523         
1524         but= uiDefBut(block, TEX, B_DIFF, "Bone:",                              160, 140, 140, 19, bone->name, 1, 31, 0, 0, "");
1525         uiButSetFunc(but, validate_bonebutton_cb, bone, NULL);
1526         
1527         QuatToEul(pchan->quat, ob_eul);
1528         ob_eul[0]*= 180.0/M_PI;
1529         ob_eul[1]*= 180.0/M_PI;
1530         ob_eul[2]*= 180.0/M_PI;
1531         
1532         uiBlockBeginAlign(block);
1533         uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCX, REDRAWVIEW3D, ICON_UNLOCKED,     10,140,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1534         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocX:",        30, 140, 120, 19, pchan->loc, -lim, lim, 100, 3, "");
1535         uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCY, REDRAWVIEW3D, ICON_UNLOCKED,     10,120,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1536         uiDefButF(block, NUM, B_ARMATUREPANEL2, "LocY:",        30, 120, 120, 19, pchan->loc+1, -lim, lim, 100, 3, "");
1537         uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCZ, REDRAWVIEW3D, ICON_UNLOCKED,     10,100,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1538         uiDefButF(block, NUM, B_ARMATUREPANEL2, "locZ:",        30, 100, 120, 19, pchan->loc+2, -lim, lim, 100, 3, "");
1539
1540         uiBlockBeginAlign(block);
1541         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTX, REDRAWVIEW3D, ICON_UNLOCKED,     10,70,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1542         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotX:",        30, 70, 120, 19, ob_eul, -1000.0, 1000.0, 100, 3, "");
1543         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTY, REDRAWVIEW3D, ICON_UNLOCKED,     10,50,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1544         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotY:",        30, 50, 120, 19, ob_eul+1, -1000.0, 1000.0, 100, 3, "");
1545         uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTZ, REDRAWVIEW3D, ICON_UNLOCKED,     10,30,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1546         uiDefButF(block, NUM, B_ARMATUREPANEL3, "RotZ:",        30, 30, 120, 19, ob_eul+2, -1000.0, 1000.0, 100, 3, "");
1547         
1548         uiBlockBeginAlign(block);
1549         uiDefIconButBitS(block, ICONTOG, OB_LOCK_SIZEX, REDRAWVIEW3D, ICON_UNLOCKED,    160,70,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1550         uiDefButF(block, NUM, B_ARMATUREPANEL2, "SizeX:",       180, 70, 120, 19, pchan->size, -lim, lim, 10, 3, "");
1551         uiDefIconButBitS(block, ICONTOG, OB_LOCK_SIZEY, REDRAWVIEW3D, ICON_UNLOCKED,    160,50,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1552         uiDefButF(block, NUM, B_ARMATUREPANEL2, "SizeY:",       180, 50, 120, 19, pchan->size+1, -lim, lim, 10, 3, "");
1553         uiDefIconButBitS(block, ICONTOG, OB_LOCK_SIZEZ, REDRAWVIEW3D, ICON_UNLOCKED,    160,30,20,19, &(pchan->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1554         uiDefButF(block, NUM, B_ARMATUREPANEL2, "SizeZ:",       180, 30, 120, 19, pchan->size+2, -lim, lim, 10, 3, "");
1555         uiBlockEndAlign(block);
1556 }
1557
1558 static void v3d_editarmature_buts(uiBlock *block, Object *ob, float lim)
1559 {
1560         EditBone *ebone;
1561         uiBut *but;
1562         
1563         ebone= G.edbo.first;
1564
1565         for (ebone = G.edbo.first; ebone; ebone=ebone->next){
1566                 if (ebone->flag & BONE_ACTIVE)
1567                         break;
1568         }
1569
1570         if (!ebone)
1571                 return;
1572         
1573         but= uiDefBut(block, TEX, B_DIFF, "Bone:",                      160, 140, 140, 19, ebone->name, 1, 31, 0, 0, "");
1574         uiButSetFunc(but, validate_editbonebutton_cb, ebone, NULL);
1575
1576         uiBlockBeginAlign(block);
1577         uiDefButF(block, NUM, B_ARMATUREPANEL1, "RootX:",       10, 70, 140, 19, ebone->head, -lim, lim, 10, 3, "");
1578         uiDefButF(block, NUM, B_ARMATUREPANEL1, "RootY:",       10, 50, 140, 19, ebone->head+1, -lim, lim, 10, 3, "");
1579         uiDefButF(block, NUM, B_ARMATUREPANEL1, "RootZ:",       10, 30, 140, 19, ebone->head+2, -lim, lim, 10, 3, "");
1580         uiBlockBeginAlign(block);
1581         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TipX:",        160, 70, 140, 19, ebone->tail, -lim, lim, 10, 3, "");
1582         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TipY:",        160, 50, 140, 19, ebone->tail+1, -lim, lim, 10, 3, "");
1583         uiDefButF(block, NUM, B_ARMATUREPANEL1, "TipZ:",        160, 30, 140, 19, ebone->tail+2, -lim, lim, 10, 3, "");
1584         uiBlockEndAlign(block);
1585         ob_eul[0]= 180.0*ebone->roll/M_PI;
1586         uiDefButF(block, NUM, B_ARMATUREPANEL1, "Roll:",        10, 100, 140, 19, ob_eul, -lim, lim, 1000, 3, "");
1587
1588 }
1589
1590 static void v3d_editmetaball_buts(uiBlock *block, Object *ob, float lim)
1591 {
1592         extern MetaElem *lastelem;
1593
1594         if(lastelem) {
1595                 uiBlockBeginAlign(block);
1596                 uiDefButF(block, NUM, B_RECALCMBALL, "LocX:", 10, 70, 140, 19, &lastelem->x, -lim, lim, 100, 3, "");
1597                 uiDefButF(block, NUM, B_RECALCMBALL, "LocY:", 10, 50, 140, 19, &lastelem->y, -lim, lim, 100, 3, "");
1598                 uiDefButF(block, NUM, B_RECALCMBALL, "LocZ:", 10, 30, 140, 19, &lastelem->z, -lim, lim, 100, 3, "");
1599
1600                 uiBlockBeginAlign(block);
1601                 if(lastelem->type!=MB_BALL)
1602                 uiDefButF(block, NUM, B_RECALCMBALL, "dx:", 160, 70, 140, 19, &lastelem->expx, 0, lim, 100, 3, "");
1603                 if((lastelem->type!=MB_BALL) && (lastelem->type!=MB_TUBE))
1604                 uiDefButF(block, NUM, B_RECALCMBALL, "dy:", 160, 50, 140, 19, &lastelem->expy, 0, lim, 100, 3, "");
1605                 if((lastelem->type==MB_ELIPSOID) || (lastelem->type==MB_CUBE))
1606                 uiDefButF(block, NUM, B_RECALCMBALL, "dz:", 160, 30, 140, 19, &lastelem->expz, 0, lim, 100, 3, "");
1607
1608                 uiBlockEndAlign(block);
1609
1610                 uiDefButF(block, NUM, B_RECALCMBALL, "Stiffness:", 10, 100, 140, 19, &lastelem->s, 0, lim, 100, 3, "");
1611         }
1612 }
1613
1614 void do_viewbuts(unsigned short event)
1615 {
1616         View3D *vd;
1617         Object *ob= OBACT;
1618         char *name;
1619         
1620         vd= G.vd;
1621         if(vd==0) return;
1622
1623         switch(event) {
1624         case B_LOADBGPIC:
1625                 if(vd->bgpic && vd->bgpic->ima) name= vd->bgpic->ima->name;
1626                 else name= G.ima;
1627                 
1628                 if(G.qual==LR_CTRLKEY)
1629                         activate_imageselect(FILE_SPECIAL, "Select Image", name, load_bgpic_image);
1630                 else
1631                         activate_fileselect(FILE_SPECIAL, "Select Image", name, load_bgpic_image);
1632                 break;
1633                 
1634         case B_BLENDBGPIC:
1635                 if(vd->bgpic && vd->bgpic->rect) setalpha_bgpic(vd->bgpic);
1636                 addqueue(curarea->win, REDRAW, 1);
1637                 break;
1638                 
1639         case B_BGPICBROWSE:
1640                 if(vd->bgpic) {
1641                         if (vd->menunr==-2) {
1642                                 activate_databrowse((ID*) vd->bgpic->ima, ID_IM, 0, B_BGPICBROWSE, &vd->menunr, do_viewbuts);
1643                         } else if (vd->menunr>0) {
1644                                 Image *newima= (Image*) BLI_findlink(&G.main->image, vd->menunr-1);
1645
1646                                 if (newima)
1647                                         view3d_change_bgpic_ima(vd, newima);
1648                         }
1649                 }
1650                 break;
1651                 
1652         case B_BGPICCLEAR:
1653                 if (vd->bgpic)
1654                         view3d_change_bgpic_ima(vd, NULL);
1655                 break;
1656                 
1657         case B_BGPICTEX:
1658                 if (vd->bgpic) {
1659                         if (vd->texnr==-2) {
1660                                 activate_databrowse((ID*) vd->bgpic->tex, ID_TE, 0, B_BGPICTEX, &vd->texnr, do_viewbuts);
1661                         } else if (vd->texnr>0) {
1662                                 Tex *newtex= (Tex*) BLI_findlink(&G.main->tex, vd->texnr-1);
1663                                 
1664                                 if (newtex)
1665                                         view3d_change_bgpic_tex(vd, newtex);
1666                         }
1667                 }
1668                 break;
1669                 
1670         case B_BGPICTEXCLEAR:
1671                 if (vd->bgpic)
1672                         view3d_change_bgpic_tex(vd, NULL);
1673                 break;
1674         
1675         case B_OBJECTPANEL:
1676                 DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
1677                 allqueue(REDRAWVIEW3D, 1);
1678                 break;
1679                 
1680         case B_OBJECTPANELROT:
1681                 if(ob) {
1682                         ob->rot[0]= M_PI*ob_eul[0]/180.0;
1683                         ob->rot[1]= M_PI*ob_eul[1]/180.0;
1684                         ob->rot[2]= M_PI*ob_eul[2]/180.0;
1685                         DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
1686                         allqueue(REDRAWVIEW3D, 1);
1687                 }
1688                 break;
1689         
1690         case B_OBJECTPANELMEDIAN:
1691                 if(ob) {
1692                         v3d_editvertex_buts(NULL, ob, 1.0);
1693                         DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
1694                         allqueue(REDRAWVIEW3D, 1);
1695                 }
1696                 break;
1697         case B_OBJECTPANELPARENT:
1698                 if(ob) {
1699                         if( test_parent_loop(ob->parent, ob) ) 
1700                                 ob->parent= NULL;
1701                         else {
1702                                 DAG_scene_sort(G.scene);
1703                                 DAG_object_flush_update(G.scene, ob, OB_RECALC_OB);
1704                                 allqueue(REDRAWVIEW3D, 1);
1705                         }
1706                 }
1707                 break;
1708                 
1709         case B_ARMATUREPANEL1:
1710                 {
1711                         bArmature *arm= G.obedit->data;
1712                         EditBone *ebone, *child;
1713                         
1714                         ebone= G.edbo.first;
1715                         for (ebone = G.edbo.first; ebone; ebone=ebone->next){
1716                                 if (ebone->flag & BONE_ACTIVE) break;
1717                         }
1718                         if (ebone) {
1719                                 ebone->roll= M_PI*ob_eul[0]/180.0;
1720                                 //      Update our parent
1721                                 if (ebone->parent && ebone->flag & BONE_CONNECTED){
1722                                         VECCOPY (ebone->parent->tail, ebone->head);
1723                                 }
1724                         
1725                                 //      Update our children if necessary
1726                                 for (child = G.edbo.first; child; child=child->next){
1727                                         if (child->parent == ebone && (child->flag & BONE_CONNECTED)){
1728                                                 VECCOPY (child->head, ebone->tail);
1729                                         }
1730                                 }
1731                                 if(arm->flag & ARM_MIRROR_EDIT) {
1732                                         EditBone *eboflip= armature_bone_get_mirrored(ebone);
1733                                         if(eboflip) {
1734                                                 eboflip->roll= -ebone->roll;
1735                                                 eboflip->head[0]= -ebone->head[0];
1736                                                 eboflip->tail[0]= -ebone->tail[0];
1737                                                 
1738                                                 //      Update our parent
1739                                                 if (eboflip->parent && eboflip->flag & BONE_CONNECTED){
1740                                                         VECCOPY (eboflip->parent->tail, eboflip->head);
1741                                                 }
1742                                                 
1743                                                 //      Update our children if necessary
1744                                                 for (child = G.edbo.first; child; child=child->next){
1745                                                         if (child->parent == eboflip && (child->flag & BONE_CONNECTED)){
1746                                                                 VECCOPY (child->head, eboflip->tail);
1747                                                         }
1748                                                 }
1749                                         }
1750                                 }
1751                                 
1752                                 allqueue(REDRAWVIEW3D, 1);
1753                         }
1754                 }
1755                 break;
1756         case B_ARMATUREPANEL3:  // rotate button on channel
1757                 {
1758                         bArmature *arm;
1759                         bPoseChannel *pchan;
1760                         Bone *bone;
1761                         
1762                         arm = get_armature(OBACT);
1763                         if (!arm || !ob->pose) return;
1764                                 
1765                         for(pchan= ob->pose->chanbase.first; pchan; pchan= pchan->next) {
1766                                 bone = pchan->bone;
1767                                 if(bone && (bone->flag & BONE_ACTIVE)) break;
1768                         }
1769                         if (!pchan) return;
1770                         
1771                         ob_eul[0]*= M_PI/180.0;
1772                         ob_eul[1]*= M_PI/180.0;
1773                         ob_eul[2]*= M_PI/180.0;
1774                         EulToQuat(ob_eul, pchan->quat);
1775                 }
1776                 /* no break, pass on */
1777         case B_ARMATUREPANEL2:
1778                 {
1779                         DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
1780                         allqueue(REDRAWVIEW3D, 1);
1781                 }
1782                 break;
1783         }
1784 }
1785
1786
1787 static void view3d_panel_object(short cntrl)    // VIEW3D_HANDLER_OBJECT
1788 {
1789         uiBlock *block;
1790         uiBut *bt;
1791         Object *ob= OBACT;
1792         float lim;
1793         static char hexcol[128];
1794         
1795         if(ob==NULL) return;
1796
1797         block= uiNewBlock(&curarea->uiblocks, "view3d_panel_object", UI_EMBOSS, UI_HELV, curarea->win);
1798         uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE | cntrl);
1799         uiSetPanelHandler(VIEW3D_HANDLER_OBJECT);  // for close and esc
1800         
1801 /* (ton) can't use the rename trick for paint... panel names and settings are stored in the files and
1802    used to find previous locations when re-open. This causes flipping */
1803
1804         if(uiNewPanel(curarea, block, "Transform Properties", "View3d", 10, 230, 318, 204)==0) return;
1805         
1806         if(ob->id.lib) uiSetButLock(1, "Can't edit library data");
1807         
1808         if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
1809                 uiBlockSetFlag(block, UI_BLOCK_FRONTBUFFER);    // force old style frontbuffer draw
1810         }
1811         else {
1812                 bt= uiDefBut(block, TEX, B_IDNAME, "OB: ",      10,180,140,20, ob->id.name+2, 0.0, 19.0, 0, 0, "");
1813                 uiButSetFunc(bt, test_idbutton_cb, ob->id.name, NULL);
1814
1815                 uiDefIDPoinBut(block, test_obpoin_but, ID_OB, B_OBJECTPANELPARENT, "Par:", 160, 180, 140, 20, &ob->parent, "Parent Object"); 
1816         }
1817
1818         lim= 10000.0f*MAX2(1.0, G.vd->grid);
1819
1820         if(ob==G.obedit) {
1821                 if(ob->type==OB_ARMATURE) v3d_editarmature_buts(block, ob, lim);
1822                 if(ob->type==OB_MBALL) v3d_editmetaball_buts(block, ob, lim);
1823                 else v3d_editvertex_buts(block, ob, lim);
1824         }
1825         else if(ob->flag & OB_POSEMODE) {
1826                 v3d_posearmature_buts(block, ob, lim);
1827         }
1828         else if(G.f & (G_VERTEXPAINT|G_TEXTUREPAINT)) {
1829                 extern VPaint Gvp;         /* from vpaint */
1830                 static float hsv[3], old[3];    // used as temp mem for picker
1831                 uiBlockPickerButtons(block, &Gvp.r, hsv, old, hexcol, 'f', REDRAWBUTSEDIT);     /* 'f' is for floating panel */
1832         }
1833         else {
1834                 uiBlockBeginAlign(block);
1835                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCX, REDRAWVIEW3D, ICON_UNLOCKED,     10,140,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1836                 uiDefButF(block, NUM, B_OBJECTPANEL, "LocX:",           30, 140, 120, 19, &(ob->loc[0]), -lim, lim, 100, 3, "");
1837                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCY, REDRAWVIEW3D, ICON_UNLOCKED,     10,120,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1838                 uiDefButF(block, NUM, B_OBJECTPANEL, "LocY:",           30, 120, 120, 19, &(ob->loc[1]), -lim, lim, 100, 3, "");
1839                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_LOCZ, REDRAWVIEW3D, ICON_UNLOCKED,     10,100,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1840                 uiDefButF(block, NUM, B_OBJECTPANEL, "LocZ:",           30, 100, 120, 19, &(ob->loc[2]), -lim, lim, 100, 3, "");
1841                 
1842                 ob_eul[0]= 180.0*ob->rot[0]/M_PI;
1843                 ob_eul[1]= 180.0*ob->rot[1]/M_PI;
1844                 ob_eul[2]= 180.0*ob->rot[2]/M_PI;
1845                 
1846                 uiBlockBeginAlign(block);
1847                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTX, REDRAWVIEW3D, ICON_UNLOCKED,     10,70,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1848                 uiDefButF(block, NUM, B_OBJECTPANELROT, "RotX:",        30, 70, 120, 19, &(ob_eul[0]), -lim, lim, 1000, 3, "");
1849                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTY, REDRAWVIEW3D, ICON_UNLOCKED,     10,50,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1850                 uiDefButF(block, NUM, B_OBJECTPANELROT, "RotY:",        30, 50, 120, 19, &(ob_eul[1]), -lim, lim, 1000, 3, "");
1851                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_ROTZ, REDRAWVIEW3D, ICON_UNLOCKED,     10,30,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1852                 uiDefButF(block, NUM, B_OBJECTPANELROT, "RotZ:",        30, 30, 120, 19, &(ob_eul[2]), -lim, lim, 1000, 3, "");
1853                 
1854                 uiBlockBeginAlign(block);
1855                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SIZEX, REDRAWVIEW3D, ICON_UNLOCKED,    160,70,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1856                 uiDefButF(block, NUM, B_OBJECTPANEL, "SizeX:",          180, 70, 120, 19, &(ob->size[0]), -lim, lim, 10, 3, "");
1857                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SIZEY, REDRAWVIEW3D, ICON_UNLOCKED,    160,50,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1858                 uiDefButF(block, NUM, B_OBJECTPANEL, "SizeY:",          180, 50, 120, 19, &(ob->size[1]), -lim, lim, 10, 3, "");
1859                 uiDefIconButBitS(block, ICONTOG, OB_LOCK_SIZEZ, REDRAWVIEW3D, ICON_UNLOCKED,    160,30,20,19, &(ob->protectflag), 0, 0, 0, 0, "Protects this value from being Transformed");
1860                 uiDefButF(block, NUM, B_OBJECTPANEL, "SizeZ:",          180, 30, 120, 19, &(ob->size[2]), -lim, lim, 10, 3, "");
1861                 uiBlockEndAlign(block);
1862         }
1863         uiClearButLock();
1864 }
1865
1866 static void view3d_panel_background(short cntrl)        // VIEW3D_HANDLER_BACKGROUND
1867 {
1868         uiBlock *block;
1869         View3D *vd;
1870         ID *id;
1871         char *strp;
1872         
1873         vd= G.vd;
1874
1875         block= uiNewBlock(&curarea->uiblocks, "view3d_panel_background", UI_EMBOSS, UI_HELV, curarea->win);
1876         uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE  | cntrl);
1877         uiSetPanelHandler(VIEW3D_HANDLER_BACKGROUND);  // for close and esc
1878         if(uiNewPanel(curarea, block, "Background Image", "View3d", 340, 10, 318, 204)==0) return;
1879
1880         if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
1881                 uiBlockSetFlag(block, UI_BLOCK_FRONTBUFFER);    // force old style frontbuffer draw
1882         }
1883         
1884         if(vd->flag & V3D_DISPBGPIC) {
1885                 if(vd->bgpic==0) {
1886                         vd->bgpic= MEM_callocN(sizeof(BGpic), "bgpic");
1887                         vd->bgpic->size= 5.0;
1888                         vd->bgpic->blend= 0.5;
1889                 }
1890         }
1891         
1892         uiDefButBitS(block, TOG, V3D_DISPBGPIC, REDRAWVIEW3D, "Use Background Image", 0, 162, 200, 20, &vd->flag, 0, 0, 0, 0, "Display an image in the background of the 3D View");
1893         
1894         uiDefBut(block, LABEL, 1, " ",  206, 162, 84, 20, NULL, 0.0, 0.0, 0, 0, "");
1895         
1896         
1897         if(vd->flag & V3D_DISPBGPIC) {
1898
1899                 /* Background Image */
1900                 uiDefBut(block, LABEL, 1, "Image:",     0, 128, 76, 19, NULL, 0.0, 0.0, 0, 0, "");
1901                 
1902                 uiBlockBeginAlign(block);
1903                 uiDefIconBut(block, BUT, B_LOADBGPIC, ICON_FILESEL,     90, 128, 20, 20, 0, 0, 0, 0, 0, "Open a new background image");
1904
1905                 id= (ID *)vd->bgpic->ima;
1906                 IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->image), id, &(vd->menunr));
1907                 if(strp[0]) {
1908                 
1909                         uiDefButS(block, MENU, B_BGPICBROWSE, strp,     110, 128, 20, 20, &(vd->menunr), 0, 0, 0, 0, "Select a background image");
1910                 
1911                         if(vd->bgpic->ima)  {
1912                                 uiDefBut(block, TEX,        0,"BG: ",           130, 128, 140, 20, &vd->bgpic->ima->name,0.0,100.0, 0, 0, "The currently selected background image");
1913                                 uiDefIconBut(block, BUT, B_BGPICCLEAR, ICON_X, 270, 128, 20, 20, 0, 0, 0, 0, 0, "Remove background image link");
1914                         }
1915                         uiBlockEndAlign(block);
1916                 } else {
1917                         uiBlockEndAlign(block);
1918                 }
1919                 MEM_freeN(strp);
1920
1921
1922                 /* Background texture */
1923                 uiDefBut(block, LABEL, 1, "Texture:",   0, 100, 76, 19, NULL, 0.0, 0.0, 0, 0, "");
1924                 
1925                 id= (ID *)vd->bgpic->tex;
1926                 IDnames_to_pupstring(&strp, NULL, NULL, &(G.main->tex), id, &(vd->texnr));
1927                 if (strp[0])
1928                         uiBlockBeginAlign(block);
1929                         uiDefButS(block, MENU, B_BGPICTEX, strp,                        90, 100, 20,20, &(vd->texnr), 0, 0, 0, 0, "Select a texture to use as an animated background image");
1930                 MEM_freeN(strp);
1931                 
1932                 if (id) {
1933                         uiDefBut(block, TEX, B_IDNAME, "TE:",                           110, 100, 160, 20, id->name+2, 0.0, 18.0, 0, 0, "");
1934                         uiDefIconBut(block, BUT, B_BGPICTEXCLEAR, ICON_X,       270, 100, 20, 20, 0, 0, 0, 0, 0, "Remove background texture link");
1935                         uiBlockEndAlign(block);
1936                 } else {
1937                         uiBlockEndAlign(block);
1938                 }
1939
1940                 uiDefButF(block, NUMSLI, B_BLENDBGPIC, "Blend:",        0, 60 , 290, 19, &vd->bgpic->blend, 0.0,1.0, 0, 0, "Set the transparency of the background image");
1941
1942                 uiDefButF(block, NUM, REDRAWVIEW3D, "Size:",            0, 28, 140, 19, &vd->bgpic->size, 0.1, 250.0, 100, 0, "Set the size (width) of the background image");
1943
1944                 uiDefButF(block, NUM, REDRAWVIEW3D, "X Offset:",        0, 6, 140, 19, &vd->bgpic->xof, -250.0,250.0, 10, 2, "Set the horizontal offset of the background image");
1945                 uiDefButF(block, NUM, REDRAWVIEW3D, "Y Offset:",        150, 6, 140, 19, &vd->bgpic->yof, -250.0,250.0, 10, 2, "Set the vertical offset of the background image");
1946
1947         
1948                 
1949                 // uiDefButF(block, NUM, REDRAWVIEW3D, "Size:",                 160,160,150,20, &vd->bgpic->size, 0.1, 250.0, 100, 0, "Set the size for the width of the BackGroundPic");
1950                 
1951
1952
1953 //              uiDefButF(block, NUMSLI, B_BLENDBGPIC, "Blend:",        120,100,190,20,&vd->bgpic->blend, 0.0,1.0, 0, 0, "Set the BackGroundPic transparency");
1954                 
1955 //              uiDefButF(block, NUM, B_DIFF, "Center X: ",     10,70,140,20,&vd->bgpic->xof, -20.0,20.0, 10, 2, "Set the BackGroundPic X Offset");
1956 //              uiDefButF(block, NUM, B_DIFF, "Center Y: ",     160,70,140,20,&vd->bgpic->yof, -20.0,20.0, 10, 2, "Set the BackGroundPic Y Offset");
1957
1958         }
1959 }
1960
1961
1962 static void view3d_panel_properties(short cntrl)        // VIEW3D_HANDLER_SETTINGS
1963 {
1964         uiBlock *block;
1965         View3D *vd;
1966         float *curs;
1967         
1968         vd= G.vd;
1969
1970         block= uiNewBlock(&curarea->uiblocks, "view3d_panel_properties", UI_EMBOSS, UI_HELV, curarea->win);
1971         uiPanelControl(UI_PNL_SOLID | UI_PNL_CLOSE  | cntrl);
1972         uiSetPanelHandler(VIEW3D_HANDLER_PROPERTIES);  // for close and esc
1973         if(uiNewPanel(curarea, block, "View Properties", "View3d", 340, 10, 318, 204)==0) return;
1974
1975         if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
1976                 uiBlockSetFlag(block, UI_BLOCK_FRONTBUFFER);    // force old style frontbuffer draw
1977         }
1978
1979         uiDefBut(block, LABEL, 1, "Grid:",                                      10, 180, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1980         uiDefButF(block, NUM, REDRAWVIEW3D, "Spacing:",         10, 160, 140, 19, &vd->grid, 0.001, 100.0, 10, 0, "Set the distance between grid lines");
1981         uiDefButS(block, NUM, REDRAWVIEW3D, "Lines:",           10, 136, 140, 19, &vd->gridlines, 0.0, 100.0, 100, 0, "Set the number of grid lines");
1982
1983         uiDefBut(block, LABEL, 1, "3D Display:",                                        160, 180, 150, 19, NULL, 0.0, 0.0, 0, 0, "");
1984         uiDefButBitS(block, TOG, V3D_SHOW_FLOOR, REDRAWVIEW3D, "Grid Floor",160, 160, 150, 19, &vd->gridflag, 0, 0, 0, 0, "Show the grid floor in free camera mode");
1985         uiDefButBitS(block, TOG, V3D_SHOW_X, REDRAWVIEW3D, "X Axis",            160, 136, 48, 19, &vd->gridflag, 0, 0, 0, 0, "Show the X Axis line");
1986         uiDefButBitS(block, TOG, V3D_SHOW_Y, REDRAWVIEW3D, "Y Axis",            212, 136, 48, 19, &vd->gridflag, 0, 0, 0, 0, "Show the Y Axis line");
1987         uiDefButBitS(block, TOG, V3D_SHOW_Z, REDRAWVIEW3D, "Z Axis",            262, 136, 48, 19, &vd->gridflag, 0, 0, 0, 0, "Show the Z Axis line");
1988
1989         uiDefBut(block, LABEL, 1, "View Camera:",                       10, 110, 140, 19, NULL, 0.0, 0.0, 0, 0, "");
1990         
1991         uiDefButF(block, NUM, REDRAWVIEW3D, "Lens:",            10, 90, 140, 19, &vd->lens, 10.0, 120.0, 100, 0, "The lens angle in perspective view");
1992         uiBlockBeginAlign(block);
1993         uiDefButF(block, NUM, REDRAWVIEW3D, "Clip Start:",      10, 66, 140, 19, &vd->near, vd->grid/10.0, 100.0, 10, 0, "Set the beginning of the range in which 3D objects are displayed (perspective view)");
1994         uiDefButF(block, NUM, REDRAWVIEW3D, "Clip End:",        10, 46, 140, 19, &vd->far, 1.0, 1000.0*vd->grid, 100, 0, "Set the end of the range in which 3D objects are displayed (perspective view)");
1995         uiBlockEndAlign(block);
1996
1997         uiDefBut(block, LABEL, 1, "3D Cursor:",                         160, 110, 140, 19, NULL, 0.0, 0.0, 0, 0, "");
1998
1999         uiBlockBeginAlign(block);
2000         curs= give_cursor();
2001         uiDefButF(block, NUM, REDRAWVIEW3D, "X:",                       160, 90, 150, 22, curs, -1000.0*vd->grid, 1000.0*vd->grid, 10, 0, "X co-ordinate of the 3D cursor");
2002         uiDefButF(block, NUM, REDRAWVIEW3D, "Y:",                       160, 68, 150, 22, curs+1, -1000.0*vd->grid, 1000.0*vd->grid, 10, 0, "Y co-ordinate of the 3D cursor");
2003         uiDefButF(block, NUM, REDRAWVIEW3D, "Z:",                       160, 46, 150, 22, curs+2, -1000.0*vd->grid, 1000.0*vd->grid, 10, 0, "Z co-ordinate of the 3D cursor");
2004         uiBlockEndAlign(block);
2005
2006         uiDefButBitS(block, TOG, V3D_SELECT_OUTLINE, REDRAWVIEW3D, "Outline Selected", 10, 10, 140, 19, &vd->flag, 0, 0, 0, 0, "Highlight selected objects with an outline, in Solid, Shaded or Textured viewport shading modes");
2007         uiDefButBitS(block, TOG, V3D_DRAW_CENTERS, REDRAWVIEW3D, "All Object Centers", 160, 10, 140, 19, &vd->flag, 0, 0, 0, 0, "Draw the center points on all objects");
2008
2009 }
2010
2011
2012
2013 static void view3d_blockhandlers(ScrArea *sa)
2014 {
2015         View3D *v3d= sa->spacedata.first;
2016         short a;
2017         
2018         /* warning; blocks need to be freed each time, handlers dont remove */
2019         uiFreeBlocksWin(&sa->uiblocks, sa->win);
2020
2021         for(a=0; a<SPACE_MAXHANDLER; a+=2) {
2022         
2023                 switch(v3d->blockhandler[a]) {
2024
2025                 case VIEW3D_HANDLER_PROPERTIES:
2026                         view3d_panel_properties(v3d->blockhandler[a+1]);
2027                         break;
2028                 case VIEW3D_HANDLER_BACKGROUND:
2029                         view3d_panel_background(v3d->blockhandler[a+1]);
2030                         break;
2031                 case VIEW3D_HANDLER_OBJECT:
2032                         view3d_panel_object(v3d->blockhandler[a+1]);
2033                 
2034                         break;
2035                 
2036                 }
2037                 /* clear action value for event */
2038                 v3d->blockhandler[a+1]= 0;
2039         }
2040         uiDrawBlocksPanels(sa, 0);
2041
2042 }
2043
2044 /* temp storage of Objects that need to be drawn as last */
2045 void add_view3d_after(View3D *v3d, Base *base, int type)
2046 {
2047         View3DAfter *v3da= MEM_callocN(sizeof(View3DAfter), "View 3d after");
2048
2049         BLI_addtail(&v3d->afterdraw, v3da);
2050         v3da->base= base;
2051         v3da->type= type;
2052 }
2053
2054 /* clears zbuffer and draws it over */
2055 static void view3d_draw_xray(View3D *v3d)
2056 {
2057         View3DAfter *v3da, *next;
2058         int doit= 0;
2059         
2060         for(v3da= v3d->afterdraw.first; v3da; v3da= v3da->next)
2061                 if(v3da->type==V3D_XRAY) doit= 1;
2062         
2063         if(doit) {
2064                 if(v3d->zbuf) glClear(GL_DEPTH_BUFFER_BIT);
2065                 v3d->xray= TRUE;
2066                 
2067                 for(v3da= v3d->afterdraw.first; v3da; v3da= next) {
2068                         next= v3da->next;
2069                         if(v3da->type==V3D_XRAY) {
2070                                 draw_object(v3da->base);
2071                                 BLI_remlink(&v3d->afterdraw, v3da);
2072                                 MEM_freeN(v3da);
2073                         }
2074                 }
2075                 v3d->xray= FALSE;
2076         }
2077 }
2078
2079 /* disables write in zbuffer and draws it over */
2080 static void view3d_draw_transp(View3D *v3d)
2081 {
2082         View3DAfter *v3da, *next;
2083
2084         glDepthMask(0);
2085         v3d->transp= TRUE;
2086                 
2087         for(v3da= v3d->afterdraw.first; v3da; v3da= next) {
2088                 next= v3da->next;
2089                 if(v3da->type==V3D_TRANSP) {
2090                         draw_object(v3da->base);
2091                         BLI_remlink(&v3d->afterdraw, v3da);
2092                         MEM_freeN(v3da);
2093                 }
2094         }
2095         v3d->transp= FALSE;
2096
2097         glDepthMask(1);
2098
2099 }
2100
2101 void drawview3dspace(ScrArea *sa, void *spacedata)
2102 {
2103         View3D *v3d= spacedata;
2104         Base *base;
2105         Object *ob;
2106         
2107         setwinmatrixview3d(0);  /* 0= no pick rect */
2108         setviewmatrixview3d();  /* note: calls where_is_object for camera... */
2109
2110         Mat4MulMat4(v3d->persmat, v3d->viewmat, curarea->winmat);
2111         Mat4Invert(v3d->persinv, v3d->persmat);
2112         Mat4Invert(v3d->viewinv, v3d->viewmat);
2113
2114         /* calculate pixelsize factor once, is used for lamps and obcenters */
2115         {
2116                 float len1, len2, vec[3];
2117
2118                 VECCOPY(vec, v3d->persinv[0]);
2119                 len1= Normalise(vec);
2120                 VECCOPY(vec, v3d->persinv[1]);
2121                 len2= Normalise(vec);
2122                 
2123                 v3d->pixsize= 2.0f*(len1>len2?len1:len2);
2124                 
2125                 /* correct for window size */
2126                 if(curarea->winx > sa->winy) v3d->pixsize/= (float)sa->winx;
2127                 else v3d->pixsize/= (float)sa->winy;
2128         }
2129         
2130         if(v3d->drawtype > OB_WIRE) {
2131                 if(G.f & G_SIMULATION)
2132                         glClearColor(0.0, 0.0, 0.0, 0.0); 
2133                 else {
2134                         float col[3];
2135                         BIF_GetThemeColor3fv(TH_BACK, col);
2136                         glClearColor(col[0], col[1], col[2], 0.0); 
2137                 }
2138                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
2139                 
2140                 glLoadIdentity();
2141         }
2142         else {
2143                 float col[3];
2144                 BIF_GetThemeColor3fv(TH_BACK, col);
2145                 glClearColor(col[0], col[1], col[2], 0.0);
2146                 glClear(GL_COLOR_BUFFER_BIT);
2147         }
2148         
2149         myloadmatrix(v3d->viewmat);
2150         persp(PERSP_STORE);  // store correct view for persp(PERSP_VIEW) calls
2151
2152         if(v3d->flag & V3D_CLIPPING)
2153                 view3d_draw_clipping(v3d);
2154         
2155         /* set zbuffer after we draw clipping region */
2156         if(v3d->drawtype > OB_WIRE) {
2157                 v3d->zbuf= TRUE;
2158                 glEnable(GL_DEPTH_TEST);
2159         }
2160         
2161         // needs to be done always, gridview is adjusted in drawgrid() now
2162         v3d->gridview= v3d->grid;
2163         
2164         if(v3d->view==0 || v3d->persp!=0) {
2165                 drawfloor();
2166                 if(v3d->persp==2) {
2167                         if(G.scene->world) {
2168                                 if(G.scene->world->mode & WO_STARS) {
2169                                         RE_make_stars(star_stuff_init_func, star_stuff_vertex_func,
2170                                                                   star_stuff_term_func);
2171                                 }
2172                         }
2173                         if(v3d->flag & V3D_DISPBGPIC) draw_bgpic();
2174                 }
2175         }
2176         else {
2177                 drawgrid();
2178
2179                 if(v3d->flag & V3D_DISPBGPIC) {
2180                         draw_bgpic();
2181                 }
2182         }
2183         
2184         if(v3d->flag & V3D_CLIPPING)
2185                 view3d_set_clipping(v3d);
2186         
2187         /* draw set first */
2188         if(G.scene->set) {
2189         
2190                 base= G.scene->set->base.first;
2191                 while(base) {
2192                         
2193                         if(v3d->lay & base->lay) {
2194
2195                                 object_handle_update(base->object);
2196                                 
2197                                 /* patch: color remains constant, only set it for wire, so transparant works */ 
2198                                 if(v3d->zbuf==0 || base->object->dt<=OB_WIRE)
2199                                         G.f |= G_PICKSEL;
2200                                 else
2201                                         G.f &= ~G_PICKSEL;
2202                                         
2203                                 BIF_ThemeColorBlend(TH_WIRE, TH_BACK, 0.6f);
2204                                 draw_object(base);
2205
2206                                 if(base->object->transflag & OB_DUPLI) {
2207                                         extern ListBase duplilist;
2208                                         Base tbase;
2209                                         
2210                                         tbase= *base;
2211                                         
2212                                         tbase.flag= OB_FROMDUPLI;
2213                                         make_duplilist(G.scene->set, base->object);
2214                                         ob= duplilist.first;
2215                                         while(ob) {
2216                                                 tbase.object= ob;
2217                                                 draw_object(&tbase);
2218                                                 ob= ob->id.next;
2219                                         }
2220                                         free_duplilist();
2221                                         
2222                                 }
2223                         }
2224                         base= base->next;
2225                 }
2226                 
2227                 G.f &= ~G_PICKSEL;
2228
2229                 /* Transp and X-ray afterdraw stuff */
2230                 view3d_draw_xray(v3d);  // clears zbuffer if it is used!
2231                 view3d_draw_transp(v3d);
2232         }
2233         
2234         /* update all objects, ipos, matrices, displists, etc. Flags set by depgraph or manual, no layer check here, gets correct flushed */
2235         for(base= G.scene->base.first; base; base= base->next) {
2236                 object_handle_update(base->object);   // bke_object.h
2237         }
2238         
2239         /* then draw not selected and the duplis, but skip editmode object */
2240         for(base= G.scene->base.first; base; base= base->next) {
2241                 if(v3d->lay & base->lay) {
2242                         
2243                         /* dupli drawing */
2244                         if(base->object->transflag & OB_DUPLI) {
2245                                 extern ListBase duplilist;
2246                                 Base tbase;
2247
2248                                 /* patch: color remains constant */ 
2249                                 G.f |= G_PICKSEL;
2250                                 BIF_ThemeColorBlend(TH_BACK, TH_WIRE, 0.5);
2251                                 
2252                                 tbase.flag= OB_FROMDUPLI;
2253                                 make_duplilist(G.scene, base->object);
2254
2255                                 ob= duplilist.first;
2256                                 while(ob) {
2257                                         tbase.object= ob;
2258                                         draw_object(&tbase);
2259                                         ob= ob->id.next;
2260                                 }
2261                                 free_duplilist();
2262                                 
2263                                 G.f &= ~G_PICKSEL;                              
2264                         }
2265                         if((base->flag & SELECT)==0) {
2266                                 if(base->object!=G.obedit) draw_object(base);
2267                         }
2268                 }
2269         }
2270         /* draw selected and editmode */
2271         for(base= G.scene->base.first; base; base= base->next) {
2272                 if(v3d->lay & base->lay) {
2273                         if (base->object==G.obedit || ( base->flag & SELECT) ) 
2274                                 draw_object(base);
2275                 }
2276         }
2277
2278         if(G.moving) {
2279                 BIF_drawConstraint();
2280                 if(G.obedit) BIF_drawPropCircle();      // only editmode has proportional edit
2281         }
2282
2283         if(G.scene->radio) RAD_drawall(v3d->drawtype>=OB_SOLID);
2284         
2285         /* Transp and X-ray afterdraw stuff */
2286         view3d_draw_xray(v3d);  // clears zbuffer if it is used!
2287         view3d_draw_transp(v3d);
2288         
2289         if(v3d->flag & V3D_CLIPPING)
2290                 view3d_clr_clipping();
2291         
2292         BIF_draw_manipulator(sa);
2293                 
2294         if(v3d->zbuf) {
2295                 v3d->zbuf= FALSE;
2296                 glDisable(GL_DEPTH_TEST);
2297         }
2298
2299         persp(PERSP_WIN);  // set ortho
2300         
2301         if(v3d->persp>1) drawviewborder();
2302         if(!(G.f & G_PLAYANIM)) drawcursor(v3d);
2303         draw_view_icon();
2304
2305         ob= OBACT;
2306         if(ob && (U.uiflag & USER_DRAWVIEWINFO)) 
2307                 draw_selected_name(ob);
2308         
2309         draw_area_emboss(sa);
2310         
2311         /* it is important to end a view in a transform compatible with buttons */
2312
2313         bwin_scalematrix(sa->win, v3d->blockscale, v3d->blockscale, v3d->blockscale);
2314         view3d_blockhandlers(sa);
2315
2316         curarea->win_swap= WIN_BACK_OK;
2317         
2318         if(G.f & (G_VERTEXPAINT|G_FACESELECT|G_TEXTUREPAINT|G_WEIGHTPAINT)) {
2319                 v3d->flag |= V3D_NEEDBACKBUFDRAW;
2320                 addafterqueue(curarea->win, BACKBUFDRAW, 1);
2321         }
2322         // test for backbuf select
2323         if(G.obedit && v3d->drawtype>OB_WIRE && (v3d->flag & V3D_ZBUF_SELECT)) {
2324                 extern int afterqtest(short win, unsigned short evt);   //editscreen.c
2325
2326                 v3d->flag |= V3D_NEEDBACKBUFDRAW;
2327                 if(afterqtest(curarea->win, BACKBUFDRAW)==0) {
2328                         addafterqueue(curarea->win, BACKBUFDRAW, 1);
2329                 }
2330         }
2331
2332         /* run any view3d draw handler script links */
2333         if (sa->scriptlink.totscript)
2334                 BPY_do_spacehandlers(sa, 0, SPACEHANDLER_VIEW3D_DRAW);
2335
2336         /* run scene redraw script links */
2337         if((G.f & G_DOSCRIPTLINKS) && G.scene->scriptlink.totscript &&
2338                         !during_script()) {
2339                 BPY_do_pyscript((ID *)G.scene, SCRIPT_REDRAW);
2340         }
2341
2342 }
2343
2344
2345         /* Called back by rendering system, icky
2346          */
2347 void drawview3d_render(struct View3D *v3d)
2348 {
2349         extern short v3d_windowmode;
2350         Base *base;
2351         Object *ob;
2352
2353         update_for_newframe_muted();    /* first, since camera can be animated */
2354
2355         v3d_windowmode= 1;
2356         setwinmatrixview3d(0);
2357         v3d_windowmode= 0;
2358         glMatrixMode(GL_PROJECTION);
2359         myloadmatrix(R.winmat);
2360         glMatrixMode(GL_MODELVIEW);
2361         
2362         setviewmatrixview3d();
2363         myloadmatrix(v3d->viewmat);
2364         Mat4MulMat4(v3d->persmat, v3d->viewmat, R.winmat);
2365         Mat4Invert(v3d->persinv, v3d->persmat);
2366         Mat4Invert(v3d->viewinv, v3d->viewmat);
2367
2368         free_all_realtime_images();
2369         reshadeall_displist();
2370         
2371         if(v3d->drawtype > OB_WIRE) {
2372                 v3d->zbuf= TRUE;
2373                 glEnable(GL_DEPTH_TEST);
2374         }
2375
2376         if(v3d->flag & V3D_CLIPPING)
2377                 view3d_set_clipping(v3d);
2378
2379         if (v3d->drawtype==OB_TEXTURE && G.scene->world) {
2380                 glClearColor(G.scene->world->horr, G.scene->world->horg, G.scene->world->horb, 0.0); 
2381         } else {
2382                 float col[3];
2383                 BIF_GetThemeColor3fv(TH_BACK, col);
2384                 glClearColor(col[0], col[1], col[2], 0.0); 
2385         }
2386         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
2387         
2388         glLoadIdentity();
2389         myloadmatrix(v3d->viewmat);
2390         
2391         /* abuse! to make sure it doesnt draw the helpstuff */
2392         G.f |= G_SIMULATION;
2393
2394         /* first draw set */
2395         if(G.scene->set) {
2396         
2397                 base= G.scene->set->base.first;
2398                 while(base) {
2399                         if(v3d->lay & base->lay) {
2400                                 if ELEM3(base->object->type, OB_LAMP, OB_CAMERA, OB_LATTICE);
2401                                 else {
2402                                         where_is_object(base->object);
2403         
2404                                         /* patch: color remains constant, only set it for wire, so transparant works */ 
2405                                         if(v3d->zbuf==0 || base->object->dt<=OB_WIRE)
2406                                                 G.f |= G_PICKSEL;
2407                                         else
2408                                                 G.f &= ~G_PICKSEL;
2409                                         
2410                                         BIF_ThemeColorBlend(TH_WIRE, TH_BACK, 0.6f);
2411                                         draw_object(base);
2412         
2413                                         if(base->object->transflag & OB_DUPLI) {
2414                                                 extern ListBase duplilist;
2415                                                 Base tbase;
2416                                                 
2417                                                 tbase.flag= OB_FROMDUPLI;
2418                                                 make_duplilist(G.scene->set, base->object);
2419                                                 ob= duplilist.first;
2420                                                 while(ob) {
2421                                                         tbase.object= ob;
2422                                                         draw_object(&tbase);
2423                                                         ob= ob->id.next;
2424                                                 }
2425                                                 free_duplilist();
2426                                         }
2427                                 }
2428                         }
2429                         base= base->next;
2430                 }
2431                 
2432                 /* Transp and X-ray afterdraw stuff */
2433                 view3d_draw_xray(v3d);  // clears zbuffer if it is used!
2434                 view3d_draw_transp(v3d);
2435                 
2436                 G.f &= ~G_PICKSEL;
2437         }
2438
2439         /* first not selected and duplis */
2440         base= G.scene->base.first;
2441         while(base) {
2442                 
2443                 if(v3d->lay & base->lay) {
2444                         if ELEM3(base->object->type, OB_LAMP, OB_CAMERA, OB_LATTICE);
2445                         else {
2446         
2447                                 if(base->object->transflag & OB_DUPLI) {
2448                                         extern ListBase duplilist;
2449                                         Base tbase;
2450                                         
2451                                         /* always draw original first because of make_displist */
2452                                         draw_object(base);
2453                                         
2454                                         /* patch: color remains constant */ 
2455                                         G.f |= G_PICKSEL;
2456                                         BIF_ThemeColorBlend(TH_WIRE, TH_BACK, 0.5f);
2457                                         
2458                                         tbase.flag= OB_FROMDUPLI;
2459                                         make_duplilist(G.scene, base->object);
2460                                         ob= duplilist.first;
2461                                         while(ob) {
2462                                                 tbase.object= ob;
2463                                                 draw_object(&tbase);
2464                                                 ob= ob->id.next;
2465                                         }
2466                                         free_duplilist();
2467                                         
2468                                         G.f &= ~G_PICKSEL;                              
2469                                 }
2470                                 else if((base->flag & SELECT)==0) {
2471                                         draw_object(base);
2472                                 }
2473                         }
2474                 }
2475                 
2476                 base= base->next;
2477         }
2478
2479         /* draw selected */
2480         base= G.scene->base.first;
2481         while(base) {
2482                 
2483                 if ( ((base)->flag & SELECT) && ((base)->lay & v3d->lay) ) {
2484                         if ELEM3(base->object->type, OB_LAMP, OB_CAMERA, OB_LATTICE);
2485                         else draw_object(base);
2486                 }
2487                 
2488                 base= base->next;
2489         }
2490
2491         if(G.scene->radio) RAD_drawall(v3d->drawtype>=OB_SOLID);
2492
2493         /* Transp and X-ray afterdraw stuff */
2494         view3d_draw_xray(v3d);  // clears zbuffer if it is used!
2495         view3d_draw_transp(v3d);
2496         
2497         if(v3d->flag & V3D_CLIPPING)
2498                 view3d_clr_clipping();
2499         
2500         if(v3d->zbuf) {
2501                 v3d->zbuf= FALSE;
2502                 glDisable(GL_DEPTH_TEST);
2503         }
2504         
2505         G.f &= ~G_SIMULATION;
2506
2507         glFlush();
2508
2509         glReadPixels(0, 0, R.rectx, R.recty, GL_RGBA, GL_UNSIGNED_BYTE, R.rectot);
2510         glLoadIdentity();
2511
2512         free_all_realtime_images();
2513 }
2514
2515
2516 double tottime = 0.0;
2517
2518 int update_time(void)
2519 {
2520         static double ltime;
2521         double time;
2522
2523         if ((U.mixbufsize)&&(audiostream_pos() != CFRA)&&(G.scene->audio.flag & AUDIO_SYNC)) return 0;
2524
2525         time = PIL_check_seconds_timer();
2526         
2527         tottime += (time - ltime);
2528         ltime = time;
2529         return (tottime < 0.0);
2530 }
2531
2532 void inner_play_anim_loop(int init, int mode)
2533 {
2534         ScrArea *sa;
2535         static ScrArea *oldsa;
2536         static double swaptime;
2537         static int curmode;
2538
2539         /* init */
2540         if(init) {
2541                 oldsa= curarea;
2542                 swaptime= 1.0/(float)G.scene->r.frs_sec;
2543                 tottime= 0.0;
2544                 curmode= mode;
2545
2546                 return;
2547         }
2548
2549         set_timecursor(CFRA);
2550         
2551         update_for_newframe_muted();
2552
2553         sa= G.curscreen->areabase.first;
2554         while(sa) {
2555                 if(sa==oldsa) {
2556                         scrarea_do_windraw(sa);
2557                 }
2558                 else if(curmode & 1) { /* catch modes 1 and 3 */
2559                         if ELEM(sa->spacetype, SPACE_VIEW3D, SPACE_SEQ) {
2560                                 scrarea_do_windraw(sa);
2561                         }
2562                 }
2563                 
2564                 sa= sa->next;   
2565         }
2566         
2567         /* make sure that swaptime passed by */
2568         tottime -= swaptime;
2569         while (update_time()) PIL_sleep_ms(1);
2570
2571         if(CFRA>=EFRA) {
2572                 if (tottime > 0.0) tottime = 0.0;
2573                 CFRA= SFRA;
2574                 audiostream_stop();
2575                 audiostream_start( CFRA );
2576         }
2577         else {
2578                 if (U.mixbufsize && (G.scene->audio.flag & AUDIO_SYNC)) CFRA = audiostream_pos();
2579                 else CFRA++;
2580         }
2581 }
2582
2583 /* play_anim: 'mode' defines where to play and if repeat is on:
2584  * - 0: current area
2585  * - 1: all view3d and seq areas
2586  * - 2: current area, no replay
2587  * - 3: all view3d and seq areas, no replay */
2588 int play_anim(int mode)
2589 {
2590         ScrArea *sa, *oldsa;
2591         int cfraont;
2592         unsigned short event=0;
2593         short val;
2594
2595         /* patch for very very old scenes */
2596         if(SFRA==0) SFRA= 1;
2597         if(EFRA==0) EFRA= 250;
2598
2599         if(SFRA>EFRA) return 0;
2600         
2601         update_time();
2602
2603         /* waitcursor(1); */
2604         G.f |= G_PLAYANIM;              /* in sequence.c and view.c this is handled */
2605
2606         cfraont= CFRA;
2607         oldsa= curarea;
2608
2609         audiostream_start( CFRA );
2610         
2611         inner_play_anim_loop(1, mode);  /* 1==init */
2612         
2613          /* forces all buffers to be OK for current frame (otherwise other windows get redrawn with CFRA+1) */
2614         curarea->win_swap= WIN_BACK_OK;
2615         screen_swapbuffers();
2616         
2617         while(TRUE) {
2618
2619                 while(qtest()) {
2620                         
2621                         /* we test events first because of MKEY event */
2622                         
2623                         event= extern_qread(&val);
2624                         if(event==ESCKEY) break;
2625                         else if(event==MIDDLEMOUSE) {
2626                                 if(U.flag & USER_VIEWMOVE) {
2627                                         if(G.qual & LR_SHIFTKEY) viewmove(0);
2628                                         else if(G.qual & LR_CTRLKEY) viewmove(2);
2629                                         else viewmove(1);
2630                                 }
2631                                 else {
2632                                         if(G.qual & LR_SHIFTKEY) viewmove(1);
2633                                         else if(G.qual & LR_CTRLKEY) viewmove(2);
2634                                         else viewmove(0);
2635                                 }
2636                         }
2637                         else if(event==MKEY) {
2638                                 if(val) add_timeline_marker(CFRA-1);
2639                         }
2640                 }
2641                 if(ELEM3(event, ESCKEY, SPACEKEY, RIGHTMOUSE)) break;
2642                 
2643                 inner_play_anim_loop(0, 0);
2644                 screen_swapbuffers();
2645                                 
2646                 if((mode > 1) && CFRA==EFRA) break; /* no replay */     
2647         }
2648
2649         if(event==SPACEKEY);
2650         else CFRA= cfraont;
2651         
2652         audiostream_stop();
2653
2654         if(oldsa!=curarea) areawinset(oldsa->win);
2655         
2656         /* restore all areas */
2657         sa= G.curscreen->areabase.first;
2658         while(sa) {
2659                 if( (mode && sa->spacetype==SPACE_VIEW3D) || sa==curarea) addqueue(sa->win, REDRAW, 1);
2660                 sa= sa->next;   
2661         }
2662         
2663         /* groups could have changed ipo */
2664         allspace(REMAKEIPO, 0);
2665         allqueue(REDRAWIPO, 0);
2666         allqueue(REDRAWNLA, 0);
2667         allqueue (REDRAWACTION, 0);
2668         
2669         /* restore for cfra */
2670         update_for_newframe_muted();
2671
2672         waitcursor(0);
2673         G.f &= ~G_PLAYANIM;
2674         
2675         if (event==ESCKEY || event==SPACEKEY) return 1;
2676         else return 0;
2677 }