1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * Copyright (C) 1999-2013 VMware, Inc. All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 /* 27 * glBlitFramebuffer functions. 28 */ 29 30 #include <stdbool.h> 31 #include <stdio.h> 32 33 #include "context.h" 34 #include "enums.h" 35 #include "blit.h" 36 #include "fbobject.h" 37 #include "framebuffer.h" 38 #include "glformats.h" 39 #include "mtypes.h" 40 #include "macros.h" 41 #include "state.h" 42 43 44 /** Set this to 1 to debug/log glBlitFramebuffer() calls */ 45 #define DEBUG_BLIT 0 46 47 48 49 static const struct gl_renderbuffer_attachment * 50 find_attachment(const struct gl_framebuffer *fb, 51 const struct gl_renderbuffer *rb) 52 { 53 GLuint i; 54 for (i = 0; i < ARRAY_SIZE(fb->Attachment); i++) { 55 if (fb->Attachment[i].Renderbuffer == rb) 56 return &fb->Attachment[i]; 57 } 58 return NULL; 59 } 60 61 62 /** 63 * \return true if two regions overlap, false otherwise 64 */ 65 bool 66 _mesa_regions_overlap(int srcX0, int srcY0, 67 int srcX1, int srcY1, 68 int dstX0, int dstY0, 69 int dstX1, int dstY1) 70 { 71 if (MAX2(srcX0, srcX1) <= MIN2(dstX0, dstX1)) 72 return false; /* dst completely right of src */ 73 74 if (MAX2(dstX0, dstX1) <= MIN2(srcX0, srcX1)) 75 return false; /* dst completely left of src */ 76 77 if (MAX2(srcY0, srcY1) <= MIN2(dstY0, dstY1)) 78 return false; /* dst completely above src */ 79 80 if (MAX2(dstY0, dstY1) <= MIN2(srcY0, srcY1)) 81 return false; /* dst completely below src */ 82 83 return true; /* some overlap */ 84 } 85 86 87 /** 88 * Helper function for checking if the datatypes of color buffers are 89 * compatible for glBlitFramebuffer. From the 3.1 spec, page 198: 90 * 91 * "GL_INVALID_OPERATION is generated if mask contains GL_COLOR_BUFFER_BIT 92 * and any of the following conditions hold: 93 * - The read buffer contains fixed-point or floating-point values and any 94 * draw buffer contains neither fixed-point nor floating-point values. 95 * - The read buffer contains unsigned integer values and any draw buffer 96 * does not contain unsigned integer values. 97 * - The read buffer contains signed integer values and any draw buffer 98 * does not contain signed integer values." 99 */ 100 static GLboolean 101 compatible_color_datatypes(mesa_format srcFormat, mesa_format dstFormat) 102 { 103 GLenum srcType = _mesa_get_format_datatype(srcFormat); 104 GLenum dstType = _mesa_get_format_datatype(dstFormat); 105 106 if (srcType != GL_INT && srcType != GL_UNSIGNED_INT) { 107 assert(srcType == GL_UNSIGNED_NORMALIZED || 108 srcType == GL_SIGNED_NORMALIZED || 109 srcType == GL_FLOAT); 110 /* Boil any of those types down to GL_FLOAT */ 111 srcType = GL_FLOAT; 112 } 113 114 if (dstType != GL_INT && dstType != GL_UNSIGNED_INT) { 115 assert(dstType == GL_UNSIGNED_NORMALIZED || 116 dstType == GL_SIGNED_NORMALIZED || 117 dstType == GL_FLOAT); 118 /* Boil any of those types down to GL_FLOAT */ 119 dstType = GL_FLOAT; 120 } 121 122 return srcType == dstType; 123 } 124 125 126 static GLboolean 127 compatible_resolve_formats(const struct gl_renderbuffer *readRb, 128 const struct gl_renderbuffer *drawRb) 129 { 130 GLenum readFormat, drawFormat; 131 132 /* This checks whether the internal formats are compatible rather than the 133 * Mesa format for two reasons: 134 * 135 * Under some circumstances, the user may request e.g. two GL_RGBA8 136 * textures and get two entirely different Mesa formats like RGBA8888 and 137 * ARGB8888. Drivers behaving like that should be able to cope with 138 * non-matching formats by themselves, because it's not the user's fault. 139 * 140 * Picking two different internal formats can end up with the same Mesa 141 * format. For example the driver might be simulating GL_RGB textures 142 * with GL_RGBA internally and in that case both internal formats would 143 * end up with RGBA8888. 144 * 145 * This function is used to generate a GL error according to the spec so in 146 * both cases we want to be looking at the application-level format, which 147 * is InternalFormat. 148 * 149 * Blits between linear and sRGB formats are also allowed. 150 */ 151 readFormat = _mesa_get_nongeneric_internalformat(readRb->InternalFormat); 152 drawFormat = _mesa_get_nongeneric_internalformat(drawRb->InternalFormat); 153 readFormat = _mesa_get_linear_internalformat(readFormat); 154 drawFormat = _mesa_get_linear_internalformat(drawFormat); 155 156 if (readFormat == drawFormat) { 157 return GL_TRUE; 158 } 159 160 return GL_FALSE; 161 } 162 163 164 static GLboolean 165 is_valid_blit_filter(const struct gl_context *ctx, GLenum filter) 166 { 167 switch (filter) { 168 case GL_NEAREST: 169 case GL_LINEAR: 170 return true; 171 case GL_SCALED_RESOLVE_FASTEST_EXT: 172 case GL_SCALED_RESOLVE_NICEST_EXT: 173 return ctx->Extensions.EXT_framebuffer_multisample_blit_scaled; 174 default: 175 return false; 176 } 177 } 178 179 180 void 181 _mesa_blit_framebuffer(struct gl_context *ctx, 182 struct gl_framebuffer *readFb, 183 struct gl_framebuffer *drawFb, 184 GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, 185 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, 186 GLbitfield mask, GLenum filter, const char *func) 187 { 188 const GLbitfield legalMaskBits = (GL_COLOR_BUFFER_BIT | 189 GL_DEPTH_BUFFER_BIT | 190 GL_STENCIL_BUFFER_BIT); 191 192 FLUSH_VERTICES(ctx, 0); 193 194 /* Update completeness status of readFb and drawFb. */ 195 _mesa_update_framebuffer(ctx, readFb, drawFb); 196 197 /* Make sure drawFb has an initialized bounding box. */ 198 _mesa_update_draw_buffer_bounds(ctx, drawFb); 199 200 if (!readFb || !drawFb) { 201 /* This will normally never happen but someday we may want to 202 * support MakeCurrent() with no drawables. 203 */ 204 return; 205 } 206 207 /* check for complete framebuffers */ 208 if (drawFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT || 209 readFb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) { 210 _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT, 211 "%s(incomplete draw/read buffers)", func); 212 return; 213 } 214 215 if (!is_valid_blit_filter(ctx, filter)) { 216 _mesa_error(ctx, GL_INVALID_ENUM, "%s(invalid filter %s)", func, 217 _mesa_enum_to_string(filter)); 218 return; 219 } 220 221 if ((filter == GL_SCALED_RESOLVE_FASTEST_EXT || 222 filter == GL_SCALED_RESOLVE_NICEST_EXT) && 223 (readFb->Visual.samples == 0 || drawFb->Visual.samples > 0)) { 224 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(%s: invalid samples)", func, 225 _mesa_enum_to_string(filter)); 226 return; 227 } 228 229 if (mask & ~legalMaskBits) { 230 _mesa_error(ctx, GL_INVALID_VALUE, "%s(invalid mask bits set)", func); 231 return; 232 } 233 234 /* depth/stencil must be blitted with nearest filtering */ 235 if ((mask & (GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT)) 236 && filter != GL_NEAREST) { 237 _mesa_error(ctx, GL_INVALID_OPERATION, 238 "%s(depth/stencil requires GL_NEAREST filter)", func); 239 return; 240 } 241 242 /* get color read/draw renderbuffers */ 243 if (mask & GL_COLOR_BUFFER_BIT) { 244 const GLuint numColorDrawBuffers = drawFb->_NumColorDrawBuffers; 245 const struct gl_renderbuffer *colorReadRb = readFb->_ColorReadBuffer; 246 const struct gl_renderbuffer *colorDrawRb = NULL; 247 GLuint i; 248 249 /* From the EXT_framebuffer_object spec: 250 * 251 * "If a buffer is specified in <mask> and does not exist in both 252 * the read and draw framebuffers, the corresponding bit is silently 253 * ignored." 254 */ 255 if (!colorReadRb || numColorDrawBuffers == 0) { 256 mask &= ~GL_COLOR_BUFFER_BIT; 257 } 258 else { 259 for (i = 0; i < numColorDrawBuffers; i++) { 260 colorDrawRb = drawFb->_ColorDrawBuffers[i]; 261 if (!colorDrawRb) 262 continue; 263 264 /* Page 193 (page 205 of the PDF) in section 4.3.2 of the OpenGL 265 * ES 3.0.1 spec says: 266 * 267 * "If the source and destination buffers are identical, an 268 * INVALID_OPERATION error is generated. Different mipmap 269 * levels of a texture, different layers of a three- 270 * dimensional texture or two-dimensional array texture, and 271 * different faces of a cube map texture do not constitute 272 * identical buffers." 273 */ 274 if (_mesa_is_gles3(ctx) && (colorDrawRb == colorReadRb)) { 275 _mesa_error(ctx, GL_INVALID_OPERATION, 276 "%s(source and destination color " 277 "buffer cannot be the same)", func); 278 return; 279 } 280 281 if (!compatible_color_datatypes(colorReadRb->Format, 282 colorDrawRb->Format)) { 283 _mesa_error(ctx, GL_INVALID_OPERATION, 284 "%s(color buffer datatypes mismatch)", func); 285 return; 286 } 287 /* extra checks for multisample copies... */ 288 if (readFb->Visual.samples > 0 || drawFb->Visual.samples > 0) { 289 /* color formats must match on GLES. This isn't checked on 290 * desktop GL because the GL 4.4 spec was changed to allow it. 291 * In the section entitled Changes in the released 292 * Specification of July 22, 2013 it says: 293 * 294 * Relax BlitFramebuffer in section 18.3.1 so that format 295 * conversion can take place during multisample blits, since 296 * drivers already allow this and some apps depend on it. 297 */ 298 if (_mesa_is_gles(ctx) && 299 !compatible_resolve_formats(colorReadRb, colorDrawRb)) { 300 _mesa_error(ctx, GL_INVALID_OPERATION, 301 "%s(bad src/dst multisample pixel formats)", func); 302 return; 303 } 304 } 305 } 306 if (filter != GL_NEAREST) { 307 /* From EXT_framebuffer_multisample_blit_scaled specification: 308 * "Calling BlitFramebuffer will result in an INVALID_OPERATION error 309 * if filter is not NEAREST and read buffer contains integer data." 310 */ 311 GLenum type = _mesa_get_format_datatype(colorReadRb->Format); 312 if (type == GL_INT || type == GL_UNSIGNED_INT) { 313 _mesa_error(ctx, GL_INVALID_OPERATION, 314 "%s(integer color type)", func); 315 return; 316 } 317 } 318 } 319 } 320 321 if (mask & GL_STENCIL_BUFFER_BIT) { 322 struct gl_renderbuffer *readRb = 323 readFb->Attachment[BUFFER_STENCIL].Renderbuffer; 324 struct gl_renderbuffer *drawRb = 325 drawFb->Attachment[BUFFER_STENCIL].Renderbuffer; 326 327 /* From the EXT_framebuffer_object spec: 328 * 329 * "If a buffer is specified in <mask> and does not exist in both 330 * the read and draw framebuffers, the corresponding bit is silently 331 * ignored." 332 */ 333 if ((readRb == NULL) || (drawRb == NULL)) { 334 mask &= ~GL_STENCIL_BUFFER_BIT; 335 } 336 else { 337 int read_z_bits, draw_z_bits; 338 339 if (_mesa_is_gles3(ctx) && (drawRb == readRb)) { 340 _mesa_error(ctx, GL_INVALID_OPERATION, 341 "%s(source and destination stencil " 342 "buffer cannot be the same)", func); 343 return; 344 } 345 346 if (_mesa_get_format_bits(readRb->Format, GL_STENCIL_BITS) != 347 _mesa_get_format_bits(drawRb->Format, GL_STENCIL_BITS)) { 348 /* There is no need to check the stencil datatype here, because 349 * there is only one: GL_UNSIGNED_INT. 350 */ 351 _mesa_error(ctx, GL_INVALID_OPERATION, 352 "%s(stencil attachment format mismatch)", func); 353 return; 354 } 355 356 read_z_bits = _mesa_get_format_bits(readRb->Format, GL_DEPTH_BITS); 357 draw_z_bits = _mesa_get_format_bits(drawRb->Format, GL_DEPTH_BITS); 358 359 /* If both buffers also have depth data, the depth formats must match 360 * as well. If one doesn't have depth, it's not blitted, so we should 361 * ignore the depth format check. 362 */ 363 if (read_z_bits > 0 && draw_z_bits > 0 && 364 (read_z_bits != draw_z_bits || 365 _mesa_get_format_datatype(readRb->Format) != 366 _mesa_get_format_datatype(drawRb->Format))) { 367 368 _mesa_error(ctx, GL_INVALID_OPERATION, 369 "%s(stencil attachment depth format mismatch)", func); 370 return; 371 } 372 } 373 } 374 375 if (mask & GL_DEPTH_BUFFER_BIT) { 376 struct gl_renderbuffer *readRb = 377 readFb->Attachment[BUFFER_DEPTH].Renderbuffer; 378 struct gl_renderbuffer *drawRb = 379 drawFb->Attachment[BUFFER_DEPTH].Renderbuffer; 380 381 /* From the EXT_framebuffer_object spec: 382 * 383 * "If a buffer is specified in <mask> and does not exist in both 384 * the read and draw framebuffers, the corresponding bit is silently 385 * ignored." 386 */ 387 if ((readRb == NULL) || (drawRb == NULL)) { 388 mask &= ~GL_DEPTH_BUFFER_BIT; 389 } 390 else { 391 int read_s_bit, draw_s_bit; 392 393 if (_mesa_is_gles3(ctx) && (drawRb == readRb)) { 394 _mesa_error(ctx, GL_INVALID_OPERATION, 395 "%s(source and destination depth " 396 "buffer cannot be the same)", func); 397 return; 398 } 399 400 if ((_mesa_get_format_bits(readRb->Format, GL_DEPTH_BITS) != 401 _mesa_get_format_bits(drawRb->Format, GL_DEPTH_BITS)) || 402 (_mesa_get_format_datatype(readRb->Format) != 403 _mesa_get_format_datatype(drawRb->Format))) { 404 _mesa_error(ctx, GL_INVALID_OPERATION, 405 "%s(depth attachment format mismatch)", func); 406 return; 407 } 408 409 read_s_bit = _mesa_get_format_bits(readRb->Format, GL_STENCIL_BITS); 410 draw_s_bit = _mesa_get_format_bits(drawRb->Format, GL_STENCIL_BITS); 411 412 /* If both buffers also have stencil data, the stencil formats must 413 * match as well. If one doesn't have stencil, it's not blitted, so 414 * we should ignore the stencil format check. 415 */ 416 if (read_s_bit > 0 && draw_s_bit > 0 && read_s_bit != draw_s_bit) { 417 _mesa_error(ctx, GL_INVALID_OPERATION, 418 "%s(depth attachment stencil bits mismatch)", func); 419 return; 420 } 421 } 422 } 423 424 425 if (_mesa_is_gles3(ctx)) { 426 /* Page 194 (page 206 of the PDF) in section 4.3.2 of the OpenGL ES 427 * 3.0.1 spec says: 428 * 429 * "If SAMPLE_BUFFERS for the draw framebuffer is greater than zero, 430 * an INVALID_OPERATION error is generated." 431 */ 432 if (drawFb->Visual.samples > 0) { 433 _mesa_error(ctx, GL_INVALID_OPERATION, 434 "%s(destination samples must be 0)", func); 435 return; 436 } 437 438 /* Page 194 (page 206 of the PDF) in section 4.3.2 of the OpenGL ES 439 * 3.0.1 spec says: 440 * 441 * "If SAMPLE_BUFFERS for the read framebuffer is greater than zero, 442 * no copy is performed and an INVALID_OPERATION error is generated 443 * if the formats of the read and draw framebuffers are not 444 * identical or if the source and destination rectangles are not 445 * defined with the same (X0, Y0) and (X1, Y1) bounds." 446 * 447 * The format check was made above because desktop OpenGL has the same 448 * requirement. 449 */ 450 if (readFb->Visual.samples > 0 451 && (srcX0 != dstX0 || srcY0 != dstY0 452 || srcX1 != dstX1 || srcY1 != dstY1)) { 453 _mesa_error(ctx, GL_INVALID_OPERATION, 454 "%s(bad src/dst multisample region)", func); 455 return; 456 } 457 } else { 458 if (readFb->Visual.samples > 0 && 459 drawFb->Visual.samples > 0 && 460 readFb->Visual.samples != drawFb->Visual.samples) { 461 _mesa_error(ctx, GL_INVALID_OPERATION, 462 "%s(mismatched samples)", func); 463 return; 464 } 465 466 /* extra checks for multisample copies... */ 467 if ((readFb->Visual.samples > 0 || drawFb->Visual.samples > 0) && 468 (filter == GL_NEAREST || filter == GL_LINEAR)) { 469 /* src and dest region sizes must be the same */ 470 if (abs(srcX1 - srcX0) != abs(dstX1 - dstX0) || 471 abs(srcY1 - srcY0) != abs(dstY1 - dstY0)) { 472 _mesa_error(ctx, GL_INVALID_OPERATION, 473 "%s(bad src/dst multisample region sizes)", func); 474 return; 475 } 476 } 477 } 478 479 /* Debug code */ 480 if (DEBUG_BLIT) { 481 const struct gl_renderbuffer *colorReadRb = readFb->_ColorReadBuffer; 482 const struct gl_renderbuffer *colorDrawRb = NULL; 483 GLuint i = 0; 484 485 printf("%s(%d, %d, %d, %d, %d, %d, %d, %d," 486 " 0x%x, 0x%x)\n", func, 487 srcX0, srcY0, srcX1, srcY1, 488 dstX0, dstY0, dstX1, dstY1, 489 mask, filter); 490 491 if (colorReadRb) { 492 const struct gl_renderbuffer_attachment *att; 493 494 att = find_attachment(readFb, colorReadRb); 495 printf(" Src FBO %u RB %u (%dx%d) ", 496 readFb->Name, colorReadRb->Name, 497 colorReadRb->Width, colorReadRb->Height); 498 if (att && att->Texture) { 499 printf("Tex %u tgt 0x%x level %u face %u", 500 att->Texture->Name, 501 att->Texture->Target, 502 att->TextureLevel, 503 att->CubeMapFace); 504 } 505 printf("\n"); 506 507 /* Print all active color render buffers */ 508 for (i = 0; i < drawFb->_NumColorDrawBuffers; i++) { 509 colorDrawRb = drawFb->_ColorDrawBuffers[i]; 510 if (!colorDrawRb) 511 continue; 512 513 att = find_attachment(drawFb, colorDrawRb); 514 printf(" Dst FBO %u RB %u (%dx%d) ", 515 drawFb->Name, colorDrawRb->Name, 516 colorDrawRb->Width, colorDrawRb->Height); 517 if (att && att->Texture) { 518 printf("Tex %u tgt 0x%x level %u face %u", 519 att->Texture->Name, 520 att->Texture->Target, 521 att->TextureLevel, 522 att->CubeMapFace); 523 } 524 printf("\n"); 525 } 526 } 527 } 528 529 if (!mask || 530 (srcX1 - srcX0) == 0 || (srcY1 - srcY0) == 0 || 531 (dstX1 - dstX0) == 0 || (dstY1 - dstY0) == 0) { 532 return; 533 } 534 535 assert(ctx->Driver.BlitFramebuffer); 536 ctx->Driver.BlitFramebuffer(ctx, readFb, drawFb, 537 srcX0, srcY0, srcX1, srcY1, 538 dstX0, dstY0, dstX1, dstY1, 539 mask, filter); 540 } 541 542 543 /** 544 * Blit rectangular region, optionally from one framebuffer to another. 545 * 546 * Note, if the src buffer is multisampled and the dest is not, this is 547 * when the samples must be resolved to a single color. 548 */ 549 void GLAPIENTRY 550 _mesa_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, 551 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, 552 GLbitfield mask, GLenum filter) 553 { 554 GET_CURRENT_CONTEXT(ctx); 555 556 if (MESA_VERBOSE & VERBOSE_API) 557 _mesa_debug(ctx, 558 "glBlitFramebuffer(%d, %d, %d, %d, " 559 " %d, %d, %d, %d, 0x%x, %s)\n", 560 srcX0, srcY0, srcX1, srcY1, 561 dstX0, dstY0, dstX1, dstY1, 562 mask, _mesa_enum_to_string(filter)); 563 564 _mesa_blit_framebuffer(ctx, ctx->ReadBuffer, ctx->DrawBuffer, 565 srcX0, srcY0, srcX1, srcY1, 566 dstX0, dstY0, dstX1, dstY1, 567 mask, filter, "glBlitFramebuffer"); 568 } 569 570 571 void GLAPIENTRY 572 _mesa_BlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, 573 GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, 574 GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, 575 GLbitfield mask, GLenum filter) 576 { 577 GET_CURRENT_CONTEXT(ctx); 578 struct gl_framebuffer *readFb, *drawFb; 579 580 if (MESA_VERBOSE & VERBOSE_API) 581 _mesa_debug(ctx, 582 "glBlitNamedFramebuffer(%u %u %d, %d, %d, %d, " 583 " %d, %d, %d, %d, 0x%x, %s)\n", 584 readFramebuffer, drawFramebuffer, 585 srcX0, srcY0, srcX1, srcY1, 586 dstX0, dstY0, dstX1, dstY1, 587 mask, _mesa_enum_to_string(filter)); 588 589 /* 590 * According to PDF page 533 of the OpenGL 4.5 core spec (30.10.2014, 591 * Section 18.3 Copying Pixels): 592 * "... if readFramebuffer or drawFramebuffer is zero (for 593 * BlitNamedFramebuffer), then the default read or draw framebuffer is 594 * used as the corresponding source or destination framebuffer, 595 * respectively." 596 */ 597 if (readFramebuffer) { 598 readFb = _mesa_lookup_framebuffer_err(ctx, readFramebuffer, 599 "glBlitNamedFramebuffer"); 600 if (!readFb) 601 return; 602 } 603 else 604 readFb = ctx->WinSysReadBuffer; 605 606 if (drawFramebuffer) { 607 drawFb = _mesa_lookup_framebuffer_err(ctx, drawFramebuffer, 608 "glBlitNamedFramebuffer"); 609 if (!drawFb) 610 return; 611 } 612 else 613 drawFb = ctx->WinSysDrawBuffer; 614 615 _mesa_blit_framebuffer(ctx, readFb, drawFb, 616 srcX0, srcY0, srcX1, srcY1, 617 dstX0, dstY0, dstX1, dstY1, 618 mask, filter, "glBlitNamedFramebuffer"); 619 } 620
