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