removed blenderdef.h, BIF_*, BDR_* and BSE_* header files (except for BIF_gl.h and...
[blender.git] / source / blender / windowmanager / intern / wm_subwindow.c
1 /**
2  * $Id: mywindow.c 9584 2007-01-03 13:45:03Z ton $
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): 2007 Blender Foundation (refactor)
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  *
28  * Subwindow opengl handling. 
29  * BTW: subwindows open/close in X11 are way too slow, tried it, and choose for my own system... (ton)
30  * 
31  */
32
33 #include <string.h>
34
35 #include "MEM_guardedalloc.h"
36
37 #include "DNA_windowmanager_types.h"
38 #include "DNA_screen_types.h"
39
40 #include "BLI_blenlib.h"
41 #include "BLI_arithb.h"
42
43 #include "BKE_global.h"
44
45 #include "BIF_gl.h"
46 #include "BIF_glutil.h"
47
48 #include "WM_api.h"
49 #include "wm_window.h"
50
51 /* wmSubWindow stored in wmWindow... but not exposed outside this C file */
52 /* it seems a bit redundant (area regions can store it too, but we keep it
53    because we can store all kind of future opengl fanciness here */
54
55 /* we use indices and array because:
56    - index has safety, no pointers from this C file hanging around
57    - fast lookups of indices with array, list would give overhead
58    - old code used it this way...
59    - keep option open to have 2 screens using same window
60 */
61
62 typedef struct wmSubWindow {
63         struct wmSubWindow *next, *prev;
64         
65         rcti winrct;
66         int swinid;
67         
68         float viewmat[4][4], winmat[4][4];
69 } wmSubWindow;
70
71
72 /* ******************* open, free, set, get data ******************** */
73
74 /* not subwindow itself */
75 static void wm_subwindow_free(wmSubWindow *swin)
76 {
77         /* future fancy stuff */
78 }
79
80 void wm_subwindows_free(wmWindow *win)
81 {
82         wmSubWindow *swin;
83         
84         for(swin= win->subwindows.first; swin; swin= swin->next)
85                 wm_subwindow_free(swin);
86         
87         BLI_freelistN(&win->subwindows);
88 }
89
90
91 void wm_subwindow_getsize(wmWindow *win, int *x, int *y) 
92 {
93         if(win->curswin) {
94                 wmSubWindow *swin= win->curswin;
95                 *x= swin->winrct.xmax - swin->winrct.xmin + 1;
96                 *y= swin->winrct.ymax - swin->winrct.ymin + 1;
97         }
98 }
99
100 void wm_subwindow_getorigin(wmWindow *win, int *x, int *y)
101 {
102         if(win->curswin) {
103                 wmSubWindow *swin= win->curswin;
104                 *x= swin->winrct.xmin;
105                 *y= swin->winrct.ymin;
106         }
107 }
108
109 int wm_subwindow_get(wmWindow *win)     
110 {
111         if(win->curswin)
112                 return win->curswin->swinid;
113         return 0;
114 }
115
116 static wmSubWindow *swin_from_swinid(wmWindow *win, int swinid)
117 {
118         wmSubWindow *swin;
119         
120         for(swin= win->subwindows.first; swin; swin= swin->next)
121                 if(swin->swinid==swinid)
122                         break;
123         return swin;
124 }
125
126 void wm_subwindow_set(wmWindow *win, int swinid)
127 {
128         wmSubWindow *swin= swin_from_swinid(win, swinid);
129         int width, height;
130         
131         if(swin==NULL) {
132                 printf("wm_subwindow_set %d: doesn't exist\n", swinid);
133                 return;
134         }
135         
136         win->curswin= swin;
137         wm_subwindow_getsize(win, &width, &height);
138         
139         glViewport(swin->winrct.xmin, swin->winrct.ymin, width, height);
140         glScissor(swin->winrct.xmin, swin->winrct.ymin, width, height);
141         
142         glMatrixMode(GL_PROJECTION);
143         glLoadMatrixf(&swin->winmat[0][0]);
144         glMatrixMode(GL_MODELVIEW);
145         glLoadMatrixf(&swin->viewmat[0][0]);
146
147         glFlush();
148         
149 }
150
151 /* always sets pixel-precise 2D window/view matrices */
152 /* coords is in whole pixels. xmin = 15, xmax= 16: means window is 2 pix big */
153 int wm_subwindow_open(wmWindow *win, rcti *winrct)
154 {
155         wmSubWindow *swin;
156         int width, height;
157         int freewinid= 1;
158         
159         for(swin= win->subwindows.first; swin; swin= swin->next)
160                 if(freewinid <= swin->swinid)
161                         freewinid= swin->swinid+1;
162
163         win->curswin= swin= MEM_callocN(sizeof(wmSubWindow), "swinopen");
164
165         swin->swinid= freewinid;
166         swin->winrct= *winrct;
167
168         Mat4One(swin->viewmat);
169         Mat4One(swin->winmat);
170         
171         /* extra service */
172         wm_subwindow_getsize(win, &width, &height);
173         wmOrtho2(win, -0.375, (float)width-0.375, -0.375, (float)height-0.375);
174         wmLoadIdentity(win);
175         
176         /* and we appy it all right away */
177         wm_subwindow_set(win, swin->swinid);
178
179         return swin->swinid;
180 }
181
182
183 void wm_subwindow_close(wmWindow *win, int swinid)
184 {
185         wmSubWindow *swin= swin_from_swinid(win, swinid);
186
187         if (swin) {
188                 if (swin==win->curswin)
189                         win->curswin= NULL;
190                 wm_subwindow_free(swin);
191                 BLI_remlink(&win->subwindows, swin);
192                 MEM_freeN(swin);
193         } 
194         else {
195                 printf("wm_subwindow_close: Internal error, bad winid: %d\n", swinid);
196         }
197
198 }
199
200 /* pixels go from 0-99 for a 100 pixel window */
201 void wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct)
202 {
203         wmSubWindow *swin= swin_from_swinid(win, swinid);
204         
205         if(swin) {
206                 swin->winrct= *winrct;
207                 
208                 /* CRITICAL, this clamping ensures that
209                         * the viewport never goes outside the screen
210                         * edges (assuming the x, y coords aren't
211                                          * outside). This caused a hardware lock
212                         * on Matrox cards if it happens.
213                         * 
214                         * Really Blender should never _ever_ try
215                         * to do such a thing, but just to be safe
216                         * clamp it anyway (or fix the bScreen
217                     * scaling routine, and be damn sure you
218                     * fixed it). - zr  (2001!)
219                         */
220                 
221                 if (swin->winrct.xmax >= win->sizex)
222                         swin->winrct.xmax= win->sizex-1;
223                 if (swin->winrct.ymax >= win->sizey)
224                         swin->winrct.ymax= win->sizey-1;
225         }
226         else {
227                 printf("wm_subwindow_position: Internal error, bad winid: %d\n", swinid);
228         }
229 }
230
231 /* ---------------- WM versions of OpenGL calls, using glBlah() syntax ------------------------ */
232 /* ----------------- exported in WM_api.h ------------------------------------------------------ */
233
234 int glaGetOneInteger(int a)
235 {
236         return 0; // XXX
237 }
238
239 void wmLoadMatrix(wmWindow *win, float mat[][4])
240 {
241         if(win->curswin==NULL) return;
242         
243         glLoadMatrixf(mat);
244         
245         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
246                 Mat4CpyMat4(win->curswin->viewmat, mat);
247         else
248                 Mat4CpyMat4(win->curswin->winmat, mat);
249 }
250
251 void wmGetMatrix(wmWindow *win, float mat[][4])
252 {
253         if(win->curswin==NULL) return;
254         
255         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW) {
256                 Mat4CpyMat4(mat, win->curswin->viewmat);
257         } else {
258                 Mat4CpyMat4(mat, win->curswin->winmat);
259         }
260 }
261
262 void wmMultMatrix(wmWindow *win, float mat[][4])
263 {
264         if(win->curswin==NULL) return;
265         
266         glMultMatrixf((float*) mat);
267         
268         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
269                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->viewmat);
270         else
271                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->winmat);
272 }
273
274 void wmGetSingleMatrix(wmWindow *win, float mat[][4])
275 {
276         if(win->curswin)
277                 Mat4MulMat4(mat, win->curswin->viewmat, win->curswin->winmat);
278 }
279
280 void wmScale(wmWindow *win, float x, float y, float z)
281 {
282         if(win->curswin==NULL) return;
283         
284         glScalef(x, y, z);
285         
286         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
287                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->viewmat);
288         else
289                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->winmat);
290         
291 }
292
293 void wmLoadIdentity(wmWindow *win)
294 {
295         if(win->curswin==NULL) return;
296         
297         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
298                 Mat4One(win->curswin->viewmat);
299         else
300                 Mat4One(win->curswin->winmat);
301         
302         glLoadIdentity();
303 }
304
305 void wmFrustum(wmWindow *win, float x1, float x2, float y1, float y2, float n, float f)
306 {
307         if(win->curswin) {
308
309                 glMatrixMode(GL_PROJECTION);
310                 glLoadIdentity();
311                 glFrustum(x1, x2, y1, y2, n, f);
312
313                 glGetFloatv(GL_PROJECTION_MATRIX, (float *)win->curswin->winmat);
314                 glMatrixMode(GL_MODELVIEW);
315         }
316 }
317
318 void wmOrtho(wmWindow *win, float x1, float x2, float y1, float y2, float n, float f)
319 {
320         if(win->curswin) {
321                 
322                 glMatrixMode(GL_PROJECTION);
323                 glLoadIdentity();
324                 
325                 glOrtho(x1, x2, y1, y2, n, f);
326                 
327                 glGetFloatv(GL_PROJECTION_MATRIX, (float *)win->curswin->winmat);
328                 glMatrixMode(GL_MODELVIEW);
329         }
330 }
331
332 void wmOrtho2(wmWindow *win, float x1, float x2, float y1, float y2)
333 {
334         /* prevent opengl from generating errors */
335         if(x1==x2) x2+=1.0;
336         if(y1==y2) y2+=1.0;
337         wmOrtho(win, x1, x2, y1, y2, -100, 100);
338 }
339
340
341 /* *************************** Framebuffer color depth, for selection codes ********************** */
342
343 static int wm_get_colordepth(void)
344 {
345         static int mainwin_color_depth= 0;      
346         
347         if(mainwin_color_depth==0) {
348                 GLint r, g, b;
349                 
350                 glGetIntegerv(GL_RED_BITS, &r);
351                 glGetIntegerv(GL_GREEN_BITS, &g);
352                 glGetIntegerv(GL_BLUE_BITS, &b);
353                 
354                 mainwin_color_depth= r + g + b;
355                 if(G.f & G_DEBUG) {
356                         printf("Color depth r %d g %d b %d\n", (int)r, (int)g, (int)b);
357                         glGetIntegerv(GL_AUX_BUFFERS, &r);
358                         printf("Aux buffers: %d\n", (int)r);
359                 }
360         }
361         return mainwin_color_depth;
362 }
363
364
365 #ifdef __APPLE__
366
367 /* apple seems to round colors to below and up on some configs */
368
369 static unsigned int index_to_framebuffer(int index)
370 {
371         unsigned int i= index;
372
373         switch(wm_get_colordepth()) {
374         case 12:
375                 i= ((i & 0xF00)<<12) + ((i & 0xF0)<<8) + ((i & 0xF)<<4);
376                 /* sometimes dithering subtracts! */
377                 i |= 0x070707;
378                 break;
379         case 15:
380         case 16:
381                 i= ((i & 0x7C00)<<9) + ((i & 0x3E0)<<6) + ((i & 0x1F)<<3);
382                 i |= 0x030303;
383                 break;
384         case 24:
385                 break;
386         default:        // 18 bits... 
387                 i= ((i & 0x3F000)<<6) + ((i & 0xFC0)<<4) + ((i & 0x3F)<<2);
388                 i |= 0x010101;
389                 break;
390         }
391         
392         return i;
393 }
394
395 #else
396
397 /* this is the old method as being in use for ages.... seems to work? colors are rounded to lower values */
398
399 static unsigned int index_to_framebuffer(int index)
400 {
401         unsigned int i= index;
402         
403         switch(wm_get_colordepth()) {
404                 case 8:
405                         i= ((i & 48)<<18) + ((i & 12)<<12) + ((i & 3)<<6);
406                         i |= 0x3F3F3F;
407                         break;
408                 case 12:
409                         i= ((i & 0xF00)<<12) + ((i & 0xF0)<<8) + ((i & 0xF)<<4);
410                         /* sometimes dithering subtracts! */
411                         i |= 0x0F0F0F;
412                         break;
413                 case 15:
414                 case 16:
415                         i= ((i & 0x7C00)<<9) + ((i & 0x3E0)<<6) + ((i & 0x1F)<<3);
416                         i |= 0x070707;
417                         break;
418                 case 24:
419                         break;
420                 default:        // 18 bits... 
421                         i= ((i & 0x3F000)<<6) + ((i & 0xFC0)<<4) + ((i & 0x3F)<<2);
422                         i |= 0x030303;
423                         break;
424         }
425         
426         return i;
427 }
428
429 #endif
430
431 void set_framebuffer_index_color(int index)
432 {
433         cpack(index_to_framebuffer(index));
434 }
435
436 int framebuffer_to_index(unsigned int col)
437 {
438         if (col==0) return 0;
439
440         switch(wm_get_colordepth()) {
441         case 8:
442                 return ((col & 0xC00000)>>18) + ((col & 0xC000)>>12) + ((col & 0xC0)>>6);
443         case 12:
444                 return ((col & 0xF00000)>>12) + ((col & 0xF000)>>8) + ((col & 0xF0)>>4);
445         case 15:
446         case 16:
447                 return ((col & 0xF80000)>>9) + ((col & 0xF800)>>6) + ((col & 0xF8)>>3);
448         case 24:
449                 return col & 0xFFFFFF;
450         default: // 18 bits...
451                 return ((col & 0xFC0000)>>6) + ((col & 0xFC00)>>4) + ((col & 0xFC)>>2);
452         }               
453 }
454
455
456 /* ********** END MY WINDOW ************** */
457
458 #ifdef WIN32
459 static int is_a_really_crappy_nvidia_card(void) {
460         static int well_is_it= -1;
461
462                 /* Do you understand the implication? Do you? */
463         if (well_is_it==-1)
464                 well_is_it= (strcmp((char*) glGetString(GL_VENDOR), "NVIDIA Corporation") == 0);
465
466         return well_is_it;
467 }
468 #endif
469
470 void myswapbuffers(void)        /* XXX */
471 {
472         ScrArea *sa;
473         
474         sa= G.curscreen->areabase.first;
475         while(sa) {
476                 if(sa->win_swap==WIN_BACK_OK) sa->win_swap= WIN_FRONT_OK;
477                 if(sa->head_swap==WIN_BACK_OK) sa->head_swap= WIN_FRONT_OK;
478                 
479                 sa= sa->next;
480         }
481
482         /* HACK, some windows drivers feel they should honor the scissor
483          * test when swapping buffers, disable the test while swapping
484          * on WIN32. (namely Matrox and NVidia's new drivers around Oct 1 2001)
485          * - zr
486          */
487
488 #ifdef WIN32
489                 /* HACK, in some NVidia driver release some kind of
490                  * fancy optimiziation (I presume) was put in which for
491                  * some reason causes parts of the buffer not to be
492                  * swapped. One way to defeat it is the following wierd
493                  * code (which we only do for nvidia cards). This should
494                  * be removed if NVidia fixes their drivers. - zr
495                  */
496         if (is_a_really_crappy_nvidia_card()) {
497                 glDrawBuffer(GL_FRONT);
498
499                 glBegin(GL_LINES);
500                 glEnd();
501
502                 glDrawBuffer(GL_BACK);
503         }
504
505         glDisable(GL_SCISSOR_TEST);
506 //      window_swap_buffers(winlay_mainwindow);
507         glEnable(GL_SCISSOR_TEST);
508 #else
509 //      window_swap_buffers(winlay_mainwindow);
510 #endif
511 }
512
513
514 /* *********************** PATTERNS ETC ***************** */
515
516 void setlinestyle(int nr)       /* Move? XXX */
517 {
518         if(nr==0) {
519                 glDisable(GL_LINE_STIPPLE);
520         }
521         else {
522                 
523                 glEnable(GL_LINE_STIPPLE);
524                 glLineStipple(nr, 0xAAAA);
525         }
526 }
527