2 * Mesa 3-D graphics library
5 * Copyright (C) 2010 LunarG Inc.
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:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * 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 OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
26 * Chia-I Wu <olv@lunarg.com>
29 #include "state_tracker/st_api.h"
31 #include "pipe/p_context.h"
32 #include "pipe/p_screen.h"
33 #include "util/u_format.h"
34 #include "util/u_pointer.h"
35 #include "util/u_inlines.h"
36 #include "util/u_atomic.h"
38 #include "main/mtypes.h"
39 #include "main/context.h"
40 #include "main/texobj.h"
41 #include "main/teximage.h"
42 #include "main/texstate.h"
43 #include "main/texfetch.h"
44 #include "main/framebuffer.h"
45 #include "main/renderbuffer.h"
46 #include "st_texture.h"
48 #include "st_context.h"
49 #include "st_format.h"
50 #include "st_cb_fbo.h"
51 #include "st_manager.h"
53 /* these functions are defined in st_context.c */
55 st_create_context(struct pipe_context *pipe,
56 const __GLcontextModes *visual,
57 struct st_context *share);
58 void st_destroy_context(struct st_context *st);
59 void st_flush(struct st_context *st, uint pipeFlushFlags,
60 struct pipe_fence_handle **fence);
63 * Cast wrapper to convert a GLframebuffer to an st_framebuffer.
64 * Return NULL if the GLframebuffer is a user-created framebuffer.
65 * We'll only return non-null for window system framebuffers.
66 * Note that this function may fail.
68 static INLINE struct st_framebuffer *
69 st_ws_framebuffer(GLframebuffer *fb)
71 /* FBO cannot be casted. See st_new_framebuffer */
72 return (struct st_framebuffer *) ((fb && !fb->Name) ? fb : NULL);
76 * Map an attachment to a buffer index.
78 static INLINE gl_buffer_index
79 attachment_to_buffer_index(enum st_attachment_type statt)
81 gl_buffer_index index;
84 case ST_ATTACHMENT_FRONT_LEFT:
85 index = BUFFER_FRONT_LEFT;
87 case ST_ATTACHMENT_BACK_LEFT:
88 index = BUFFER_BACK_LEFT;
90 case ST_ATTACHMENT_FRONT_RIGHT:
91 index = BUFFER_FRONT_RIGHT;
93 case ST_ATTACHMENT_BACK_RIGHT:
94 index = BUFFER_BACK_RIGHT;
96 case ST_ATTACHMENT_DEPTH_STENCIL:
99 case ST_ATTACHMENT_ACCUM:
100 index = BUFFER_ACCUM;
102 case ST_ATTACHMENT_SAMPLE:
104 index = BUFFER_COUNT;
112 * Map a buffer index to an attachment.
114 static INLINE enum st_attachment_type
115 buffer_index_to_attachment(gl_buffer_index index)
117 enum st_attachment_type statt;
120 case BUFFER_FRONT_LEFT:
121 statt = ST_ATTACHMENT_FRONT_LEFT;
123 case BUFFER_BACK_LEFT:
124 statt = ST_ATTACHMENT_BACK_LEFT;
126 case BUFFER_FRONT_RIGHT:
127 statt = ST_ATTACHMENT_FRONT_RIGHT;
129 case BUFFER_BACK_RIGHT:
130 statt = ST_ATTACHMENT_BACK_RIGHT;
133 statt = ST_ATTACHMENT_DEPTH_STENCIL;
136 statt = ST_ATTACHMENT_ACCUM;
139 statt = ST_ATTACHMENT_INVALID;
147 * Validate a framebuffer to make sure up-to-date pipe_textures are used.
150 st_framebuffer_validate(struct st_framebuffer *stfb, struct st_context *st)
152 struct pipe_screen *screen = st->pipe->screen;
153 struct pipe_resource *textures[ST_ATTACHMENT_COUNT];
156 boolean changed = FALSE;
158 if (!p_atomic_read(&stfb->revalidate))
161 /* validate the fb */
162 if (!stfb->iface->validate(stfb->iface, stfb->statts, stfb->num_statts, textures))
165 width = stfb->Base.Width;
166 height = stfb->Base.Height;
168 for (i = 0; i < stfb->num_statts; i++) {
169 struct st_renderbuffer *strb;
170 struct pipe_surface *ps;
176 idx = attachment_to_buffer_index(stfb->statts[i]);
177 if (idx >= BUFFER_COUNT) {
178 pipe_resource_reference(&textures[i], NULL);
182 strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
184 if (strb->texture == textures[i]) {
185 pipe_resource_reference(&textures[i], NULL);
189 ps = screen->get_tex_surface(screen, textures[i], 0, 0, 0,
190 PIPE_BIND_RENDER_TARGET);
192 pipe_surface_reference(&strb->surface, ps);
193 pipe_resource_reference(&strb->texture, ps->texture);
194 /* ownership transfered */
195 pipe_surface_reference(&ps, NULL);
199 strb->Base.Width = strb->surface->width;
200 strb->Base.Height = strb->surface->height;
202 width = strb->Base.Width;
203 height = strb->Base.Height;
206 pipe_resource_reference(&textures[i], NULL);
210 st->dirty.st |= ST_NEW_FRAMEBUFFER;
211 _mesa_resize_framebuffer(st->ctx, &stfb->Base, width, height);
213 assert(stfb->Base.Width == width);
214 assert(stfb->Base.Height == height);
217 p_atomic_set(&stfb->revalidate, FALSE);
221 * Update the attachments to validate by looping the existing renderbuffers.
224 st_framebuffer_update_attachments(struct st_framebuffer *stfb)
228 stfb->num_statts = 0;
229 for (idx = 0; idx < BUFFER_COUNT; idx++) {
230 struct st_renderbuffer *strb;
231 enum st_attachment_type statt;
233 strb = st_renderbuffer(stfb->Base.Attachment[idx].Renderbuffer);
234 if (!strb || strb->software)
237 statt = buffer_index_to_attachment(idx);
238 if (statt != ST_ATTACHMENT_INVALID &&
239 st_visual_have_buffers(stfb->iface->visual, 1 << statt))
240 stfb->statts[stfb->num_statts++] = statt;
243 p_atomic_set(&stfb->revalidate, TRUE);
247 * Add a renderbuffer to the framebuffer.
250 st_framebuffer_add_renderbuffer(struct st_framebuffer *stfb,
253 struct gl_renderbuffer *rb;
254 enum pipe_format format;
258 /* do not distinguish depth/stencil buffers */
259 if (idx == BUFFER_STENCIL)
264 format = stfb->iface->visual->depth_stencil_format;
268 format = stfb->iface->visual->accum_format;
272 format = stfb->iface->visual->color_format;
277 if (format == PIPE_FORMAT_NONE)
280 samples = stfb->iface->visual->samples;
282 samples = st_get_msaa();
284 rb = st_new_renderbuffer_fb(format, samples, sw);
288 if (idx != BUFFER_DEPTH) {
289 _mesa_add_renderbuffer(&stfb->Base, idx, rb);
292 if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0))
293 _mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, rb);
294 if (util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1))
295 _mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, rb);
302 * Intialize a __GLcontextModes from a visual.
305 st_visual_to_context_mode(const struct st_visual *visual,
306 __GLcontextModes *mode)
308 memset(mode, 0, sizeof(*mode));
310 if (st_visual_have_buffers(visual, ST_ATTACHMENT_BACK_LEFT_MASK))
311 mode->doubleBufferMode = GL_TRUE;
312 if (st_visual_have_buffers(visual,
313 ST_ATTACHMENT_FRONT_RIGHT_MASK | ST_ATTACHMENT_BACK_RIGHT_MASK))
314 mode->stereoMode = GL_TRUE;
316 if (visual->color_format != PIPE_FORMAT_NONE) {
317 mode->rgbMode = GL_TRUE;
320 util_format_get_component_bits(visual->color_format,
321 UTIL_FORMAT_COLORSPACE_RGB, 0);
323 util_format_get_component_bits(visual->color_format,
324 UTIL_FORMAT_COLORSPACE_RGB, 1);
326 util_format_get_component_bits(visual->color_format,
327 UTIL_FORMAT_COLORSPACE_RGB, 2);
329 util_format_get_component_bits(visual->color_format,
330 UTIL_FORMAT_COLORSPACE_RGB, 3);
332 mode->rgbBits = mode->redBits +
333 mode->greenBits + mode->blueBits + mode->alphaBits;
336 if (visual->depth_stencil_format != PIPE_FORMAT_NONE) {
338 util_format_get_component_bits(visual->depth_stencil_format,
339 UTIL_FORMAT_COLORSPACE_ZS, 0);
341 util_format_get_component_bits(visual->depth_stencil_format,
342 UTIL_FORMAT_COLORSPACE_ZS, 1);
344 mode->haveDepthBuffer = mode->depthBits > 0;
345 mode->haveStencilBuffer = mode->stencilBits > 0;
348 if (visual->accum_format != PIPE_FORMAT_NONE) {
349 mode->haveAccumBuffer = GL_TRUE;
352 util_format_get_component_bits(visual->accum_format,
353 UTIL_FORMAT_COLORSPACE_RGB, 0);
354 mode->accumGreenBits =
355 util_format_get_component_bits(visual->accum_format,
356 UTIL_FORMAT_COLORSPACE_RGB, 1);
357 mode->accumBlueBits =
358 util_format_get_component_bits(visual->accum_format,
359 UTIL_FORMAT_COLORSPACE_RGB, 2);
360 mode->accumAlphaBits =
361 util_format_get_component_bits(visual->accum_format,
362 UTIL_FORMAT_COLORSPACE_RGB, 3);
365 if (visual->samples) {
366 mode->sampleBuffers = 1;
367 mode->samples = visual->samples;
372 * Determine the default draw or read buffer from a visual.
375 st_visual_to_default_buffer(const struct st_visual *visual,
376 GLenum *buffer, GLint *index)
378 enum st_attachment_type statt;
382 statt = visual->render_buffer;
383 /* do nothing if an invalid render buffer is specified */
384 if (statt == ST_ATTACHMENT_INVALID ||
385 !st_visual_have_buffers(visual, 1 << statt))
389 case ST_ATTACHMENT_FRONT_LEFT:
391 idx = BUFFER_FRONT_LEFT;
393 case ST_ATTACHMENT_BACK_LEFT:
395 idx = BUFFER_BACK_LEFT;
397 case ST_ATTACHMENT_FRONT_RIGHT:
398 buf = GL_FRONT_RIGHT;
399 idx = BUFFER_FRONT_RIGHT;
401 case ST_ATTACHMENT_BACK_RIGHT:
403 idx = BUFFER_BACK_RIGHT;
411 if (buf != GL_NONE) {
420 * Create a framebuffer from a manager interface.
422 static struct st_framebuffer *
423 st_framebuffer_create(struct st_framebuffer_iface *stfbi)
425 struct st_framebuffer *stfb;
426 __GLcontextModes mode;
429 stfb = CALLOC_STRUCT(st_framebuffer);
433 st_visual_to_context_mode(stfbi->visual, &mode);
434 _mesa_initialize_window_framebuffer(&stfb->Base, &mode);
436 /* modify the draw/read buffers of the fb */
437 st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorDrawBuffer[0],
438 &stfb->Base._ColorDrawBufferIndexes[0]);
439 st_visual_to_default_buffer(stfbi->visual, &stfb->Base.ColorReadBuffer,
440 &stfb->Base._ColorReadBufferIndex);
444 /* add the color buffer */
445 idx = stfb->Base._ColorDrawBufferIndexes[0];
446 if (!st_framebuffer_add_renderbuffer(stfb, idx)) {
451 st_framebuffer_add_renderbuffer(stfb, BUFFER_DEPTH);
452 st_framebuffer_add_renderbuffer(stfb, BUFFER_ACCUM);
454 st_framebuffer_update_attachments(stfb);
456 stfb->Base.Initialized = GL_TRUE;
462 * Reference a framebuffer.
465 st_framebuffer_reference(struct st_framebuffer **ptr,
466 struct st_framebuffer *stfb)
468 GLframebuffer *fb = &stfb->Base;
469 _mesa_reference_framebuffer((GLframebuffer **) ptr, fb);
473 st_context_notify_invalid_framebuffer(struct st_context_iface *stctxi,
474 struct st_framebuffer_iface *stfbi)
476 struct st_context *st = (struct st_context *) stctxi;
477 struct st_framebuffer *stfb;
479 /* either draw or read winsys fb */
480 stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);
481 if (!stfb || stfb->iface != stfbi)
482 stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);
483 assert(stfb && stfb->iface == stfbi);
485 p_atomic_set(&stfb->revalidate, TRUE);
489 st_context_flush(struct st_context_iface *stctxi, unsigned flags,
490 struct pipe_fence_handle **fence)
492 struct st_context *st = (struct st_context *) stctxi;
493 st_flush(st, flags, fence);
494 if (flags & PIPE_FLUSH_RENDER_CACHE)
495 st_manager_flush_frontbuffer(st);
499 st_context_teximage(struct st_context_iface *stctxi, enum st_texture_type target,
500 int level, enum pipe_format internal_format,
501 struct pipe_resource *tex, boolean mipmap)
503 struct st_context *st = (struct st_context *) stctxi;
504 GLcontext *ctx = st->ctx;
505 struct gl_texture_unit *texUnit = _mesa_get_current_tex_unit(ctx);
506 struct gl_texture_object *texObj;
507 struct gl_texture_image *texImage;
508 struct st_texture_object *stObj;
509 struct st_texture_image *stImage;
510 GLenum internalFormat;
514 target = GL_TEXTURE_1D;
517 target = GL_TEXTURE_2D;
520 target = GL_TEXTURE_3D;
522 case ST_TEXTURE_RECT:
523 target = GL_TEXTURE_RECTANGLE_ARB;
530 if (util_format_get_component_bits(internal_format,
531 UTIL_FORMAT_COLORSPACE_RGB, 3) > 0)
532 internalFormat = GL_RGBA;
534 internalFormat = GL_RGB;
536 texObj = _mesa_select_tex_object(ctx, texUnit, target);
537 _mesa_lock_texture(ctx, texObj);
539 stObj = st_texture_object(texObj);
540 /* switch to surface based */
541 if (!stObj->surface_based) {
542 _mesa_clear_texture_object(ctx, texObj);
543 stObj->surface_based = GL_TRUE;
546 texImage = _mesa_get_tex_image(ctx, texObj, target, level);
547 stImage = st_texture_image(texImage);
549 _mesa_init_teximage_fields(ctx, target, texImage,
550 tex->width0, tex->height0, 1, 0, internalFormat);
551 texImage->TexFormat = st_ChooseTextureFormat(ctx, internalFormat,
552 GL_RGBA, GL_UNSIGNED_BYTE);
553 _mesa_set_fetch_functions(texImage, 2);
556 _mesa_clear_texture_image(ctx, texImage);
559 stObj->pipe = st->pipe;
560 pipe_resource_reference(&stImage->pt, tex);
562 _mesa_dirty_texobj(ctx, texObj, GL_TRUE);
563 _mesa_unlock_texture(ctx, texObj);
569 st_context_destroy(struct st_context_iface *stctxi)
571 struct st_context *st = (struct st_context *) stctxi;
572 st_destroy_context(st);
575 static struct st_context_iface *
576 st_api_create_context(struct st_api *stapi, struct st_manager *smapi,
577 const struct st_visual *visual,
578 struct st_context_iface *shared_stctxi)
580 struct st_context *shared_ctx = (struct st_context *) shared_stctxi;
581 struct st_context *st;
582 struct pipe_context *pipe;
583 __GLcontextModes mode;
585 pipe = smapi->screen->context_create(smapi->screen, NULL);
589 st_visual_to_context_mode(visual, &mode);
590 st = st_create_context(pipe, &mode, shared_ctx);
596 st->iface.destroy = st_context_destroy;
598 st->iface.notify_invalid_framebuffer =
599 st_context_notify_invalid_framebuffer;
600 st->iface.flush = st_context_flush;
602 st->iface.teximage = st_context_teximage;
603 st->iface.copy = NULL;
605 st->iface.st_context_private = (void *) smapi;
611 st_api_make_current(struct st_api *stapi, struct st_context_iface *stctxi,
612 struct st_framebuffer_iface *stdrawi,
613 struct st_framebuffer_iface *streadi)
615 struct st_context *st = (struct st_context *) stctxi;
616 struct st_framebuffer *stdraw, *stread, *stfb;
619 _glapi_check_multithread();
622 /* reuse/create the draw fb */
623 stfb = st_ws_framebuffer(st->ctx->WinSysDrawBuffer);
624 if (stfb && stfb->iface == stdrawi) {
626 st_framebuffer_reference(&stdraw, stfb);
629 stdraw = st_framebuffer_create(stdrawi);
632 /* reuse/create the read fb */
633 stfb = st_ws_framebuffer(st->ctx->WinSysReadBuffer);
634 if (!stfb || stfb->iface != streadi)
636 if (stfb && stfb->iface == streadi) {
638 st_framebuffer_reference(&stread, stfb);
641 stread = st_framebuffer_create(streadi);
644 if (stdraw && stread) {
645 st_framebuffer_validate(stdraw, st);
646 if (stread != stdraw)
647 st_framebuffer_validate(stread, st);
649 /* modify the draw/read buffers of the context */
650 st_visual_to_default_buffer(stdraw->iface->visual,
651 &st->ctx->Color.DrawBuffer[0], NULL);
652 st_visual_to_default_buffer(stread->iface->visual,
653 &st->ctx->Pixel.ReadBuffer, NULL);
655 ret = _mesa_make_current(st->ctx, &stdraw->Base, &stread->Base);
661 st_framebuffer_reference(&stdraw, NULL);
662 st_framebuffer_reference(&stread, NULL);
665 ret = _mesa_make_current(NULL, NULL, NULL);
671 static struct st_context_iface *
672 st_api_get_current(struct st_api *stapi)
674 GET_CURRENT_CONTEXT(ctx);
675 struct st_context *st = (ctx) ? ctx->st : NULL;
677 return (st) ? &st->iface : NULL;
681 st_api_is_visual_supported(struct st_api *stapi,
682 const struct st_visual *visual)
688 st_api_get_proc_address(struct st_api *stapi, const char *procname)
690 return (st_proc_t) _glapi_get_proc_address(procname);
694 st_api_destroy(struct st_api *stapi)
700 * Flush the front buffer if the current context renders to the front buffer.
703 st_manager_flush_frontbuffer(struct st_context *st)
705 struct st_framebuffer *stfb = st_ws_framebuffer(st->ctx->DrawBuffer);
706 struct st_renderbuffer *strb = NULL;
709 strb = st_renderbuffer(stfb->Base.Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
715 struct pipe_surface *front_surf = strb->surface;
716 st->pipe->screen->flush_frontbuffer(st->pipe->screen,
717 front_surf, st->winsys_drawable_handle);
721 stfb->iface->flush_front(stfb->iface, ST_ATTACHMENT_FRONT_LEFT);
725 * Return the surface of an EGLImage.
727 struct pipe_surface *
728 st_manager_get_egl_image_surface(struct st_context *st,
729 void *eglimg, unsigned usage)
731 struct st_manager *smapi =
732 (struct st_manager *) st->iface.st_context_private;
733 struct st_egl_image stimg;
734 struct pipe_surface *ps;
736 if (!smapi || !smapi->get_egl_image)
739 memset(&stimg, 0, sizeof(stimg));
740 stimg.stctxi = &st->iface;
741 stimg.egl_image = eglimg;
742 if (!smapi->get_egl_image(smapi, &stimg))
745 ps = smapi->screen->get_tex_surface(smapi->screen,
746 stimg.texture, stimg.face, stimg.level, stimg.zslice, usage);
747 pipe_resource_reference(&stimg.texture, NULL);
753 * Re-validate the framebuffers.
756 st_manager_validate_framebuffers(struct st_context *st)
758 struct st_framebuffer *stdraw = st_ws_framebuffer(st->ctx->DrawBuffer);
759 struct st_framebuffer *stread = st_ws_framebuffer(st->ctx->ReadBuffer);
762 if ((stdraw && !stdraw->iface) || (stread && !stread->iface)) {
763 struct pipe_screen *screen = st->pipe->screen;
764 if (screen->update_buffer)
765 screen->update_buffer(screen, st->pipe->priv);
770 st_framebuffer_validate(stdraw, st);
771 if (stread && stread != stdraw)
772 st_framebuffer_validate(stread, st);
776 * Add a color renderbuffer on demand.
779 st_manager_add_color_renderbuffer(struct st_context *st, GLframebuffer *fb,
782 struct st_framebuffer *stfb = st_ws_framebuffer(fb);
784 /* FBO or st_public.h */
785 if (!stfb || !stfb->iface)
788 if (stfb->Base.Attachment[idx].Renderbuffer)
792 case BUFFER_FRONT_LEFT:
793 case BUFFER_BACK_LEFT:
794 case BUFFER_FRONT_RIGHT:
795 case BUFFER_BACK_RIGHT:
802 if (!st_framebuffer_add_renderbuffer(stfb, idx))
805 st_framebuffer_update_attachments(stfb);
806 st_invalidate_state(st->ctx, _NEW_BUFFERS);
812 * Create an st_api to manage the state tracker.
815 st_manager_create_api(void)
817 struct st_api *stapi;
819 stapi = CALLOC_STRUCT(st_api);
821 stapi->destroy = st_api_destroy;
822 stapi->get_proc_address = st_api_get_proc_address;
823 stapi->is_visual_supported = st_api_is_visual_supported;
825 stapi->create_context = st_api_create_context;
826 stapi->make_current = st_api_make_current;
827 stapi->get_current = st_api_get_current;