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