#include "main/context.h"
#include "main/fbobject.h"
#include "main/framebuffer.h"
+#include "main/macros.h"
#include "main/renderbuffer.h"
#include "pipe/p_context.h"
#include "pipe/p_screen.h"
#include "st_context.h"
#include "st_cb_fbo.h"
-#include "st_cb_texture.h"
#include "st_format.h"
#include "st_public.h"
#include "st_texture.h"
+#include "st_manager.h"
#include "util/u_format.h"
-#include "util/u_rect.h"
+#include "util/u_inlines.h"
-/**
- * Compute the renderbuffer's Red/Green/EtcBit fields from the pipe format.
- */
-static int
-init_renderbuffer_bits(struct st_renderbuffer *strb,
- enum pipe_format pipeFormat)
-{
- struct pipe_format_info info;
-
- if (!st_get_format_info( pipeFormat, &info )) {
- assert( 0 );
- }
-
- strb->Base.Format = info.mesa_format;
- strb->Base.DataType = st_format_datatype(pipeFormat);
-
- return info.size;
-}
-
/**
* gl_renderbuffer::AllocStorage()
* This is called to allocate the original drawing surface, and
GLenum internalFormat,
GLuint width, GLuint height)
{
- struct pipe_context *pipe = ctx->st->pipe;
+ struct pipe_screen *screen = ctx->st->pipe->screen;
struct st_renderbuffer *strb = st_renderbuffer(rb);
enum pipe_format format;
if (strb->format != PIPE_FORMAT_NONE)
format = strb->format;
else
- format = st_choose_renderbuffer_format(pipe->screen, internalFormat);
+ format = st_choose_renderbuffer_format(screen, internalFormat);
/* init renderbuffer fields */
strb->Base.Width = width;
strb->Base.Height = height;
- init_renderbuffer_bits(strb, format);
+ strb->Base.Format = st_pipe_format_to_mesa_format(format);
+ strb->Base.DataType = st_format_datatype(format);
strb->defined = GL_FALSE; /* undefined contents now */
- if(strb->software) {
+ if (strb->software) {
size_t size;
- _mesa_free(strb->data);
+ free(strb->data);
assert(strb->format != PIPE_FORMAT_NONE);
strb->stride = util_format_get_stride(strb->format, width);
size = util_format_get_2d_size(strb->format, strb->stride, height);
- strb->data = _mesa_malloc(size);
+ strb->data = malloc(size);
return strb->data != NULL;
}
*/
pipe_surface_reference( &strb->surface, NULL );
pipe_texture_reference( &strb->texture, NULL );
+ pipe_sampler_view_reference(&strb->sampler_view, NULL);
/* Setup new texture template.
*/
PIPE_BUFFER_USAGE_CPU_WRITE);
#endif
- strb->texture = pipe->screen->texture_create( pipe->screen,
- &template );
+ strb->texture = screen->texture_create(screen, &template);
if (!strb->texture)
return FALSE;
- strb->surface = pipe->screen->get_tex_surface( pipe->screen,
- strb->texture,
- 0, 0, 0,
- surface_usage );
+ strb->surface = screen->get_tex_surface(screen,
+ strb->texture,
+ 0, 0, 0,
+ surface_usage);
if (strb->surface) {
assert(strb->surface->texture);
assert(strb->surface->format);
ASSERT(strb);
pipe_surface_reference(&strb->surface, NULL);
pipe_texture_reference(&strb->texture, NULL);
- _mesa_free(strb->data);
- _mesa_free(strb);
+ pipe_sampler_view_reference(&strb->sampler_view, NULL);
+ free(strb->data);
+ free(strb);
}
_mesa_init_renderbuffer(&strb->Base, 0);
strb->Base.ClassID = 0x4242; /* just a unique value */
strb->Base.NumSamples = samples;
+ strb->Base.Format = st_pipe_format_to_mesa_format(format);
+ strb->Base.DataType = st_format_datatype(format);
strb->format = format;
- init_renderbuffer_bits(strb, format);
strb->software = sw;
switch (format) {
- case PIPE_FORMAT_A8R8G8B8_UNORM:
case PIPE_FORMAT_B8G8R8A8_UNORM:
- case PIPE_FORMAT_X8R8G8B8_UNORM:
+ case PIPE_FORMAT_A8R8G8B8_UNORM:
case PIPE_FORMAT_B8G8R8X8_UNORM:
- case PIPE_FORMAT_A1R5G5B5_UNORM:
- case PIPE_FORMAT_A4R4G4B4_UNORM:
- case PIPE_FORMAT_R5G6B5_UNORM:
+ case PIPE_FORMAT_X8R8G8B8_UNORM:
+ case PIPE_FORMAT_B5G5R5A1_UNORM:
+ case PIPE_FORMAT_B4G4R4A4_UNORM:
+ case PIPE_FORMAT_B5G6R5_UNORM:
strb->Base.InternalFormat = GL_RGBA;
break;
case PIPE_FORMAT_Z16_UNORM:
case PIPE_FORMAT_Z32_UNORM:
strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
break;
- case PIPE_FORMAT_S8Z24_UNORM:
- case PIPE_FORMAT_Z24S8_UNORM:
- case PIPE_FORMAT_X8Z24_UNORM:
+ case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
+ case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
case PIPE_FORMAT_Z24X8_UNORM:
+ case PIPE_FORMAT_X8Z24_UNORM:
strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
break;
- case PIPE_FORMAT_S8_UNORM:
+ case PIPE_FORMAT_S8_USCALED:
strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
break;
case PIPE_FORMAT_R16G16B16A16_SNORM:
default:
_mesa_problem(NULL,
"Unexpected format in st_new_renderbuffer_fb");
- _mesa_free(strb);
+ free(strb);
return NULL;
}
struct gl_renderbuffer *rb;
struct pipe_texture *pt = st_get_texobj_texture(att->Texture);
struct st_texture_object *stObj;
- const struct gl_texture_image *texImage =
- att->Texture->Image[att->CubeMapFace][att->TextureLevel];
+ const struct gl_texture_image *texImage;
+ GLint pt_level;
+ /* When would this fail? Perhaps assert? */
if (!pt)
return;
+ /* The first gallium texture level = Mesa BaseLevel */
+ pt_level = MAX2(0, (GLint) att->TextureLevel - att->Texture->BaseLevel);
+ texImage = att->Texture->Image[att->CubeMapFace][pt_level];
+
/* create new renderbuffer which wraps the texture image */
rb = st_new_renderbuffer(ctx, 0);
if (!rb) {
/* point renderbuffer at texobject */
strb->rtt = stObj;
- strb->rtt_level = att->TextureLevel;
+ strb->rtt_level = pt_level;
strb->rtt_face = att->CubeMapFace;
strb->rtt_slice = att->Zoffset;
pipe_surface_reference(&strb->surface, NULL);
+ pipe_sampler_view_reference(&strb->sampler_view, st_get_stobj_sampler_view(stObj));
+
+ assert(strb->rtt_level <= strb->texture->last_level);
+
/* new surface for rendering into the texture */
strb->surface = screen->get_tex_surface(screen,
strb->texture,
PIPE_BUFFER_USAGE_GPU_READ |
PIPE_BUFFER_USAGE_GPU_WRITE);
- init_renderbuffer_bits(strb, pt->format);
+ strb->format = pt->format;
+
+ strb->Base.Format = st_pipe_format_to_mesa_format(pt->format);
+ strb->Base.DataType = st_format_datatype(pt->format);
/*
printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p %d x %d\n",
st_flush( ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL );
- if (strb->surface)
- pipe_surface_reference( &strb->surface, NULL );
-
strb->rtt = NULL;
/*
printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);
*/
- _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
-
/* restore previous framebuffer state */
st_invalidate_state(ctx, _NEW_BUFFERS);
}
(void) st_get_framebuffer_surface(stfb, backIndex, &surf_back);
if (surf_front && surf_back) {
- if (st->pipe->surface_copy) {
- st->pipe->surface_copy(st->pipe,
- surf_front, 0, 0, /* dest */
- surf_back, 0, 0, /* src */
- fb->Width, fb->Height);
- } else {
- util_surface_copy(st->pipe, FALSE,
- surf_front, 0, 0,
- surf_back, 0, 0,
- fb->Width, fb->Height);
- }
+ st->pipe->surface_copy(st->pipe,
+ surf_front, 0, 0, /* dest */
+ surf_back, 0, 0, /* src */
+ fb->Width, fb->Height);
}
}
static void
st_DrawBuffers(GLcontext *ctx, GLsizei count, const GLenum *buffers)
{
+ GLframebuffer *fb = ctx->DrawBuffer;
+ GLuint i;
+
(void) count;
(void) buffers;
+
+ /* add the renderbuffers on demand */
+ for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
+ gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i];
+ st_manager_add_color_renderbuffer(ctx->st, fb, idx);
+ }
+
check_create_front_buffers(ctx, ctx->DrawBuffer);
}
static void
st_ReadBuffer(GLcontext *ctx, GLenum buffer)
{
+ GLframebuffer *fb = ctx->ReadBuffer;
+
(void) buffer;
- check_create_front_buffers(ctx, ctx->ReadBuffer);
+
+ /* add the renderbuffer on demand */
+ st_manager_add_color_renderbuffer(ctx->st, fb, fb->_ColorReadBufferIndex);
+ check_create_front_buffers(ctx, fb);
}
functions->DrawBuffers = st_DrawBuffers;
functions->ReadBuffer = st_ReadBuffer;
}
+
+struct pipe_sampler_view *
+st_renderbuffer_get_sampler_view(struct st_renderbuffer *rb,
+ struct pipe_context *pipe)
+{
+ if (!rb->sampler_view) {
+ rb->sampler_view = st_sampler_view_from_texture(pipe, rb->texture);
+ }
+
+ return rb->sampler_view;
+}