st_cb_fbo.c revision adfbba476db1fc55006efb748656ebb1a481d143 
1/**************************************************************************
2 *
3 * Copyright 2007 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/**
30 * Framebuffer/renderbuffer functions.
31 *
32 * \author Brian Paul
33 */
34
35
36#include "main/imports.h"
37#include "main/context.h"
38#include "main/fbobject.h"
39#include "main/framebuffer.h"
40#include "main/renderbuffer.h"
41
42#include "pipe/p_context.h"
43#include "pipe/p_defines.h"
44#include "pipe/p_inlines.h"
45#include "pipe/p_screen.h"
46#include "st_context.h"
47#include "st_cb_fbo.h"
48#include "st_cb_texture.h"
49#include "st_format.h"
50#include "st_public.h"
51#include "st_texture.h"
52
53
54
55/**
56 * Compute the renderbuffer's Red/Green/EtcBit fields from the pipe format.
57 */
58static int
59init_renderbuffer_bits(struct st_renderbuffer *strb,
60                       enum pipe_format pipeFormat)
61{
62   struct pipe_format_info info;
63
64   if (!st_get_format_info( pipeFormat, &info )) {
65      assert( 0 );
66   }
67
68   strb->Base._ActualFormat = info.base_format;
69   strb->Base.RedBits = info.red_bits;
70   strb->Base.GreenBits = info.green_bits;
71   strb->Base.BlueBits = info.blue_bits;
72   strb->Base.AlphaBits = info.alpha_bits;
73   strb->Base.DepthBits = info.depth_bits;
74   strb->Base.StencilBits = info.stencil_bits;
75   strb->Base.DataType = st_format_datatype(pipeFormat);
76
77   return info.size;
78}
79
80/**
81 * gl_renderbuffer::AllocStorage()
82 * This is called to allocate the original drawing surface, and
83 * during window resize.
84 */
85static GLboolean
86st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
87                              GLenum internalFormat,
88                              GLuint width, GLuint height)
89{
90   struct pipe_context *pipe = ctx->st->pipe;
91   struct st_renderbuffer *strb = st_renderbuffer(rb);
92   struct pipe_texture template;
93   unsigned surface_usage;
94
95   /* Free the old surface and texture
96    */
97   pipe_surface_reference( &strb->surface, NULL );
98   pipe_texture_reference( &strb->texture, NULL );
99
100
101   memset(&template, 0, sizeof(template));
102
103   if (strb->format != PIPE_FORMAT_NONE) {
104      template.format = strb->format;
105   }
106   else {
107      template.format = st_choose_renderbuffer_format(pipe, internalFormat);
108   }
109
110   strb->Base.Width  = width;
111   strb->Base.Height = height;
112   init_renderbuffer_bits(strb, template.format);
113
114   template.target = PIPE_TEXTURE_2D;
115   template.compressed = 0;
116   pf_get_block(template.format, &template.block);
117   template.width[0] = width;
118   template.height[0] = height;
119   template.depth[0] = 1;
120   template.last_level = 0;
121   template.nr_samples = rb->Samples;
122
123   if (pf_is_depth_stencil(template.format)) {
124      template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
125   }
126   else {
127      template.tex_usage = (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
128                            PIPE_TEXTURE_USAGE_RENDER_TARGET);
129   }
130
131
132   /* Probably need dedicated flags for surface usage too:
133    */
134   surface_usage = (PIPE_BUFFER_USAGE_GPU_READ |
135                    PIPE_BUFFER_USAGE_GPU_WRITE);
136#if 0
137                    PIPE_BUFFER_USAGE_CPU_READ |
138                    PIPE_BUFFER_USAGE_CPU_WRITE);
139#endif
140
141   strb->texture = pipe->screen->texture_create( pipe->screen,
142                                                 &template );
143
144   /* Special path for accum buffers.
145    *
146    * Try a different surface format.  Since accum buffers are s/w
147    * only for now, the surface pixel format doesn't really matter,
148    * only that the buffer is large enough.
149    */
150   if (!strb->texture && template.format == DEFAULT_ACCUM_PIPE_FORMAT)
151   {
152      /* Actually, just setting this usage value should be sufficient
153       * to tell the driver to go ahead and allocate the buffer, even
154       * if HW doesn't support the format.
155       */
156      template.tex_usage = 0;
157      surface_usage = (PIPE_BUFFER_USAGE_CPU_READ |
158                       PIPE_BUFFER_USAGE_CPU_WRITE);
159
160      strb->texture = pipe->screen->texture_create( pipe->screen,
161                                                    &template );
162
163   }
164
165   if (!strb->texture)
166      return FALSE;
167
168   strb->surface = pipe->screen->get_tex_surface( pipe->screen,
169                                                  strb->texture,
170                                                  0, 0, 0,
171                                                  surface_usage );
172
173   assert(strb->surface->texture);
174   assert(strb->surface->buffer);
175   assert(strb->surface->format);
176   assert(strb->surface->block.size);
177   assert(strb->surface->block.width);
178   assert(strb->surface->block.height);
179   assert(strb->surface->width == width);
180   assert(strb->surface->height == height);
181   assert(strb->surface->stride);
182
183
184   return strb->surface != NULL;
185}
186
187
188/**
189 * gl_renderbuffer::Delete()
190 */
191static void
192st_renderbuffer_delete(struct gl_renderbuffer *rb)
193{
194   struct st_renderbuffer *strb = st_renderbuffer(rb);
195   ASSERT(strb);
196   pipe_surface_reference(&strb->surface, NULL);
197   pipe_texture_reference(&strb->texture, NULL);
198   free(strb);
199}
200
201
202/**
203 * gl_renderbuffer::GetPointer()
204 */
205static void *
206null_get_pointer(GLcontext * ctx, struct gl_renderbuffer *rb,
207                 GLint x, GLint y)
208{
209   /* By returning NULL we force all software rendering to go through
210    * the span routines.
211    */
212#if 0
213   assert(0);  /* Should never get called with softpipe */
214#endif
215   return NULL;
216}
217
218
219/**
220 * Called via ctx->Driver.NewFramebuffer()
221 */
222static struct gl_framebuffer *
223st_new_framebuffer(GLcontext *ctx, GLuint name)
224{
225   /* XXX not sure we need to subclass gl_framebuffer for pipe */
226   return _mesa_new_framebuffer(ctx, name);
227}
228
229
230/**
231 * Called via ctx->Driver.NewRenderbuffer()
232 */
233static struct gl_renderbuffer *
234st_new_renderbuffer(GLcontext *ctx, GLuint name)
235{
236   struct st_renderbuffer *strb = CALLOC_STRUCT(st_renderbuffer);
237   if (strb) {
238      _mesa_init_renderbuffer(&strb->Base, name);
239      strb->Base.Delete = st_renderbuffer_delete;
240      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
241      strb->Base.GetPointer = null_get_pointer;
242      strb->format = PIPE_FORMAT_NONE;
243      return &strb->Base;
244   }
245   return NULL;
246}
247
248
249/**
250 * Allocate a renderbuffer for a an on-screen window (not a user-created
251 * renderbuffer).  The window system code determines the format.
252 */
253struct gl_renderbuffer *
254st_new_renderbuffer_fb(enum pipe_format format, int samples)
255{
256   struct st_renderbuffer *strb;
257
258   strb = CALLOC_STRUCT(st_renderbuffer);
259   if (!strb) {
260      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");
261      return NULL;
262   }
263
264   _mesa_init_renderbuffer(&strb->Base, 0);
265   strb->Base.ClassID = 0x4242; /* just a unique value */
266   strb->Base.Samples = samples;
267   strb->format = format;
268
269   switch (format) {
270   case PIPE_FORMAT_A8R8G8B8_UNORM:
271   case PIPE_FORMAT_B8G8R8A8_UNORM:
272   case PIPE_FORMAT_X8R8G8B8_UNORM:
273   case PIPE_FORMAT_B8G8R8X8_UNORM:
274   case PIPE_FORMAT_A1R5G5B5_UNORM:
275   case PIPE_FORMAT_A4R4G4B4_UNORM:
276   case PIPE_FORMAT_R5G6B5_UNORM:
277      strb->Base.InternalFormat = GL_RGBA;
278      strb->Base._BaseFormat = GL_RGBA;
279      break;
280   case PIPE_FORMAT_Z16_UNORM:
281      strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;
282      strb->Base._BaseFormat = GL_DEPTH_COMPONENT;
283      break;
284   case PIPE_FORMAT_Z32_UNORM:
285      strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
286      strb->Base._BaseFormat = GL_DEPTH_COMPONENT;
287      break;
288   case PIPE_FORMAT_S8Z24_UNORM:
289   case PIPE_FORMAT_Z24S8_UNORM:
290   case PIPE_FORMAT_X8Z24_UNORM:
291   case PIPE_FORMAT_Z24X8_UNORM:
292      strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
293      strb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
294      break;
295   case PIPE_FORMAT_S8_UNORM:
296      strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
297      strb->Base._BaseFormat = GL_STENCIL_INDEX;
298      break;
299   case DEFAULT_ACCUM_PIPE_FORMAT: /*PIPE_FORMAT_R16G16B16A16_SNORM*/
300      strb->Base.InternalFormat = GL_RGBA16;
301      strb->Base._BaseFormat = GL_RGBA;
302      break;
303   default:
304      _mesa_problem(NULL,
305		    "Unexpected format in st_new_renderbuffer_fb");
306      return NULL;
307   }
308
309   /* st-specific methods */
310   strb->Base.Delete = st_renderbuffer_delete;
311   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
312   strb->Base.GetPointer = null_get_pointer;
313
314   /* surface is allocated in st_renderbuffer_alloc_storage() */
315   strb->surface = NULL;
316
317   return &strb->Base;
318}
319
320
321
322
323/**
324 * Called via ctx->Driver.BindFramebufferEXT().
325 */
326static void
327st_bind_framebuffer(GLcontext *ctx, GLenum target,
328                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
329{
330
331}
332
333/**
334 * Called by ctx->Driver.FramebufferRenderbuffer
335 */
336static void
337st_framebuffer_renderbuffer(GLcontext *ctx,
338                            struct gl_framebuffer *fb,
339                            GLenum attachment,
340                            struct gl_renderbuffer *rb)
341{
342   /* XXX no need for derivation? */
343   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
344}
345
346
347/**
348 * Called by ctx->Driver.RenderTexture
349 */
350static void
351st_render_texture(GLcontext *ctx,
352                  struct gl_framebuffer *fb,
353                  struct gl_renderbuffer_attachment *att)
354{
355   struct st_renderbuffer *strb;
356   struct gl_renderbuffer *rb;
357   struct pipe_texture *pt = st_get_texobj_texture(att->Texture);
358   struct st_texture_object *stObj;
359   const struct gl_texture_image *texImage =
360      att->Texture->Image[att->CubeMapFace][att->TextureLevel];
361
362   if (!pt)
363      return;
364
365   assert(!att->Renderbuffer);
366
367   /* create new renderbuffer which wraps the texture image */
368   rb = st_new_renderbuffer(ctx, 0);
369   if (!rb) {
370      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()");
371      return;
372   }
373
374   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);
375   assert(rb->RefCount == 1);
376   rb->AllocStorage = NULL; /* should not get called */
377   strb = st_renderbuffer(rb);
378
379   /* get the texture for the texture object */
380   stObj = st_texture_object(att->Texture);
381
382   /* point renderbuffer at texobject */
383   strb->rtt = stObj;
384   strb->rtt_level = att->TextureLevel;
385   strb->rtt_face = att->CubeMapFace;
386   strb->rtt_slice = att->Zoffset;
387
388   rb->Width = texImage->Width2;
389   rb->Height = texImage->Height2;
390   /*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/
391
392   /*printf("***** pipe texture %d x %d\n", pt->width[0], pt->height[0]);*/
393
394   pipe_texture_reference( &strb->texture, pt );
395
396   pipe_surface_reference(&strb->surface, NULL);
397
398   /* the new surface will be created during framebuffer validation */
399
400   init_renderbuffer_bits(strb, pt->format);
401
402   /*
403   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",
404          att->Texture, pt, strb->surface, rb->Width, rb->Height);
405   */
406
407   /* Invalidate buffer state so that the pipe's framebuffer state
408    * gets updated.
409    * That's where the new renderbuffer (which we just created) gets
410    * passed to the pipe as a (color/depth) render target.
411    */
412   st_invalidate_state(ctx, _NEW_BUFFERS);
413}
414
415
416/**
417 * Called via ctx->Driver.FinishRenderTexture.
418 */
419static void
420st_finish_render_texture(GLcontext *ctx,
421                         struct gl_renderbuffer_attachment *att)
422{
423   struct pipe_screen *screen = ctx->st->pipe->screen;
424   struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer);
425
426   if (!strb)
427      return;
428
429   st_flush( ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL );
430
431   if (strb->surface)
432      screen->tex_surface_release( screen, &strb->surface );
433
434   strb->rtt = NULL;
435
436   /*
437   printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);
438   */
439
440   _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
441
442   /* restore previous framebuffer state */
443   st_invalidate_state(ctx, _NEW_BUFFERS);
444}
445
446
447
448void st_init_fbo_functions(struct dd_function_table *functions)
449{
450   functions->NewFramebuffer = st_new_framebuffer;
451   functions->NewRenderbuffer = st_new_renderbuffer;
452   functions->BindFramebuffer = st_bind_framebuffer;
453   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;
454   functions->RenderTexture = st_render_texture;
455   functions->FinishRenderTexture = st_finish_render_texture;
456   /* no longer needed by core Mesa, drivers handle resizes...
457   functions->ResizeBuffers = st_resize_buffers;
458   */
459}
460