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