1 /* 2 * Windows (Win32/Win64) device driver for Mesa 3 * 4 */ 5 6 #include "wmesadef.h" 7 #include "colors.h" 8 #include "GL/wmesa.h" 9 #include <winuser.h> 10 #include "main/context.h" 11 #include "main/extensions.h" 12 #include "main/framebuffer.h" 13 #include "main/renderbuffer.h" 14 #include "main/macros.h" 15 #include "drivers/common/driverfuncs.h" 16 #include "drivers/common/meta.h" 17 #include "vbo/vbo.h" 18 #include "swrast/swrast.h" 19 #include "swrast/s_renderbuffer.h" 20 #include "swrast_setup/swrast_setup.h" 21 #include "tnl/tnl.h" 22 #include "tnl/t_context.h" 23 #include "tnl/t_pipeline.h" 24 25 26 /* linked list of our Framebuffers (windows) */ 27 static WMesaFramebuffer FirstFramebuffer = NULL; 28 29 30 /** 31 * Create a new WMesaFramebuffer object which will correspond to the 32 * given HDC (Window handle). 33 */ 34 static WMesaFramebuffer 35 wmesa_new_framebuffer(HDC hdc, struct gl_config *visual) 36 { 37 WMesaFramebuffer pwfb 38 = (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer)); 39 if (pwfb) { 40 _mesa_initialize_window_framebuffer(&pwfb->Base, visual); 41 pwfb->hDC = hdc; 42 /* insert at head of list */ 43 pwfb->next = FirstFramebuffer; 44 FirstFramebuffer = pwfb; 45 } 46 return pwfb; 47 } 48 49 /** 50 * Given an hdc, free the corresponding WMesaFramebuffer 51 */ 52 static void 53 wmesa_free_framebuffer(HDC hdc) 54 { 55 WMesaFramebuffer pwfb, prev; 56 for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) { 57 if (pwfb->hDC == hdc) 58 break; 59 prev = pwfb; 60 } 61 if (pwfb) { 62 struct gl_framebuffer *fb; 63 if (pwfb == FirstFramebuffer) 64 FirstFramebuffer = pwfb->next; 65 else 66 prev->next = pwfb->next; 67 fb = &pwfb->Base; 68 _mesa_reference_framebuffer(&fb, NULL); 69 } 70 } 71 72 /** 73 * Given an hdc, return the corresponding WMesaFramebuffer 74 */ 75 static WMesaFramebuffer 76 wmesa_lookup_framebuffer(HDC hdc) 77 { 78 WMesaFramebuffer pwfb; 79 for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) { 80 if (pwfb->hDC == hdc) 81 return pwfb; 82 } 83 return NULL; 84 } 85 86 87 /** 88 * Given a struct gl_framebuffer, return the corresponding WMesaFramebuffer. 89 */ 90 static WMesaFramebuffer wmesa_framebuffer(struct gl_framebuffer *fb) 91 { 92 return (WMesaFramebuffer) fb; 93 } 94 95 96 /** 97 * Given a struct gl_context, return the corresponding WMesaContext. 98 */ 99 static WMesaContext wmesa_context(const struct gl_context *ctx) 100 { 101 return (WMesaContext) ctx; 102 } 103 104 105 /* 106 * Every driver should implement a GetString function in order to 107 * return a meaningful GL_RENDERER string. 108 */ 109 static const GLubyte *wmesa_get_string(struct gl_context *ctx, GLenum name) 110 { 111 return (name == GL_RENDERER) ? 112 (GLubyte *) "Mesa Windows GDI Driver" : NULL; 113 } 114 115 116 /* 117 * Determine the pixel format based on the pixel size. 118 */ 119 static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC) 120 { 121 pwfb->cColorBits = GetDeviceCaps(hDC, BITSPIXEL); 122 123 /* Only 16 and 32 bit targets are supported now */ 124 assert(pwfb->cColorBits == 0 || 125 pwfb->cColorBits == 16 || 126 pwfb->cColorBits == 24 || 127 pwfb->cColorBits == 32); 128 129 switch(pwfb->cColorBits){ 130 case 8: 131 pwfb->pixelformat = PF_INDEX8; 132 break; 133 case 16: 134 pwfb->pixelformat = PF_5R6G5B; 135 break; 136 case 24: 137 case 32: 138 pwfb->pixelformat = PF_8R8G8B; 139 break; 140 default: 141 pwfb->pixelformat = PF_BADFORMAT; 142 } 143 } 144 145 146 /** 147 * Create DIB for back buffer. 148 * We write into this memory with the span routines and then blit it 149 * to the window on a buffer swap. 150 */ 151 static BOOL wmCreateBackingStore(WMesaFramebuffer pwfb, long lxSize, long lySize) 152 { 153 LPBITMAPINFO pbmi = &(pwfb->bmi); 154 HDC hic; 155 156 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 157 pbmi->bmiHeader.biWidth = lxSize; 158 pbmi->bmiHeader.biHeight= -lySize; 159 pbmi->bmiHeader.biPlanes = 1; 160 pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwfb->hDC, BITSPIXEL); 161 pbmi->bmiHeader.biCompression = BI_RGB; 162 pbmi->bmiHeader.biSizeImage = 0; 163 pbmi->bmiHeader.biXPelsPerMeter = 0; 164 pbmi->bmiHeader.biYPelsPerMeter = 0; 165 pbmi->bmiHeader.biClrUsed = 0; 166 pbmi->bmiHeader.biClrImportant = 0; 167 168 pwfb->cColorBits = pbmi->bmiHeader.biBitCount; 169 pwfb->ScanWidth = (lxSize * (pwfb->cColorBits / 8) + 3) & ~3; 170 171 hic = CreateIC("display", NULL, NULL, NULL); 172 pwfb->dib_hDC = CreateCompatibleDC(hic); 173 174 pwfb->hbmDIB = CreateDIBSection(hic, 175 &pwfb->bmi, 176 DIB_RGB_COLORS, 177 (void **)&(pwfb->pbPixels), 178 0, 179 0); 180 pwfb->hOldBitmap = SelectObject(pwfb->dib_hDC, pwfb->hbmDIB); 181 182 DeleteDC(hic); 183 184 wmSetPixelFormat(pwfb, pwfb->hDC); 185 return TRUE; 186 } 187 188 189 static void wmDeleteBackingStore(WMesaFramebuffer pwfb) 190 { 191 if (pwfb->hbmDIB) { 192 SelectObject(pwfb->dib_hDC, pwfb->hOldBitmap); 193 DeleteDC(pwfb->dib_hDC); 194 DeleteObject(pwfb->hbmDIB); 195 } 196 } 197 198 199 /** 200 * Find the width and height of the window named by hdc. 201 */ 202 static void 203 get_window_size(HDC hdc, GLuint *width, GLuint *height) 204 { 205 if (WindowFromDC(hdc)) { 206 RECT rect; 207 GetClientRect(WindowFromDC(hdc), &rect); 208 *width = rect.right - rect.left; 209 *height = rect.bottom - rect.top; 210 } 211 else { /* Memory context */ 212 /* From contributed code - use the size of the desktop 213 * for the size of a memory context (?) */ 214 *width = GetDeviceCaps(hdc, HORZRES); 215 *height = GetDeviceCaps(hdc, VERTRES); 216 } 217 } 218 219 220 static void 221 wmesa_get_buffer_size(struct gl_framebuffer *buffer, GLuint *width, GLuint *height) 222 { 223 WMesaFramebuffer pwfb = wmesa_framebuffer(buffer); 224 get_window_size(pwfb->hDC, width, height); 225 } 226 227 228 static void wmesa_flush(struct gl_context *ctx) 229 { 230 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->WinSysDrawBuffer); 231 232 if (ctx->Visual.doubleBufferMode == 1) { 233 BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height, 234 pwfb->dib_hDC, 0, 0, SRCCOPY); 235 } 236 else { 237 /* Do nothing for single buffer */ 238 } 239 } 240 241 242 /**********************************************************************/ 243 /***** CLEAR Functions *****/ 244 /**********************************************************************/ 245 246 /* 247 * Clear the color/depth/stencil buffers. 248 */ 249 static void clear(struct gl_context *ctx, GLbitfield mask) 250 { 251 #define FLIP(Y) (ctx->DrawBuffer->Height - (Y) - 1) 252 const GLint x = ctx->DrawBuffer->_Xmin; 253 const GLint y = ctx->DrawBuffer->_Ymin; 254 const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin; 255 const GLint width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin; 256 257 WMesaContext pwc = wmesa_context(ctx); 258 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 259 int done = 0; 260 261 /* Let swrast do all the work if the masks are not set to 262 * clear all channels. */ 263 if (!ctx->Color.ColorMask[0][0] || 264 !ctx->Color.ColorMask[0][1] || 265 !ctx->Color.ColorMask[0][2] || 266 !ctx->Color.ColorMask[0][3]) { 267 _swrast_Clear(ctx, mask); 268 return; 269 } 270 271 if (mask & BUFFER_BITS_COLOR) { 272 /* setup the clearing color */ 273 const union gl_color_union color = ctx->Color.ClearColor; 274 GLubyte col[3]; 275 UNCLAMPED_FLOAT_TO_UBYTE(col[0], color.f[0]); 276 UNCLAMPED_FLOAT_TO_UBYTE(col[1], color.f[1]); 277 UNCLAMPED_FLOAT_TO_UBYTE(col[2], color.f[2]); 278 pwc->clearColorRef = RGB(col[0], col[1], col[2]); 279 DeleteObject(pwc->clearPen); 280 DeleteObject(pwc->clearBrush); 281 pwc->clearPen = CreatePen(PS_SOLID, 1, pwc->clearColorRef); 282 pwc->clearBrush = CreateSolidBrush(pwc->clearColorRef); 283 } 284 285 /* Back buffer */ 286 if (mask & BUFFER_BIT_BACK_LEFT) { 287 288 int i, rowSize; 289 UINT bytesPerPixel = pwfb->cColorBits / 8; 290 LPBYTE lpb, clearRow; 291 LPWORD lpw; 292 BYTE bColor; 293 WORD wColor; 294 BYTE r, g, b; 295 DWORD dwColor; 296 LPDWORD lpdw; 297 298 /* Try for a fast clear - clearing entire buffer with a single 299 * byte value. */ 300 if (width == ctx->DrawBuffer->Width && 301 height == ctx->DrawBuffer->Height) { /* entire buffer */ 302 /* Now check for an easy clear value */ 303 switch (bytesPerPixel) { 304 case 1: 305 bColor = BGR8(GetRValue(pwc->clearColorRef), 306 GetGValue(pwc->clearColorRef), 307 GetBValue(pwc->clearColorRef)); 308 memset(pwfb->pbPixels, bColor, 309 pwfb->ScanWidth * height); 310 done = 1; 311 break; 312 case 2: 313 wColor = BGR16(GetRValue(pwc->clearColorRef), 314 GetGValue(pwc->clearColorRef), 315 GetBValue(pwc->clearColorRef)); 316 if (((wColor >> 8) & 0xff) == (wColor & 0xff)) { 317 memset(pwfb->pbPixels, wColor & 0xff, 318 pwfb->ScanWidth * height); 319 done = 1; 320 } 321 break; 322 case 3: 323 /* fall through */ 324 case 4: 325 if (GetRValue(pwc->clearColorRef) == 326 GetGValue(pwc->clearColorRef) && 327 GetRValue(pwc->clearColorRef) == 328 GetBValue(pwc->clearColorRef)) { 329 memset(pwfb->pbPixels, 330 GetRValue(pwc->clearColorRef), 331 pwfb->ScanWidth * height); 332 done = 1; 333 } 334 break; 335 default: 336 break; 337 } 338 } /* all */ 339 340 if (!done) { 341 /* Need to clear a row at a time. Begin by setting the first 342 * row in the area to be cleared to the clear color. */ 343 344 clearRow = pwfb->pbPixels + 345 pwfb->ScanWidth * FLIP(y) + 346 bytesPerPixel * x; 347 switch (bytesPerPixel) { 348 case 1: 349 lpb = clearRow; 350 bColor = BGR8(GetRValue(pwc->clearColorRef), 351 GetGValue(pwc->clearColorRef), 352 GetBValue(pwc->clearColorRef)); 353 memset(lpb, bColor, width); 354 break; 355 case 2: 356 lpw = (LPWORD)clearRow; 357 wColor = BGR16(GetRValue(pwc->clearColorRef), 358 GetGValue(pwc->clearColorRef), 359 GetBValue(pwc->clearColorRef)); 360 for (i=0; i<width; i++) 361 *lpw++ = wColor; 362 break; 363 case 3: 364 lpb = clearRow; 365 r = GetRValue(pwc->clearColorRef); 366 g = GetGValue(pwc->clearColorRef); 367 b = GetBValue(pwc->clearColorRef); 368 for (i=0; i<width; i++) { 369 *lpb++ = b; 370 *lpb++ = g; 371 *lpb++ = r; 372 } 373 break; 374 case 4: 375 lpdw = (LPDWORD)clearRow; 376 dwColor = BGR32(GetRValue(pwc->clearColorRef), 377 GetGValue(pwc->clearColorRef), 378 GetBValue(pwc->clearColorRef)); 379 for (i=0; i<width; i++) 380 *lpdw++ = dwColor; 381 break; 382 default: 383 break; 384 } /* switch */ 385 386 /* copy cleared row to other rows in buffer */ 387 lpb = clearRow - pwfb->ScanWidth; 388 rowSize = width * bytesPerPixel; 389 for (i=1; i<height; i++) { 390 memcpy(lpb, clearRow, rowSize); 391 lpb -= pwfb->ScanWidth; 392 } 393 } /* not done */ 394 mask &= ~BUFFER_BIT_BACK_LEFT; 395 } /* back buffer */ 396 397 /* front buffer */ 398 if (mask & BUFFER_BIT_FRONT_LEFT) { 399 HDC DC = pwc->hDC; 400 HPEN Old_Pen = SelectObject(DC, pwc->clearPen); 401 HBRUSH Old_Brush = SelectObject(DC, pwc->clearBrush); 402 Rectangle(DC, 403 x, 404 FLIP(y) + 1, 405 x + width + 1, 406 FLIP(y) - height + 1); 407 SelectObject(DC, Old_Pen); 408 SelectObject(DC, Old_Brush); 409 mask &= ~BUFFER_BIT_FRONT_LEFT; 410 } /* front buffer */ 411 412 /* Call swrast if there is anything left to clear (like DEPTH) */ 413 if (mask) 414 _swrast_Clear(ctx, mask); 415 416 #undef FLIP 417 } 418 419 420 /**********************************************************************/ 421 /***** PIXEL Functions *****/ 422 /**********************************************************************/ 423 424 #define FLIP(Y) (rb->Height - (Y) - 1) 425 426 427 /** 428 ** Front Buffer reading/writing 429 ** These are slow, but work with all non-indexed visual types. 430 **/ 431 432 /* Write a horizontal span of RGBA color pixels with a boolean mask. */ 433 static void write_rgba_span_front(struct gl_context *ctx, 434 struct gl_renderbuffer *rb, 435 GLuint n, GLint x, GLint y, 436 const void *values, 437 const GLubyte *mask) 438 { 439 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 440 WMesaContext pwc = wmesa_context(ctx); 441 WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(pwc->hDC); 442 HBITMAP bmp=0; 443 HDC mdc=0; 444 typedef union 445 { 446 unsigned i; 447 struct { 448 unsigned b:8, g:8, r:8, a:8; 449 }; 450 } BGRA; 451 BGRA *bgra, c; 452 GLuint i; 453 454 if (n < 16) { // the value 16 is just guessed 455 y=FLIP(y); 456 if (mask) { 457 for (i=0; i<n; i++) 458 if (mask[i]) 459 SetPixel(pwc->hDC, x+i, y, 460 RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP])); 461 } 462 else { 463 for (i=0; i<n; i++) 464 SetPixel(pwc->hDC, x+i, y, 465 RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP])); 466 } 467 } 468 else { 469 if (!pwfb) { 470 _mesa_problem(NULL, "wmesa: write_rgba_span_front on unknown hdc"); 471 return; 472 } 473 bgra=malloc(n*sizeof(BGRA)); 474 if (!bgra) { 475 _mesa_problem(NULL, "wmesa: write_rgba_span_front: out of memory"); 476 return; 477 } 478 c.a=0; 479 if (mask) { 480 for (i=0; i<n; i++) { 481 if (mask[i]) { 482 c.r=rgba[i][RCOMP]; 483 c.g=rgba[i][GCOMP]; 484 c.b=rgba[i][BCOMP]; 485 c.a=rgba[i][ACOMP]; 486 bgra[i]=c; 487 } 488 else 489 bgra[i].i=0; 490 } 491 } 492 else { 493 for (i=0; i<n; i++) { 494 c.r=rgba[i][RCOMP]; 495 c.g=rgba[i][GCOMP]; 496 c.b=rgba[i][BCOMP]; 497 c.a=rgba[i][ACOMP]; 498 bgra[i]=c; 499 } 500 } 501 bmp=CreateBitmap(n, 1, 1, 32, bgra); 502 mdc=CreateCompatibleDC(pwfb->hDC); 503 SelectObject(mdc, bmp); 504 y=FLIP(y); 505 BitBlt(pwfb->hDC, x, y, n, 1, mdc, 0, 0, SRCCOPY); 506 SelectObject(mdc, 0); 507 DeleteObject(bmp); 508 DeleteDC(mdc); 509 free(bgra); 510 } 511 } 512 513 514 /* Write an array of RGBA pixels with a boolean mask. */ 515 static void write_rgba_pixels_front(struct gl_context *ctx, 516 struct gl_renderbuffer *rb, 517 GLuint n, 518 const GLint x[], const GLint y[], 519 const void *values, 520 const GLubyte *mask) 521 { 522 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 523 GLuint i; 524 WMesaContext pwc = wmesa_context(ctx); 525 (void) ctx; 526 for (i=0; i<n; i++) 527 if (mask[i]) 528 SetPixel(pwc->hDC, x[i], FLIP(y[i]), 529 RGB(rgba[i][RCOMP], rgba[i][GCOMP], 530 rgba[i][BCOMP])); 531 } 532 533 534 535 /* Read a horizontal span of color pixels. */ 536 static void read_rgba_span_front(struct gl_context *ctx, 537 struct gl_renderbuffer *rb, 538 GLuint n, GLint x, GLint y, 539 void *values) 540 { 541 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 542 WMesaContext pwc = wmesa_context(ctx); 543 GLuint i; 544 COLORREF Color; 545 y = FLIP(y); 546 for (i=0; i<n; i++) { 547 Color = GetPixel(pwc->hDC, x+i, y); 548 rgba[i][RCOMP] = GetRValue(Color); 549 rgba[i][GCOMP] = GetGValue(Color); 550 rgba[i][BCOMP] = GetBValue(Color); 551 rgba[i][ACOMP] = 255; 552 } 553 } 554 555 556 /* Read an array of color pixels. */ 557 static void read_rgba_pixels_front(struct gl_context *ctx, 558 struct gl_renderbuffer *rb, 559 GLuint n, const GLint x[], const GLint y[], 560 void *values) 561 { 562 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 563 WMesaContext pwc = wmesa_context(ctx); 564 GLuint i; 565 COLORREF Color; 566 for (i=0; i<n; i++) { 567 GLint y2 = FLIP(y[i]); 568 Color = GetPixel(pwc->hDC, x[i], y2); 569 rgba[i][RCOMP] = GetRValue(Color); 570 rgba[i][GCOMP] = GetGValue(Color); 571 rgba[i][BCOMP] = GetBValue(Color); 572 rgba[i][ACOMP] = 255; 573 } 574 } 575 576 /*********************************************************************/ 577 578 /* DOUBLE BUFFER 32-bit */ 579 580 #define WMSETPIXEL32(pwc, y, x, r, g, b) { \ 581 LPDWORD lpdw = ((LPDWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \ 582 *lpdw = BGR32((r),(g),(b)); } 583 584 585 586 /* Write a horizontal span of RGBA color pixels with a boolean mask. */ 587 static void write_rgba_span_32(struct gl_context *ctx, 588 struct gl_renderbuffer *rb, 589 GLuint n, GLint x, GLint y, 590 const void *values, 591 const GLubyte *mask) 592 { 593 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 594 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 595 GLuint i; 596 LPDWORD lpdw; 597 598 (void) ctx; 599 600 y=FLIP(y); 601 lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x; 602 if (mask) { 603 for (i=0; i<n; i++) 604 if (mask[i]) 605 lpdw[i] = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 606 rgba[i][BCOMP]); 607 } 608 else { 609 for (i=0; i<n; i++) 610 *lpdw++ = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 611 rgba[i][BCOMP]); 612 } 613 } 614 615 616 /* Write an array of RGBA pixels with a boolean mask. */ 617 static void write_rgba_pixels_32(struct gl_context *ctx, 618 struct gl_renderbuffer *rb, 619 GLuint n, const GLint x[], const GLint y[], 620 const void *values, 621 const GLubyte *mask) 622 { 623 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 624 GLuint i; 625 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 626 for (i=0; i<n; i++) 627 if (mask[i]) 628 WMSETPIXEL32(pwfb, FLIP(y[i]), x[i], 629 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]); 630 } 631 632 633 /* Read a horizontal span of color pixels. */ 634 static void read_rgba_span_32(struct gl_context *ctx, 635 struct gl_renderbuffer *rb, 636 GLuint n, GLint x, GLint y, 637 void *values) 638 { 639 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 640 GLuint i; 641 DWORD pixel; 642 LPDWORD lpdw; 643 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 644 645 y = FLIP(y); 646 lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x; 647 for (i=0; i<n; i++) { 648 pixel = lpdw[i]; 649 rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16); 650 rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8); 651 rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff); 652 rgba[i][ACOMP] = 255; 653 } 654 } 655 656 657 /* Read an array of color pixels. */ 658 static void read_rgba_pixels_32(struct gl_context *ctx, 659 struct gl_renderbuffer *rb, 660 GLuint n, const GLint x[], const GLint y[], 661 void *values) 662 { 663 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 664 GLuint i; 665 DWORD pixel; 666 LPDWORD lpdw; 667 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 668 669 for (i=0; i<n; i++) { 670 GLint y2 = FLIP(y[i]); 671 lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i]; 672 pixel = *lpdw; 673 rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16); 674 rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8); 675 rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff); 676 rgba[i][ACOMP] = 255; 677 } 678 } 679 680 681 /*********************************************************************/ 682 683 /* DOUBLE BUFFER 24-bit */ 684 685 #define WMSETPIXEL24(pwc, y, x, r, g, b) { \ 686 LPBYTE lpb = ((LPBYTE)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (3 * x)); \ 687 lpb[0] = (b); \ 688 lpb[1] = (g); \ 689 lpb[2] = (r); } 690 691 /* Write a horizontal span of RGBA color pixels with a boolean mask. */ 692 static void write_rgba_span_24(struct gl_context *ctx, 693 struct gl_renderbuffer *rb, 694 GLuint n, GLint x, GLint y, 695 const void *values, 696 const GLubyte *mask) 697 { 698 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 699 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 700 GLuint i; 701 LPBYTE lpb; 702 703 (void) ctx; 704 705 y=FLIP(y); 706 lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x); 707 if (mask) { 708 for (i=0; i<n; i++) 709 if (mask[i]) { 710 lpb[3*i] = rgba[i][BCOMP]; 711 lpb[3*i+1] = rgba[i][GCOMP]; 712 lpb[3*i+2] = rgba[i][RCOMP]; 713 } 714 } 715 else { 716 for (i=0; i<n; i++) { 717 *lpb++ = rgba[i][BCOMP]; 718 *lpb++ = rgba[i][GCOMP]; 719 *lpb++ = rgba[i][RCOMP]; 720 } 721 } 722 } 723 724 725 /* Write an array of RGBA pixels with a boolean mask. */ 726 static void write_rgba_pixels_24(struct gl_context *ctx, 727 struct gl_renderbuffer *rb, 728 GLuint n, const GLint x[], const GLint y[], 729 const void *values, 730 const GLubyte *mask) 731 { 732 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 733 GLuint i; 734 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 735 for (i=0; i<n; i++) 736 if (mask[i]) 737 WMSETPIXEL24(pwfb, FLIP(y[i]), x[i], 738 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]); 739 } 740 741 742 /* Read a horizontal span of color pixels. */ 743 static void read_rgba_span_24(struct gl_context *ctx, 744 struct gl_renderbuffer *rb, 745 GLuint n, GLint x, GLint y, 746 void *values) 747 { 748 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 749 GLuint i; 750 LPBYTE lpb; 751 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 752 753 y = FLIP(y); 754 lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x); 755 for (i=0; i<n; i++) { 756 rgba[i][RCOMP] = lpb[3*i+2]; 757 rgba[i][GCOMP] = lpb[3*i+1]; 758 rgba[i][BCOMP] = lpb[3*i]; 759 rgba[i][ACOMP] = 255; 760 } 761 } 762 763 764 /* Read an array of color pixels. */ 765 static void read_rgba_pixels_24(struct gl_context *ctx, 766 struct gl_renderbuffer *rb, 767 GLuint n, const GLint x[], const GLint y[], 768 void *values) 769 { 770 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 771 GLuint i; 772 LPBYTE lpb; 773 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 774 775 for (i=0; i<n; i++) { 776 GLint y2 = FLIP(y[i]); 777 lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + (3 * x[i]); 778 rgba[i][RCOMP] = lpb[3*i+2]; 779 rgba[i][GCOMP] = lpb[3*i+1]; 780 rgba[i][BCOMP] = lpb[3*i]; 781 rgba[i][ACOMP] = 255; 782 } 783 } 784 785 786 /*********************************************************************/ 787 788 /* DOUBLE BUFFER 16-bit */ 789 790 #define WMSETPIXEL16(pwc, y, x, r, g, b) { \ 791 LPWORD lpw = ((LPWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \ 792 *lpw = BGR16((r),(g),(b)); } 793 794 795 796 /* Write a horizontal span of RGBA color pixels with a boolean mask. */ 797 static void write_rgba_span_16(struct gl_context *ctx, 798 struct gl_renderbuffer *rb, 799 GLuint n, GLint x, GLint y, 800 const void *values, 801 const GLubyte *mask) 802 { 803 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 804 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 805 GLuint i; 806 LPWORD lpw; 807 808 (void) ctx; 809 810 y=FLIP(y); 811 lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x; 812 if (mask) { 813 for (i=0; i<n; i++) 814 if (mask[i]) 815 lpw[i] = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 816 rgba[i][BCOMP]); 817 } 818 else { 819 for (i=0; i<n; i++) 820 *lpw++ = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 821 rgba[i][BCOMP]); 822 } 823 } 824 825 826 827 /* Write an array of RGBA pixels with a boolean mask. */ 828 static void write_rgba_pixels_16(struct gl_context *ctx, 829 struct gl_renderbuffer *rb, 830 GLuint n, const GLint x[], const GLint y[], 831 const void *values, 832 const GLubyte *mask) 833 { 834 const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values; 835 GLuint i; 836 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 837 (void) ctx; 838 for (i=0; i<n; i++) 839 if (mask[i]) 840 WMSETPIXEL16(pwfb, FLIP(y[i]), x[i], 841 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]); 842 } 843 844 845 /* Read a horizontal span of color pixels. */ 846 static void read_rgba_span_16(struct gl_context *ctx, 847 struct gl_renderbuffer *rb, 848 GLuint n, GLint x, GLint y, 849 void *values) 850 { 851 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 852 GLuint i, pixel; 853 LPWORD lpw; 854 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 855 856 y = FLIP(y); 857 lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x; 858 for (i=0; i<n; i++) { 859 pixel = lpw[i]; 860 /* Windows uses 5,5,5 for 16-bit */ 861 rgba[i][RCOMP] = (pixel & 0x7c00) >> 7; 862 rgba[i][GCOMP] = (pixel & 0x03e0) >> 2; 863 rgba[i][BCOMP] = (pixel & 0x001f) << 3; 864 rgba[i][ACOMP] = 255; 865 } 866 } 867 868 869 /* Read an array of color pixels. */ 870 static void read_rgba_pixels_16(struct gl_context *ctx, 871 struct gl_renderbuffer *rb, 872 GLuint n, const GLint x[], const GLint y[], 873 void *values) 874 { 875 GLubyte (*rgba)[4] = (GLubyte (*)[4])values; 876 GLuint i, pixel; 877 LPWORD lpw; 878 WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer); 879 880 for (i=0; i<n; i++) { 881 GLint y2 = FLIP(y[i]); 882 lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i]; 883 pixel = *lpw; 884 /* Windows uses 5,5,5 for 16-bit */ 885 rgba[i][RCOMP] = (pixel & 0x7c00) >> 7; 886 rgba[i][GCOMP] = (pixel & 0x03e0) >> 2; 887 rgba[i][BCOMP] = (pixel & 0x001f) << 3; 888 rgba[i][ACOMP] = 255; 889 } 890 } 891 892 893 894 895 /**********************************************************************/ 896 /***** BUFFER Functions *****/ 897 /**********************************************************************/ 898 899 900 901 902 static void 903 wmesa_delete_renderbuffer(struct gl_context *ctx, struct gl_renderbuffer *rb) 904 { 905 _mesa_delete_renderbuffer(ctx, rb); 906 } 907 908 909 /** 910 * This is called by Mesa whenever it determines that the window size 911 * has changed. Do whatever's needed to cope with that. 912 */ 913 static GLboolean 914 wmesa_renderbuffer_storage(struct gl_context *ctx, 915 struct gl_renderbuffer *rb, 916 GLenum internalFormat, 917 GLuint width, 918 GLuint height) 919 { 920 rb->Width = width; 921 rb->Height = height; 922 return GL_TRUE; 923 } 924 925 926 /** 927 * Called by ctx->Driver.ResizeBuffers() 928 * Resize the front/back colorbuffers to match the latest window size. 929 */ 930 static void 931 wmesa_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *buffer, 932 GLuint width, GLuint height) 933 { 934 WMesaFramebuffer pwfb = wmesa_framebuffer(buffer); 935 936 if (pwfb->Base.Width != width || pwfb->Base.Height != height) { 937 /* Realloc back buffer */ 938 if (ctx->Visual.doubleBufferMode == 1) { 939 wmDeleteBackingStore(pwfb); 940 wmCreateBackingStore(pwfb, width, height); 941 } 942 } 943 _mesa_resize_framebuffer(ctx, buffer, width, height); 944 } 945 946 947 /** 948 * Called by glViewport. 949 * This is a good time for us to poll the current window size and adjust 950 * our renderbuffers to match the current window size. 951 * Remember, we have no opportunity to respond to conventional 952 * resize events since the driver has no event loop. 953 * Thus, we poll. 954 * MakeCurrent also ends up making a call here, so that ensures 955 * we get the viewport set correctly, even if the app does not call 956 * glViewport and relies on the defaults. 957 */ 958 static void wmesa_viewport(struct gl_context *ctx, 959 GLint x, GLint y, 960 GLsizei width, GLsizei height) 961 { 962 GLuint new_width, new_height; 963 964 wmesa_get_buffer_size(ctx->WinSysDrawBuffer, &new_width, &new_height); 965 966 /** 967 * Resize buffers if the window size changed. 968 */ 969 wmesa_resize_buffers(ctx, ctx->WinSysDrawBuffer, new_width, new_height); 970 ctx->NewState |= _NEW_BUFFERS; /* to update scissor / window bounds */ 971 } 972 973 974 975 976 /** 977 * Called when the driver should update it's state, based on the new_state 978 * flags. 979 */ 980 static void wmesa_update_state(struct gl_context *ctx, GLuint new_state) 981 { 982 _swrast_InvalidateState(ctx, new_state); 983 _swsetup_InvalidateState(ctx, new_state); 984 _vbo_InvalidateState(ctx, new_state); 985 _tnl_InvalidateState(ctx, new_state); 986 987 /* TODO - This code is not complete yet because I 988 * don't know what to do for all state updates. 989 */ 990 991 if (new_state & _NEW_BUFFERS) { 992 } 993 } 994 995 996 997 998 999 /**********************************************************************/ 1000 /***** WMESA Functions *****/ 1001 /**********************************************************************/ 1002 1003 WMesaContext WMesaCreateContext(HDC hDC, 1004 HPALETTE* Pal, 1005 GLboolean rgb_flag, 1006 GLboolean db_flag, 1007 GLboolean alpha_flag) 1008 { 1009 WMesaContext c; 1010 struct dd_function_table functions; 1011 GLint red_bits, green_bits, blue_bits, alpha_bits; 1012 struct gl_context *ctx; 1013 struct gl_config *visual; 1014 1015 (void) Pal; 1016 1017 /* Indexed mode not supported */ 1018 if (!rgb_flag) 1019 return NULL; 1020 1021 /* Allocate wmesa context */ 1022 c = CALLOC_STRUCT(wmesa_context); 1023 if (!c) 1024 return NULL; 1025 1026 #if 0 1027 /* I do not understand this contributed code */ 1028 /* Support memory and device contexts */ 1029 if(WindowFromDC(hDC) != NULL) { 1030 c->hDC = GetDC(WindowFromDC(hDC)); /* huh ???? */ 1031 } 1032 else { 1033 c->hDC = hDC; 1034 } 1035 #else 1036 c->hDC = hDC; 1037 #endif 1038 1039 /* Get data for visual */ 1040 /* Dealing with this is actually a bit of overkill because Mesa will end 1041 * up treating all color component size requests less than 8 by using 1042 * a single byte per channel. In addition, the interface to the span 1043 * routines passes colors as an entire byte per channel anyway, so there 1044 * is nothing to be saved by telling the visual to be 16 bits if the device 1045 * is 16 bits. That is, Mesa is going to compute colors down to 8 bits per 1046 * channel anyway. 1047 * But we go through the motions here anyway. 1048 */ 1049 switch (GetDeviceCaps(c->hDC, BITSPIXEL)) { 1050 case 16: 1051 red_bits = green_bits = blue_bits = 5; 1052 alpha_bits = 0; 1053 break; 1054 default: 1055 red_bits = green_bits = blue_bits = 8; 1056 alpha_bits = 8; 1057 break; 1058 } 1059 /* Create visual based on flags */ 1060 visual = _mesa_create_visual(db_flag, /* db_flag */ 1061 GL_FALSE, /* stereo */ 1062 red_bits, green_bits, blue_bits, /* color RGB */ 1063 alpha_flag ? alpha_bits : 0, /* color A */ 1064 DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */ 1065 8, /* stencil_bits */ 1066 16,16,16, /* accum RGB */ 1067 alpha_flag ? 16 : 0, /* accum A */ 1068 1); /* num samples */ 1069 1070 if (!visual) { 1071 free(c); 1072 return NULL; 1073 } 1074 1075 /* Set up driver functions */ 1076 _mesa_init_driver_functions(&functions); 1077 functions.GetString = wmesa_get_string; 1078 functions.UpdateState = wmesa_update_state; 1079 functions.GetBufferSize = wmesa_get_buffer_size; 1080 functions.Flush = wmesa_flush; 1081 functions.Clear = clear; 1082 functions.ResizeBuffers = wmesa_resize_buffers; 1083 functions.Viewport = wmesa_viewport; 1084 1085 /* initialize the Mesa context data */ 1086 ctx = &c->gl_ctx; 1087 _mesa_initialize_context(ctx, API_OPENGL, visual, 1088 NULL, &functions, (void *)c); 1089 1090 /* visual no longer needed - it was copied by _mesa_initialize_context() */ 1091 _mesa_destroy_visual(visual); 1092 1093 _mesa_enable_sw_extensions(ctx); 1094 _mesa_enable_1_3_extensions(ctx); 1095 _mesa_enable_1_4_extensions(ctx); 1096 _mesa_enable_1_5_extensions(ctx); 1097 _mesa_enable_2_0_extensions(ctx); 1098 _mesa_enable_2_1_extensions(ctx); 1099 1100 _mesa_meta_init(ctx); 1101 1102 /* Initialize the software rasterizer and helper modules. */ 1103 if (!_swrast_CreateContext(ctx) || 1104 !_vbo_CreateContext(ctx) || 1105 !_tnl_CreateContext(ctx) || 1106 !_swsetup_CreateContext(ctx)) { 1107 _mesa_free_context_data(ctx); 1108 free(c); 1109 return NULL; 1110 } 1111 _swsetup_Wakeup(ctx); 1112 TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline; 1113 1114 return c; 1115 } 1116 1117 1118 void WMesaDestroyContext( WMesaContext pwc ) 1119 { 1120 struct gl_context *ctx = &pwc->gl_ctx; 1121 WMesaFramebuffer pwfb; 1122 GET_CURRENT_CONTEXT(cur_ctx); 1123 1124 if (cur_ctx == ctx) { 1125 /* unbind current if deleting current context */ 1126 WMesaMakeCurrent(NULL, NULL); 1127 } 1128 1129 /* clean up frame buffer resources */ 1130 pwfb = wmesa_lookup_framebuffer(pwc->hDC); 1131 if (pwfb) { 1132 if (ctx->Visual.doubleBufferMode == 1) 1133 wmDeleteBackingStore(pwfb); 1134 wmesa_free_framebuffer(pwc->hDC); 1135 } 1136 1137 /* Release for device, not memory contexts */ 1138 if (WindowFromDC(pwc->hDC) != NULL) 1139 { 1140 ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC); 1141 } 1142 DeleteObject(pwc->clearPen); 1143 DeleteObject(pwc->clearBrush); 1144 1145 _mesa_meta_free(ctx); 1146 1147 _swsetup_DestroyContext(ctx); 1148 _tnl_DestroyContext(ctx); 1149 _vbo_DestroyContext(ctx); 1150 _swrast_DestroyContext(ctx); 1151 1152 _mesa_free_context_data(ctx); 1153 free(pwc); 1154 } 1155 1156 1157 /** 1158 * Create a new color renderbuffer. 1159 */ 1160 static struct gl_renderbuffer * 1161 wmesa_new_renderbuffer(void) 1162 { 1163 struct gl_renderbuffer *rb = CALLOC_STRUCT(gl_renderbuffer); 1164 if (!rb) 1165 return NULL; 1166 1167 _mesa_init_renderbuffer(rb, (GLuint)0); 1168 1169 rb->_BaseFormat = GL_RGBA; 1170 rb->InternalFormat = GL_RGBA; 1171 rb->Delete = wmesa_delete_renderbuffer; 1172 rb->AllocStorage = wmesa_renderbuffer_storage; 1173 return rb; 1174 } 1175 1176 1177 void WMesaMakeCurrent(WMesaContext c, HDC hdc) 1178 { 1179 WMesaFramebuffer pwfb; 1180 1181 { 1182 /* return if already current */ 1183 GET_CURRENT_CONTEXT(ctx); 1184 WMesaContext pwc = wmesa_context(ctx); 1185 if (pwc && c == pwc && pwc->hDC == hdc) 1186 return; 1187 } 1188 1189 pwfb = wmesa_lookup_framebuffer(hdc); 1190 1191 /* Lazy creation of framebuffers */ 1192 if (c && !pwfb && hdc) { 1193 struct gl_renderbuffer *rb; 1194 struct gl_config *visual = &c->gl_ctx.Visual; 1195 GLuint width, height; 1196 1197 get_window_size(hdc, &width, &height); 1198 1199 c->clearPen = CreatePen(PS_SOLID, 1, 0); 1200 c->clearBrush = CreateSolidBrush(0); 1201 1202 pwfb = wmesa_new_framebuffer(hdc, visual); 1203 1204 /* Create back buffer if double buffered */ 1205 if (visual->doubleBufferMode == 1) { 1206 wmCreateBackingStore(pwfb, width, height); 1207 } 1208 1209 /* make render buffers */ 1210 if (visual->doubleBufferMode == 1) { 1211 rb = wmesa_new_renderbuffer(); 1212 _mesa_add_renderbuffer(&pwfb->Base, BUFFER_BACK_LEFT, rb); 1213 } 1214 rb = wmesa_new_renderbuffer(); 1215 _mesa_add_renderbuffer(&pwfb->Base, BUFFER_FRONT_LEFT, rb); 1216 1217 /* Let Mesa own the Depth, Stencil, and Accum buffers */ 1218 _swrast_add_soft_renderbuffers(&pwfb->Base, 1219 GL_FALSE, /* color */ 1220 visual->depthBits > 0, 1221 visual->stencilBits > 0, 1222 visual->accumRedBits > 0, 1223 visual->alphaBits >0, 1224 GL_FALSE); 1225 } 1226 1227 if (c && pwfb) 1228 _mesa_make_current(&c->gl_ctx, &pwfb->Base, &pwfb->Base); 1229 else 1230 _mesa_make_current(NULL, NULL, NULL); 1231 } 1232 1233 1234 void WMesaSwapBuffers( HDC hdc ) 1235 { 1236 GET_CURRENT_CONTEXT(ctx); 1237 WMesaContext pwc = wmesa_context(ctx); 1238 WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc); 1239 1240 if (!pwfb) { 1241 _mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc"); 1242 return; 1243 } 1244 1245 /* If we're swapping the buffer associated with the current context 1246 * we have to flush any pending rendering commands first. 1247 */ 1248 if (pwc->hDC == hdc) { 1249 _mesa_notifySwapBuffers(ctx); 1250 1251 BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height, 1252 pwfb->dib_hDC, 0, 0, SRCCOPY); 1253 } 1254 else { 1255 /* XXX for now only allow swapping current window */ 1256 _mesa_problem(NULL, "wmesa: can't swap non-current window"); 1257 } 1258 } 1259 1260 void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx) 1261 { 1262 _mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx); 1263 } 1264 1265
