Merge branch 'mesa_7_6_branch'
[mesa.git] / src / mesa / drivers / dri / intel / intel_fbo.c
1 /**************************************************************************
2 *
3 * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28
29 #include "main/imports.h"
30 #include "main/macros.h"
31 #include "main/mtypes.h"
32 #include "main/fbobject.h"
33 #include "main/framebuffer.h"
34 #include "main/renderbuffer.h"
35 #include "main/context.h"
36 #include "main/texformat.h"
37 #include "main/texrender.h"
38 #include "drivers/common/meta.h"
39
40 #include "intel_context.h"
41 #include "intel_buffers.h"
42 #include "intel_fbo.h"
43 #include "intel_mipmap_tree.h"
44 #include "intel_regions.h"
45
46
47 #define FILE_DEBUG_FLAG DEBUG_FBO
48
49
50 /**
51 * Create a new framebuffer object.
52 */
53 static struct gl_framebuffer *
54 intel_new_framebuffer(GLcontext * ctx, GLuint name)
55 {
56 /* Only drawable state in intel_framebuffer at this time, just use Mesa's
57 * class
58 */
59 return _mesa_new_framebuffer(ctx, name);
60 }
61
62
63 /** Called by gl_renderbuffer::Delete() */
64 static void
65 intel_delete_renderbuffer(struct gl_renderbuffer *rb)
66 {
67 GET_CURRENT_CONTEXT(ctx);
68 struct intel_context *intel = intel_context(ctx);
69 struct intel_renderbuffer *irb = intel_renderbuffer(rb);
70
71 ASSERT(irb);
72
73 if (irb->span_cache != NULL)
74 _mesa_free(irb->span_cache);
75
76 if (intel && irb->region) {
77 intel_region_release(&irb->region);
78 }
79
80 _mesa_free(irb);
81 }
82
83
84 /**
85 * Return a pointer to a specific pixel in a renderbuffer.
86 */
87 static void *
88 intel_get_pointer(GLcontext * ctx, struct gl_renderbuffer *rb,
89 GLint x, GLint y)
90 {
91 /* By returning NULL we force all software rendering to go through
92 * the span routines.
93 */
94 return NULL;
95 }
96
97
98 /**
99 * Called via glRenderbufferStorageEXT() to set the format and allocate
100 * storage for a user-created renderbuffer.
101 */
102 static GLboolean
103 intel_alloc_renderbuffer_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
104 GLenum internalFormat,
105 GLuint width, GLuint height)
106 {
107 struct intel_context *intel = intel_context(ctx);
108 struct intel_renderbuffer *irb = intel_renderbuffer(rb);
109 GLboolean softwareBuffer = GL_FALSE;
110 int cpp;
111
112 ASSERT(rb->Name != 0);
113
114 switch (internalFormat) {
115 case GL_R3_G3_B2:
116 case GL_RGB4:
117 case GL_RGB5:
118 rb->_ActualFormat = GL_RGB5;
119 rb->DataType = GL_UNSIGNED_BYTE;
120 rb->RedBits = 5;
121 rb->GreenBits = 6;
122 rb->BlueBits = 5;
123 irb->texformat = &_mesa_texformat_rgb565;
124 cpp = 2;
125 break;
126 case GL_RGB:
127 case GL_RGB8:
128 case GL_RGB10:
129 case GL_RGB12:
130 case GL_RGB16:
131 rb->_ActualFormat = GL_RGB8;
132 rb->DataType = GL_UNSIGNED_BYTE;
133 rb->RedBits = 8;
134 rb->GreenBits = 8;
135 rb->BlueBits = 8;
136 rb->AlphaBits = 0;
137 irb->texformat = &_mesa_texformat_argb8888; /* XXX: Need xrgb8888 */
138 cpp = 4;
139 break;
140 case GL_RGBA:
141 case GL_RGBA2:
142 case GL_RGBA4:
143 case GL_RGB5_A1:
144 case GL_RGBA8:
145 case GL_RGB10_A2:
146 case GL_RGBA12:
147 case GL_RGBA16:
148 rb->_ActualFormat = GL_RGBA8;
149 rb->DataType = GL_UNSIGNED_BYTE;
150 rb->RedBits = 8;
151 rb->GreenBits = 8;
152 rb->BlueBits = 8;
153 rb->AlphaBits = 8;
154 irb->texformat = &_mesa_texformat_argb8888;
155 cpp = 4;
156 break;
157 case GL_STENCIL_INDEX:
158 case GL_STENCIL_INDEX1_EXT:
159 case GL_STENCIL_INDEX4_EXT:
160 case GL_STENCIL_INDEX8_EXT:
161 case GL_STENCIL_INDEX16_EXT:
162 /* alloc a depth+stencil buffer */
163 rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
164 rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
165 rb->StencilBits = 8;
166 cpp = 4;
167 irb->texformat = &_mesa_texformat_s8_z24;
168 break;
169 case GL_DEPTH_COMPONENT16:
170 rb->_ActualFormat = GL_DEPTH_COMPONENT16;
171 rb->DataType = GL_UNSIGNED_SHORT;
172 rb->DepthBits = 16;
173 cpp = 2;
174 irb->texformat = &_mesa_texformat_z16;
175 break;
176 case GL_DEPTH_COMPONENT:
177 case GL_DEPTH_COMPONENT24:
178 case GL_DEPTH_COMPONENT32:
179 rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
180 rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
181 rb->DepthBits = 24;
182 cpp = 4;
183 irb->texformat = &_mesa_texformat_s8_z24;
184 break;
185 case GL_DEPTH_STENCIL_EXT:
186 case GL_DEPTH24_STENCIL8_EXT:
187 rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
188 rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
189 rb->DepthBits = 24;
190 rb->StencilBits = 8;
191 cpp = 4;
192 irb->texformat = &_mesa_texformat_s8_z24;
193 break;
194 default:
195 _mesa_problem(ctx,
196 "Unexpected format in intel_alloc_renderbuffer_storage");
197 return GL_FALSE;
198 }
199
200 intelFlush(ctx);
201
202 /* free old region */
203 if (irb->region) {
204 intel_region_release(&irb->region);
205 }
206
207 /* allocate new memory region/renderbuffer */
208 if (softwareBuffer) {
209 return _mesa_soft_renderbuffer_storage(ctx, rb, internalFormat,
210 width, height);
211 }
212 else {
213 /* Choose a pitch to match hardware requirements:
214 */
215 GLuint pitch = ((cpp * width + 63) & ~63) / cpp;
216
217 /* alloc hardware renderbuffer */
218 DBG("Allocating %d x %d Intel RBO (pitch %d)\n", width,
219 height, pitch);
220
221 irb->region = intel_region_alloc(intel, I915_TILING_NONE,
222 cpp, width, height, pitch,
223 GL_TRUE);
224 if (!irb->region)
225 return GL_FALSE; /* out of memory? */
226
227 ASSERT(irb->region->buffer);
228
229 rb->Width = width;
230 rb->Height = height;
231
232 return GL_TRUE;
233 }
234 }
235
236
237 /**
238 * Called for each hardware renderbuffer when a _window_ is resized.
239 * Just update fields.
240 * Not used for user-created renderbuffers!
241 */
242 static GLboolean
243 intel_alloc_window_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
244 GLenum internalFormat, GLuint width, GLuint height)
245 {
246 ASSERT(rb->Name == 0);
247 rb->Width = width;
248 rb->Height = height;
249 rb->_ActualFormat = internalFormat;
250
251 return GL_TRUE;
252 }
253
254
255 static void
256 intel_resize_buffers(GLcontext *ctx, struct gl_framebuffer *fb,
257 GLuint width, GLuint height)
258 {
259 struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)fb;
260 int i;
261
262 _mesa_resize_framebuffer(ctx, fb, width, height);
263
264 fb->Initialized = GL_TRUE; /* XXX remove someday */
265
266 if (fb->Name != 0) {
267 return;
268 }
269
270 /* Make sure all window system renderbuffers are up to date */
271 for (i = 0; i < 2; i++) {
272 struct gl_renderbuffer *rb = &intel_fb->color_rb[i]->Base;
273
274 /* only resize if size is changing */
275 if (rb && (rb->Width != width || rb->Height != height)) {
276 rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height);
277 }
278 }
279 }
280
281
282 /** Dummy function for gl_renderbuffer::AllocStorage() */
283 static GLboolean
284 intel_nop_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
285 GLenum internalFormat, GLuint width, GLuint height)
286 {
287 _mesa_problem(ctx, "intel_op_alloc_storage should never be called.");
288 return GL_FALSE;
289 }
290
291
292 void
293 intel_renderbuffer_set_region(struct intel_renderbuffer *rb,
294 struct intel_region *region)
295 {
296 struct intel_region *old;
297
298 old = rb->region;
299 rb->region = NULL;
300 intel_region_reference(&rb->region, region);
301 intel_region_release(&old);
302 }
303
304
305 /**
306 * Create a new intel_renderbuffer which corresponds to an on-screen window,
307 * not a user-created renderbuffer.
308 */
309 struct intel_renderbuffer *
310 intel_create_renderbuffer(GLenum intFormat)
311 {
312 GET_CURRENT_CONTEXT(ctx);
313
314 struct intel_renderbuffer *irb;
315 const GLuint name = 0;
316
317 irb = CALLOC_STRUCT(intel_renderbuffer);
318 if (!irb) {
319 _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
320 return NULL;
321 }
322
323 _mesa_init_renderbuffer(&irb->Base, name);
324 irb->Base.ClassID = INTEL_RB_CLASS;
325
326 switch (intFormat) {
327 case GL_RGB5:
328 irb->Base._ActualFormat = GL_RGB5;
329 irb->Base._BaseFormat = GL_RGBA;
330 irb->Base.RedBits = 5;
331 irb->Base.GreenBits = 6;
332 irb->Base.BlueBits = 5;
333 irb->Base.DataType = GL_UNSIGNED_BYTE;
334 irb->texformat = &_mesa_texformat_rgb565;
335 break;
336 case GL_RGB8:
337 irb->Base._ActualFormat = GL_RGB8;
338 irb->Base._BaseFormat = GL_RGB;
339 irb->Base.RedBits = 8;
340 irb->Base.GreenBits = 8;
341 irb->Base.BlueBits = 8;
342 irb->Base.AlphaBits = 0;
343 irb->Base.DataType = GL_UNSIGNED_BYTE;
344 irb->texformat = &_mesa_texformat_argb8888; /* XXX: Need xrgb8888 */
345 break;
346 case GL_RGBA8:
347 irb->Base._ActualFormat = GL_RGBA8;
348 irb->Base._BaseFormat = GL_RGBA;
349 irb->Base.RedBits = 8;
350 irb->Base.GreenBits = 8;
351 irb->Base.BlueBits = 8;
352 irb->Base.AlphaBits = 8;
353 irb->Base.DataType = GL_UNSIGNED_BYTE;
354 irb->texformat = &_mesa_texformat_argb8888;
355 break;
356 case GL_STENCIL_INDEX8_EXT:
357 irb->Base._ActualFormat = GL_STENCIL_INDEX8_EXT;
358 irb->Base._BaseFormat = GL_STENCIL_INDEX;
359 irb->Base.StencilBits = 8;
360 irb->Base.DataType = GL_UNSIGNED_BYTE;
361 irb->texformat = &_mesa_texformat_s8_z24;
362 break;
363 case GL_DEPTH_COMPONENT16:
364 irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
365 irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
366 irb->Base.DepthBits = 16;
367 irb->Base.DataType = GL_UNSIGNED_SHORT;
368 irb->texformat = &_mesa_texformat_z16;
369 break;
370 case GL_DEPTH_COMPONENT24:
371 irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
372 irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
373 irb->Base.DepthBits = 24;
374 irb->Base.DataType = GL_UNSIGNED_INT;
375 irb->texformat = &_mesa_texformat_s8_z24;
376 break;
377 case GL_DEPTH24_STENCIL8_EXT:
378 irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
379 irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
380 irb->Base.DepthBits = 24;
381 irb->Base.StencilBits = 8;
382 irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
383 irb->texformat = &_mesa_texformat_s8_z24;
384 break;
385 default:
386 _mesa_problem(NULL,
387 "Unexpected intFormat in intel_create_renderbuffer");
388 _mesa_free(irb);
389 return NULL;
390 }
391
392 irb->Base.InternalFormat = intFormat;
393
394 /* intel-specific methods */
395 irb->Base.Delete = intel_delete_renderbuffer;
396 irb->Base.AllocStorage = intel_alloc_window_storage;
397 irb->Base.GetPointer = intel_get_pointer;
398
399 return irb;
400 }
401
402
403 /**
404 * Create a new renderbuffer object.
405 * Typically called via glBindRenderbufferEXT().
406 */
407 static struct gl_renderbuffer *
408 intel_new_renderbuffer(GLcontext * ctx, GLuint name)
409 {
410 /*struct intel_context *intel = intel_context(ctx); */
411 struct intel_renderbuffer *irb;
412
413 irb = CALLOC_STRUCT(intel_renderbuffer);
414 if (!irb) {
415 _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
416 return NULL;
417 }
418
419 _mesa_init_renderbuffer(&irb->Base, name);
420 irb->Base.ClassID = INTEL_RB_CLASS;
421
422 /* intel-specific methods */
423 irb->Base.Delete = intel_delete_renderbuffer;
424 irb->Base.AllocStorage = intel_alloc_renderbuffer_storage;
425 irb->Base.GetPointer = intel_get_pointer;
426 /* span routines set in alloc_storage function */
427
428 return &irb->Base;
429 }
430
431
432 /**
433 * Called via glBindFramebufferEXT().
434 */
435 static void
436 intel_bind_framebuffer(GLcontext * ctx, GLenum target,
437 struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
438 {
439 if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) {
440 intel_draw_buffer(ctx, fb);
441 }
442 else {
443 /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */
444 }
445 }
446
447
448 /**
449 * Called via glFramebufferRenderbufferEXT().
450 */
451 static void
452 intel_framebuffer_renderbuffer(GLcontext * ctx,
453 struct gl_framebuffer *fb,
454 GLenum attachment, struct gl_renderbuffer *rb)
455 {
456 DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0);
457
458 intelFlush(ctx);
459
460 _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
461 intel_draw_buffer(ctx, fb);
462 }
463
464
465 static GLboolean
466 intel_update_wrapper(GLcontext *ctx, struct intel_renderbuffer *irb,
467 struct gl_texture_image *texImage)
468 {
469 irb->texformat = texImage->TexFormat;
470
471 if (texImage->TexFormat == &_mesa_texformat_argb8888) {
472 irb->Base._ActualFormat = GL_RGBA8;
473 irb->Base._BaseFormat = GL_RGBA;
474 irb->Base.DataType = GL_UNSIGNED_BYTE;
475 DBG("Render to RGBA8 texture OK\n");
476 }
477 else if (texImage->TexFormat == &_mesa_texformat_rgb565) {
478 irb->Base._ActualFormat = GL_RGB5;
479 irb->Base._BaseFormat = GL_RGB;
480 irb->Base.DataType = GL_UNSIGNED_BYTE;
481 DBG("Render to RGB5 texture OK\n");
482 }
483 else if (texImage->TexFormat == &_mesa_texformat_argb1555) {
484 irb->Base._ActualFormat = GL_RGB5_A1;
485 irb->Base._BaseFormat = GL_RGBA;
486 irb->Base.DataType = GL_UNSIGNED_BYTE;
487 DBG("Render to ARGB1555 texture OK\n");
488 }
489 else if (texImage->TexFormat == &_mesa_texformat_argb4444) {
490 irb->Base._ActualFormat = GL_RGBA4;
491 irb->Base._BaseFormat = GL_RGBA;
492 irb->Base.DataType = GL_UNSIGNED_BYTE;
493 DBG("Render to ARGB4444 texture OK\n");
494 }
495 else if (texImage->TexFormat == &_mesa_texformat_z16) {
496 irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
497 irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
498 irb->Base.DataType = GL_UNSIGNED_SHORT;
499 DBG("Render to DEPTH16 texture OK\n");
500 }
501 else if (texImage->TexFormat == &_mesa_texformat_s8_z24) {
502 irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
503 irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
504 irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
505 DBG("Render to DEPTH_STENCIL texture OK\n");
506 }
507 else {
508 DBG("Render to texture BAD FORMAT %d\n",
509 texImage->TexFormat->MesaFormat);
510 return GL_FALSE;
511 }
512
513 irb->Base.InternalFormat = irb->Base._ActualFormat;
514 irb->Base.Width = texImage->Width;
515 irb->Base.Height = texImage->Height;
516 irb->Base.RedBits = texImage->TexFormat->RedBits;
517 irb->Base.GreenBits = texImage->TexFormat->GreenBits;
518 irb->Base.BlueBits = texImage->TexFormat->BlueBits;
519 irb->Base.AlphaBits = texImage->TexFormat->AlphaBits;
520 irb->Base.DepthBits = texImage->TexFormat->DepthBits;
521 irb->Base.StencilBits = texImage->TexFormat->StencilBits;
522
523 irb->Base.Delete = intel_delete_renderbuffer;
524 irb->Base.AllocStorage = intel_nop_alloc_storage;
525
526 return GL_TRUE;
527 }
528
529
530 /**
531 * When glFramebufferTexture[123]D is called this function sets up the
532 * gl_renderbuffer wrapper around the texture image.
533 * This will have the region info needed for hardware rendering.
534 */
535 static struct intel_renderbuffer *
536 intel_wrap_texture(GLcontext * ctx, struct gl_texture_image *texImage)
537 {
538 const GLuint name = ~0; /* not significant, but distinct for debugging */
539 struct intel_renderbuffer *irb;
540
541 /* make an intel_renderbuffer to wrap the texture image */
542 irb = CALLOC_STRUCT(intel_renderbuffer);
543 if (!irb) {
544 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture");
545 return NULL;
546 }
547
548 _mesa_init_renderbuffer(&irb->Base, name);
549 irb->Base.ClassID = INTEL_RB_CLASS;
550
551 if (!intel_update_wrapper(ctx, irb, texImage)) {
552 _mesa_free(irb);
553 return NULL;
554 }
555
556 return irb;
557 }
558
559
560 /**
561 * Called by glFramebufferTexture[123]DEXT() (and other places) to
562 * prepare for rendering into texture memory. This might be called
563 * many times to choose different texture levels, cube faces, etc
564 * before intel_finish_render_texture() is ever called.
565 */
566 static void
567 intel_render_texture(GLcontext * ctx,
568 struct gl_framebuffer *fb,
569 struct gl_renderbuffer_attachment *att)
570 {
571 struct gl_texture_image *newImage
572 = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
573 struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
574 struct intel_texture_image *intel_image;
575 GLuint dst_x, dst_y;
576
577 (void) fb;
578
579 ASSERT(newImage);
580
581 intel_image = intel_texture_image(newImage);
582 if (!intel_image->mt) {
583 /* Fallback on drawing to a texture that doesn't have a miptree
584 * (has a border, width/height 0, etc.)
585 */
586 _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
587 _mesa_render_texture(ctx, fb, att);
588 return;
589 }
590 else if (!irb) {
591 irb = intel_wrap_texture(ctx, newImage);
592 if (irb) {
593 /* bind the wrapper to the attachment point */
594 _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base);
595 }
596 else {
597 /* fallback to software rendering */
598 _mesa_render_texture(ctx, fb, att);
599 return;
600 }
601 }
602
603 if (!intel_update_wrapper(ctx, irb, newImage)) {
604 _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
605 _mesa_render_texture(ctx, fb, att);
606 return;
607 }
608
609 DBG("Begin render texture tid %x tex=%u w=%d h=%d refcount=%d\n",
610 _glthread_GetID(),
611 att->Texture->Name, newImage->Width, newImage->Height,
612 irb->Base.RefCount);
613
614 /* point the renderbufer's region to the texture image region */
615 if (irb->region != intel_image->mt->region) {
616 if (irb->region)
617 intel_region_release(&irb->region);
618 intel_region_reference(&irb->region, intel_image->mt->region);
619 }
620
621 /* compute offset of the particular 2D image within the texture region */
622 intel_miptree_get_image_offset(intel_image->mt,
623 att->TextureLevel,
624 att->CubeMapFace,
625 att->Zoffset,
626 &dst_x, &dst_y);
627
628 intel_image->mt->region->draw_offset = (dst_y * intel_image->mt->pitch +
629 dst_x) * intel_image->mt->cpp;
630 intel_image->mt->region->draw_x = dst_x;
631 intel_image->mt->region->draw_y = dst_y;
632
633 /* update drawing region, etc */
634 intel_draw_buffer(ctx, fb);
635 }
636
637
638 /**
639 * Called by Mesa when rendering to a texture is done.
640 */
641 static void
642 intel_finish_render_texture(GLcontext * ctx,
643 struct gl_renderbuffer_attachment *att)
644 {
645 /* no-op
646 * Previously we released the renderbuffer's intel_region but
647 * that's not necessary and actually caused problems when trying
648 * to do a glRead/CopyPixels from the renderbuffer later.
649 * The region will be released later if the texture is replaced
650 * or the renderbuffer deleted.
651 *
652 * The intention of this driver hook is more of a "done rendering
653 * to texture, please re-twiddle/etc if necessary".
654 */
655 }
656
657
658 /**
659 * Do additional "completeness" testing of a framebuffer object.
660 */
661 static void
662 intel_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
663 {
664 const struct intel_renderbuffer *depthRb =
665 intel_get_renderbuffer(fb, BUFFER_DEPTH);
666 const struct intel_renderbuffer *stencilRb =
667 intel_get_renderbuffer(fb, BUFFER_STENCIL);
668 int i;
669
670 if (stencilRb && stencilRb != depthRb) {
671 /* we only support combined depth/stencil buffers, not separate
672 * stencil buffers.
673 */
674 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
675 }
676
677 for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
678 struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i];
679 struct intel_renderbuffer *irb = intel_renderbuffer(rb);
680
681 if (rb == NULL)
682 continue;
683
684 if (irb == NULL) {
685 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
686 continue;
687 }
688
689 switch (irb->texformat->MesaFormat) {
690 case MESA_FORMAT_ARGB8888:
691 case MESA_FORMAT_RGB565:
692 case MESA_FORMAT_ARGB1555:
693 case MESA_FORMAT_ARGB4444:
694 break;
695 default:
696 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
697 }
698 }
699 }
700
701
702 /**
703 * Do one-time context initializations related to GL_EXT_framebuffer_object.
704 * Hook in device driver functions.
705 */
706 void
707 intel_fbo_init(struct intel_context *intel)
708 {
709 intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer;
710 intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer;
711 intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer;
712 intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer;
713 intel->ctx.Driver.RenderTexture = intel_render_texture;
714 intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;
715 intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;
716 intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer;
717 intel->ctx.Driver.BlitFramebuffer = _mesa_meta_BlitFramebuffer;
718 }