From 107206bbbe6f110e5d280ecb306bec0f764c834d Mon Sep 17 00:00:00 2001
From: Brian <brian@i915.localnet.net>
Date: Thu, 2 Aug 2007 10:30:32 -0600
Subject: New header file.

---
 src/mesa/state_tracker/st_cb_clear.h | 37 ++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 src/mesa/state_tracker/st_cb_clear.h

(limited to 'src/mesa/state_tracker/st_cb_clear.h')

diff --git a/src/mesa/state_tracker/st_cb_clear.h b/src/mesa/state_tracker/st_cb_clear.h
new file mode 100644
index 0000000000..32086971b5
--- /dev/null
+++ b/src/mesa/state_tracker/st_cb_clear.h
@@ -0,0 +1,37 @@
+/**************************************************************************
+ * 
+ * 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.
+ * 
+ **************************************************************************/
+
+
+#ifndef ST_CB_CLEAR_H
+#define ST_CB_CLEAR_H
+
+extern void st_init_cb_clear( struct st_context *st );
+
+extern void st_destroy_cb_clear( struct st_context *st );
+
+#endif /* ST_CB_CLEAR_H */
+
-- 
cgit v1.2.3


From 6da9234fd437f97267e7831f034c78b31156d939 Mon Sep 17 00:00:00 2001
From: Brian <brian.paul@tungstengraphics.com>
Date: Mon, 6 Aug 2007 20:53:28 +0100
Subject: New st_init_*_functions() to initialize the driver functions table.

We need to do these initializations before initializing the Mesa context
because context init involves creating texture/program/etc objects.
---
 src/mesa/state_tracker/st_cb_bufferobjects.c | 18 ++++++++---------
 src/mesa/state_tracker/st_cb_bufferobjects.h | 11 +++++------
 src/mesa/state_tracker/st_cb_clear.c         | 10 +---------
 src/mesa/state_tracker/st_cb_clear.h         |  5 +++--
 src/mesa/state_tracker/st_cb_drawpixels.c    |  8 +-------
 src/mesa/state_tracker/st_cb_drawpixels.h    |  4 +---
 src/mesa/state_tracker/st_cb_fbo.c           |  9 +--------
 src/mesa/state_tracker/st_cb_fbo.h           |  5 ++---
 src/mesa/state_tracker/st_cb_program.c       | 29 ++++++++++------------------
 src/mesa/state_tracker/st_cb_texture.c       | 12 +++---------
 src/mesa/state_tracker/st_cb_texture.h       |  6 +-----
 src/mesa/state_tracker/st_context.c          | 18 +++++++++++++++++
 src/mesa/state_tracker/st_context.h          |  7 +++----
 src/mesa/state_tracker/st_program.h          |  5 +++--
 14 files changed, 60 insertions(+), 87 deletions(-)

(limited to 'src/mesa/state_tracker/st_cb_clear.h')

diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.c b/src/mesa/state_tracker/st_cb_bufferobjects.c
index a667b3e775..d020eb2007 100644
--- a/src/mesa/state_tracker/st_cb_bufferobjects.c
+++ b/src/mesa/state_tracker/st_cb_bufferobjects.c
@@ -192,15 +192,13 @@ st_bufferobj_unmap(GLcontext *ctx,
 
 
 void
-st_init_cb_bufferobjects( struct st_context *st )
+st_init_bufferobject_functions(struct dd_function_table *functions)
 {
-   GLcontext *ctx = st->ctx;
-
-   ctx->Driver.NewBufferObject = st_bufferobj_alloc;
-   ctx->Driver.DeleteBuffer = st_bufferobj_free;
-   ctx->Driver.BufferData = st_bufferobj_data;
-   ctx->Driver.BufferSubData = st_bufferobj_subdata;
-   ctx->Driver.GetBufferSubData = st_bufferobj_get_subdata;
-   ctx->Driver.MapBuffer = st_bufferobj_map;
-   ctx->Driver.UnmapBuffer = st_bufferobj_unmap;
+   functions->NewBufferObject = st_bufferobj_alloc;
+   functions->DeleteBuffer = st_bufferobj_free;
+   functions->BufferData = st_bufferobj_data;
+   functions->BufferSubData = st_bufferobj_subdata;
+   functions->GetBufferSubData = st_bufferobj_get_subdata;
+   functions->MapBuffer = st_bufferobj_map;
+   functions->UnmapBuffer = st_bufferobj_unmap;
 }
diff --git a/src/mesa/state_tracker/st_cb_bufferobjects.h b/src/mesa/state_tracker/st_cb_bufferobjects.h
index 2787411c5f..2090a743e0 100644
--- a/src/mesa/state_tracker/st_cb_bufferobjects.h
+++ b/src/mesa/state_tracker/st_cb_bufferobjects.h
@@ -1,4 +1,4 @@
- /**************************************************************************
+/**************************************************************************
  * 
  * Copyright 2005 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
@@ -43,11 +43,6 @@ struct st_buffer_object
 };
 
 
-/* Hook the bufferobject implementation into mesa: 
- */
-void st_init_cb_bufferobjects( struct st_context *st );
-
-
 /* Are the obj->Name tests necessary?  Unfortunately yes, mesa
  * allocates a couple of gl_buffer_object structs statically, and the
  * Name == 0 test is the only way to identify them and avoid casting
@@ -63,4 +58,8 @@ st_buffer_object(struct gl_buffer_object *obj)
 }
 
 
+extern void
+st_init_bufferobject_functions(struct dd_function_table *functions);
+
+
 #endif
diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index c907b0ed22..0ec7784d84 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -418,15 +418,7 @@ static void st_clear(GLcontext *ctx, GLbitfield mask)
 }
 
 
-void st_init_cb_clear( struct st_context *st )
+void st_init_clear_functions(struct dd_function_table *functions)
 {
-   struct dd_function_table *functions = &st->ctx->Driver;
-
    functions->Clear = st_clear;
 }
-
-
-void st_destroy_cb_clear( struct st_context *st )
-{
-}
-
diff --git a/src/mesa/state_tracker/st_cb_clear.h b/src/mesa/state_tracker/st_cb_clear.h
index 32086971b5..c715e56bd5 100644
--- a/src/mesa/state_tracker/st_cb_clear.h
+++ b/src/mesa/state_tracker/st_cb_clear.h
@@ -29,9 +29,10 @@
 #ifndef ST_CB_CLEAR_H
 #define ST_CB_CLEAR_H
 
-extern void st_init_cb_clear( struct st_context *st );
 
-extern void st_destroy_cb_clear( struct st_context *st );
+extern void
+st_init_clear_functions(struct dd_function_table *functions);
+
 
 #endif /* ST_CB_CLEAR_H */
 
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index 13f5c5f3c7..92a4e305d1 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -262,14 +262,8 @@ st_drawpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
 }
 
 
-void st_init_cb_drawpixels( struct st_context *st )
+void st_init_drawpixels_functions(struct dd_function_table *functions)
 {
-   struct dd_function_table *functions = &st->ctx->Driver;
-
    functions->DrawPixels = st_drawpixels;
 }
 
-
-void st_destroy_cb_drawpixels( struct st_context *st )
-{
-}
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.h b/src/mesa/state_tracker/st_cb_drawpixels.h
index 8c36aaa931..71ba487020 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.h
+++ b/src/mesa/state_tracker/st_cb_drawpixels.h
@@ -30,9 +30,7 @@
 #define ST_CB_DRAWPIXELS_H
 
 
-void st_init_cb_drawpixels( struct st_context *st );
-
-void st_destroy_cb_drawpixels( struct st_context *st );
+extern void st_init_drawpixels_functions(struct dd_function_table *functions);
 
 
 #endif /* ST_CB_DRAWPIXELS_H */
diff --git a/src/mesa/state_tracker/st_cb_fbo.c b/src/mesa/state_tracker/st_cb_fbo.c
index 6b9ae88dbe..d0205fd635 100644
--- a/src/mesa/state_tracker/st_cb_fbo.c
+++ b/src/mesa/state_tracker/st_cb_fbo.c
@@ -322,10 +322,8 @@ st_finish_render_texture(GLcontext *ctx,
 
 
 
-void st_init_cb_fbo( struct st_context *st )
+void st_init_fbo_functions(struct dd_function_table *functions)
 {
-   struct dd_function_table *functions = &st->ctx->Driver;
-
    functions->NewFramebuffer = st_new_framebuffer;
    functions->NewRenderbuffer = st_new_renderbuffer;
    functions->BindFramebuffer = st_bind_framebuffer;
@@ -336,8 +334,3 @@ void st_init_cb_fbo( struct st_context *st )
    functions->ResizeBuffers = st_resize_buffers;
    */
 }
-
-
-void st_destroy_cb_fbo( struct st_context *st )
-{
-}
diff --git a/src/mesa/state_tracker/st_cb_fbo.h b/src/mesa/state_tracker/st_cb_fbo.h
index f4fa66df59..6142434ec6 100644
--- a/src/mesa/state_tracker/st_cb_fbo.h
+++ b/src/mesa/state_tracker/st_cb_fbo.h
@@ -30,9 +30,8 @@
 #define ST_CB_FBO_H
 
 
-extern void st_init_cb_fbo( struct st_context *st );
-
-extern void st_destroy_cb_fbo( struct st_context *st );
+extern void
+st_init_fbo_functions(struct dd_function_table *functions);
 
 
 #endif /* ST_CB_FBO_H */
diff --git a/src/mesa/state_tracker/st_cb_program.c b/src/mesa/state_tracker/st_cb_program.c
index 6da2aeb2f2..ed47c12066 100644
--- a/src/mesa/state_tracker/st_cb_program.c
+++ b/src/mesa/state_tracker/st_cb_program.c
@@ -32,7 +32,6 @@
 
 #include "st_context.h"
 #include "st_program.h"    
-
 #include "glheader.h"
 #include "macros.h"
 #include "enums.h"
@@ -44,6 +43,11 @@
 #include "pipe/tgsi/mesa/tgsi_mesa.h"
 
 
+/* Counter to track program string changes:
+ */
+static GLuint program_id = 0;
+
+
 static void st_bind_program( GLcontext *ctx,
 			     GLenum target, 
 			     struct gl_program *prog )
@@ -70,7 +74,7 @@ static struct gl_program *st_new_program( GLcontext *ctx,
    case GL_VERTEX_PROGRAM_ARB: {
       struct st_vertex_program *prog = CALLOC_STRUCT(st_vertex_program);
 
-      prog->id = st->program_id++;
+      prog->id = program_id++;
       prog->dirty = 1;
 
       return _mesa_init_vertex_program( ctx, 
@@ -84,7 +88,7 @@ static struct gl_program *st_new_program( GLcontext *ctx,
    {
       struct st_fragment_program *prog = CALLOC_STRUCT(st_fragment_program);
 
-      prog->id = st->program_id++;
+      prog->id = program_id++;
       prog->dirty = 1;
 
       return _mesa_init_fragment_program( ctx, 
@@ -124,7 +128,7 @@ static void st_program_string_notify( GLcontext *ctx,
       if (prog == &ctx->FragmentProgram._Current->Base)
 	 st->dirty.st |= ST_NEW_FRAGMENT_PROGRAM;
 
-      p->id = st->program_id++;      
+      p->id = program_id++;      
       p->param_state = p->Base.Base.Parameters->StateFlags;
    }
    else if (target == GL_VERTEX_PROGRAM_ARB) {
@@ -133,7 +137,7 @@ static void st_program_string_notify( GLcontext *ctx,
       if (prog == &ctx->VertexProgram._Current->Base)
 	 st->dirty.st |= ST_NEW_VERTEX_PROGRAM;
 
-      p->id = st->program_id++;      
+      p->id = program_id++;      
       p->param_state = p->Base.Base.Parameters->StateFlags;
 
       /* Also tell tnl about it:
@@ -144,15 +148,8 @@ static void st_program_string_notify( GLcontext *ctx,
 
 
 
-void st_init_cb_program( struct st_context *st )
+void st_init_program_functions(struct dd_function_table *functions)
 {
-   struct dd_function_table *functions = &st->ctx->Driver;
-
-   /* Need these flags:
-    */
-   st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
-   st->ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
-
 #if 0
    assert(functions->ProgramStringNotify == _tnl_program_string); 
 #endif
@@ -162,9 +159,3 @@ void st_init_cb_program( struct st_context *st )
    functions->IsProgramNative = st_is_program_native;
    functions->ProgramStringNotify = st_program_string_notify;
 }
-
-
-void st_destroy_cb_program( struct st_context *st )
-{
-}
-
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index a0245b553f..5872ae3e74 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -1241,7 +1241,7 @@ do_copy_texsubimage(GLcontext *ctx,
       get_teximage_source(ctx, internalFormat);
 
    if (!stImage->mt || !src) {
-      DBG("%s fail %p %p\n", __FUNCTION__, stImage->mt, src);
+      DBG("%s fail %p %p\n", __FUNCTION__, (void *) stImage->mt, (void *) src);
       return GL_FALSE;
    }
 
@@ -1726,10 +1726,9 @@ st_tex_unmap_images(struct pipe_context *pipe,
 
 
 
-void st_init_cb_texture( struct st_context *st )
+void
+st_init_texture_functions(struct dd_function_table *functions)
 {
-   struct dd_function_table *functions = &st->ctx->Driver;
-
    functions->ChooseTextureFormat = st_ChooseTextureFormat;
    functions->TexImage1D = st_TexImage1D;
    functions->TexImage2D = st_TexImage2D;
@@ -1756,8 +1755,3 @@ void st_init_cb_texture( struct st_context *st )
 
    functions->TextureMemCpy = do_memcpy;
 }
-
-
-void st_destroy_cb_texture( struct st_context *st )
-{
-}
diff --git a/src/mesa/state_tracker/st_cb_texture.h b/src/mesa/state_tracker/st_cb_texture.h
index c474d16465..c732881c39 100644
--- a/src/mesa/state_tracker/st_cb_texture.h
+++ b/src/mesa/state_tracker/st_cb_texture.h
@@ -9,11 +9,7 @@ st_finalize_mipmap_tree(GLcontext *ctx,
 
 
 extern void
-st_init_cb_texture( struct st_context *st );
-
-
-extern void
-st_destroy_cb_texture( struct st_context *st );
+st_init_texture_functions(struct dd_function_table *functions);
 
 
 #endif /* ST_CB_TEXTURE_H */
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index 2b96286770..0ea06c692d 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -28,6 +28,7 @@
 #include "imports.h"
 #include "st_public.h"
 #include "st_context.h"
+#include "st_cb_bufferobjects.h"
 #include "st_cb_clear.h"
 #include "st_cb_drawpixels.h"
 #include "st_cb_texture.h"
@@ -61,10 +62,17 @@ struct st_context *st_create_context( GLcontext *ctx,
    st_init_atoms( st );
    st_init_draw( st );
 
+   /* Need these flags:
+    */
+   st->ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
+   st->ctx->FragmentProgram._UseTexEnvProgram = GL_TRUE;
+
+#if 0
    st_init_cb_clear( st );
    st_init_cb_program( st );
    st_init_cb_drawpixels( st );
    st_init_cb_texture( st );
+#endif
 
    return st;
 }
@@ -75,11 +83,13 @@ void st_destroy_context( struct st_context *st )
    st_destroy_atoms( st );
    st_destroy_draw( st );
 
+#if 0
    st_destroy_cb_clear( st );
    st_destroy_cb_program( st );
    st_destroy_cb_drawpixels( st );
    /*st_destroy_cb_teximage( st );*/
    st_destroy_cb_texture( st );
+#endif
 
    st->pipe->destroy( st->pipe );
    FREE( st );
@@ -87,3 +97,11 @@ void st_destroy_context( struct st_context *st )
 
  
 
+void st_init_driver_functions(struct dd_function_table *functions)
+{
+   st_init_bufferobject_functions(functions);
+   st_init_clear_functions(functions);
+   st_init_drawpixels_functions(functions);
+   st_init_program_functions(functions);
+   st_init_texture_functions(functions);
+}
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index ef3cdb3b09..fe73630c75 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -97,10 +97,6 @@ struct st_context
 
    struct st_state_flags dirty;
 
-   /* Counter to track program string changes:
-    */
-   GLuint program_id;
-
    GLfloat polygon_offset_scale; /* ?? */
 };
 
@@ -113,4 +109,7 @@ static INLINE struct st_context *st_context(GLcontext *ctx)
 }
 
 
+extern void st_init_driver_functions(struct dd_function_table *functions);
+
+
 #endif
diff --git a/src/mesa/state_tracker/st_program.h b/src/mesa/state_tracker/st_program.h
index f6d5f6d76c..8dcb2ceb48 100644
--- a/src/mesa/state_tracker/st_program.h
+++ b/src/mesa/state_tracker/st_program.h
@@ -87,8 +87,9 @@ struct st_vertex_program
    GLuint param_state;
 };
 
-void st_init_cb_program( struct st_context *st );
-void st_destroy_cb_program( struct st_context *st );
+
+extern void st_init_program_functions(struct dd_function_table *functions);
+
 
 static inline struct st_fragment_program *
 st_fragment_program( struct gl_fragment_program *fp )
-- 
cgit v1.2.3


From 85e4ec6d118e340eaccd176aa622221642a2e754 Mon Sep 17 00:00:00 2001
From: Brian <brian.paul@tungstengraphics.com>
Date: Thu, 20 Mar 2008 09:13:51 -0600
Subject: gallium: use the utility pasthrough shaders

This avoids the Mesa->TGSI translation step.
---
 src/mesa/state_tracker/st_cb_clear.c | 137 +++++++----------------------------
 src/mesa/state_tracker/st_cb_clear.h |   4 +
 src/mesa/state_tracker/st_context.c  |   1 +
 src/mesa/state_tracker/st_context.h  |   7 ++
 4 files changed, 39 insertions(+), 110 deletions(-)

(limited to 'src/mesa/state_tracker/st_cb_clear.h')

diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index c23938dc68..8cc02f63bb 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -49,6 +49,7 @@
 #include "pipe/p_defines.h"
 #include "pipe/p_winsys.h"
 #include "util/u_pack_color.h"
+#include "util/u_simple_shaders.h"
 
 #include "cso_cache/cso_context.h"
 
@@ -57,6 +58,20 @@
 #define TEST_DRAW_PASSTHROUGH 0
 
 
+void
+st_destroy_clear(struct st_context *st)
+{
+   if (st->clear.fs) {
+      st->pipe->delete_fs_state(st->pipe, st->clear.fs);
+      st->clear.fs = NULL;
+   }
+   if (st->clear.vs) {
+      st->pipe->delete_vs_state(st->pipe, st->clear.vs);
+      st->clear.vs = NULL;
+   }
+}
+
+
 static GLboolean
 is_depth_stencil_format(enum pipe_format pipeFormat)
 {
@@ -71,104 +86,6 @@ is_depth_stencil_format(enum pipe_format pipeFormat)
 
 
 
-/**
- * Create a simple fragment shader that just passes through the fragment color.
- */
-static struct st_fragment_program *
-make_frag_shader(struct st_context *st)
-{
-   GLcontext *ctx = st->ctx;
-   struct st_fragment_program *stfp;
-   struct gl_program *p;
-   GLuint interpMode[16];
-   GLuint i;
-
-   /* XXX temporary */
-   for (i = 0; i < 16; i++)
-      interpMode[i] = TGSI_INTERPOLATE_LINEAR;
-
-   p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
-   if (!p)
-      return NULL;
-
-   p->NumInstructions = 2;
-   p->Instructions = _mesa_alloc_instructions(2);
-   if (!p->Instructions) {
-      ctx->Driver.DeleteProgram(ctx, p);
-      return NULL;
-   }
-   _mesa_init_instructions(p->Instructions, 2);
-   /* MOV result.color, fragment.color; */
-   p->Instructions[0].Opcode = OPCODE_MOV;
-   p->Instructions[0].DstReg.File = PROGRAM_OUTPUT;
-   p->Instructions[0].DstReg.Index = FRAG_RESULT_COLR;
-   p->Instructions[0].SrcReg[0].File = PROGRAM_INPUT;
-   p->Instructions[0].SrcReg[0].Index = FRAG_ATTRIB_COL0;
-   /* END; */
-   p->Instructions[1].Opcode = OPCODE_END;
-
-   p->InputsRead = FRAG_BIT_COL0;
-   p->OutputsWritten = (1 << FRAG_RESULT_COLR);
-
-   stfp = (struct st_fragment_program *) p;
-   st_translate_fragment_program(st, stfp, NULL);
-
-   return stfp;
-}
-
-
-/**
- * Create a simple vertex shader that just passes through the
- * vertex position and color.
- */
-static struct st_vertex_program *
-make_vertex_shader(struct st_context *st)
-{
-   GLcontext *ctx = st->ctx;
-   struct st_vertex_program *stvp;
-   struct gl_program *p;
-
-   p = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
-   if (!p)
-      return NULL;
-
-   p->NumInstructions = 3;
-   p->Instructions = _mesa_alloc_instructions(3);
-   if (!p->Instructions) {
-      ctx->Driver.DeleteProgram(ctx, p);
-      return NULL;
-   }
-   _mesa_init_instructions(p->Instructions, 3);
-   /* MOV result.pos, vertex.pos; */
-   p->Instructions[0].Opcode = OPCODE_MOV;
-   p->Instructions[0].DstReg.File = PROGRAM_OUTPUT;
-   p->Instructions[0].DstReg.Index = VERT_RESULT_HPOS;
-   p->Instructions[0].SrcReg[0].File = PROGRAM_INPUT;
-   p->Instructions[0].SrcReg[0].Index = VERT_ATTRIB_POS;
-   /* MOV result.color, vertex.color; */
-   p->Instructions[1].Opcode = OPCODE_MOV;
-   p->Instructions[1].DstReg.File = PROGRAM_OUTPUT;
-   p->Instructions[1].DstReg.Index = VERT_RESULT_COL0;
-   p->Instructions[1].SrcReg[0].File = PROGRAM_INPUT;
-   p->Instructions[1].SrcReg[0].Index = VERT_ATTRIB_COLOR0;
-   /* END; */
-   p->Instructions[2].Opcode = OPCODE_END;
-
-   p->InputsRead = VERT_BIT_POS | VERT_BIT_COLOR0;
-   p->OutputsWritten = ((1 << VERT_RESULT_COL0) |
-                        (1 << VERT_RESULT_HPOS));
-
-   stvp = (struct st_vertex_program *) p;
-   st_translate_vertex_program(st, stvp, NULL);
-#if 0
-   assert(stvp->cso);
-#endif
-
-   return stvp;
-}
-
-
-
 /**
  * Draw a screen-aligned quadrilateral.
  * Coords are window coords with y=0=bottom.  These coords will be transformed
@@ -311,23 +228,23 @@ clear_with_quad(GLcontext *ctx,
    }
 
    /* fragment shader state: color pass-through program */
-   {
-      static struct st_fragment_program *stfp = NULL;
-      if (!stfp) {
-         stfp = make_frag_shader(st);
-      }
-      pipe->bind_fs_state(pipe, stfp->driver_shader);
+   if (!st->clear.fs) {
+      st->clear.fs = util_make_fragment_passthrough_shader(pipe);
    }
+   pipe->bind_fs_state(pipe, st->clear.fs);
+
 
 #if !TEST_DRAW_PASSTHROUGH
    /* vertex shader state: color/position pass-through */
-   {
-      static struct st_vertex_program *stvp = NULL;
-      if (!stvp) {
-         stvp = make_vertex_shader(st);
-      }
-      pipe->bind_vs_state(pipe, stvp->driver_shader);
+   if (!st->clear.vs) {
+      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
+                                      TGSI_SEMANTIC_COLOR };
+      const uint semantic_indexes[] = { 0, 0 };
+      st->clear.vs = util_make_vertex_passthrough_shader(pipe, 2,
+                                                         semantic_names,
+                                                         semantic_indexes);
    }
+   pipe->bind_vs_state(pipe, st->clear.vs);
 #endif
 
 #if !TEST_DRAW_PASSTHROUGH
diff --git a/src/mesa/state_tracker/st_cb_clear.h b/src/mesa/state_tracker/st_cb_clear.h
index c715e56bd5..dfa4033faa 100644
--- a/src/mesa/state_tracker/st_cb_clear.h
+++ b/src/mesa/state_tracker/st_cb_clear.h
@@ -30,6 +30,10 @@
 #define ST_CB_CLEAR_H
 
 
+extern void
+st_destroy_clear(struct st_context *st);
+
+
 extern void
 st_init_clear_functions(struct dd_function_table *functions);
 
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index e1fc885e0e..b1681be2eb 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -155,6 +155,7 @@ static void st_destroy_context_priv( struct st_context *st )
    st_destroy_draw( st );
    st_destroy_generate_mipmap(st);
    st_destroy_blit(st);
+   st_destroy_clear(st);
 
    _vbo_DestroyContext(st->ctx);
 
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index ca8307c4ba..8058086d87 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -142,12 +142,19 @@ struct st_context
       GLuint combined_prog_sn;
    } pixel_xfer;
 
+   /** for glBitmap */
    struct {
       struct st_fragment_program *program;  /**< bitmap tex/kil program */
       GLuint user_prog_sn;  /**< user fragment program serial no. */
       struct st_fragment_program *combined_prog;
    } bitmap;
 
+   /** for glClear */
+   struct {
+      void *vs;
+      void *fs;
+   } clear;
+
    struct gen_mipmap_state *gen_mipmap;
    struct blit_state *blit;
 
-- 
cgit v1.2.3


From ce5c867cbb17b2444ebc3db5c6a03cee5e2edb8a Mon Sep 17 00:00:00 2001
From: Brian Paul <brian.paul@tungstengraphics.com>
Date: Thu, 3 Apr 2008 12:54:32 -0600
Subject: gallium: streamline viewport/raster/shader state for clearing with
 quads

Move init of these items to new st_init_clear().
---
 src/mesa/state_tracker/st_cb_clear.c | 75 ++++++++++++++++++------------------
 src/mesa/state_tracker/st_cb_clear.h |  4 ++
 src/mesa/state_tracker/st_context.c  |  1 +
 src/mesa/state_tracker/st_context.h  |  2 +
 4 files changed, 45 insertions(+), 37 deletions(-)

(limited to 'src/mesa/state_tracker/st_cb_clear.h')

diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index 041b9be2cc..b5e737e0d1 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -55,6 +55,42 @@
 #include "cso_cache/cso_context.h"
 
 
+void
+st_init_clear(struct st_context *st)
+{
+   struct pipe_context *pipe = st->pipe;
+
+   /* rasterizer state: bypass clipping */
+   memset(&st->clear.raster, 0, sizeof(st->clear.raster));
+   st->clear.raster.bypass_clipping = 1;
+
+   /* viewport state: identity since we're drawing in window coords */
+   st->clear.viewport.scale[0] = 1.0;
+   st->clear.viewport.scale[1] = 1.0;
+   st->clear.viewport.scale[2] = 1.0;
+   st->clear.viewport.scale[3] = 1.0;
+   st->clear.viewport.translate[0] = 0.0;
+   st->clear.viewport.translate[1] = 0.0;
+   st->clear.viewport.translate[2] = 0.0;
+   st->clear.viewport.translate[3] = 0.0;
+
+   /* fragment shader state: color pass-through program */
+   st->clear.fs =
+      util_make_fragment_passthrough_shader(pipe, &st->clear.frag_shader);
+
+   /* vertex shader state: color/position pass-through */
+   {
+      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
+                                      TGSI_SEMANTIC_COLOR };
+      const uint semantic_indexes[] = { 0, 0 };
+      st->clear.vs = util_make_vertex_passthrough_shader(pipe, 2,
+                                                         semantic_names,
+                                                         semantic_indexes,
+                                                         &st->clear.vert_shader);
+   }
+}
+
+
 void
 st_destroy_clear(struct st_context *st)
 {
@@ -233,47 +269,12 @@ clear_with_quad(GLcontext *ctx,
       cso_set_depth_stencil_alpha(st->cso_context, &depth_stencil);
    }
 
-   /* rasterizer state: bypass clipping */
-   {
-      struct pipe_rasterizer_state raster;
-      memset(&raster, 0, sizeof(raster));
-      raster.bypass_clipping = 1;
-      cso_set_rasterizer(st->cso_context, &raster);
-   }
+   cso_set_rasterizer(st->cso_context, &st->clear.raster);
+   cso_set_viewport(st->cso_context, &st->clear.viewport);
 
-   /* fragment shader state: color pass-through program */
-   if (!st->clear.fs) {
-      st->clear.fs = util_make_fragment_passthrough_shader(pipe, &st->clear.frag_shader);
-   }
    pipe->bind_fs_state(pipe, st->clear.fs);
-
-
-   /* vertex shader state: color/position pass-through */
-   if (!st->clear.vs) {
-      const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
-                                      TGSI_SEMANTIC_COLOR };
-      const uint semantic_indexes[] = { 0, 0 };
-      st->clear.vs = util_make_vertex_passthrough_shader(pipe, 2,
-                                                         semantic_names,
-                                                         semantic_indexes,
-                                                         &st->clear.vert_shader);
-   }
    pipe->bind_vs_state(pipe, st->clear.vs);
 
-   /* viewport state: identity since we're drawing in window coords */
-   {
-      struct pipe_viewport_state vp;
-      vp.scale[0] = 1.0;
-      vp.scale[1] = 1.0;
-      vp.scale[2] = 1.0;
-      vp.scale[3] = 1.0;
-      vp.translate[0] = 0.0;
-      vp.translate[1] = 0.0;
-      vp.translate[2] = 0.0;
-      vp.translate[3] = 0.0;
-      cso_set_viewport(st->cso_context, &vp);
-   }
-
    /* draw quad matching scissor rect (XXX verify coord round-off) */
    draw_quad(ctx, x0, y0, x1, y1, ctx->Depth.Clear, ctx->Color.ClearColor);
 
diff --git a/src/mesa/state_tracker/st_cb_clear.h b/src/mesa/state_tracker/st_cb_clear.h
index dfa4033faa..f49387747d 100644
--- a/src/mesa/state_tracker/st_cb_clear.h
+++ b/src/mesa/state_tracker/st_cb_clear.h
@@ -30,6 +30,10 @@
 #define ST_CB_CLEAR_H
 
 
+extern void
+st_init_clear(struct st_context *st);
+
+
 extern void
 st_destroy_clear(struct st_context *st);
 
diff --git a/src/mesa/state_tracker/st_context.c b/src/mesa/state_tracker/st_context.c
index a20195f2de..7511c28074 100644
--- a/src/mesa/state_tracker/st_context.c
+++ b/src/mesa/state_tracker/st_context.c
@@ -110,6 +110,7 @@ st_create_context_priv( GLcontext *ctx, struct pipe_context *pipe )
 
    st_init_atoms( st );
    st_init_bitmap(st);
+   st_init_clear(st);
    st_init_draw( st );
    st_init_generate_mipmap(st);
    st_init_blit(st);
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index 44705bc89a..bcebbd4943 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -161,6 +161,8 @@ struct st_context
    struct {
       struct pipe_shader_state vert_shader;
       struct pipe_shader_state frag_shader;
+      struct pipe_rasterizer_state raster;
+      struct pipe_viewport_state viewport;
       void *vs;
       void *fs;
       float vertices[4][2][4];  /**< vertex pos + color */
-- 
cgit v1.2.3


From d2c2e9316d043ab584794a3524f22776deb4c777 Mon Sep 17 00:00:00 2001
From: Keith Whitwell <keith@tungstengraphics.com>
Date: Fri, 12 Dec 2008 16:46:34 +0000
Subject: gallium: avoid mapping same vertex buffer in subsequent frames

Quite a few util modules were maintaining a single vertex buffer over multiple
frames, and potentially reusing it in subsequent frames.  Unfortunately that
would force us into syncrhonous rendering as the buffer manager would be
forced to wait for the previous rendering to complete prior to allowing the
map.

This resolves that issue, but requires the state tracker to issue a few new
flush() calls at the end of each frame.
---
 src/gallium/auxiliary/util/u_blit.c       | 88 ++++++++++++++++++++++---------
 src/gallium/auxiliary/util/u_blit.h       |  4 ++
 src/gallium/auxiliary/util/u_draw_quad.c  |  5 +-
 src/gallium/auxiliary/util/u_draw_quad.h  |  2 +-
 src/gallium/auxiliary/util/u_gen_mipmap.c | 51 +++++++++++++++---
 src/gallium/auxiliary/util/u_gen_mipmap.h |  5 ++
 src/mesa/state_tracker/st_cb_accum.c      |  3 +-
 src/mesa/state_tracker/st_cb_bitmap.c     | 60 +++++++++++++++------
 src/mesa/state_tracker/st_cb_bitmap.h     |  6 +++
 src/mesa/state_tracker/st_cb_clear.c      | 31 +++++++++--
 src/mesa/state_tracker/st_cb_clear.h      |  3 ++
 src/mesa/state_tracker/st_cb_drawpixels.c |  2 +-
 src/mesa/state_tracker/st_cb_fbo.c        |  2 +-
 src/mesa/state_tracker/st_cb_flush.c      | 11 +++-
 src/mesa/state_tracker/st_cb_readpixels.c |  4 +-
 src/mesa/state_tracker/st_context.h       |  2 +
 16 files changed, 219 insertions(+), 60 deletions(-)

(limited to 'src/mesa/state_tracker/st_cb_clear.h')

diff --git a/src/gallium/auxiliary/util/u_blit.c b/src/gallium/auxiliary/util/u_blit.c
index d28201ac8d..2cef3338b5 100644
--- a/src/gallium/auxiliary/util/u_blit.c
+++ b/src/gallium/auxiliary/util/u_blit.c
@@ -66,6 +66,8 @@ struct blit_state
    void *fs;
 
    struct pipe_buffer *vbuf;  /**< quad vertices */
+   unsigned vbuf_slot;
+
    float vertices[4][2][4];   /**< vertex/texcoords for quad */
 };
 
@@ -138,17 +140,7 @@ util_create_blit(struct pipe_context *pipe, struct cso_context *cso)
 
    /* fragment shader */
    ctx->fs = util_make_fragment_tex_shader(pipe, &ctx->frag_shader);
-
-   ctx->vbuf = pipe_buffer_create(pipe->screen,
-                                  32,
-                                  PIPE_BUFFER_USAGE_VERTEX,
-                                  sizeof(ctx->vertices));
-   if (!ctx->vbuf) {
-      FREE(ctx);
-      ctx->pipe->delete_fs_state(ctx->pipe, ctx->fs);
-      ctx->pipe->delete_vs_state(ctx->pipe, ctx->vs);
-      return NULL;
-   }
+   ctx->vbuf = NULL;
 
    /* init vertex data that doesn't change */
    for (i = 0; i < 4; i++) {
@@ -181,15 +173,35 @@ util_destroy_blit(struct blit_state *ctx)
 }
 
 
+static unsigned get_next_slot( struct blit_state *ctx )
+{
+   const unsigned max_slots = 4096 / sizeof ctx->vertices;
+
+   if (ctx->vbuf_slot >= max_slots) 
+      util_blit_flush( ctx );
+
+   if (!ctx->vbuf) {
+      ctx->vbuf = pipe_buffer_create(ctx->pipe->screen,
+                                     32,
+                                     PIPE_BUFFER_USAGE_VERTEX,
+                                     max_slots * sizeof ctx->vertices);
+   }
+   
+   return ctx->vbuf_slot++ * sizeof ctx->vertices;
+}
+                               
+
+
 /**
  * Setup vertex data for the textured quad we'll draw.
  * Note: y=0=top
  */
-static void
+static unsigned
 setup_vertex_data(struct blit_state *ctx,
                   float x0, float y0, float x1, float y1, float z)
 {
    void *buf;
+   unsigned offset;
 
    ctx->vertices[0][0][0] = x0;
    ctx->vertices[0][0][1] = y0;
@@ -215,12 +227,16 @@ setup_vertex_data(struct blit_state *ctx,
    ctx->vertices[3][1][0] = 0.0f;
    ctx->vertices[3][1][1] = 1.0f;
 
+   offset = get_next_slot( ctx );
+
    buf = pipe_buffer_map(ctx->pipe->screen, ctx->vbuf,
                          PIPE_BUFFER_USAGE_CPU_WRITE);
 
-   memcpy(buf, ctx->vertices, sizeof(ctx->vertices));
+   memcpy((char *)buf + offset, ctx->vertices, sizeof(ctx->vertices));
 
    pipe_buffer_unmap(ctx->pipe->screen, ctx->vbuf);
+
+   return offset;
 }
 
 
@@ -228,13 +244,14 @@ setup_vertex_data(struct blit_state *ctx,
  * Setup vertex data for the textured quad we'll draw.
  * Note: y=0=top
  */
-static void
+static unsigned
 setup_vertex_data_tex(struct blit_state *ctx,
                       float x0, float y0, float x1, float y1,
                       float s0, float t0, float s1, float t1,
                       float z)
 {
    void *buf;
+   unsigned offset;
 
    ctx->vertices[0][0][0] = x0;
    ctx->vertices[0][0][1] = y0;
@@ -260,12 +277,16 @@ setup_vertex_data_tex(struct blit_state *ctx,
    ctx->vertices[3][1][0] = s0;
    ctx->vertices[3][1][1] = t1;
 
+   offset = get_next_slot( ctx );
+
    buf = pipe_buffer_map(ctx->pipe->screen, ctx->vbuf,
                          PIPE_BUFFER_USAGE_CPU_WRITE);
 
-   memcpy(buf, ctx->vertices, sizeof(ctx->vertices));
+   memcpy((char *)buf + offset, ctx->vertices, sizeof(ctx->vertices));
 
    pipe_buffer_unmap(ctx->pipe->screen, ctx->vbuf);
+
+   return offset;
 }
 /**
  * Copy pixel block from src surface to dst surface.
@@ -291,6 +312,7 @@ util_blit_pixels(struct blit_state *ctx,
    const int srcH = abs(srcY1 - srcY0);
    const int srcLeft = MIN2(srcX0, srcX1);
    const int srcTop = MIN2(srcY0, srcY1);
+   unsigned offset;
 
    assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
           filter == PIPE_TEX_MIPFILTER_LINEAR);
@@ -398,11 +420,11 @@ util_blit_pixels(struct blit_state *ctx,
    cso_set_framebuffer(ctx->cso, &fb);
 
    /* draw quad */
-   setup_vertex_data(ctx,
-                     (float) dstX0, (float) dstY0, 
-                     (float) dstX1, (float) dstY1, z);
+   offset = setup_vertex_data(ctx,
+                              (float) dstX0, (float) dstY0, 
+                              (float) dstX1, (float) dstY1, z);
 
-   util_draw_vertex_buffer(ctx->pipe, ctx->vbuf,
+   util_draw_vertex_buffer(ctx->pipe, ctx->vbuf, offset,
                            PIPE_PRIM_TRIANGLE_FAN,
                            4,  /* verts */
                            2); /* attribs/vert */
@@ -421,6 +443,18 @@ util_blit_pixels(struct blit_state *ctx,
    screen->texture_release(screen, &tex);
 }
 
+
+/* Release vertex buffer at end of frame to avoid synchronous
+ * rendering.
+ */
+void util_blit_flush( struct blit_state *ctx )
+{
+   pipe_buffer_reference(ctx->pipe->screen, &ctx->vbuf, NULL);
+   ctx->vbuf_slot = 0;
+} 
+
+
+
 /**
  * Copy pixel block from src texture to dst surface.
  * Overlapping regions are acceptable.
@@ -442,6 +476,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
    struct pipe_screen *screen = pipe->screen;
    struct pipe_framebuffer_state fb;
    float s0, t0, s1, t1;
+   unsigned offset;
 
    assert(filter == PIPE_TEX_MIPFILTER_NEAREST ||
           filter == PIPE_TEX_MIPFILTER_LINEAR);
@@ -496,13 +531,14 @@ util_blit_pixels_tex(struct blit_state *ctx,
    cso_set_framebuffer(ctx->cso, &fb);
 
    /* draw quad */
-   setup_vertex_data_tex(ctx,
-                     (float) dstX0, (float) dstY0,
-                     (float) dstX1, (float) dstY1,
-                     s0, t0, s1, t1,
-                     z);
-
-   util_draw_vertex_buffer(ctx->pipe, ctx->vbuf,
+   offset = setup_vertex_data_tex(ctx,
+                                  (float) dstX0, (float) dstY0,
+                                  (float) dstX1, (float) dstY1,
+                                  s0, t0, s1, t1,
+                                  z);
+
+   util_draw_vertex_buffer(ctx->pipe, 
+                           ctx->vbuf, offset,
                            PIPE_PRIM_TRIANGLE_FAN,
                            4,  /* verts */
                            2); /* attribs/vert */
diff --git a/src/gallium/auxiliary/util/u_blit.h b/src/gallium/auxiliary/util/u_blit.h
index 308075698f..c35beceda8 100644
--- a/src/gallium/auxiliary/util/u_blit.h
+++ b/src/gallium/auxiliary/util/u_blit.h
@@ -70,6 +70,10 @@ util_blit_pixels_tex(struct blit_state *ctx,
                      int dstX1, int dstY1,
                      float z, uint filter);
 
+/* Call at end of frame to avoid synchronous rendering.
+ */
+extern void
+util_blit_flush( struct blit_state *ctx );
 
 #ifdef __cplusplus
 }
diff --git a/src/gallium/auxiliary/util/u_draw_quad.c b/src/gallium/auxiliary/util/u_draw_quad.c
index 8ecae71b64..d7bb74b87b 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.c
+++ b/src/gallium/auxiliary/util/u_draw_quad.c
@@ -40,6 +40,7 @@
 void 
 util_draw_vertex_buffer(struct pipe_context *pipe,
                         struct pipe_buffer *vbuf,
+                        uint offset,
                         uint prim_type,
                         uint num_verts,
                         uint num_attribs)
@@ -53,7 +54,7 @@ util_draw_vertex_buffer(struct pipe_context *pipe,
    /* tell pipe about the vertex buffer */
    vbuffer.buffer = vbuf;
    vbuffer.pitch = num_attribs * 4 * sizeof(float);  /* vertex size */
-   vbuffer.buffer_offset = 0;
+   vbuffer.buffer_offset = offset;
    pipe->set_vertex_buffers(pipe, 1, &vbuffer);
 
    /* tell pipe about the vertex attributes */
@@ -124,7 +125,7 @@ util_draw_texquad(struct pipe_context *pipe,
          v[29] = 1.0;
 
          pipe_buffer_unmap(pipe->screen, vbuf);
-         util_draw_vertex_buffer(pipe, vbuf, PIPE_PRIM_TRIANGLE_FAN, 4, 2);
+         util_draw_vertex_buffer(pipe, vbuf, 0, PIPE_PRIM_TRIANGLE_FAN, 4, 2);
       }
 
       pipe_buffer_reference(pipe->screen, &vbuf, NULL);
diff --git a/src/gallium/auxiliary/util/u_draw_quad.h b/src/gallium/auxiliary/util/u_draw_quad.h
index ec4862ead3..00d3f5b715 100644
--- a/src/gallium/auxiliary/util/u_draw_quad.h
+++ b/src/gallium/auxiliary/util/u_draw_quad.h
@@ -37,7 +37,7 @@ struct pipe_buffer;
 
 extern void 
 util_draw_vertex_buffer(struct pipe_context *pipe,
-                        struct pipe_buffer *vbuf,
+                        struct pipe_buffer *vbuf, uint offset,
                         uint num_attribs, uint num_verts, uint prim_type);
 
 
diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.c b/src/gallium/auxiliary/util/u_gen_mipmap.c
index 9d305ad763..5f395ec6e9 100644
--- a/src/gallium/auxiliary/util/u_gen_mipmap.c
+++ b/src/gallium/auxiliary/util/u_gen_mipmap.c
@@ -69,6 +69,8 @@ struct gen_mipmap_state
    void *fs;
 
    struct pipe_buffer *vbuf;  /**< quad vertices */
+   unsigned vbuf_slot;
+
    float vertices[4][2][4];   /**< vertex/texcoords for quad */
 };
 
@@ -779,10 +781,28 @@ util_create_gen_mipmap(struct pipe_context *pipe,
 }
 
 
-static void
+static unsigned get_next_slot( struct gen_mipmap_state *ctx )
+{
+   const unsigned max_slots = 4096 / sizeof ctx->vertices;
+
+   if (ctx->vbuf_slot >= max_slots) 
+      util_gen_mipmap_flush( ctx );
+
+   if (!ctx->vbuf) {
+      ctx->vbuf = pipe_buffer_create(ctx->pipe->screen,
+                                     32,
+                                     PIPE_BUFFER_USAGE_VERTEX,
+                                     max_slots * sizeof ctx->vertices);
+   }
+   
+   return ctx->vbuf_slot++ * sizeof ctx->vertices;
+}
+
+static unsigned
 set_vertex_data(struct gen_mipmap_state *ctx, float width, float height)
 {
    void *buf;
+   unsigned offset;
 
    ctx->vertices[0][0][0] = 0.0f; /*x*/
    ctx->vertices[0][0][1] = 0.0f; /*y*/
@@ -804,12 +824,16 @@ set_vertex_data(struct gen_mipmap_state *ctx, float width, float height)
    ctx->vertices[3][1][0] = 0.0f;
    ctx->vertices[3][1][1] = 1.0f;
 
+   offset = get_next_slot( ctx );
+
    buf = pipe_buffer_map(ctx->pipe->screen, ctx->vbuf,
                          PIPE_BUFFER_USAGE_CPU_WRITE);
 
-   memcpy(buf, ctx->vertices, sizeof(ctx->vertices));
+   memcpy((char *)buf + offset, ctx->vertices, sizeof(ctx->vertices));
 
    pipe_buffer_unmap(ctx->pipe->screen, ctx->vbuf);
+
+   return offset;
 }
 
 
@@ -834,6 +858,17 @@ util_destroy_gen_mipmap(struct gen_mipmap_state *ctx)
 }
 
 
+
+/* Release vertex buffer at end of frame to avoid synchronous
+ * rendering.
+ */
+void util_gen_mipmap_flush( struct gen_mipmap_state *ctx )
+{
+   pipe_buffer_reference(ctx->pipe->screen, &ctx->vbuf, NULL);
+   ctx->vbuf_slot = 0;
+} 
+
+
 /**
  * Generate mipmap images.  It's assumed all needed texture memory is
  * already allocated.
@@ -855,6 +890,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
    struct pipe_framebuffer_state fb;
    uint dstLevel;
    uint zslice = 0;
+   uint offset;
 
    /* check if we can render in the texture's format */
    if (!screen->is_format_supported(screen, pt->format, PIPE_TEXTURE_2D,
@@ -925,10 +961,13 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
       cso_set_sampler_textures(ctx->cso, 1, &pt);
 
       /* quad coords in window coords (bypassing clipping, viewport mapping) */
-      set_vertex_data(ctx,
-                      (float) pt->width[dstLevel],
-                      (float) pt->height[dstLevel]);
-      util_draw_vertex_buffer(ctx->pipe, ctx->vbuf,
+      offset = set_vertex_data(ctx,
+                               (float) pt->width[dstLevel],
+                               (float) pt->height[dstLevel]);
+
+      util_draw_vertex_buffer(ctx->pipe, 
+                              ctx->vbuf,
+                              offset,
                               PIPE_PRIM_TRIANGLE_FAN,
                               4,  /* verts */
                               2); /* attribs/vert */
diff --git a/src/gallium/auxiliary/util/u_gen_mipmap.h b/src/gallium/auxiliary/util/u_gen_mipmap.h
index 3277024f07..54608f9466 100644
--- a/src/gallium/auxiliary/util/u_gen_mipmap.h
+++ b/src/gallium/auxiliary/util/u_gen_mipmap.h
@@ -50,6 +50,11 @@ util_create_gen_mipmap(struct pipe_context *pipe, struct cso_context *cso);
 extern void
 util_destroy_gen_mipmap(struct gen_mipmap_state *ctx);
 
+/* Release vertex buffer at end of frame to avoid synchronous
+ * rendering.
+ */
+extern void 
+util_gen_mipmap_flush( struct gen_mipmap_state *ctx );
 
 
 extern void
diff --git a/src/mesa/state_tracker/st_cb_accum.c b/src/mesa/state_tracker/st_cb_accum.c
index cf3a99e7e9..a4e72b48ed 100644
--- a/src/mesa/state_tracker/st_cb_accum.c
+++ b/src/mesa/state_tracker/st_cb_accum.c
@@ -38,6 +38,7 @@
 #include "st_cb_accum.h"
 #include "st_cb_fbo.h"
 #include "st_draw.h"
+#include "st_public.h"
 #include "st_format.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
@@ -324,7 +325,7 @@ st_Accum(GLcontext *ctx, GLenum op, GLfloat value)
    const GLint height = ctx->DrawBuffer->_Ymax - ypos;
 
    /* make sure color bufs aren't cached */
-   pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+   st_flush( st, PIPE_FLUSH_RENDER_CACHE, NULL );
 
    switch (op) {
    case GL_ADD:
diff --git a/src/mesa/state_tracker/st_cb_bitmap.c b/src/mesa/state_tracker/st_cb_bitmap.c
index 73645201cc..bc05ca6a2f 100644
--- a/src/mesa/state_tracker/st_cb_bitmap.c
+++ b/src/mesa/state_tracker/st_cb_bitmap.c
@@ -349,8 +349,7 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
    return pt;
 }
 
-
-static void
+static GLuint
 setup_bitmap_vertex_data(struct st_context *st,
                          int x, int y, int width, int height,
                          float z, const float color[4])
@@ -369,12 +368,18 @@ setup_bitmap_vertex_data(struct st_context *st,
    const GLfloat clip_y0 = (GLfloat)(y0 / fb_height * 2.0 - 1.0);
    const GLfloat clip_x1 = (GLfloat)(x1 / fb_width * 2.0 - 1.0);
    const GLfloat clip_y1 = (GLfloat)(y1 / fb_height * 2.0 - 1.0);
+   const GLuint max_slots = 4096 / sizeof(st->bitmap.vertices);
    GLuint i;
-   void *buf;
+
+   if (st->bitmap.vbuf_slot >= max_slots) {
+      pipe_buffer_reference(pipe->screen, &st->bitmap.vbuf, NULL);
+      st->bitmap.vbuf_slot = 0;
+   }
 
    if (!st->bitmap.vbuf) {
-      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 32, PIPE_BUFFER_USAGE_VERTEX,
-                                           sizeof(st->bitmap.vertices));
+      st->bitmap.vbuf = pipe_buffer_create(pipe->screen, 32, 
+                                           PIPE_BUFFER_USAGE_VERTEX,
+                                           max_slots * sizeof(st->bitmap.vertices));
    }
 
    /* Positions are in clip coords since we need to do clipping in case
@@ -413,9 +418,19 @@ setup_bitmap_vertex_data(struct st_context *st,
    }
 
    /* put vertex data into vbuf */
-   buf = pipe_buffer_map(pipe->screen, st->bitmap.vbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
-   memcpy(buf, st->bitmap.vertices, sizeof(st->bitmap.vertices));
-   pipe_buffer_unmap(pipe->screen, st->bitmap.vbuf);
+   {
+      char *buf = pipe_buffer_map(pipe->screen, 
+                                  st->bitmap.vbuf, 
+                                  PIPE_BUFFER_USAGE_CPU_WRITE);
+
+      memcpy(buf + st->bitmap.vbuf_slot * sizeof st->bitmap.vertices, 
+             st->bitmap.vertices, 
+             sizeof st->bitmap.vertices);
+
+      pipe_buffer_unmap(pipe->screen, st->bitmap.vbuf);
+   }
+
+   return st->bitmap.vbuf_slot++ * sizeof st->bitmap.vertices;
 }
 
 
@@ -434,6 +449,7 @@ draw_bitmap_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
    struct cso_context *cso = ctx->st->cso_context;
    struct st_fragment_program *stfp;
    GLuint maxSize;
+   GLuint offset;
 
    stfp = combined_bitmap_fragment_program(ctx);
 
@@ -518,11 +534,11 @@ draw_bitmap_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
    }
 
    /* draw textured quad */
-   setup_bitmap_vertex_data(st, x, y, width, height,
-                            ctx->Current.RasterPos[2],
-                            color);
+   offset = setup_bitmap_vertex_data(st, x, y, width, height,
+                                     ctx->Current.RasterPos[2],
+                                     color);
 
-   util_draw_vertex_buffer(pipe, st->bitmap.vbuf,
+   util_draw_vertex_buffer(pipe, st->bitmap.vbuf, offset,
                            PIPE_PRIM_TRIANGLE_FAN,
                            4,  /* verts */
                            3); /* attribs/vert */
@@ -592,12 +608,12 @@ st_flush_bitmap_cache(struct st_context *st)
          struct pipe_screen *screen = pipe->screen;
 
          assert(cache->xmin <= cache->xmax);
-         /*
-         printf("flush size %d x %d  at %d, %d\n",
+ 
+/*         printf("flush size %d x %d  at %d, %d\n",
                 cache->xmax - cache->xmin,
                 cache->ymax - cache->ymin,
                 cache->xpos, cache->ypos);
-         */
+*/
 
          /* The texture surface has been mapped until now.
           * So unmap and release the texture surface before drawing.
@@ -623,6 +639,20 @@ st_flush_bitmap_cache(struct st_context *st)
    }
 }
 
+/* Flush bitmap cache and release vertex buffer.
+ */
+void
+st_flush_bitmap( struct st_context *st )
+{
+   st_flush_bitmap_cache(st);
+
+   /* Release vertex buffer to avoid synchronous rendering if we were
+    * to map it in the next frame.
+    */
+   pipe_buffer_reference(st->pipe->screen, &st->bitmap.vbuf, NULL);
+   st->bitmap.vbuf_slot = 0;
+}
+
 
 /**
  * Try to accumulate this glBitmap call in the bitmap cache.
diff --git a/src/mesa/state_tracker/st_cb_bitmap.h b/src/mesa/state_tracker/st_cb_bitmap.h
index aae11d34c9..81cf61981d 100644
--- a/src/mesa/state_tracker/st_cb_bitmap.h
+++ b/src/mesa/state_tracker/st_cb_bitmap.h
@@ -42,5 +42,11 @@ st_destroy_bitmap(struct st_context *st);
 extern void
 st_flush_bitmap_cache(struct st_context *st);
 
+/* Flush bitmap cache and release vertex buffer.  Needed at end of
+ * frame to avoid synchronous rendering.
+ */
+extern void
+st_flush_bitmap(struct st_context *st);
+
 
 #endif /* ST_CB_BITMAP_H */
diff --git a/src/mesa/state_tracker/st_cb_clear.c b/src/mesa/state_tracker/st_cb_clear.c
index bc3055c3fd..b6cea16163 100644
--- a/src/mesa/state_tracker/st_cb_clear.c
+++ b/src/mesa/state_tracker/st_cb_clear.c
@@ -148,12 +148,18 @@ draw_quad(GLcontext *ctx,
 {
    struct st_context *st = ctx->st;
    struct pipe_context *pipe = st->pipe;
+   const GLuint max_slots = 1024 / sizeof(st->clear.vertices);
    GLuint i;
    void *buf;
 
+   if (st->clear.vbuf_slot >= max_slots) {
+      pipe_buffer_reference(pipe->screen, &st->clear.vbuf, NULL);
+      st->clear.vbuf_slot = 0;
+   }
+
    if (!st->clear.vbuf) {
       st->clear.vbuf = pipe_buffer_create(pipe->screen, 32, PIPE_BUFFER_USAGE_VERTEX,
-                                          sizeof(st->clear.vertices));
+                                          max_slots * sizeof(st->clear.vertices));
    }
 
    /* positions */
@@ -181,14 +187,23 @@ draw_quad(GLcontext *ctx,
 
    /* put vertex data into vbuf */
    buf = pipe_buffer_map(pipe->screen, st->clear.vbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
-   memcpy(buf, st->clear.vertices, sizeof(st->clear.vertices));
+
+   memcpy((char *)buf + st->clear.vbuf_slot * sizeof(st->clear.vertices), 
+          st->clear.vertices, 
+          sizeof(st->clear.vertices));
+
    pipe_buffer_unmap(pipe->screen, st->clear.vbuf);
 
    /* draw */
-   util_draw_vertex_buffer(pipe, st->clear.vbuf,
+   util_draw_vertex_buffer(pipe, 
+                           st->clear.vbuf, 
+                           st->clear.vbuf_slot * sizeof(st->clear.vertices),
                            PIPE_PRIM_TRIANGLE_FAN,
                            4,  /* verts */
                            2); /* attribs/vert */
+
+   /* Increment slot */
+   st->clear.vbuf_slot++;
 }
 
 
@@ -508,6 +523,16 @@ clear_depth_stencil_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
 }
 
 
+void st_flush_clear( struct st_context *st )
+{
+   /* Release vertex buffer to avoid synchronous rendering if we were
+    * to map it in the next frame.
+    */
+   pipe_buffer_reference(st->pipe->screen, &st->clear.vbuf, NULL);
+   st->clear.vbuf_slot = 0;
+}
+ 
+
 
 /**
  * Called via ctx->Driver.Clear()
diff --git a/src/mesa/state_tracker/st_cb_clear.h b/src/mesa/state_tracker/st_cb_clear.h
index f49387747d..bc035ac25c 100644
--- a/src/mesa/state_tracker/st_cb_clear.h
+++ b/src/mesa/state_tracker/st_cb_clear.h
@@ -37,6 +37,9 @@ st_init_clear(struct st_context *st);
 extern void
 st_destroy_clear(struct st_context *st);
 
+extern void
+st_flush_clear(struct st_context *st);
+
 
 extern void
 st_init_clear_functions(struct dd_function_table *functions);
diff --git a/src/mesa/state_tracker/st_cb_drawpixels.c b/src/mesa/state_tracker/st_cb_drawpixels.c
index 5b24b9f068..32bf21411d 100644
--- a/src/mesa/state_tracker/st_cb_drawpixels.c
+++ b/src/mesa/state_tracker/st_cb_drawpixels.c
@@ -494,7 +494,7 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
       memcpy(map, verts, sizeof(verts));
       pipe_buffer_unmap(pipe->screen, buf);
 
-      util_draw_vertex_buffer(pipe, buf,
+      util_draw_vertex_buffer(pipe, buf, 0,
                               PIPE_PRIM_QUADS,
                               4,  /* verts */
                               3); /* attribs/vert */
diff --git a/src/mesa/state_tracker/st_cb_fbo.c b/src/mesa/state_tracker/st_cb_fbo.c
index 00076f61e0..eece7dee11 100644
--- a/src/mesa/state_tracker/st_cb_fbo.c
+++ b/src/mesa/state_tracker/st_cb_fbo.c
@@ -426,7 +426,7 @@ st_finish_render_texture(GLcontext *ctx,
    if (!strb)
       return;
 
-   ctx->st->pipe->flush(ctx->st->pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+   st_flush( ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL );
 
    if (strb->surface)
       screen->tex_surface_release( screen, &strb->surface );
diff --git a/src/mesa/state_tracker/st_cb_flush.c b/src/mesa/state_tracker/st_cb_flush.c
index cc40467941..072f2e92ad 100644
--- a/src/mesa/state_tracker/st_cb_flush.c
+++ b/src/mesa/state_tracker/st_cb_flush.c
@@ -37,11 +37,14 @@
 #include "st_context.h"
 #include "st_cb_bitmap.h"
 #include "st_cb_flush.h"
+#include "st_cb_clear.h"
 #include "st_cb_fbo.h"
 #include "st_public.h"
 #include "pipe/p_context.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_winsys.h"
+#include "util/u_gen_mipmap.h"
+#include "util/u_blit.h"
 
 
 static INLINE GLboolean
@@ -78,7 +81,13 @@ void st_flush( struct st_context *st, uint pipeFlushFlags,
 {
    FLUSH_VERTICES(st->ctx, 0);
 
-   st_flush_bitmap_cache(st);
+   /* Release any vertex buffers that might potentially be accessed in
+    * successive frames:
+    */
+   st_flush_bitmap(st);
+   st_flush_clear(st);
+   util_blit_flush(st->blit);
+   util_gen_mipmap_flush(st->gen_mipmap);
 
    st->pipe->flush( st->pipe, pipeFlushFlags, fence );
 }
diff --git a/src/mesa/state_tracker/st_cb_readpixels.c b/src/mesa/state_tracker/st_cb_readpixels.c
index c801532788..646eaff190 100644
--- a/src/mesa/state_tracker/st_cb_readpixels.c
+++ b/src/mesa/state_tracker/st_cb_readpixels.c
@@ -317,10 +317,8 @@ st_readpixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
    if (!dest)
       return;
 
-   st_flush_bitmap_cache(ctx->st);
-
    /* make sure rendering has completed */
-   pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
+   st_flush(ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL);
 
    if (format == GL_STENCIL_INDEX) {
       st_read_stencil_pixels(ctx, x, y, width, height, type, pack, dest);
diff --git a/src/mesa/state_tracker/st_context.h b/src/mesa/state_tracker/st_context.h
index 5bcb87ce20..695ac4a96f 100644
--- a/src/mesa/state_tracker/st_context.h
+++ b/src/mesa/state_tracker/st_context.h
@@ -154,6 +154,7 @@ struct st_context
       void *vs;
       float vertices[4][3][4];  /**< vertex pos + color + texcoord */
       struct pipe_buffer *vbuf;
+      unsigned vbuf_slot;       /* next free slot in vbuf */
       struct bitmap_cache *cache;
    } bitmap;
 
@@ -173,6 +174,7 @@ struct st_context
       void *fs;
       float vertices[4][2][4];  /**< vertex pos + color */
       struct pipe_buffer *vbuf;
+      unsigned vbuf_slot;
    } clear;
 
    void *passthrough_fs;  /**< simple pass-through frag shader */
-- 
cgit v1.2.3