2.50: svn merge https://svn.blender.org/svnroot/bf-blender/trunk/blender -r17853...
[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 void wmSubWindowScissorSet(wmWindow *win, int swinid, rcti *srct)
235 {
236         int width, height;
237         _curswin= swin_from_swinid(win, swinid);
238         
239         if(_curswin==NULL) {
240                 printf("wmSubWindowSet %d: doesn't exist\n", swinid);
241                 return;
242         }
243         
244         win->curswin= _curswin;
245         _curwindow= win;
246         
247         width= _curswin->winrct.xmax - _curswin->winrct.xmin + 1;
248         height= _curswin->winrct.ymax - _curswin->winrct.ymin + 1;
249         glViewport(_curswin->winrct.xmin, _curswin->winrct.ymin, width, height);
250
251         if(srct) {
252                 width= srct->xmax - srct->xmin + 1;
253                 height= srct->ymax - srct->ymin + 1;
254                 glScissor(srct->xmin, srct->ymin, width, height);
255         }
256         else
257                 glScissor(_curswin->winrct.xmin, _curswin->winrct.ymin, width, height);
258         
259         glMatrixMode(GL_PROJECTION);
260         glLoadMatrixf(&_curswin->winmat[0][0]);
261         glMatrixMode(GL_MODELVIEW);
262         glLoadMatrixf(&_curswin->viewmat[0][0]);
263         
264         glFlush();
265 }
266
267
268 /* enable the WM versions of opengl calls */
269 void wmSubWindowSet(wmWindow *win, int swinid)
270 {
271         wmSubWindowScissorSet(win, swinid, NULL);
272 }
273
274 void wmLoadMatrix(float mat[][4])
275 {
276         if(_curswin==NULL) return;
277         
278         glLoadMatrixf(mat);
279         
280         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
281                 Mat4CpyMat4(_curswin->viewmat, mat);
282         else
283                 Mat4CpyMat4(_curswin->winmat, mat);
284 }
285
286 void wmGetMatrix(float mat[][4])
287 {
288         if(_curswin==NULL) return;
289         
290         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW) {
291                 Mat4CpyMat4(mat, _curswin->viewmat);
292         } else {
293                 Mat4CpyMat4(mat, _curswin->winmat);
294         }
295 }
296
297 void wmMultMatrix(float mat[][4])
298 {
299         if(_curswin==NULL) return;
300         
301         glMultMatrixf((float*) mat);
302         
303         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
304                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)_curswin->viewmat);
305         else
306                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)_curswin->winmat);
307 }
308
309 void wmGetSingleMatrix(float mat[][4])
310 {
311         if(_curswin)
312                 Mat4MulMat4(mat, _curswin->viewmat, _curswin->winmat);
313 }
314
315 void wmScale(float x, float y, float z)
316 {
317         if(_curswin==NULL) return;
318         
319         glScalef(x, y, z);
320         
321         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
322                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)_curswin->viewmat);
323         else
324                 glGetFloatv(GL_MODELVIEW_MATRIX, (float *)_curswin->winmat);
325         
326 }
327
328 void wmLoadIdentity(void)
329 {
330         if(_curswin==NULL) return;
331         
332         if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
333                 Mat4One(_curswin->viewmat);
334         else
335                 Mat4One(_curswin->winmat);
336         
337         glLoadIdentity();
338 }
339
340 void wmFrustum(float x1, float x2, float y1, float y2, float n, float f)
341 {
342         if(_curswin) {
343
344                 glMatrixMode(GL_PROJECTION);
345                 glLoadIdentity();
346                 glFrustum(x1, x2, y1, y2, n, f);
347
348                 glGetFloatv(GL_PROJECTION_MATRIX, (float *)_curswin->winmat);
349                 glMatrixMode(GL_MODELVIEW);
350         }
351 }
352
353 void wmOrtho(float x1, float x2, float y1, float y2, float n, float f)
354 {
355         if(_curswin) {
356                 
357                 glMatrixMode(GL_PROJECTION);
358                 glLoadIdentity();
359                 
360                 glOrtho(x1, x2, y1, y2, n, f);
361                 
362                 glGetFloatv(GL_PROJECTION_MATRIX, (float *)_curswin->winmat);
363                 glMatrixMode(GL_MODELVIEW);
364         }
365 }
366
367 void wmOrtho2(float x1, float x2, float y1, float y2)
368 {
369         /* prevent opengl from generating errors */
370         if(x1==x2) x2+=1.0;
371         if(y1==y2) y2+=1.0;
372         wmOrtho(x1, x2, y1, y2, -100, 100);
373 }
374
375
376 /* *************************** Framebuffer color depth, for selection codes ********************** */
377
378 static int wm_get_colordepth(void)
379 {
380         static int mainwin_color_depth= 0;      
381         
382         if(mainwin_color_depth==0) {
383                 GLint r, g, b;
384                 
385                 glGetIntegerv(GL_RED_BITS, &r);
386                 glGetIntegerv(GL_GREEN_BITS, &g);
387                 glGetIntegerv(GL_BLUE_BITS, &b);
388                 
389                 mainwin_color_depth= r + g + b;
390                 if(G.f & G_DEBUG) {
391                         printf("Color depth r %d g %d b %d\n", (int)r, (int)g, (int)b);
392                         glGetIntegerv(GL_AUX_BUFFERS, &r);
393                         printf("Aux buffers: %d\n", (int)r);
394                 }
395         }
396         return mainwin_color_depth;
397 }
398
399
400 #ifdef __APPLE__
401
402 /* apple seems to round colors to below and up on some configs */
403
404 static unsigned int index_to_framebuffer(int index)
405 {
406         unsigned int i= index;
407
408         switch(wm_get_colordepth()) {
409         case 12:
410                 i= ((i & 0xF00)<<12) + ((i & 0xF0)<<8) + ((i & 0xF)<<4);
411                 /* sometimes dithering subtracts! */
412                 i |= 0x070707;
413                 break;
414         case 15:
415         case 16:
416                 i= ((i & 0x7C00)<<9) + ((i & 0x3E0)<<6) + ((i & 0x1F)<<3);
417                 i |= 0x030303;
418                 break;
419         case 24:
420                 break;
421         default:        // 18 bits... 
422                 i= ((i & 0x3F000)<<6) + ((i & 0xFC0)<<4) + ((i & 0x3F)<<2);
423                 i |= 0x010101;
424                 break;
425         }
426         
427         return i;
428 }
429
430 #else
431
432 /* this is the old method as being in use for ages.... seems to work? colors are rounded to lower values */
433
434 static unsigned int index_to_framebuffer(int index)
435 {
436         unsigned int i= index;
437         
438         switch(wm_get_colordepth()) {
439                 case 8:
440                         i= ((i & 48)<<18) + ((i & 12)<<12) + ((i & 3)<<6);
441                         i |= 0x3F3F3F;
442                         break;
443                 case 12:
444                         i= ((i & 0xF00)<<12) + ((i & 0xF0)<<8) + ((i & 0xF)<<4);
445                         /* sometimes dithering subtracts! */
446                         i |= 0x0F0F0F;
447                         break;
448                 case 15:
449                 case 16:
450                         i= ((i & 0x7C00)<<9) + ((i & 0x3E0)<<6) + ((i & 0x1F)<<3);
451                         i |= 0x070707;
452                         break;
453                 case 24:
454                         break;
455                 default:        // 18 bits... 
456                         i= ((i & 0x3F000)<<6) + ((i & 0xFC0)<<4) + ((i & 0x3F)<<2);
457                         i |= 0x030303;
458                         break;
459         }
460         
461         return i;
462 }
463
464 #endif
465
466 void WM_set_framebuffer_index_color(int index)
467 {
468         cpack(index_to_framebuffer(index));
469 }
470
471 int WM_framebuffer_to_index(unsigned int col)
472 {
473         if (col==0) return 0;
474
475         switch(wm_get_colordepth()) {
476         case 8:
477                 return ((col & 0xC00000)>>18) + ((col & 0xC000)>>12) + ((col & 0xC0)>>6);
478         case 12:
479                 return ((col & 0xF00000)>>12) + ((col & 0xF000)>>8) + ((col & 0xF0)>>4);
480         case 15:
481         case 16:
482                 return ((col & 0xF80000)>>9) + ((col & 0xF800)>>6) + ((col & 0xF8)>>3);
483         case 24:
484                 return col & 0xFFFFFF;
485         default: // 18 bits...
486                 return ((col & 0xFC0000)>>6) + ((col & 0xFC00)>>4) + ((col & 0xFC)>>2);
487         }               
488 }
489
490
491 /* ********** END MY WINDOW ************** */
492
493 #ifdef WIN32
494 static int is_a_really_crappy_nvidia_card(void) {
495         static int well_is_it= -1;
496
497                 /* Do you understand the implication? Do you? */
498         if (well_is_it==-1)
499                 well_is_it= (strcmp((char*) glGetString(GL_VENDOR), "NVIDIA Corporation") == 0);
500
501         return well_is_it;
502 }
503 #endif
504