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