path: root/src/mesa/state_tracker/st_cb_fbo.c

/**************************************************************************
 * 
 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
 * All Rights Reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * 
 **************************************************************************/


/**
 * Framebuffer/renderbuffer functions.
 *
 * \author Brian Paul
 */


#include "main/imports.h"
#include "main/context.h"
#include "main/fbobject.h"
#include "main/framebuffer.h"
#include "main/renderbuffer.h"

#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "st_context.h"
#include "st_cb_fbo.h"
#include "st_cb_teximage.h"


struct pipe_format_info
{
   GLuint format;
   GLenum base_format;
   GLubyte red_bits;
   GLubyte green_bits;
   GLubyte blue_bits;
   GLubyte alpha_bits;
   GLubyte luminance_bits;
   GLubyte intensity_bits;
   GLubyte depth_bits;
   GLubyte stencil_bits;
   GLubyte size;           /**< in bytes */
};


/*
 * XXX temporary here
 */
static const struct pipe_format_info *
pipe_get_format_info(GLuint format)
{
   static const struct pipe_format_info info[] = {
      {
         PIPE_FORMAT_U_R8_G8_B8_A8,  /* format */
         GL_RGBA,                    /* base_format */
         8, 8, 8, 8, 0, 0,           /* color bits */
         0, 0,                       /* depth, stencil */
         4                           /* size in bytes */
      },
      {
         PIPE_FORMAT_U_A8_R8_G8_B8,
         GL_RGBA,                    /* base_format */
         8, 8, 8, 8, 0, 0,           /* color bits */
         0, 0,                       /* depth, stencil */
         4                           /* size in bytes */
      },
      {
         PIPE_FORMAT_U_A1_R5_G5_B5,
         GL_RGBA,                    /* base_format */
         5, 5, 5, 1, 0, 0,           /* color bits */
         0, 0,                       /* depth, stencil */
         2                           /* size in bytes */
      },
      {
         PIPE_FORMAT_U_R5_G6_B5,
         GL_RGBA,                    /* base_format */
         5, 6, 5, 0, 0, 0,           /* color bits */
         0, 0,                       /* depth, stencil */
         2                           /* size in bytes */
      },
      /* XXX lots more */
      {
         PIPE_FORMAT_S8_Z24,
         GL_DEPTH_STENCIL_EXT,       /* base_format */
         0, 0, 0, 0, 0, 0,           /* color bits */
         24, 8,                      /* depth, stencil */
         4                           /* size in bytes */
      }
   };         
   GLuint i;

   for (i = 0; i < sizeof(info) / sizeof(info[0]); i++) {
      if (info[i].format == format)
         return info + i;
   }
   return NULL;
}


/**
 * gl_renderbuffer::AllocStorage()
 */
static GLboolean
st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
                              GLenum internalFormat,
                              GLuint width, GLuint height)
{
   struct pipe_context *pipe = ctx->st->pipe;
   struct st_renderbuffer *strb = st_renderbuffer(rb);
   const GLuint pipeFormat
      = st_choose_pipe_format(pipe, internalFormat, GL_NONE, GL_NONE);
   const struct pipe_format_info *info = pipe_get_format_info(pipeFormat);
   GLuint cpp, pitch;

   assert(info);
   if (!info)
      return GL_FALSE;

   switch (pipeFormat) {
   case PIPE_FORMAT_S8_Z24:
      strb->Base.DataType = GL_UNSIGNED_INT;
      break;
   default:
      strb->Base.DataType = GL_UNSIGNED_BYTE; /* XXX fix */
   }

   strb->Base._ActualFormat = info->base_format;
   strb->Base.RedBits = info->red_bits;
   strb->Base.GreenBits = info->green_bits;
   strb->Base.BlueBits = info->blue_bits;
   strb->Base.AlphaBits = info->alpha_bits;
   strb->Base.DepthBits = info->depth_bits;
   strb->Base.StencilBits = info->stencil_bits;

   cpp = info->size;

   if (!strb->surface) {
      strb->surface = pipe->surface_alloc(pipe, pipeFormat);
      assert(strb->surface);
      if (!strb->surface)
         return GL_FALSE;
   }

   /* free old region */
   if (strb->surface->region) {
      pipe->region_release(pipe, &strb->surface->region);
   }

   /* Choose a pitch to match hardware requirements:
    */
   pitch = ((cpp * width + 63) & ~63) / cpp; /* XXX fix: device-specific */

   strb->surface->region = pipe->region_alloc(pipe, cpp, pitch, height);
   if (!strb->surface->region)
      return GL_FALSE; /* out of memory, try s/w buffer? */

   ASSERT(strb->surface->region->buffer);

   strb->Base.Width  = strb->surface->width  = width;
   strb->Base.Height = strb->surface->height = height;

   return GL_TRUE;
}


/**
 * gl_renderbuffer::Delete()
 */
static void
st_renderbuffer_delete(struct gl_renderbuffer *rb)
{
   GET_CURRENT_CONTEXT(ctx);
   struct pipe_context *pipe = ctx->st->pipe;
   struct st_renderbuffer *strb = st_renderbuffer(rb);
   ASSERT(strb);
   if (strb && strb->surface) {
      if (strb->surface->region) {
         pipe->region_release(pipe, &strb->surface->region);
      }
      free(strb->surface);
   }
   free(strb);
}


/**
 * gl_renderbuffer::GetPointer()
 */
static void *
null_get_pointer(GLcontext * ctx, struct gl_renderbuffer *rb,
                 GLint x, GLint y)
{
   /* By returning NULL we force all software rendering to go through
    * the span routines.
    */
#if 0
   assert(0);  /* Should never get called with softpipe */
#endif
   return NULL;
}


/**
 * Called via ctx->Driver.NewFramebuffer()
 */
static struct gl_framebuffer *
st_new_framebuffer(GLcontext *ctx, GLuint name)
{
   /* XXX not sure we need to subclass gl_framebuffer for pipe */
   return _mesa_new_framebuffer(ctx, name);
}


/**
 * Called via ctx->Driver.NewRenderbuffer()
 */
static struct gl_renderbuffer *
st_new_renderbuffer(GLcontext *ctx, GLuint name)
{
   struct st_renderbuffer *strb = CALLOC_STRUCT(st_renderbuffer);
   if (strb) {
      _mesa_init_renderbuffer(&strb->Base, name);
      strb->Base.Delete = st_renderbuffer_delete;
      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
      strb->Base.GetPointer = null_get_pointer;
      return &strb->Base;
   }
   return NULL;
}


#if 000
struct gl_renderbuffer *
st_new_renderbuffer_fb(struct pipe_region *region, GLuint width, GLuint height)
{
   struct st_renderbuffer *strb = CALLOC_STRUCT(st_renderbuffer);
   if (!strb)
      return;

   _mesa_init_renderbuffer(&strb->Base, name);
   strb->Base.Delete = st_renderbuffer_delete;
   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
   strb->Base.GetPointer = null_get_pointer;
   strb->Base.Width = width;
   strb->Base.Heigth = height;

   strb->region = region;

   return &strb->Base;
}

#else

struct gl_renderbuffer *
st_new_renderbuffer_fb(GLenum intFormat)
{
   struct st_renderbuffer *strb;

   strb = CALLOC_STRUCT(st_renderbuffer);
   if (!strb) {
      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");
      return NULL;
   }

   _mesa_init_renderbuffer(&strb->Base, 0);
   strb->Base.ClassID = 0x42; /* XXX temp */
   strb->Base.InternalFormat = intFormat;

   switch (intFormat) {
   case GL_RGB5:
   case GL_RGBA8:
      strb->Base._BaseFormat = GL_RGBA;
      break;
   case GL_DEPTH_COMPONENT16:
   case GL_DEPTH_COMPONENT32:
      strb->Base._BaseFormat = GL_DEPTH_COMPONENT;
      break;
   case GL_DEPTH24_STENCIL8_EXT:
      strb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
      break;
   default:
      _mesa_problem(NULL,
		    "Unexpected intFormat in st_new_renderbuffer");
      return NULL;
   }

   /* st-specific methods */
   strb->Base.Delete = st_renderbuffer_delete;
   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
   strb->Base.GetPointer = null_get_pointer;

   /* surface is allocate in alloc_renderbuffer_storage() */
   strb->surface = NULL;

   return &strb->Base;
}
#endif



/**
 * Called via ctx->Driver.BindFramebufferEXT().
 */
static void
st_bind_framebuffer(GLcontext *ctx, GLenum target,
                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
{

}

/**
 * Called by ctx->Driver.FramebufferRenderbuffer
 */
static void
st_framebuffer_renderbuffer(GLcontext *ctx, 
                            struct gl_framebuffer *fb,
                            GLenum attachment,
                            struct gl_renderbuffer *rb)
{
   /* XXX no need for derivation? */
   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
}


/**
 * Called by ctx->Driver.RenderTexture
 */
static void
st_render_texture(GLcontext *ctx,
                  struct gl_framebuffer *fb,
                  struct gl_renderbuffer_attachment *att)
{
   struct st_context *st = ctx->st;
   struct pipe_framebuffer_state framebuffer;
   struct pipe_surface *texsurface;

   texsurface = NULL;  /* find the mipmap level, cube face, etc */

   /*
    * XXX basically like this... set the current color (or depth)
    * drawing surface to be the given texture renderbuffer.
    */
   memset(&framebuffer, 0, sizeof(framebuffer));
   framebuffer.num_cbufs = 1;
   framebuffer.cbufs[0] = texsurface;

   if (memcmp(&framebuffer, &st->state.framebuffer, sizeof(framebuffer)) != 0) {
      st->state.framebuffer = framebuffer;
      st->pipe->set_framebuffer_state( st->pipe, &framebuffer );
   }
}


/**
 * Called via ctx->Driver.FinishRenderTexture.
 */
static void
st_finish_render_texture(GLcontext *ctx,
                         struct gl_renderbuffer_attachment *att)
{
   /* restore drawing to normal framebuffer. may be a no-op */
}



void st_init_fbo_functions(struct dd_function_table *functions)
{
   functions->NewFramebuffer = st_new_framebuffer;
   functions->NewRenderbuffer = st_new_renderbuffer;
   functions->BindFramebuffer = st_bind_framebuffer;
   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;
   functions->RenderTexture = st_render_texture;
   functions->FinishRenderTexture = st_finish_render_texture;
   /* no longer needed by core Mesa, drivers handle resizes...
   functions->ResizeBuffers = st_resize_buffers;
   */
}