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