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