st_atom_framebuffer.c File Reference

Include dependency graph for st_atom_framebuffer.c:

Go to the source code of this file.

Functions
static void	update_renderbuffer_surface (struct st_context *st, struct st_renderbuffer *strb)
	When doing GL render to texture, we have to be sure that finalize_texture() didn't yank out the pipe_texture that we earlier created a surface for.
static void	update_framebuffer_state (struct st_context *st)
	Update framebuffer state (color, depth, stencil, etc.
Variables
struct st_tracked_state	st_update_framebuffer

---

Function Documentation

static void update_framebuffer_state

(

struct st_context *

st

)

[static]

Update framebuffer state (color, depth, stencil, etc.

buffers)

Definition at line 93 of file st_atom_framebuffer.c.

References assert, st_renderbuffer::Base, pipe_framebuffer_state::cbufs, st_context::cso_context, cso_set_framebuffer(), st_context::ctx, st_context::framebuffer, FRONT_STATUS_COPY_OF_BACK, FRONT_STATUS_DIRTY, st_context::frontbuffer_status, pipe_framebuffer_state::height, pipe_framebuffer_state::num_cbufs, st_renderbuffer::rtt, st_renderbuffer(), st_context::state, st_renderbuffer::surface, update_renderbuffer_surface(), pipe_framebuffer_state::width, and pipe_framebuffer_state::zsbuf.

{
   struct pipe_framebuffer_state *framebuffer = &st->state.framebuffer;
   struct gl_framebuffer *fb = st->ctx->DrawBuffer;
   struct st_renderbuffer *strb;
   GLuint i, j;

   memset(framebuffer, 0, sizeof(*framebuffer));

   framebuffer->width = fb->Width;
   framebuffer->height = fb->Height;

   /*printf("------ fb size %d x %d\n", fb->Width, fb->Height);*/

   /* Examine Mesa's ctx->DrawBuffer->_ColorDrawBuffers state
    * to determine which surfaces to draw to
    */
   framebuffer->num_cbufs = 0;
   for (j = 0; j < MAX_DRAW_BUFFERS; j++) {
      for (i = 0; i < fb->_NumColorDrawBuffers[j]; i++) {
         strb = st_renderbuffer(fb->_ColorDrawBuffers[j][i]);

         /*printf("--------- framebuffer surface rtt %p\n", strb->rtt);*/
         if (strb->rtt) {
            /* rendering to a GL texture, may have to update surface */
            update_renderbuffer_surface(st, strb);
         }

         if (strb->surface) {
            framebuffer->cbufs[framebuffer->num_cbufs] = strb->surface;
            framebuffer->num_cbufs++;
         }
      }
   }

   strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
   if (strb) {
      strb = st_renderbuffer(strb->Base.Wrapped);
      if (strb->rtt) {
         /* rendering to a GL texture, may have to update surface */
         update_renderbuffer_surface(st, strb);
      }

      framebuffer->zsbuf = strb->surface;
   }
   else {
      strb = st_renderbuffer(fb->Attachment[BUFFER_STENCIL].Renderbuffer);
      if (strb) {
         strb = st_renderbuffer(strb->Base.Wrapped);
         assert(strb->surface);
         framebuffer->zsbuf = strb->surface;
      }
   }

   cso_set_framebuffer(st->cso_context, framebuffer);

   if (fb->_ColorDrawBufferMask[0] & BUFFER_BIT_FRONT_LEFT) {
      if (st->frontbuffer_status == FRONT_STATUS_COPY_OF_BACK) {
         /* XXX copy back buf to front? */
      }
      /* we're assuming we'll really draw to the front buffer */
      st->frontbuffer_status = FRONT_STATUS_DIRTY;
   }
}

static void update_renderbuffer_surface	(	struct st_context *	st,
		struct st_renderbuffer *	strb
	)			[static]

When doing GL render to texture, we have to be sure that finalize_texture() didn't yank out the pipe_texture that we earlier created a surface for.

Check for that here and create a new surface if needed.

Definition at line 50 of file st_atom_framebuffer.c.

References st_renderbuffer::Base, pipe_screen::get_tex_surface, pipe_texture::height, pipe_surface::height, pipe_texture::last_level, st_context::pipe, PIPE_BUFFER_USAGE_GPU_READ, PIPE_BUFFER_USAGE_GPU_WRITE, pipe_surface_reference(), st_texture_object::pt, st_renderbuffer::rtt, st_renderbuffer::rtt_face, st_renderbuffer::rtt_slice, pipe_context::screen, st_renderbuffer::surface, pipe_surface::texture, pipe_texture::width, and pipe_surface::width.

{
   struct pipe_screen *screen = st->pipe->screen;
   struct pipe_texture *texture = strb->rtt->pt;
   int rtt_width = strb->Base.Width;
   int rtt_height = strb->Base.Height;

   if (!strb->surface ||
       strb->surface->texture != texture ||
       strb->surface->width != rtt_width ||
       strb->surface->height != rtt_height) {
      GLuint level;
      /* find matching mipmap level size */
      for (level = 0; level <= texture->last_level; level++) {
         if (texture->width[level] == rtt_width &&
             texture->height[level] == rtt_height) {

            pipe_surface_reference(&strb->surface, NULL);

            strb->surface = screen->get_tex_surface(screen,
                                              texture,
                                              strb->rtt_face,
                                              level,
                                              strb->rtt_slice,
                                              PIPE_BUFFER_USAGE_GPU_READ |
                                              PIPE_BUFFER_USAGE_GPU_WRITE);
#if 0
            printf("-- alloc new surface %d x %d into tex %p\n",
                   strb->surface->width, strb->surface->height,
                   texture);
#endif
            break;
         }
      }
   }
}

---

Variable Documentation

struct st_tracked_state st_update_framebuffer

Initial value:

 {
   "st_update_framebuffer",                             
   {                                                    
      _NEW_BUFFERS,                                     
       0x8 ,                            
   },
   update_framebuffer_state                             
}

Definition at line 159 of file st_atom_framebuffer.c.

---